BigInt 可以表示任意大的整数，可用于实现高精度计算，也可转换为任意位的有符号及无符号数。

## 基础使用

初始化 BigInt 对象：

```js
// 字面量
let n = 1n

// 将整数转换为 BigInt，前提是需要满足整数范围的数，不然未传入时已丢失精度
let n = BigInt(1)

// 将字符串读取为转换为 BigInt
let n = BigInt("11111111111111111111111")

```

数学运算：

```js
// 支持 +、*、-、**、%，需要 BigInt 之间相互运算
let b = BigInt(a) * 2n
```

转为 64 位数，传入：

```js
// 将 BigInt 转换为 64 位整数
let a = BigInt.asIntN(64, -1n)

// 将 BigInt 转换为 64 位无符号整数
let b = BigInt.asUintN(64, -1n)
```

## 模拟 int 或 long long 类型

有时看到其他语言的题解，会利用 int 或 long long 类型进行计算。JS 的 number 类型行为与这些类型有各种不同。

而通过 BigInt 的转换方法，可模拟作为 64 位有符号整数进行计算，可达到类似于 long long 的效果，数值超出时是取模的效果。

数值读取时转换一次，计算后再次转换即可：

```js
let a = BigInt.asIntN(64, "...")
let b = BigInt.asIntN(64, "...")
let c = BigInt.asIntN(64, a * b)
```


通过 BigInt 实现大整数高精度计算，及模拟 long long 等类型的数值计算

在做一道图相关的题目时，使用了数组模拟链表，进行邻接表存储图的形式，代码如下：

```js
let h = [], e = [], ne = [], idx = 0
```

这段代码习惯性地声明在了全局变量中。

这个代码基本逻辑是比较熟悉的，按理说根据曾经做过的方法照样写就不会错的，但是却始终无法通过全部用例。

最后把这段数组的声明提取到入口函数中，发现直接执行通过了。

搜索了一下，才发现 LeetCode 提交代码时，代码中的全局变量有时可能无法完成初始化，仍保留上次的值。才想起来之前就看过类似的说法，这次算是亲自体验了一把。

所以要么不使用全局变量，要么在执行的入口函数中再次初始化**所有**的全局变量。

有时候使用了全局变量，因业务逻辑没有报错，但是因为未初始化，使动态数组变可能得很大，也会极大影响执行效率。


从邻接表存储图提交错误，体验 LeetCode 全局变量无法重新初始化问题

## 字符串

### ansii 码与字符互转

```javascript
'a'.charCodeAt()
String.fromCharCode(97)
```

### 补充头部

整型转为 32 位二进制表示：

```javascript
console.log((123).toString(2).padStart(32, '0'))
```

## 数值

### 整数范围

数值最大范围：

```javascript
console.log(Number.MAX_VALUE) // 1.7976931348623157e+308
console.log(Number.MIN_VALUE) // 5e-324
```

能表示的整数范围

```javascript
console.log(Number.MAX_SAFE_INTEGER) // 9007199254740991
console.log(Number.MIN_SAFE_INTEGER) // -9007199254740991
```


```


JS 算法刷题字符串、数值处理语法查漏补缺

Set 和 Map 在工程项目中不常用，但算法刷题中常常用到。

## 集合 Set

一种**无序且唯一**的数据结构

```js
const set = new Set();
set.add(1);
set.add(2);
if (set.has(1)) {
  set.delete(1);
}
console.log(set.size);

// 遍历
set.forEach(val => {
    console.log(val)
})
for (let val of set) console.log(val);

// 创建为数组、数组去重
const arr = [...set]; // Array.from(set)
```

## Map

js 中，优先使用 Map 而不是 Object：

- 它可以存放任意类型的 key 值，在频繁增删键值对的场景下表现更好。
- 在 LeetCode 中，Map 性能比 object 更好。
- 它的 key 值顺序为首次插入的顺序，但是 object 不一定保持这个顺序，有时是字典序

```js
var map = new Map();
map.set(1, 0);
map.set(2, 1);
if (map.has(2)) {
  map.delete(2);
}
console.log(map.get(2));
console.log(map.size);

// 遍历
map.forEach((val, key) => {
    console.log(key, val)
})
for (let [key, value] of map) console.log(key, value);
for (let val of set) console.log(val);
```

初始化时赋值：

```js
let first = new Map([
  [1, "one"],
  [2, "two"],
  [3, "three"],
]);
```

JS 中的 Set 和 Map

用 JS 去写需要自行获取输入的算法平台时，除了处理输入稍微繁琐，总体来说没有什么问题。对于获取输入流，我整理了一个模板框架，个人感觉还是比较好用的，可以做到像其他语言一样按行读取。

可借助编辑器的快捷输入，去使用这套模板框架，比如：

- IDEA: Live Template
- VSCode: User snippets (File->Preferences->User snippets)
- 可通过 codemirror 的 autocomplete ，封装一个自己的 Web IDE

### abuf 基础框架模板

包括：

- 读取所有输入流放到字符串
- 定义常用的方法简写 af 和 log
- 入口函数 run 方法，传参输入流字符串，方便本地调试时传入题目用例
- 将输入流字符串拆分，提供按行读取的方法 readline

```js
let bs = ''
process.stdin.on('data', d => bs += d)
process.stdin.on('end', () => run(bs))

