TypeScript 函数

this类型

一般来说this为方法调用时位于点号左边的对象，this 不由声明方式决定，
而由调用方式决定。call,apply,bind 可以修改函数调用时，this的值。

  //  this类型，可以给函数的this指定类型
function fancyDate(this:Date){

}
// 给this指定类型后就不需要使用apply,call,bind去绑定this了
// fun.apply(this,[])
// fun.call(this,arg1,arg2)
// fun.bind(this,arg1,arg2)()

生成器函数 generator

生成器函数，生成器是惰性的 返回结果是一个可迭代的迭代器
可以理解为生成器是用来生成迭代器的语法糖
说明：惰性求值是函数式编程中的特性，它是指仅在需要时才对表达式求值。

function *createFibonacciGenerator():IterableIterator<number>{
  let [a,b]=[0,1]
  while(true){
    yield a;  //每次迭代器执行next,生成器函数生成 a 并对 表达式求值，你要调用next函数才会求值
    [a,b]=[b,a+b]
  }
}
let FibonacciGenerator=createFibonacciGenerator() // 生成器返回可迭代的迭代器
FibonacciGenerator.next() // 只有当迭代器执行next，开始迭代，生成器才会使用yield生成值
FibonacciGenerator.next() // 每次迭代产出一个值
FibonacciGenerator.next()

迭代器 Iterator与 可迭代的迭代器 IterableIterator

1. 迭代器对象 iterator

// 有 Symbol.iterator属性的对象是迭代器器对象
let range = {
  current: 1,
  target: 5,
  [Symbol.iterator](){
    return this // 这个方法必须返回迭代器
  }
};
// 但是它还不可以使用for...of 迭代，因为它没有实现next方法
// 会报  undefined is not a function 的错误

2. 可迭代的迭代器 IterableIterator

// 实现next 方法让对象可迭代
// 需要注意的是next 方法必须返回{done:true/false,value:...} 这样的数据
// 必须要有done=true 的结束分支，不然for...of会造成死循环
let range = {
  current: 1,
  target: 5,
  [Symbol.iterator](){
    return this
  },
  next(){
    if(this.target>=this.current){
      return {value:this.current++,done:false}  
    }else{
      return {done:true} // done为true 迭代结束，for...of跳出循环
    }
  }
};
for(let res of range){
  console.log(res)
}
// for...of的执行过程，首先执行Symbol.iterator拿到迭代器，然后调用迭代器的next方法

3. 我们来看一下TypeScript 对迭代器的定义
   ts的：拥有 [Symbol.iterator]方法对象是可迭代的，迭代器必须实现next方法
   我的：拥有 [Symbol.iterator]方法对象是迭代器对象，实现了next方法才可迭代
   好吧完全相反！ 每个人的理解都不一样看你们怎么理解了

interface Iterator<T, TReturn = any, TNext = undefined> {
    // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
    next(...args: [] | [TNext]): IteratorResult<T, TReturn>; // 迭代器必须实现next方法
    return?(value?: TReturn): IteratorResult<T, TReturn>;
    throw?(e?: any): IteratorResult<T, TReturn>;
}

interface Iterable<T> {
    [Symbol.iterator](): Iterator<T>;    // 拥有 [Symbol.iterator]方法，对象是可迭代的
}

interface IterableIterator<T> extends Iterator<T> {
    [Symbol.iterator](): IterableIterator<T>;
}

函数类型签名与函数重载

// 函数签名的两种写法
// 简单的写法，与函数表达式一样
type fun=()=>void 

//完整类型签名，使用type 和interface与对象的函数简写方式一样
type FunType2={  
  fun():void
  }
interface type{
  fun(s:string):string
  fun(s:string):boolean
  fun(n:number):number
}
// 使用函数签名实现函数重载
type usertype={
  (id:number):string
  (name:string):string
} 
// 函数实现必须兼容重载签名
let getUsers:usertype=(arg:number|string)=>{
  return ''
}

}