[TypeScript] - TypeScript官方文档学习笔记-基本类型（一）

ゝ一纸荒年。 2023-02-21 06:23 8阅读 0赞

[TypeScript该部分文档地址][TypeScript]

# 基本类型 #

*  boolean
 *  number
 *  string
 *  Array
 *  Tuple
 *  enum
 *  any
 *  void
 *  null & undefined
 *  never
 *  object

## Boolean ##

let a: boolean = false;

## Number ##

与`JS`同，所有数值都为浮点，支持多种进制。

let decimal: number = 6;
    let hex: number = 0xf00d;//十六进制
    let binary: number = 0b1010;//二进制
    let octal: number = 0o744; //八进制

## String ##

用`"`和`'`包裹。

let color: string = "blue";
    color = 'red';

可以用字符串模板，反引号包裹，`${}`引用变量。与`js`同

let fullName: string = `Bob Bobbington`;
    let age: number = 37;
    let sentence: string = `Hello, my name is ${ fullName }.
    
    I'll be ${ age + 1 } years old next month.`;

## Array ##

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

## Tuple - 元组 ##

用固定数量，已知类型的元素表示数组

// 定义元组
    let x: [string, number];
    // 初始化
    x = ["hello", 10]; // OK
    // 不正确的初始化
    x = [10, "hello"]; // Error

## Enum - 枚举 ##

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];

## Any ##

若希望变量为动态类型，使用`any`不进行类型检查

let notSure: any = 4;
    notSure = "maybe a string instead";
    
    let list: any[] = [1, true, "free"];
    list[1] = 100;

## Void ##

通常作为函数返回值标识。

function warnUser(): void {
        console.log("This is my warning message");
    }

修饰变量显得不必要。被修饰的变量只能为`null,undefined`

let unusable: void = undefined;
    unusable = null; // OK if `--strictNullChecks` is not given

## Null & Undefined ##

类似`void`，不太有用

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

默认情况下，`null`和`undefined`是所有其他类型的子类型。

但是，当使用`--strictNullChecks`时，`null`和`undefined`只能分配给`any`和各自的类型（一个例外：`undefined`是也可以分配给`void`）。这有助于避免*许多*常见错误。如果要传递一个 `string`或`null`or `undefined`，则可以使用并集类型`string | null | undefined`。

## Never ##

never类型表示永远不会出现的值的类型。例如，never是一个函数表达式的返回类型，或者一个总是抛出异常的箭头函数表达式，或者一个永不返回的函数表达式。

never类型是每一个类型的子类型，并且可以分配给每一个类型；但是，没有任何类型是never的子类型，或者可以分配给never（除了never本身）。即使是 any 也不能分配给 never。

// 返回never的方法必须有无法到达的终点
    function error(message: string): never {
      throw new Error(message);
    }
    
    // Inferred return type is never
    function fail() {
      return error("Something failed");
    }
    
    // Function returning never must have unreachable end point
    function infiniteLoop(): never {
      while (true) {}
    }

## Object ##

declare function create(o: object | null): void;
    
    create({ prop: 0 }); // OK
    create(null); // OK

## 类型断言 ##

有时你会在一个情况下，你会比`TypeScript`更了解一个值。通常，当你知道某个实体的类型可能比它的当前类型更具体时，就会发生这种情况(泛型)。

类型断言是一种告诉编译器 "相信我，我知道我在做什么 "的方式。类型断言就像其他语言中的类型转换一样，但不执行特殊的检查或数据重组。它对运行时没有影响，纯粹由编译器使用。`TypeScript`假设你，已经执行了任何你需要的特殊检查。

let someValue: any = "this is a string";
    let strLength: number = (<string>someValue).length;
    
    // 或者使用as
    let someValue: any = "this is a string";
    let strLength: number = (someValue as string).length;

> 这两个样本是等价的。使用一个而不是另一个主要是偏好的选择；然而，当`TypeScript`与`JSX`一起使用时，只允许使用`as-style assertions`。

[TypeScript]: https://www.typescriptlang.org/docs/handbook/basic-types.html