TypeScript 类型学习

最新推荐文章于 2024-06-12 08:50:30 发布
最新推荐文章于 2024-06-12 08:50:30 发布
阅读量3.4k 收藏 2
点赞数
分类专栏： JavaScript & TypeScript 文章标签： 前端 学习 typescript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49424368/article/details/124299496
版权

TypeScript 是 JavaScript 的超集，它扩展了 JavaScript，有 JavaScript 没有的东西，支持最新的 JavaScript 新特性，故而也包含着 JavaScript 的八大内置类型。

let str: string = "jimmy";
let num: number = 24;
let bool: boolean = false;
let u: undefined = undefined;
let n: null = null;
let obj: object = {x: 1};
let big: bigint = 100n;
let sym: symbol = Symbol("me");

基本数据类型

Boolean、Number、String

// Number 类型
// 类型声明大小写皆可
let number: number = 10;
let number1: Number = 12;

// Boolean 类型
// boolean 值为 true 或 false
let isBool: boolean = true;

// String 类型
// 保存一个字符串
let str: string = 'hello world';

Null、Undefined

// JavaScript 中没有空值 Void 的概念，在 TypeScript 中，可以用 void 表示没有任何返回值的函数;
// 声明一个 void 类型的变量没有什么用，因为你只能将它赋值为 undefined 和 null;
function alertName(): void {
    alert('My name is Tom');
}

let unusable: void = 1;
// Type 'number' is not assignable to type 'void'.


// Null 和 Undefined
// TypeScript 里，undefined 和 null 两者各自有自己的类型分别叫做 undefined 和 null。 
// 和 void 相似，它们的本身的类型用处不是很大。
let u: undefined = undefined;
let n: null = null;
// 默认情况下 null 和 undefined 是所有类型的子类型。 就是说你可以把null和undefined赋值给number类型的变量。
// 然而，当你指定了--strictNullChecks标记，null和undefined只能赋值给void和它们各自。 这能避免很多常见的问题。 

// 启用 --strictNullChecks
let num: number;
num = 1; // 运行正确
num = undefined;    // 运行错误
num = null;    // 运行错误

ES6 中的新类型 Symbol 和 ES11 中的 BigInt

Symbol：Symbol 是 ES6 中引入的原始数据类型，代表着独一无二的

声明：const sy = Stmbol()
参数：string(可选)
方法：

  • Symbol.for(): 创建以参数作为描述的 Symbol 值，如存在此参数则返回原有的 Symbol 值（先搜索后创建，登记在全局环境）
  • Symbol.keyFor(): 返回已登记的 Symbol 值的描述（只能返回 Symbol.for() 的 key）
  • Object.getOwnPropertySymbols(): 返回对象中所有用作属性名的 Symbol 值的数组
 // 声明
 let a = Symbol();
 let b = Symbol();
 console.log(a === b); // false
 
 //Symbol.for()
 let c = Symbol.for("domesy");
 let d = Symbol.for("domesy");
 console.log(c === d); // true
 
 //Symbol.keyFor()
 const e = Symbol.for("1");
 console.log(Symbol.keyFor(e)); // 1
 
 //Symbol.description
 let symbol = Symbol("es");
 console.log(symbol.description); // es
 console.log(Symbol("es") === Symbol("es")); // false
 console.log(symbol === symbol); // true
 console.log(symbol.description === "es"); // true
BigInt：表示一个任意精度的整数，可以表示超长数据，可以超出 2 的 53次方。

特别注意：

  • Number 类型的数字有精度限制，只能安全的表示 -253-1 和 253-1 范围内的值。超出这个范围的整数，就无法精确表示了。
  • Bigint 没有位数的限制，任何位数的整数都可以精确表示。但是其只能用于表示整数，且为了与 Number 进行区分，BigInt 类型的数据必须添加后缀 n。
  • BigInt 可以使用负号，但是不能使用正号。
  • number 类型的数字和 Bigint 类型的数字不能混合计算。
// Number
console.log(2 ** 53) // 9007199254740992
console.log(Number.MAX_SAFE_INTEGER) // 9007199254740991

// BigInt
const bigInt = 9007199254740993n
console.log(bigInt) // 9007199254740993n
console.log(typeof bigInt) // bigint
console.log(1n == 1) // true
console.log(1n === 1) // false
const bigIntNum = BigInt(9007199254740993n)
console.log(bigIntNum) // 9007199254740993n

