javascript

数组

for … in …

遍历数组中的键

for … of …

遍历数组中的值，或者字符串中的字符

map

map 方法会对数组中的每个元素执行一次提供的函数，并将结果放入一个新数组中。

用法

1	array.map(callback(currentValue[, index[, array]])[, thisArg])

参数说明：

callback: 生成新数组元素的函数，依次为每个元素执行，接收以下三个参数：
- currentValue: 当前处理的元素。
- index（可选）: 当前处理元素的索引。
- array（可选）: 调用 map 方法的数组本身。
thisArg（可选）: 执行 callback 时的 this 值。

返回值：

一个新数组，每个元素都是回调函数的返回值。

示例

1	const doubled = numbers.map(number => number * 2);

reduce

用于将数组中的所有元素通过一个累加函数合并成单一的值。

它常用于求和、计算平均值、数组扁平化等操作。

用法

1	array.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

参数说明：

callback: 在数组每个元素上执行的函数，接受四个参数：
- accumulator: 累计器，累加回调函数的返回值；它是上一次调用回调函数时返回的值，或者是提供的初始值（initialValue）。
- currentValue: 数组中正在处理的元素。
- index（可选）: 数组中正在处理的当前元素的索引。若提供 initialValue，则索引号为 0；否则为 1。
- array（可选）: 调用 reduce 的数组。
initialValue（可选）: 作为第一次调用回调函数时 accumulator 的值。如果未提供，则将数组的第一个元素作为初始值，并从第二个元素开始执行回调函数。

返回值：

函数累计处理的结果。

示例代码

1	const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);

foreach

与 map 不同的是，forEach 不会返回一个新数组，而只是执行提供的函数，并对原数组进行操作。

用法

1	array.forEach(callback(currentValue[, index[, array]])[, thisArg])

参数说明：

callback: 对每个元素执行的函数，接受三个参数：
- currentValue: 当前正在处理的元素。
- index（可选）: 当前元素的索引。
- array（可选）: 调用 forEach 的数组。
thisArg（可选）: 执行 callback 时的 this 值。

示例代码

1
2
3

numbers.forEach((number, index, array) => {
  array[index] = number * 2;
});

includes

includes 是 JavaScript 数组和字符串的方法，用于判断数组或字符串中是否包含特定的元素或子字符串。它返回一个布尔值。

语法

1	array.includes(searchElement, fromIndex)

参数说明

searchElement: 需要在数组中搜索的元素。
fromIndex（可选）: 从该索引处开始搜索 searchElement。如果省略，则从数组的开头开始搜索。

示例

const fruits = ['apple', 'banana', 'mango'];

console.log(fruits.includes('banana')); // 输出: true
console.log(fruits.includes('grape'));  // 输出: false
console.log(fruits.includes('apple', 1)); // 输出: false

unshift

unshift() 方法用于将一个或多个元素添加到数组的开头，并返回新数组的长度。

let arr = [1, 2, 3];
arr.unshift(0); // 添加一个元素
console.log(arr); // 输出: [0, 1, 2, 3]

arr.unshift(-2, -1); // 添加多个元素
console.log(arr); // 输出: [-2, -1, 0, 1, 2, 3]

push

push() 方法用于将一个或多个元素添加到数组的末尾，并返回新数组的长度。

let arr = [1, 2, 3];
arr.push(4); // 添加一个元素
console.log(arr); // 输出: [1, 2, 3, 4]

arr.push(5, 6); // 添加多个元素
console.log(arr); // 输出: [1, 2, 3, 4, 5, 6]

js数组初始化

1 2	//获得一个128长度每个元素都为数字 0 的数组 let nums = Array(128).fill(0)

splice

Array.from()

将类数组对象或可迭代对象转换为数组。
可选地使用映射函数处理每个元素。
可以方便地处理各种对象为数组的转换，非常灵活。

Map

在 JavaScript 中，Map 是一种键值对的数据结构，类似于对象，但有一些不同之处。Map 的键可以是任意类型（包括对象、函数等），而对象的键只能是字符串或符号。Map 提供了一些非常有用的方法和操作，常见操作如下：

创建 `Map`

创建一个新的空 Map：

1	const map = new Map();

也可以在创建时初始化 Map：

const map = new Map([
  ['name', 'Alice'],
  ['age', 25],
  [true, 'booleanKey']
]);

设置键值对 (`set`)

使用 set() 方法向 Map 中添加键值对。set() 方法会返回 Map 本身，因此可以进行链式调用。

1
2
3

map.set('name', 'Alice');
map.set('age', 25);
map.set(true, 'booleanKey');

链式调用：

1	map.set('city', 'New York').set('country', 'USA');

获取值 (`get`)

使用 get() 方法通过键获取对应的值。如果键不存在，则返回 undefined。

1
2
3

