- 类型断言
- 枚举类型
- 泛型
- 函数中使用泛型
- 类中使用泛型
- 泛型中keyof使用
- namespace命名空间
- 定义全局变量
类型断言
interface Bird {
fly:boolean,
flyFun:()=>{}
}
interface Dog {
fly:boolean,
dogFun:()=>{}
}
// 类型断言
function animal(params:Bird|Dog){
if(params.fly){
(params as Bird).flyFun()
}else{
(params as Dog).dogFun()
}
}
// 类型保护 in 语法
function animal2(params:Bird|Dog){
if("flyFun" in params){
params.flyFun()
}else{
params.dogFun()
}
}
枚举类型
enum Result {
one,
tow,
three
}
console.log(Result.one) // 0
console.log(Result.tow) // 1
console.log(Result.three) //2
console.log(Result[1]) // tow
enum Result {
one,
tow=2,
three
}
console.log(Result.one) // 0
console.log(Result.tow) // 2
console.log(Result.three) //3
console.log(Result[2]) // tow
泛型
泛型简单理解为 泛指的类型(generic)
函数中使用类型
// 简单用法
function join<T>(first:T,last:T){
return `${first}${last}`
}
join<string>("hllo","world"); // "hello world"
// 灵活泛型
function map<T>(arr:Array<T>){
console.log(arr)
}
map(<string|number|{[propName:string]:any}>)([123,"123",{name:"this a object"}])
// 多重泛型
function sub<T,P>(first:T,last:P){
console.log(first,last)
}
sub<number,string>(1,"string")
类中使用类型
interface item{
name:string
}
class Xxx<T extends item>{
constructor(private data:T[]){}
getItem(index:number):string{
return this.data[index].name
}
}
let xxx = new Xxx([
{
name:"hello"
}
])
console.log(xxx.getItem(0))
namespace 命名空间
namespace Home { // namespace 会生成全局变量 Home
export class CreateHtml{
constructor(){
}
}
}
定义全局变量
// 定义全局变量
declare var $ : (param:()=>void) = > void
// 定义全局函数 & 函数重载
declare function $(params:()=>void):void;
declare function $(param:string):{html:(html:string)=>{}}
泛型中keyof使用
interface Person {
name:string,
age:number,
gender:string
}
class Teacher{
constructor(private info:Person){}
getInfo<T extends keyof Person>(key:T): Person[T]{
return this.info[key];
}
}
const tercher = new Thacher({
name:'dell',
age:18,
gender:"male"
})
const test = teacher.getInfo("hello")
console.log(test)