TypeScript 文档

TypeScript 文档

基础类型

布尔值

let isDone: boolean = false;

数字

let decLiteral: number = 6; //十进制
let hexLiteral: number = 0xf00d; //十六进制
let binaryLiteral: number = 0b1010; //二进制
let octalLiteral: number = 0o744; //八进制

字符串

// 普通字符串
let name: string = "bob";
name = "smith";
// 使用模板字符串
let name: string = `Gene`;
let sentence: string = `Hello, my name is ${
   name}.

数组

let list: number[] = [1, 2, 3];
// 使用数组泛型，Array<元素类型>
let list: Array<number> = [1, 2, 3];

元组 Tuple

// 声明一个元组类型
let x: [string, number];
// 初始化它
x = ["hello", 10]; // OK
// 初始化错误
x = [10, "hello"]; // Error

// 当访问一个越界的元素，会使用联合类型替代
x[3] = "world"; // OK, 字符串可以赋值给(string | number)类型
x[5].toString(); // OK, 'string' 和 'number' 都有 toString
x[6] = true; // Error, 布尔不是(string | number)类型

枚举

enum Color {
   
  Red,
  Green,
  Blue,
}
let c: Color = Color.Green;

// 默认情况下，从0开始为元素编号。 你也可以手动的指定成员的数值
enum Color {
   
  Red = 1,
  Green,
  Blue,
}
let c: Color = Color.Green;

Any

// 那些在编程阶段还不清楚类型的变量指定一个类型
let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, 定义一个布尔值

Void

// void类型像是与any类型相反，它表示没有任何类型
function warnUser(): void {
   
  console.log("This is my warning message");
}
// 声明一个void类型的变量没有什么大用，因为你只能为它赋予undefined和null
let unusable: void = undefined;

Null 和 Undefined

// undefined和null两者各自有自己的类型分别叫做undefined和null
// 我们不能给这些变量赋值了!
let u: undefined = undefined;
let n: null = null;

Never

// never类型表示的是那些永不存在的值的类型
// never类型是任何类型的子类型，也可以赋值给任何类型
// 没有类型是never的子类型或可以赋值给never类型（除了自己），即使是any也不可以
// 返回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表示非原始类型
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

类型断言

// 这个的 < > 加前面，数组那个加后面
// 你会比TypeScript更了解某个值的详细信息
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
// 另一个为as语法
// 当你在TypeScript里使用JSX时，只有 as语法断言是被允许的
let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;

变量声明

变量声明+解构 都比较熟悉了就不写了

接口 interface

接口初探

// 使用接口来描述：必须包含一个label属性且类型为string
interface LabelledValue {
   
  label: string;
}

function printLabel(labelledObj: LabelledValue) {
   
  console.log(labelledObj.label);
}

let myObj = {
    size: 10, label: "Size 10 Object" };
printLabel(myObj);

可选属性 option bags 模式

// 带有可选属性的接口与普通的接口定义差不多，
// 只是在可选属性名字定义的后面加一个?符号
interface SquareConfig {
   
  color?: string;
  width?: number;
}

function createSquare(config: SquareConfig): {
    color: string; area: number } {
   
  let newSquare = {
    color: "white", area: 100 };
  if (config.color) {
   
    newSquare.color = config.color;
  }
  if (config.width) {
   
    newSquare.area = config.width * config.width;
  }
  return newSquare;
}

let mySquare = createSquare({
    color: "black" });

只读属性 readonly

做为变量使用的话用 const，若做为属性则使用 readonly

// 一些对象属性只能在对象刚刚创建的时候修改其值
interface Point {
   
  readonly x: number;
  readonly y: number;
}
let p1: Point = {
    x: 10, y: 20 };
p1.x = 5; // error!

// TypeScript具有ReadonlyArray<T>类型，它与Array<T>相似
let a: number[] = [1, 2, 3, 4];
let ro: ReadonlyArray<number> = a;
ro[0] = 12; // error!
ro.push(5); // error!
ro.length = 100; // error!
a = ro; // error!
// 可以用类型断言重写 a = ro
a = ro as number[]; //okey

额外的属性检查

interface SquareConfig {
   
  color?: string;
  width?: number;
}

function createSquare(config: SquareConfig): {
    color: string; area: number } {
   
  // ...
}

// error: 'colour' not expected in type 'SquareConfig'
let mySquare = createSquare({
    colour: "red", width: 100 });

函数类型

interface SearchFunc {
   
  (source: string, subString: string): boolean;
}

let mySearch: SearchFunc;
// 函数的参数名不需要与接口里定义的名字相匹配function(src: string, sub: string)
mySearch = function (source: string, subString: string) {
   
  let result = source.search(subString);
  return result > -1;
};

可索引的类型

interface StringArray {
   
  [index: number]: string