016--自找麻烦之typescript（ts）

1. ts是js的超集，ts没有兼容性问题，ts是微软开源的

2. ts环境搭建：(mac)

        sudo npm i -g typescript

        tsc 文件名.ts  （生成js文件）

3. ts 多了元组（类似数组，里面的值可以是各种不同类型），枚举类型enum（有限的可能性），任意值any（类型任意改变），空值void（不能赋值，一般用于返回值）, symbol等

4. ts 是有类型的script

5. ts虽然比js难，但是在大型工程化项目是有价值的

6.  接口： 也是一种类型（可以自定义的类型） 约定，限制

接口就是用来指定一个协议，这个协议是用来约束数据应该具备什么样的能力的

interface Person {
  name: string;
  age: number;
}

function sayHello( obj: Person){ //接口的用法

console. log( '我叫' + obj. name + ", 我今年" + obj. age + "岁");

}

// 函数类型  这个接口其实就是对函数进行约束的东西
// 这个接口对于函数的要求就是：
// 1. 要求有两个参数： source   subString
// 2. source参数必须是字符串类型
// 3. subString参数也必须是字符串类型
// 4. 函数的返回值必须是布尔值
interface SearchFunc {
    //小括号中约束的是参数列表           :后面的约束的是函数的返回值
    (source: string, subString: string): boolean;
}

// func这个变量现在能够存储的东西
// 只能是用SearchFunc这个接口来约束的一个函数
let func: SearchFunc;

func = function(source: string, subString: string){
    return true;
};



//接口也是可以被实现的
interface ICat{
    name: string,
    nianren();
}

class Cat implements  ICat{
    name: string;
    nianren(){
        
    }
}

7. ts 是真面向对象，js 是假的

8. 访问修饰符： 

        public  公有  任何人能访问

        private  私有  只有类内部可以访问

        protected  受保护-友元   只有子类和类内部能用

9. 泛型： (与any不同的地方是可以限定类型) 在大型项目才能体现出泛型的优势

class Calc<T>{
  a: T;
  b: T;
}
var obj = new Calc<number>();
obj.a=12;
obj.b='abc';   //这里这样就不通过，因为已经规定T是number类型

10. ES6 中的类 与 TS中的类 的区别

//es6
class Person{
    constructor(){
        this.name = "张学友";
        this.age = 60;
    }

    sing(){
        console.log("我和你吻别");
    }
}

var p = new Person();

// ts中class的写法和es6中class写法的区别

// 属性，必须先声明，后使用。

class Person{
    //属性声明
    //属性名: 类型
    name: string;
    age: number;

    constructor(){
        this.name = "张学友";
        this.age = 18;
    }

    sing(){
        console.log("我和你吻别吧");
    }
}

let p: Person = new Person();

p.sing();

11.  ts中的类实现继承

class Animal{
    protected age: number;

    constructor(){
        this.age = 18;
    }

    eat(){
        console.log("吃个大鸡腿");
    }
}


class Dog extends Animal{
   type: string;
   constructor(){
       // 和es6完全一致，如果需要在子类中书写构造函数
       // 那么必须在子类的构造函数中手动的调用super  super指的其实就是父类的构造函数
       // 内部实现属性继承的方式其实是借用构造函数继承（了解）

       super();
       this.type = "大黄狗";
       this.age = 10;
   }

   watchDoor(){
       console.log("生人勿近");
   }
}

let dog: Dog = new Dog();



//如果父类中的属性或者方法使用的是如下的修饰符
//1. public: 表示在哪里都可以使用，包括继承之后的子类中，子类创建的对象都可以使用
//2. private：表示只能在父类自己中使用，子类无法用，子类的对象，父类自己的对象都无法使用
//3. protected：表示只能在父类中和继承父类的子类中使用，不能通过对象来访问

dog.eat();

dog.watchDoor();

======================================

TypeScript 入门教程 读书笔记

1. ts中用 void 表示没有任何返回值的函数，声明一个 void 类型的变量没用，因为它只能赋值为 undefined 和 null

2. 与 void 的区别 是： undefined 和 null 是所有类型的子类型。也就是说 undefined 类型的变量 ，可以赋值给 number 类型的变量，而void 类型的变量，不可以赋值给 number 类型的变量

3. 在ts中，使用接口来定义对象的类型（接口一般首字母大写）

看到40页 ，讲得太细，不想看了。。。。

============================================

1. ts的类中 super 的用法 是用来调用父类的构造函数（即是父类的constructor方法），也可以用来调用父类中定义的方法

super.eat();   //eat()是在父类中定义的方法

2. 接口： 

interface Animal{
  eat();
}
class Sheep implements Animal {    //implements 表示绵羊这个类实现Animal这个接口，绵羊这个类必须要有animal接口的方法eat
  eat(){console.log("i eat cao");}
}

3. ts的类型定义文件 （比如说ts要用到jq就要有jq.d.ts 的文件，也就是jq的ts版本）

    如何找其他库的类型定义文件(用这个库typings)：  https://github.com/typings/typings