对象类型

数组（Array）

// Array 类型
// 数组集合，可以通过 type[] 或 Array<type> 为数组内的元素指定类型
let arr1: string[] = ['a', 'b', 'c'];
let arr2: Array<string> = ['d', 'e', 'f'];

// any在数组中的应用
// 一个比较常见的做法是，用 any 表示数组中允许出现任意类型：
let list: any[] = ['sakura', 21, { website: 'https://baidu.com' }];

元组（Tuple）

// Tuple 类型
// 元组允许表示一个已知元素数量和类型的数组，各元素的类型不必相同
let tup: [string, number];
tup = ['hello', 2];
// tup = [2, 'a'];  Error

枚举（Enums）

// Enums 类型
// 枚举类型用于定义数值集合
// 列出所有可用值，一个枚举的默认初始值为0，可以调整开始的数字
enum Role {Student = 3, Teacher, Chairman};
let role1: Role = Role.Student;
let role2: Role = Role.Teacher;
let role3: Role = Role.Chairman;
console.log(role1, role2, role3);  // 3, 4, 5

Set 对象

Set 是 ES6 中新的数据结构，允许存储任何类型的值，原始值或者是对象引用，但成员的值是唯一的，没有重复的值。
Set 本身是一个构造函数，用来生成Set 数据结构。Set函数可以接受一个数组（或者具有 iterable 接口的其他数据结构）作为参数，用来初始化。
Set 对象的声明：
const set = new Set()
Set 实例对象的属性：

  • size：返回 Set 实例中的成员总数

Set 实例对象的方法：

  • add()：在 Set 对象尾部添加一个元素。返回该 Set 对象
  • delete()：移除 Set 的中与这个值相等的元素，有则返回 true，无则返回 false
  • clear()：清除 Set 的所有元素
  • has()：是否存在这个值，如果存在为 true，否则为 false

遍历方法：

  • keys()：返回键名的遍历器
  • values()：返回键值的遍历器
  • entries()：返回键值对的遍历器
  • forEach()：使用回调函数遍历每个成员
 let map = new Set()
 
 //set()
 map.set('a', 1)
 map.set('b', 2)
 console(map) // Map(2) {'a' => 1, 'b' => 2}
 
 //get
 map.get("a") // 1
 
 //size
 console(map.size) // 2
 
 //delete()
 map.delete("a") // true
 console(map) // Map(1) {'b' => 2}
 
 //has()
 map.has('b') // true
 map.has(1) // false
 
 //clear()
 map.clear()
 console(map) // Map(0) {}
 
 let arr = [["a", 1], ["b", 2], ["c", 3]]
 let map = new Map(arr)
 
 // keys()
 for (let key of map.keys()) {
    console.log(key); // 以此打印：a b c
 }
 
 //values()
 for (let value of map.values()) {
    console.log(value); // 以此打印：1 2 3
 }
 
 //entries()
 for (let data of map.entries()) {
    console.log(data); // 以此打印：["a", 1] ["b", 2] ["c", 3]
 }
 
 //forEach
 map.forEach((item) => {
    console.log(item)// 以此打印：1 2 3
 });

Map 对象

Map 是 ES6 中新的数据结构，Map 对象用于保存键值对。任何值(对象或者原始值) 都可以作为一个键或一个值。构造函数 Map 可以接受一个数组作为参数。
Map和Object的区别

  • Map中的键值是有序的（FIFO 原则），而添加到对象中的键则不是。
  • Map的键值对个数可以从 size 属性获取，而 Object 的键值对个数只能手动计算。
  • Object 都有自己的原型，原型链上的键名有可能和你自己在对象上的设置的键名产生冲突。

Map 对象的声明：
const set = new Map()
const set = new Map(Array)
属性：

  • size：返回 Map 实例中值的个数

方法：

  • set(): 添加Map后的一个键值对，返回实例
  • get(): 返回键值对
  • delete(): 移除Map的中与这个值相等的元素，有则返回true,无则返回false
  • clear(): 清楚Map的所有元素
  • has(): 是否存在这个值，如果存在为 true，否则为false

