# 以下是关于 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附加一些生命周期相同的数据内容（如缓存）