一、基础类型

1.字符串

let name:string = 'tom'
name = 'jack'
// name = 12 // error
let age:number = 12
const info = `My name is ${name}, I am ${age} years old!`

2.布尔值

let isDone: boolean = false;
isDone = true;
// isDone = 2 // error

3.数字

let a1: number = 10 // 十进制
let a2: number = 0b1010  // 二进制
let a3: number = 0o12 // 八进制
let a4: number = 0xa // 十六进制
接受整数浮点数，以及各种禁制

4.undefined 和 null

let u: undefined = undefined
let n: null = null
默认情况下 null 和 undefined 是所有类型的子类型。
 就是说你可以把 null 和 undefined 赋值给 任意类型的变量，但在严格模式下不允许

5.数组

//定义数组的两种方式
  //方式一 变量名:数据类型[] = 变量值
  let arr1:number[] = [1,2,3,4]
   console.log(arr1)
   let arr2:object[] = [{},{},{}]
   console.log(arr2)
   //方式二数组泛型  变量名:Array<数据类型> = 变量值
   let arr3:Array<number> = [1,2,3]
    console.log(arr3)
  let arr4:Array<object> = [{},{},{}]
    console.log(arr4)

6.元组

 //元组
    let arr5:[number,string,boolean] = [1,'2',true]
    console.log(arr5)
限制数据类型的同时也限制数据数量，元组在类型声明的时候规定好有几个元素，每个元素分别是什么类型
赋值的时候必须严格按照规则，不能多不能少，同时每个位置的数据类型也要对应上

7.枚举

    //枚举
    enum  Person {
      xiaoming,
      xiaogang,
      xiaohong
  }
  let poeple:Person = Person.xiaohong
    console.log(poeple)//0
 枚举数值默认从0开始依次递增
 根据特定的名称得到对应的枚举数值
也可以给定某个名称一个值，后续的名称会在他的基础上递增
enum  Person {
      xiaoming  = 100,
      xiaogang, //101
      xiaohong //102
  }
  let poeple:Person = Person.xiaogang

注意有赋值数字后续的名称才会递增，否则只有被赋值的那个名称有值，后续的都是undefined。
enum  Person {
      xiaoming  = '123',
      xiaogang, //undefined
      xiaohong //undefined
  }
  let poeple:Person = Person.xiaogang

8.any

    let test:any = {}
    test = 1
    test = '1'
    test = []
    test = undefined
    test = null

被赋予any类型的数据可以被赋值成任意类型

9.void
某种程度上来说，void 类型像是与 any 类型相反，它表示没有任何类型。 当一个函数没有返回值时，你通常会见到其返回值类型是 void

/* 表示没有任何类型, 一般用来说明函数的返回值不能是undefined和null之外的值 */
function fn(): void {
  console.log('fn()')
  // return undefined
  // return null
  // return 1 // error
}

10.object

object 表示非原始类型，也就是除 number，string，boolean之外的类型,并非只是对象类型。
function fn2(obj:object):object {
  console.log('fn2()', obj)
  return {}
  // return undefined
  // return null
}
console.log(fn2(new String('abc')))
// console.log(fn2('abc') // error
console.log(fn2(String))

11.指定函数返回值的类型

小括号后面接上:数据类型,此写法规定了函数必须要有返回值，并且返回值要符合规定的数据类型
function f():string {
        return '1'
    }

12.联合类型

通过|符号连接多种数据类型，被赋予此类型的变量可以存储规定范围内的数据类型的值
 let test2:number|string|number[]|null|boolean|undefined = 1
    test2 = '1'
    test2 = [1]
    test2 = null
    test2 = false

13.断言
当某个变量可能是多个类型时，此时在使用这个变量的时候可能会发生一些ts的报错。
比如下面例子中，str可能是string类型或者number类型，那么在函数体里直接使用
str.length就会引发ts报错，因为number并没有length属性，此时就可以通过断言来告诉ts我确定这个变量是某个类型，可以放心使用。
语法一：<类型>值 语法二：（值 as 类型）

    //断言
  function myfun(str:string|number):number{
      if((<string>str).length){
            return (str as string).length
      }else{
          return str.toString().length
      }
  }

14.接口
TypeScript 的核心原则之一是对值所具有的结构进行类型检查。我们使用接口（Interfaces）来定义对象的类型。接口是对象的状态(属性)和行为(方法)的抽象(描述)

通过接口约束的变量必须含有接口内指定的必选属性，
带问号的属性表示可有可无，可以在变量初始化时传入也可以在初始化之后新增
interface IPerson {
   readonly id:number
    name:string
    sex:string
    age?:number
}
let person:IPerson = {
    id:1,
    name:1+'',
    sex:'18',
}
person.age = 6

15.函数类型

函数类型，就是一个只有形参和返回值的表达式，他约束了函数的形参类型和返回值类型
interface Hanshu {
    (name:string,age?:number):void
}
let fun:Hanshu = function (name) {
    console.log(name)
    return name
}
fun('灰飞啦')

16.类类型

//类 类型
interface IsFly {
    fly():void
}

//声明一个类，受IsFly接口约束
class bird implements IsFly{
    fly(){
        console.log('飞飞飞')
    }
}
let b = new bird()
b.fly()

interface ISswim {
    swim():void
}

class fish implements ISswim{
    swim(){
        console.log('游泳')
    }
}
let f = new fish()
f.swim()

//实现一个接口，继承以上两个接口

interface flyandswim extends ISswim,IsFly{
    say():void
}

class me implements flyandswim{
    fly(){
        console.log('飞飞飞1')
    }
    swim(){
        console.log('游泳1')
    }
    say(){
        console.log('我的接口继承了其他两个接口')
    }
}
let a = new me()
a.fly()
a.swim()
a.say()

通过implements关键字去指定一个类的接口，这个类必须按照接口的约定来定义自身属性，同时接口和接口之间还可以通过extends 来继承其他接口的约束。

17.泛型
当我们在定义一个函数，类，接口等等东西的时候我们可能并不能预先知道他是一个什么类型，而是需要在调用时动态的传入来确定类型。这个时候就会用到泛型。
可以简单的理解为函数的参数一样，你传入的是什么类型，那他就是什么类型。
示例

这就是一个泛型函数，用一个T占位，传入了string之后那用到了T的地方都会被约束为string类型
 function fanxing<T>(name:T):T {
        console.log(name)
        return name
    }
    fanxing<string>('测试一下泛型拉')
泛型约束
 function fanxing<T>(name:T):T {
        console.log(name)
        return name.length
    }
像这样，如果我们要返回name的长度，这个时候ts就会报错
，因为他不知道name的类型，也不知道name有没有length这个属性
这个时候就可以用上泛型约束，保证在调用函数时传入的类型必须有length属性
function fanxing<T extends {length:number}>(name:T):any {
    console.log(name)
    return name.length
}
fanxing<string>('测试一下泛型拉')