TS ​

// 类型别名和函数很像
type x = (x:string,y:number)=>number

let x1:x = (x,y)=>{
  return y
}

interface x {
  (x:string,y:number):number
} 

let x1:x = (x,y)=>{
  return y
}

// 示例2
interface A1 {
  name: string;
}

interface A2 {
  name: string;
  age: number;
}
// A的类型为string
type A = A2 extends A1 ? string : number;

const a: A = "this is string";

type A = number | 1; // number 
type B = never | string; // string （never 前面说了是所有类型的子类型）

type X3 =   {
  z:string;
  x:number
} & {
  z1:boolean
  readonly z: string;
};

// 合并类型
type C<T> = {
  [k in keyof T]: T[k];
};

// 交叉类型是一个是马老师的粉丝,一个是蔡徐坤的粉丝,他们共有的粉丝是交叉类型
type g3 = C<X3>;

type A<T> = T extends { a: infer U, b: infer U } ? U : any; 
type Foo = A<{ a: number, b: string }> // type Foo = string | number

interface x {
  a: string
  b: string
}

interface y {
  a: string
  c: number
}

type c = x & y

let x2: c = {
  a: "1",
  b: "2",
  c: 2
}

type c = x & y;

type Computed<T> = {
  [K in keyof T] :T[K]
}

// type F = {
//     a: string;
//     b: string;
//     c: number;
// }
type F = Computed<c>

type c1 = x | y;
let x2: c1= {
  a: "1",
  b: "2",
  c: 2,
}

let x2: c1= {
  a: "1",
  b: "2",
}

let x2: c1= {
  a: "1",
  c: 2,
}

interface User {
  name: string;
  age: number;
}
// 重载签名
function test(para: User): number;
function test(para: number, flag: boolean): number;

// 因为 flag 可能没有传值,需要传递 `void`
function test(para: User | number, flag: boolean | void): number {
  return 12;
}

const user = {
  name: "Jack",
  age: 666,
};
// Error: 参数不匹配
const res = test(12, false);

interface Animal {
  name: string;
}

interface Dog extends Animal {
  break(): void;
}

let a: Animal;
let b: Dog;

// 可以赋值，子类型更佳具体，可以赋值给更佳宽泛的父类型
a = b;
// 反过来不行
b = a;

type A = 1 | 2 | 3;
type B = 2 | 3;
let a: A;
let b: B;

// 不可赋值
b = a;
// 可以赋值
a = b;

type Func = (a: string, b: string) => void;

let sum: Func;
// 形参数量比 Func 少
let f1 = (a: string) => {};
// 形参数量比 Func 多，在函数体内可能用到了形参
let f3 = (a: string, b: string, c: string) => {};

sum = f1;
// 错误，函数体还是f3，但是形参是 sum 的
sum = f3;
// sum 的函数体内需要 3 个参数
sum("1", "2");

type Func = () => { name: string; age: number };

let sum: Func;
let f1 = () => {
  return { name: "zs" };
};
let f2 = () => {
  return { name: "zs", age: 20, gender: 1 };
};

// 报错,少一个返回值
sum = f1;

sum = f2;

// 使用的时候,这两个是必须存在的
sum().age / sum.name;

let fn1!: (a: string, b: number) => string;
let fn2!: (a: string, b: number) => string | number | boolean;
fn2 = fn1; // correct 
fn1 = fn2 // error: 不可以将 string|number|boolean 赋给 string 类型

type IParent = () => void;
type IChild = (val: string) => void;

let parentTest: IParent = () => {};
let childTest: IChild = (val) => { console.log(val)};

childTest = parentTest; // ok
parentTest = childTest; // error


let parentTest2: IParent = (val) => { console.log(val)}; // error
let childTest2: IChild = () => { }; // ok

type Bar<T> = T extends { a: (x: infer U) => void; b: (x: infer U) => void }
  ? U
  : never;

type T20 = Bar<{ a: (x: string) => void; b: (x: string) => void }>; // string
type T21 = Bar<{ a: (x: string) => void; b: (x: number) => void }>; // string & number

type X3 = ((x:{a:string})=>any) | ((x:{b:number})=>any);

let X4= function (cb:X3){
  cb({
    a:"a",
    b:10
  })
}

