// 值的比较
// 比较结果为 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 已定义)
网友评论