JavaScript常用API整理

写题的时候好多API都模糊了，我应该好好整理一下，于是查文档+看视频+问AI,整理了下面内容，我觉得比较重要的高频api

核心js定义了最小限度的API，用于操作数值、文本、数组、Map、Set等
js类型可以分为原始类型（Number,String,null,undefined,symbol）和对象类型（Array,Set,Map,RegExp,Date等）

Number 数学计算

方法	描述
`Math.round()`	四舍五入取整
`Math.fround()`	舍入到最接近的32位浮点数
`Math.ceil()`	向上取整 `1.1 => 2`
`Math.floor()`	向下取整 `1.9 => 1`
`Math.sqrt()`	开二次方
`Math.pow(n, m)`	`n` 的 `m` 次幂
`Math.random()`	生成随机小数 `0.0 ~ 1.0`
`Math.max(a, b, c)`	取最大的一个数
`Math.min(a, b, c)`	取最小的一个数

String 字符串操作

方法	描述
`str.length`	返回字符串长度
`str[n]`	返回字符串第 `n` 个索引对应的字符
`str[str.length - 1]`	综合前两个，返回字符串最后一个字符
`str.substring(n, m)`	返回从 `n` 到 `m-1` 索引的字符串片段
`str.slice(n, m)`	同 `substring`，支持负数索引
`str.slice(n)`	返回从索引 `n` 截取到结尾的字符串片段
`str.slice(-n)`	从后往前数 `n` 个字符到最后一个字符的片段
`str.indexOf('str2')`	返回 `str2` 第一次出现的索引值
`str.lastIndexOf('str2')`	返回 `str2` 最后一次出现的索引值
`str.includes('str2')`	包含返回 `true`，反之 `false`
`str.startsWith('str2')`	是 `str2` 开头的返回 `true`，反之 `false`
`str.endsWith('str2')`	是 `str2` 结尾的返回 `true`，反之 `false`
`str.toUpperCase()`	返回字符串全大写形式
`str.toLowerCase()`	返回字符串全小写形式
`str.split('')`	分割字符串（如 `str.split(',')` 或正则表达式）
`str.replace('str1', 'str2')`	替换 `str1` 为 `str2`（支持正则表达式）
`str.trim()`	去除首尾空格
`str.trimStart()`	去除开头空格
`str.trimEnd()`	去除结尾空格
`str.padStart(5, '&')`	前补全（如 `"nie".padStart(5, '&') => '&&nie'`）
`str.padEnd(5, '&')`	后补全（如 `"nie".padEnd(5, '&') => 'nie&&'`）
`str.padStart(5)`	默认补空格（如 `"nie".padStart(5) => ' nie'`）
`str.repeat(5)`	重复 `5` 次（如 `"nie".repeat(5) => 'nienienienienie'`）

Boolean 布尔值

Boolean(x) 判断值的真假（返回true或false）

Boolean(0)// false
Boolean(NaN)// false
Boolean('')// false
Boolean(null)// false
Boolean(undefined)// false
Boolean([])// true
!!!Boolean({})// true
!!!Boolean('')// true
Boolean('false')// true

类型转换

控制数字转字符串的格式

方法	描述
`num.toFixed(n)`	转为 `n` 位小数的字符串（四舍五入）

1 2	let num = 1234.56789; num.toFixed(3); // "1234.568"

显式类型转换

方法	描述
`String(x)`	转为字符串
`Number(x)`	转为数字
`Boolean(x)`	转为布尔值

隐式类型转换

场景	方法
转字符串	`x + " "`（需加括号）或 `${x}`（推荐，无需括号）
转数字	`+x`（如 `+'123'` → `123`）
转布尔值	`!!x`（如 `!!null` → `false`）

Object 对象

let obj = {
  name: 'Nie',
  age: 23,
  sayHello: function() {
    console.log('你好呀，我叫' + this.name);
  }
};

访问不存在的属性 → 返回 undefined
访问不存在属性的其他操作（如 obj.nonExist.length）→ 报错

Array 数组

