js 常用简写技巧（干货满满）

分享一些自己常用的js简写技巧与一些冷门但实用的语法，长期更新，会着重挑选一些实用的简写技巧，使自己的代码更简洁优雅~

相信你看完后会一定会有收获！💪

这里只会收集一些大多数人不知道的用法，但是确实能提高自己的编码技巧，像ES6那些基础的简写语法比如：三目运算符代替if else、箭头函数、结构赋值、...运算符等写法相对比较基础，并且大家都知道，在这里不做过多赘述。

注意本篇内容涉及到的语法从ES6到ES11不等，具体使用需要考虑项目兼容性问题！

另外推荐一个只用一行代码实现一个方法的实用网站phuoc.ng，github

If-Else 用 || 或 ?? 运算符进行简化

逻辑或操作符||，这里要注意的是0和''也会认为是false

如果||前面的值是0 '' false null undefined NaN其中的任意一种，则直接返回||后面的值

function(obj){
  var a = obj || {}
}
// 等价于 =>>
function(obj){
  var a;
  if(
    obj === 0 || 
    obj === "" || 
    obj === false || 
    obj === null || 
    obj === undefined ||
    isNaN(obj)
  ){
     a = {}
   } else {
     a = obj;
  }
}

空值合并操作符??如果没有定义左侧返回右侧。如果是，则返回左侧。

这种方法非常实用，有时候仅仅只是想判断一个字段有没有值，而不是把空字符串或者0也当做false处理

function(obj){
  var a = obj ?? {}
}
// 等价于 =>>
function(obj){
  var a;
  if(
    obj === null || 
    obj === undefined
  ){
     a = {}
   } else {
     a = obj;
  }
}

输入框非空的判断（有时候不想把0当成false可以用此方法。比如分数0也是个值，这种情况就不能认为是false）

if(value !== null && value !== undefined && value !== ''){}
// 等价于 ==>
if((value ?? '') !== ''){}

includes的正确使用姿势

在上面逻辑或操作符||代码段里有一个if判断比较长，这时候就可以用includes去简化代码

if(
  obj === 0 || 
  obj === "" || 
  obj === false || 
  obj === null || 
  obj === undefined
){
  // ...
}

// 使用includes简化
if([0, '', false, null, undefined].includes(obj)){
  // ...
}

防止崩溃的可选链(?.)

可选链操作符?. 如果访问未定义的属性，则会产生错误。这就是可选链的用武之地。 在未定义属性时使用可选链运算符，undefined将返回而不是错误。这可以防止你的代码崩溃。

const student = {
  name: "lwl",
  address: {
    state: "New York"
  },
}

// 一层一层判断
console.log(student && student.address && student.address.ZIPCode) // 输出：undefined
// 使用可选链操作符
console.log(student?.address?.ZIPCode) // 输出：undefined

可选链运算符也可以用于方法调用。如果方法存在，它将被调用，否则将返回 undefined。例如：

const obj = {
  foo() {
    console.log('Hello from foo!')
  }
}

obj.foo?.() // 输出：'Hello from foo!'
obj.bar?.() // 输出：undefined，因为 bar 方法不存在

同样，数组也可以使用。例如：

const arr = [1, 2, 3, 4]

console.log(arr[0]) // 输出：1
console.log(arr[4]) // 输出：undefined

// 使用可选链运算符
console.log(arr?.[0]) // 输出：1
console.log(arr?.[4]) // 输出：undefined
console.log(arr?.[0]?.toString()) // 输出：'1'

// 多维数组也可以
const arr2 = [[[1]]]
console.log(arr2?.[0]?.[0]?.[0]) // 输出：1
console.log(arr2?.[0]?.[1]?.[0]) // 输出：undefined

逻辑空赋值(??=)

逻辑空赋值??= 逻辑空赋值运算符(x ??= y)仅在 x 是 nullish (null 或 undefined) 时对其赋值。

const a = { duration: 50 };

a.duration ??= 10;
console.log(a.duration);
// expected output: 50

a.speed ??= 25;
console.log(a.speed);
// expected output: 25

快速生成1-10的数组

