赋值运算符

赋值运算符=，使用方式如x=y。

复合赋值运算符将赋值与运算符组合在一起，例如：a += b 等价于 a = a + b，

其中的 += 即为复合赋值运算符

复合赋值运算符包括：+=、-=、*=、/=、%=、<<=、>>=、>>>=、&=、|=、^=。

比较运算符

===与==的区别：

let a:Object=1;

let b:Object='1';

// == 只比较值相等

console.info(a == b); // true

// === 比较值和类型都相等

console.info(a === b); // false

算术运算符

一元运算符包括：-、+、--、++。

二元运算符列举如下：

位运算符

基础位运算符示例，包括：

• 按位与(&)
• 按位或(|)
• 按位异或(^)
• 按位非(~)
• 左移(<<)
• 算术右移(>>)
• 逻辑右移(>>>)

@Entry
@Component
struct BitwiseOperatorsExample {
  @State result: string = '';

  build() {
    Column() {
      Text('位运算符示例').fontSize(24).fontWeight(FontWeight.Bold).margin(10)
      
      Button('执行位运算示例')
        .onClick(() => {
          this.performBitwiseOperations();
        })
        .margin(10)
      
      Scroll() {
        Text(this.result)
          .fontSize(16)
          .margin(10)
          .width('100%')
      }
      .width('100%')
      .height('80%')
    }
    .width('100%')
    .height('100%')
    .padding(10)
  }

  performBitwiseOperations() {
    let output = '';
    
    // 按位与(&)示例
    let a = 5;  // 二进制: 0101
    let b = 3;  // 二进制: 0011
    let andResult = a & b;  // 结果: 0001 (十进制: 1)
    output += `按位与(&):\n`;
    output += `${a} & ${b} = ${andResult}\n`;
    output += `二进制表示: ${a.toString(2)} & ${b.toString(2)} = ${andResult.toString(2)}\n\n`;
    
    // 按位或(|)示例
    let orResult = a | b;  // 结果: 0111 (十进制: 7)
    output += `按位或(|):\n`;
    output += `${a} | ${b} = ${orResult}\n`;
    output += `二进制表示: ${a.toString(2)} | ${b.toString(2)} = ${orResult.toString(2)}\n\n`;
    
    // 按位异或(^)示例
    let xorResult = a ^ b;  // 结果: 0110 (十进制: 6)
    output += `按位异或(^):\n`;
    output += `${a} ^ ${b} = ${xorResult}\n`;
    output += `二进制表示: ${a.toString(2)} ^ ${b.toString(2)} = ${xorResult.toString(2)}\n\n`;
    
    // 按位非(~)示例
    let notResultA = ~a;  // 对5取反
    output += `按位非(~):\n`;
    output += `~${a} = ${notResultA}\n`;
    output += `二进制表示: ~${a.toString(2)} = ${notResultA.toString(2)}\n`;
    output += `(在JavaScript/TypeScript中，~操作符会将数字转换为-(n+1))\n\n`;
    
    // 左移(<<)示例
    let leftShiftResult = a << 2;  // 结果: 10100 (十进制: 20)
    output += `左移(<<):\n`;
    output += `${a} << 2 = ${leftShiftResult}\n`;
    output += `二进制表示: ${a.toString(2)} << 2 = ${leftShiftResult.toString(2)}\n\n`;
    
    // 算术右移(>>)示例
    let rightShiftResult = a >> 1;  // 结果: 0010 (十进制: 2)
    output += `算术右移(>>):\n`;
    output += `${a} >> 1 = ${rightShiftResult}\n`;
    output += `二进制表示: ${a.toString(2)} >> 1 = ${rightShiftResult.toString(2)}\n\n`;
    
    // 算术右移负数示例
    let negativeNum = -10;  // 在二进制补码表示中，最高位为符号位
    let arithmeticRightShiftNegative = negativeNum >> 1;  // 保留符号位
    output += `负数的算术右移(>>):\n`;
    output += `${negativeNum} >> 1 = ${arithmeticRightShiftNegative}\n`;
    output += `(算术右移保留符号位)\n\n`;
    
    // 逻辑右移(>>>)示例
    let unsignedRightShiftResult = a >>> 1;  // 结果与 >> 相同，但对于负数会有不同
    output += `逻辑右移(>>>):\n`;
    output += `${a} >>> 1 = ${unsignedRightShiftResult}\n`;
    output += `二进制表示: ${a.toString(2)} >>> 1 = ${unsignedRightShiftResult.toString(2)}\n\n`;
    
    // 逻辑右移负数示例
    let logicalRightShiftNegative = negativeNum >>> 1;  // 不保留符号位，左边补0
    output += `负数的逻辑右移(>>>):\n`;
    output += `${negativeNum} >>> 1 = ${logicalRightShiftNegative}\n`;
    output += `(逻辑右移不保留符号位，左边补0)\n\n`;
    
    // 位运算的实际应用示例
    output += `位运算的实际应用示例:\n\n`;
    
    // 1. 使用位运算检查奇偶性
    output += `1. 检查奇偶性 (使用 & 1):\n`;
    output += `15 是${(15 & 1) === 0 ? '偶数' : '奇数'}\n`;
    output += `16 是${(16 & 1) === 0 ? '偶数' : '奇数'}\n\n`;
    
    // 2. 使用位运算交换两个变量
    let x = 10;
    let y = 20;
    output += `2. 不使用临时变量交换两个数:\n`;
    output += `交换前: x = ${x}, y = ${y}\n`;
    x = x ^ y;
    y = x ^ y;
    x = x ^ y;
    output += `交换后: x = ${x}, y = ${y}\n\n`;
    
    // 3. 使用位运算乘以或除以2的幂
    output += `3. 使用位运算乘以或除以2的幂:\n`;
    output += `8 << 1 = ${8 << 1} (相当于 8 * 2)\n`;
    output += `8 << 2 = ${8 << 2} (相当于 8 * 4)\n`;
    output += `8 >> 1 = ${8 >> 1} (相当于 8 / 2)\n`;
    output += `8 >> 2 = ${8 >> 2} (相当于 8 / 4)\n`;
    
    this.result = output;
  }
}

