TypeScript学习笔记（一）

变量声明

// 变量声明 var const let
var const let

基础类型

// 布尔值
let isDone: boolean = false

// 数字
let decLiteral: number = 6

// 字符串
let name2: string = "bob"

// 数组
let list: number[] = [1, 2, 3]
let list2: Array<String> = ['1', '2', '3']

// 元组
let x: [string, number] = ['hello', 10]
// 枚举 经测试：里面的值暂只能是number和string类型、若是为number类型，例如Blue=3，则可通过:string = Color[3]获取枚举名
enum Color { Red = '1', Green = '2', Blue = 3, yellow = 4, pink = '5' }
let c: Color = Color.Green
let colorName: string = Color[3]

// Any 动态类型
let notSure: any = 4
notSure = "maybe a string instead"
notSure = false
// 使用数组时，元素是不同类型的
notSure = [1, 2, '3', { a: 1 }]

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

// Null 和 Undefined
let u1: number = undefined
let n1: number = null

// Never
// 返回never的函数必须存在无法达到的终点、后续代码不执行（例如error、死循环等）

function error(message: string): never {
    throw new Error(message)
}
function fail() {
    return error("Something failed")
}

function infiniteLoop(): never {
    while (true) {

    }
}

// 对象
let o: object = { a: 1, b: 2, c: 3, d: [{ da: 1 }, 2], e: { ea: 1, eb: 2 } }

函数

// 函数
function add(x: number, y?: number): number {
    return x + y
}

let myAdd = function (x: string = '3', ...y: string[]): string {
    return x + ' ' + y.join(' ')
}

泛型

function identity<T>(arg: T): T {
    return arg
}
const output = identity<string>("myString")

高级类型

// 交叉类型
function extend<T, U>(first: T, second: U): T & U {
    let result = <T & U>{}
    for (let id in first) {
        (<any>result)[id] = (<any>first)[id]
    }
    for (let id in second) {
        if (!result.hasOwnProperty(id)) {
            (<any>result)[id] = (<any>second)[id]
        }
    }
    return result
}

class Person {
    constructor(public name: string) { }
}
interface Loggable {
    log(): void
}
class ConsoleLogger implements Loggable {
    log() {
        console.log(this)
    }
}
const jim = extend(new Person("Jim"), new ConsoleLogger())
const n = jim.name
jim.log()
const a = extend('1', false)

// 联合类型
function padLeft(value: string, padding: string | number): object {
    const result: object = { value, padding }
    return result
}
const indentedString = padLeft("Hello world", 1)

Symbols

// 对象属性
const sym = Symbol('key')
const obj: object = {
    [sym]: "value"
}
console.log(obj[sym])

// 类成员属性
const getClassNameSymbol = Symbol()
class C {
	 // Symbol成员属性
    [getClassNameSymbol](): string {
        return "C1d"
    }
    // symbols列表
    [Symbol.hasInstance](instance): Boolean {
        console.log('instance:', instance)
        return Array.isArray(instance)
    }
    [Symbol.search](string: string): number {
        console.log('string:', string)
        return 1
    }
}
const class1 = new C()
const className = class1[getClassNameSymbol]
const className1 = className()
console.log('className1:', className1)
console.log('Symbol.hasInstance:', [] instanceof <any>new C)
console.log('Symbol.search:', 'C2112'.search(<any>class1))