生成0-9，利用了数组的下标值。推荐使用Array.from()，性能更好也比较灵活，改成(v, k) => k + 1就是1-10

// 方法一
const arr1 = [...new Array(10).keys()]
// 方法二
const arr2 = Array.from(Array(10), (v, k) => k)
// 方法三
const arr3 = Array.from({length: 10}, (v, k) => k)

生成1-10，通过map的特性

const arr1 = [...Array(10)].map((v, i) => i + 1)
// 下面这两个和上面生成0-9的方式一样
const arr2 = Array.from(Array(10), (v, k) => k + 1)
const arr3 = Array.from({length: 10}, (v, k) => k + 1)

快速生成10个0的数组

const arr = new Array(10).fill(0)

快速生成10个[]的数组（二维数组）

注意： 二维数组不能直接写成new Array(10).fill([])（也就是fill方法不能传引用类型的值，[]换成new Array()也不行）,因为fill里传入引用类型值会导致每一个数组都指向同一个地址，改变一个数据的时候其他数据也会随之改变，详见mdn官方说明

// 错误写法
const arr = new Array(10).fill([]) // 注意这是错误写法，不要这么写
// 正确写法
const arr = new Array(10).fill().map(() => new Array())
// 当然用上面的Array.from方法也可以
const arr = Array.from(Array(10), () => [])
const arr = Array.from({ length: 10 }, () => [])

数组降维

你是否还在用递归给一个多维数组降维？如果是，那你应该知道一下es6的 flat() 方法。

如果不确定需要降维的数组有多深，可以传入最大值作为参数Infinity，默认值深度为1

const arr = [1, [2, [3, 4], 5], 6]
const flatArr = arr.flat(Infinity) // 输出 [1, 2, 3, 4, 5, 6]

你是否在使用map的时候想要对数组降维？大概像这样：

const arr = [1, 2, 3, 4]
const result = arr.map(v => [v, v * 2]).flat()
console.log(result); // 输出 [1, 2, 2, 4, 3, 6, 4, 8]

其实js也提供了更简便的方法，那就是flatMap()，可以改成这样：

const result = arr.flatMap(v => [v, v * 2])

Set集合实践：数组去重、交集、并集、差集

// 1.数组去重 
let arr1 = [1, 3, 2, 1, 4, 2, 1] 
let result1 = [...new Set(arr1)] 
console.log(result1) // [1, 3, 2, 4] 

// 2.交集 
let arr2 = [4, 3, 4, 7] 
let result2 = [...new Set(arr1)].filter(v => new Set(arr2).has(v)) 
console.log(result2) // [3, 4] 

// 3.并集 
let result3 = [...new Set([...arr1, ...arr2])] 
console.log(result3) // [1, 3, 2, 4, 7] 

// 4.差集 
let result4 = [...new Set(arr1)].filter(v => !(new Set(arr2).has(v))) 
console.log(result4) // [1, 2]

在没有第三个变量的情况下交换两个变量

在 JavaScript 中，你可以使用解构从数组中拆分值。这可以应用于交换两个变量而无需第三个

比较简单，es6语法

let x = 1;
let y = 2;

// 交换变量
[x, y] = [y, x];

将对象的值收集到数组中

用于Object.values()将对象的所有值收集到一个新数组中

const info = { name: "Matt", country: "Finland", age: 35 };

// LONGER FORM
let data = [];
for (let key in info) {
  data.push(info[key]);
}

// SHORTHAND
const data = Object.values(info);

指数运算符（用的不多）

你Math.pow()习惯把一个数字提高到一个幂吗？你知道你也可以使用**运算符吗？

虽然可以简写，不过我还是建议写成Math.pow()方法，代码更有语义化。

注意：**运算符要求操作数为数值类型，不过在js里也能正常运行。

Math.pow(2, 3); // 输出: 8 
2 ** 3; // 输出: 8 

Math.pow(4, 0.5); // 输出: 2 
4 ** 0.5; // 输出: 2 

Math.pow(3, -2); // 输出: 0.1111111111111111 
3 ** -2; // 输出: 0.1111111111111111 

Math.pow('2', '3'); // 输出: 8 (参数被自动转换为数字) 
'2' ** '3'; // js中输出: 8，其他语言可能报错

