1. 解构赋值的进阶使用

解构赋值不仅适用于变量快速提取，也能在函数参数、嵌套结构和默认值中发挥巨大作用。

对象与数组的深层提取

// 普通方式：冗长且重复
const name = user.name;
const age = user.age;
const city = user.address.city;
const country = user.address.country;
const firstHobby = user.hobbies[0];

// 解构方式：一行搞定
const { 
  name, 
  age, 
  address: { city, country }, 
  hobbies: [firstHobby] 
} = user;

函数参数解构与默认值合并

// 传统写法
function createUser(userInfo) {
  const name = userInfo.name || 'Anonymous';
  const age = userInfo.age || 18;
  const email = userInfo.email || 'no-email@example.com';
  return { name, age, email };
}

// 解构简化
function createUser({
  name = 'Anonymous',
  age = 18,
  email = 'no-email@example.com'
} = {}) {
  return { name, age, email };
}

2. 短路逻辑与空值合并操作符

逻辑操作符不仅用于布尔判断，也常用于条件赋值与默认处理。

Nullish Coalescing（??）

// 写法对比
const name = user.name ?? 'Guest'; // 比 || 更精准，null 和 undefined 才触发

Optional Chaining（?.）

// 避免嵌套 null 检查
const city = user?.address?.city ?? 'Unknown';

逻辑赋值简写（ES2021）

user.settings ||= {};               // 若未定义则初始化
user.settings.theme ??= 'light';   // 若为 null/undefined 则赋值

3. 数组与对象操作的现代写法

ES6+ 提供了高效的数组去重、过滤、映射等方法，使得数据处理更直观。

用户去重与过滤组合

// 简洁的链式操作
const result = [...new Map(users.map(u => [u.id, u])).values()]
  .filter(u => u.age >= 18 && u.active);

动态属性名构建对象

function createConfig(type, value, enabled) {
  return {
    [`${type}Setting`]: value,
    [`${type}Enabled`]: enabled,
    timestamp: Date.now()
  };
}

4. 模板字符串的高级用法

模板字符串不仅适用于插值，也能在多行构建、标签函数处理等方面简化逻辑。

标签模板：防止 XSS、生成 HTML

function escapeHtml(text) {
  return text.replace(/</g, '&lt;').replace(/>/g, '&gt;');
}
function html(strings, ...values) {
  return strings.reduce((out, str, i) => out + str + escapeHtml(values[i] ?? ''), '');
}
const card = html`
  <div class="card">
    <h2>${user.name}</h2>
    <p>${user.email}</p>
  </div>
`;

条件拼接 SQL、模板类内容

function generateSQL(table, conditions = [], orderBy = '') {
  return `
    SELECT * FROM ${table}
    ${conditions.length ? `WHERE ${conditions.join(' AND ')}` : ''}
    ${orderBy ? `ORDER BY ${orderBy}` : ''}
  `.replace(/\s+/g, ' ').trim();
}

5. 函数式编程技巧提升抽象能力

运用柯里化、组合函数等手段，可以使重复逻辑模块化，提升复用性和可测试性。

表单验证函数组合

const required = field => val => val ? { valid: true } : { valid: false, message: `${field} is required` };
const pattern = (regex, msg) => val => regex.test(val) ? { valid: true } : { valid: false, message: msg };
const validateEmail = composeValidators(
  required('Email'),
  pattern(/^[^\s@]+@[^\s@]+.[^\s@]+$/, 'Invalid email format')
);
function composeValidators(...fns) {
  return value => {
    for (const fn of fns) {
      const result = fn(value);
      if (!result.valid) return result;
    }
    return { valid: true };
  };
}

数据管道与函数组合处理

const pipe = (...fns) => input => fns.reduce((val, fn) => fn(val), input);
const processData = pipe(
  data => data.filter(u => u.active),
  data => data.map(u => ({ ...u, displayName: `${u.firstName} ${u.lastName}` })),
  data => data.sort((a, b) => a.displayName.localeCompare(b.displayName)),
  data => data.reduce((acc, u) => {
    (acc[u.category] ||= []).push(u);
    return acc;
  }, {})
);

总结

• 提升代码的可读性

• 降低维护成本

• 加速开发效率

• 强化架构思维