八、typescript 高级类型与模块

八、高级类型

 //  别名<T>：type类似于interface
       type con<T>={calue:T}
        
        type tree<T>={
            left:tree<T>;
            right:tree<T>
        }
       
       
       type Link<T> = T&{next:Link<T>}
       interface Person{
        name:string
       }
       
       var peo:Link<Person>
       var s = peo.name
       var s = peo.next.name
       var s = peo.next.next.next.name

  **迭代器和生成器**
 for...of 遍历可迭代的对象.调用对象的Symbol.iterator方法

   //
      let arrr=[1, false,'str']
      for(let enter in arr){
        console.log(enter)  //1  false   'str'
      }
      

  for..of  和 for..in 都是可迭代一个列表，但是迭代的值不同，for..in迭代的是对象的键的列表，而for...of则迭代的是对象的键对应的值

     
      let  list = [ 4, 5, 6]
      
      for(let i  in list){
        console.log(i)    // 0  1   2
      }
      
      for(let i  of list){
        console.log(i)   // 4  5  6
        
      }

  for..in 可以操作任何对象，提供了查看对象熟悉的一种方法，但for...of关注与迭代对象的值，内置对象Map和Set实现了Symbol.iterator方法

    
let pets = new Set(["Cat", "Dog", "Hamster"]); 
pets["species"] = "mammals"; 

for (let pet in pets) {
    console.log(pet); // "species" 
} 

for (let pet of pets) { 
    console.log(pet); // "Cat", "Dog", "Hamster"
}

九、模块
导出: export

export class P{
    a(s:string){
        return a
    }
 }

重命名 as

 export {P}
 export {P as Pserson}
 
 默认导出： export default P

导入：import

 import { P } from  '...'
 import * as all  from '...'
 import '...'

重命名：as

 import { P as Pname} from '...'

 export =  和 import = require()
 //若使用export = 导出一个模块，则必须使用ts特定语法 import module=require('module')来导入此模块
 

 //test
 class P {
    a(s:string){
        return s.length
    }
 }
 export = P
 
 //导入
 import P = require('./test')
 
 //模块声明通配符 *
 declare module "*!test"{
    const content:string;
    export default content;
 }
 
 seclare module "json!*"{
    const content:any;
    export default content
 }
 
 import con from './yyy!text';
 import con from './json!yyyyy'
 
 
// umd模块：
 export function isP(x:number):boolean;
 export as namespace math;
 
 
 import {isP}  from './test'
 isP(2)
 math.isP(2)  //error  不能再模块内使用全局定义 不导入模块不报错