TypeScript入门学习汇总

const hello:string ="Hello MyWorld!"
console.log(hello);

console.log("Runoob")
console.log("Google");

console.log("MyTS");console.log("Google");//不报错
console.log("MyTS") console.log("Google");//报错

/*any 变量的值会动态改变时，比如来自用户的输入，任意值类型可以让这些变量跳过编译阶段的类型检查 */
let x:any=1;
console.log(x);//输出结果 1
x="hello any";
console.log(x);//输出结果 hello any
x=false;
console.log(x);//输出结果 false

/**any 改写现有代码时，任意值允许在编译时可选择地包含或移除类型检查 */
let y: any = 4;
y.ifItExists();    // 正确，ifItExists方法在运行时可能存在，但这里并不会检查
y.toFixed();    // 正确

let prettySure:Object=4;
prettySure.toFixed();    // 错误 Property 'toFixed' does not exist on type 'Object'.

/**any 定义存储各种类型数据的数组时 */
let arrayList: any[] = [1, false, 'fine'];
arrayList[1] = 100;
console.log(arrayList); //输出结果 [ 1, 100, 'fine' ]

let decLiteral: number = 6;//十进制
console.log(decLiteral);//输出结果 6
let hexLiteral: number = 0xf00d;//十六进制
console.log(decLiteral);//输出结果 6
let binaryLiteral: number = 0b1010;//二进制
console.log(decLiteral);//输出结果 6
let octalLiteral: number = 0o744;//八进制
console.log(decLiteral);//输出结果 6

var num=new Number(20);
console.log(num);// 输出结果 [Number: 20]
var strToNum=new Number("30");
console.log(strToNum);//输出结果 [Number: 30]
var enToNum=new Number("abcs");
console.log(enToNum);//输出结果 [Number: NaN]

//prototype 属性
function employee(id:number,name:string) { 
    this.id = id; 
    this.name = name; 
} 
var emp = new employee(123,"admin"); 
employee.prototype.email = "admin@runoob.com"; 
console.log("员工号: "+emp.id);
console.log("员工姓名: "+emp.name);
console.log("员工邮箱: "+emp.email);

var num=new Number(20.1314);
console.log(`toExponential转为指数计数法:${num.toExponential()}`);// 输出结果 2.01314e+1

console.log(`toFixed不保留小数:${num.toFixed()}`);//输出结果 20
console.log(`toFixed保留2位小数:${num.toFixed(2)}`);//输出结果20.3
console.log(`toFixed保留五位小数:${num.toFixed(5)}`);//输出结果 20.13140

console.log(`toLocaleString转成字符串:${num.toLocaleString()}`);//输出结果 20.1314

console.log(`toPrecision数字格式化指定长度:${num.toPrecision()}`);// 输出结果 20.1314
console.log(`toPrecision数字格式化指定1位长度:${num.toPrecision(1)}`);//输出结果 2e+1
console.log(`toPrecision数字格式化指定2位长度:${num.toPrecision(2)}`);//输出结果 20
console.log(`toPrecision数字格式化指定3位长度:${num.toPrecision(3)}`);//输出结果 20.1

console.log(`toString转换为字符换:${num.toString()}`);// 输出结果 20.1314
console.log(`toString转换为二进制字符换:${num.toString(2)}`);// 输出结果 10100.0010000110100011011011100010111010110001110001
console.log(`toString转换为八进制字符换:${num.toString(8)}`);// 输出结果 24.1032155613530704
console.log(`toString转换为十六进制字符换:${num.toString(16)}`);// 输出结果 14.21a36e2eb1c4

console.log(`valueOf原始数字值:${num.valueOf()}`);//输出结果 20.1314

let myname: string = "TypeScript";//双引号
let mySimpleName:string='TS';//单引号
let years: number = 5;
let words: string = `您好，今年是${ myname }（简称${mySimpleName}）发布${ years + 1}周年`;//模板字符串
console.log(words);//输出结果 您好，今年是TypeScript（简称TS）发布6周年
let fullTxt:string='您好，今年是'+myname+'（简称'+mySimpleName+'）发布'+(years+1)+'周年';//拼接字符串
console.log(fullTxt);//输出结果 您好，今年是TypeScript（简称TS）发布6周年

var str = new String( "This is string" ); // 等同于 var str="This is string";
console.log(`str.constructor is:${str.constructor}`);
console.log(`字符串长度:${str.length}`);
//prototype
function employee(id:number,name:string) { 
    this.id = id;
    this.name = name; 
 } 
 var emp = new employee(123,"admin"); 
 employee.prototype.email="admin@runoob.com"; // 添加属性 email
 console.log("员工号: "+emp.id);
 console.log("员工姓名: "+emp.name);
 console.log("员工邮箱: "+emp.email);

var strTxt=new String("MyTypeScript");
var concatStr=" hello world!";
//concat 连接两个或更多字符串，并返回新的字符串
let fullTxt=strTxt.concat(concatStr);
console.log(`concat后的字符串:${fullTxt}`);//输出结果 MyTypeScript hello world!

//charAt 返回在指定位置的字符
console.log(`charAt范围0处的字符串:${strTxt.charAt(0)}`);// 输出结果 M
console.log(`charAt范围12处的字符串:${strTxt.charAt(12)}`);// 输出结果

//charCodeAt 返回在指定的位置的字符的 Unicode 编码
console.log(`charCodeAt 0处的字符串:${strTxt.charCodeAt(0)}`);// 输出结果 77
console.log(`charCodeAt 12处的字符串:${strTxt.charCodeAt(12)}`);// 输出结果 NAN

//indexOf 返回某个指定的字符串值在字符串中首次出现的位置
console.log(`indexOf:${strTxt.indexOf("y")}`);//输出结果 1
console.log(`indexOf:${strTxt.indexOf("G")}`);//输出结果 -1
//lastIndexOf 从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置
console.log(`lastIndexOf:${strTxt.lastIndexOf("y")}`);//输出结果 3
console.log(`lastIndexOf:${strTxt.lastIndexOf("G")}`);//输出结果 -1