console.log(map.get('name')); // 输出 'Alice'
console.log(map.get('age'));  // 输出 25
console.log(map.get('nonExistentKey')); // 输出 undefined

检查是否存在键 (`has`)

使用 has() 方法检查 Map 中是否存在某个键。

1 2	console.log(map.has('name')); // 输出 true console.log(map.has('address')); // 输出 false

删除键值对 (`delete`)

使用 delete() 方法可以通过键删除一个键值对。如果删除成功，返回 true，否则返回 false。

1 2	map.delete('age'); console.log(map.has('age')); // 输出 false

清空 `Map` (`clear`)

使用 clear() 方法删除 Map 中所有的键值对。

1 2	map.clear(); console.log(map.size); // 输出 0

获取键值对的数量 (`size`)

使用 size 属性获取 Map 中的键值对数量。

const map = new Map([
  ['name', 'Alice'],
  ['age', 25]
]);
console.log(map.size);  // 输出 2

遍历 `Map` (`forEach`)

使用 forEach() 方法可以遍历 Map，对每个键值对执行回调函数。回调函数接收两个参数：值和键。

map.forEach((value, key) => {
  console.log(`${key}: ${value}`);
});
// 输出:a
// name: Alice
// age: 25

获取键 (`keys`)

使用 keys() 方法返回一个 Map 对象键的迭代器。

for (const key of map.keys()) {
  console.log(key);
}
// 输出:
// name
// age

获取值 (`values`)

使用 values() 方法返回一个 Map 对象值的迭代器。

for (const value of map.values()) {
  console.log(value);
}
// 输出:
// Alice
// 25

获取键值对 (`entries`)

使用 entries() 方法返回一个包含键值对的迭代器。

for (const [key, value] of map.entries()) {
  console.log(`${key}: ${value}`);
}
// 输出:
// name: Alice
// age: 25

Set

在 JavaScript 中，Set 是一种数据结构，它类似于数组，但 Set 中的每个值必须是唯一的。Set 提供了多种操作来管理和操作其元素。

创建`set`

可以用new set()创建一个新set，或者使用数组等可迭代对象来初始化

1
2
3

const set1 = new Set(); // 创建一个空的 Set
const set2 = new Set([1, 2, 3, 4, 5]); // 使用数组初始化 Set
console.log(set2); // 输出: Set { 1, 2, 3, 4, 5 }

添加元素 (`add`)

add() 方法用于向 Set 中添加新元素。如果元素已经存在，则不会添加重复的值。

const mySet = new Set();
mySet.add(1);
mySet.add(5);
mySet.add(1); // 不会添加重复的 1
console.log(mySet); // 输出: Set { 1, 5 }

删除元素 (`delete`)

delete() 方法用于从 Set 中删除指定的元素。如果删除成功，返回 true；否则返回 false。

1
2
3

const mySet = new Set([1, 2, 3]);
mySet.delete(2); // 删除值为 2 的元素
console.log(mySet); // 输出: Set { 1, 3 }

检查元素是否存在(`has`)

has() 方法用于检查 Set 中是否存在某个元素，返回布尔值。

1
2
3

const mySet = new Set([1, 2, 3]);
console.log(mySet.has(2)); // 输出: true
console.log(mySet.has(4)); // 输出: false

获取元素个数(`size`)

size 属性返回 Set 中元素的个数。

1 2	const mySet = new Set([1, 2, 3, 4]); console.log(mySet.size); // 输出: 4

清空Set (`clear`)

1
2
3

const mySet = new Set([1, 2, 3]);
mySet.clear(); // 清空 Set
console.log(mySet); // 输出: Set {}

遍历 Set (`forEach`, `for...of`)

可以使用 forEach() 或 for...of 循环遍历 Set 中的每个元素。

const mySet = new Set([1, 2, 3]);
mySet.forEach((value) => {
  console.log(value);
});

const mySet = new Set([1, 2, 3]);
for (let value of mySet) {
  console.log(value);
}
// 输出:
// 1
// 2
// 3

转换为数组 (`Array.from` 或展开运算符 `...`)

可以将 Set 转换为数组。

使用 Array.from()：

1
2
3

const mySet = new Set([1, 2, 3]);
const arr = Array.from(mySet);
console.log(arr); // 输出: [1, 2, 3]

使用展开运算符 ...：

1
2
3

const mySet = new Set([1, 2, 3]);
const arr = [...mySet];
console.log(arr); // 输出: [1, 2, 3]

set的迭代方法

Set 支持多种迭代方法，可以获取键、值、键值对（键和值是一样的）。

keys(): 返回 Set 对象中的键的迭代器（与 values() 相同，Set 中的键和值是一样的）。
values(): 返回 Set 对象中的值的迭代器。
entries(): 返回 Set 对象中每个元素的键值对的迭代器。

