semlinker / awesome-typescript Goto Github PK

A collection of awesome TypeScript resources for client-side and server-side development

typescript awesome-list vue-typescript react-typescripts

awesome-typescript's Introduction

Awesome TypeScript

TypeScript is a free and open source programming language developed by Microsoft. It is a superset of JavaScript and essentially adds optional static typing and class-based object-oriented programming to the language.

Awesome TypeScript inspired by dzharii/awesome-typescript，Thanks dzharii。

The resources of this article are mainly from the following websites：

Chinese | English

Welcome to the Mastering TypeScript series. This series will introduce the core knowledge and techniques of TypeScript in the form of animations. Let's learn together! Previous articles are as follows:

Awesome TypeScript
- Contents
- TypeScript Tutorials
  - Features
  - Chinese
  - English
    - Features
    - Tutorials
    - Samples
    - Guide
    - Awesome
- TypeScript Starters/Boilerplates
- TypeScript Design patterns
- TypeScript Videos
  - Chinese
  - English
- TypeScript QA
- TypeScript Books
  - Chinese
  - English
- TypeScript Tools/Libraries/frameworks
  - Build
    - webpack
    - gulp
    - grunt
    - compiler
    - linter
  - Ioc
  - Doc
  - Data Structure
  - Database
  - Server
- TypeScript IDE
  - Offline
    - IDE/Plugins
  - Online
    - Playground
    - Chrome Extension
- Contributing
  - Guide

TypeScript Tutorials

Features

Chinese

Beginner

Advanced

Practical

Angular

Vue

React

React Native

胡桓铭 - React Native 与 TypeScript 在企业开发中的实践

Wechat

Guyoung - 使用 TypeScript 开发微信小程序

Node.js

English

Features

Tutorials

Samples

Guide

Awesome

TypeScript Starters/Boilerplates

TypeScript Design patterns

TypeScript Videos

Chinese

English

TypeScript QA

TypeScript Books

Chinese

English

TypeScript Tools/Libraries

Build

webpack

gulp

ivogabe - gulp-typescript

grunt

TypeStrong - grunt-ts

compiler

linter

palantir - tslint

Ioc

Doc

TypeStrong - typedoc

Data Structure

Database

Server

TypeScript IDE

Offline

IDE/Plugins

Online

Playground

Chrome Extension

OctoLinker

Contributing

We welcome your contributions 🌺

Guide

Please make sure to add your item in the correct section.
Always add new items at the end of the list. The format should be consistent with the current section's items.
If you feel that some items are in the wrong section or you need to add a new section, please feel free to edit.

⬆ Go To Top

awesome-typescript's People

Contributors

Stargazers

Watchers

Forkers

jiaozheng lingxiaoluo coderew starkmore ljjcherry js-proj duanshuaimin qingbeefed guoxiangwen liaoyongfu parsedark hj3938 mikecodemikelife hhy5277 ssh-shashi linlazy shaunstanislauslau jerry-chow styfle windofthesky chasingsnail 359887612 gordonruizean mtwebui chocogo biborn allensmile awesome-archive bsyslient hunglethanh9 shoubogao yynice shirleylsm lpove cybernetics chrispinzaru lovememo dwqyun 06094051 zkbl logcas abbyjl guofazhan yishengyouni accr gardenliu ciki6 floatsword jkchao rkweb lichengtao1989 fenglianshuai jacksplwxy objectivezhou momoirocloverz llz93 keekuun ghostrin caojiaxin lyluyi leonardo-zyh nthompson196 lusinga lailashiyanti9 daisyfeng128128 meatroll huchun666 uiyin lzchuanmr yansideyu liangchaofei justsysy mrmengj yqoo ccy303 mapwaylabs wangshuaifeng zdq1111 alcantara6 angelxg miroslavpetrik kamahl19 iszoe magina000 adam-hanna liwenkangatom heptaluan sunweiconfidence ok2fly wsl66 wyh888 journeyc hglvan manydots wangshuaixue knifelly tongzhenyu0312 talljack chengling0824 ts-team