位运算的实用工具类，包含多种实际应用：

• 检查偶数
• 计算下一个2的幂
• 使用异或交换两个数
• 检查一个数是否是2的幂
• 计算2的n次方
• 除以2的n次方
• 转换为无符号整数
• 位操作（设置、清除、检查、切换特定位）

/**
 * 位运算工具类
 * 展示各种位运算符的实际应用
 */
export class BitwiseOperationsUtil {
  /**
   * 使用按位与(&)检查一个数是否为偶数
   * @param num 要检查的数字
   * @return 如果是偶数返回true，否则返回false
   */
  static isEven(num: number): boolean {
    // 如果最低位是0，则为偶数
    return (num & 1) === 0;
  }
  
  /**
   * 使用按位或(|)将一个数向上取整到最接近的2的幂
   * @param num 要处理的数字
   * @return 大于或等于num的最小2的幂
   */
  static nextPowerOfTwo(num: number): number {
    num--;
    num |= num >> 1;
    num |= num >> 2;
    num |= num >> 4;
    num |= num >> 8;
    num |= num >> 16;
    num++;
    return num;
  }
  
  /**
   * 使用按位异或(^)交换两个数
   * @param nums 包含两个要交换的数的数组
   */
  static swapWithXOR(nums: number[]): void {
    if (nums.length >= 2) {
      nums[0] = nums[0] ^ nums[1];
      nums[1] = nums[0] ^ nums[1];
      nums[0] = nums[0] ^ nums[1];
    }
  }
  
  /**
   * 使用按位非(~)检查一个数是否是2的幂
   * @param num 要检查的数字
   * @return 如果是2的幂返回true，否则返回false
   */
  static isPowerOfTwo(num: number): boolean {
    // 2的幂在二进制中只有一个1，如4 (100)
    // 减1后，这个1右边的所有位都变成1，如3 (011)
    // 原数与(原数-1)按位与的结果应该是0
    return num > 0 && (num & (num - 1)) === 0;
  }
  
