八、高级类型
// 别名<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 不能再模块内使用全局定义 不导入模块不报错