// 值的比较

// 比较结果为 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 已定义）