基础类型

布尔值

用boolean表示

let flag: boolean = false

数字

和Javascript一样, typescript 里的数字都是浮点数, 都可以用number来表示, 并且支持二, 八, 十, 十六进制字面量

let binary: number = 0b10101 // 二进制 --> 21
let octal: number = 0o17 // 八进制 --> 15
let dec: number = 1290 // 十进制
let hex: number = 0xa1 // 十六进制 --> 161

字符串

单引号' 或 双引号" 或 反引号 ``` 表示

let firstName: string = 'Jay'
let lastName: string = 'Chou'
let fullName: string = `${firstName} ${lastName}`

数组

在类型后面加上 [] 或者使用数组泛型 Array<Type>

let list: number[] = [0, 1, 2, 3, 4]
let gen: Array<string> = ['Jay', 'Kylie', 'Tom']

元组 Tuple

表示一个数组, 它的元素类型和数量已知, 并且元素类型存在顺序关系

let jay: [string, number]
jay = ['Jay', 18]
jay = [18, 'Jay'] // 报错

但你访问或赋值越界元素时, 会使用联合类型

jay[3] = 'male' // 'male' 字符串可以赋值给(string | number)联合类型
jay[4].toString() // 不报错, string和number都有toString方法
jay[5] = false // 报错, boolean不是(string | number)联合类型

—- ts 3.1之后的版本访问越界元素会直接报错

枚举 enum

对 JavaScript 标准数据类型的一个补充

enum Color {Red, Green, Blue}
let c: Color = Color.Green
// 默认情况下，从 0 开始为元素编号。 你也可以手动的指定成员的数值
enum Color {Red = 1, Green, Blue}
let c: Color = Color.Green
// 或者，全部都采用手动赋值
enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2]
console.log(colorName)  // 显示'Green'因为上面代码里它的值是2

unknown

我们可能需要描述我们在编写应用程序时不知道的变量类型。这些值可能来自动态内容—例如来自用户—或者我们可能希望有意接受我们的API中的所有值。在这些情况下，我们希望提供一个类型，告诉编译器和未来的读者，这个变量可能是任何东西，所以我们给它 unknown 类型。TypeScript 3.0中引入 unknown 类型

let notSure: unknown = 4;
notSure = "maybe a string instead";
// OK, definitely a boolean
notSure = false;

如果你有一个未知类型的变量，你可以通过做typeof检查、比较检查或者更高级的类型防护来缩小它的范围

declare const maybe: unknown;
// 'maybe' could be a string, object, boolean, undefined, or other types
const aNumber: number = maybe;
Type 'unknown' is not assignable to type 'number'.
if (maybe === true) {
  // TypeScript knows that maybe is a boolean now
  const aBoolean: boolean = maybe;
  // So, it cannot be a string
  const aString: string = maybe;
Type 'boolean' is not assignable to type 'string'.
}
if (typeof maybe === "string") {
  // TypeScript knows that maybe is a string
  const aString: string = maybe;
  // So, it cannot be a boolean
  const aBoolean: boolean = maybe;
Type 'string' is not assignable to type 'boolean'.

any

有时候，我们会想要为那些在编程阶段还不清楚类型的变量指定一个类型。 这些值可能来自于动态的内容，比如来自用户输入或第三方代码库。 这种情况下，我们不希望类型检查器对这些值进行检查而是直接让它们通过编译阶段的检查。

let list: any[] = [1, true, 'free']
list[1] = 100

void

它表示没有任何类型。 当一个函数没有返回值时，你通常会见到其返回值类型是 void

function warnUser(): void {
  console.log('This is my warning message')
}
// 声明一个 void 类型的变量没有什么大用，因为你只能为它赋予 undefined 和 null
let unusable: void = undefined

null 和 undefined

undefined 和 null 两者各自有自己的类型分别叫做 undefined 和 null。 和 void 相似，它们的本身的类型用处不是很大
默认情况下 null 和 undefined 是所有类型的子类型。 就是说你可以把 null 和 undefined 赋值给 number 类型的变量。
然而，当你指定了 --strictNullChecks 标记，null 和 undefined 只能赋值给 void 和它们各自，这能避免 很多常见的问题。 也许在某处你想传入一个 string 或 null 或 undefined，你可以使用联合类型 string | null | undefined

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

tsc xxx.ts --strictNullChecks

never

never 类型表示的是那些永不存在的值的类型。 例如， never 类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型； 变量也可能是 never 类型，当它们被永不为真的类型保护所约束时。
never 类型是任何类型的子类型，也可以赋值给任何类型；然而，没有类型是 never 的子类型或可以赋值给never 类型（除了 never 本身之外）。 即使 any 也不可以赋值给 never

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
  throw new Error(message)
}
// 推断的返回值类型为never
function fail() {
  return error("Something failed")
}
// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
  while (true) {
  }
}

object

object 表示非原始类型，也就是除 number，string，boolean，symbol，null或undefined 之外的类型。
使用 object 类型，就可以更好的表示像 Object.create 这样的 API

declare function create(o: object | null): void
create({ prop: 0 }) // OK
create(null) // OK
create(42) // Error
create('string') // Error
create(false) // Error
create(undefined) // Error