TypeSprict -- 基础类型

1.'TypeSprict ' 和 'JavaSprict' 的类型是基本一致，'TypeSprict' 依次是:1.1 'boolean' -- 布尔类型,定以后可以赋值true/false 和Boolean()对象1.2 'number' --数字类型，,定以后可以赋值'2/8/10/16进制'，'整数类型'，'小数类型'，'NaN','Infinity（表示无穷大）'1.3 'string' -- 字符串类型1.4 '数组类型' -- '类型[]' /' Array<类型>'1.5 '元组类型' -- '[类型]'1.6 'enum'    -- 枚举1.7 'any'     -- 任意类型1.8 'void'    -- 空置,定义方法时候没有返回值使用1.9 'null/undefined' -- 'Null 和 Undefined'1.10'never'  -- 不存在类型一般用于错误处理函数.例如'抛出异常'/'死循环'1.11'object' -- 对象1.12'类型断言' -- （笔者目前觉得是指定某个类型似做某件事）
2.基本类型使用的时候，通过冒号分割，以冒号左边为变量名，右面是变量的
类型
3.下面的案例建议在刚才的'example' 文件下创建一个'.ts'文件，并且在这个文
件中引入对应在'example' 创建的ts文件，例如: 在'example' 创建了一个
'basic-type.ts'文件，在'index.ts' 引入时需要写:import './example/basic-type'
4.注意'let' 和 'const' 变量声明修饰问题，在第一个案例中会详细说明，其他
案例同理
复制代码

let 和 const 注意事项

1.两者区别'const' 必须定义就赋值,但'let' 定义时候可以不赋值，但使用时候
必须赋值
复制代码

const

• 错误示范 如果使用const声明变量，在初始的时候没有赋值是不被允许的

const name1 : string
复制代码

• 正确写法

const name1 : string = 'wang'
console.log(name1)  // 打印结果 wang
复制代码

let

1.let 和 const 最大的区别'let' 允许 定义时不用赋值，但使用前必须赋值
复制代码

• 错误示范

let name1 : string // 这一步是正确的可以定义不赋值
console.log(name1) // 错误的 使用时候必须要赋值
复制代码

• 正确操作

let name1 : string // 当然也可以写成 let name1:string = 'wang'
name1 ='wang'
console.log(name1) // 打印结果是wang
复制代码

基本类型写法

布尔类型 -- boolean

1.只能赋值true 或者 false和Boolean()对象
复制代码

• 赋值为true 和 false

let bool:boolean = true // 只能赋值true 或者 false 和Boolean()对象
bool = false // 重新赋值
console.log(bool) // 打印结果false
复制代码

• 赋值为Boolean()对象

let bool: boolean = Boolean(1);
console.log(bool) // true
复制代码

数字类型 -- number

1.ts 和 js 一样，TypeScript里的所有数字都是浮点数。不想java中有整数类
型、双精度类型等等，因为'ts' 的 数字表现形式是'number'
2.定义成number 只能赋值有:'二进制'、'八进制'、'十进制'、'十六进制'、'整数类型和小数类型(整数类型可以算进十进制)'、'NaN(非数字类型)'、'Infinity（表示无穷大）'
复制代码

可以参考js数字类型 -- 作者 酱路油过

let binNum:number = 0b110 // 二进制
let octNum:number = 0o6 // 八进制
let num:number =  6// 十进制
let hexNum:number = 0x6 // 十六进制
let maxNum:number = Infinity // 无穷大
let minNum:number = -Infinity // 无穷小
let isNaNum:number = NaN // 表示非数值类型
console.log(binNum) // 6
console.log(octNum) // 6
console.log(num) // 6
console.log(hexNum) // 6
console.log(maxNum) // Infinity
console.log(minNum) // -Infinity
console.log(isNaNum) // NaN
复制代码

字符串类型 -- string

1.字符串也支持es6的`` 拼接写法
复制代码

// 字符串类型
let num:number = 1
let str: string
str = 'abc'
str = `数值${num}` // 使用es6 拼接 ``
console.log( str )
复制代码

数组类型

1.数组类型是用来限制数组内部元素的类型，写法有两种
'「类型 + 方括号」表示法','数组泛型'
复制代码

• 「类型 + 方括号」

// 第一种写法
let arr: number[]
arr = [1]
复制代码

• 泛型

// 第二种写法泛型
let arr2: Array<number>
arr2 = [1]
复制代码

• 联合类型

// 联合类型(下面案例显示可以是数字字符串类型)
let arr3: (string|number)[]
arr3 = [2,'3']
// 联合类型泛型的形式
let arr4: Array<string|number>
arr4 = [2,'3']
复制代码

元组类型

1.元组类型 固定长度固定类型
2.顺序必须一一对应
3.2.6版本后不不准在越界超过定义数组长度
4.但是可以'push' 往里面添加元素,但只能添加定义好的联合类型
复制代码