awesome-typescript's Issues

「重学TS 2.0 」TS 练习题第十二题

实现一个 Head 工具类型，用于获取数组类型的第一个类型。具体的使用示例如下所示：

type Head<T extends Array<any>> = // 你的实现代码

// 测试用例
type H0 = Head<[]> // never
type H1 = Head<[1]> // 1
type H2 = Head<[3, 2]> // 3

提示：该题目有多种解法，感兴趣小伙伴可以自行尝试一下。
请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第三十八题

实现 StartsWith 工具类型，判断字符串字面量类型 T 是否以给定的字符串字面量类型 U 开头，并根据判断结果返回布尔值。具体的使用示例如下所示：

type StartsWith<T extends string, U extends string> = // 你的实现代码

type S0 = StartsWith<'123', '12'> // true
type S1 = StartsWith<'123', '13'> // false
type S2 = StartsWith<'123', '1234'> // false

此外，继续实现 EndsWith 工具类型，判断字符串字面量类型 T 是否以给定的字符串字面量类型 U 结尾，并根据判断结果返回布尔值。具体的使用示例如下所示：

type EndsWith<T extends string, U extends string> = // 你的实现代码

type E0 = EndsWith<'123', '23'> // true
type E1 = EndsWith<'123', '13'> // false
type E2 = EndsWith<'123', '123'> // true

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第四十二题

实现 IndexOf 工具类型，用于获取数组类型中指定项的索引值。若不存在的话，则返回 -1 字面量类型。具体的使用示例如下所示：

type IndexOf<A extends any[], Item> = // 你的实现代码

type Arr = [1, 2, 3, 4, 5]
type I0 = IndexOf<Arr, 0> // -1
type I1 = IndexOf<Arr, 1> // 0
type I2 = IndexOf<Arr, 3> // 2

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第三题

第三题

在掌握 TS 这些工具类型，让你开发事半功倍这篇文章中，阿宝哥介绍了 TS 内置的工具类型：Partial<T>，它的作用是将某个类型里的属性全部变为可选项 ?。

interface Todo {
  title: string;
  description: string;
}

function updateTodo(todo: Todo, fieldsToUpdate: Partial<Todo>) {
  return { ...todo, ...fieldsToUpdate };
}

// lib.es5.d.ts
type Partial<T> = {
  [P in keyof T]?: T[P];
};

那么如何定义一个 SetOptional 工具类型，支持把给定的 keys 对应的属性变成可选的？对应的使用示例如下所示：

type Foo = {
	a: number;
	b?: string;
	c: boolean;
}

// 测试用例
type SomeOptional = SetOptional<Foo, 'a' | 'b'>;

// type SomeOptional = {
// 	a?: number; // 该属性已变成可选的
// 	b?: string; // 保持不变
// 	c: boolean; 
// }

在实现 SetOptional 工具类型之后，如果你感兴趣，可以继续实现 SetRequired 工具类型，利用它可以把指定的 keys 对应的属性变成必填的。对应的使用示例如下所示：

type Foo = {
	a?: number;
	b: string;
	c?: boolean;
}

// 测试用例
type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
// type SomeRequired = {
// 	a?: number;
// 	b: string; // 保持不变
// 	c: boolean; // 该属性已变成必填
// }

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第二十七题

实现一个 Reverse 工具类型，用于对元组类型中元素的位置颠倒，并返回该数组。元组的第一个元素会变成最后一个，最后一个元素变成第一个。

type Reverse<
  T extends Array<any>,
  R extends Array<any> = []
> = // 你的实现代码

type R0 = Reverse<[]> // []
type R1 = Reverse<[1, 2, 3]> // [3, 2, 1]

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第二十题

实现一个 Curry 工具类型，用来实现函数类型的柯里化处理。具体的使用示例如下所示：

