Typescript 详细总结1

基本数据类型

类型注释 :number

let  num:number = 5 // 数字类型

let  str:string = 'str' // 字符串类型

let  boolen:boolean  = true // 布尔

 类型断言，确定类型后，不能赋其他类型值

any 类型

let   anything:any = 'ssssss'

let   anything:any = 223

any类型 变量中可以储存任何类型的值，关闭了ts的类型检验

声明变量如果不指定类型，则自动默认为any let num = 10  // 隐式any

Unknow 类型

let unkow:unknown = 'srttt'

unkow = true

unkow = 12

unknow   实际上就是一个安全的any类型，不能直接赋值给其他变量

如果需要变量赋值，可以使用if判断是否是此类型，进而赋值

或者类型断言 unkow as string

Unknow 和 any 不同点

任何值都可以赋值any,unkown,但unkown不能赋值给除unkown和any之外的值

// #region  unknown 与 any区别
// 1.可以把任何类型的值赋给any
// 任何值都可以赋值给unkonwn,any 但是unkonwn不能赋值给除 unkonwn，any 以外的值
let any:any 
let unknown:unknown = 'sss'
let num:number=18
num = any
num = unknown  
console.log(num);

数组array

// #region 数组类型
let arr: string[]  // 字符串数组
let arr2: number[] // 数字数组
let arr3: boolean[]  // 布尔值数组

let arrs: string[][] // 二维数组
arrs = [['ss', 'ddd']]
console.log(arrs[0].length);

元组 tuples

固定长度的数组 

// #region 元典类型
let empole:[string,number,boolean] = ['ss',22,false]
empole[0] = 'dd'
//#endregion

枚举 enum

存储一组有限值，可以限定值的范围

// #region 枚举
// 默认从零开始 设置默认值后从默认值开始递增
// 若设置除 number 以外类型的值，所有值都需要默认值
// 声明时编译的是打印
const enum num {
    one = 'he',
    two = 'll',
    three = 'o'
}

// 当值为枚举类型时，赋值为枚举类型
let a: num = num.one
console.log(a);

console.log(num.one);
// #endregion

函数 function

function fn(参数1:类型,参数二:类型) :返回值类型 =>{}

通过类型注释可以标注函数接收的参数类型和返回值的类型

如果函数没有返回值，使用void标注 fn():void

通过？的方式可以设置可选参数 fn(a?:number) // a=number/undefind  可选参数原本就是原本类型

若定义函数形参为结构语法  fn({data,now}:{data:string; now:number} )  // 与形参一一对应

永远不会返回结果 fn():never

//#region 函数
function sum(num1: number, num2: number): number {
    return num1 + num2
}

// 没用返回值时，用:volid
function setnum(data: boolean): void {
    console.log(99999);
}

// 函数(参数类型)=>返回值类型
let log: (n: number) => number;
log = (x) => {
    return 10
}

// 函数返回值必须返回
function a1(num1: number): number {
    if (false) {
        return num1
    }
    else {
        return num1
    }
}

// 参数必须传参
// ？可选参数 
function a2(num1: number = 1, num2?: number): number { // 默认参数
    if (num2) {
        return num1 + num2
    }
    return num1
}

console.log(a2());

// 结构语法 结构赋值
const data = ({date, weather}:{date:Date,weather:string})=>{
 console.log(date,weather);
}

const tody={
    date:new Date(),
    weather:'sunny'
}

data(tody)

对象 object

字面量对象 let obj: {x:number, y:number} = {x:10,y:100}

let student: { age?: number } = {}; //age?: number | undefined

const userInfo = {
    names: 'zhangsan',
    age: 18,
    love: {
        play: 'basketball',
        sing: 'r&b'
    }
}

// 解构对象里的数据 一层层解构
const { names, age }: { names: string, age: number } = userInfo
const { love }: { love: { play: string, sing: string } } = userInfo
const {love:{play,sing}}:{love: { play: string, sing: string }} = userInfo

console.log(love);
console.log(play);


//  type ts新增 允许自定义数据类型
type standard = { x: number, y: number }

let position: standard = { x: 100, y: 20 }
let position2: standard = { x: 100, y: 20 }

position.x = 555
console.log(position2);

// readonly 属性只读 不能修改
let a3: { readonly num: number } = { num: 10 }

// #endregion

可空类型

在ts中 ，undefined和null 这两个值也可以作为类型使用

 let und:undefind   let null:null

// ts中 undefined和null可以当数据类型
let a9: undefined = undefined
let a8: null = null

类型推断

有初始值是，类型推断就为初始值的类型 let num = 11 // number

没有初始值是，为any类型 let num； // any

// 系统类型推断
// 有初始值时，数据类型就为初始值的数据类型，无初始值时为any类型
let num1 = 10
let str = 'ss'
let x;  // any

// string
let strArr = ['a','b','c']
// num
let numArr = [1,2,3]
// boolen
let boolenArr = [true,false,undefined]
// never
let arr5 = [] // 数组中没用值为 never 即不能有值 

arr5[0] = 10  //报错 不能有值

// 对多数组类型时要加括号
let ary:(string | number)[] = [1,'f',50]

// ts编辑器会自己推断函数的返回值

never

void 表示没有任何类型（可以被赋值为 null 和 undefined）

never 表示一个不包含值的类型，即表示永远不存在的值。

区别：拥有 void 返回值类型的函数能正常运行。拥有 never 返回值类型的函数无法正常返回，无法终止，或会抛出异常。