let tuple: [string, number, boolean]
tuple = ['a',1,true]
复制代码

枚举类型 -- enum

1.写法：'enum 变量名 {}'，变量名第一个单词一般大写
2.使用场景:当后台开发人员将一些特定的内容通过,特殊含义的数字提供给
我们时候，这个举个例子：权限后台返回给我们0 代表管理员，1代表普通
用户,我们需要结合写一些注释提供给其他接下来的维护,前端人员说明，现
在可以利用枚举值
3.默认顺序从0开始
复制代码

• 枚举类型定义参数点定义变量返回的是数值

enum Roles {SUPER_ADMIN,ADIMN,USER
}
console.log(Roles.SUPER_ADMIN)// 返回的是0
// 后台返回的这种数据不一定是从0 开始 我么你想自定制怎么办
// 可以在后面去赋值，可以三个都赋值，也可以指定赋值其中一个
// 后面的排序会根据上一个进行 累加1
enum Roles2 {SUPER_ADMIN,ADIMN = 3,USER
}
console.log(Roles2.SUPER_ADMIN)// 返回的是0
console.log(Roles2.USER)// 返回的是4
复制代码

• 枚举类型[对应枚举数值]返回的是定义名称

enum Roles {SUPER_ADMIN,ADIMN,USER
}
console.log(Roles[2])// USER
复制代码

• 内外部枚举？？？？？？？？？？？？

任意类型 -- any

1. 这些值可能来自于动态的内容，比如来自用户输入或第三方代码库。 这
种情况下，我们不希望类型检查器对这些值进行检查而是直接让它们通过编
译阶段的检查。 那么我们可以使用any类型来标记这些变量
2.使用any 等同于 :let something;something = 'seven';something = 7;
复制代码

// any任意类型 少用
let value: any
value = 1
value = '1'
// 利用any 定义数组
const arr4: any[] = [1,'a']
复制代码

空值 -- void

1.它表示没有任何类型
2.当变量定义的时候只能赋值'undefined' (官方文档说变量定义这个一般没多大用)
3.变量的时候也可以赋值null 但需要修改配置文件
4.当函数定义的时候表示函数没有任何返回值
复制代码

let anyParams: void = undefined
// let anyParams2:void = null 可以赋值null 但需要修改配置文件// 没有返回值的函数
const consoleText = (text:string):void => {console.log(text)
}
consoleText('测试')
复制代码

Null 和 Undefined

1.如果开启严格模式不能吧其他模式的值设置为null 和 undfined
2.与 void 的区别是，undefined 和 null 是所有类型的子类型。也就是说
undefined 类型的变量，可以赋值给 number 类型的变量
复制代码

let u: undefined
u = undefined //  只能是undefined类型
let n: null
n = null // 只能是null 类型
复制代码

不存在的类型 -- never

1.永远不存在值的类型，一般用于错误处理函数.例如'抛出异常'/'死循环'
复制代码

// never 类型  不存在的类型
const errorFunc = (message: string): never => {throw new Error(message)
}
// 死循环
const infiniteFunc = (): never => {while(true){}
}
// 任意类型都可以赋值 never 但是never 不能赋值任意类型
// 立即执行函 类型是never 下面是
let test:number
const infiniteFunc2 = ((): never => {while(true){}
})()test = infiniteFunc2 // 其他 类型可以赋值never类型
// infiniteFunc2 = test never类型不可以赋值其他类型
复制代码

对象 -- object ??????

1.就是我们熟知的object类型
复制代码

let obj:object = {name:"wang"
}
function objFun(obj:object):void{console.log(obj)
}
objFun(obj)
复制代码

类型断言-- （笔者目前觉得是指定某个类似做某件事）

1.两种写法：'<类型>值'  或者 '值 as 类型'
2.当我们使用一些联合类型的时候，不同的联合类型是具有不同属性，例如
数字就不存在字符串长度的方法，但是为了区分联合类型传递的参数去做不
一样方法，就需要使用到类型断言
3.它没有运行时的影响，只是在编译阶段起作用。 TypeScript会假设你，程序员，已经进行了必须的检查。
4.下面函数中的应用如果是js的话传入的数字，数字.length 会对应'undefined'
代码不会出现问题的，但因为ts 强类型，他会去查你类型中是否有这个方法
让你通过断言去做不同的操作
5.简单的说因为ts给我们做了强制的判断，因此我们也要对指定的联合参数
断言告诉他使用那个
复制代码

• 两种写法

// 尖括号写法
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
// as 的写法
let someValue1: any = "this is a string";
let strLength1: number = (someValue1 as string).length;
复制代码

• 函数中的应用

function getLength(something: string | number): number {if ((<string>something).length) {return (<string>something).length;} else {console.log(2)return something.toString().length;}
}
console.log(getLength(1))
复制代码