ts基础学习

// https://segmentfault.com/q/1010000021160333?utm_source=sf-similar-question

 

// interface Test {

// one: boolean

// two: string

// }

// declare type K = keyof Test

// function foo<K extends keyof Test>(key: K, val: Test[K]) {

// //

// }

 

function sun(a: number, b: number): number {

return a + b

}

 

let b: "male" | "female" //用字面量赋值代表只能是这两个值的其中一个

 

b = "hello" //否则就会报错

 

let c: boolean | string; //联合类型

 

let d: number;

let e: any

e = 'hello'

d = e //any可以赋值给任何类型的变量,但是unknown不能被赋值给另个有类型变量,除非用类型判断或断言

 

let obj1: object

obj1 = function () { } //如果我们直接指定obj是一个对象类型,那么function,arrray都是对象

 

let obj2: { aaa: string } //如果这么指定,那么这个对象里面必须有且仅有一个aaa的属性

obj2 = function () { }

 

let obj3: { aaa: string, bbb?: number }

obj3 = { aaa: 'aa' }

 

let fn: (a: number, b: number) => number //给函数做限制

fn = function (a, b, c) {

return a + b

}

 

let arr: string | number[]

arr = [1]

 

let tup: [string, number] //元祖tuple代表长度固定的数组

 

enum Gender {

Male = 0,

Female = 1

}

let human: { name: string, gender: Gender }

human = {

name: "a",

gender: Gender.Male //这个时候gender属性是0

}

//类型别名,这样可以让我们的类型可以复用

type myType = 1 | 2 | 3 | 4 | 5

let num1: myType

let num2: myType

 

type fnType = (a: number, b: number) => number

let fn1: fnType

let fn2: fnType

 

//interface是用来定义object的,是可以重复声明的,等于合并了,并且接口里面的属性和方法不能有实际的实现

//只能用来定义类型.

interface myObject {

name: string,

sayHello: () => number

}

interface myObject {

age: number

}

//接口可以用来限制class也可以限制实例

class MyObject implements myObject {

name = "name"

age = 18

sayHello() { return 1 }

}

let obj: myObject

 

class Test {

//语法糖,等价于类里面有个public a属性

constructor(public a: string) { }

}

 

function test<T>(a: T): T { return a }

test(10)

test<string>('')

 

interface MyTest {

length: number

}

//意识是传进人的参数必须extends了MyTest这个接口

function test1<T extends MyTest>(a: T): number {

return a.length

}

test1({

length: 2

})

//生成tsconfig可以使用tsc --init有了tsconfig文件之后,执行tsc或者tsc -w就会对所有ts文件生效