Category: typescript

export type Dispatch<T> = T extends (...args: infer A) => any ? (...args: A) => void : never;

type T0 = Dispatch<() => string>; // () => void,  里面 A 就是[]
type T1 = Dispatch<(s: string) => void> // (s: string) => void,  A 就是 [string]
type T2 = Dispatch<(<T>(arg: T) => T)>; // (arg: unknow) => void, A 就是[unknow]
type  T3 = Dispatch<object>; // never

 // 这么传跟已知类型传其实没太大区别
type Parameters1<T, R extends Array<any>> = T extends (...args: R) => any ? R : any;
type T4 = Parameters1<(s: string) => void, number[]>;

// 函数类型
interface SearchFunc {
  (source: string, subString: string): boolean;
}

// 对象/方法
type Connected = {
  delay(input: number): string;
  setMessage(action: Date): string;
};

// ******* 类型分配 ******
class EffectModule {
  a = 1;
  b() {

  }
}
interface Action<T> {
  payload?: T;
  type: string;
}
// 获取方法的名称
type MethodName<T> = {[F in keyof T]: T[F] extends Function ? F : never}[keyof T]  
type EE =  MethodName<EffectModule>

type asyncMethod<T, U> = (input: Promise<T>) => Promise<Action<U>> 
type asyncMethodConnect<T, U> = (input: T) => Action<U> 
type syncMethod<T, U> = (action: Action<T>) => Action<U> 
type syncMethodConnect<T, U> = (action: T) => Action<U> 
type EffectMethodAssign<T> = T extends asyncMethod<infer U, infer V>  ? asyncMethodConnect<U, V> : T extends syncMethod<infer U, infer V> ? syncMethodConnect<U, V> : never

type Connect = (module: EffectModule) => {
  [F in MethodName<typeof module>]:EffectMethodAssign<typeof module[F]>
}

//********* */ keyof 用法 **********

interface Itest{
  webName:string;
  age: number;
  address:string;
  dd: never;
}

type ant = keyof Itest; // ant = "webName" | "age" | "address"｜ 'dd'

type d = Itest[keyof Itest] // string | number  , 这里 never 就被剔除

// ********** extends 的 条件类型 *************
// extends 运用在 type 和 class 中时完全是两种作用的效果

// 简单的值匹配
type Equal<X, Y> = X extends Y ? true : false;
type Str = Equal<'a', 'a'>; // true
type Boo = Equal<true, false>; // false
// 简单的类型匹配
type isNum<T> = T extends number ? number : string

//判断联合类型
type A = 'x';
type B = 'x' | 'y';
type Y = A extends B ? true : false; // true

// 当联合类型无法做出判断时
type AB<T> = T extends 'x' ? 'a' : 'b';

type C = AB<'x'>;
// 得到 type C = 'a'
type All = AB<'x' | 'y'>; // 非确定条件，可能是 'x' 或 'y' 
// 得到 type All = 'a' | 'b';

//泛型约束
interface Lengthwise {
  length: number;
  a: string;
}
function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);  // Now we know it has a .length property, so no more error
  return arg;
}

// 
type p = 'length' extends keyof Lengthwise ? true : false; // true;


// *** 高级类型 ***

// Partial<T>, Readonly<T>,
// Record<K extends keyof any, T>,
// Pick<T, K extends keyof T> , 
// Exclude<T, U> 相反的Extract<T, U>
// 排除接口中指定的属性 Omit<T, K extends keyof any> 
type record = Record<'x' | 'y', number>; //{x: number, y; number} 
// NonNullable< T >
type Tp1 = NonNullable<string | null | undefined>; // string

// Parameters 获取函数的全部参数类型，以 元组类型 返回：
// Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
type F1 = (a: string, b: number) => void;
type F1ParamTypes = Parameters<F1>;  // [a:string, b:number]

// ReturnType 接收函数声明，返回函数的返回值类型，如果多个类型则以 联合类型 方式返回
//type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
type F2 = () => Date;
type F1ReturnType = ReturnType<F1>; // Date

// InstanceType 只是这里获取的是 构造函数 的全部参数
// type InstanceType<T extends new (...args: any) => any> = T extends new (...args: any) => infer R ? R : any;

xxx.d.ts
declare module "test" {
  export var value: number;
  export function hello(str: string): String;
}

declare var D2: string;

declare namespace mySpace {
  interface ITest {
    id: number;
  }
}

import test from "test";

test.hello('123');
test.value;

window.D2 = "hello";

const obj: mySpace.ITest = {
  id: 1
};

使用module-function.d.ts 模块,因为 模块可以作为函数调用
var x = require("foo"); // 
// Note: calling 'x' as a function
var y = x(42);

/// <reference types="someLib" />

function getThing(): someLib.thing;

import * as moment from "moment";

function getThing(): moment;

// node.d.ts 文件
declare module "url" {
    export function normalize(p: string): string;
    export function join(...paths: any[]): string;
    export let sep: string;
}

/// <reference path="node.d.ts"/>
import * as URL from "url";
let myUrl = URL.parse("http://www.typescriptlang.org");

//声明文件
declare module "hot-new-module";

//简写模块里所有导出的类型将是any。
//其他文件 模块引入
import x, {y} from "hot-new-module";
x(y);

// In a .d.ts file or .ts file that is not a module:
declare module "SomeModule" {
    export function fn(): string;
}

/// <reference path="myModules.d.ts" />    
// 这里的引用标签指定了外来模块的位置
import * as m from "SomeModule";

export var SomeVar: { a: SomeType };
export interface SomeType {
  count: number;
}

import * as foo from './foo';
let x: foo.SomeType = foo.SomeVar.a;
console.log(x.count);

export var Bar: { a: Bar };
export interface Bar {
  count: number;
}

import { Bar } from './foo';
let x: Bar = Bar.a;
console.log(x.count);

interface Foo {
  x: number;
}
// ... elsewhere ...
interface Foo {
  y: number; // 继续增加
}
let a: Foo = ...;
console.log(a.x + a.y); // OK

class Foo {
  x: number;
}
// ... elsewhere ...
interface Foo {
  y: number; // 往class 增加 y
}
let a: Foo = ...;
console.log(a.x + a.y); // OK

class C {
}
// ... elsewhere ...
namespace C {
  export let x: number;
}
let y = C.x; // OK

class C {
}
// ... elsewhere ...
namespace C {
  export interface D { }
}
let y: C.D; // OK

namespace X {
  export interface Y { }
  export class Z { }
}

// ... elsewhere ...
namespace X {
  export var Y: number;
  export namespace Z {
    export class C { }
  }
}
type X = string;