//localeCompare 用本地特定的顺序来比较两个字符串
console.log(`localeCompare:${strTxt.localeCompare("MyTypeScript")}`);//输出结果 0
console.log(`localeCompare:${strTxt.localeCompare(concatStr)}`);//输出结果 1

//match 查找找到一个或多个正则表达式的匹配
console.log(`match:${strTxt.match(/p/g)}`);//输出结果 p,p
console.log(`match:${strTxt.match(/G/g)}`);//输出结果 null

//search 检索与正则表达式相匹配的值
console.log(`match:${strTxt.search(/p/g)}`);//输出结果 4
console.log(`match:${strTxt.search(/G/g)}`);//输出结果 -1

//replace 替换与正则表达式匹配的子串
console.log(`replace:${concatStr.replace("!","")}`);//输出结果 hello world

//split 把字符串分割为子字符串数组
var txtSplit="my,your,her,his";
console.log(txtSplit.split(","));//输出结果 [ 'my', 'your', 'her', 'his' ]
console.log(txtSplit.split(",",2));//输出结果 [ 'my', 'your' ]

//substring 提取字符串中两个指定的索引号之间的字符
console.log(`substring:${strTxt.substring(2)}`);//输出结果 TypeScript
console.log(`substring:${strTxt.substring(2,4)}`);//输出结果 Ty

//toUpperCase 字符转大写
console.log(`toUpperCase:${strTxt.toUpperCase()}`);//输出结果 MYTYPESCRIPT
//toLowerCase 字符转小写
console.log(`toLowerCase:${strTxt.toLowerCase()}`);//输出结果 mytypescript

// 在元素类型后面加上[]
let arr1: number[] = [1, 2];
//使用数组泛型
let arr: Array<number> = [1, 2];
console.log(arr);

//使用Arrary对象
//空数组
let arrNums:number[]=new Array();
console.log(arrNums);
arrNums.push(50);//数组新增元素
console.log(arrNums);
//指定长度的数组
let arrNums1:number[]=new Array(4);//长度为4的空数组
console.log(arrNums1);//输出结果 [ <4 empty items> ]
arrNums1.push(20);//数组新增元素
arrNums1.push(30);//数组新增元素
arrNums1.push(40);//数组新增元素
arrNums1.push(50);//数组新增元素
arrNums1.push(60);//数组新增元素
console.log(arrNums1);//输出结果 [ <4 empty items>, 20, 30, 40, 50, 60 ]
//直接初始化数组元素
var sites:string[] = new Array("Google","RunTS","Taobao","Facebook") 
console.log(sites);//输出结果 [ 'Google', 'RunTS', 'Taobao', 'Facebook' ]

//数组元素赋值给变量
var arr:number[] = [12,13];
var[x,y] = arr; // 将数组的两个元素赋值给变量 x 和 y  等价于 var x=arr[0];var y=arr[1];
console.log(x);// 输出结果 12
console.log(y);//输出结果 13

var multi:number[][] = [[1,2,3],[23,24,25]]; 
console.log(multi[0][0]);
console.log(multi[0][1]);
console.log(multi[0][2]);
console.log(multi[1][0]);
console.log(multi[1][1]);
console.log(multi[1][2]);

var alpha = ["a", "b", "c"]; 

// concat方法，只能同种类型的数组连接
var concatArr = ["1", "2", "3"];
let fullConcat = alpha.concat(concatArr); 
console.log("fullConcat : " + fullConcat );//输出结果 a,b,c,1,2,3

//push 向数组的末尾添加一个或更多元素，并返回新的长度
let pushArr=alpha.push("d");
console.log(`push后的新数组 : ${alpha} 新的数组长度:${pushArr}`);//输出结果 push后的新数组 : a,b,c,d 新的数组长度:4
//pop 删除数组的最后一个元素并返回删除的元素 
let popArr=alpha.pop();
console.log(`pop后的新数组 : ${alpha} 删除的元素:${popArr}` );// 输出结果 pop后的新数组 : a,b,c 删除的元素:d
//shift 删除数组的第一个元素并返回删除的第一个元素
let shiftArr=concatArr.shift();
console.log(`shift后的新数组:${concatArr};删除的第一个元素${shiftArr}`);//输出结果 shift后的新数组:2,3;删除的第一个元素1
//unshift 向数组的开头添加一个或更多元素，并返回新的长度
let unshiftArr=concatArr.unshift("1");
console.log(`unshift后的新数组:${concatArr};新的数组长度${unshiftArr}`);//输出结果 unshift后的新数组:1,2,3;新的数组长度3
//splice 从数组中添加或删除元素
let addItem=concatArr.splice(2,0,"4"); //参数 第一个表示开始位置的索引编码，第二个表示删除的字符数，第三个参数表示新增的元素
console.log(`splice添加元素后的数组:${concatArr};新增的元素${addItem}`); //输出结果 splice添加元素后的数组:1,2,4,3;新增的元素
let delItem=concatArr.splice(2,1);
console.log(`splice删除元素后的数组:${concatArr};删除的元素${delItem}`); //输出结果 splice删除元素后的数组:1,2,3;删除的元素4

//indexOf 搜索数组中的元素，并返回它所在的位置，如果搜索不到，返回值 -1，代表没有此项。
let cindex=alpha.indexOf('c');
console.log(`查找字母c的索引编号:${cindex}`);//输出结果 2
let dindex=alpha.indexOf('d');
console.log(`查找字母d的索引编号:${dindex}`);//输出结果 -1
//lastIndexOf 返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。
let cLastIndex=alpha.lastIndexOf("c");
console.log(`查找字母c的最后出现的索引编号:${cLastIndex}`);//输出结果 2

//join 把数组的所有元素放入一个字符串
let arrToStr=alpha.join();
console.log(`join后的结果:${arrToStr}`);//输出结果 a,b,c
//toString 把数组转换为字符串，并返回结果
let strArr=alpha.toString();
console.log(`toString后的结果:${strArr}`);//输出结果 a,b,c