遍历方法：

  • keys()：返回键名的遍历器
  • values()：返回键值的遍历器
  • entries()：返回键值对的遍历器
  • forEach()：使用回调函数遍历每个成员
 let map = new Set()
 
 //set()
 map.set('a', 1)
 map.set('b', 2)
 console(map) // Map(2) {'a' => 1, 'b' => 2}
 
 //get
 map.get("a") // 1
 
 //size
 console(map.size) // 2
 
 //delete()
 map.delete("a") // true
 console(map) // Map(1) {'b' => 2}
 
 //has()
 map.has('b') // true
 map.has(1) // false
 
 //clear()
 map.clear()
 console(map) // Map(0) {}
 
 let arr = [["a", 1], ["b", 2], ["c", 3]]
 let map = new Map(arr)
 
 // keys()
 for (let key of map.keys()) {
    console.log(key); // 以此打印：a b c
 }
 
 //values()
 for (let value of map.values()) {
    console.log(value); // 以此打印：1 2 3
 }
 
 //entries()
 for (let data of map.entries()) {
    console.log(data); // 以此打印：["a", 1] ["b", 2] ["c", 3]
 }
 
 //forEach
 map.forEach((item) => {
    console.log(item)// 以此打印：1 2 3
 });

对象（Object）

// object 类型用于表示非原始类型
let objectCase: object;
objectCase = 1; // error
objectCase = "a"; // error
objectCase = true; // error
objectCase = null; // error
objectCase = undefined; // error
objectCase = {}; // ok


// Object 类型代表所有拥有 toString、hasOwnProperty 方法的类型 
// 所以所有原始类型、非原始类型都可以赋给 Object(严格模式下 null 和 undefined 不可以)
let simpleCase: {};
simpleCase = 1; // ok
simpleCase = "a"; // ok
simpleCase = true; // ok
simpleCase = null; // error
simpleCase = undefined; // error
simpleCase = {}; // ok


// 使用object类型，就可以更好的表示像Object.create这样的API
declare function create(o: object | null): void;
create({ prop: 0 }); // OK
create(null); // OK

// create(42); // Error
// create("string"); // Error
// create(false); // Error
// create(undefined); // Error

// 对象类型可以指定一些甚至所有的属性为可选的，你只需要在属性名后添加一个 ?:

function getName(obj: { name: string; age?: number }): void {
    console.log(obj.name);
    console.log(obj.age);
}

getName({ name: "Sakura" });

// {} 空对象类型和 Object 一样，也是表示原始类型和非原始类型的集合
let simpleCase: {};
simpleCase = 1; // ok
simpleCase = "a"; // ok
simpleCase = true; // ok
simpleCase = null; // error
simpleCase = undefined; // error
simpleCase = {}; // ok

函数（Function）

// 参数类型注解
function sum(x: number, y: number): number {
  return x + y;
}

// 输入多余的（或者少于要求的）参数，是不被允许的：

sum(1);
// 应有 2 个参数，但获得 1 个

sum(1, 2, 3); 
// 应有 2 个参数，但获得 3 个


// 可选参数和参数默认值
function hello(name1: string, name2?: string): void {
  console.log(`hello! ${name1} ${name2 ? "and" + " " + name2 : ""}`);
}

hello("余光1", "余光2"); 
// hello! 余光1 and 余光2
hello("余光"); 
// hello! 余光


// 匿名函数
const arr = [1, 2, 3, 4];

arr.forEach((val) => {
  val.toFixed(1);
});
// ✅

arr.forEach((val) => {
  val.split("-");
});
// ❌ 类型“number”上不存在属性“split”。

任意值（Any）、未知类型（Unknown）

// Any
// 在 TypeScript 中，任何类型都可以被归为 any 类型。
// 这让 any 类型成为了类型系统的顶级类型（也被称作全局超级类型）。
let any: any = 1;
let any: any[] = [1, 'a', false];

// TypeScript 允许我们对 any 类型的值执行任何操作，而无需事先执行任何形式的检查
let value: any;

value.foo.bar; // OK
value.trim(); // OK
value(); // OK
new value(); // OK
value[0][1]; // OK

// 一般使用场景： 第三方库没有提供类型文件时可以使用 any 类型转换遇到困难或者数据结构太复杂难以定义 
// 不过不要太依赖 any, 否则就失去了 ts 的意义了


// Unknown
// 就像所有类型都可以赋值给 any，所有类型也都可以赋值给 unknown。
// 这使得 unknown 成为 TypeScript 类型系统的另一种顶级类型
let value: unknown;

