先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新Web前端全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上前端开发知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
如果你需要这些资料,可以添加V获取:vip1024c (备注前端)
正文
}
console.log(identity(68, “Semlinker”));
对于上述代码,编译器足够聪明,能够知道我们的参数类型,并将它们赋值给 T 和 U,而不需要开发人员显式指定它们。下面我们来看张动图,直观地感受一下类型传递的过程:
(图片来源:https://medium.com/better-programming/typescript-generics-90be93d8c292)
如你所见,该函数接收你传递给它的任何类型,使得我们可以为不同类型创建可重用的组件。现在我们再来看一下 identity
函数:
function identity <T, U>(value: T, message: U) : T {
console.log(message);
return value;
}
相比之前定义的 identity
函数,新的 identity
函数增加了一个类型变量 U
,但该函数的返回类型我们仍然使用 T
。如果我们想要返回两种类型的对象该怎么办呢?针对这个问题,我们有多种方案,其中一种就是使用元组,即为元组设置通用的类型:
function identity <T, U>(value: T, message: U) : [T, U] {
return [value, message];
}
虽然使用元组解决了上述的问题,但有没有其它更好的方案呢?答案是有的,你可以使用泛型接口。
二、泛型接口
为了解决上面提到的问题,首先让我们创建一个用于的 identity
函数通用 Identities
接口:
interface Identities<V, M> {
value: V,
message: M
}
在上述的 Identities
接口中,我们引入了类型变量 V
和 M
,来进一步说明有效的字母都可以用于表示类型变量,之后我们就可以将 Identities
接口作为 identity
函数的返回类型:
function identity<T, U> (value: T, message: U): Identities<T, U> {
console.log(value + ": " + typeof (value));
console.log(message + ": " + typeof (message));
let identities: Identities<T, U> = {
value,
message
};
return identities;
}
console.log(identity(68, “Semlinker”));
以上代码成功运行后,在控制台会输出以下结果:
68: number
Semlinker: string
{value: 68, message: “Semlinker”}
泛型除了可以应用在函数和接口之外,它也可以应用在类中,下面我们就来看一下在类中如何使用泛型。
三、泛型类
在类中使用泛型也很简单,我们只需要在类名后面,使用 <T, ...>
的语法定义任意多个类型变量,具体示例如下:
interface GenericInterface {
value: U
getIdentity: () => U
}
class IdentityClass implements GenericInterface {
value: T
constructor(value: T) {
this.value = value
}
getIdentity(): T {
return this.value
}
}
const myNumberClass = new IdentityClass(68);
console.log(myNumberClass.getIdentity()); // 68
const myStringClass = new IdentityClass(“Semlinker!”);
console.log(myStringClass.getIdentity()); // Semlinker!
接下来我们以实例化 myNumberClass
为例,来分析一下其调用过程:
-
在实例化
IdentityClass
对象时,我们传入Number
类型和构造函数参数值68
; -
之后在
IdentityClass
类中,类型变量T
的值变成Number
类型; -
IdentityClass
类实现了GenericInterface<T>
,而此时T
表示Number
类型,因此等价于该类实现了GenericInterface<Number>
接口; -
而对于
GenericInterface<U>
接口来说,类型变量U
也变成了Number
。这里我有意使用不同的变量名,以表明类型值沿链向上传播,且与变量名无关。
泛型类可确保在整个类中一致地使用指定的数据类型。比如,你可能已经注意到在使用 Typescript 的 React 项目中使用了以下约定:
type Props = {
className?: string
…
};
type State = {
submitted?: bool
…
};
class MyComponent extends React.Component<Props, State> {
…
}
在以上代码中,我们将泛型与 React 组件一起使用,以确保组件的 props 和 state 是类型安全的。
相信看到这里一些读者会有疑问,我们在什么时候需要使用泛型呢?通常在决定是否使用泛型时,我们有以下两个参考标准:
-
当你的函数、接口或类将处理多种数据类型时;
-
当函数、接口或类在多个地方使用该数据类型时。
很有可能你没有办法保证在项目早期就使用泛型的组件,但是随着项目的发展,组件的功能通常会被扩展。这种增加的可扩展性最终很可能会满足上述两个条件,在这种情况下,引入泛型将比复制组件来满足一系列数据类型更干净。
我们将在本文的后面探讨更多满足这两个条件的用例。不过在这样做之前,让我们先介绍一下 Typescript 泛型提供的其他功能。
四、泛型约束
有时我们可能希望限制每个类型变量接受的类型数量,这就是泛型约束的作用。下面我们来举几个例子,介绍一下如何使用泛型约束。
4.1 确保属性存在
有时候,我们希望类型变量对应的类型上存在某些属性。这时,除非我们显式地将特定属性定义为类型变量,否则编译器不会知道它们的存在。
一个很好的例子是在处理字符串或数组时,我们会假设 length
属性是可用的。让我们再次使用 identity
函数并尝试输出参数的长度:
function identity(arg: T): T {
console.log(arg.length); // Error
return arg;
}
在这种情况下,编译器将不会知道 T
确实含有 length
属性,尤其是在可以将任何类型赋给类型变量 T
的情况下。我们需要做的就是让类型变量 extends
一个含有我们所需属性的接口,比如这样:
interface Length {
length: number;
}
function identity(arg: T): T {
console.log(arg.length); // 可以获取length属性
return arg;
}
T extends Length
用于告诉编译器,我们支持已经实现 Length
接口的任何类型。之后,当我们使用不含有 length
属性的对象作为参数调用 identity
函数时,TypeScript 会提示相关的错误信息:
identity(68); // Error
// Argument of type ‘68’ is not assignable to parameter of type ‘Length’.(2345)
此外,我们还可以使用 ,
号来分隔多种约束类型,比如:<T extends Length, Type2, Type3>
。而对于上述的 length
属性问题来说,如果我们显式地将变量设置为数组类型,也可以解决该问题,具体方式如下:
function identity(arg: T[]): T[] {
console.log(arg.length);
return arg;
}
// or
function identity(arg: Array): Array {
console.log(arg.length);
return arg;
}
4.2 检查对象上的键是否存在
泛型约束的另一个常见的使用场景就是检查对象上的键是否存在。不过在看具体示例之前,我们得来了解一下 keyof
操作符,keyof
操作符是在 TypeScript 2.1 版本引入的,该操作符可以用于获取某种类型的所有键,其返回类型是联合类型。 “耳听为虚,眼见为实”,我们来举个 keyof
的使用示例:
interface Person {
name: string;
age: number;
location: string;
}
type K1 = keyof Person; // “name” | “age” | “location”
type K2 = keyof Person[]; // number | “length” | “push” | “concat” | …
type K3 = keyof { [x: string]: Person }; // string | number
通过 keyof
操作符,我们就可以获取指定类型的所有键,之后我们就可以结合前面介绍的 extends
约束,即限制输入的属性名包含在 keyof
返回的联合类型中。具体的使用方式如下:
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
在以上的 getProperty
函数中,我们通过 K extends keyof T
确保参数 key 一定是对象中含有的键,这样就不会发生运行时错误。这是一个类型安全的解决方案,与简单调用 let value = obj[key];
不同。
下面我们来看一下如何使用 getProperty
函数:
enum Difficulty {
Easy,
Intermediate,
Hard
}
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
let tsInfo = {
name: “Typescript”,
supersetOf: “Javascript”,
difficulty: Difficulty.Intermediate
}
let difficulty: Difficulty =
getProperty(tsInfo, ‘difficulty’); // OK
let supersetOf: string =
getProperty(tsInfo, ‘superset_of’); // Error
在以上示例中,对于 getProperty(tsInfo, 'superset_of')
这个表达式,TypeScript 编译器会提示以下错误信息:
Argument of type ‘“superset_of”’ is not assignable to parameter of type
‘“difficulty” | “name” | “supersetOf”’.(2345)
很明显通过使用泛型约束,在编译阶段我们就可以提前发现错误,大大提高了程序的健壮性和稳定性。接下来,我们来介绍一下泛型参数默认类型。
五、泛型参数默认类型
在 TypeScript 2.3 以后,我们可以为泛型中的类型参数指定默认类型。当使用泛型时没有在代码中直接指定类型参数,从实际值参数中也无法推断出类型时,这个默认类型就会起作用。
泛型参数默认类型与普通函数默认值类似,对应的语法很简单,即 <T=Default Type>
,对应的使用示例如下:
interface A<T=string> {
name: T;
}
const strA: A = { name: “Semlinker” };
const numB: A = { name: 101 };
泛型参数的默认类型遵循以下规则:
-
有默认类型的类型参数被认为是可选的。
-
必选的类型参数不能在可选的类型参数后。
-
如果类型参数有约束,类型参数的默认类型必须满足这个约束。
-
当指定类型实参时,你只需要指定必选类型参数的类型实参。未指定的类型参数会被解析为它们的默认类型。
-
如果指定了默认类型,且类型推断无法选择一个候选类型,那么将使用默认类型作为推断结果。
-
一个被现有类或接口合并的类或者接口的声明可以为现有类型参数引入默认类型。
-
一个被现有类或接口合并的类或者接口的声明可以引入新的类型参数,只要它指定了默认类型。
六、泛型条件类型
在 TypeScript 2.8 中引入了条件类型,使得我们可以根据某些条件得到不同的类型,这里所说的条件是类型兼容性约束。尽管以上代码中使用了 extends
关键字,也不一定要强制满足继承关系,而是检查是否满足结构兼容性。
条件类型会以一个条件表达式进行类型关系检测,从而在两种类型中选择其一:
T extends U ? X : Y
以上表达式的意思是:若 T
能够赋值给 U
,那么类型是 X
,否则为 Y
。在条件类型表达式中,我们通常还会结合 infer
关键字,实现类型抽取:
interface Dictionary<T = any> {
}
type StrDict = Dictionary
type DictMember = T extends Dictionary ? V : never
type StrDictMember = DictMember // string
在上面示例中,当类型 T 满足 T extends Dictionary
约束时,我们会使用 infer
关键字声明了一个类型变量 V,并返回该类型,否则返回 never
类型。
在 TypeScript 中,
never
类型表示的是那些永不存在的值的类型。例如,never
类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型。
另外,需要注意的是,没有类型是
never
的子类型或可以赋值给never
类型(除了never
本身之外)。即使any
也不可以赋值给never
。
除了上述的应用外,利用条件类型和 infer
关键字,我们还可以方便地实现获取 Promise 对象的返回值类型,比如:
async function stringPromise() {
return “Hello, Semlinker!”;
}
interface Person {
name: string;
age: number;
}
async function personPromise() {
return { name: “Semlinker”, age: 30 } as Person;
}
type PromiseType = (args: any[]) => Promise;
type UnPromisify = T extends PromiseType ? U : never;
type extractStringPromise = UnPromisify; // string
type extractPersonPromise = UnPromisify; // Person
七、泛型工具类型
为了方便开发者 TypeScript 内置了一些常用的工具类型,比如 Partial、Required、Readonly、Record 和 ReturnType 等。出于篇幅考虑,这里我们只简单介绍其中几个常用的工具类型。
7.1 Partial
Partial<T>
的作用就是将某个类型里的属性全部变为可选项 ?
。
定义:
/**
* node_modules/typescript/lib/lib.es5.d.ts
* Make all properties in T optional
*/
type Partial = {
[P in keyof T]?: T[P];
};
在以上代码中,首先通过 keyof T
拿到 T
的所有属性名,然后使用 in
进行遍历,将值赋给 P
,最后通过 T[P]
取得相应的属性值。中间的 ?
号,用于将所有属性变为可选。
示例:
interface Todo {
title: string;
description: string;
}
function updateTodo(todo: Todo, fieldsToUpdate: Partial) {
return { …todo, …fieldsToUpdate };
}
const todo1 = {
title: “organize desk”,
description: “clear clutter”
};
const todo2 = updateTodo(todo1, {
description: “throw out trash”
});
在上面的 updateTodo
方法中,我们利用 Partial<T>
工具类型,定义 fieldsToUpdate
的类型为 Partial<Todo>
,即:
{
title?: string | undefined;
description?: string | undefined;
}
7.2 Record
Record<K extends keyof any, T>
的作用是将 K
中所有的属性的值转化为 T
类型。
定义:
/**
* node_modules/typescript/lib/lib.es5.d.ts
* Construct a type with a set of properties K of type T
*/
type Record<K extends keyof any, T> = {
};
示例:
interface PageInfo {
title: string;
}
type Page = “home” | “about” | “contact”;
const x: Record<Page, PageInfo> = {
about: { title: “about” },
contact: { title: “contact” },
home: { title: “home” }
};
7.3 Pick
Pick<T, K extends keyof T>
的作用是将某个类型中的子属性挑出来,变成包含这个类型部分属性的子类型。
定义:
// node_modules/typescript/lib/lib.es5.d.ts
/**
* From T, pick a set of properties whose keys are in the union K
*/
type 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
};
7.4 Exclude
Exclude<T, U>
的作用是将某个类型中属于另一个的类型移除掉。
定义:
// node_modules/typescript/lib/lib.es5.d.ts
/**
* Exclude from T those types that are assignable to U
*/
type Exclude<T, U> = T extends U ? never : T;
如果 T
能赋值给 U
类型的话,那么就会返回 never
类型,否则返回 T
类型。最终实现的效果就是将 T
中某些属于 U
的类型移除掉。
示例:
type T0 = Exclude<“a” | “b” | “c”, “a”>; // “b” | “c”
type T1 = Exclude<“a” | “b” | “c”, “a” | “b”>; // “c”
结尾
学习html5、css、javascript这些基础知识,学习的渠道很多,就不多说了,例如,一些其他的优秀博客。但是本人觉得看书也很必要,可以节省很多时间,常见的javascript的书,例如:javascript的高级程序设计,是每位前端工程师必不可少的一本书,边看边用,了解js的一些基本知识,基本上很全面了,如果有时间可以读一些,js性能相关的书籍,以及设计者模式,在实践中都会用的到。
高级程序设计,是每位前端工程师必不可少的一本书,边看边用,了解js的一些基本知识,基本上很全面了,如果有时间可以读一些,js性能相关的书籍,以及设计者模式,在实践中都会用的到。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024c (备注前端)
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
typescript/lib/lib.es5.d.ts
/**
* Exclude from T those types that are assignable to U
*/
type Exclude<T, U> = T extends U ? never : T;
如果 T
能赋值给 U
类型的话,那么就会返回 never
类型,否则返回 T
类型。最终实现的效果就是将 T
中某些属于 U
的类型移除掉。
示例:
type T0 = Exclude<“a” | “b” | “c”, “a”>; // “b” | “c”
type T1 = Exclude<“a” | “b” | “c”, “a” | “b”>; // “c”
结尾
学习html5、css、javascript这些基础知识,学习的渠道很多,就不多说了,例如,一些其他的优秀博客。但是本人觉得看书也很必要,可以节省很多时间,常见的javascript的书,例如:javascript的高级程序设计,是每位前端工程师必不可少的一本书,边看边用,了解js的一些基本知识,基本上很全面了,如果有时间可以读一些,js性能相关的书籍,以及设计者模式,在实践中都会用的到。
高级程序设计,是每位前端工程师必不可少的一本书,边看边用,了解js的一些基本知识,基本上很全面了,如果有时间可以读一些,js性能相关的书籍,以及设计者模式,在实践中都会用的到。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024c (备注前端)
[外链图片转存中…(img-sT65kf75-1713222503397)]
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!