跟着小满学TS

使用tsc -v查看版本 
使用tsc  --init 创建配置项
使用tsc -w 监听ts的变化去成成js文件 一直打开就行
最后用node XXX.js文件去运行js文件 新增新的终端去运行

 可以在变量后面定义类型

一 字符型

let str:string = `${num}`
console.log(str)

二 数字型

let notANumber: number = NaN;//NaN
let num: number = 123;//普通数字
let infinityNumber: number = Infinity;//无穷大
let decimal: number = 6;//十进制
let hex: number = 0xf00d;//十六进制
let binary: number = 0b1010;//二进制
let octal: number = 0o744;//八进制s

 三 布尔型

let bt:boolean = true
let bf:boolean = false

 四 null类型和undefined类型

let n:null = null
let u:undefined = undefined

五 空类型 void 

let v1:void = null
let v2:void = undefined
function myfn():void{
}//证明函数没有返回值

需要关闭严格模式（在tsconfig.json配置文件里）

改成  "strict": false

六 任意类型 

 安装ts库

npm i ts-node -g
npm init -y
npm i @types/node -D//声明文件

 使用命令 node-ts index.ts直接输出结果

 

 类型定义顺序

1 top type 顶级类型 any任意类型 unknow不知道类型
2 Object
3 Number String Boolean
4 number string boolean
5 1       “123” false
6 never

any和unknow的区别 

1.unknown只能赋给自身或者any类型
let a:unknown = 1
let b:any = 2
a = b
b = a
2.unknown没有办法读任何属性 方法也不可以调用
let a:unknown = {name:"chensiyi",fun:()=>{

}}
a.name
a.fun()//报错不会存在
结论unknown类型比any类型更安全如果有一个不确定的类型优先使用unknown

Object object {} 之前的区别

Object所有类型都指向它
let a:Object = 1
let a1:Object = "123"
let a2:Object = true
let a3:Object = () => {
}
let a4:Object = {name:"123"}
object对类型进行一个约束（能够选出引用类型）
let a:object = 1//报错
let a1:object = "123"//报错
let a2:object = true//报错
let a3:object = () =>{}
let a4:object = {}
{} 相当于 new Object 和 Object的区别是里面的属性不能修改（少用）
let a:{} = 1
let a1:{} = "123"
let a2:{} = true
let a3:{} = () => {
}
let a4:{} = {name:"123"}
a4.name = 111//报错

interface属性用来定义对象类型的

interface As {
    name:string
    age:number
}
let a:As = {
    name:"chensyi",
    age:123
}
//他们两个要长得相同不能多属性不能少属性

interface属性重名会重合

interface As {
    name:string
    age:number
}
interface As {
    child:string
}
let a:As = {
    name:"chensyi",
    age:123,
    child:"123"
}

 可以用数字签名去定义

interface As {
    name:string
    age:number
    [propName:string]:any
}

let a:As = {
    name:"chensyi",
    age:123,
    a:1,
    age1:undefined
}

遇到可以有可以没有的属性可以添加?

interface As {
    name:string
    age?:number //age属性可以有可以没有
    [propName:string]:any
}

let a:As = {
    name:"chensyi",
    a:1,
    age1:undefined
}

使用readonly一般是只读属性不能去更改的属性一般使用id或者函数

interface As {
    name:string
    age?:number
    readonly id:number //一般id不能更改
    readonly cb:()=>boolean
    [propName:string]:any
}

let a:As = {
    id:1,
    name:"chensyi",
    a:1,
    age1:undefined,
    cb:()=>{
        return false
    }
}
a.id = 2//报错
a.cb =()=>{
    return true
}//报错

inderface继承

interface As extends Ad{
    name:string
    age?:number
    readonly id:number //一般id不能更改
    readonly cb:()=>boolean
    [propName:string]:any
}
interface Ad {
    money:number
}
let a:As = {
    id:1,
    name:"chensyi",
    a:1,
    age1:undefined,
    money:123,//继承时候相同于合并一起了
    cb:()=>{
        return false
    }
}

定义函数类型

interface Fn {
    (name:string):number[]//函数参数类型string类型返回的是一个数字类型的数组
}
const fn:Fn = function(name:string){
    return [1]
}

数组类型

普通数组

可以使用两种方法来定义数组的类型

let arr:number[] = [1,2,3,4,5] 
let arr1:Array<number> = [1,2,3,4,5] //使用泛型去约束

对象数组

interface A {
    name:string
    age:number
}
let arr:A[] = [{name:"123",age:123}]

二维数组

let arr1:number[][] = [[1],[2],[3]]
let arr:Array<Array<number>> =  [[1],[2],[3]]

大杂烩数组

let arr2:any[] = [1,true,"123"]

函数里数组如何定义

function fn(...args:any[]){
    console.log(args);
}
fn(1,2,3)
//结果[1,2,3]

伪数组

function fn(...args:any[]){
    console.log(arguments);
    let a:IArguments = arguments
}
fn(1,2,3)


IArguments原理
function fn(...args:any[]){
    let a:Ag = arguments
}
interface Ag {
    callee:Function
    length:number
    [index:number]:any
}