//forEach() 数组每个元素都执行一次回调函数
alpha.forEach(item=>{ console.log(`forEach遍历 当前值：${item}`);});
//every方法 检测数值元素的每个元素是否都符合条件
var everyArrary=new Array(1,2,3,4,5,6);
let eResult=everyArrary.every((val,indexVal,arrary)=>{
    return val%2==0;
});
console.log(`every遍历检测每个元素除以2余数都为0结果:${eResult}`);//输出结果 false
//some 检测数组元素中是否有元素符合指定条件
let someResult=everyArrary.some((val,indexVal,arrary)=>{ return val%8==0;});
console.log(`some遍历检测存在8的倍数结果:${someResult}`);//输出结果 false
let someResult1=everyArrary.some((val,indexVal,arrary)=>{ return val%2==0;});
console.log(`some 遍历检测存在2的倍数结果:${someResult1}`);//输出结果 true

//filter方法，检测数值元素，并返回符合条件所有元素的数组
var filterArrary=new Array(10,20,30,40,50,60);
let rArrary=filterArrary.filter((val,indexVal,arrary)=>{return (val>=20&&val<=40)});
console.log(`filter过滤20-40之间的整数${rArrary}`);//输出结果 20,30,40
//slice 选取数组的的一部分，并返回一个新数组
var sliceArr=filterArrary.slice(1,3);// 第一个参数表示开始索引编码 第二个参数表示结束索引编码
console.log(`slice选取部分数据:${sliceArr}`);//输出结果 20,30

//sort 对数组的元素进行排序
var sortNumArr=[1,3,4,6,5,8,10,9];
var sortTxtArr=["a","d","f","c"];
console.log(`sortNum数组排序前的数据:${sortNumArr}`);//输出结果 1,3,4,6,5,8,10,9
sortNumArr.sort();
console.log(`sortNum数组排序后的数据:${sortNumArr}`);//输出结果 1,10,3,4,5,6,8,9

console.log(`sortTxt数组排序前的数据:${sortTxtArr}`);//输出结果 a,d,f,c
sortTxtArr.sort();
console.log(`sortTxt数组排序后的数据:${sortTxtArr}`);//输出结果 a,c,d,f
//reverse 反转数组的元素顺序
var reverseNumArr=[1,3,4,6,5,8,10,9];
var reverseTxtArr=["a","d","f","c"];
console.log(`reverseNum数组排序前的数据:${reverseNumArr}`);//输出结果 1,3,4,6,5,8,10,9
reverseNumArr.reverse();
console.log(`reverseNum数组排序后的数据:${reverseNumArr}`);//输出结果 9,10,8,5,6,4,3,1
reverseNumArr.reverse();
console.log(`reverseNum数组二次排序后的数据:${reverseNumArr}`);//输出结果 1,3,4,6,5,8,10,9

console.log(`reverseTxt数组排序前的数据:${reverseTxtArr}`);//输出结果 a,d,f,c
reverseTxtArr.reverse();
console.log(`reverseTxt数组排序后的数据:${reverseTxtArr}`);//输出结果 c,f,d,a

//reduce 将数组元素计算为一个值（从左到右）
var reduceArrary=[20,40,7,8];
let reduceNum=reduceArrary.reduce(function(preVal,curVal,curIndex,arrary)
{
    console.log(`reduce:preVal ${preVal},curVal ${curVal},curIndex ${curIndex}, arrary ${arrary}`);
    return preVal+curVal;
});
console.log(`reduce计算结果:${reduceNum}`);//输出结果 75
//reduceRight 将数组元素计算为一个值（从右到左）
let reduceRightNum=reduceArrary.reduceRight(function(preVal,curVal,curIndex,arrary)
{
    console.log(`reduceRight:preVal ${preVal},curVal ${curVal},curIndex ${curIndex}, arrary ${arrary}`);
    return preVal+curVal;
});
console.log(`reduceRight计算结果:${reduceNum}`);//输出结果 75

//map 通过指定函数处理数组的每个元素，并返回处理后的数组
var mapNumArrary=[1,2,3,4];
let newNumArr=new Array();
//void函数
let mapArr1=mapNumArrary.map(function(val,index,arrary){
    newNumArr.push(val);
});
console.log(newNumArr);//输出结果 [ 1, 2, 3, 4 ]
console.log(mapArr1);//输出结果 [ undefined, undefined, undefined, undefined ]
//有返回值的函数
let mapArr2=mapNumArrary.map(function(val,index,arrary){
    return val*2;
});
console.log(mapArr2);//输出结果 [ 2, 4, 6, 8 ]

let x: [string, number];
x = ['TypeScript', 1];    // 运行正常
x = [1, 'TypeScript'];    // 报错 Type 'number' is not assignable to type 'string'.  Type 'string' is not assignable to type 'number'.
console.log(x[0]);    // 输出 TypeScript

var mytuple = [10,"Hello","World","typeScript"]; 
mytuple.push(12);// 添加到元组中
console.log(`添加后元组数据：${mytuple}`);//10,Hello,World,typeScript,12
mytuple.pop();//删除元组最后一个元素      
console.log(`删除后元组数据：${mytuple}`);//10,Hello,World,typeScript

var mytuple = [10, "RunTs", "Taobao", "Google"]; // 创建一个元组
console.log("元组的第一个元素为：" + mytuple[0]);
// 更新元组元素
mytuple[0] = 121;   
console.log("元组中的第一个元素更新为："+ mytuple[0]);

var a =[10,"RunTs"];
var [b,c] = a; 
console.log(b);//输出结果 10
console.log(c);//输出结果 RunTs

//默认0元素开始编号
enum Color {Red, Green, Blue};
let c: Color = Color.Green;
let colorName: string = Color[2];//获取枚举值名称
console.log(colorName);//输出结果 Blue
//从1开始编号
enum Color1 {Red = 1, Green, Blue};
let c1: Color1 = Color1.Green;
let colorName1: string = Color1[2];
console.log(colorName1);//输出结果 Green
//全部手动赋值
enum Color2 {Red = 2, Green = 3, Blue = 4};
let c2: Color2 = Color2.Green;
let colorName2: string = Color2[2];
console.log(colorName2);//输出结果 Red