Math.floor() 简写（用的不多）

向下取整Math.floor()并不是什么新鲜事。但是你知道你也可以使用~~运算符吗？

同上虽然可以简写，不过我还是建议写成Math.floor()方法，代码更有语义化。

注意：对于正数而言两者都是直接去掉小数位，但对于负数来说Math.floor()是向下取整，~~依然是只去掉小数位，整数位不变。 请看下面输出结果：

Math.floor(3.14); // 输出: 3 
Math.floor(5.7); // 输出: 5 
Math.floor(-2.5); // 输出: -3 
Math.floor(10); // 输出: 10

~~3.14; // 输出: 3 
~~5.7; // 输出: 5 
~~(-2.5); // 输出: -2 
~~10; // 输出: 10

逗号运算符(,)

逗号（ , ）运算符对它的每个操作数从左到右求值，并返回最后一个操作数的值。这让你可以创建一个复合表达式，其中多个表达式被评估，复合表达式的最终值是其成员表达式中最右边的值。这通常用于为 for 循环提供多个参数。

这里只说一下函数return的时候用逗号运算符简化代码的技巧，其他用法请直接点击查看官方文档。

举一个简单的例子：

// 简化前
const result = arr => {
  arr.push('a')
  return arr
}
console.log(result([1,2])) // 输出：[1, 2, 'a']

这段代码需要返回修改后的数组，不能直接return arr.push('a')，因为push的返回值是修改后数组的长度，这时候可以用逗号运算符简化成一行代码。

// 简化后
const result = arr => (arr.push('a'), arr)
console.log(result([1,2])) // 输出：[1, 2, 'a']

Array.map()的简写

比如想要拿到接口返回的特定字段的值，可以用解构赋值和对象的简写方法对map方法简写，详细解释请移步js map方法应用场景 处理对象数组。

比如接口返回数据，此时如果只想要数据里的id和name，就可以用下面的简写方式。

// 接口返回数据
res = [{
  id: 1,
  name: 'zhangsan',
  age: 16,
  gender: 0
}, {
  id: 2,
  name: 'lisi',
  age: 20,
  gender: 1
}]

// 第一种方法：箭头函数、 解构赋值
const data = res.map(({id, name}) => ({id, name}))
// 第二种方法：箭头函数、返回对象（相对更容易理解）
const data = res.map(v => ({id: v.id, name: v.name}))

文字排序

我们知道数组方法sort()默认是按照UTF-16码元值升序排序

我们可以使用charCodeAt()方法获取UTF-16码元

对于中文或者其他语言按照拼音排序（字典顺序排序）则需要用到localeCompare()方法

['张三', '李四', '赵五', '王二', '陈六'].sort()
// 输出：['张三', '李四', '王二', '赵五', '陈六']
['张三', '李四', '赵五', '王二', '陈六'].sort((a, b) => a.localeCompare(b, 'zh-Hans-CN'))
// 输出：['陈六', '李四', '王二', '张三', '赵五']

['apple', 'Banana', 'cherry', 'Date', 'apricot', 'Banana'].sort()
// 输出：['Banana', 'Banana', 'Date', 'apple', 'apricot', 'cherry']
['apple', 'Banana', 'cherry', 'Date', 'apricot', 'Banana'].sort((a, b) => a.localeCompare(b, 'en'))
// 输出：['apple', 'apricot', 'Banana', 'Banana', 'cherry', 'Date']

• 'zh' 表示主语言标记，代表中文。
• 'Hans' 是脚本子标记，表示简体汉字。
• 'CN' 是区域子标记，表示中国。

如果您不提供locales参数（第二个参数），localeCompare方法通常会默认使用浏览器或操作系统的当前语言环境

at()方法获取数组最后一位值

// 获取arr的最后一位值
const arr = [1, 2, 3, 4, 5]
// 一般写法
const last = arr[arr.length - 1]
// 二般写法
const last = arr.slice(-1)[0]
// 终极写法
const last = arr.at(-1)

undefined 应尽量避免直接使用（用的不多，但需要了解一下）

