JavaScript Boolean（布尔）

什么是布尔类型

布尔类型（Boolean）是 JavaScript 中一种基本数据类型，它只有两个值：true（真）和 false（假）。布尔类型通常用于条件判断和逻辑运算。

布尔值的创建

你可以通过以下方式创建布尔值：

// 直接赋值
let isTrue = true;
let isFalse = false;

// 使用 Boolean 构造函数
let bool1 = new Boolean(true);
let bool2 = new Boolean(false);

// 使用 Boolean 函数转换
let bool3 = Boolean(1); // true
let bool4 = Boolean(0); // false
let bool5 = Boolean("hello"); // true
let bool6 = Boolean(""); // false

// 使用 !! 运算符转换
let bool7 = !!1; // true
let bool8 = !!0; // false

布尔值的转换

JavaScript 中，许多值在布尔上下文中会被自动转换为布尔值。以下是一些常见值的布尔转换：

假值（Falsy Values）

在布尔上下文中被转换为 false 的值：

// 假值列表
false; // 布尔假值
0 - // 数字零
  0; // 负零
0n; // BigInt 零
(""); // 空字符串
null; // 空值
undefined; // 未定义
NaN; // 非数字

// 验证
console.log(Boolean(false)); // false
console.log(Boolean(0)); // false
console.log(Boolean("")); // false
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean(NaN)); // false

真值（Truthy Values）

在布尔上下文中被转换为 true 的值：

// 真值列表
true        // 布尔真值
1           // 非零数字
-1          // 非零负数
1n          // 非零 BigInt
'hello'     // 非空字符串
'false'     // 字符串 'false'
[]          // 空数组
{}          // 空对象
function(){} // 空函数

// 验证
console.log(Boolean(true));    // true
console.log(Boolean(1));       // true
console.log(Boolean('hello')); // true
console.log(Boolean([]));      // true
console.log(Boolean({}));      // true

布尔运算符

JavaScript 提供了以下布尔运算符：

逻辑与（&&）

// 逻辑与：只有当两个操作数都为真时，结果才为真
console.log(true && true); // true
console.log(true && false); // false
console.log(false && true); // false
console.log(false && false); // false

// 短路求值：如果第一个操作数为假，则返回第一个操作数，否则返回第二个操作数
console.log("hello" && "world"); // 'world'
console.log("" && "world"); // ''
console.log(0 && 1); // 0

逻辑或（||）

// 逻辑或：只要有一个操作数为真，结果就为真
console.log(true || true); // true
console.log(true || false); // true
console.log(false || true); // true
console.log(false || false); // false

// 短路求值：如果第一个操作数为真，则返回第一个操作数，否则返回第二个操作数
console.log("hello" || "world"); // 'hello'
console.log("" || "world"); // 'world'
console.log(0 || 1); // 1

逻辑非（!）

// 逻辑非：返回操作数的相反布尔值
console.log(!true); // false
console.log(!false); // true
console.log(!0); // true
console.log(!1); // false
console.log(!""); // true
console.log(!"hello"); // false

// 双重逻辑非：将值转换为布尔值
console.log(!!true); // true
console.log(!!false); // false
console.log(!!0); // false
console.log(!!1); // true
console.log(!!""); // false
console.log(!!"hello"); // true

逻辑空值合并（??）（ES2020+）

// 逻辑空值合并：如果第一个操作数不为 null 或 undefined，则返回第一个操作数，否则返回第二个操作数
console.log(null ?? "default"); // 'default'
console.log(undefined ?? "default"); // 'default'
console.log(false ?? "default"); // false
console.log(0 ?? "default"); // 0
console.log("" ?? "default"); // ''

可选链运算符（?.）（ES2020+）

虽然不是严格的布尔运算符，但可选链运算符常用于布尔上下文中，用于安全地访问对象的属性：

// 可选链运算符：如果对象存在，则访问其属性，否则返回 undefined
const user = { name: "John" };
console.log(user?.name); // 'John'
console.log(user?.age); // undefined
console.log(user?.address?.street); // undefined

// 与逻辑与运算符的比较
console.log(user && user.name); // 'John'
console.log(user && user.age); // undefined

Boolean 对象

Boolean 对象是布尔值的包装对象，使用 new Boolean() 创建：

// 创建 Boolean 对象
let boolObj = new Boolean(true);
console.log(boolObj); // [Boolean: true]
console.log(typeof boolObj); // 'object'

// 布尔值与 Boolean 对象的区别
let boolPrimitive = true;
let boolObject = new Boolean(true);