let colorName3: string =Color2[Color2.Red];
console.log(colorName3);//输出结果 Red

// 启用 --strictNullChecks
let x: number;
x = 1; // 正确
x = undefined;    // 错误 Type 'undefined' is not assignable to type 'number'.
x = null;    // 错误 Type 'null' is not assignable to type 'number'.

// 启用 --strictNullChecks
let y: number | null | undefined;
y= 1; // 正确
y = undefined; // 正确
y = null;    // 正确

let x: never;
let y: number;
// 错误，Type 'number' is not assignable to type 'never'.
x = 123;

// 运行正确，never 类型可以赋值给 never类型
x = (()=>{ throw new Error('exception')})();

// 运行正确，never 类型可以赋值给 数字类型
y = (()=>{ throw new Error('exception')})();

// 返回值为 never 的函数可以是抛出异常的情况
function error(message: string): never {
    throw new Error(message);
}

// 返回值为 never 的函数可以是无法被执行到的终止点的情况
function loop(): never {
    while (true) {}
}

let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
console.log(strLength);//输出结果16

let someValue: any = "this is a string";
let strLength: number = (someValue as string ).length;
console.log(strLength);//输出结果16

var val:string|number;
val = 12;
console.log("数字为 "+ val);
val = "RunTs";
console.log("字符串为 " + val);
//赋值其他类型的数据就会报错
val=true;//编译报错 Type 'boolean' is not assignable to type 'string | number'.

//联合类型作为函数参数使用
function f(personName:string|string[]){
    console.log(`人员姓名 ${personName}`);
}
f("TypeScript");
f(["TS","JS"]);

//数组声明为联合类型
var arr:string[]|number[];
arr=["TS","JS"];
console.log(arr);
arr=[1,2,3,4,5];
console.log(arr);

//声明变量的类型及初始值
var myName:string="TypeScript";
console.log(myName);
//声明变量的类型，但没有初始值，变量值会设置为 undefined 
var myAge:number;
console.log(myAge);//编译报错 Variable 'myAge' is used before being assigned.
//声明变量并初始值，但不设置类型，该变量可以是任意类型
var myHight=165;
console.log(typeof(myHight));//输出结果 number
//声明变量没有设置类型和初始值，类型可以是任意类型，默认初始值为 undefined
var myWeight;
console.log(myWeight);// 输出结果 undefined

var global_num = 12; //全局变量
//Nmbers 类
class Numbers { 
   num_val = 13; // 实例变量
   static sval = 10;// 静态变量   
   storeNum():void { 
      var local_num = 14;    // 局部变量
      console.log(local_num);
   } 
} 
console.log("全局变量为: "+global_num);// 输出结果 全局变量为: 12
console.log(Numbers.sval);// Numbers 静态变量  输出结果 10
var obj = new Numbers(); 
console.log("Numbers实例变量: "+obj.num_val);//输出结果 Numbers实例变量: 13
obj.storeNum();//输出结果 14

for (var i = 0; i < 10; i++) {
    setTimeout(function() { console.log(i); }, 100 * i);
}

for (var i = 0; i < 10; i++) {
    // capture the current state of 'i'
    // by invoking a function with its current value
    (function(i) {
        setTimeout(function() { console.log(i); }, 100 * i);
    })(i);
}

//代码块内有效
{
    let a = 0;
    var b = 1;
}
console.log(a); // 编译报错 Cannot find name 'a'.
console.log(b);  // 1

//不允许重复声明
let c = 1; //编译报错 Cannot redeclare block-scoped variable 'c'.
let c = 2;//编译报错 Cannot redeclare block-scoped variable 'c'.
var d = 3;
var d = 4;
console.log(c);
console.log(d); //输出结果 4

//拥有块级作用域的变量的另一个特点是，它们不能在被声明之前读或写。 虽然这些变量始终“存在”于它们的作用域里，但在直到声明它的代码之前的区域都属于 时间死区。 它只是用来说明我们不能在 let语句之前访问它们
console.log(e);  //编译报错 Variable 'e' is used before being assigned.
let e = "apple";

{
    var myName="TypeScript";
    const myAge=30;
    //不可修改值
    myAge=40; //编译报错 Cannot assign to 'myAge' because it is a constant.
    //声明必须赋初始值
    const cityName; //编译报错 'const' declarations must be initialized.
}
console.log(myName);
console.log(myAge);// 编译报错 Cannot find name 'myAge'. 

let myName:string="TypeScript";
let isTS=myName=="TypeScript"?true:false; //等价于 if(myName==""){isTS=true;} else { isTS=true;}

let myName:string="TypeScript";
console.log(typeof(myName));//输出结果 string
let myage=30;
console.log(typeof(myage));//输出结果 number

switch(expression){
    case constant-expression  :
       statement(s);
       break; /* 可选的 */
    case constant-expression  :
       statement(s);
       break; /* 可选的 */
  
    /* 您可以有任意数量的 case 语句 */
    default : /* 可选的 */
       statement(s);
}

for ( init; condition; increment ){
    statement(s);
}

let count:number=10;
for(let i=0;i<count;i++){
    console.log(i);
}

for (var val in list) { 
    //语句 
}

let arraryInput=[1,2,3,4,5];
for(let j in arraryInput){
    console.log(j);
}

