TypeScript 关键字

1. declare 关键字

   1. 关键字 declare 表示声明的意思，我们可以用它来做出各种声明

   2. declare 是给编译器读取用的，可以暂时不调用

2. as 关键字表示断言

   1. as 断言可以将日常宽泛的数据类型定义具体化，避免造成数据处理错误  

   2. let m = 100;
      let n="abc";
      let array = [m,n] ;
      let f = array[0];
      f = 2000;
      f="aaa";// f 可以被赋值为数字后再改成字符串
      
      let m = 100;
      let n="abc";
      let array = [m,n] as const;// 通过as const 将数组限定第一个数据的类型number，第二个是string
      let f = array[0];
      f = 2000;
      f="aaa"; // 再改成字符串类型就会报错   不能将类型“string”分配给类型“number”
      
      -----------------------------------------------------------------------------------
      function asConst(){
        let a:string = "abc";
        let b = (firstname:string,lastname:string):string => firstname + lastname;
        return [a,b];
        // q报错解决方案1  return [a,b] as const;
         // q报错解决方案2  return [a, b] as [typeof a, typeof b]
      }
      
      let [p,q] = asConst();
      console.log( q("Green","Tom")); /*
      函数q会报错 
      此表达式不可调用。
        "string | ((firstname: string, lastname: string) => string)" 类型的部分要素不可调用。
          类型 "string" 没有调用签名*/
      // 上述代码会直接编译失败，原因是系统认为变量q的类型是string | ((firstname: string, lastname: string) => string)，编译器并不能认定q是一个函数。

3. abstract

   1. abstract用于定义抽象类和抽象方法，抽象方法必须在抽象类中，具体实现在继承的类中实现

   2. 抽象类不能被实例化，子类继承可以实例化

   3. abstract clss Person {
        private name: string;
        constructor(n: string) {
          this.name  = n;
        }
        
        abstract eat(food: string): any; // 抽象方法必须在继承类中实现
      }
      
      class Student extends Person {
        constructor(n: string) {
          super(n)
        }
        
        eat(food: string): any {
          console.log(`吃了${food}`)
        }
        
      }
      
      const s1: Student  = new Student('jack');
      s1.eat('鸡腿');

4. 1. 成员可见性（Member Visibility）

      1. public 成员默认可见性为public，一个public的成员在任何地方都可以被获取

         class Person {
           // public是默认的所有可以不写
           public say() {
              console.log('Hi!')
           }
         }
         
         const p = new Person();
         p.say(); // Hi!

      2. private 成员只能在声明类的，内部进行访问,即派生类也不可访问

         class Base {
           private x:number = 0;
         }
         
         const b = new Base();
         b.x; // Property 'x' is private and only accessible within class 'Base';

      3. protected 成员仅对子类可见，在派生类中可以访问

         class Animal {
           protected name: string;
           // 构造函数也可以被标记为protected。这意味着这个类不能再包含它的类外被实例化，但是能被继承，也就是可以在派生类中被super执行
           protected constructor(name: string) {
             this.name = name;
           }
         }
         
         class Dog extends Animal {
           private food: string;
           constructor(n: string, f: string) {
             super(n);
             this.food = f;
           }
           getNme('name:', this.name); // 这里的name就是Animal中的
         }
         
         const d = new Dog('小黄', '小G');