type Curry<
  F extends (...args: any[]) => any,
  P extends any[] = Parameters<F>, 
  R = ReturnType<F> 
> = // 你的实现代码

type F0 = Curry<() => Date>; // () => Date
type F1 = Curry<(a: number) => Date>; // (arg: number) => Date
type F2 = Curry<(a: number, b: string) => Date>; //  (arg_0: number) => (b: string) => Date

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第三十五题

实现一个 Add 工具类型，用于实现对数值类型对应的数值进行加法运算。具体的使用示例如下所示：

type Add<T, R> = // 你的实现代码

type A0 = Add<5, 5>; // 10
type A1 = Add<8, 20> // 28
type A2 = Add<10, 30>; // 40

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第二十九题

实现一个 ToPath 工具类型，用于把属性访问（. 或 []）路径转换为元组的形式。具体的使用示例如下所示：

type ToPath<S extends string> = // 你的实现代码

ToPath<'foo.bar.baz'> //=> ['foo', 'bar', 'baz']
ToPath<'foo[0].bar.baz'> //=> ['foo', '0', 'bar', 'baz']

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第三十九题

实现 IsAny 工具类型，用于判断类型 T 是否为 any 类型。具体的使用示例如下所示：

type IsAny<T> = // 你的实现代码

type I0 = IsAny<never> // false
type I1 = IsAny<unknown> // false
type I2 = IsAny<any> // true

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第五题

第五题

定义一个工具类型 AppendArgument，为已有的函数类型增加指定类型的参数，新增的参数名是 x，将作为新函数类型的第一个参数。具体的使用示例如下所示：

type Fn = (a: number, b: string) => number
type AppendArgument<F, A> = // 你的实现代码

type FinalFn = AppendArgument<Fn, boolean> 
// (x: boolean, a: number, b: string) => number

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第十九题

实现一个 OptionalKeys 工具类型，用来获取对象类型中声明的可选属性。具体的使用示例如下所示：

type Person = {
  id: string;
  name: string;
  age: number;
  from?: string;
  speak?: string;
};

type OptionalKeys<T> = // 你的实现代码
type PersonOptionalKeys = OptionalKeys<Person> // "from" | "speak"

提示：该题目有多种解法，感兴趣小伙伴可以自行尝试一下。
请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第八题

第八题

定义 NonEmptyArray 工具类型，用于确保数据非空数组。

type NonEmptyArray<T> = // 你的实现代码

const a: NonEmptyArray<string> = [] // 将出现编译错误
const b: NonEmptyArray<string> = ['Hello TS'] // 非空数据，正常使用

提示：该题目有多种解法，感兴趣小伙伴可以自行尝试一下。
请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第三十六题

实现一个 Filter 工具类型，用于根据类型变量 F 的值进行类型过滤。具体的使用示例如下所示：

type Filter<T extends any[], F> = // 你的实现代码

type F0 = Filter<[6, "lolo", 7, "semlinker", false], number>; // [6, 7]
type F1 = Filter<["kakuqo", 2, ["ts"], "lolo"], string>; // ["kakuqo", "lolo"]
type F2 = Filter<[0, true, any, "abao"], string>; // [any, "abao"]

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第三十题

完善 Chainable 类型的定义，使得 TS 能成功推断出 result 变量的类型。调用 option 方法之后会不断扩展当前对象的类型，使得调用 get 方法后能获取正确的类型。

declare const config: Chainable

type Chainable = {
  option(key: string, value: any): any
  get(): any
}

const result = config
  .option('age', 7)
  .option('name', 'lolo')
  .option('address', { value: 'XiaMen' })
  .get()

type ResultType = typeof result  
// 期望 ResultType 的类型是：
// {
//   age: number
//   name: string
//   address: {
//     value: string
//   }
// }

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第二十六题