let someArray = [1, "string", false];
//for...of循环
for (let entry of someArray) {
    console.log(entry); // 1, "string", false
}
//forEach循环
someArray.forEach((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引 index${indexVal}`);
    console.log(`当前array ${array}`);
});
//every循环 有返回值
//默认只遍历循环第一个元素，返回值为false
let returnEvery=someArray.every((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引index ${indexVal}`);
    console.log(`当前array ${array}`);    
});
console.log(returnEvery);//false
//会循环遍历所有元素，返回值为true
returnEvery=someArray.every((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引index ${indexVal}`);
    console.log(`当前array ${array}`);  
    return true;//continue  
});
console.log(returnEvery);//true
//只会循环遍历第一个元素，返回值为false
returnEvery=someArray.every((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引index ${indexVal}`);
    console.log(`当前array ${array}`);  
    return false;//quit  
});
console.log(returnEvery);//false
//会循环遍历所有元素，返回值为true
returnEvery=someArray.every((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引index ${indexVal}`);
    console.log(`当前array ${array}`);  
    return "ok";//quit  
});
console.log(returnEvery);//true

//some循环
//默认遍历所有元素 返回值 false
let someReturn=someArray.some((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引index ${indexVal}`);
    console.log(`当前array ${array}`);   
});
console.log(someReturn);//false
//只会遍历第一个元素 返回值 true
someReturn=someArray.some((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引index ${indexVal}`);
    console.log(`当前array ${array}`);   
    return true;
});
console.log(someReturn);//true
//会遍历所有元素 返回值false
someReturn=someArray.some((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引index ${indexVal}`);
    console.log(`当前array ${array}`);   
    return false;
});
console.log(someReturn);//false
//只会遍历第一个元素 返回值true
someReturn=someArray.some((val, indexVal, array) => {
    console.log(`当前值 ${val}`);
    console.log(`当前索引index ${indexVal}`);
    console.log(`当前array ${array}`);   
    return 'ok';
});
console.log(someReturn);//true

while(condition)
{
   statement(s);
}

var num:number = 5; 
var factorial:number = 1;  
while(num >=1) { 
    factorial = factorial * num; 
    num--; 
} 
console.log("5 的阶乘为："+factorial);

do
{
   statement(s);
}while( condition );

var n:number = 10;
do { 
    console.log(n); 
    n--; 
} while(n>=0);

var i:number = 1;
while(i<=10) { 
    if (i % 5 == 0) {   
        console.log ("在 1~10 之间第一个被 5 整除的数为 : "+i);
        break;     // 找到一个后退出循环
    } 
    i++;
}  // 输出 5 然后程序执行结束
//循环内嵌套循环
let testArrary=[1,2,3,4,5];
let testArrary2=[3,4,5,6,10];
for(let i of testArrary)
{
   for(let j of testArrary2)
   {
      if((i*2)==j)
      {
        console.log(`i：${i} j：${j}`);
        break;
      }
   }
}

var num:number = 0;
var count:number = 0;
for(num=0;num<=20;num++) {
    if (num % 2==0) {
        continue;
    }
    count++;
}
console.log ("0 ~20 之间的奇数个数为: "+count)    //输出10个偶数

for(;;) { 
   // 语句
}

for(;;) { 
   console.log("这段代码会不停的执行") 
}

while(true) { 
   // 语句
} 

while(true) { 
   console.log("这段代码会不停的执行") 
}

var houseData=
{
    door:"white door",
    windows:"",
    bedNum:5,
    TVBrand:"XiaoMi",
    bedRoomNum:5,
    cars:["Red Car","Green Car","Black Car"],
    keyOfRoomNum:function(){},//函数模型
    houseDesc:function(){ return "MyHouse";}
};
console.log(houseData.door);//输出结果 white door
houseData.keyOfRoomNum=function(){
    console.log("房间钥匙总共15把");
};
houseData.keyOfRoomNum();// 输出结果 房间钥匙总共15把
console.log(houseData.houseDesc());// 输出结果 MyHouse
console.log(houseData.cars);//输出结果 [ 'Red Car', 'Green Car', 'Black Car' ]

interface IPoint{
    xPoint:number,
    yPoint:number
} 
function addPoints(p1:IPoint,p2:IPoint):IPoint { 
    let xPointSum = p1.xPoint + p2.xPoint; 
    let yPointSum = p1.yPoint + p2.yPoint; 
    return {xPoint:xPointSum,yPoint:yPointSum};
} 
var newPoint = addPoints({xPoint:3,yPoint:4},{xPoint:5,yPoint:1});
console.log(newPoint);//输出结果 { xPoint: 8, yPoint: 5 }
//错误 Argument of type '{ xPoint: number; }' is not assignable to parameter of type 'IPoint'. Property 'yPoint' is missing in type '{ xPoint: number; }' but required in type 'IPoint'.
var newPoint2 = addPoints({xPoint:1},{xPoint:4,yPoint:3});

let namesMap=new Map();
//设置map
namesMap.set("1","TypeScript");
namesMap.set("2","JavaScript");
namesMap.set("3","ES6");

//数量
console.log(namesMap.size);// 输出结果 3

//循环遍历 Map中的key
for (let key of namesMap.keys()) {
    console.log(key);                  
} 
//循环遍历 Map中的value
for (let value of namesMap.values()) {
    console.log(value);                 
}
//循环遍历 Map中的key => value
for (let entry of namesMap.entries()) {
    console.log(entry[0], entry[1]);   
}
//循环遍历——使用对象解析
for (let [key, value] of namesMap) {
    console.log(key, value);            
}

//获取键值对应的value值
console.log(namesMap.get("1"));//输出结果 TypeScript
//判断是否包含key
console.log(namesMap.has("1"));// 输出结果 true
console.log(namesMap.has("7"));// 输出结果 false
//删除键值对
console.log(namesMap.delete("3"));// 输出结果 true 
console.log(namesMap);// 输出结果 Map(2) { '1' => 'TypeScript', '2' => 'JavaScript' }
console.log(namesMap.delete("7"));// 输出结果 false
//清除
namesMap.clear();
console.log(namesMap.size);// 输出结果 0

function MyTs(){
    console.log("欢迎来到TypeScript的世界");
}
MyTs();

function function_name():return_type {
    // 语句
    return value;    
}

function MyTWithVal():string{
    return "欢迎来到TypeScript的世界";
}
console.log(MyTWithVal());

function fWithPara(studentName:string,age:number){
    console.log(`姓名为 ${studentName}的学生，年龄是${age}岁`);
}
fWithPara("王明",18);

function fSelPara(companyName:string,simpleName?:string){
    if(simpleName){
        console.log(`公司名称为 ${companyName}的简称是${simpleName}`);
    }
    else {
        console.log(`公司名称为 ${companyName}`);
    }    
}
fSelPara("阿里巴巴","淘宝");//输出结果 公司名称为 阿里巴巴的简称是淘宝
fSelPara("阿里巴巴");//输出结果 公司名称为 阿里巴巴

