TypeScript 学习笔记（一）- 基本类型

一、原始数据类型

布尔值

布尔值是最基础的数据类型，在 TypeScript 中，使用 boolean 定义布尔值类型

let isTrue: boolean = false;

数值

使用 number 定义数值类型

let num: number = 1;

字符串

使用 string 定义字符串类型

let name: string = "Tom";

Null 和 Undefined

可以使用 null 和 undefined 来定义这两个原始数据类型

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

二、任意值 any

任意值（Any）用来表示允许赋值为任意类型。
any 类型可以在赋值过程中任意改变类型

  const num: number = 1;
  const str: string = '1';
  let param: any;
  param = num;
  param = str;

声明一个变量为任意值之后，对它的任何操作，返回的内容的类型都是任意值。

三、 联合类型

一个变量可以同时支持一种类型或者多种不同的类型，不同类型之间使用 ｜来分割

let union: number | string
union = 1;
union = "1";
union = true; // error 出错，不能是number和string之外的其他类型

四、数组类型

在 TypeScript 中，数组类型有多种定义方式，比较灵活。

数组

最简单的方法是使用「类型 + 方括号」来表示数组：

let strArray: string[];
strArray = ['1', '2'];

数组泛型

我们也可以使用数组泛型来表示数组：

let numberArray: Array<number> = [1, 1, 2, 3, 5];

数组接口

接口也可以用来描述数组：

interface numberArray {
    [index: number]: number;
}
let fibonacci: numberArray = [1, 1, 2, 3, 5];

NumberArray 表示：只要索引的类型是数字时，那么值的类型必须是数字。

虽然接口也可以用来描述数组，但是我们一般不会这么做，因为这种方式比前两种方式复杂多了。

元组（Tuple）

数组合并了相同类型的对象，而元组（Tuple）合并了不同类型的对象。

元组就是固定长度、固定类型的数组，注意一定要指明类型

let strArray: [number, string];
strArray = [1, '2'];

五、void

使用 void 来表示一个函数没有一个返回值

function log(msg: string): void {
  console.log(msg);
}

六、never

一个函数永远执行不完，一般用于错误抛出

function throwError(message: string, errorCode: number): never {
	throw {
		message,
		errorCode,
	}
}

七、字面量类型

字面量类型用来约束取值只能是某几个字符串中的一个。

const a = 3
const b = 0 | 1 | 2
const c = 'a' | 'b' | 'c'

注意，类型别名与字符串字面量类型都是使用 type 进行定义。

八、枚举

枚举（Enum）类型用于取值被限定在一定范围内的场景，比如一周只能有七天，颜色限定为红绿蓝等。

enum Color {
	red,
	green,
	blue
}

let color = Color.blue
console.log(color) // 2

enum Color {
	red = "red",
	green = "green",
	blue = "blue"
}

let color = Color.blue
console.log(color) // "blue"

九、接口

它能合并众多类型声明至一个类型声明

interface Name {
  first: string;
  second: string;
}

let name: Name;
name = {
  first: 'John',
  second: 'Doe'
};

定义的变量比接口少了一些属性，或者多一些属性都是不允许的

name = {
  // Error: 'Second is missing'
  first: 'John'
};

name = {
  // Error: 'Second is the wrong type'
  first: 'John',
  second: 1337
};

name = {
// Error: 'third' does not exist in type 'Name'
  first: 'John',
  second: 'Doe',
  third: '1'
};

十、泛型（Generics）

泛型是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。

let list1: number[] = [1,2,3,4]
let list2: Array<string> = [1,2,3,4]

let  lastInArray = <T>(arr: T[]) => {
	return arr[arr.length - 1];
}

let l1 = lastInArray([1,2,3,4])
let l2 = lastInArray<string>(['a', 'b', 'c'])
let l3 = lastInArray<string | number>(['a', 'b', 'c'])

多个类型参数

定义泛型的时候，可以一次定义多个类型参数：

function swap<T, U>(tuple: [T, U]): [U, T] {
    return [tuple[1], tuple[0]];
}

swap([7, 'seven']); // ['seven', 7]
swap<string, number>(['1', 1])

十一、类型相关

类型推论

如果没有明确的指定类型，那么 TypeScript 会依照类型推论（Type Inference）的规则推断出一个类型。

let age = "7";
// 等价于
let age: string = "7"

如果定义的时候没有赋值，不管之后有没有赋值，都会被推断成 any 类型而完全不被类型检查。

let myFavoriteNumber;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;

类型断言

类型断言（Type Assertion）可以用来手动指定一个值的类型。

值 as 类型
或者
<类型>值

在 tsx 语法（React 的 jsx 语法的 ts 版）中必须使用前者，即 值 as 类型。

类型别名

类型别名用来给一个类型起个新名字。

type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;
function getName(n: NameOrResolver): Name {
    if (typeof n === 'string') {
        return n;
    } else {
        return n();
    }
}

类型别名常用于联合类型。

参考链接
2小时极速入门 TypeScript
TypeScript入门教程
深入理解 TypeScript