实现一个 IsNever 工具类型，判断指定的类型是否为 never 类型。具体的使用示例如下所示：

type I0 = IsNever<never> // true
type I1 = IsNever<never | string> // false
type I2 = IsNever<null> // false

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第四题

第四题

Pick<T, K extends keyof T> 的作用是将某个类型中的子属性挑出来，变成包含这个类型部分属性的子类型。

interface Todo {
  title: string;
  description: string;
  completed: boolean;
}

type TodoPreview = Pick<Todo, "title" | "completed">;

const todo: TodoPreview = {
  title: "Clean room",
  completed: false
};

那么如何定义一个 ConditionalPick 工具类型，支持根据指定的 Condition 条件来生成新的类型，对应的使用示例如下：

interface Example {
	a: string;
	b: string | number;
	c: () => void;
	d: {};
}

// 测试用例：
type StringKeysOnly = ConditionalPick<Example, string>;
//=> {a: string}

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第四十四题

实现 Unpacked 工具类型，用于对类型执行 “拆箱” 操作。具体的使用示例如下所示：

type Unpacked<T> = // 你的实现代码

type T00 = Unpacked<string>;  // string
type T01 = Unpacked<string[]>;  // string
type T02 = Unpacked<() => string>;  // string
type T03 = Unpacked<Promise<string>>;  // string
type T04 = Unpacked<Unpacked<Promise<string>[]>>;  // string
type T05 = Unpacked<any>;  // any
type T06 = Unpacked<never>;  // never

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第七题

第七题

使用类型别名定义一个 EmptyObject 类型，使得该类型只允许空对象赋值：

type EmptyObject = {} 

// 测试用例
const shouldPass: EmptyObject = {}; // 可以正常赋值
const shouldFail: EmptyObject = { // 将出现编译错误
  prop: "TS"
}

在通过 EmptyObject 类型的测试用例检测后，我们来更改以下 takeSomeTypeOnly 函数的类型定义，让它的参数只允许严格SomeType类型的值。具体的使用示例如下所示：

type SomeType =  {
  prop: string
}

// 更改以下函数的类型定义，让它的参数只允许严格SomeType类型的值
function takeSomeTypeOnly(x: SomeType) { return x }

// 测试用例：
const x = { prop: 'a' };
takeSomeTypeOnly(x) // 可以正常调用

const y = { prop: 'a', addditionalProp: 'x' };
takeSomeTypeOnly(y) // 将出现编译错误

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第二十四题

实现一个 Mutable 工具类型，用于移除对象类型上所有属性或部分属性的 readonly 修饰符。具体的使用示例如下所示：

type Foo = {
  readonly a: number;
  readonly b: string;
  readonly c: boolean;
};

type Mutable<T, Keys extends keyof T = keyof T> = // 你的实现代码

const mutableFoo: Mutable<Foo, 'a'> = { a: 1, b: '2', c: true };

mutableFoo.a = 3; // OK
mutableFoo.b = '6'; // Cannot assign to 'b' because it is a read-only property.

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第十题

第十题

实现一个 Trim 工具类型，用于对字符串字面量类型进行去空格处理。具体的使用示例如下所示：

type Trim<V extends string> = // 你的实现代码

// 测试用例
Trim<' semlinker '>
//=> 'semlinker'

提示：可以考虑先定义 TrimLeft 和 TrimRight 工具类型，再组合成 Trim 工具类型。
请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第二十一题

实现一个 Merge 工具类型，用于把两个类型合并成一个新的类型。第二种类型（SecondType）的 Keys 将会覆盖第一种类型（FirstType）的 Keys。具体的使用示例如下所示：

type Foo = { 
   a: number;
   b: string;
};

type Bar = {
   b: number;
};

type Merge<FirstType, SecondType> = // 你的实现代码

const ab: Merge<Foo, Bar> = { a: 1, b: 2 };

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第十七题