  /**
   * 使用左移(<<)计算2的n次方
   * @param n 指数
   * @return 2的n次方
   */
  static powerOfTwo(n: number): number {
    return 1 << n;  // 相当于 2^n
  }
  
  /**
   * 使用右移(>>)计算数字除以2的n次方
   * @param num 被除数
   * @param n 指数
   * @return num除以2的n次方的结果
   */
  static divideByPowerOfTwo(num: number, n: number): number {
    return num >> n;  // 相当于 num / (2^n)
  }
  
  /**
   * 使用逻辑右移(>>>)将有符号整数转换为无符号整数
   * @param num 有符号整数
   * @return 无符号整数表示
   */
  static toUnsigned(num: number): number {
    return num >>> 0;
  }
  
  /**
   * 使用位运算设置特定位
   * @param num 原始数字
   * @param position 要设置的位置(0-31)
   * @return 设置指定位后的数字
   */
  static setBit(num: number, position: number): number {
    return num | (1 << position);
  }
  
  /**
   * 使用位运算清除特定位
   * @param num 原始数字
   * @param position 要清除的位置(0-31)
   * @return 清除指定位后的数字
   */
  static clearBit(num: number, position: number): number {
    return num & ~(1 << position);
  }
  
  /**
   * 使用位运算检查特定位是否设置
   * @param num 要检查的数字
   * @param position 要检查的位置(0-31)
   * @return 如果指定位为1返回true，否则返回false
   */
  static isBitSet(num: number, position: number): boolean {
    return (num & (1 << position)) !== 0;
  }
  
  /**
   * 使用位运算切换特定位
   * @param num 原始数字
   * @param position 要切换的位置(0-31)
   * @return 切换指定位后的数字
   */
  static toggleBit(num: number, position: number): number {
    return num ^ (1 << position);
  }
}

演示工具类的使用方法:

import { BitwiseOperationsUtil } from './BitwiseOperationsUtil';

@Entry
@Component
struct BitwiseOperationsDemo {
  @State result: string = '';

  build() {
    Column() {
      Text('位运算实际应用示例').fontSize(24).fontWeight(FontWeight.Bold).margin(10)
      
      Button('运行位运算工具类示例')
        .onClick(() => {
          this.runBitwiseUtilDemo();
        })
        .margin(10)
      
      Scroll() {
        Text(this.result)
          .fontSize(16)
          .margin(10)
          .width('100%')
      }
      .width('100%')
      .height('80%')
    }
    .width('100%')
    .height('100%')
    .padding(10)
  }