为什么不建议直接使用undefined，而是建议使用void 0来代替？在MDN官方文档上写的很清楚：

在现代浏览器（JavaScript 1.8.5/Firefox 4+），自 ECMAscript5 标准以来 undefined 是一个不能被配置（non-configurable），不能被重写（non-writable）的属性。即便事实并非如此，也要避免去重写它。

一个没有被赋值的变量的类型是 undefined。如果方法或者是语句中操作的变量没有被赋值，则会返回 undefined

什么意思呢？简单来说就是虽然目前主流浏览器全局作用域已经禁止修改undefined的值，但是它有可能在非全局作用域中被当作标识符（变量名）来使用（因为 undefined 不是保留字）

例如：（不要这样做！）

(() => {
  const undefined = "foo";
  console.log(undefined, typeof undefined); // foo string
})();

((undefined) => {
  console.log(undefined, typeof undefined); // foo string
})("foo");

所以我们可以用void 0代替undefined，通过使用 void 0，你可以确保获取到真正的 undefined 值，而不会受到 undefined 可能被覆盖的影响。这是一种比较保险的做法，特别是在编写跨平台或跨浏览器的代码时，以确保代码的稳健性

console.log(void 0); // 输出：undefined

Object.freeze()对象冻结

Object.freeze() 是 JavaScript 中一个用于冻结对象的方法。当你冻结一个对象时，该对象将变得不可更改，无法添加、删除或修改其属性或方法。

const obj = { prop: 'value' };
Object.freeze(obj); 

// 尝试修改、添加、删除属性 
obj.prop = 'new value';
obj.newProp = 'new property';
delete obj.prop;

console.log(obj); // 输出：{ prop: 'value' }

for of 获取 index 方法

当我们使用 for of 循环遍历数组的时候，有时候会使用到 数组的index，但是 for of 又得不到 index，所以最后不得不去使用 forEach去遍历数组，但我们要尽量避免使用forEach；

解决方法：在 Array 构造函数上有一个数组的方法 entries()，该方法返回一个 数组的迭代对象，该对象包含数组的索引和值，迭代对象中的 key === 索引值、value === 索引对应的元素，此时就可以正常访问索引和值了；

const arr = [1, 2, 3]
for (const [index, value] of arr.entries()) {
  console.log(index, value)
}

for in 精简参数

为了避免接口传参传入多余的参数，或者接口返回参数需要赋值给某个对象的某些属性时，难道还要一个一个赋值吗？如果参数过多的情况下使用for in是一个不错的选择

// 比如接口返回数据有很多无用字段res，我们只需要一部分参数obj
res = {
  a: 12,
  b: 23,
  c: 34,
  d: 45
}
obj = {
  a: 12,
  b: 23
}
// 一般情况下会一个一个赋值
obj.a = res.a
obj.b = res.b
// 但参数比较多的时候这样写就很麻烦，所以可以使用for in优化代码
for (const key in obj) {
  obj[key] = res[key]
}

利用Intl实现千分位格式化数字

new Intl.NumberFormat().format(1234567.89); // "1,234,567.89"（自动适配本地化）

Object.hasOwn 替代 hasOwnProperty

const obj = { a: 1 };
Object.hasOwn(obj, 'a'); // true（比 obj.hasOwnProperty 更安全）

更新记录

• 2024-2-13 undefined 应尽量避免直接使用、Object.freeze()对象冻结：新增内容
• 2023-11-30 at()方法获取数组最后一位值：新增内容
• 2023-11-1 文字排序：新增内容
• 2023-9-7 Set集合实践：数组去重、交集、并集、差集：补充交集、并集、差集的案例
• 2023-7-7 Array.map()的简写：新增内容
• 2023-6-27 防止崩溃的可选链(?.)：补充方法和数组的使用
• 2023-6-21 逗号运算符(,)：新增内容
• 2023-6-16 指数运算符和Math.floor() 简写：补充两者区别
• 2023-5-30 数组降维：新增内容
• 2023-5-27 If-Else 用 || 或 ?? 运算符进行简化：补充上NaN
• 2025-8-15 新增for of、 for in、Intl、Object.hasOwn使用方法