const af = Array.from
const log = console.log

function run(bs) {
  let buf = bs.trim().split('\n'), bp = 0
  let readline = () => buf[bp++]
  
  let [n] = readline().split(' ').map(x => +x)
}
```

### areadline 读取一行并拆分

继续读取下一行，并按空格拆分：

```
let line = readline().split(' ').map(x => +x)
```

应用场景：

- 可嵌套在 for 中使用，比如接下来读n行，遍历n次，每次使用这个 areadline 读取。
- 可直接使用 line 数组；或者使用解构赋值设置变量。

### aarr 创建指定长度的数组

算法题往往需要创建指定长度的数组。

备注：**不要将以下代码封装为函数**，而是**直接使用**。封装为函数的话，创建多层数组，会遭到优化，导致每一个二级数组都指向同一个地址。

```js
af({length: n}, () => )
```


好用的原创 JS 算法题输入流读取模板

使用 JavaScript 刷题，最大的缺陷就是没有优先队列/堆这个数据结构。不过，LeetCode 引入了 datastructures-js/priority-queue 库，可以使用。

## 库介绍

LeetCode 编辑器语言选择 JavaScript，它旁边有提示图标，点击看到，如需使用优先队列，可使用 `datastructures-js/priority-queue@5.3.0`。

这个库实现了最大堆、最小堆，以及自行指定优先规则回调的优先队列。

## 安装

https://www.npmjs.com/package/@datastructures-js/priority-queue

```
npm i -D @datastructures-js/priority-queue@5.3.0
```

安装后就可以本地调试了，本地需要从库中引入类。因为该库支持 TS，在编辑器中会有较好的提示。

使用方法： https://github.com/datastructures-js/priority-queue/tree/v5.3.0

## 使用

在答题时，使用时，不需要引入，直接用即可。

提供类： PriorityQueue

构造函数：传入对象，通过 compare 对象传入比较函数。

如创建大根堆与小根堆，其中 compare  与 sort 的一样，传入 `a - b` 或 `a > b ? 1 : -1` 是从小到大，为小根堆，反之 `b - a` 为大根堆：

```js
const pq = new PriorityQueue({compare: (a, b) => a - b}) // 小根堆
const pq = new PriorityQueue({compare: (a, b) => b - a}) // 大根堆
```

常用方法：

- enqueue(x)  入队  / dequeue() 出队并返回元素
- size() 返回长度
- front() 返回优先级最高的元素
- clear() 清空

尝试使用其处理堆的经典题目, leetcode 215. 数组中的第K个最大元素：

```js
var findKthLargest = function (nums, k) {
    const pq = new PriorityQueue({compare: (a, b) => a - b})
    for (let i = 0; i < nums.length; i++) {
        pq.enqueue(nums[i])
        if (pq.size() > k) pq.dequeue()
    }

    return pq.front()
};
```


LeetCode 中 JavaScript 的 priority-queue


## 进制表示

```js
let a = 0b10100; //二进制
let b = 0o24; //八进制
let c = 20; //十进制
let d = 0x14; //十六进制
console.log(a == b);
console.log(b == c);
console.log(c == d);
```

## 进制转换

10 进制转任意进制 10 进制数.toString(目标进制)

```js
console.log(c.toString(2));
```

任意进制转十进制 parseInt('任意进制字符串', 原始进制);

```js
console.log(parseInt("10100", 2));
```

## 不支持显示与使用符号位

js 计算时使用的是四字节的整型，即跟 C 语言的 int 类似。包括使用“取反”这个位运算的时候，得到的结果都是跟 C 语言 int 一致的。如:  `~147` 得到 `-148`。另外，也有 `>>>` 这个无符号右移运算符。

但进制的表示与转换，不支持负数符号位显示，都会把数当做正整数处理。如果是进制转化，会在前面加一个负号。

比如 C 处理 `printf("%X\n", -14);` 得到 `fffffff2` ，包含符号位；

JS 处理 `console.log((-14).toString(2));` 却得到 `-1110`,  即 14 的二进制 `1110` 前面加了负号。

## 写一个整数转化完整二进制表示的方法

由于运算时，js 的整数是有符号 32 位整数。遍历 32 次，求得每个位置显示的值，即可得到数值的完整的二进制表示。

每个位置显示的值：把该位移到最右 (`num >> i`) 后，与 `000...0001` 进行与运算 （前面都是0，所以都会返回0，得到最右位置的值，看看它是 0 还是 1）。

```js
function toBin(num){
    let s = ''
    for(let i = 0; i < 32; i++) {
        s = String(num >> i & 1) + s
    }
    return s;
}
```

- toBin(10)  得到 00000000000000000000000000001010
- toBin(-10) 得到 11111111111111111111111111110110
- -10 的二进制，正好是 10 的反码加 1，得到的结果正确