// 值的比较
// 比较结果为 Boolean 类型
// 所有比较运算符均返回布尔值：
// true —— 表示“yes（是）”，“correct（正确）”或“the truth（真）”。
// false —— 表示“no（否）”，“wrong（错误）”或“not the truth（非真）”。
alert(2 >1 ); // true（正确）
alert(2 ==1 ); // false（错误）
alert(2 !=1 ); // true（正确）
let result =5 >4; // 把比较的结果赋值给 result
alert(result ); // true
// 字符串比较
alert('Z' >'A' ); // true
alert('Glow' >'Glee' ); // true
alert('Bee' >'Be' ); // true
// 在上面的第一个例子中，'Z' > 'A' 比较在算法的第 1 步就得到了结果。
// 在第二个例子中，字符串 Glow 与 Glee 的比较则需要更多步骤，因为需要逐个字符进行比较：
// G 和 G 相等。
// l 和 l 相等。
// o 比 e 大，算法停止，第一个字符串大于第二个。
// 字符串的比较算法非常简单：
// 首先比较两个字符串的首位字符大小。
// 如果一方字符较大（或较小），则该字符串大于（或小于）另一个字符串。算法结束。
// 否则，如果两个字符串的首位字符相等，则继续取出两个字符串各自的后一位字符进行比较。
// 重复上述步骤进行比较，直到比较完成某字符串的所有字符为止。
// 如果两个字符串的字符同时用完，那么则判定它们相等，否则未结束（还有未比较的字符）的字符串更大
// 在上面的算法中，比较大小的逻辑与字典或电话簿中的排序很像，但也不完全相同。
// 比如说，字符串比较对字母大小写是敏感的。大写的 "A" 并不等于小写的 "a"。哪一个更大呢？实际上小写的 "a" 更大。这是因为在 JavaScript 使用的内部编码表中（Unicode），小写字母的字符索引值更大。我们会在 字符串 这章讨论更多关于字符串的细节。
// 不同类型间的比较
// 当对不同类型的值进行比较时，JavaScript 会首先将其转化为数字（number）再判定大小。
alert('2' >1 ); // true，字符串 '2' 会被转化为数字 2
alert('01' ==1 ); // true，字符串 '01' 会被转化为数字 1
alert(true ==1 ); // true
alert(false ==0 ); // true
let a =0
alert(Boolean(a))// false
let b ="0"
alert(Boolean(b))// true
alert(a ==b)// true
// 严格相等
// 普通的相等性检查 == 存在一个问题，它不能区分出 0 和 false：
alert(0 ==false ); // true
alert('' ==false ); // true
// 严格相等运算符 === 在进行比较时不会做任何的类型转换。
alert(0 ===false ); // false，因为被比较值的数据类型不同
// 同样的，与“不相等”符号 != 类似，“严格不相等”表示为 !==。
// 严格相等的运算符虽然写起来稍微长一些，但是它能够很清楚地显示代码意图，降低你犯错的可能性。
// 对 null 和 undefined 进行比较
alert(null ===undefined ); // false
alert(null ==undefined ); // true
// 当使用数学式或其他比较方法 < > <= >= 时：
// null/undefined 会被转化为数字：null 被转化为 0，undefined 被转化为 NaN。
alert(null >0 ); // (1) false
alert(null ==0 ); // (2) false
alert(null >=0 ); // (3) true
// 是的，上面的结果完全打破了你对数学的认识。在最后一行代码显示“null 大于等于 0”的情况下，前两行代码中一定会有一个是正确的，然而事实表明它们的结果都是 false。
// 比较运算符始终返回布尔值。
// 字符串的比较，会按照“词典”顺序逐字符地比较大小。
// 当对不同类型的值进行比较时，它们会先被转化为数字（不包括严格相等检查）再进行比较。
// 在非严格相等 == 下，null 和 undefined 相等且各自不等于任何其他的值。
// 在使用 > 或 < 进行比较时，需要注意变量可能为 null/undefined 的情况。比较好的方法是单独检查变量是否等于 null/undefined。
// 5 > 4 → true
// "apple" > "pineapple" → false
// "2" > "12" → true
// undefined == null → true
// undefined === null → false
// null == "\n0\n" → false
// null === +"\n0\n" → false
// 结果的原因：
// 数字间比较大小，显然得 true。
// 按词典顺序比较，得 false。"a" 比 "p" 小。
// 与第 2 题同理，首位字符 "2" 大于 "1"。
// null 只与 undefined 互等。
// 严格相等模式下，类型不同得 false。
// 与第 4 题同理，null 只与 undefined 相等。
// 不同类型严格不相等。
// 条件分支：if 和 '?'
let year =prompt("hahah","")
if (year ==2015)alert("xxxxx")// 单个语句
if (year ==2016) {
alert("xxxx")
alert("xxxxx")
}//建议每次使用 if 语句都用大括号 {} 来包装代码块，即使只有一条语句。这样可以提高代码可读性。
// 布尔转换
if (0) {//0 是假值 false
// xxx 、
}
if (1) {// 1 是真值（truthy）
...
}
let year =prompt('In which year was ECMAScript-2015 specification published?', '');
if (year ==2015) {
alert('You guessed it right!' );
}else {
alert('How can you be so wrong?' ); // 2015 以外的任何值
}
if (year <2015) {
alert('Too early...' );
}else if (year >2015) {
alert('Too late' );
}else {
alert('Exactly!' );
}
// 条件运算符 ‘?’
let accessAllowed;
let age =prompt('How old are you?', '');
if (age >18) {
accessAllowed =true;
}else {
accessAllowed =false;
}
alert(accessAllowed);
// 简写为：
let condition =true
// let result = condition ? value1 : value2; 计算条件结果，如果结果为真，则返回 value1，否则返回 value2。
// 多个 ‘?’
let age =prompt("age?","18")
let message = (age <3) ?'xxx' : (age <18) ?"21212" : (age <100) ?'121212' :"12121221"
alert(message );
// let message;
// if (login == 'Employee') {
// message = 'Hello';
// } else if (login == 'Director') {
// message = 'Greetings';
// } else if (login == '') {
// message = 'No login';
// } else {
// message = '';
// }
// let message = (login == 'Employee') ? 'Hello' :
// (login == 'Director') ? 'Greetings' :
// (login == '') ? 'No login' :
// '';
// 逻辑运算符
// 或运算寻找第一个真值
// 或运算符 || 做了如下的事情：
// 从左到右依次计算操作数。
// 处理每一个操作数时，都将其转化为布尔值。如果结果是 true，就停止计算，返回这个操作数的初始值。
// 如果所有的操作数都被计算过（也就是，转换结果都是 false），则返回最后一个操作数。
// 返回的值是操作数的初始形式，不会做布尔转换。
// 换句话说，一个或运算 || 的链，将返回第一个真值，如果不存在真值，就返回该链的最后一个值。
// 例如：
alert(1 ||0 ); // 1（1 是真值）
alert(null ||1 ); // 1（1 是第一个真值）
alert(null ||0 ||1 ); // 1（第一个真值）
alert(undefined ||null ||0 ); // 0（都是假值，返回最后一个值）
// 获取变量列表或者表达式中的第一个真值。
// 例如，我们有变量 firstName、lastName 和 nickName，都是可选的（即可以是 undefined，也可以是假值）。
// 我们用或运算 || 来选择有数据的那一个，并显示出来（如果没有设置，则用 "Anonymous"）：
let firstName ="";
let lastName ="";
let nickName ="SuperCoder";
alert(firstName ||lastName ||nickName ||"Anonymous"); //如果所有变量的值都为假，结果就是 "Anonymous"。
// 短路求值（Short-circuit evaluation）。
// 或运算符 || 的另一个用途是所谓的“短路求值”。
// 这指的是，|| 对其参数进行处理，直到达到第一个真值，然后立即返回该值，而无需处理其他参数。
// 如果操作数不仅仅是一个值，而是一个有副作用的表达式，例如变量赋值或函数调用，那么这一特性的重要性就变得显而易见了。
// 在下面这个例子中，只会打印第二条信息：
true ||alert("not printed");
false ||alert("printed");
// 在第一行中，或运算符 || 在遇到 true 时立即停止运算，所以 alert 没有运行。
// 有时，人们利用这个特性，只在左侧的条件为假时才执行命令。
// && 与运算寻找第一个假值
// result = value1 && value2 && value3;
// 与运算 && 做了如下的事：
// 从左到右依次计算操作数。
// 在处理每一个操作数时，都将其转化为布尔值。如果结果是 false，就停止计算，并返回这个操作数的初始值。
// 如果所有的操作数都被计算过（例如都是真值），则返回最后一个操作数。
// 换句话说，与运算返回第一个假值，如果没有假值就返回最后一个值。
// 上面的规则和或运算很像。区别就是与运算返回第一个假值，而或运算返回第一个真值。
// 如果第一个操作数是真值，
// 与运算返回第二个操作数：
alert(1 &&0 ); // 0
alert(1 &&5 ); // 5
// 如果第一个操作数是假值，
// 与运算将直接返回它。第二个操作数会被忽略
alert(null &&5 ); // null
alert(0 &&"no matter what" ); // 0
alert(1 &&2 &&null &&3 ); // null
alert(1 &&2 &&3 ); // 3，最后一个值
// 与运算 && 在或运算 || 之前进行
// 与运算 && 的优先级比或运算 || 要高。
// 所以代码 a && b || c && d 跟 && 表达式加了括号完全一样：(a && b) || (c && d)。
!（非）
// 感叹符号 ! 表示布尔非运算符。
alert( !true ); // false
alert( !0 ); // true
// 两个非运算 !! 有时候用来将某个值转化为布尔类型：
alert( !!"non-empty string" ); // true
alert( !!null ); // false
// 非运算符 ! 的优先级在所有逻辑运算符里面最高，所以它总是在 && 和 || 之前执行。
// let userName = prompt("Who's there?", '');
// if (userName === 'Admin') {
// let pass = prompt('Password?', '');
// if (pass === 'TheMaster') {
// alert( 'Welcome!' );
// } else if (pass === '' || pass === null) {
// alert( 'Canceled' );
// } else {
// alert( 'Wrong password' );
// }
// } else if (userName === '' || userName === null) {
// alert( 'Canceled' );
// } else {
// alert( "I don't know you" );
// }
// 空值合并运算符 '??'
// ?? 运算符的优先级非常低，仅略高于 ? 和 =，因此在表达式中使用它时请考虑添加括号。
// 空值合并运算符（nullish coalescing operator）的写法为两个问号 ??。
// 由于它对待 null 和 undefined 的方式类似，所以在本文中我们将使用一个特殊的术语对其进行表示。我们将值既不是 null 也不是 undefined 的表达式称为“已定义的（defined）”。
// a ?? b 的结果是：
// 如果 a 是已定义的，则结果为 a，
// 如果 a 不是已定义的，则结果为 b。
// let user;
// alert(user ?? "匿名"); // 匿名（user 未定义）
// let user = "John";
// alert(user ?? "匿名"); // John（user 已定义）
网友评论