Skip to content
Shimon's BlogShimon's Blog
主页
杂谈
  • 主页
      • 代码笔记
          • 代码学习教程
              • JavaScript 教程
                  • 快速上手
                    • Map 和 Set
                      • 函数
                        • 变量
                          • 基本语法
                            • 字符串
                              • 实战
                                • 对象
                                  • 布尔值
                                    • 比较运算符
                                      • 布尔运算符
                                        • 与运算符 &&
                                          • 或运算符 ||
                                            • 非运算符 !
                                              • 三元运算符
                                            • 循环
                                              • 快速上手
                                                • 数据类型
                                                  • 数组
                                                    • 条件判断
                                                      • 遍历
                                                      • 错误处理
                                                      • 如何学习一门计算机语言

                                                    布尔值

                                                    Shimon Zhan2019年9月15日
                                                    • JavaScript
                                                    • 快速上手
                                                    大约 3 分钟

                                                    此页内容
                                                    • 比较运算符
                                                    • 布尔运算符
                                                      • 与运算符 &&
                                                      • 或运算符 ||
                                                      • 非运算符 !
                                                      • 三元运算符

                                                    布尔值代表“真”和“假”两个状态。“真”用关键字 true 表示,“假”用关键字 false 表示。布尔值只有这两个值。

                                                    下列运算符会返回布尔值:

                                                    • 前置逻辑运算符: ! (Not)
                                                    • 相等运算符: ===,!==,==,!=
                                                    • 比较运算符: >,>=,<,<=

                                                    如果 JavaScript 预期某个位置应该是布尔值,会将该位置上现有的值自动转为布尔值。转换规则是除了下面六个值被转为 false,其他值都视为 true。

                                                    • undefined
                                                    • null
                                                    • false
                                                    • 0
                                                    • NaN
                                                    • "" 或 ''(空字符串)

                                                    布尔值往往用于程序流程的控制,请看一个例子。

                                                    if ("") {
                                                      console.log("true");
                                                    }
                                                    // 没有任何输出
                                                    

                                                    上面代码中,if 命令后面的判断条件,预期应该是一个布尔值,所以 JavaScript 自动将空字符串,转为布尔值 false,导致程序不会进入代码块,所以没有任何输出。

                                                    注意

                                                    注意,空数组([])和空对象({})对应的布尔值,都是 true。

                                                    if ([]) {
                                                      console.log("true");
                                                    }
                                                    // true
                                                    
                                                    if ({}) {
                                                      console.log("true");
                                                    }
                                                    // true
                                                    

                                                    # 比较运算符

                                                    当我们对 Number 做比较时,可以通过比较运算符得到一个布尔值:

                                                    2 > 5; // false
                                                    5 >= 2; // true
                                                    7 == 7; // true
                                                    

                                                    实际上,JavaScript 允许对任意数据类型做比较:

                                                    false == 0; // true
                                                    false === 0; // false
                                                    

                                                    要特别注意相等运算符 ==。JavaScript 在设计时,有两种比较运算符:

                                                    • 第一种是 == 比较,它会自动转换数据类型再比较,很多时候,会得到非常诡异的结果;

                                                    • 第二种是 === 比较,它不会自动转换数据类型,如果数据类型不一致,返回 false,如果一致,再比较。

                                                    注意

                                                    由于 JavaScript 这个设计缺陷,不要使用 == 比较,始终坚持使用 === 比较。

                                                    另一个例外是 NaN 这个特殊的 Number 与所有其他值都不相等,包括它自己:

                                                    NaN === NaN; // false
                                                    

                                                    唯一能判断 NaN 的方法是通过 isNaN() 函数:

                                                    isNaN(NaN); // true
                                                    

                                                    最后要注意浮点数的相等比较:

                                                    1 / 3 === 1 - 2 / 3; // false
                                                    

                                                    这不是 JavaScript 的设计缺陷。因为计算机无法精确表示无限循环小数,浮点数在运算过程中会产生误差。要比较两个浮点数是否相等,只能计算它们之差的绝对值,看是否小于某个阈值:

                                                    Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001; // true
                                                    

                                                    # 布尔运算符

                                                    # 与运算符 &&

                                                    && 运算是与运算,从左至右运行时,检测到有任一表达式为 false 时,即停止执行输出该表达式的值,否则输出最后一个表达式的值。

                                                    也就是说,只有当所有表达式都为“真”时, && 才会输出真值。

                                                    true && true; // 这个&&语句计算结果为true
                                                    true && false; // 这个&&语句计算结果为false
                                                    false && true && false; // 这个&&语句计算结果为false
                                                    

                                                    # 或运算符 ||

                                                    || 运算是或运算,从左至右运行时,检测到有任一表达式为 true 时,即停止执行输出该表达式的值,否则输出最后一个表达式的值。

                                                    也就是说,只有当所有表达式都为“假”时, || 才会输出假值。

                                                    false || false; // 这个||语句计算结果为false
                                                    true || false; // 这个||语句计算结果为true
                                                    false || true || false; // 这个||语句计算结果为true
                                                    

                                                    # 非运算符 !

                                                    ! 运算是非运算,它是一个单目运算符,把 true 变成 false,false 变成 true:

                                                    提示

                                                    ! 会等待其后的表达式运算完毕,之后将其转换为 Boolean 后给出一个相反的值。

                                                    !true; // 结果为false
                                                    !false; // 结果为true
                                                    !(2 > 5); // 结果为true
                                                    

                                                    布尔值经常用在条件判断中,比如:

                                                    let age = 15;
                                                    
                                                    if (age >= 18) alert("adult");
                                                    else alert("teenager");
                                                    

                                                    # 三元运算符

                                                    详见 条件判断 → 三元运算符 章节

                                                    上次编辑于: 2022/4/19 07:13:07
                                                    贡献者: ShimonZhan
                                                    上一页
                                                    对象
                                                    下一页
                                                    循环
                                                    Copyright © 2021-present Shimon Zhan