value = true; // OK
value = 42; // OK
value = "Hello World"; // OK
value = []; // OK
value = {}; // OK
value = Math.random; // OK
value = null; // OK
value = undefined; // OK
value = new TypeError(); // OK
value = Symbol("type"); // OK

// unknown 和 any 的主要区别是 unknown 类型会更加严格 
// 在对 unknown 类型的值执行大多数操作之前 我们必须进行某种形式的检查 
// 而在对 any 类型的值执行操作之前 我们不必进行任何检查
// 所有类型都可以被归为 unknown 但unknown类型只能被赋值给 any 类型和 unknown 类型本身 
// 而 any 啥都能分配和被分配
let value: unknown;

let value1: unknown = value; // OK
let value2: any = value; // OK
let value3: boolean = value; // Error
let value4: number = value; // Error
let value5: string = value; // Error
let value6: object = value; // Error
let value7: any[] = value; // Error
let value8: Function = value; // Error


let value: unknown;

value.foo.bar; // Error
value.trim(); // Error
value(); // Error
new value(); // Error
value[0][1]; // Error

// 将 value 变量类型设置为 unknown 后，这些操作都不再被认为是类型正确的。
// 通过将 any 类型改变为 unknown 类型，我们已将允许所有更改的默认设置，更改为禁止任何更改。

空值（Void）、Never

// Void 类型
// JavaScript 没有空值 Void 的概念，在 TypeScirpt 中，可以用 void 表示没有任何返回值的函数。
function alertName(): void {
    console.log('My name is changdong');
}


// Never 类型
// never 是其它类型（包括 null 和 undefined）的子类型，代表从不会出现的值。
// 这意味着声明为 never 类型的变量只能被 never 类型所赋值，在函数中它通常表现为抛出异常或无法执行到终止点（例如无限循环)。
let a: never;
let b: number;
// a = 123; // 运行错误，数字类型不能转为 never 类型
a = (() => { throw new Error('never')})(); // 运行正确，never 类型可以赋值给 never类型
b = (()=>{ throw new Error('exception')})(); // 运行正确，never 类型可以赋值给 数字类型
// 返回值为 never 的函数可以是抛出异常的情况
function error(message: string): never {
    throw new Error(message);
}
// 返回值为 never 的函数可以是无法被执行到的终止点的情况
function loop(): never {
    while (true) {}
}

字面量类型

在 TypeScript 中，字面量不仅可以表示值，还可以表示类型，即所谓的字面量类型。
目前，TypeScript 支持 3 种字面量类型：字符串字面量类型、数字字面量类型、布尔字面量类型，对应的字符串字面量、数字字面量、布尔字面量分别拥有与其值一样的字面量类型，

let flag1: "hello" = "hello";
let flag2: 1 = 1;
let flag3: true = true;

变量上的类型注解（Type Annotations on Variables）

// 使用 const、var、let 声明一个变量时，你可以选择性的添加一个类型注解，显式指定变量的类型：
let myName: string = "Sakura";

// TypeScript 并不使用“在左边进行类型声明”的形式，比如 int x = 0；类型注解往往跟在要被声明类型的内容后面。
// 不过大部分时候，这不是必须的。因为 TypeScript 会自动推断类型。举个例子，变量的类型可以基于初始值进行推断：

// No type annotation needed -- 'myName' inferred as type 'string'
let myName = "Sakura.";

联合类型（Union Types）

// 联合类型通常与 null 和 undefined 一起使用
const sayHello = (name: string | undefined) => {
  console.log('hello ' + name);
};

// name 的类型是 string | undefined 意味着可以将 string 或 undefined 的值传递给sayHello 函数。
sayHello("sember");
sayHello(undefined);

// 也许在某处你想传入一个string或null或undefined，你可以使用联合类型string | null | undefined。
// 启用 --strictNullChecks
let num2: number | null | undefined;
num2 = 1; // 运行正确
num2 = undefined;    // 运行正确
num2 = null;    // 运行正确

// 配合字面量进行使用，用来约束取值只能是某几个值中的一个。
let num: 1 | 2 = 1;
type EventNames = 'click' | 'scroll' | 'mousemove';