const mySet = new Set([1, 2, 3]);

console.log([...mySet.keys()]);   // 输出: [1, 2, 3]
console.log([...mySet.values()]); // 输出: [1, 2, 3]
console.log([...mySet.entries()]); // 输出: [[1, 1], [2, 2], [3, 3]]

优先队列

堆

字符串

substring

1 2	// 提取从索引 0 到 5 之间的字符（不包含索引 5） let result1 = str.substring(0, 5);

charCodeAt

let str = 'ab'

// 返回'a'的unicode编码
str.charCodeAt(0)
// 返回'b'的unicode编码
str.charCodeAt(1)

//ascii编码和unicode前128个编码是一样的

replace

replace 是 JavaScript 中用于字符串的一个方法，用来替换字符串中的指定子字符串。它返回一个新的字符串，其中的某些模式被替换为指定的替换值。replace 方法不会改变原始字符串。

基本用法

用字符串作为 searchValue

1
2
3

let str = 'Hello, world!';
let newStr = str.replace('world', 'JavaScript');
console.log(newStr); // 输出: Hello, JavaScript!

用正则表达式作为 searchValue

1
2
3

let str = 'Hello, world!';
let newStr = str.replace(/world/, 'JavaScript');
console.log(newStr); // 输出: Hello, JavaScript!

全局替换

默认情况下，replace 方法只替换第一个匹配项。如果要替换所有匹配项，需要使用正则表达式的全局标志 g。

1
2
3

let str = 'Hello, world! Hello, everyone!';
let newStr = str.replace(/Hello/g, 'Hi');
console.log(newStr); // 输出: Hi, world! Hi, everyone

栈与队列

js中，用数组来模拟栈和队列

栈

在js中可以用数组的push()和pop()方法来实现栈的行为

let stack  = []
stack.push(1) //[1]
stack.push(2) //[1, 2]
stack.push(3) //[1, 2, 3]
stack.pop() //[1, 2]
let x = stack.pop() //[1] ,x = 2

队列

在js中可以用push() 和 shift()方法来模拟队列的行为

let queue = []
queue.push(1) //[1]
queue.push(2) //[1, 2]
queue.push(3) //[1, 2, 3]
queue.shift() // [2, 3]
let x = queue.shift() //[3] x = 2

取整

1. `Math.floor()`

Math.floor() 方法会向下取整，即返回小于或等于给定数字的最大整数。

1 2	console.log(Math.floor(4.7)); // 输出: 4 console.log(Math.floor(-4.7)); // 输出: -5

2. `Math.ceil()`

Math.ceil() 方法会向上取整，即返回大于或等于给定数字的最小整数。

1 2	console.log(Math.ceil(4.1)); // 输出: 5 console.log(Math.ceil(-4.1)); // 输出: -4

3. `Math.round()`

Math.round() 方法会四舍五入，即返回四舍五入后的整数。

1
2
3

console.log(Math.round(4.5)); // 输出: 5
console.log(Math.round(4.4)); // 输出: 4
console.log(Math.round(-4.5)); // 输出: -4

4. `Math.trunc()`

向零截断

Math.trunc() 方法会直接去掉小数部分，即返回数字的整数部分。

1 2	console.log(Math.trunc(4.9)); // 输出: 4 console.log(Math.trunc(-4.9)); // 输出: -4

5. 按位取整

按位取整通过使用按位运算符来进行取整。它会去掉数字的小数部分，类似于 Math.trunc() 的效果，但只适用于32位有符号整数。

1 2	console.log(4.7 \| 0); // 输出: 4 console.log(-4.7 \| 0); // 输出: -4

6. `parseInt()`

parseInt() 函数会将字符串解析为整数，但它也可以用于取整小数。

扩展运算符 `...`

绝对值

`Math.abs`

数字判断

`isNaN`

isNaN() 是一个用于判断某个值是否是 NaN 的函数。

它的工作机制是：首先会尝试将传入的值转换为数值，然后检测转换后的结果是否为 NaN。如果是 NaN，则返回 true，否则返回 false。

isNaN('abc');    // 返回 true，因为 'abc' 不能转换为数字
isNaN(123);      // 返回 false，因为 123 是有效的数字
isNaN(NaN);      // 返回 true
isNaN(true);     // 返回 false，true 会被转换为 1

`Number()`

Number() 是一个函数，它可以将各种类型的值（如字符串、布尔值、null 等）转换为数值类型。

它的作用是进行显式类型转换。

Number('123'); // 返回 123（字符串转换为数字）
Number(true);  // 返回 1（布尔值 true 转换为 1）
Number(false); // 返回 0（布尔值 false 转换为 0）
Number(null);  // 返回 0（null 转换为 0）
Number('abc'); // 返回 NaN（无法转换为数值时，返回 NaN）

