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+1console.log(`toFixed不保留小数:${num.toFixed()}`);//输出结果 20
console.log(`toFixed保留2位小数:${num.toFixed(2)}`);//输出结果20.3
console.log(`toFixed保留五位小数:${num.toFixed(5)}`);//输出结果 20.13140console.log(`toLocaleString转成字符串:${num.toLocaleString()}`);//输出结果 20.1314console.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.1console.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.21a36e2eb1c4console.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"; // 添加属性 emailconsole.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,9console.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,9console.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);//输出结果 Redlet 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();