193 lines
4.6 KiB
Markdown
193 lines
4.6 KiB
Markdown
# 以下是关于 ts（以及任何关于 ts 的不限于语法，技巧之类的学习心得）
|
|
|
|
## any unknown void never
|
|
|
|
- any 表示任意类型。这导致不会对类型进行任何检查，用太多不太好就是了。
|
|
- unknown 表示位置类型。看作 any 的安全版本。可以赋值为任何类型，但在使用之前必须进行类型检查或类型断言。
|
|
- void 代表没有返回值。
|
|
- never 代表永远不会有任何返回值，如死循环或抛出异常。
|
|
|
|
## 接口 interface
|
|
|
|
- 基本可以认为是声明 object 类型用的东西
|
|
|
|
## 泛型 <T>
|
|
|
|
- 实际上可以理解为是一种类型的变量
|
|
- 如：
|
|
|
|
```ts
|
|
function identity<T>(arg: T): T {
|
|
return arg
|
|
}
|
|
|
|
// 使用泛型函数
|
|
let result = identity<string>('Hello')
|
|
console.log(result) // 输出: Hello
|
|
|
|
let numberResult = identity<number>(42)
|
|
console.log(numberResult) // 输出: 42
|
|
|
|
// 基本语法
|
|
interface Pair<T, U> {
|
|
first: T
|
|
second: U
|
|
}
|
|
|
|
// 使用泛型接口
|
|
let pair: Pair<string, number> = { first: 'hello', second: 42 }
|
|
console.log(pair) // 输出: { first: 'hello', second: 42 }
|
|
```
|
|
|
|
## 箭头函数与普通函数的区别
|
|
|
|
- 箭头函数没有 yield
|
|
- 无 prototype
|
|
- 没有 this 和 arguments
|
|
|
|
## 使用 Object.freeze()
|
|
|
|
- Object.freeze() 可以冻结一个对象，使其不能添加、删除或修改属性。
|
|
|
|
```ts
|
|
const obj = { key: 'value' };
|
|
Object.freeze(obj);
|
|
|
|
obj.key = 'new value'; // 无效
|
|
obj.newKey = 'new value'; // 无效
|
|
delete obj.key; // 无效
|
|
|
|
console.log(obj);
|
|
```
|
|
|
|
## 使用 Object.defineProperty()使对象某一 key 其不可变
|
|
|
|
- Object.defineProperty() 可以定义对象属性，并使其不可变。
|
|
|
|
```ts
|
|
const obj = {};
|
|
Object.defineProperty(obj, 'key', {
|
|
value: 'value',
|
|
writable: false,
|
|
configurable: false // 不可配置的
|
|
});
|
|
|
|
obj.key = 'new value'; // 无效
|
|
delete obj.key; // 无效
|
|
|
|
console.log(obj); // 输出: { key: 'value' }
|
|
```
|
|
|
|
## Object.seal()。
|
|
|
|
- Object.seal() 可以让对象不能添加或删除属性，但允许修改现有属性的值。
|
|
|
|
```ts
|
|
const obj = { key: 'value' };
|
|
Object.seal(obj);
|
|
|
|
obj.key = 'new value'; // 有效
|
|
obj.newKey = 'new value'; // 无效
|
|
delete obj.key; // 无效
|
|
|
|
console.log(obj);
|
|
```
|
|
|
|
## 判断是否为数组
|
|
|
|
- Array.isArray()
|
|
- instanceof Array
|
|
- obj.**proto** === [].**proto**
|
|
|
|
## 是否为 NaN
|
|
|
|
- Number.isNaN()
|
|
|
|
## obj 可迭代
|
|
|
|
- 实现了迭代器协议（拥有 Symbol.iterator 方法）实现了迭代器协议（拥有 Symbol.iterator 方法）
|
|
|
|
```ts
|
|
const iterable = {
|
|
*[Symbol.iterator]() {
|
|
yield 1;
|
|
yield 2;
|
|
yield 3;
|
|
}
|
|
}
|
|
```
|
|
|
|
## promise新的
|
|
|
|
- Promise.race(iterable) 接受一个可迭代对象，返回第一个解决或拒绝的 Promise 的结果。
|
|
- Promise.allSettled(iterable) 接受一个可迭代对象，返回一个 Promise，所有 Promise 无论解决或拒绝都会返回结果。
|
|
- Promise.any(iterable) 接受一个可迭代对象，返回第一个成功解决的 Promise 的结果。如果所有 Promise 都被拒绝，则返回一个拒绝的 Promise。
|
|
|
|
## deepReadonly
|
|
|
|
```ts
|
|
type DeepReadonly<T> = {
|
|
readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P]
|
|
}
|
|
|
|
```
|
|
|
|
## callable的对象
|
|
|
|
```ts
|
|
const callableObject = {
|
|
[Symbol('callable')](...args) {
|
|
console.log('Object called with args:', ...args);
|
|
// 执行一些操作并返回结果
|
|
return args.reduce((sum, val) => sum + val, 0);
|
|
}
|
|
}
|
|
```
|
|
|
|
## 异步迭代
|
|
|
|
```ts
|
|
const asyncIterable = {
|
|
async *[Symbol.asyncIterator]() {
|
|
yield await new Promise(resolve => setTimeout(() => resolve(1), 1000));
|
|
yield await new Promise(resolve => setTimeout(() => resolve(2), 1000));
|
|
yield await new Promise(resolve => setTimeout(() => resolve(3), 1000));
|
|
}
|
|
};
|
|
|
|
(async function() {
|
|
for await (const value of asyncIterable) {
|
|
console.log(value); // 输出: 1, 2, 3，每个值之间间隔1秒
|
|
}
|
|
})
|
|
```
|
|
|
|
|
|
---
|
|
|
|
二进制/文件处理
|
|
|
|
blob： 一种类文件对象，只能使用fileReader进行异步读取，读取为arrayBuffer
|
|
|
|
arraybuffer： 一种通用的二进制数据缓冲区，需要通过视图（如uint8array）进行修改
|
|
|
|
---
|
|
|
|
关于闭包，有逻辑的回答：
|
|
|
|
闭包（closure）指有权访问另一个函数作用域中变量的函数。 ----- JavaScript 高级程序设计
|
|
闭包有什么用？
|
|
|
|
延伸变量作用域范围，读取函数内部的变量
|
|
让这些变量的值始终保持在内存中
|
|
|
|
简单理解就是 ，一个作用域可以访问另外一个函数内部的局部变量。
|
|
|
|
---
|
|
|
|
weakMap
|
|
|
|
key必须为一个obj
|
|
可以用于给一个obj附加一些生命周期相同的数据内容（如缓存）
|
|
|