方法	描述
`arr.length`	返回数组长度
`arr[n]`	访问索引 `n` 的元素（负数或越界返回 `undefined`）
`Array.from('hello')`	解包字符串为 `[ 'h', 'e', 'l', 'l', 'o' ]`
`[...'hello']`	解构字符串为 `[ 'h', 'e', 'l', 'l', 'o' ]`

改变原数组的方法（不返回原数组）

方法	描述
`push(item)`	末尾添加元素，返回新长度
`pop()`	删除末尾元素，返回被删除的元素
`unshift(item)`	开头添加元素，返回新长度
`shift()`	删除开头元素，返回被删除的元素
`splice(loc)`	从 `loc` 开始删除到末尾，返回被删除的数组
`splice(loc, n)`	从 `loc` 开始删除 `n` 个元素，返回被删除的数组
`splice(loc, n, ...items)`	删除 `n` 个元素后，在 `loc` 插入新元素
`reverse()`	反转数组

数组的其他重要操作

方法	描述
`slice(start,end)`	返回从start到end(不包括end)的片段，不改变原数组
`fill(item，start，end)`	用 item 填充从 start 到 end(不包括 end )的片段
`sort(func)`	按照指定规则排序。默认按照字符串字典序排序
`concat(… items)`	将新元素依次添加到原数组的尾部,返回新数组，不改变原数组
`join(sep)`	返回字符串，字符串由原数组的元素组成，元素之间用 sep 分隔，不改变原数组

[1，2，3].sort((a，b)=>a-b)//[1，2，3]
[1，2，3].sort((a，b)=>b-a)//[3，2，1]
[
iname:{"Alice", grade: 1},{name:"Bob",grade:2}
].sort((a，b)→ a.grade - b.grade)
//[{name:"Alice",grade:1},{name:"Bob",grade: 2}]

数组的迭代方法

方法	描述
`forEach(func)`	遍历每个元素调用 `func`
`map(func)`	遍历并返回新数组（如 `arr.map(x => x*2)`）
`filter(func)`	筛选满足条件的元素，返回新数组.只包含func返回true的元素
`reduce(func, init)`	对每个元素调用 func ， func 的返回值作为下一次调用 func 时的第一个参数init 是第一次调用 func 时的第一个参数

//生成1-20的奇数并求和
new Array(20)
  .fill(0)
  .map((_, idx) => idx + 1)
  .filter(x => x % 2 !== 0)
  .reduce((a, b) => a + b, 0); // 输出 100

数组的其他方法

方法	描述
`every(func)`	所有元素满足条件返回 `true`
`some(func)`	任意一个元素满足条件返回 `true`
`find(func)`	返回第一个满足条件的元素
`findIndex(func)`	返回第一个满足条件的元素索引
`indexOf()`	要获取的在数组中第一次出现的位置的元素
`LastIndexOf()`	要获取的在数组中最后一次出现的位置的元素

Set集合

方法	描述
`new Set([1,2,3])`	创建集合（无索引、无序、无重复）
`set.add(n)`	插入元素
`set.delete(2)`	删除元素 `2`
`set.has(n)`	判断集合中是否存在元素 `n`
`set.size`	返回集合元素个数

Map映射

方法	描述
`new Map()`	创建键值对映射（键/值可以是任意类型）
`map.set('name', 'nie')`	设置键值对 `('name', 'nie')`
`map.get('name')`	返回键 `'name'` 对应的值 `'nie'`
`map.has('age')`	判断是否存在键 `'age'`
`map.delete('age')`	删除键 `'age'` 对应的键值对
`map.size`	返回映射元素个数

Data

let date = new Date()
date.getFullYear()//=2025
date.getMonth()//→0(0表示1月)
date.getDate()//→1
date.getDay()//→0(0表示星期日)
date.getTime()//=1704128000000(时间戳，毫秒)
date.setFullYear(2020)//=1577836800000
date.setMonth(date.getMonth()+1)// 可进行计算
date>new Date(2020，0，1)//true，可进行比较

其他

flat()扁平化数组

flat() 是 JavaScript中用于扁平化数组的方法，其核心功能是将嵌套的数组展开为指定深度的单层数组
语法：array.flat(depth);