function function_name(param1[:type],param2[:type] = default_value) { 
}

function fDefault(studentName:string,age:number=0){
    console.log(`姓名为 ${studentName}的学生，年龄是${age}岁`);
}
fDefault("王明",18);//输出结果 姓名为 王明的学生，年龄是18岁
fDefault("王明");//输出结果 姓名为 王明的学生，年龄是0岁

function fRePara(mainGroupName:string,...otherGroupName:string[]){
    if(otherGroupName.length>0){
        console.log(`主队为 ${mainGroupName}，其他队${otherGroupName}`);
    }
    else{
        console.log(`主队为 ${mainGroupName}`);
    }
}
fRePara("第一梯队","第二梯队","第三梯队");//输出结果 主队为 第一梯队，其他队第二梯队,第三梯队
fRePara("第一梯队");//输出结果 主队为 第一梯队

var res = function( [arguments] ) { ... }

//匿名函数
var showTime=function(){
    var curDate=new Date();
    console.log(`当前日期：${curDate.getFullYear()}年${curDate.getMonth()+1}月${curDate.getDate()}日`);
}
showTime();
//匿名函数自调用
(function(){
    console.log("hello world");
}())

var res = new Function ([arg1[, arg2[, ...argN]],] functionBody)

var myFunction = new Function("a", "b", "return a * b"); 
var x = myFunction(4, 3); 
console.log(x);//输出结果 12

( [param1, param2,…param n] )=>statement;

//带参箭头函数
var func=(x:number,y:number)=>{
    let sum=x+y;
    console.log(sum);
}
func(20,30);
//单个带参箭头函数
//标准写法
var funcSS=(x:number)=>{
    console.log(x);
}
funcSS(10);
//可以省略()
var funcS=x=>{
    console.log(x);
}
funcS(50);
//无参数箭头函数
var testLambda=()=>{
    console.log("这是没有参数的箭头函数");
}
testLambda();

function disp(s1:string):void; 
function disp(n1:number,s1:string):void; 
 
function disp(x:any,y?:any):void { 
    console.log(x); 
    console.log(y); 
} 
disp("abc");//输出结果 abc undefined
disp(1,"xyz");//输出结果 1 xyz

//标准接口
interface IPerson{
    PersonName:string,
    Height:number,
    weight:number,
    Gender:string
}
//定义一个类型为IPerson的变量，变量中的字段必须和接口中的一致（字段名称和字段数量及字段类型），否则会编译报错
let commonPerson:IPerson=
{
    PersonName:"接口类型的变量",
    Height:167,
    weight:116,
    Gender:"女",
}
console.log(commonPerson.PersonName);
commonPerson.PersonName="接口类型的变量测试";
console.log(commonPerson.PersonName);

//定义一个类，继承IPerson,类中必须包含IPerson中所有的字段，否则编译报错；类中的字段可以比接口中的字段多
class PersonInfo implements IPerson
{
    PersonName: string;
    Height: number;
    weight: number;
    Gender: string;
    TelNum:string;
    DetailAddress:string;
}
let personTest=new PersonInfo();
personTest.PersonName="类继承接口";
personTest.TelNum="13775175856";
console.log(personTest.PersonName);

//带有函数的接口定义
interface IFunc
{
    /**新增用户 
     *userName：用户姓名
    */
    AddUser(userName:string):void,
    GetUserName(userId:number):string,
    DeleteUser(userId:number):boolean,
    GetUserList():void
}
//定义一个类，继承IFunc接口
class MyFunc implements IFunc
{
    AddUser(userName:string):void 
    {
        console.log("新增用户："+userName);
    }
    GetUserName(userId: number): string 
    {
        console.log("获取用户姓名："+userId);
        return "获取用户名称";
    }
    DeleteUser(userId: number): boolean
    {
        console.log("删除用户："+userId);
        return true;
    }
    GetUserList(): void 
    {
        console.log("获取用户列表");
    }
    /**获取用户分页列表
     * pageIndex:页码
     * pageSize:每页数量
     */
    GetUserPage(pageIndex:number,pageSize:number):void {
        
    }
}

let myfunc=new MyFunc();
myfunc.AddUser("张三");
let delResult=myfunc.DeleteUser(1);
console.log(delResult);

interface IPerson{
    PersonName:string,
    Height:number,
    weight:number,
    Gender:string
}
//单个接口继承
interface IPersonDetail extends IPerson
{
    Address:string,
    TelNum:string,
    Email:string
}
//多个接口继承
interface IUser extends IPerson,IPersonDetail
{
    UserName:string
}

//定义类
class PersonDetail
{
    Address:string;
    TelNum:string;
    Email:string;
    private personCompany:string="";
    protected companyName:string="";
}
//接口继承类
interface IPerson extends PersonDetail
{
    PersonName:string,
    Height:number,
    weight:number,
    Gender:string
}
//定义类，继承 IPerson 
// 对于 PersonDetail类中的private及protected成员 编译报错 Type 'PersonInfo' is missing the following properties from type 'IPerson': personCompany, companyName
class PersonInfo implements IPerson
{
    PersonName:string;
    Height:number;
    weight:number;
    Gender:string;
    Address:string;
    TelNum:string;
    Email:string;
}
//类继承类 再继承接口 ，必须包含接口中的字段，否则编译报错
class Control extends PersonDetail implements IPerson
{
    private state: any;
    PersonName:string;
    Height:number;
    weight:number;
    Gender:string
}

interface ICounter {
    (start: number): string;
    interval: number;
    reset(): void;
}

function getCounter(): ICounter {
    let counter = <ICounter>function (start: number) { };
    counter.interval = 123;
    counter.reset = function () { };
    return counter;
}

let c = getCounter();
c(10);
c.reset();
c.interval = 5.0;

//只有字段的类
class ClassInfo{
    classNo:string;//班级名称字段
    studentNum:number;//学生数字段
 }
 var classInfo=new ClassInfo();
 classInfo.classNo="高三一班";
 classInfo.studentNum=50;
 console.log(`${classInfo.classNo}共有学生${classInfo.studentNum}名`);
