let 变量: 类型

let 变量: 类型 = 值

function fn(参数: 类型, 参数: 类型): 返回值类型{
         .....  
    }

// 声明一个变量 a，同时指定它的类型为 number
 let a:number;

//  a 的类型设置为了 number，在以后的使用过程中 a 的值只能是数字
a = 10;
a = 33;
// a = 'hello'  此行代码会报错，因为变量 a 的类型是 number，不能赋值字符串


let b:string
b = 'hello'
// b=123  不能赋值为 number



// 声明变量直接进行赋值
let c:boolean = false;

// 如果变量的声明和赋值是同时进行的，TS 可以自动对变量进行类型检测。如下面的自动就是 boolean 类型的
let d = false;


// 可以使用 | 来连接多个类型,这时候 e 只能为 “mail” 或者 “haha”
let e: "mail" | 'haha';



// f 只能为 布尔类型或者 字符串类型
let f: boolean | string;

// any 表示的是任意类型，一个变量设置为 any 后相当于对该变量关闭了 ts 的类型检测
let a: any  // 下面的几种赋值都是可以的
a = 10
a = 'haha'
a = false

// unknown 表示未知类型的值, unknown 和 any 的区别在于 any 可以赋值给其他变量，unknown 不可以
let b: unknown
b = 10
b = 'haha'
b = false



// a 和 b 的参数类型都是 number，括号外面的是返回值的类型，这里返回值的类型为 string
function sun(a: number,b: number):string{
    return "a" + "b"
}

// void 用来表示空，以函数为例，就表示没有返回值的函数
function fn1():void{
    console.log('hhhh...')
}


// never 表示永远不会返回结果
function fn2():never{
    throw new Error('报错了。。。')
}

// object 表示一个 js 对象
let a: object;
a = {}

// {} 用来指定对象中可以包含哪些属性，
// 语法：{属性名: 属性值, 属性名: 属性值}
let b: {name: string}  // b 里只能有一个 name，不能有其他的属性了，有且只能有 name 一个属性
b = {name: '邹邹'}

// 在属性名后面加上？，表示属性是可选的
let c: {name: string, age?:number}
c = {name: "啦啦。。。"}  // age 是可选的

// [propName: string]: any 表示任意类型的属性。propName 随便起的名字，propName: string 表示对象里的 key 的类型为字符串，它的值的类型为 any，
// [propName: string]: any 这样 就可以在对象里写入多个 key
let d: {name: string,[propName: string]: any}
d = {name: "haha", a: 1, b :'嘿嘿嘿', c: true}


// string[] 表示字符串数组
let e: string[]
e = ['a', 'b', 'c']

/* 数组有下面的两种写法 */

// number 表示数值数组
let f: number[]  // 推荐这种写法
f = [1,2,3]
// 下面的这个也表示数值数组
let g: Array<number>  // 不推荐这种写法
g = [4, 5, 6] 


// 元组，就是固定长度的数组
let h: [string, number]
h = ['hello',123] // 只能有两个元素，第一个是字符串，第二个是数字，多了少了都会报错 


// 枚举
// 创建一个枚举
enum Gender{
    Male = 1, // 代表 男
    Female = 0  // 代表 女
}
// 使用枚举类
let i:{ name: string, gender: Gender}
i = {
    name: '张三',
    gender: Gender.Male  // 使用枚举里的性别
}

type myType = 1 | 2 | 3 | 4  // 给 1 | 2 | 3 | 4 起了个别名为 myType
let a: myType // a 的类型为 myType，也就是 a 只能为 1 | 2 | 3 | 4
let b: myType