TypeScript 类型学习

最新推荐文章于 2024-07-03 23:56:01 发布
最新推荐文章于 2024-07-03 23:56:01 发布
阅读量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学习笔记
04-27
TypeScript学习笔记 TypeScript是一个自由和开源的编程语言，由微软开发。它是JavaScript的一个超集，扩展了JavaScript的语法，解决了JavaScript的“痛点”：弱类型和没有命名空间，导致很难模块化。TypeScript支持...
TypeScript 学习笔记之基本类型
09-03
TypeScript 是 JavaScript 的超集，TypeScript 经过编译之后都会生成 JavaScript 代码...TypeScript 最大的特点就是类型化，因此才叫做 TypeScript。比起弱类型的 JavaScript，类型化的 TypeScript 显得更加容易维护。
解决新建vue3+ts项目报错类型“{}“上不存在属性
m0_47301039的博客
08-09 3619
解决新建vue3+ts项目报错类型“{}“上不存在属性
解决：类型“{}”上不存在属性“xxx”
qq_48783694的博客
03-19 1143
卸载vscode中的插件：typeScript Vue Plugin。
ts2339错误：类型{}上不存在属性“xxx“
南沙的星星
12-18 1万+
正确姿势：const aaa:any = {};
类型“{}”上不存在属性“xxx”。ts(2339)-解决方案集锦
訾博（ZiBo）的博客
01-15 3183
类型“{}”上不存在属性“xxx”。ts(2339)
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”的问题，不要担心，不要着急，看了很多篇的博客，我终于是彻底解决了这些恶心的报错，然后就迫不及待地想要分享给大家，希望对各位有所帮助哦！
[ts] TypeScript语法学习笔记
weixin_61625219的博客
03-22 1009
[ts] TypeScript语法学习笔记
TypeScript环境下ElementUI报错类型“{}”上不存在属性“clearFiles”
Hanyeah的博客
01-18 927
typescript下类型“{}”上不存在属性“clearFiles”的解决办法
typescript学习笔记
03-04
Typescript 学习笔记 TypeScript 是一种静态类型的编程语言，作为 JavaScript 的超集，它的主要特性是坚持与 ECMAScript 标准同步发展。下面是 TypeScript 的一些重要知识点： 一、ECMAScript 标准同步发展 * ...
TypeScript类型声明书写详解
10-16
主要介绍了TypeScript类型声明书写详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Typescript类型脚本课件.pptx
06-19
Typescript类型脚本课件 Typescript是一种静态类型检查的JavaScript超集语言，由Microsoft开发，代码开源于GitHub上。Typescript的主要特点是提供了类型系统和对JS新标准的支持（ES6/7/8）。 Typescript可以帮助...
Vue3-ts报错：类型“never”上不存在属性“resetFields“
m0_56699208的博客
01-15 1658
此时formRef.value 的类型是 never ，要避免这个错误，将 ref 的初始值改为空即可。类型“never”上不存在属性“resetFields“
vue3(ts)类型“EventTarget”上不存在属性“value”
Gaojuncheng112的博客
04-17 5713
e.target在ts下的类型断言
TS如何解决属性在另一个类型中不存在的问题？
拯救世界的光太郎
12-28 5685
TS 在遇到以下这些条件语句时，会在语句的块级作用域内「收紧」变量的类型，这种类型推断的行为称作类型守卫 (Type Guard)。=、!==（这里列举常用的 4 种）类型守卫可以帮助我们在块级作用域中获得更为精确的变量类型这里就可以通过判断 animal 中是否存在 meow 属性，来确定变量是否为 Cat 类型的对象let call;// 鼠标放到 animal 上，可以看到类型被限定为 Cat } else {
vue3中绑定一个点击事件类型出现“{}”上不存在属性问题
qq_44866810的博客
02-05 2612
vue3中绑定一个点击事件类型出现“{}”上不存在属性问题
解决ts类型“never”上不存在属性“XXX”解决办法
m0_49566505的博客
06-08 1万+
这个问题是因为使用了ts但没有去定义它的类型比如这种 这里就会报错一个“never”上不存在属性“XXX”解决办法可以 targetList: [ ] as any,或者直接targetList: Array()
自定义组件传参
IT_IOS_MAN的博客
02-07 468
参数声明 Component({ // 参数 properties: { // 这里定义了innerText属性，属性值可以在组件使用时指定 innerText: { type: String, value: 'default value', } }, // 生命周期 lifetimes: { attached: function() { // 在组件实例进入页面节点树时执行 }, detached:
Vuex 核心揭秘：打造高效前端状态库
最新发布
a3098448071的博客
07-03 1132
状态（State）类似于 Vue 组件的data属性，用于存储组件的响应式数据。在 Vuex 中，state用于存储整个应用的全局状态。Getters类似于 Vue 组件的computed计算属性，它们用于从其他数据派生出新的数据。在 Vuex 中，getters用于从state中派生出一些状态，这些状态可以根据state的变化而缓存或重新计算。Mutations类似于 Vue 组件的methods中的方法，用于改变组件的data。在 Vuex 中，mutations用于改变state。
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、付费专栏及课程。

余额充值