// 字段、构造函数、方法同事包含的类
class Car { 
    // 字段
    engine:string;  
    // 构造函数
    constructor(engine:string) { 
       this.engine = engine; 
    }    
    // 方法
    disp():void { 
       console.log("函数中显示发动机型号:"+this.engine) 
    } 
 }  
 // 创建一个对象
 var obj = new Car("XXSY1");
 // 访问字段
 console.log("读取发动机型号 :  "+obj.engine); 
 // 访问方法
 obj.disp();

//类的继承
class AreaInfo{
    Area:number;//面积
    Unit:string;//面积单位
}

class Circle extends AreaInfo{
    Diam:number;//直径
}

var mycircle=new Circle();
mycircle.Diam=10;
mycircle.Area=500;
mycircle.Unit="平方米";
console.log(mycircle);

//重写继承类的方法
class PrinterClass { 
    doPrint():void {
       console.log("父类的 doPrint() 方法。") 
    } 
 } 
 class StringPrinter extends PrinterClass { 
    doPrint():void { 
       super.doPrint(); // 调用父类的函数
       console.log("子类的 doPrint()方法。")
    } 
 }

class ClassInfo{
    static classNo:string;
    static showInfo(){
        console.log("我是班级"+this.classNo+"中的一员");
    }
}

ClassInfo.classNo="高三一班";
ClassInfo.showInfo();

class Person{ } 
var obj = new Person() 
var isPerson = obj instanceof Person; 
console.log("obj 对象是 Person 类实例化来的吗？ " + isPerson);

class Person{ 
    public PersonName:string;//人员姓名
    protected LinkTel:string;//联系电话
    private MoneyNum:number;
} 
var perInfo=new Person();
perInfo.PersonName="马云";
perInfo.LinkTel="";//编译报错 Property 'LinkTel' is protected and only accessible within class 'Person' and its subclasses.
perInfo.MoneyNum=50000000000;//编译报错 Property 'MoneyNum' is private and only accessible within class 'Person'.

class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8;
    constructor (theName: string) {
        this.name = theName;
    }
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // Cannot assign to 'name' because it is a read-only propert

let passcode = "secret passcode";
class Employee {
    private _fullName: string;
    get fullName(): string {
        return this._fullName;
    }
    set fullName(newName: string) {
        if (passcode && passcode == "secret passcode") {
            this._fullName = newName;
        }
        else {
            console.log("Error: Unauthorized update of employee!");
        }
    }
}
let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
    console.log(employee.fullName);
}

abstract class Department {
    constructor(public name: string) {
    }
    printName(): void {
        console.log('Department name: ' + this.name);
    }
    abstract printMeeting(): void; // 必须在派生类中实现
}
class AccountingDepartment extends Department {
    constructor() {
        super('Accounting and Auditing'); // constructors in derived classes must call super()
    }
    printMeeting(): void {
        console.log('The Accounting Department meets each Monday at 10am.');
    }
    generateReports(): void {
        console.log('Generating accounting reports...');
    }
}
let department: Department; // ok to create a reference to an abstract type
department = new Department(); // error: cannot create an instance of an abstract class
department = new AccountingDepartment(); // ok to create and assign a non-abstract subclass
department.printName();
department.printMeeting();
department.generateReports(); // error: Property 'generateReports' does not exist on type 'Department'.

interface ILoan { 
    interest:number; 
 } 
  
 class AgriLoan implements ILoan { 
    interest:number;
    rebate:number;  
    constructor(interest:number,rebate:number) { 
       this.interest = interest; 
       this.rebate = rebate;
    } 
 } 
  
 var obj = new AgriLoan(10,1); 
 console.log("利润为 : "+obj.interest+"，抽成为 : "+obj.rebate);

export interface StringValidator
{
    IsAcceptable(s: string): boolean;
}

class UserRepository
{
    GetUserName(userId:number):string
    {
        return "查询用户："+userId;
    }
}

export {UserRepository};//导出语句
export{ UserRepository as UserRep};//导出语句并重命名

export interface StringValidator
{
    IsAcceptable(s: string): boolean;
}

import { StringValidator } from './Validation';
const numberRegexp = /^[0-9]+$/;//数字验证正则表达式
/**邮政编码验证 */
export class ZipCodeValidator implements StringValidator {
    IsAcceptable(s: string) {
        return s.length === 5 && numberRegexp.test(s);
    }
}

export class ParseIntBasedZipCodeValidator 
{
    isAcceptable(s: string) 
    {
        return s.length === 5 && parseInt(s).toString() === s;
    }
}
// 导出原先的验证器但做了重命名
export {ZipCodeValidator as RegExpBasedZipCodeValidator} from "./ZipCodeValidator";

export * from "./StringValidator"; // exports interface StringValidator
export * from "./ZipCodeValidator";  // exports class ZipCodeValidator

declare let $: JQuery;
export default $;

import $ from "JQuery";
$("button.continue").html( "Next Step..." );

import { ZipCodeValidator } from "./ZipCodeValidator";
let myValidator = new ZipCodeValidator();

import { ZipCodeValidator as ZCV} from "./ZipCodeValidator";
let letValid=new ZCV();

import * as validator from "./ZipCodeValidator";
let myZipCodeValid = new validator.ZipCodeValidator();

import "./my-module.js";

let numberRegexp = /^[0-9]+$/;
class ZipCodeValidator {
    isAcceptable(s: string) {
        return s.length === 5 && numberRegexp.test(s);
    }
}
export = ZipCodeValidator;

import zip = require("./ZipCodeValidator");
// Some samples to try
let strings = ["Hello", "98052", "101"];
// Validators to use
let validator = new zip();
// Show whether each string passed each validator
strings.forEach(s => {
  console.log(`"${ s }" - ${ validator.isAcceptable(s) ? "matches" : "does not match" }`);
});

/**验证器 */
namespace Validation
{
    const lettersRegexp = /^[A-Za-z]+$/;//字母验证表达式
    const numberRegexp = /^[0-9]+$/;//数字验证正则表达式