实现一个 Includes 工具类型，用于判断指定的类型 E 是否包含在 T 数组类型中。具体的使用示例如下所示：

type Includes<T extends Array<any>, E> = // 你的实现代码

type I0 = Includes<[], 1> // false
type I1 = Includes<[2, 2, 3, 1], 2> // true
type I2 = Includes<[2, 3, 3, 1], 1> // true

提示：该题目有多种解法，感兴趣小伙伴可以自行尝试一下。
请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第九题

第九题

定义一个 JoinStrArray 工具类型，用于根据指定的 Separator 分隔符，对字符串数组类型进行拼接。具体的使用示例如下所示：

type JoinStrArray<Arr extends string[], Separator extends string, Result extends string = ""> = // 你的实现代码

// 测试用例
type Names = ["Sem", "Lolo", "Kaquko"]
type NamesComma = JoinStrArray<Names, ","> // "Sem,Lolo,Kaquko"
type NamesSpace = JoinStrArray<Names, " "> // "Sem Lolo Kaquko"
type NamesStars = JoinStrArray<Names, "⭐️"> // "Sem⭐️Lolo⭐️Kaquko"

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第四十题

实现 AnyOf 工具类型，只要数组中任意元素的类型非 Falsy 类型、 {} 类型或 [] 类型，则返回 true，否则返回 false。如果数组为空的话，则返回 false。具体的使用示例如下所示：

type AnyOf<T extends any[]> = // 你的实现代码

type A0 = AnyOf<[]>; // false
type A1 = AnyOf<[0, '', false, [], {}]> // false
type A2 = AnyOf<[1, "", false, [], {}]> // true

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第十八题

实现一个 UnionToIntersection 工具类型，用于把联合类型转换为交叉类型。具体的使用示例如下所示：

type UnionToIntersection<U> = // 你的实现代码

// 测试用例
type U0 = UnionToIntersection<string | number> // never
type U1 = UnionToIntersection<{ name: string } | { age: number }> // { name: string; } & { age: number; }

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第三十二题

实现一个 RepeatString 工具类型，用于根据类型变量 C 的值，重复 T 类型并以字符串的形式返回新的类型。具体的使用示例如下所示：

type RepeatString<
  T extends string,
  C extends number,
> = // 你的实现代码

type S0 = RepeatString<"a", 0>; // ''
type S1 = RepeatString<"a", 2>; // 'aa'
type S2 = RepeatString<"ab", 3>; // 'ababab'

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第四十五题

实现 JsonifiedObject 工具类型，用于对 object 对象类型进行序列化操作。具体的使用示例如下所示：

type JsonifiedObject<T extends object> = // 你的实现代码

type MyObject = {
  str: "literalstring",
  fn: () => void,
  date: Date,
  customClass: MyClass,
  obj: {
    prop: "property",
    clz: MyClass,
    nested: { attr: Date }
  },
}

declare class MyClass {
  toJSON(): "MyClass";
}

/**
 * type JsonifiedMyObject = {
 *  str: "literalstring";
 *  fn: never;
 *  date: string;
 *  customClass: "MyClass";
 *  obj: JsonifiedObject<{
 *    prop: "property";
 *    clz: MyClass;
 *    nested: {
 *      attr: Date;
 *    };
 *   }>;
 * }
*/
type JsonifiedMyObject = Jsonified<MyObject>;
declare let ex: JsonifiedMyObject;
const z1: "MyClass" = ex.customClass;
const z2: string = ex.obj.nested.attr;

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第二十二题

实现一个 RequireAtLeastOne 工具类型，它将创建至少含有一个给定 Keys 的类型，其余的 Keys 保持原样。具体的使用示例如下所示：

type Responder = {
   text?: () => string;
   json?: () => string;
   secure?: boolean;
};

type RequireAtLeastOne<
    ObjectType,
    KeysType extends keyof ObjectType = keyof ObjectType,
> = // 你的实现代码

