ts / 基础类型 && 类型断言 && 变量声明 （一）

ts / 基础类型 && 类型断言 && 变量声明

基础类型

原始类型

let isDone: boolean = false;
let decLiteral: number = 6;
let name: string = "bob";

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

元祖

元组类型允许表示一个已知元素数量和类型的数组

let x: [string, number];

枚举

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

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

c==2

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

console.log(colorName);  // 显示'Green'因为上面代码里它的值是2

function warnUser(): void{  }
无返回值的函数

类型断言

let strLength: number = (<string>someValue).length;
let strLength: number = (someValue as string).length;

变量声明

var

• var声明会被提升
• var可以反复声明

for && setTimeout && var

当在for中包裹延时函数时，延时函数会在一段时间后输出变量最后的值，一个通常的解决方法是使用立即执行的函数表达式（IIFE）来捕获每次迭代时i的值

for (var i = 0; i < 10; i++) {
    // capture the current state of 'i'
    // by invoking a function with its current value
    (function(i) {
        setTimeout(function() { console.log(i); }, 100 * i);
    })(i);
}

let

• 不会提升
• 不能重复声明
• 块级作用域

for && setTimeout && let

当let声明出现在循环体里时拥有完全不同的行为。 不仅是在循环里引入了一个新的变量环境，而是针对 每次迭代都会创建这样一个新作用域。 这就是我们在使用立即执行的函数表达式时做的事，所以在 setTimeout例子里我们仅使用let声明就可以了。

for (let i = 0; i < 10 ; i++) {
    setTimeout(function() {console.log(i); }, 100 * i);
}

const

它们拥有与 let相同的作用域规则，但是不能对它们重新赋值。

解构数组

全解构

let input = [1, 2];
let [first, second] = input;

交换变量

[first, second] = [second, first];

参数解构

function f([first, second]: [number, number]) {
    console.log(first);
    console.log(second);
}
f(input);

跳跃解构 && 收集剩余参数

let [first, ...rest] = [1, 2, 3, 4];
console.log(first); // outputs 1
console.log(rest); // outputs [ 2, 3, 4 ]

let [, second, , fourth] = [1, 2, 3, 4];

对象解构

解构为变量

let { a, b } = o;

可以用没有声明的赋值，但需要用括号将它括起来。

({ a, b } = { a: "baz", b: 101 });

收集剩余变量 && 属性重命名

let { a, ...passthrough } = o;

let { a: newName1, b: newName2 } = o;
// 等同于
// let newName1 = o.a;
// let newName2 = o.b;

指明类型的解构

let {a, b}: {a: string, b: number} = o;

默认值

function keepWholeObject(wholeObject: { a: string, b?: number }) {
    let { a, b = 1001 } = wholeObject;
}

function f({ a, b = 0 } = { a: "" }): void {
    // ...
}
f({ a: "yes" }); // ok, default b = 0
f(); // ok, default to {a: ""}, which then defaults b = 0
f({}); // error, 'a' is required if you supply an argument

ts声明对象

obj : { [name: string]: string } ={
	key: value
}