ts学习一些简单的，难的还得在项目中

1.number string boolean void (undefined null)这两个类型用的不多.注意：可以作为其他类型的子类型
let b:number = undefined
let b:string = null
let notANumber: number = NaN;//Nan
let num: number = 123;//普通数字
let infinityNumber: number = Infinity;//无穷大
let decimal: number = 6;//十进制
let hex: number = 0xfood;//十六进制
let binary: number = 0b1010;//二进制
let octal: number = 0o744;//八进制s
let bool:boolean = false
let bool:boolean = true
let n:null = null 
let u:undefined = undefined
Let v:void = null
Let v:void = undefined
Void用砸函数上面,没有返回值，function fn():void{}

1.any(任意类型) unknown(不知道类型) Object Number String Boolean
    (1)top type类型，any unknown 
    (2)Object
    (3)Number String Bollean
    (4)number string boolean
    (5)1 '小满' false
    (6)never  //用到兜底逻辑，所有类型都不包括
    function error():never { throw new Error('小满') }
unknown只能赋值给自身或是any类型,没有办法读任何属性和方法的调用，比any更加安全
any随便

1.object Object {}
    (1)Object包含所有object的类型 let a:Object = 1/let a:Object = []/let a:Object = ()=>{}  
    (2)除了字符串，数字，布尔类型 
    (3){}相当于new Object，无法对变量进行操作

2.接口和对象类型,定义的不能多属性,也不能少属性
interface 重名会重合，合并
interface 任意属性key,可以随便写   [propName:string]:any
interface ? readonly
interface 接口继承
interface 定义函数类型
interface Person {
    name:string,
    age?:number,
    [propName:string]:any,
    readonly id:number,
    readonly rd:()=>{}
}
let a:Person ={
    name:'nisen'，
    age:18    
}
定义函数类型
interface Fn{
    (name:string):number[]

}
Const fn = function (name:string){
    return [1]
}

2.数组类型
let array:number[] = reactive([1,2,3])数组类型是定义里边的元素的类型
泛型写法：let arr2:Array<number> = [10,20,30]
定义对象数组用interface
interface X{
    name:''
}
let arr:X[] = [{name:''},{name:''}]

let arr:any[] = [1,{name:''}]
Function fn(...args:any[]){
    let a:IArguments =arguments 
}

3.函数类型传递对象,?可选参数
interface User {
    name:string,
    age:number
}
(user?:User):User=>{}

3.Ts可以定义this的类型，必须是第一个参数定义this的类型，js中无法使用
interface obj {
    user:number[]
    add:(this:Obj,num:number)=>void
}

Let obj:Obj = {
    user:[1,2,3],
    add(this:Obj, num:number){
        this.user.push(num)
    }
}

4.联合类型
//强转成boolean
Let fn  = (type:number ｜ boolean):boolean=>{
    return !!type
}
//交叉类型&
//类型断言as,欺骗ts,不要乱用 num as string或者是<string>num