console.log(typeof boolPrimitive); // 'boolean'
console.log(typeof boolObject); // 'object'
console.log(boolPrimitive === boolObject); // false
console.log(boolPrimitive == boolObject); // true（会进行类型转换）

// Boolean 对象的 valueOf() 方法
console.log(boolObject.valueOf()); // true
console.log(typeof boolObject.valueOf()); // 'boolean'

布尔值的应用

条件判断

// if 语句
let age = 18;
if (age >= 18) {
  console.log("成年人");
} else {
  console.log("未成年人");
}

// 三元运算符
let isAdult = age >= 18 ? "成年人" : "未成年人";
console.log(isAdult);

// while 循环
let count = 5;
while (count > 0) {
  console.log(count);
  count--;
}

// do-while 循环
let i = 0;
do {
  console.log(i);
  i++;
} while (i < 5);

逻辑运算

// 检查变量是否存在
let username = "";
let displayName = username || "Guest";
console.log(displayName); // 'Guest'

// 安全地访问嵌套对象
const user = { profile: { name: "John" } };
let userName = user && user.profile && user.profile.name;
console.log(userName); // 'John'

// 使用可选链运算符（ES2020+）
let userAge = user?.profile?.age ?? "未知";
console.log(userAge); // '未知'

// 检查多个条件
let password = "MyPassword123";
let isPasswordValid =
  password.length >= 8 && /[A-Z]/.test(password) && /[0-9]/.test(password);
console.log(isPasswordValid); // true

函数参数默认值

// 使用逻辑或设置默认值
function greet(name) {
  name = name || "Guest";
  console.log(`Hello, ${name}!`);
}

greet("John"); // Hello, John!
greet(); // Hello, Guest!

// 使用 ES6 默认参数
function greetES6(name = "Guest") {
  console.log(`Hello, ${name}!`);
}

greetES6("John"); // Hello, John!
greetES6(); // Hello, Guest!

// 使用空值合并运算符（ES2020+）处理假值
function processValue(value) {
  // 只有当 value 为 null 或 undefined 时才使用默认值
  value = value ?? "default";
  console.log(value);
}

processValue(null); // 'default'
processValue(undefined); // 'default'
processValue(false); // false
processValue(0); // 0
processValue(""); // ''

最佳实践

1. 使用布尔字面量：直接使用 true 和 false 字面量，而不是通过 new Boolean() 创建布尔对象。布尔对象是引用类型，可能会导致意外的行为。

   // 推荐
   let isActive = true;
   
   // 不推荐
   let isActive = new Boolean(true);

2. 使用 === 进行严格比较：比较布尔值时，使用严格相等运算符 === 而不是抽象相等运算符 ==，以避免类型转换导致的意外结果。

   // 推荐
   if (isActive === true) {
     // 代码
   }
   
   // 不推荐
   if (isActive == true) {
     // 代码
   }

3. 使用双重逻辑非 !! 转换为布尔值：当需要显式地将值转换为布尔值时，使用双重逻辑非 !! 是一种简洁的方式。

   // 推荐
   let isTruthy = !!value;
   
   // 也可以使用 Boolean 函数
   let isTruthy = Boolean(value);

4. 注意假值的陷阱：了解哪些值是假值，避免在条件判断中出现意外。例如，空数组 [] 和空对象 {} 在布尔上下文中是真值。

   // 注意：空数组是真值
   if ([]) {
     console.log("空数组是真值");
   }
   
   // 注意：空对象是真值
   if ({}) {
     console.log("空对象是真值");
   }

5. 使用 ES6+ 的特性：对于现代 JavaScript 环境，使用可选链运算符 ?. 和空值合并运算符 ?? 可以使代码更简洁、更安全。

   // 推荐（ES2020+）
   let userName = user?.name ?? "Guest";
   
   // 不推荐
   let userName = user && user.name ? user.name : "Guest";

6. 避免不必要的布尔转换：在条件判断中，JavaScript 会自动进行布尔转换，不需要显式地使用 Boolean() 或 !!。

   // 推荐
   if (value) {
     // 代码
   }
   
   // 不推荐
   if (Boolean(value)) {
     // 代码
   }

总结

布尔类型是 JavaScript 中一种基本数据类型，它只有两个值：true 和 false。布尔类型在条件判断、逻辑运算和控制流程中起着核心作用。

了解布尔值的转换规则、布尔运算符的使用方法以及布尔值的常见应用场景，有助于你更有效地编写 JavaScript 代码。

通过遵循最佳实践，你可以避免布尔值使用中的常见陷阱，编写更清晰、更可靠的 JavaScript 代码。