TypeScript笔记 javascript

 

// 循环

// for...in 一组值的集合或列表进行迭代输出

var j;

var n = "a b c";

for (j in n) {

console.log(n[j],j);//a,0 1 b,2 ....

}

// for...of 允许你遍历 Arrays（数组）, Strings（字符串）, Maps（映射）, Sets（集合）等可迭代的数据结构等

let someArray = [1, "string", false];

for (let entry of someArray) {

console.log(entry); // 1, "string", false

}

//因为 forEach 在 iteration 中是无法返回的，所以可以使用 every 和 some 来取代 forEach

let list = [4,5,6];

// list.forEach((val, idx, array) => {

// // val: 当前值

// // idx：当前index

// // array: Array

// console.log(val,idx,array);

// });

// var arr = [1,2,3,4,5];

// var num = 3;

// arr.every(function(v){

// if(v == num) {

// return false;

// }else{debugger

// console.log(v);

// return true;

// }

// });

// for(var i=0;i<arr.length;i++){

// if(i==2){continue;}

// console.log(arr[i])

// }

list.every((val, idx, array) =>{//迭代时每一次都得有返回，返回ture是继续，返回false是结束。无返回，则只循环首个

console.log('eT',val);//4

return true;//continues 4 5 6

})

list.some((val, idx, array) =>{//返回true,结束

if(val==5){

return true;//break

}

console.log('sT',val);//4

})

list.some((val, idx, array) =>{//返回false,跳出本次循环，继续

if(val==5){

return false;//continues

}

console.log('sF',val);//4 6

})

list.some((val, idx, array) =>{//无返回，循环全部

console.log('sAll',val);//4 5 6

})

// 函数参数

//在 TypeScript 函数里，如果我们定义了参数，则我们必须传入这些参数,除非将这些参数设置为可选，可选参数使用问号标识 ？

// function buildName(firstName: string="gates", lastName?: string) {}//传参时， firstName 必选的，lastName 可选；参数不能同时设置为可选和默认

var myFunction = new Function("a", "b", "return a * b"); //构造函数

var x = myFunction(4, 3);

console.log(x);

var foo = x=>10 + x ;//单个参数 () 是可选的;无参数时可以设置空括号

console.log(foo(100))

//函数重载

//如果参数类型不同，则参数类型应设置为 any

// function disp(x:any,y?:any):void {

// console.log(x);

// console.log(y);

// }

// disp("abc") ;//abc undefined

// disp(1,"xyz");//1,xyz

var str = new String( "This is string" );

console.log("str.constructor is:" + str.constructor);//对创建该对象的函数的引用

var str1 = new String( "This is beautiful string" );

var index = str1.localeCompare( "This is beautiful string"); //用本地特定的顺序来比较两个字符串

console.log("localeCompare first :" + index ); //相同输出0，不同输出1

 

var str="The rain in SPAIN stays mainly in the plain";

var n=str.match(/ain/g);//查找找到一个或多个正则表达式的匹配 ["ain", "ain", "ain"]

 

// \w 表示 匹配包括下划线的任何单词字符(含数字)

var re = /(\w+)\s(\w+)/;

var str = "zara ali";

var newstr = str.replace(re, "$2, $1");//$1,$2...是表示的小括号里的内容

console.log(newstr); // ali, zara

//slice()截取片段 split()字符串拆分为数组

//substr()从起始索引提取指定书目字符 substring()提取两个索引之间的字符

//valueOf()返回指定字符串对象的原始值 var str = new String("Runoob"); console.log(str.valueOf( )); // Runoob

 

//数组

// 数组方法

// every() 检测数值元素的每个元素是否都符合条件

//some()检测数组元素中是否有元素符合指定条件。

function isBigEnough(element, index, array) {

return (element >= 10);

}

var passed = [12, 5, 8, 130, 44].every(isBigEnough);

console.log("Test Value : " + passed ); // false

var retval = [2, 5, 8, 1, 4].some(isBigEnough);

console.log("Returned value is : " + retval ); // false

 

//map() 通过指定函数处理数组的每个元素，并返回处理后的数组。

var numbers = [1, 4, 9];

var roots = numbers.map(Math.sqrt);

console.log("roots is : " + roots ); // 1,2,3

 

//reduce()将数组元素计算为一个值（从左到右）。reduceRight()从右到左

var total = [0, 1, 2, 3].reduce(function(a, b){ return a + b; });

console.log("total is : " + total ); // 6

 

//TypeScript元组

//元组中允许存储不同类型的元素，元组可以作为参数传递给函数。

 

//接口不能转换为 JavaScript。 它只是 TypeScript 的一部分

 

//类

// class Car {

// engine:string; // 字段

// constructor(engine:string) { // 构造函数

// this.engine = engine

// }

// disp():void { // 方法

// console.log("发动机为 : "+this.engine)

// }

// }

//子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承；不支持继承多个类，但 TypeScript 支持多重继承

//类继承后，子类可以对父类的方法重新定义，这个过程称之为方法的重写。 super 关键字是对父类的直接引用，该关键字可以引用父类的属性和方法

// class PrinterClass {

// doPrint():void {

// console.log("父类的 doPrint() 方法。")

// }

// }

// class StringPrinter extends PrinterClass {

// doPrint():void {

// super.doPrint() // 调用父类的函数

// console.log("子类的 doPrint()方法。")

// }

// }

//访问控制修饰符 public（默认） protected自身、子、父 private自身

//类可以实现接口，使用关键字 implements，并将 interest 字段作为类的属性使用

 

//声明文件 declare 定义的类型只会用于编译时的检查，编译结果中会被删除。声明文件以 .d.ts 为后缀