  runBitwiseUtilDemo() {
    let output = '';
    
    // 测试偶数检查
    output += '偶数检查:\n';
    output += `10 是偶数? ${BitwiseOperationsUtil.isEven(10)}\n`;
    output += `15 是偶数? ${BitwiseOperationsUtil.isEven(15)}\n\n`;
    
    // 测试下一个2的幂
    output += '下一个2的幂:\n';
    output += `10 的下一个2的幂: ${BitwiseOperationsUtil.nextPowerOfTwo(10)}\n`;
    output += `16 的下一个2的幂: ${BitwiseOperationsUtil.nextPowerOfTwo(16)}\n`;
    output += `17 的下一个2的幂: ${BitwiseOperationsUtil.nextPowerOfTwo(17)}\n\n`;
    
    // 测试XOR交换
    output += 'XOR交换:\n';
    let nums = [10, 20];
    output += `交换前: [${nums}]\n`;
    BitwiseOperationsUtil.swapWithXOR(nums);
    output += `交换后: [${nums}]\n\n`;
    
    // 测试2的幂检查
    output += '2的幂检查:\n';
    output += `4 是2的幂? ${BitwiseOperationsUtil.isPowerOfTwo(4)}\n`;
    output += `6 是2的幂? ${BitwiseOperationsUtil.isPowerOfTwo(6)}\n\n`;
    
    // 测试计算2的n次方
    output += '计算2的n次方:\n';
    output += `2^3 = ${BitwiseOperationsUtil.powerOfTwo(3)}\n`;
    output += `2^5 = ${BitwiseOperationsUtil.powerOfTwo(5)}\n\n`;
    
    // 测试除以2的n次方
    output += '除以2的n次方:\n';
    output += `16 / 2^2 = ${BitwiseOperationsUtil.divideByPowerOfTwo(16, 2)}\n`;
    output += `20 / 2^2 = ${BitwiseOperationsUtil.divideByPowerOfTwo(20, 2)}\n\n`;
    
    // 测试转换为无符号整数
    output += '转换为无符号整数:\n';
    let negativeNum = -1;
    output += `${negativeNum} 转换为无符号: ${BitwiseOperationsUtil.toUnsigned(negativeNum)}\n\n`;
    
    // 测试位操作
    output += '位操作:\n';
    let num = 0;  // 0000
    output += `初始值: ${num} (${num.toString(2)})\n`;
    
    // 设置第1位和第3位
    num = BitwiseOperationsUtil.setBit(num, 0);  // 0001
    num = BitwiseOperationsUtil.setBit(num, 2);  // 0101
    output += `设置第0位和第2位后: ${num} (${num.toString(2)})\n`;
    
    // 检查位
    output += `第0位是否设置? ${BitwiseOperationsUtil.isBitSet(num, 0)}\n`;
    output += `第1位是否设置? ${BitwiseOperationsUtil.isBitSet(num, 1)}\n`;
    
    // 切换第1位
    num = BitwiseOperationsUtil.toggleBit(num, 1);  // 0111
    output += `切换第1位后: ${num} (${num.toString(2)})\n`;
    
    // 清除第0位
    num = BitwiseOperationsUtil.clearBit(num, 0);  // 0110
    output += `清除第0位后: ${num} (${num.toString(2)})\n`;
    
    this.result = output;
  }
}

展示了位运算在权限管理中的应用：

• 使用位掩码定义不同权限
• 通过位运算添加、移除、检查和切换权限
• 检查多个权限条件

/**
 * 使用位运算实现权限标志位的示例
 * 这是一种常见的位运算应用场景
 */
@Entry
@Component
struct BitwiseFlagsExample {
  @State result: string = '';
  
  // 定义权限常量
  readonly READ: number = 1;       // 0001
  readonly WRITE: number = 2;      // 0010
  readonly EXECUTE: number = 4;    // 0100
  readonly ADMIN: number = 8;      // 1000
  
  build() {
    Column() {
      Text('位运算权限标志位示例').fontSize(24).fontWeight(FontWeight.Bold).margin(10)
      
      Button('运行权限标志位示例')
        .onClick(() => {
          this.runPermissionFlagsDemo();
        })
        .margin(10)
      
      Scroll() {
        Text(this.result)
          .fontSize(16)
          .margin(10)
          .width('100%')
      }
      .width('100%')
      .height('80%')
    }
    .width('100%')
    .height('100%')
    .padding(10)
  }
  
