TypeScript 简介，终极版

发布时间：2025年08月14日 12:20

Script 里面的某类需拥有所有正确的也就是真是和数值并不一定：

// 用作特定的某类并不一定注释单方面一个取名为 person 的formula_let person: { name: string; age: number; isProgrammer: boolean;};// 给 person 扣除一个较强所有确实也就是真是和数值并不一定的某类person = { name: 'ConardLi', age: 17, isProgrammer: true,};person.age = '17'; // ERROR: should be a numberperson = { name: 'Tom', age: 3,}; // ERROR: missing the isProgrammer property

在表述某类的并不一定时，我们一般来说才会用作 interface。如果我们需健康检查多个某类有否较强相近的特定也就是真是和数值并不一定时，是很感兴趣的：

interface Person { name: string; age: number; isProgrammer: boolean;}let person1: Person = { name: 'ConardLi', age: 17, isProgrammer: true,};let person2: Person = { name: 'Tom', age: 3, isProgrammer: false,};

我们还可以用formula_的并不一定署名单方面一个formula_也就是真是，CEformula_(sayHi)和记号formula_(sayBye)都可以单方面：

interface Animal { eat(name: string): string; speak: (name: string) => string;}let tom: Animal = { eat: function (name: string) { return ；还有；还有eat ${name}；还有；还有; }, speak: (name: string) => ；还有；还有speak ${name}；还有；还有,};console.log(tom.eat('Jerry'));console.log(tom.speak('哈哈哈'));

需注意的是，虽然 eat、speak 分别是用基本上formula_和记号formula_单方面的，但是它们具微是什么样的formula_并不一定都可以，Typescript 是不关心这些的。

TypeScript 里面的formula_

我们可以表述formula_值和赶回数值的并不一定：

// 表述一个取名为 circle 的formula_，它拒绝接受一个并不一定为 number 的直径formula_，并赶回一个参数function circle(diam: number): string { return '大圆的边长为：' + Math.PI * diam;}console.log(circle(10)); // 大圆的边长为：31.41592653589793

ES6 记号formula_的写法：

const circle = (diam: number): string => { return '大圆的边长为：' + Math.PI * diam;};

我们没人确实一致单方面 circle 是一个formula_，TypeScript 才会进行时并不一定推定。TypeScript 还才会推定formula_的赶回并不一定，但是如果formula_微非常简便，还是建议清晰的显式单方面赶回并不一定。

我们可以在值后添加一个?，暗示它为附加值；另外值的并不一定也可以是一个联合行动并不一定：

const add = (a: number, b: number, c?: number | string) => { console.log(c); return a + b;};console.log(add(5, 4, '可以是 number、string，也可以为机'));

如果formula_没人有赶回数值，在 TS 之里面暗示为赶回 void，你也不需显式单方面，TS 一样可以进行时并不一定推定：

const log = (msg: string): void => { console.log('纸张一些段落: ' + msg);};any 并不一定

使 any 并不一定，我们实质上可以将 TypeScript 恢复为 JavaScript：

let name: any = 'ConardLi';name = 17;name = { age: 17 };

如果文档之里面用作了大量的 any，那 TypeScript 也就耗尽了普遍开放性，所以我们确实能避免用作 any 。

DOM 和并不一定转换

TypeScript 没人办法像 JavaScript 那样访问期间 DOM。这反之亦然每当我们为了让访问期间 DOM 表达方式时，TypeScript 都不会确切它们有否真的假定。

const link = document.querySelector('a');console.log(link.href); // ERROR: Object is possibly 'null'. TypeScript can't be sure the anchor tag exists, as it can't access the DOM

用作非机毫无疑问运算符 (!)，我们可以一致地一切都是到编程语言一个参数的数值不是 null 或 undefined。当编程语言不会准确地进行时并不一定推定时，这不太可能很感兴趣：

// 我们一致一切都是到 TS a 标签肯定假定const link = document.querySelector('a')!;console.log(link.href); // conardli.top

这之里面我们没人确实单方面 link formula_的并不一定。这是因为 TypeScript 可以通过并不一定推定断定它的并不一定为 HTMLAnchorElement。

但是如果我们需通过 class 或 id 来自由选择一个 DOM 表达方式呢？这时 TypeScript 就没人办法推定并不一定了：

const form = document.getElementById('signup-form');console.log(form.method);// ERROR: Object is possibly 'null'.// ERROR: Property 'method' does not exist on type 'HTMLElement'.