// 表示当前类型至少包含 'text' 或 'json' 键
const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
    json: () => '{"message": "ok"}',
    secure: true
};

请在下面评论你的答案。

#### 7.1 EmptyObject

7.1 EmptyObject

type EmptyObject = {
  // type PropertyKey = string | number | symbol
  [K in PropertyKey]: never 
}

// 测试用例
const shouldPass: EmptyObject = {}; // 可以正常赋值
const shouldFail: EmptyObject = { // 将出现编译错误
  prop: "TS"
}

7.2 takeSomeTypeOnly

type SomeType =  {
  prop: string
}

type Exclusive<T1, T2 extends T1> = {
  [K in keyof T2]: K extends keyof T1 ? T2[K] : never 
}

// 更改以下函数的类型定义，让它的参数只允许严格SomeType类型的值
function takeSomeTypeOnly<T extends SomeType>(x: Exclusive<SomeType, T>) { return x }

// 测试用例：
const x = { prop: 'a' };
takeSomeTypeOnly(x) // 可以正常调用

const y = { prop: 'a', addditionalProp: 'x' };
takeSomeTypeOnly(y) // 将出现编译错误

Originally posted by @semlinker in #25 (comment)

7.2不太理解

「重学TS 2.0 」TS 练习题第四十三题

实现一个 Permutation 工具类型，当输入一个联合类型时，返回一个包含该联合类型的全排列类型数组。具体的使用示例如下所示：

type Permutation<T, K=T> = // 你的实现代码

// ["a", "b"] | ["b", "a"]
type P0 = Permutation<'a' | 'b'>  // ['a', 'b'] | ['b' | 'a']
// type P1 = ["a", "b", "c"] | ["a", "c", "b"] | ["b", "a", "c"] 
// | ["b", "c", "a"] | ["c", "a", "b"] | ["c", "b", "a"]
type P1 = Permutation<'a' | 'b' | 'c'>

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第二十五题

实现一个 IsUnion 工具类型，判断指定的类型是否为联合类型。具体的使用示例如下所示：

type IsUnion<T, U = T> = // 你的实现代码

type I0 = IsUnion<string|number> // true
type I1 = IsUnion<string|never> // false
type I2 =IsUnion<string|unknown> // false

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第二题

第二题

本道题我们希望参数 a 和 b 的类型都是一致的，即 a 和 b 同时为 number 或 string 类型。当它们的类型不一致的值，TS 类型检查器能自动提示对应的错误信息。

function f(a: string | number, b: string | number) {
  if (typeof a === 'string') {
    return a + ':' + b; // no error but b can be number!
  } else {
    return a + b; // error as b can be number | string
  }
}

f(2, 3); // Ok
f(1, 'a'); // Error
f('a', 2); // Error
f('a', 'b') // Ok

请在下面评论你的答案

article about use typescript in wechat has been deleted

Guyoung - 使用 TypeScript 开发微信小程序

「重学TS 2.0 」TS 练习题第十一题

实现一个 IsEqual 工具类型，用于比较两个类型是否相等。具体的使用示例如下所示：

type IsEqual<A, B> = // 你的实现代码

// 测试用例
type E0 = IsEqual<1, 2>; // false
type E1 = IsEqual<{ a: 1 }, { a: 1 }> // true
type E2 = IsEqual<[1], []>; // false

请在下面评论你的答案。

typescript

「重学TS 2.0 」TS 练习题第一题

第一题

type User = {
  id: number;
  kind: string;
};

function makeCustomer<T extends User>(u: T): T {
  // Error（TS 编译器版本：v4.4.2）
  // Type '{ id: number; kind: string; }' is not assignable to type 'T'.
  // '{ id: number; kind: string; }' is assignable to the constraint of type 'T', 
  // but 'T' could be instantiated with a different subtype of constraint 'User'.
  return {
    id: u.id,
    kind: 'customer'
  }
}

