美文网首页
JS基础(二)

JS基础(二)

作者: a437e8f87a81 | 来源:发表于2022-02-15 11:42 被阅读0次

    // 值的比较

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

    相关文章

      网友评论

          本文标题:JS基础(二)

          本文链接:https://www.haomeiwen.com/subject/ajuhlrtx.html