5.内置对象
let num:Number = new Number(1)
let date:Date = new Date()
let reg:RegExp = new RegExp(/\w/)
let error:Error = new Error(错了')
let xhr:XMLHttpRequest = new XMLHttpRequest(）

DOM对象
//HTML(元素名称)Element HTMLElement Element
let div:NodeList = document.querySelectorAl1('footer')
let div:NodeListof<HTMLDivElement ｜ HTMLElement>= document.querySelectorAll('div')

BOM对象
let local:Storage = localStorage
Let location:Location = location
Let cookie:string = doucument.cookie
let promise：Promise<number> = new Promise((res)=>{res(1)})
let promise：Promise<string> = new Promise((res)=>{res(1)})代码雨

6.元祖类型:readonly表示只读,?表示可以有可以没有，typeof获取元组的类型
let arr: readonly [number,boolean] =[1,false]
let arr: readonly [x:number,y?:boolean] =[1]
let excel:[string,string,number][] =[
    ['nisen','女'，18]，
    ['nisen','女'，18]，
    ['nisen','女'，18]
]
type first = typeof arr[0] 获取arr的类型
6.枚举类型emnu
emnu Color {
    red = 1,//增长枚举
    green,
    blue
}
6.类型推论和类型别名，extends是包含的意思type num = 1 extends number ? 1 : 0 
type s = string | number
Let str:s ='nisen'

7.泛型:动态类型
function xiaoman(a:number,b:number):Array<number>{
    return [a,b]
}
function xiaoman(a:string,b:string):Array<string>{
    return [a,b]
}
用泛型优化
function xiaoman<T>(a: T,b: T):Array<T>{
    return [a,b]
}
xiaoman(1,2)
别名用泛型
type A<T> = string | number | T
Let a:A<boolean> = true
Let a:A<boolean> = 1
interface用泛型
Interface Date<T>{ msg:T }
Let data:Data<string> = { mag:'heihei' }
泛型支持多个，可以给泛型一个默认值
function add<T = number,K=number>(a:,b:K):Array<T | K>{
    return [a,b]
}
add(1,false)
接口类型的泛型
interface Data{
    message: string,
    code: number
}
get<Data>('/xxx/xxx')
get<T>(url:string):Promise<T>{
    return new Promise((res,rej)=>{})
}
泛型约束,extends
function add<T extends number>(a:T,b:T){
    return a+b
}
<T extends number>(a:T,b,T)=>{ return a+b }
Interface Length {
    length:number
}
function add<T extends Length>(a:T){
    return a.length
}
泛型keyof推断成联合类型
let obj = {
    name:'',
    sex:''
}
type Key = keyof typeof obj

8.类
1.class 的基本用法 继承 和 类型约束 implements(约束类的)
2. class 的修饰 readonly private protected public
3.super 原理
4.静态方法
5. get set

Interface Options{
    name:string
}
Interface PersonClass {
    name:Options
    init():void
}
class Person implements PersonClass{
    Options:Options
    constructor(options:Options){
        this.options = options
    }
    init():void{
        
    }
}

New Person({name:''})

6.接口：首字母大写，一般I开头
    对象属性必须一样(name?:string，表示可有可无)
    readonly表示只读的
    interface IPerson { 
          readonly name: string,
          age:number
    }

7.类型断言：手动指定一个类型
    第一种(x as number)
    第二种<string>x
8.起别名（type snb = string | number | boolean ）
9.元祖(Tuple) let Tarr:[number,string] = [123,'123'],添加内容的时候需要的是number或string
10.枚举：使用枚举给一组树枝赋予名称，没有赋值就是从0开始自增
    enum NumberType{
        one,
        two,
        three,
        four
    }
11.泛型：定义函数，接口或累的时候，不预先指定具体的类型，而在使用的时候在指定类型的一种特性
    <T>表示任意输入的类型
    function getArr<T>(value:T,count:number):T[]{
        const arr: T[] = []

        return arr
    }
    getArr<string>()

断言。as。
类型别名type
接口interface 
Interface params{
    readonly id:number,
    name?:string,
    age?:number,(表示可有可无)
}
(Value : params)=>{},传递的参数必须和接口一致

函数类型：参数类型，返回值类型
泛型<T>

泛型接口。
interface A{
    <T>(a:T,b:T):boolean
}
const func:A = (x,y) => {}

interface A<T>{
    <T>(a:T,b:T):boolean
}
const func: A<number> = (x,y) => {}

const emit = defineEmits<{
  foo: [id: number]
  bar: [name: string, ...rest: any[]]
}>()

typeof 变量 === “类型”
设置判断函数，返回值类型为 “形参 is 类型”
const isArray = (val: any):val is Array<any> => Array.isArray(val);
语法：变量 instanceof 类型
注：该方法仅适用于对对象进行类型保护
// 获取dom
const title = ref<HTMLElement|null>()
const handleClick = (event:Event): void=>{
    console.log("event=>", event);
    console.log("dom=>",title.value);
}