以上代码为什么会提示错误，应该如何解决上述问题？

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第三十一题

实现一个 Repeat 工具类型，用于根据类型变量 C 的值，重复 T 类型并以元组的形式返回新的类型。具体的使用示例如下所示：

type Repeat<T, C extends number> = // 你的实现代码

type R0 = Repeat<0, 0>; // []
type R1 = Repeat<1, 1>; // [1]
type R2 = Repeat<number, 2>; // [number, number]

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第十六题

实现一个 Push 工具类型，用于把指定类型 E 作为第最后一个元素添加到 T 数组类型中。具体的使用示例如下所示：

type Push<T extends any[], V> = // 你的实现代码

// 测试用例
type Arr0 = Push<[], 1> // [1]
type Arr1 = Push<[1, 2, 3], 4> // [1, 2, 3, 4]

请在下面评论你的答案。

Another awesome typescript

You might want to link to this existing list from @dzharii with the same awesome-typescript name here: https://github.com/dzharii/awesome-typescript

Maybe "prior art" or some sort of credit.

「重学TS 2.0 」TS 练习题第四十一题

实现 Replace 工具类型，用于实现字符串类型的替换操作。具体的使用示例如下所示：

type Replace<
  S extends string,
  From extends string,
  To extends string
> = // 你的实现代码 
  
type R0 = Replace<'', '', ''> // ''
type R1 = Replace<'foobar', 'bar', 'foo'> // "foofoo"
type R2 = Replace<'foobarbar', 'bar', 'foo'> // "foofoobar"

此外，继续实现 ReplaceAll 工具类型，用于实现替换所有满足条件的子串。具体的使用示例如下所示：

type ReplaceAll<
  S extends string,
  From extends string,
  To extends string
> = // 你的实现代码 

type R0 = ReplaceAll<'', '', ''> // ''
type R1 = ReplaceAll<'barfoo', 'bar', 'foo'> // "foofoo"
type R2 = ReplaceAll<'foobarbar', 'bar', 'foo'> // "foofoofoo"
type R3 = ReplaceAll<'foobarfoobar', 'ob', 'b'> // "fobarfobar"

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第三十七题

实现一个 Flat 工具类型，支持把数组类型拍平（扁平化）。具体的使用示例如下所示：

type Flat<T extends any[]> = // 你的实现代码

type F0 = Flat<[]> // []
type F1 = Flat<['a', 'b', 'c']> // ["a", "b", "c"]
type F2 = Flat<['a', ['b', 'c'], ['d', ['e', ['f']]]]> // ["a", "b", "c", "d", "e", "f"]

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第六题

第六题

定义一个 NativeFlat 工具类型，支持把数组类型拍平（扁平化）。具体的使用示例如下所示：

type NaiveFlat<T extends any[]> = // 你的实现代码

// 测试用例：
type NaiveResult = NaiveFlat<[['a'], ['b', 'c'], ['d']]>
// NaiveResult的结果： "a" | "b" | "c" | "d"

在完成 NaiveFlat 工具类型之后，在继续实现 DeepFlat 工具类型，以支持多维数组类型：

type DeepFlat<T extends any[]> = unknown // 你的实现代码

// 测试用例
type Deep = [['a'], ['b', 'c'], [['d']], [[[['e']]]]];
type DeepTestResult = DeepFlat<Deep>  
// DeepTestResult: "a" | "b" | "c" | "d" | "e"

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第十三题

实现一个 Tail 工具类型，用于获取数组类型除了第一个类型外，剩余的类型。具体的使用示例如下所示：

type Tail<T extends Array<any>> =  // 你的实现代码

// 测试用例
type T0 = Tail<[]> // []
type T1 = Tail<[1, 2]> // [2]
type T2 = Tail<[1, 2, 3, 4, 5]> // [2, 3, 4, 5]

提示：该题目有多种解法，感兴趣小伙伴可以自行尝试一下。
请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第二十三题

