typescript的基础类型

 //基本语法：let 变量名:数据类型=值

    //布尔类型

    let flag:Boolean=true;

    console.log(flag);

    //数字类型

    let a1: number = 10 // 十进制

    let a2: number = 0b1010  // 二进制

    let a3: number = 0o12 // 八进制

    let a4: number = 0xa // 十六进制

    console.log(a1,a2,a3,a4);

    //字符串类型和 JavaScript 一样，可以使用双引号（"）或单引号（'）表示字符串,字符串类型和数字类型是可以拼接的。

    let name:string = 'tom'

    name = 'jack'

    // name = 12 // error

    let age:number = 12

    const info = `My name is ${name}, I am ${age} years old!`

    console.log(info);

    console.log(name+age);//jack12

    //总结：ts变量中一开始是什么类型，那么后期赋值的时候只能是这个类型的数据，是不允许其他类型的数据复制给当前这个变量的

    //例如 let name:string = 'tom' name = 12 不允许

    //undefined 和 null

    //null 和 undefined 是所有类型的子类型。 就是说你可以把 null 和 undefined 赋值给 number 类型的变量。

    let u: undefined = undefined

    let n: null = null

    console.log(u,n);

    let num2: number=null;

    console.log(num2);

//数组类型

   //数组类型定义方式1

   //语法：let 变量名:数据类型[]=[值1,值2...]

   let arr1:number[]=[100,200,10];

   console.log(arr1);

   //数组类型定义方式2

   //语法：let 变量名:Array<数据类型>=[值1,值2...]

   let arr2:Array<number>=[1,2,3];

   console.log(arr2);

   //注意问题：数组定义后，里面的数据类型必须和定义数组的时候的类型是一致的，复奏有错误提示信息。也不会编译通过

   

   //元组类型：在定义数组的时候，类型和数据的个数一开始就已经限定了

   let arr3:[string,boolean,number]=['wy',true,199.333];

   console.log(arr3);

   //注意问题：元组类型在使用的时候，数据类型的位置和数据的个数，应该和在定义元组的时候的数据类型和位置应该是一致的。

   console.log(arr3[0].split(''))

   console.log(arr3[2].toFixed(2))

//枚举类型,枚举里面的每个数据值都可以叫元素，每个元素都有自己的编号。编号默认从0开始，依次递增加1.

   enum Color{

       red=100,//枚举类型的每个元素的值也可以进行设置。

       blue,

       green

   }

   //定义一个Color的枚举类型的变量来接受枚举的值。

   let color:Color=Color.red;

   console.log(color);//100

   console.log(Color[102])//blue。

   console.log(Color.red,Color.blue)//100 101

   enum Geumer{

       男,

       女

   }

   console.log(Geumer.男)//0.  可以为中文

//any类型

   let str: any=100

   str='wy';

   console.log(str);

   //当一个数组中要存储多个类型，个数不确定，类型不确定，此时也可以使用any类型来定义数组

   let arr1: any[]=[1,'wy',true];

   console.log(arr1);

   console.log(arr1[0].split(''));//用字符串的方法也没报错这是any类型的缺点。

//void 类型像是与 any 类型相反，它表示没有任何类型。 当一个函数没有返回值时，你通常会见到其返回值类型是 void

   /* 表示没有任何类型, 一般用来说明函数的返回值不能是undefined和null之外的值 */

    function fn(): void {

    console.log('fn()')

    // return undefined

    // return null

    // return 1 // error

  }

  //声明一个 void 类型的变量没有什么大用，因为你只能为它赋予 undefined 和 null：

  

  let unusable: void = undefined

//object类型

   //定义一个函数，参数是object类型，返回值也是object类型

   function getObj(obj:object): object{

    console.log(obj)

    return{

        name:'暴宁馨',

        age:27

    }

   }

   console.log(getObj({name:'wy',age:'18'}))

   //console.log(getObj('123'))//错误。必须得是object类型

   console.log(getObj(new String('123')))

   console.log(getObj(String));

//联合类型

   //需求1: 定义一个函数得到一个数字或字符串值的字符串形式值

   function getString(str:number|string):string{

       return str.toString();

   }

   console.log(getString('123'));

   //需求2: 定义一个函数得到一个数字或字符串值的长度

   //类型断言

   //类型断言的语法1：<类型>变量名

   //类型断言的语法2：值 as 类型

   function getNumber(str:number|string):number{

    if((<string>str).length){

        // return (<string>str).length//类型断言就是告诉浏览器我确定这是一个字符串类型

        return (str as string).length

    }else{

        return str.toString().length;

    }

}

console.log(getNumber('123'));//3

//类型推断 TS会在没有明确的指定类型的时候推测出一个类型

//有下面2种情况: 1. 定义变量时赋值了, 推断为对应的类型. 2. 定义变量时没有赋值, 推断为any类型

/* 定义变量时赋值了, 推断为对应的类型 */

let b9 = 123 // number

// b9 = 'abc' // error

/* 定义变量时没有赋值, 推断为any类型 */

let b10  // any类型

b10 = 123

b10 = 'abc'