【第一章】

一、 ts 基本数据类型

// 字符串
let str: string = 'TS'
let moban: string = `Web ${str}`
console.log(moban);

// 数字
let notANumber: number = NaN;//Nan
let num: number = 123;//普通数字
let infinityNumber: number = Infinity;//无穷大

// 布尔
let flag: boolean = true
// 隐式转换
let flag2: boolean = Boolean(0)
// 布尔对象
let flagObj: Boolean = new Boolean(1)
console.log(flag, flag2, flagObj); //true false [Boolean: true]  

//  null undefind
let n: null = null
let u: undefined = undefined

//  void 空 可用于函数没有返回值 或 返回 undefind
function a(): void {
  // return 1 报错
  // return undefined
  return
}

// any unknow
let any: any = 1
let unknow: unknown = 1
let str2: string = ''
// any 类型会影响 其他变量类型
str2 = any
// unknow  不可以随便赋值 
// str2 = unknow // 报错
// 判断
/* if (typeof unknow === 'string') {
  str2 = unknow
} */

二 、接口与对象类型

对象类型

· Object
· object
· {}

//  Object   object   {} 区别
  // Object 任意类型
  let a: Object = 123
  let a1: Object = ""
  let a2: Object = []
  // object 引用数据类型  object array  function
  // let b: object = 123 报错
  let b: object = {}
  let b2: object = []
  let b3: object = (): void => { }
  // {} 定义字面量 Object  注意：定义后变量不可更改
  let c: {} = { a: 2 }
  // c.a = 3  //报错

接口

// 接口 interface
  // 定义一个接口
  interface myInter {
    // readonly 只读属性
    readonly name: string,
    //  ? 可选操作符  
    age?: number
    // [propName: string] 任意属性
    [propName: string]: any,
    //  函数
    cb: () => void
  }
  // 接口继承  extends
  interface myInter2 extends myInter {
    //  | 联合类型
    hobby: string | string[]
  }

  let obj: myInter2 = {
    name: '张三',
    cb: () => { },
    sex: '女',
    hobby: []
  }
  console.log(obj);

三、数组类型

//类型加中括号
  let arr: number[] = [123]
  //这样会报错定义了数字类型出现字符串是不允许的
  // let arr1: number[] = [1, 2, 3, '1']

  var arr3: number[] = [1, 2, 3]; //数字类型的数组
  var arr4: string[] = ["1", "2"]; //字符串类型的数组
  var arr5: any[] = [1, "2", true]; //任意类型的数组
  console.log(arr); // [ 123 ]

  // 泛型数组
  let arr6: Array<number> = [1, 2, 3, 4, 5]

  // 多维数组
  let data: number[][] = [[1, 2], [3, 4]];

  // 类数组
  function arr2(...args: any[]) {
    //  IArguments类数组类型
    const a: IArguments = arguments
    console.log(a); // { '0': 1, '1': 2, '2': 3 }
    console.log(args); // [ 1, 2, 3 ]
  }
  arr2(1, 2, 3)

  // 类数组接口
  interface NumberArray {
    [index: number]: number;
  }
  //表示：只要索引的类型是数字时，那么值的类型必须是数字。
  let fibonacci: NumberArray = [1, 1, 2, 3, 5];
  console.log(fibonacci); // [1, 1, 2, 3, 5]

四、函数

·基本用法

// 基本用法
function getMsg(name: string, age: number): string {
  return name + age
}
console.log(getMsg('张三', 18)); // 张三18

· 函数接口

// 函数类型  约束函数
interface funInter {
  (a: string, b: string): boolean
}
const fnInter: funInter = function (a: string, b: string): boolean {
  return a.indexOf(b) !== -1
}
console.log(fnInter('abc', 'b')); // true

· 函数重载

// 函数重载  定义多套函数规则 根据传入参数执行不同的结果
function fn(params: User): string
function fn(params: number, flag: boolean): number
function fn(params: User | number, flag?: boolean): any {
  if (typeof params === 'number') {
    console.log(params + (flag ? 1 : 0));
  } else {
    console.log(params.name);
  }
}
fn({ name: '张三' })
fn(1, true)

五、联合类型-交叉类型-类型断言

· 联合类型

// 联合类型 |
let tel: number | string = 10086
tel = '026-1234546'

· 交叉类型

// 交叉类型 &
interface one {
  name: string
}
interface two {
  age: number
}

function fn2(info: one & two): void {
  console.log(info);
}
fn2({ name: '张三', age: 18 })

· 类型断言

// 类型断言
function fn3(params: number | string): void {
  // 语法：  参数 as 类型
  console.log((params as string).length);
  // <类型>参数
  console.log((<string>params).length);
}
fn3('123')
fn3(123)

六、class 类

1.创建一个类

public 默认公共的 外部与内部都能访问该变量
private 私有的 只能在类 内部访问
protected 受保护的 父类与子类 内部可以访问
static 静态属性或方法 类直接调用访问

// 创建一个类
class Person {
  // public 默认公共的 外部与内部都能访问该变量
  public name: string
  // private  私有的  只能在类 内部访问 
  private age: number
  // protected  受保护的  父类与子类 内部可以访问
  protected sex: string
  // static 静态属性  类直接调用访问
  static x: string = '静态属性'
  constructor(name: string, age: number, sex: string) {
    this.name = name
    this.age = age
    this.sex = sex
  }
  // static 静态方法  只能访问静态属性 或方法
  static run() {
    console.log(this.x);
    // console.log(this.age); 无法访问
  }
  static dev() {
    this.run()
  }
}

// 创建一个实例
const p = new Person('张三', 18, '男');
// p.age   私有变量  报错无法访问
// p.sex  受保护变量  报错无法访问

// 静态属性和方法 类直接调用
console.log(Person.x);
Person.dev();

2.implements 类是实现接口

 interface A {
    name: string
  }
  interface B {
    age: number
  }
  class Test1 {
    sex: string = '男'
  }
  // 类继承与实现接口
  class Test extends Test1 implements A, B {
    name: string
    age: number
    constructor(name: string, age: number) {
      super()
      this.name = name
      this.age = age
    }
  }

3.抽象类

//   abstract 定义抽象类  抽类只能被继承 不能被实例化
  abstract class A {
  //抽象属性
    abstract name: string
    abstract age: number
    setName(name: string) {
      this.name = name
    }
  }
  // new A()  报错
  class B extends A {
    // 抽象 方法或属性要在派生类中实现
    name: string
    age: number
    constructor(name: string, age: number) {
      super()
      this.name = name
      this.age = age
    }
  }
  const b = new B('张三', 18)
  b.setName('李四')
  console.log(b.name);