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";

//導(dǎo)出變量
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};
?
//導(dǎo)出函數(shù)
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};//導(dǎo)出多個函數(shù)
?
//函數(shù)別名形式導(dǎo)出
export {a1 as ADD_FUNC ,b1 as DEL_FUNC};
?
//默認導(dǎo)出,一個模塊只能有一個默認導(dǎo)出,不管是類,方法或者是變量
//export default class a{};//默認導(dǎo)出類a后就不能再默認導(dǎo)出函數(shù),或者默認導(dǎo)出變量
//export default function b(){};
let qq=0;
export default qq; //默認導(dǎo)出不能使用 as 別名導(dǎo)出

import {HeadName,MidName,BothDate,X,Y,Z,ADD_FUNC,DEL_FUNC,Add} from "./ExportEx";
export {ADD_FUNC,DEL_FUNC,Add as myAdd} from "./ExportEx";//從導(dǎo)入模塊直接導(dǎo)出方法
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: 這就是類型, 對一個函數(shù)進行約束.
// 利用接口對函數(shù)進行約束, 描述一個函數(shù)的結(jié)構(gòu), 有什么參數(shù), 什么返回值.
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);

// 利用接口定義類的結(jié)構(gòu), 對類中的屬性和方法進行約束.
interface AnimalType {
? aname: string;
? eat(n: string): void;
}

// implements 表示一個類要實現(xiàn)某個接口, 必須按照接口的要求, 實現(xiàn)這個類的內(nèi)部結(jié)構(gòu).
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<T> {
? p: T;
? p1: T;
}

type PTypeOne<T> = {
? p: T;
? p1: T;
};

let pp1: PTypeOne<string> = {
? p: "123",
? p1: "222",
};

let pp2: PType<number> = {
? p: 12,
? p1: 22,
};

let pp3: PType<number[]> = {
? p: [1, 2, 3],
? p1: [4, 5, 6],
};

// 制作泛型函數(shù)
function getValue<T>(a: T, b: T): T {
? return (a as any) + (b as any);
}
console.log(getValue<string>("10", "20"));
console.log(getValue<number>(10, 20));

function getResult<T, Y>(a: T, b: Y): any {
? return (a as any) + (b as any);
}
console.log(getResult<string, number>("10", 20));

// 對于聯(lián)合類型比較長的情況，可以通過type關(guān)鍵字，給這個聯(lián)合類型起個別名(相當(dāng)于自定義了一種新類型)。重用的時候?qū)懫饋矸奖恪?
type baseTypeArr = (number | string | boolean)[];

// number | string | boolean | number[]: 聯(lián)合類型，表示當(dāng)前這個變量，允許接收number/string/boolean/number[]這幾個類型中的一個即可。
type baseType = number | string | boolean | number[];

// 對于初始值可能為null/undefined的類型，也使用聯(lián)合類型約束
declare type dataType = string | undefined;
declare type arrType = number[] | null;

// declare 聲明類型 namespace 命名空間 ，每個命名空間內(nèi)都是獨立作用域，其實就是將不同的類型放到各自的模塊內(nèi)，統(tǒng)一管理。
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標(biāo)識的數(shù)據(jù)，ts會放棄對它的檢查，而是直接通過編譯，ts失效了。一定是在不確定類型/類型不統(tǒng)一是才使用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> = P extends infer P ? keyof P : never
??
? type T = UnionKey<Union>

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]
}

interface Named { name: string }
class Person {
? name: string
}
let p: Named
// ok
p = new Person()

// type '"hello"'
let x = "hello" as const
// type 'readonly [10, 20]'
let y = [10, 20] as const
// type '{ readonly text: "hello" }'
let z = { text: "hello" } as const

? declare global {
? ? interface Window {
? ? ? myCustomFn: () => void;
? ? }
? }

let aaa: [string, number] = ['aaa', 5];
// 添加時不會報錯
aaa.push(6);
// 打印整個元祖不會報錯
console.log(aaa); // ['aaa',5,6];
// 打印添加的元素時會報錯
console.log(aaa[2]); // error

class Animal {
    speak(word: string): string {
        return '動作叫:' + word;
    }
}

class Cat extends Animal {
    speak(word: string): string {
        return '貓叫:' + word;
    }
}

let cat = new Cat();
console.log(cat.speak('hello'));

/**--------------------------------------------**/

function double(val: number): number
function double(val: string): string
function double(val: any): any {
    if (typeof val == 'number') {
        return val * 2;
    }
    return val + val;
}

let r = double(1);
console.log(r);