type Foo<T> = T extends () => { a: infer U; b: infer U } ? U : never;

type T10 = Foo<() => { a: string; b: string }>; // string
type T11 = Foo<() => { a: string; b: number }>; // string | number

interface Array<T> {
  concat(...arg: T[]): T[]; // 这种写法会禁止逆变，不去检测 逆变
  // concat:(...arg:T[])=>T[]
}

let p!: Array<Parent>;
let c!: Array<Child>;
p = c;

function getName() {}
namespace getName {
  export const type = "form";
}

console.log(getName.type); // form

const b = () => "hello";
b.id = false;

// 定义类型
const y: { (): string; id: boolean } = b;

// 可以写成下面的这种
type FunctionWithId = {
  (): string;
  id: boolean;
};

const x: FunctionWithId = b;

type ICallBack1 = <T>(item: T, idx: number) => T;

// 使用接口时确定类型，手动传入
type ICallBack<T> = (item: T, idx: number) => T;

//手动传入
let fun: ICallBack<string> = (item, idx) => item;

// 禁止手动传入,因为它的类型就是 T
let fun2: ICallBack1 = (item, idx) => item;

// 当传入一个字符串的时候，T 的类型被确定,返回值是 string 类型
fun2("aaa", 1);

function a ():void{
    obj.name = "zs"
}

let obj  ={
  name:'lisi'  
}

let x = a()

function getPointX(point: { x: number }) {
  return point.x
}

getPointX({ x: 1, y: '2' }) // error 

const point = {
	x: 1,
  y: '2'
}

getPointX(point) // OK 

const sType: {
  [k: `${string}HD`]: any;
} = {
  aHD: "AAA",
};

// type T3 = "top-left" | "top-right" | "bottom-left" | "bottom-right"
type T3 = `${"top" | "bottom"}-${"left" | "right"}`;
// type T4 = 1 | "1" | 2 | 3 | "2" | "3"
type T4 = `${1 | 2 | 3}` | 1 | 2 | 3;

type monthOryear = "month" | "year"
type addOrMinus = "+" | "-"
// type x = "month+" | "month-" | "year+" | "year-"
type x = `${monthOryear}${addOrMinus}`;

const addOrMinus = (monthOryear: "month" | "year", addOrMinus: "+" | "-") => {

  type N = `${"year" | "month"}${"+" | "-"}`

  let map = new Map<N, Function>([])
  
  map.set('year+', function () {})
  map.set('year-', function () {})

  map.set('month+', function () {})

  map.set('month-', function () {})

  let x = `${monthOryear}${addOrMinus}`;

  let fn = map.get(`${monthOryear}${addOrMinus}`); 
  // 被当做一个 string 类型
  let fn2 = map.get(monthOryear+addOrMinus);  
}

type Either2dOr3d = [number, number, number?];
const e: Either2dOr3d = [1, 1];

// 元祖类型，只能有一个数字
let d: [1 | 2 | 3] = [2];

type BooleansStringNumber = [...boolean[], string, number];

const f: BooleansStringNumber = ["1", 1];

// 前面只能是 boolean,或者是不填，不能是其他类型
const f: BooleansStringNumber = [false, 1, "1", 1]; 

// 可以不用写最后的布尔值，固定了位置
type StringNumberBooleans = [string | number, number, ...boolean[]];
let s: StringNumberBooleans = ["a", 12];

type StringNumberBooleans = [name: string, age: number];
let s: StringNumberBooleans = ["a", 12];

abstract class Animal {
  abstract makeSound(): void;
  drink(){
    console.log('喝水')
  }
}

class People {
  name: number|undefined;
  age: number|undefined;
  constructor() {}
  static a(){}
}

// p1可以正常赋值
const p1: People = new People();

// 等号后面的People报错，类型“typeof People”缺少类型“People”中的以下属性: name, age
// const p2: People = People; 


// p3报错，类型 "People" 中缺少属性 "prototype"，但类型 "typeof People" 中需要该属性
// const p3: typeof People = new People(); 
// p4可以正常赋值
const p4: typeof People = People;
p4.a

class Person {
  getP(){
    console.log("Child")
  }
}

class Child extends Person {
  getChild(){
    console.log("Child")
  }
}