const arr = [1, [2, [3, [4]]]];
console.log(arr.flat(1)); // 输出：[1, 2, [3, [4]]]
console.log(arr.flat(2)); // 输出：[1, 2, 3, [4]]
console.log(arr.flat(3)); // 输出：[1, 2, 3, 4]

常遇到的场景

数组合并并去重

使用 Set 集合

1
2
3

const arr1 = [1, 2, 3];
const arr2 = [3, 4, 5];
const arr3 = [5, 6, 7];

Set 结合扩展运算符

1
2
3

const mergedArray = [...new Set([...arr1, ...arr2, ...arr3])];

console.log(mergedArray); // 输出: [1, 2, 3, 4, 5, 6, 7]

concat 和 Set

1
2
3

const mergedArray = [...new Set(arr1.concat(arr2, arr3))];

console.log(mergedArray); // 输出: [1, 2, 3, 4, 5, 6, 7]

如果数组数量多，可以用 apply 动态合并

const arrays = [arr1, arr2, arr3];
const merged = [].concat.apply([], arrays);
const result = [...new Set(merged)];
可以合并成：
const mergedArray = [...new Set(Array.prototype.concat.apply([], [arr1, arr2, arr3]))];

reduce+includes
reduce方法：用于将数组 “累积” 成一个单一的值（比如求和、合并等）；acc（累加器），curr（当前项），基本结构：
1
2
3
4
array.reduce((累加器, 当前项) => {
// 处理逻辑
return 累加器; // 返回更新后的累加器
}, 初始值);

const mergedArray = [arr1, arr2, arr3].reduce((acc, curr) => {
  curr.forEach(item => {
    if (!acc.includes(item)) acc.push(item);
  });
  return acc;
}, []);

console.log(mergedArray); // 输出: [1, 2, 3, 4, 5, 6, 7]

对象转数组

提取键Object.keys()

Object.keys()可以提取对象的所有键，并返回一个数组

1
2
3

const obj = { a: 1, b: 2, c: 3 };
const keys = Object.keys(obj);
console.log(keys); // 输出: ["a", "b", "c"]

提取值Object.values()

Object.values 可以提取对象的所有值，并返回一个数组

1
2
3

const obj = { a: 1, b: 2, c: 3 };
const values = Object.values(obj);
console.log(values); // 输出: [1, 2, 3]

提取键值对Object.entries()

Object.entries 返回一个二维数组，每个子数组包含键和值

const obj = { a: 1, b: 2, c: 3 };
const entries = Object.entries(obj);
console.log(entries); // 输出: [["a", 1], ["b", 2], ["c", 3]]
用途：
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key}: ${value}`);
}
// 输出:
// a: 1
// b: 2
// c: 3

转换为键值对对象数组

1
2
3

const obj = { name: "Alice", age: 30 };
const arr = Object.entries(obj).map(([k, v]) => ({ [k]: v }));
// 输出: [{name: "Alice"}, {age: 30}]

数组变字符串

使用 join() 方法

const arr = [1, 2, 3, 4];
const str = arr.join(","); // 使用逗号作为分隔符
console.log(str); // 输出: "1,2,3,4"
没有分隔符（直接拼接）
const str2 = arr.join(""); // 输出: "1234"

toString 方法

toString 是数组的原型方法，将数组元素转换为逗号分隔的字符串

1 2	const arr = [1, 2, 3]; console.log(arr.toString()); // "1,2,3"

对于多维数组，toString 会递归展开为一维字符串：

1 2	const arr2d = [[1, 2], [3, 4]]; console.log(arr2d.toString()); // "1,2,3,4"

对象变字符串

JSON.stringify

将对象转换为 JSON 格式的字符串
JSON.stringify(obj, replacer, space);
replacer：可选参数，用于筛选或转换数据（函数或数组）
space：可选参数，控制缩进（数字或字符串）

1
2
3

const obj = { a: 1, b: 2, c: 3 };
const str = JSON.stringify(obj);
console.log(str); // 输出: '{"a":1,"b":2,"c":3}'