  runPermissionFlagsDemo() {
    let output = '';
    
    // 创建不同权限组合
    let userPermissions = 0;
    let adminPermissions = 0;
    
    // 为普通用户设置读写权限
    userPermissions |= this.READ;
    userPermissions |= this.WRITE;
    
    // 为管理员设置所有权限
    adminPermissions |= this.READ;
    adminPermissions |= this.WRITE;
    adminPermissions |= this.EXECUTE;
    adminPermissions |= this.ADMIN;
    
    // 显示权限
    output += '权限标志位:\n';
    output += `READ: ${this.READ.toString(2).padStart(4, '0')}\n`;
    output += `WRITE: ${this.WRITE.toString(2).padStart(4, '0')}\n`;
    output += `EXECUTE: ${this.EXECUTE.toString(2).padStart(4, '0')}\n`;
    output += `ADMIN: ${this.ADMIN.toString(2).padStart(4, '0')}\n\n`;
    
    // 显示用户权限
    output += '普通用户权限:\n';
    output += `权限值: ${userPermissions} (${userPermissions.toString(2).padStart(4, '0')})\n`;
    output += `有读权限? ${this.hasPermission(userPermissions, this.READ)}\n`;
    output += `有写权限? ${this.hasPermission(userPermissions, this.WRITE)}\n`;
    output += `有执行权限? ${this.hasPermission(userPermissions, this.EXECUTE)}\n`;
    output += `有管理员权限? ${this.hasPermission(userPermissions, this.ADMIN)}\n\n`;
    
    // 显示管理员权限
    output += '管理员权限:\n';
    output += `权限值: ${adminPermissions} (${adminPermissions.toString(2).padStart(4, '0')})\n`;
    output += `有读权限? ${this.hasPermission(adminPermissions, this.READ)}\n`;
    output += `有写权限? ${this.hasPermission(adminPermissions, this.WRITE)}\n`;
    output += `有执行权限? ${this.hasPermission(adminPermissions, this.EXECUTE)}\n`;
    output += `有管理员权限? ${this.hasPermission(adminPermissions, this.ADMIN)}\n\n`;
    
    // 权限操作示例
    output += '权限操作示例:\n';
    
    // 移除用户的写权限
    output += `移除用户的写权限前: ${userPermissions.toString(2).padStart(4, '0')}\n`;
    userPermissions = this.removePermission(userPermissions, this.WRITE);
    output += `移除用户的写权限后: ${userPermissions.toString(2).padStart(4, '0')}\n`;
    output += `有写权限? ${this.hasPermission(userPermissions, this.WRITE)}\n\n`;
    
    // 添加用户的执行权限
    output += `添加用户的执行权限前: ${userPermissions.toString(2).padStart(4, '0')}\n`;
    userPermissions = this.addPermission(userPermissions, this.EXECUTE);
    output += `添加用户的执行权限后: ${userPermissions.toString(2).padStart(4, '0')}\n`;
    output += `有执行权限? ${this.hasPermission(userPermissions, this.EXECUTE)}\n\n`;
    
    // 切换用户的读权限
    output += `切换用户的读权限前: ${userPermissions.toString(2).padStart(4, '0')}\n`;
    userPermissions = this.togglePermission(userPermissions, this.READ);
    output += `切换用户的读权限后: ${userPermissions.toString(2).padStart(4, '0')}\n`;
    output += `有读权限? ${this.hasPermission(userPermissions, this.READ)}\n\n`;
    
    // 检查是否有多个权限
    let requiredPermissions = this.READ | this.EXECUTE;
    output += `用户是否同时拥有读和执行权限? ${this.hasAllPermissions(userPermissions, requiredPermissions)}\n`;
    output += `管理员是否同时拥有读和执行权限? ${this.hasAllPermissions(adminPermissions, requiredPermissions)}\n\n`;
    
    // 检查是否有任一权限
    output += `用户是否拥有读或写权限? ${this.hasAnyPermission(userPermissions, this.READ | this.WRITE)}\n`;
    
    this.result = output;
  }
  
  // 检查是否有指定权限
  hasPermission(permissions: number, permission: number): boolean {
    return (permissions & permission) === permission;
  }
  
  // 添加权限
  addPermission(permissions: number, permission: number): number {
    return permissions | permission;
  }
  
  // 移除权限
  removePermission(permissions: number, permission: number): number {
    return permissions & ~permission;
  }
  
  // 切换权限
  togglePermission(permissions: number, permission: number): number {
    return permissions ^ permission;
  }
  
  // 检查是否同时拥有多个权限
  hasAllPermissions(permissions: number, requiredPermissions: number): boolean {
    return (permissions & requiredPermissions) === requiredPermissions;
  }
  
  // 检查是否拥有任一权限
  hasAnyPermission(permissions: number, somePermissions: number): boolean {
    return (permissions & somePermissions) !== 0;
  }
}

逻辑运算符