// 当TypeScript不确定一个联合类型的变量到底是哪个类型的时候
// 我们只能访问此联合类型的所有类型里共有的属性或方法：
function getLength(something: string | number[]): number {
    return something.length;
}
// ✅
function getLength(something: string | number): number {
    return something.length;
}
// ❌ 类型“string | number”上不存在属性“length”。类型“number”上不存在属性“length”。

交叉类型

交叉类型是将多个类型合并为一个类型。通过 & 运算符可以将现有的多种类型叠加到一起成为一种类型，它包含了所需的所有类型的特性

type Flag1 = { x: number };
type Flag2 = Flag1 & { y: string };

let flag3: Flag2 = {
  x: 1,
  y: "hello",
  henb,
};

类型别名

// 类型别名用来给一个类型起个“新”名字。例如：

type hasLen = string | number[]; // isNumber就是新名字，他可能更语义化一些
const arr: hasLen = [1];


// 又或者，常用语给一个联合类型定义自己的类型别名

type Name = string; // 字符串
type NameResolver = () => string; // 函数
type NameOrResolver = Name | NameResolver; // 联合类型

function getName(n: NameOrResolver): Name {
  if (typeof n === "string") {
    return n;
  } else {
    return n();
  }
}

function getName(obj: { name: string; age: number }): void {
  console.log(obj.name);
  console.log(obj.age);
}

