| 和 || 在实际开发中的使用方法

一、基本使用方法

1. 按位或运算符（|）
   常用于二进制位操作，如权限控制、状态合并等场景。

// 权限控制示例
const READ = 1;    // 二进制: 0001
const WRITE = 2;   // 二进制: 0010
const DELETE = 4;  // 二进制: 0100

// 组合权限
let userPermission = READ | WRITE; // 0011 = 3

// 检查权限
if (userPermission & READ) {
   
  console.log("用户拥有读取权限");
}

1. 逻辑或运算符（||）
   常用于条件判断中的短路求值，或设置默认值。

// 短路求值示例
function validateInput(value) {
   
  if (!value || value.length === 0) {
   
    return "输入不能为空";
  }
  return "验证通过";
}

// 默认值设置
const config = {
   
  timeout: options.timeout || 3000,
  retries: options.retries || 3
};

二、组件封装方案

1. 位操作工具类封装

class BitwiseUtils {
   
  constructor() {
   }

  // 合并多个标志位
  static combineFlags(...flags) {
   
    return flags.reduce((result, flag) => result | flag, 0);
  }

  // 检查是否包含某个标志位
  static hasFlag(value, flag) {
   
    return (value & flag) === flag;
  }

  // 移除某个标志位
  static removeFlag(value, flag) {
   
    return value & ~flag;
  }
}

// 使用示例
const permissions = BitwiseUtils.combineFlags(READ, WRITE);
BitwiseUtils.hasFlag(permissions, DELETE); // false

1. 逻辑判断组件封装（React示例）

function ConditionalComponent({
    condition, left, right }) {
   
  return condition ? left : right;
}

// 使用示例
}
  right={
   }
/>

三、进阶应用场景

1. 性能优化：短路求值的应用

// 避免不必要的函数调用
function expensiveOperation() {
   
  console.log("执行耗时操作");
  return true;
}

// 当isEnabled为false时，不会执行expensiveOperation
if (isEnabled || expensiveOperation()) {
   
  // 处理逻辑
}

1. 二进制状态机

class StateMachine {
   
  constructor() {
   
    this.state = 0;
  }

  // 设置状态
  setState(state) {
   
    this.state |= state;
  }

  // 清除状态
  clearState(state) {
   
    this.state &= ~state;
  }

  // 检查状态
  isActive(state) {
   
    return (this.state & state) !== 0;
  }
}

// 使用示例
const machine = new StateMachine();
machine.setState(LOADING);
machine.isActive(LOADING); // true

四、注意事项

1. 运算符优先级问题

// 错误示例：可能导致逻辑错误
if (a || b & c) {
    ... }

// 正确示例：使用括号明确优先级
if (a || (b & c)) {
    ... }

1. 类型转换陷阱

// 非布尔值在逻辑运算中的转换
0 || 5; // 返回5（真值）
'' || 'default'; // 返回'default'

通过合理封装和使用这两个运算符，可以提高代码的可读性和可维护性，同时避免潜在的逻辑错误。