let c:Person = new Child;
// c.getChild() 
// c.getP() 

type Y = { a:number } & {}
let x:Y = { a:100 }

// 原理
type NonNullable<T> = T & {};
// null | HTMLElement
let ele = document.getElementById("div");
// 去除 null
type D = NonNullable<typeof ele>; // HTMLElement
//只有 HTMLElement
(ele as D).style.color = "red";

interface Bird {
  fly: string;
}

interface Fish {
  swim: string;
}

function isBird(val: Bird | Fish): val is Bird {
  return "fly" in val;
}

// 是因为 isBird 返回的是一个 boolean 值，所以才需要一个 is 关键字
function test(a: Bird | Fish) {
  if (isBird(a)) {
    a; // Bird
  } else {
  }
}

interface Vibe {
  mood: "happy" | "sad";
}

// vibe.mood: "happy" | "sad"
const vibe: Vibe = {
  mood: "happy",
};

// vibe.mood: "happy"
const vibe = {
  mood: "happy",
} satisfies Vibe; 

type ICustomerImage = {
  height: string;
};

type UserImage = string | ICustomerImage;

interface IUser {
  id: number;
  image: UserImage;
}

const badImage: IUser = {
  id: 1,
  image: "aa",
};

const goodImage = {
  id: 1,
  image: "aa",
} satisfies IUser; 

let r = badImage.image; // 只能获取字符串和 对象的公有方法
r.toString
r.valueOf 

let r1 = goodImage.image; // 就是一个字符串，可以获取字符串的方法
r1.at
r1.search

type Exclude<T, U> = T extends U ? never : T;

type A = Exclude<"key1" | "key2", "key2">; // 'key1'

type A = Exclude<'key1' | 'key2', 'key2'>

// 等价于

type A = Exclude<'key1', 'key2'> | Exclude<'key2', 'key2'>

// =>

type A = ('key1' extends 'key2' ? never : 'key1') 
        |('key2' extends 'key2' ? never : 'key2')

// =>

// never是所有类型的子类型
type A = 'key1' | never = 'key1'

type Extract<T, U> = T extends U ? T : never;

interface A {
  name:string
  age:number
}

interface B {
  address:string
  code:number
}

type C = A | B;

//B
type D = Extract<C, { address:string }>;

type MyReturnType<T extends Function> = T extends (...args: any) => infer R
  ? R
  : never;

type ExcludeType<T extends Array<any>, K extends string | number | boolean> = {
  [P in keyof T]: T[P] extends K ? never : T[P];
}[number];

type Merge<F extends Record<string, any>, S extends Record<string, any>> = {
  [K in keyof F | keyof S]: K extends keyof S
    ? S[K]
    : K extends keyof F
    ? F[K]
    : never;
};

type G1<T> = {
  // 交叉类型限制 类型 相当于取的交集，因为 Capitalize 只接受 string
  // as 重新映射
  [k in keyof T as `get${Capitalize<k & string>}`]?: () => T[k];
};

type D1 = {
  a: never;
  b: never;
  c: string;
};

// 使用 keyof 的意思是 Pick 后面只能使用 'a' | 'b' |'c'
type OmitNever<T> = Pick<
  T,
  { [P in keyof T]: T[P] extends never ? never : P }[keyof T]
>; // { 'name':'zs',age :12 }['name' | 'age'] 'zs'

type Me = { name: "阿宝哥"; city: "XM" }["name" | "city"];
type Me = "阿宝哥" | "XM"; // 先生成映射类型后再利用Lookup Types

interface Example {
  a: string;
  b: boolean;
}

// 可以是 布尔也可以是 字符串
let D: Example["b" | "a"] = false;

// 代表的是一个值
type TrimLeft<V extends string> = V extends ` ${infer R}` ? R : V;
let c: TrimLeft<" abcd"> = "abcd";

// [1, 2, 5, 3, 6]
type L = Flatten<[[1, 2, 5, 3], 6]>;

// 不断递归
type Flatten<T extends any[]> = T extends [infer F, ...infer R]
  ? F extends any[]
    ? [...Flatten<F>, ...Flatten<R>]
    : [F, ...Flatten<R>]
  : T;