const res = getName({ name: "Sakura", age: 22 });
椿生Sakura.
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
理解 TypeScript 背后的结构化类型系统
发果叁
01-29 491
基于类型结构进行类型兼容性判断关键体现在两个类型的比较当中，当两个类型比较时，如果是按照属性和方法是否相同来比较的话就称为结构化类型系统，也叫鸭子类型。')}')}虽然invokeSay函数接收的参数类型是Dog，但是由于Cat类型的结构和Dog是一样的（都是只有一个 say 方法），因此会被认为是同一种类型，这就是结构化类型的特点，基于类型结构进行类型兼容性判断代表语言：C#、Python、Objective-C基于类型名进行兼容性判断/** @description 人民币 */
vscode中vue3+ts报类型“{ }“上不存在属性“ “，以及ts.config.app.json和tsconfig.node.json中报错（彻底解决）
LLL3189860667的博客
07-26 1万+
亲爱的小伙伴们，你们是否遇到过使用vscode打开vue3+ts项目时一片爆红，一直提示类型"{}"上不存在属性 ""，以及ts.config.app.json和tsconfig.node.json中报“在没有"node"模块解析策略的情况下，无法指定选项"-resolveJsonModule”的问题，不要担心，不要着急，看了很多篇的博客，我终于是彻底解决了这些恶心的报错，然后就迫不及待地想要分享给大家，希望对各位有所帮助哦！
类型“{}”上不存在属性“xxx”。ts(2339)-解决方案集锦
最新发布
BWCX_NLFD_K的博客
06-12 289
把 tsconfig.json 里面的 compilerOptions 下的 moduleResolution 属性值改成 node！在 tsconfig.json 里面添加下面配置。重启 Vue - Official 插件。一、方案一（优先尝试）二、方案二（优先尝试）
解决：类型“{}”上不存在属性“xxx”
qq_48783694的博客
03-19 1182
卸载vscode中的插件：typeScript Vue Plugin。
解决Vue3的ts报错：类型“{}”上不存在属性“xxx”，三种方法彻底根治
热门推荐
05-09 4万+
网上找了各种原因，有让添加jsconfig.json文件的，有让新建一个项目的，有的直接放弃ts的，哈哈哈，真的是千奇百怪都有，好吧，我这里就也出一种方法，不要用vscode了，使用WebStorm，哈哈哈，可能让你也想不到吧，但是真的有效啊：请看效果，就不报错了，撒花。
ts2339错误：类型{}上不存在属性“xxx“
南沙的星星
12-18 1万+
正确姿势：const aaa:any = {};
React + TS 报错：类型“Readonly＜{}＞”上不存在属性“name”
lhz_333的博客
07-12 4956
解决父子组件传参报错：类型“Readonly”上不存在属性“name”。
报错类型“{}”上不存在属性“”
m0_48390697的博客
07-21 9879
报错类型“{}”上不存在属性“”
TypeScript学习
yuan_xiaoxin的博客
06-30 142
TypeScript学习介绍TS和JS的不同点1. 类型注解2. **变量在终端打印**3. TS中的数据类型4. Any 类型详情5. 位运算符6. 带参数函数TypeScriptJavaScript7. 可选参数和默认参数可选参数TypeScriptTS和JS的相同点1. 变量的命名规则和规范2. 空白和换行3. TypeScript 保留关键字4. 算术运算符5. 关系运算符6. 逻辑运算符7. 条件语句和循环总结: 介绍 通过本篇文章 你可以通过了解TS和JS 不同之处和相同之处来学习T
typeScript学习笔记
04-27
TypeScript学习笔记 TypeScript是一个自由和开源的编程语言，由微软开发。它是JavaScript的一个超集，扩展了JavaScript的语法，解决了JavaScript的“痛点”：弱类型和没有命名空间，导致很难模块化。TypeScript支持...
TypeScript 学习笔记之基本类型
09-03
TypeScript 是一种强大的静态类型语言，它是 JavaScript 的超集，扩展了 JS 的功能，特别是引入了类型系统。在 TypeScript 中，类型系统增强了代码的可预测性、稳定性和可维护性，使得开发者能够在编码阶段捕获潜在...
TypeScript类型声明书写详解
10-16
TypeScript是一种静态类型的强类型语言，它扩展了JavaScript，提供了丰富的类型系统，使得代码更加健壮和可维护。...通过查看开源库如lodash的类型声明，我们可以学习到更多实际应用中的类型定义技巧。
typescript学习笔记
03-04
Typescript 学习笔记 TypeScript 是一种静态类型的编程语言，作为 JavaScript 的超集，它的主要特性是坚持与 ECMAScript 标准同步发展。下面是 TypeScript 的一些重要知识点： 一、ECMAScript 标准同步发展 * ...
Typescript类型脚本课件.pptx
06-19
Typescript类型脚本课件 Typescript是一种静态类型检查的JavaScript超集语言，由Microsoft开发，代码开源于GitHub上。Typescript的主要特点是提供了类型系统和对JS新标准的支持（ES6/7/8）。 Typescript可以帮助...
[ts] TypeScript语法学习笔记
weixin_61625219的博客
03-22 1024
[ts] TypeScript语法学习笔记
TS 类型上不存在属性( Property ‘$xxx‘ does not exist on type ‘xxx‘；)
MISSNext的博客
07-05 1万+
问题 访问vue原型绑定的属性，在组件中使用的时候报错，如果使用eslint 运行不起来 解决 方式1（繁琐，使用页面需要增加多个） $http:any this.$http 方式2 (繁琐，使用此方法的组件都需要声明一次) [x:string]:any 方式三（建议使用这一种） 在src目录下新增xxx.d.ts文件 （全局声明简捷 如下） import VueRouter, { Route } from 'vue-router'; declare module 'vue/types/vue
解决新建vue3+ts项目报错类型“{}“上不存在属性
m0_47301039的博客
08-09 3650
解决新建vue3+ts项目报错类型“{}“上不存在属性
typescript 如何学习
05-09
TypeScript 是一种由 Microsoft 开发的开源编程语言，它是 JavaScript 的超集，提供了更多的功能和类型检查，可以更好地帮助开发者编写更可靠的代码。 以下是学习 TypeScript 的一些步骤： 1. 学习 JavaScript 基础知识：TypeScript 是 JavaScript 的超集，因此首先需要掌握 JavaScript 的基础知识。 2. 学习 TypeScript 的基础语法：了解 TypeScript 的基础语法，包括变量声明、数据类型、函数、类等。 3. 学习 TypeScript 的高级特性：了解 TypeScript 的高级特性，例如泛型、接口、枚举、装饰器等。 4. 使用 TypeScript 开发项目：在实际项目中使用 TypeScript，可以更好地理解 TypeScript 的使用方法和优势。 5. 学习 TypeScript 的工具和框架：掌握 TypeScript 的工具和框架，例如 TypeScript 编译器、TypeScript 的语法高亮插件、Angular 框架等。 6. 参与 TypeScript 社区：参与 TypeScript 社区，了解最新的 TypeScript 版本和技术，也可以与其他 TypeScript 开发者交流经验和技巧。 总之，学习 TypeScript 需要掌握 JavaScript 基础知识，了解 TypeScript 的基础语法和高级特性，实践使用 TypeScript 开发项目，并参与 TypeScript 社区。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值