实现一个 RemoveIndexSignature 工具类型，用于移除已有类型中的索引签名。具体的使用示例如下所示：

interface Foo {
  [key: string]: any;
  [key: number]: any;
  bar(): void;
}

type RemoveIndexSignature<T> = // 你的实现代码

type FooWithOnlyBar = RemoveIndexSignature<Foo>; //{ bar: () => void; }

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第三十三题

实现一个 ToNumber 工具类型，用于实现把数值字符串类型转换为数值类型。具体的使用示例如下所示：

type ToNumber<T extends string> = // 你的实现代码

type T0 = ToNumber<"0">; // 0
type T1 = ToNumber<"10">; // 10
type T2 = ToNumber<"20">; // 20

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第十五题

实现一个 Shift 工具类型，用于移除 T 数组类型中的第一个类型。具体的使用示例如下所示：

type Shift<T extends any[]> = // 你的实现代码

// 测试用例
type S0 = Shift<[1, 2, 3]> 
type S1 = Shift<[string,number,boolean]>

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第十四题

实现一个 Unshift 工具类型，用于把指定类型 E 作为第一个元素添加到 T 数组类型中。具体的使用示例如下所示：

type Unshift<T extends any[], E> =  // 你的实现代码

// 测试用例
type Arr0 = Unshift<[], 1>; // [1]
type Arr1 = Unshift<[1, 2, 3], 0>; // [0, 1, 2, 3]

提示：该题目有多种解法，感兴趣小伙伴可以自行尝试一下。
请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第十五题

实现一个 Shift 工具类型，用于移除 T 数组类型中的第一个类型。具体的使用示例如下所示：

type Shift<T extends any[]> = // 你的实现代码

// 测试用例
type S0 = Shift<[1, 2, 3]> // [2, 3]
type S1 = Shift<[string,number,boolean]> // [number,boolean]

请在下面评论你的答案。

「重学TS 2.0 」TS 练习题第三十四题

实现一个 SmallerThan 工具类型，用于比较数值类型的大小。具体的使用示例如下所示：

type SmallerThan<
  N extends number,
  M extends number,
> = // 你的实现代码

type S0 = SmallerThan<0, 1>; // true
type S1 = SmallerThan<2, 0>; // false
type S2 = SmallerThan<8, 10>; // true

请在下面评论你的答案

「重学TS 2.0 」TS 练习题第二十八题

实现一个 Split 工具类型，根据给定的分隔符（Delimiter）对包含分隔符的字符串进行切割。可用于定义 String.prototype.split 方法的返回值类型。具体的使用示例如下所示：

type Item = 'semlinker,lolo,kakuqo';

type Split<
	S extends string, 
	Delimiter extends string,
> = // 你的实现代码

type ElementType = Split<Item, ','>; // ["semlinker", "lolo", "kakuqo"]

请在下面评论你的答案。

semlinker / awesome-typescript Goto Github PK

awesome-typescript's Introduction

Awesome TypeScript

Contents

TypeScript Tutorials

Features

Chinese

Beginner

Advanced

Practical

English

Features

Tutorials

Samples

Guide

Awesome

TypeScript Starters/Boilerplates

TypeScript Design patterns

TypeScript Videos

Chinese

English

TypeScript QA

TypeScript Books

Chinese

English

TypeScript Tools/Libraries

Build

webpack

gulp

grunt

compiler

linter

Ioc

Doc

Data Structure

Database

Server

TypeScript IDE

Offline

IDE/Plugins

Online

Playground

Chrome Extension

Contributing

Guide

awesome-typescript's People

Contributors

Stargazers

Watchers

Forkers

awesome-typescript's Issues

第三题

第五题

第八题

第四题

第七题

第十题

第九题

7.1 EmptyObject

7.2 takeSomeTypeOnly

第二题

第一题

第六题

Recommend Projects

Recommend Topics

Recommend Org