// R 指代的第一个字符，infer _ 没有用到
type First<T extends any[]> = T extends [infer R, ...infer _] ? R : never;

// First<[() => 123, { a: string }] == ()=>123

// 具名元祖类型
type First<T extends any[]> = T extends [F: infer R, ...args: infer _]
  ? R
  : never;

type MyParameters<V extends Function> = V extends (s: infer P) => any
  ? P
  : never;

let c: MyParameters<(a: string) => string> = "";

type InstanceType<T extends abstract new (...args: any) => any> =
  T extends abstract new (...args: any) => infer R ? R : any;

class MyClass {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
  getName() {
    return this.name;
  }
}
type MyInstanceType = InstanceType<typeof MyClass>;

const instance: MyInstanceType = new MyClass("Alice", 30);

let x = "hello";

// hurray! we can assign to 'x' later on!
x = "world";

// Type '10'
let x = 10 as const;

// Type 'readonly [10, 20]'
let y = [10, 20] as const;

// Type '{ readonly text: "hello" }'
let z = { text: "hello" } as const;

// Type '10'
let x = <const>10;

// Type 'readonly [10, 20]'
let y = <const>[10, 20];

// Type '{ readonly text: "hello" }'
let z = <const>{ text: "hello" };

// Works with no types referenced or declared.
// We only needed a single const assertion.
function getShapes() {
    let result = [
        { kind: "circle", radius: 100, },
        { kind: "square", sideLength: 50, },
    ] as const;
    
    return result;
}

for (const shape of getShapes()) {
    // Narrows perfectly!
    if (shape.kind === "circle") {
        console.log("Circle radius", shape.radius);
    }
    else {
        console.log("Square side length", shape.sideLength);
    }
}

export const Colors = {
    red: "RED",
    blue: "BLUE",
    green: "GREEN",
} as const;

// or use an 'export default'

export default {
    red: "RED",
    blue: "BLUE",
    green: "GREEN",
} as const;

// 在不确定函数参数的类型时
// 将函数的参数声明为unknown类型而非any
// TS同样会对于unknown进行类型检测，而any就不会
function resultValueBySome(val:unknown) { 
  if (typeof val === 'string') {  
    // 此时 val 是string类型   
    // do someThing 
  } else if (typeof val === 'number') { 
    // 此时 val 是number类型   
    // do someThing  
  } 
  // ...
}

type x2 = string extends unknown ? true : false; // true
type x2 = string extends any ? true : false; // true

let x: any = 1;
x = [];

type P<T> = T extends "x" ? string : number;
type A3 = P<"x" | "y">; // A3的类型是 string | number

// 元祖类型
type WrappedTuple<T> = [T] extends [boolean] ? "Y" : "N";
// 数组类型
type WrappedArray<T> = T[] extends boolean[] ? "Y" : "N";
// Promise
type WrappedPromise<T> = Promise<T> extends Promise<boolean> ? "Y" : "N";
​

type T1 = WrappedTuple<number | boolean>; // "N"
type T2 = WrappedArray<number | boolean>; // "N"
type T3 = WrappedPromise<true | false>; // "Y"

// 重要
type NoDistrubate<T> = T & {}
type UnionAsset<T> =  NoDistrubate<T> extends boolean ? true :false
// 没有分发
type s = UnionAsset<true | false>  // true

type Extract2<T, U> = U extends T ? string : number;

// 'a' extends "a" | 'b' extends "a"  => string | number
type z = Extract2<"a", "a" | 'b'> // string | number

// 'a' extends "a" | 'b'  => string
type z1 = Extract2<"a" | "b" , "a" > // string

enum Seasons {
  Spring = "Spring",
  Summer = "Summer",
}

namespace Seasons {
  export let Autum = "Autum";
  export let Winter = "Winter";
}

let s = Seasons.Autum; 

enum Status {
  SUCCESS = "success",
  DANGER = "danger",
  WARNING = "warning",
}

type StatusKey = keyof typeof Status;
// 'SUCCESS' | 'DANGER' | 'WARNING'

const keyArr: StatusKey[] = ["SUCCESS", "DANGER"]; // passed

type StatusVal = `${Status}`;
// 'success' | 'danger' | 'warning'