    export interface StringValidator
    {
        IsAcceptable(s: string): boolean;
    }
    /**字母验证 */
    export class LettersOnlyValidator implements StringValidator
    {
        IsAcceptable(s: string)
        {
            return lettersRegexp.test(s);
        }
    }
    /**邮政编码验证 */
    export class ZipCodeValidator implements StringValidator
    {
        IsAcceptable(s: string) 
        {
            return s.length === 5 && numberRegexp.test(s);
        }
    }

}

let strings = ["Hello", "98052", "101"];
// Validators to use
let validators: { [s: string]: Validation.StringValidator; } = {};
validators["ZIP code"] = new Validation.ZipCodeValidator();
validators["Letters only"] = new Validation.LettersOnlyValidator();
// Show whether each string passed each validator
strings.forEach(s => {
    for (let name in validators) 
    {
        console.log(`"${ s }" - ${ validators[name].IsAcceptable(s) ? "matches" : "does not match" } ${ name }`);
    }
});

namespace Validation
{
    export interface StringValidator
    {
        IsAcceptable(s: string): boolean;
    }
}

/// <reference path="Validation.ts" />

namespace Validation
{
    const lettersRegexp = /^[A-Za-z]+$/;//字母验证表达式
    /**字母验证 */
    export class LettersOnlyValidator implements StringValidator
    {
        IsAcceptable(s: string)
        {
            return lettersRegexp.test(s);
        }
    }
}

/// <reference path="Validation.ts" />

namespace Validation
{
    const numberRegexp = /^[0-9]+$/;//数字验证正则表达式
    /**邮政编码验证 */
    export class ZipCodeValidator implements StringValidator
    {
        IsAcceptable(s: string) 
        {
            return s.length === 5 && numberRegexp.test(s);
        }
    }
}

/// <reference path="Validation.ts" />
/// <reference path="LettersValidator.ts" />
/// <reference path="ZipCodeValidator.ts" />

let strings = ["Hello", "98052", "101"];
// Validators to use
let validators: { [s: string]: Validation.StringValidator; } = {};
validators["ZIP code"] = new Validation.ZipCodeValidator();
validators["Letters only"] = new Validation.LettersOnlyValidator();
// Show whether each string passed each validator
strings.forEach(s => {
    for (let name in validators) 
    {
        console.log(`"${ s }" - ${ validators[name].IsAcceptable(s) ? "matches" : "does not match" } ${ name }`);
    }
});

namespace Shapes {
//嵌套的命名空间
    export namespace Polygons {
        export class Triangle { }
        export class Square { }
    }
}

import polygons = Shapes.Polygons;
let sq = new polygons.Square(); // Same as "new Shapes.Polygons.Square()"

declare namespace D3 {
    export interface Selectors {
        select: {
            (selector: string): Selection;
            (element: EventTarget): Selection;
        };
    }

    export interface Event {
        x: number;
        y: number;
    }

    export interface Base extends Selectors {
        event: Event;
    }
}

declare let d3: D3.Base;

// In a .d.ts file or .ts file that is not a module:
declare module "SomeModule" {
    export function fn(): string;
}

/// <reference path="myModules.d.ts" />
import * as m from "SomeModule";

export namespace Shapes {
    export class Triangle { /* ... */ }
    export class Square { /* ... */ }
}

import * as shapes from "./shapes";
let t = new shapes.Shapes.Triangle(); // shapes.Shapes?

export class Triangle { /* ... */ }
export class Square { /* ... */ }

import * as shapes from "./shapes";
let t = new shapes.Triangle();

$(() => { console.log('hello!'); } );

<script src="http://a.great.cdn.for/someLib.js" rel="external nofollow" ></script>

function createGreeting(s) {
    return "Hello, " + s;
}

window.createGreeting = function(s) {
    return "Hello, " + s;
}

var fs = require("fs");

import fs = require("fs");

var someLib = require('someLib');

define(..., ['someLib'], function(someLib) {

});

import moment = require("moment");
console.log(moment.format());

console.log(moment.format());

(function (root, factory) {
    if (typeof define === "function" && define.amd) {
        define(["libName"], factory);
    } else if (typeof module === "object" && module.exports) {
        module.exports = factory(require("libName"));
    } else {
        root.returnExports = factory(root.libName);
    }
}(this, function (b) {

// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
// Project: [~THE PROJECT NAME~]
// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>

/*~ This is the module plugin template file. You should rename it to index.d.ts
 *~ and place it in a folder with the same name as the module.
 *~ For example, if you were writing a file for "super-greeter", this
 *~ file should be 'super-greeter/index.d.ts'
 */

/*~ On this line, import the module which this module adds to */
import * as m from 'someModule';

/*~ You can also import other modules if needed */
import * as other from 'anotherModule';

/*~ Here, declare the same module as the one you imported above */
declare module 'someModule' {
    /*~ Inside, add new function, classes, or variables. You can use
     *~ unexported types from the original module if needed. */
    export function theNewMethod(x: m.foo): other.bar;

    /*~ You can also add new properties to existing interfaces from
     *~ the original module by writing interface augmentations */
    export interface SomeModuleOptions {
        someModuleSetting?: string;
    }

    /*~ New types can also be declared and will appear as if they
     *~ are in the original module */
    export interface MyModulePluginOptions {
        size: number;
    }
}

var x = "hello, world";
// Creates new methods on built-in types
console.log(x.startsWithHello());

var y = [1, 2, 3];
// Creates new methods on built-in types
console.log(y.reverseAndSort());

// 'require' call that doesn't use its return value
var unused = require("magic-string-time");
/* or */
require("magic-string-time");

var x = "hello, world";
// Creates new methods on built-in types
console.log(x.startsWithHello());

var y = [1, 2, 3];
// Creates new methods on built-in types
console.log(y.reverseAndSort());

/// <reference types="someLib" />

function getThing(): someLib.thing;

import * as moment from "moment";

function getThing(): moment;

/// <reference types="moment" />

function getThing(): moment;

import * as someLib from 'someLib';

declare namespace cats {
    interface KittySettings { }
}

// at top-level
interface CatsKittySettings { }

import exp = require("express");
var app = exp();