Typescript特性

字符串特性：
1、自动转换
`asd
asdas
aasd` 
以上等于'asdasdasaasd'
2、字符串模板
`aaa ${x} ` = "aaa"+x
3、自动拆分字符串
test(a,b,c){
console.log(a);
console.log(b);

console.log(c);

}
test('asda ${xxx} ,aasdsa ${sss}');
则打印'asda','aasdsa' （会被切割）,xxx,sss

参数类型：
1、
var a :string = "xxx"; ->字符串类型的变量
var b :number= 12; ->数字类型的变量

var c :boolean= true; ->布尔类型的变量

var d :any = "" ->任意类型的变量
比如var a = false; 声明不是定义的类型的值会报错
2、
function test():void{} ->不可有返回值，有return会报错。
3、
function test(a:string){} ->方法的参数也可以声明类型
4、可自定义类型
class Person{ name:string;age:number};
var zhangsan：Person = new Person(); -->这里的Person是定义的类型
zhangsan.name = 12 ->会报错
5、参数默认值
function test(a:string,b:string,c:number){...}
test('ad','asd',13)->必须要传对应的参数，否则会报错
function test(a : string , b : string , c : number = 15){..} -->
test('aasd','ab')-->第三个不用传
function test(a:string , b ? : string ){..}
test('aaa')或test('aaa','bbb') -->都可以,但是可选参数不能声明在必须参数的前面

Rest and Spread 操作符（声明任意数量的方法参数）
function func1(...args){
    args.forEach(function(arg){
        console.log(arg);
    })
};
func1(1,2,3,4,5) ->打印1，2，3，4，5

generator函数(控制函数的执行过程，手工暂停和恢复代码执行)
function* doSomething(){
    console.log("s");

    yield;

    console.log("e");

}
要声明doSomething
var func1 = doSomething();
func1.next(); -->打印s 再次执行function.next() 则打印e

destructuring析构表达式
通过表达式将对象或数组拆解成任意数量的变量
1、
function getStock(){
    return{
        code:"IBM",
        price:100

    }

}
var { code,price } = getStock();
console.log(code) ->IBM
var{ code:codex , price } = getStock();
console.log(codex); -->可以打印别名
2、
function getStock(){
    return{
        code:"IBM",

        price{
            price1:200,
            price2:400   
        }

    }

}
var {code,price:{price1}} = getStock();
console.log(price1) ->200
3、针对数组的析构表达式
var arr =[1,2,3,4]
var {num1,num2} = arr;
console.log(num1)->1
console.log(num2)->2

var { , , num1,num2}
console.log()
console.log(num1)->3
console.log(num2)->4
var {num1,...others} =arr;
console.log(others) --> array[3] ->2，3，4
function dosth([num1,...others]){console.log(..)} 
dosth(arr) ->方法的参数也是析构表达式和上面结果一样

箭头表达式
var sum = (arg1,arg2) => arg1 + arg2; 
只有一个参数的话小括号也不用写，如果箭头表达式内容是多行 则需要写return关键字和大括号
等于var sum = function (arg1,arg2){
    return arg1+arg2

} 
箭头表达式会消除，传统函数中this指向问题

for of ，for in与forEach（）循环
var myArr = [1,2,3,4]
myArr.desc = "xx"
myArr.forEach(value => console.log(value)); 1,2,3,4   --不能brack和打印出 desc
for（var n in myArr）{console.log(n)} 0,1,2,3,desc --这里打印的是数组的下标和属性的名字
for (var n in myArr) { console.log(myArr
)} --1,2,3,4,xx 和元素和属性
for(var n of myArr) { console.log(n)} --1,2,3,4 直接打印键值对的值，不会打印出数组属性，可以brack打断
for（var n of "xxxxx"）{console.log(n)}

Typescript-类
class Person{
    name;

    eat(){
        console.log("im eating")
    }

}
var p1 = new Person(); ->类的实例化通过new完成
p1.name = "xx";
p1.eat();
可以设置访问控制符
public （默认）
private 私有的，只有在类的内部可以访问的到 类的外部访问不到。
protected 受保护的， 在类和类的子类中可以访问到，类的外部访问不到
类中的方法constructor() 类的构造函数。在new的时候被调用
constructor(name : string)  ->必须在创建类的时候必须指定一个参数就可以这样用
var p1 = new Person(); ->报错
constructor(public name:string){} ->这样写可以自动声明一个name属性 ，在创建的时候给name属性赋值(必须要public)
类的继承 class Employee extends Person {}
var e1 = new Employee("xx");
所以e1 继承了Person的所以属性和方法
super有2个用法，一个是调用父类的构造函数，一个是调用父类的其他方法。
子类的构造函数必须要调用父类的构造函数，super(name);

Typescript 泛型
限制集合的内容
var workers: Array<Person> = []; ->规定了这个数组里面只能放person
可以workers[0] = new Person("xx");
workers[1] = new Employee("xx","2"); 都可以这样用