Typescript模块的导入导出与继承方式_javascript技巧_

export let x = 8888; export let print = function (x){console.log(x);};

export let x = 8888; export let print = function (x){console.log(x);};

export * as B from "./ModB"; export {H,Hello}  from "./ModB.js"; export {Hello as exp}  from "./ModB.js";

//导出变量 export let HeadName = 'Nance'; export let MidName = 'Jone'; export let BothDate = '2020-12-20';   let [X,Y,Z]=[0,0,0]; export {X,Y,Z};   //导出函数 export function Add(a,b){return a+b;}   function Multiply(x,y){return x * y;} export {Multiply};   function a1(a,b){return a+b;} function b1(a,b){return a-b;}; export {a1,b1};//导出多个函数   //函数别名形式导出 export {a1 as ADD_FUNC ,b1 as DEL_FUNC};   //默认导出,一个模块只能有一个默认导出,不管是类,方法或者是变量 //export default class a{};//默认导出类a后就不能再默认导出函数,或者默认导出变量 //export default function b(){}; let qq=0; export default qq; //默认导出不能使用 as 别名导出

import {HeadName,MidName,BothDate,X,Y,Z,ADD_FUNC,DEL_FUNC,Add} from "./ExportEx"; export {ADD_FUNC,DEL_FUNC,Add as myAdd} from "./ExportEx";//从导入模块直接导出方法 console.log(HeadName,MidName,BothDate); console.log(X,Y,Z); console.log(ADD_FUNC(1,2),DEL_FUNC(3,4)); console.log(Add(5,6));

// (newName: string) => void: 这就是类型, 对一个函数进行约束. // 利用接口对函数进行约束, 描述一个函数的结构, 有什么参数, 什么返回值. interface FunctionType {   (newName: string, newAge: number, test?: string): void; } let setMyName: FunctionType = function (   name: string,   age: number,   a?: string ): void {   console.log(name + age); }; setMyName("新名称", 100); // 利用接口定义类的结构, 对类中的属性和方法进行约束. interface AnimalType {   aname: string;   eat(n: string): void; } // implements 表示一个类要实现某个接口, 必须按照接口的要求, 实现这个类的内部结构. class Animal implements AnimalType {   aname: string;   constructor() {     this.aname = "鸭子";   }   eat(a: string): string {     return "123";   } } let ani = new Animal(); console.log(ani.eat("1"));

// 制作泛型接口, 用T来表示广泛的类型, 就看使用的时候, 传递的是什么类型. interface PType {   p: T;   p1: T; } type PTypeOne = {   p: T;   p1: T; }; let pp1: PTypeOne = {   p: "123",   p1: "222", }; let pp2: PType = {   p: 12,   p1: 22, }; let pp3: PType = {   p: [1, 2, 3],   p1: [4, 5, 6], }; // 制作泛型函数 function getValue(a: T, b: T): T {   return (a as any) + (b as any); } console.log(getValue("10", "20")); console.log(getValue(10, 20)); function getResult(a: T, b: Y): any {   return (a as any) + (b as any); } console.log(getResult("10", 20));

// 对于联合类型比较长的情况，可以通过type关键字，给这个联合类型起个别名(相当于自定义了一种新类型)。重用的时候写起来方便。 type baseTypeArr = (number | string | boolean)[]; // number | string | boolean | number[]: 联合类型，表示当前这个变量，允许接收number/string/boolean/number[]这几个类型中的一个即可。 type baseType = number | string | boolean | number[]; // 对于初始值可能为null/undefined的类型，也使用联合类型约束 declare type dataType = string | undefined; declare type arrType = number[] | null; // declare 声明类型 namespace 命名空间 ，每个命名空间内都是独立作用域，其实就是将不同的类型放到各自的模块内，统一管理。 namespace HomeType {   type homeList = number | string; } declare namespace CateType {   type cateList = number | string; } declare namespace CartType {   type cartList = number | string; } // 自定义类型，叫People类型 // psex?: boolean 表示People类型中的psex属性可有可无 type People = {   page: number;   pname: string;   psex?: boolean | undefined; }; type CommonObject = {   // [propName: string | number]: string | number | boolean; // [propName: string] 接收任意key，且是字符串。   [propName: string | number]: any; // any：让一个变量可以是任意类型的值，被any标识的数据，ts会放弃对它的检查，而是直接通过编译，ts失效了。一定是在不确定类型/类型不统一是才使用any。 }; declare interface MyPeople {   pname: string;   page: number;   psex?: boolean; }

   // 普通枚举    enum Witcher {      Ciri = 'Queen',      Geralt = 'Geralt of Rivia'    }    function getGeraltMessage(arg: {[key: string]: string}): string {      return arg.Geralt    }    getGeraltMessage(Witcher) // Geralt of Rivia      // const枚举    const enum Witcher {      Ciri = 'Queen',      Geralt = 'Geralt of Rivia'    }    const witchers: Witcher[] = [Witcher.Ciri, Witcher.Geralt]    // 编译后    // const witchers = ['Queen', 'Geralt of Rivia'

  type Name = { name: string }   type Age = { age: number }   type Union = Name | Age      type UnionKey
 = P extends infer P ? keyof P : never      type T = UnionKey

type A = {     a: string;     b: number; } type B = {     [K in keyof A]?: A[K] } type C = {     [K in keyof B]-?: B[K] } type D = {     readonly [K in keyof A]: A[K] } type E = {     -readonly [K in keyof A]: A[K] }