typescript 初探之基础类型附ts式求斐波拉切数列

typescript 支持校验 JavaScript 数据类型，比如 number、boolean、string…可以让我们在写程序时清晰地看见各个对象的类型，更规范地编写，更方便地定位错误。
比如这样操作：

let bo: boolean = false;
let num: number = 4;
let name: string = "lisi";

定义数组

• 在元素类型后面加[]，表示由此类型元素组成的一个数组

let arr: number[] = [1, 2, 3, 4];

• 数组泛型，Array<元素类型>

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

定义元组类型
元组类型表示一个已知元素数量和类型的数组，各元素类型可以不同，表示数组中对应位置对应元素的类型。不可设置越界元素。

let arr: [string, number] = ["hello", 5];
console.log(arr[0]); //hello
arr[2] = 4; //报错

定义枚举类型
使用枚举类型可以为数组赋值名称。我们可以把 enum 当成数组来看，Color.Green 默认得到的是索引(0,1,2)，可以自定义枚举值，使用枚举值能够获取枚举名称。

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

自定义枚举值：

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

通过枚举值查找枚举名称：

enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2];

alert(colorName);  // 'Green'

定义联合类型
当使变量可以设置为多种数据类型时，可以使用|来操作，意思是可以接收被设置的这几种类型。例如，a 可以是 string 类型也可以是 number 类型。

let a: string | number = 23; // 这时a可以是字符串也可以是数字

这里需要注意的是使用联合类型时对其他定义类型的影响，例如:

function min(num1: number, num2: number | string): number {
  if (num1 < num2) {
    return num1;
  }
  return num2; // 报错
}

在这里 num2 是联合类型可以接收数字和字符串，但是 min 返回值是 number，所以要将返回值也设置成联合：

function min(num1: number, num2: number | string): number | string {
  if (num1 < num2) {
    return num1;
  }
  return num2; // 报错
}

或者使用 any 类型，意思是接收任意类型数据：

function min(num1: number, num2: number | string): any {
  if (num1 < num2) {
    return num1;
  }
  return num2; // 报错
}

定义任意值类型
有时候我们不知道变量是什么类型，或者不希望 typescript 检测这些值，就可以使用 any :

let data: any; //data可以是任意类型

前面讲了元组类型不能设置越界元素，如果将数组设置为 any 类型，则可以设置越界元素接收任意类型的数值：

let newArr: any = [1, "3", true];
newArr[3] = "abc";
console.log(newArr); // [ 1, '3', true, 'abc' ]

void 类型
any 类型代表什么都接收，那么 void 类型就是它的对立面了，表示什么都没有，它只能接收 undefined 和 null。例如：

let unusable: void = undefined; // 也可以赋值为null

对函数设置 void 类型则表示该函数没有返回值，不应该 return 除了 undefined\null 以外的任何值，空值也不可以：

function test(): void {
  return 123; // 报错
}

null\undefined 类型

null\undefined 相当于 void 的子集，验证一个 null 或者 undefined 的值。

never 类型

never 类型是任何类型的子类型，代表从不会出现的值，在函数中它通常表现为抛出异常或无法执行到终止点（例如无限循环）。

// 运行正确，never 类型可以赋值给 never类型
let x: never = (() => {
  throw new Error("exception");
})();
// 运行正确，never 类型可以赋值给 数字类型
let y: number = (() => {
  throw new Error("exception");
})();
function error(message: string): never {
  throw new Error(message);
}
// 返回值为 never 的函数可以是无法被执行到的终止点的情况
function loop(): never {
  while (true) {}
}

类型断言

类型断言可以用来手动指定一个值的类型：允许变量从一种类型更改为另一种类型。使用<类型>值或者 值 as 类型格式。当 S 类型是 T 类型的子集，或者 T 类型是 S 类型的子集时，S 能被成功断言成 S。这是为了在进行类型断言时提供额外的安全性，完全毫无根据的断言是危险的，如果你想这么做，你可以使用 any。

str 初始是字符串，执行<any>str语句将 string 类型断言为 any 类型，此时 any 类型再断言为 number 类型，string 类型不能直接被断言为 any 类型，可以认为 any 类型里包含 number 类型，而 string 补包含。

let str:string = "1";
let str2: number = <number>(<any>str);
console.log(typeof str2);       // string

str3 初始设置为 any 类型，即 str3 为任意类型。当执行str2 as string语句后，str3 就为 string 类型。

let str3: any = "string";
let strLength: number = (str3 as string).length;     // 将str断言为string类型
console.log(strLength)     // 6

在使用联合类型过程中使用断言：

function foo(data: number | string): void {
  if ((data as string).length) {
    console.log(`one: + ${typeof data} + ${data}`);
  } else {
    console.log(`two: + ${typeof data} + ${data}`);
  }
}
foo(1);   // two: + number + 1
foo("a");   // one: + string + a

斐波拉切 DOME

function fibo(max: number | string): number[] {
  let b: number[] = [];
  if ((max as string).length) {
    max = Number(max);
  }
  for (let i = 0; i < max; i++) {
    if (i < 2) {
      b.push(1);
    } else {
      b.push(b[b.length - 1] + b[b.length - 2]);
    }
  }
  return b;
}
console.log(fibo("10"));