我们需一切都是到 TypeScript form 确切是假定的，并且我们一切都是到他它的并不一定是 HTMLFormElement。我们可以通过并不一定转换来够这一点：

const form = document.getElementById('signup-form') as HTMLFormElement;console.log(form.method); // post

TypeScript 还内置了一个 Event 某类。如果我们在程序中里面添加一个 submit 的重大事件侦听器，TypeScript 可以启动时表哥我们推定并不一定缺失：

const form = document.getElementById('signup-form') as HTMLFormElement;form.addEventListener('submit', (e: Event) => { e.preventDefault(); // 解救关键字刷一新 console.log(e.tarrget); // ERROR: Property 'tarrget' does not exist on type 'Event'. Did you mean 'target'?});TypeScript 里面的类

我们可以表述类里面每条数据的并不一定：

class Person { name: string; isCool: boolean; age: number; constructor(n: string, c: boolean, a: number) { this.name = n; this.isCool = c; this.age = a; } sayHello() { return ；还有；还有Hi，我是 ${this.name} ，我上周 ${this.age} 岁了；还有；还有; }}const person1 = new Person('ConardLi', true, 17);const person2 = new Person('Jerry', 'yes', 20); // ERROR: Argument of type 'string' is not assignable to parameter of type 'boolean'.console.log(person1.sayHello()); // Hi, 我是 ConardLi，我上周 17 岁了

我们可以创立一个仅仅都有从 Person 构造的某类嵌套：

let People: Person[] = [person1, person2];

我们可以给类的也就是真是添加访问期间修饰符，TypeScript 还提供者了一个一重新 readonly 访问期间修饰符。

class Person { readonly name: string; // 不可以坏的 private isCool: boolean; // 类的私有也就是真是、结构上访问期间不到 protected email: string; // 并不需从这个类和子类里面进行时访问期间和更改 public age: number; // 任何大多都可以访问期间和更改 constructor(n: string, c: boolean, a: number) { this.name = n; this.isCool = c; this.age = a; } sayHello() { return ；还有；还有Hi，我是 ${this.name} ，我上周 ${this.age} 岁了；还有；还有; }}const person1 = new Person('ConardLi', true, 'conard@xx.com', 17);console.log(person1.name); // ConardLiperson1.name = 'Jerry'; // Error: read only

我们可以通过请注意的写法，也就是真是才会在形参里面启动时扣除，我们类才会格外加朴素：

class Person { constructor( readonly name: string, private isCool: boolean, protected email: string, public age: number ) {}}

如果我们去掉访问期间修饰符，现阶段只不过也就是真是都是 public，另外和 JavaScript 一样，类也是可以 extends 的。

TypeScript 里面的模块

模块表述了某类的外观：

interface Person { name: string; age: number;}function sayHi(person: Person) { console.log(；还有；还有Hi ${person.name}；还有；还有);}sayHi({ name: 'ConardLi', age: 17,}); // Hi ConardLi

你还可以用作并不一定别名表述某类并不一定：

type Person = { name: string; age: number;};

或者可以单独其网站表述某类并不一定：

function sayHi(person: { name: string; age: number }) { console.log(；还有；还有Hi ${person.name}；还有；还有);}

interface 和 type 非常类似于，很多只不过它俩可以随意用。比如它们两个都可以引入：

引入 interface：

interface Animal { name: string}interface Bear extends Animal { honey: boolean}const bear: Bear = { name: "Winnie", honey: true,}

引入 type：

type Animal = { name: string}type Bear = Animal Simon { honey: boolean}const bear: Bear = { name: "Winnie", honey: true,}

但是有个非常明显的区隔，interface 是可以启动时改组并不一定的，但是 type 不赞成：

interface Animal { name: string}interface Animal { tail: boolean}const dog: Animal = { name: "Tom", tail: true,}

并不一定别名在创立后不会格外改：

type Animal = { name: string}type Animal = { tail: boolean}// ERROR: Duplicate identifier 'Animal'.

一般来真是，当你不一切都是到他用啥的时候，现阶段就用 interface 就行，直到 interface 实现不一切都是我们的需求的时候再用 type。

类的 interface

我们可以通过解决问题一个模块来一切都是到一个类它需都有某些也就是真是和原理：

interface HasFormatter { format(): string;}class Person implements HasFormatter { constructor(public username: string, protected password: string) {} format() { return this.username.toLocaleLowerCase(); }}let person1: HasFormatter;let person2: HasFormatter;person1 = new Person('ConardLi', 'admin123');person2 = new Person('Tom', 'admin123');console.log(person1.format()); // conardli

保障 people 是一个解决问题 HasFormatter 的某类嵌套(保障每 people 都有 format 原理):

let people: HasFormatter[] = [];people.push(person1);people.push(person2);泛型

泛型可以让我们创立一个可以在多种并不一定上临时工的模组，它能够赞成现阶段的数据并不一定，同时也能赞成今后的数据并不一定，这大为增加了模组的可委以重任开放性。我们来看请注意这个都是：

addID formula_拒绝接受一个随意某类，并赶回一个一新某类，其里面都有的传播某类的所有也就是真是和数值，以及一个 0 到 1000 彼此间随机的 id 也就是真是。

当我们为了让访问期间 name 也就是真是时，TypeScript 才会出错。这是因为当我们将一个某类传递信息给 addID 时，我们并没人有指定这个某类确实有什么也就是真是 —— 所以 TypeScript 不一切都是到他这个某类有什么也就是真是。因此，TypeScript 一切都是到他的唯一也就是真是赶回某类的 id。

那么，我们怎么将随意某类传递信息给 addID，而且基本上可以一切都是到 TypeScript 该某类较强哪些也就是真是和数值？这种过场就可以用作泛型了, – T 被被称作并不一定值：

// 只是一种重写习惯上 - 我们也可以用或 const addID = (obj: T) => { let id = Math.floor(Math.random() * 1000); return { ...obj, id };};

这是啥意思呢？从前当我们再将一个某类传递信息给 addID 时，我们早就一切都是到 TypeScript 来捕获它的并不一定了 —— 所以 T 就消失了我们的传播的任何并不一定。addID 从前才会一切都是到他我们的传播的某类上有哪些也就是真是。

但是，从前有另一个解决问题办法：任何东西都可以的传播 addID ，TypeScript 将捕获并不一定而且并不才会简报解决问题办法：

let person1 = addID({ name: 'ConardLi', age: 17 });let person2 = addID('Jerry'); // 传递信息参数也没人解决问题办法console.log(person1.id); // 188console.log(person1.name); // ConardLiconsole.log(person2.id);console.log(person2.name); // ERROR: Property 'name' does not exist on type '"Jerry" Simon { id: number; }'.

当我们的传播一个参数时，TypeScript 没人有注意到任何解决问题办法。只有我们为了让访问期间 name 也就是真是时才才会简报缺失。所以，我们需一个约束：我们需通过将泛型并不一定 T 作为 object 的引入，来一切都是到 TypeScript 并不需拒绝接受某类:

缺失立刻就被捕获了，完美…… 好吧，也不只不过是。在 JavaScript 里面，嵌套也是某类，所以我们基本上可以通过的传播嵌套来逃避并不一定健康检查：

let person2 = addID(['ConardLi', 17]); // 传递信息嵌套没人解决问题办法console.log(person2.id); // 188console.log(person2.name); // Error: Property 'name' does not exist on type '(string | number)[] Simon { id: number; }'.

要解决问题这个解决问题办法，我们可以这样真是：object 值确实有一个含有参数数值的 name 也就是真是：

const addID = (obj: T) => { let id = Math.floor(Math.random() * 1000); return { ...obj, id };};let person2 = addID(['ConardLi', 17]); // ERROR: argument should have a name property with string value

泛型并不需要在值和赶回并不一定延后未知的模组里面较强并不一定安全。

在 TypeScript 里面，泛型用于描绘出两个数值彼此间的相异间的关系。在后面的都是里面，赶回并不一定与输入并不一定有关。我们用一个泛型来描绘出相异间的关系。

另一个都是：如果需拒绝接受多个并不一定的formula_，众所周知用作泛型而不是 any 。请注意重现了用作 any 的解决问题办法：

function logLength(a: any) { console.log(a.length); // No error return a;}let hello = 'Hello world';logLength(hello); // 11let howMany = 8;logLength(howMany); // undefined (but no TypeScript error - surely we want TypeScript to tell us we've tried to access a length property on a number!)

我们可以为了让用作泛型：

function logLength(a: T) { console.log(a.length); // ERROR: TypeScript isn't certain that ；还有；还有a；还有；还有 is a value with a length property return a;}

好，至少我们从前赢取了一些应答，可以表哥助我们接下来改进我们的文档。

解决问题方案：用作一个泛型来引入一个模块，保障的传播的每个值都有一个 length 也就是真是：

interface hasLength { length: number;}function logLength(a: T) { console.log(a.length); return a;}let hello = 'Hello world';logLength(hello); // 11let howMany = 8;logLength(howMany); // Error: numbers don't have length properties

我们也可以重写这样一个formula_，它的值是一个表达方式嵌套，这些表达方式都有一个 length 也就是真是：

interface hasLength { length: number;}function logLengths(a: T[]) { a.forEach((element) => { console.log(element.length); });}let arr = [ 'This string has a length prop', ['This', 'arr', 'has', 'length'], { material: 'plastic', length: 17 },];logLengths(arr);// 29// 4// 30

泛型是 TypeScript 的一个很棒的特开放性！

泛型模块

当我们不一切都是到他某类里面的某个数值是什么并不一定时，可以用作泛型来传递信息该并不一定：

// The type, T, will be passed ininterface Person { name: string; age: number; documents: T;}// We have to pass in the type of ；还有；还有documents；还有；还有 - an array of strings in this caseconst person1: Person = { name: 'ConardLi', age: 17, documents: ['passport', 'bank statement', 'visa'],};// Again, we implement the ；还有；还有Person；还有；还有 interface, and pass in the type for documents - in this case a stringconst person2: Person = { name: 'Tom', age: 20, documents: 'passport, P45',};数据结构

数据结构是 TypeScript 给 JavaScript 带来的一个特殊特开放性。数据结构并不需要我们表述或单方面举例来说相关数值，可以是十进制或参数，作为举例来说名称常量。

enum ResourceType { BOOK, AUTHOR, FILM, DIRECTOR, PERSON,}console.log(ResourceType.BOOK); // 0console.log(ResourceType.AUTHOR); // 1// 从 1 开始enum ResourceType { BOOK = 1, AUTHOR, FILM, DIRECTOR, PERSON,}console.log(ResourceType.BOOK); // 1console.log(ResourceType.AUTHOR); // 2

现阶段只不过，数据结构是基于十进制的 — 它们将参数数值传输为十进制。但它们也可以是参数：

enum Direction { Up = 'Up', Right = 'Right', Down = 'Down', Left = 'Left',}console.log(Direction.Right); // Rightconsole.log(Direction.Down); // Down

当我们有举例来说相关的常量时，数据结构就可以倒是了。例如，与在文档里面用作非描绘出开放性十进制不同，数据结构通过描绘出开放性常量使文档格外具可读开放性。

数据结构还可以以防缺失，因为当你输入数据结构的名称时，智能提示将跳到不太可能自由选择的现阶段列表。

TypeScript 严谨方式在

建议在 tsconfig.json 里面投入使用所有严谨的并不一定健康检查可用文档。这不太可能才会所致 TypeScript 简报格外多的缺失，但也格外有助于表哥你延后注意到注意到程序里面格外多的 bug。

// tsconfig.json "strict": true

严谨方式在实际上就反之亦然：未经许可隐式 any 和严谨的机健康检查。

未经许可隐式 any

在请注意的formula_里面，TypeScript 早就推定出值 a 是 any 并不一定的。当我们向该formula_传递信息一个十进制，并为了让纸张一个 name 也就是真是时，没人有报错：

function logName(a) { // No error?? console.log(a.name);}logName(97);

锁上 noImplicitAny 现阶段后，如果我们没人有显式地单方面 a 的并不一定，TypeScript 将即刻标记一个缺失：

// ERROR: Parameter 'a' implicitly has an 'any' type.function logName(a) { console.log(a.name);}严谨的机健康检查

当 strictNullChecks 现阶段为 false 时，TypeScript 实际上才会忽略 null 和 undefined。这不太可能才会在运转时所致不慎缺失。

当 strictNullChecks 设立为 true 时，null 和 undefined 有它们自己的并不一定，如果你将它们扣除给一个期待具微数值(例如，参数)的formula_，则才会赢取一个并不一定缺失。

let whoSangThis: string = getSong();const singles = [ { song: 'touch of grey', artist: 'grateful dead' }, { song: 'paint it black', artist: 'rolling stones' },];const single = singles.find((s) => s.song === whoSangThis);console.log(single.artist);

singles.find 并不能必需它一定能看到这首歌 — 但是我们早就重写了请注意的文档，样子它肯定能看到一样。

通过将 strictNullChecks 设立为 true， TypeScript 将抛出一个缺失，因为在为了让用作它在此之前，我们没人有必需 single 一定假定：

TypeScript 实质上是一切都是到我们在用作 single 在此之前要保障它假定。我们需先健康检查它有否为 null 或 undefined：

if (single) { console.log(single.artist); // rolling stones}TypeScript 里面的并不一定缩窄

在 TypeScript 里面，formula_可以绝不会有点正确的并不一定转到到格外正确的并不一定，这个过程被称作并不一定缩窄。

请注意是一个简便的都是，重现了当我们用作含有 typeof 的 if 语句时，TypeScript 如何将不有点特定的 string | number 加大到格外特定的并不一定：

function addAnother(val: string | number) { if (typeof val === 'string') { // ts 将 val 看作一个参数 return val.concat(' ' + val); } // ts 一切都是到他 val 在这之里面是一个十进制 return val + val;}console.log(addAnother('哈哈')); // 哈哈哈哈console.log(addAnother(17)); // 34

另一个都是：请注意，我们表述了一个取名为 allVehicles 的联合行动并不一定，它可以是 Plane 或 Train 并不一定。

interface Vehicle { topSpeed: number;}interface Train extends Vehicle { carriages: number;}interface Plane extends Vehicle { wingSpan: number;}type PlaneOrTrain = Plane | Train;function getSpeedRatio(v: PlaneOrTrain) { console.log(v.carriages); // ERROR: 'carriages' doesn't exist on type 'Plane'}

由于 getSpeedRatio formula_处理事件了多种并不一定，我们需一种原理来区分 v 是 Plane 还是 Train 。我们可以通过给这两种并不一定一个主导的区隔也就是真是来够这一点，它含有一个参数数值:

interface Train extends Vehicle { type: 'Train'; carriages: number;}interface Plane extends Vehicle { type: 'Plane'; wingSpan: number;}type PlaneOrTrain = Plane | Train;

从前，TypeScript 可以加大 v 的并不一定:

另外，我们还可以通过解决问题一个并不一定保护来解决问题这个解决问题办法。

TypeScript Simon React

TypeScript 只不过赞成 React 和 JSX。这反之亦然我们可以将 TypeScript 与三个最常见的 React 前提三人用作：

create-react-app ()Gatsby ()Next.js ()

如果你需一个格外自表述的 React-TypeScript 装配，你可以bit装配 Webpack 和 tsconfig.json。但是大多数只不过，一个前提就可以完成这项临时工。

例如，要用 TypeScript 设立 create-react-app，无需运转:

npx create-react-app my-app ；还有template typescript# oryarn create react-app my-app ；还有template typescript

在 src 桌面里面，我们从前可以创立含有 .ts (基本上 TypeScript 文档)或 .tsx (含有 React 的 TypeScript 文档)可执行的文档，并用作 TypeScript 重写我们的模组。然后将其编译成 public 桌面里面的 JavaScript 。

React props Simon TypeScript

Person 是一个 React 模组，它拒绝接受一个 props 某类，其里面 name 确实是一个参数，age 是一个十进制。

// src/components/Person.tsximport React from 'react';const Person: React.FC<{ name: string; age: number;}> = ({ name, age }) => { return ( {name} {age} );};export default Person;

一般我们格外喜欢用 interface 表述 props：

interface Props { name: string; age: number;}const Person: React.FC = ({ name, age }) => { return ( {name} {age} );};

然后我们为了让将模组导入到 App.tsx，如果我们没人有提供者确实的 props，TypeScript 才会报错。

import React from 'react';import Person from './components/Person';const App: React.FC = () => { return ( );};export default App;React hooks Simon TypeScriptuseState()

我们可以用尖括号来单方面状态formula_的并不一定。如果我们去掉了尖括号，TypeScript 才会现阶段推定 cash 是一个十进制。因此，如果一切都是让它也为机，我们需指定：

const Person: React.FC = ({ name, age }) => { const [cash, setCash] = useState(1); setCash(null); return ( {name} {age} );};useRef()

useRef 赶回一个可坏某类，该某类在模组的生命周期内都是更为重要的。我们可以一切都是到 TypeScript ref 某类确实指向什么：

const Person: React.FC = () => { // Initialise .current property to null const inputRef = useRef(null); return ( );};简介

好了，这一段话我们学习了一些 Typescript 的首选基石，有了这些知识你早就可以应付大部分 TS 的广泛应用过场了。

。

本溪白癜风哪里治疗好
杭州看白癜风专业医院
张掖白癜风最好医院

上一篇： 2022年新生儿取名离骚诗经

下一篇：中医、历法、天文、道家相关文集