美文网首页
类型和语法--类型、值

类型和语法--类型、值

作者: 怪兽别跑biubiubi | 来源:发表于2019-07-10 10:36 被阅读0次
        <!DOCTYPE html>
        <html lang="en">
        <head>
          <meta charset="UTF-8">
          <meta name="viewport" content="width=device-width, initial-scale=1.0">
          <meta http-equiv="X-UA-Compatible" content="ie=edge">
          <title>类型和语法--2</title>
        </head>
        <body>
          <script>
            // 类数组
            // var a = "foo";
            // var b = ["f", "o", "o"];
            // console.log(a.length);  // 3
            // console.log(b.length);  // 3
    
            // console.log(a.indexOf('o'));  // 1
            // console.log(b.indexOf('o'));  // 1
    
            // var c = a.concat('bar');
            // var d = b.concat(["b", "a", "r"]);
            // console.log(c);  // foobar
            // console.log(d);  // ["f", "o", "o", "b", "a", "r"]
            
            // console.log(a === c);  // false
            // console.log(b === d);  // false
    
            // console.log(a);  // foo
            // console.log(b);  // ["f", "o", "o"]
    
            // var e = a.charAt(1);
            // console.log(e);  // o
    
            // c = a.toUpperCase(); // toUpperCase()将字符串转换为大写
            // console.log(c); // FOO
            // console.log(a); // foo
            // b.push('!');
            // console.log(b); // ["f", "o", "o", "!"]
            // ----------------------------------------------------------------------------------------------
              // 总结:
              // --------字符串原始值不会改变,会创建并返回一个新的字符串;
              // --------数组的成员函数都是在原始值上直接进行操作的;
            // ----------------------------------------------------------------------------------------------
    
            //  ------- 处理字符串 -------
            // 一:
            // var c = Array.prototype.join.call(a, '-');  // join:将一个数组或者一个类数组对象的所有元素连成一个字符串并返回这个字符串
            // var d = Array.prototype.map.call(a, (v) => {
            //   return v.toUpperCase() + '.'
            // }).join('');
            // console.log(c);  // f-o-o
            // console.log(d);  // F.O.O.
            // 二:字符串反转
            // b.reverse();
            // console.log(b);  // ["o","o","f"]
    
            // var c = a.split("").reverse().join("");
            // console.log(c);  // oof
            // ----------------------------------------------------------------------------------------------
              // reverse:颠倒数组中元素的顺序
              // split:把一个字符串分割成字符串数组
              // join:将一个数组或者一个类数组对象的所有元素连成一个字符串并返回这个字符串
            // ----------------------------------------------------------------------------------------------
    
    
            // ========================================================================================================
            // number
            // var a = 2E6;
            // console.log(a);  // 2000000
            // console.log(a.toExponential());  // 2e+6
            // var b = a * a;
            // console.log(b.toExponential());  // 4e+12
            // var c = 1 / a;
            // console.log(c.toExponential());  // 5e-7  -  0.0000005
            // ----------------------------------------------------------------------------------------------
              // toExponential:把对象的值转换成指数计数法;
            // ----------------------------------------------------------------------------------------------
    
              // var a = 43.59;
              // console.log(a.toFixed(0));  // 44
              // console.log(a.toFixed(1));  // 43.6
              // console.log(a.toFixed(2));  // 43.59
              // console.log(a.toFixed(3));  // 43.590
              // console.log(a.toFixed(4));  // 43.5900
              // ----------------------------------------------------------------------------------------------
                // toFixed:指定小数部分的显示位数;
              // ----------------------------------------------------------------------------------------------
              // console.log(a.toPrecision(1));  // 4e+1
              // console.log(a.toPrecision(2));  // 44
              // console.log(a.toPrecision(3));  // 43.6
              // console.log(a.toPrecision(4));  // 43.59
              // console.log(a.toPrecision(5));  // 43.590
              // console.log(a.toPrecision(6));  // 43.5900
              // ----------------------------------------------------------------------------------------------
                // toPrecision:指定有效数位的显示位数;
              // ----------------------------------------------------------------------------------------------
              // 无效语法:
              // console.log(42.toFixed( 3 ));    // SyntaxError 
        
              // 下面的语法都有效:
              // console.log((42).toFixed( 3 ));  // "42.000" 
              // console.log(0.42.toFixed( 3 ));  // "0.420" 
              // console.log(42..toFixed( 3 ));   // "42.000"
              // 42.. 第一个 . 被视为 number 的一部分,第二个 . 是属性访问 运算符。
    
              // console.log(42 .toFixed(3)); // "42.000" 注意空格
    
              // console.log(0xf3);  // 243
    
              // console.log(0o363);      // 243的八进制 
              // console.log(0O363);      // 同上 
        
              // console.log(0b11110011); // 243的二进制 
              // console.log(0B11110011); // 同上
    
            // ========================================================================================================
            // 解决 0.1 + 0.2 != 0.3的问题
              // function numbersClose (n1, n2) {
              //   return Math.abs(n1 - n2) < Number.EPSILON;
              // };
              // var a = 0.1 + 0.2;
              // var b = 0.3;
              // console.log(numbersClose(a, b));  // true
              // console.log(numbersClose( 0.0000001, 0.0000002 ));  // false
    
              // document.write(Math.abs(7.25) + "<br />")
              // document.write(Math.abs(-7.25) + "<br />")
              // document.write(Math.abs(7.25-10))
    
    
              // document.write(Number.isInteger(42) + "<br />");  // true
              // document.write(Number.isInteger(42.3));  // false
    
              // document.write(Number.isSafeInteger(Math.pow(2, 53)) + "<br />");  // false
              // document.write(Number.isSafeInteger(Math.pow(2, 53) - 1));  // true
    
              // document.write(Math.pow(2, 5));
    
              // ----------------------------------------------------------------------------------------------
                // Math.abs:返回数的绝对值
                // Number.EPSILON:表示 1 与大于 1 的最小浮点数之间的差。
                // Number.isInteger:检测一个值是否为整数
                // Number.isSafeInteger:检测一个值是否是安全的整数
              // ----------------------------------------------------------------------------------------------
    
            // ========================================================================================================
            // 特殊的数字 
              // if (!Number.isNaN) {
              //   Number.isNaN ((n) => {
              //     return typeof n === 'number' && window.isNaN(n);
              //     // return n !== n;
              //   });
              // };
              // var a = 2 / 'foo';
              // var b = 'foo';
    
              // console.log(Number.isNaN(a));  // true
              // console.log(Number.isNaN(b));  // false
    
              // ----------------------------------------------------------------------------------------------
                // isNaN(...):判断一个值是否是 NaN。缺陷:判断一个值是否不是 NaN,也不是数字
                // Number.isNaN(...):判断一个值是否是 NaN。 --->推荐使用
                // NaN 是 JavaScript 中唯 一一个不等于自身的值。
              // ----------------------------------------------------------------------------------------------
    
            // ========================================================================================================
            // 无穷数 
                // var a = 1 / 0;
                // console.log(a);  // Infinity
                // var b = Number.MAX_VALUE;  // 1.7976931348623157e+308
                // var c = Number.MIN_VALUE;  // 5e-324
                // console.log(b, c);
    
            // ========================================================================================================
                // var arr = [1,2,3, { a : 1 } ];
                // console.log(JSON.stringify(arr));  // [1,2,3,{"a":1}]
    
                // var jsonStr = '[1,2,3,{"a":1}]';
                // console.log(JSON.parse(jsonStr));  // [1, 2, 3, {"a":1}]
    
    
                // var a = 0 / -3; 
                // console.log(JSON.stringify( a ));   // "0"
                // console.log(JSON.parse( "-0" ));   // "-0"
                // -0 == 0;    // true 
                // JSON.stringify(-0) 返回 "0",而 JSON.parse("-0") 返回 -0。
    
                function isNegZero(n) {     
                  n = Number( n );     
                  return (n === 0) && (1 / n === -Infinity); 
                } 
                console.log(isNegZero( -0 ));        // true 
                console.log(isNegZero( 0 / -3 ));    // true 
                console.log(isNegZero( 0 ));         // false
    
              // ----------------------------------------------------------------------------------------------
                // JSON.stringify(...):将数组转换为字符串。
                // JSON.parse(...):解析字符串转换为数组
              // ----------------------------------------------------------------------------------------------
    
    
            // ========================================================================================================
              // var a = 2 / "foo"; 
              // var b = -3 * 0; 
              // Object.is( a, NaN );    // true 
              // Object.is( b, -0 );     // true 
              // Object.is( b, 0 );      // false
              
              if (!Object.is) {     
                Object.is = function(v1, v2) {         
                  // 判断是否是-0         
                  if (v1 === 0 && v2 === 0) {             
                    return 1 / v1 === 1 / v2; 
                  }         
                  // 判断是否是NaN         
                  if (v1 !== v1) {             
                    return v2 !== v2;         
                  }         
                  // 其他情况         
                  return v1 === v2;     
                }; 
              }
              // ----------------------------------------------------------------------------------------------
                // Object.is(...):判断两个值是否绝对相等。主要用来处理那些特殊的相等比较。
              // ----------------------------------------------------------------------------------------------
    
    
    
            // 小结 ========================================================================================================
              
              // JavaScript 中的数组是通过数字索引的一组任意类型的值。
              // 字符串和数组类似,但是它们的 行为特征不同,在将字符作为数组来处理时需要特别小心。
              // JavaScript 中的数字包括“整 数”和“浮点型”。
              // 基本类型中定义了几个特殊的值。
              // null 类型只有一个值 null,undefined 类型也只有一个值 undefined。
              // 所有变量在赋值之 前默认值都是 undefined。
              // void 运算符返回 undefined。
              // 数字类型有几个特殊值,包括NaN( 意指“not a number”, 更确切地说是“invalid number”)、 +Infinity、-Infinity和 -0。
              // 简单标量基本类型值(字符串和数字等)通过值复制来赋值 / 传递,而复合值(对象等) 通过引用复制来赋值 / 传递。
              // JavaScript 中的引用和其他语言中的引用 / 指针不同,它们不 能指向别的变量 / 引用,只能指向值
          
            // 小结 ========================================================================================================     
          </script>
        </body>
        </html>

    相关文章

      网友评论

          本文标题:类型和语法--类型、值

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