const valArr: StatusVal[] = ["success", "danger", "warning"]; // passed

function assert(value: unknown, message?: string): asserts value {
  if (!value) {
    throw new Error(message);
  }
}

function assertNonNull<T>(obj: T): asserts obj is NonNullable<T> {
  if (obj === null || obj === undefined) {
    throw new Error("Assertion failed: Object is null or undefined");
  }
}

function assertNumberArray(value: unknown): asserts value is number[] {
  if (!(value as any[]).every(item => typeof item === "number")) {
    throw new Error();
  }
}

interface Person {
  name:string
  age:number
  address:string
}

type PickKeysByValues<T extends object,U>={
  [K in keyof T as T[K] extends U ? never : K]:T[K]
}
// type C = {
//     age: number;
// }
type C = PickKeysByValues<Person,string>

let result = myLib.makeGreeting("hello, world");
console.log("The computed greeting is:" + result);
let count = myLib.numberOfGreetings;

declare namespace myLib {
  function makeGreeting(s: string): string;
  let numberOfGreetings: number;
}

declare var foo1: number;
declare let foo2: boolean;
declare const foo: string;

declare function foo3(s: string): string;
declare function foo3(s: number): number;

const myGreeter = new Greeter("hello, world");
myGreeter.greeting = "howdy";
myGreeter.showGreeting();
// 静态方法
Greeter.showGreeting2()

class SpecialGreeter extends Greeter {
  constructor() {
    super("Very special greetings");
  }
}

declare class Greeter {
  constructor(greeting: string);
  greeting: string;
  showGreeting(): void;
  static showGreeting2():void
}

import {mock,IMock} from "Mock"
mock({
  "@name": "asdf",
  "@type":12321
})

declare module "Mock" {
  export interface IMock {
    "@name": string;
    "@type": number;
  }
  function mock(option: Partial<IMock>): void;
  export { mock };
}

interface IMock {
  "@name": string;
  "@type": number;
}

type x = 1 | 2 | 3;

let F:HTMLElement  = document.createElement("div"); 
let F1:Element  = document.createElement("div"); 
F1.style 
F.style

interface HTMLElement extends Element, ElementCSSInlineStyle, ElementContentEditable, GlobalEventHandlers, HTMLOrSVGElement {
   hidden: boolean;
   readonly offsetHeight: number;
   readonly offsetLeft: number;
   click(): void;

   addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
   
   removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
}

interface ElementCSSInlineStyle {
    readonly attributeStyleMap: StylePropertyMap;
    readonly style: CSSStyleDeclaration;
}

interface Cat {
  type: "cat";
  breeds: "Abyssinian" | "Shorthair" | "Curl" | "Bengal";
}

interface Dog {
  type: "dog";
  breeds: "Hound" | "Brittany" | "Bulldog" | "Boxer";
  color: "brown" | "white" | "black";
}

type Animal = Cat | Dog;

type cases = [
  Expect<Equal<LookUp<Animal, "dog">, Dog>>,
  Expect<Equal<LookUp<Animal, "cat">, Cat>>
];

//满足分发, 会进行分发
type Extract<T, U> = T extends U ? T : never;
// 必须是 T extends U["type"]
// 因为 T 是联合类型,需要分发
type LookUp<U extends { type: string }, T> = T extends U["type"]
  ? Extract<U, { type: T }>
  : never;

type cases = [
  Expect<Equal<GetRequired<{ foo: number; bar?: string }>, { foo: number }>>,
  Expect<
    Equal<GetRequired<{ foo: undefined; bar?: undefined }>, { foo: undefined }>
  >
];

//  type Required<T> = {
//     [P in keyof T]-?: T[P];
// };

type GetRequired<T> = {
  [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
};

type y = GetRequired<{ foo: number; bar?: string }>;

type cases = [
  Expect<Equal<OptionalKeys<{ a: number; b?: string }>, "b">>,
  Expect<Equal<OptionalKeys<{ a: undefined; b?: undefined }>, "b">>,
  Expect<
    Equal<
      OptionalKeys<{ a: undefined; b?: undefined; c?: string; d?: null }>,
      "b" | "c" | "d"
    >
  >,
  Expect<Equal<OptionalKeys<{}>, never>>
];