处理输入输出

1. 创建输入输出接口

const readline = require('readline');

// 创建一个 readline 接口，用于处理输入输出
const rl = readline.createInterface({
    input: process.stdin,  // 监听标准输入（用户输入）
    output: process.stdout  // 标准输出（打印输出，通常是命令行）
});

2. 监听输入

rl.on('line', callback) 这个函数用于监听每一行的输入。当用户按下回车键并输入一行数据后，line 事件会触发，并将输入内容传递给回调函数。

rl.on('line', (line) => {
    if (inputStep === 0) {
        // 处理第一行输入，数组长度 n
        n = parseInt(line.trim());
        inputStep++;
    } else if (inputStep <= n) {
        // 处理数组输入
        array.push(parseInt(line.trim()));
        inputStep++;
    } else {
        // 处理区间输入
        let range = line.trim().split(' ').map(Number);
        ranges.push(range);
    }
});

3. 关闭输入流

当输入完成后，通常需要关闭输入流，否则程序会一直等待用户的输入。可以在适当时候调用 rl.close()。

rl.on('line', (line) => {
    // 当接收到输入后处理
    if (line === 'exit') {
        rl.close();  // 当用户输入 'exit' 时关闭输入流
    }
});

rl.on('close', () => {
	// 输入结束后执行的代码
    console.log('程序结束');
    process.exit(0);  // 退出程序
});

require 和 import

在 JavaScript 中，require 和 import 都用于引入模块，但它们用于不同的模块系统，具体使用情况取决于运行环境和模块格式。

`require`

模块系统：require 是用于 CommonJS 模块系统的语法，它主要用于 Node.js 环境中(服务器端)。
用法：
- 动态引入：require 可以在代码的任何地方使用，并且支持条件引入（根据条件动态引入模块）。
- 同步加载：require 会同步加载模块，当一个模块被引入时，代码会等待模块加载完成。

`import`

模块系统：import 是用于 ES6 (ES2015) 模块系统的语法，适用于现代 JavaScript，包括浏览器环境和 Node.js 中的 ES Modules（需要特定的设置）
用法：
- 静态引入：import 通常必须放在模块的顶层，并且在编译时处理，因此它不能像 require 一样动态使用（尽管有 import() 的动态引入方式，但那是另一种情况，详见下文）。
- 异步加载：import 是异步加载的（在浏览器环境下，模块通过异步请求加载）。
- 按需引入：可以从模块中按需导入指定的部分，减少加载的内容。

总结

Node.js 环境下，如果使用 CommonJS 模块（默认模块系统），就用 require；如果启用了 ES 模块，就用 import。

浏览器 环境下，应该使用 import，因为这是现代浏览器支持的模块系统。

动态加载：require 可以在 Node.js 中随时使用，但在 ES6 模块系统中，需要用 import() 函数来实现动态加载。

数组

for … in …

for … of …

map

reduce

foreach

includes

unshift

push

js数组初始化

splice

Array.from()

Map

创建 Map

设置键值对 (set)

获取值 (get)

检查是否存在键 (has)

删除键值对 (delete)

清空 Map (clear)

获取键值对的数量 (size)

遍历 Map (forEach)

获取键 (keys)

获取值 (values)

获取键值对 (entries)

Set

创建set

添加元素 (add)

删除元素 (delete)

检查元素是否存在(has)

获取元素个数(size)

清空Set (clear)

遍历 Set (forEach, for...of)

转换为数组 (Array.from 或 展开运算符 ...)

set的迭代方法

优先队列

堆

字符串

substring

charCodeAt

replace

栈与队列

栈

队列

取整

1. Math.floor()

2. Math.ceil()

3. Math.round()

4. Math.trunc()

5. 按位取整

6. parseInt()

扩展运算符 ...

绝对值

Math.abs

数字判断

isNaN

Number()

处理输入输出

1. 创建输入输出接口

2. 监听输入

3. 关闭输入流

require 和 import

require

import

总结

创建 `Map`

设置键值对 (`set`)

获取值 (`get`)

检查是否存在键 (`has`)

删除键值对 (`delete`)

清空 `Map` (`clear`)

获取键值对的数量 (`size`)

遍历 `Map` (`forEach`)

获取键 (`keys`)

获取值 (`values`)

获取键值对 (`entries`)

创建`set`

添加元素 (`add`)

删除元素 (`delete`)

检查元素是否存在(`has`)

获取元素个数(`size`)

清空Set (`clear`)

遍历 Set (`forEach`, `for...of`)

转换为数组 (`Array.from` 或展开运算符 `...`)

1. `Math.floor()`

2. `Math.ceil()`

3. `Math.round()`

4. `Math.trunc()`

6. `parseInt()`

扩展运算符 `...`

`Math.abs`

`isNaN`

`Number()`

`require`

`import`