javascript高级相关语法

javascript高级相关语法

隐式转换

1、减 乘 除的运算

在对各种非number类型的进行减乘除时，会先将非number的转为number类型进行计算。

布尔类型 ： true 转换为 1 false转换为0

null：转换为0

undefined：转化为数字类型为 NaN

["5"] :转换为数字类型为5

2、加法

1>当一侧为string类型时，会被识别为字符串的拼接，将另一边不是字符串的转化为字符串类型进行计算

2>当一侧为number类型，另一侧为原始类型，将原始类型转化为number类型

3>当一侧为number类型，另一侧为引用类型，会先将两侧转化为字符串，然后进行字符串的拼接

2+“3”=“23”  //规则一
2 + null =2
2+ true =2
2+false = 2
123+{}= 123{object object}

3、逻辑语句中的类型转换

当使用 if while for 语句时，我们希望返回一个Boolean值，这时就需要隐式转换，分为下面两种情况：

1>单个变量

如果只有单个变量，会先将变量转换为布尔值

只有 null undefined '' NaN 0 false 这几个是 false，其他的情况都是 true，比如 {} , []。

2> 使用==的五条规则

• NaN和任何值比较返回的都是false

  NAN ==  NAN;  //false

• 布尔值和其它类型的值比较，会先将布尔值转换为number类型

  true == 1  // true 
  true == '2'  // false, 先把 true 变成 1，而不是把 '2' 变成 true
  true == ['1']  // true, 先把 true 变成 1， ['1']拆箱成 '1', 再参考规则3
  true == ['2']  // false, 同上
  undefined == false // false ，首先 false 变成 0，然后参考规则4
  null == false // false，同上

• string和number比较，将string转化为number再进行比较

  123 == '123' // true, '123' 会先变成 123
  '' == 0 // true, '' 会首先变成 0

• null == undefined比较结果是true，除此之外，null、undefined和其他任何结果的比较值都为false`

• 原始类型和引用类型作比较时，引用类型会依照ToPrimitive规则转换为原始类型。===

 严格等于

首先比较数据类型在比较值

// 严格等于
console.log(null == undefined); // true
console.log(null === undefined); // false
console.log(null === null); // true
console.log(new Object() === new Object()); // false

类型检测

• typeof检测基本数据类型

instance适用于引用数据类型

console.log([1,2,3] instanceof Array); // true
console.log({} instanceof Object); // true
console.log({} instanceof Array); // false
console.log( new Date() instanceof Date); // true

• Object.protrotype,toString.call  可以判断数组  对象的类型

console.log(Object.prototype.toString.call([1,2,3]);//[object Array]
console.log(Object.prototype.toString.call({name:"张三"});//[object ]
console.log(Object.prototype.toString.call(‘abc’);//[object String]

 表达式和运算符

 表达式：使用运算符将操作进行连接，单个常量或者变量也是一个表达式

1+5
var a = 10;
常量3.14也是表达式。
true, this, undefined 都属于表达式

数组以及对象的初始化表达式

  //  数组  对象初始化表达式
        //创建对象 
        //  1、利用自变量的方式创造对象
        var obj = { a: 3, b: 8 }
        console.log("obj", obj)  //{a:3,b:8}
        var obj2 = new Object();
        obj2.a = 1;
        obj2.b = 4;
        console.log("obj2", obj2)  //{1:1,b:4}

        //创建数组
        var arr = [1, 4, 6];
        console.log(arr);//[1,4,6] 
        var arr2 = new Array(2, 4, 6);//创建一个数组，数组中包含三个值  分别为 2，4，6
        console.log(arr2);//[2, 4, 6]

        const arr3 = [8];//定义一个包含一个元素的数组
        const arr4 = new Array(5);//创建一个包含五个元素的数组，内容为undefined

        var arr5 = [1, , , 4]; // 稀疏数组
        arr5.forEach(function (item, index) {
            console.log(item, index); // 不会遍历出空属性  1 0  4 3
        });

        var arr6 = [1, 4];
        arr6[100] = 100;
        console.log('arr6', arr6.length, arr6);//101   [1, 4, 空属性 × 98, 100]
        for (var i = 0; i < arr6.length; i++) {
            console.log(arr6[i]);
        }

        arr6.forEach(function (item, index) {
            console.log(item, index);  // 不会遍历出空属性
        });

函数表达式

        //函数表达式
        //创建函数
        function fn(){
            console.log('这是一个函数')
        };
        fn();//调用函数
       
        var fn2 = function(){
            console.log('这是fn2hansgu1')
        };//使用函数白哦大师创建的函数，要在函数定义之后调用
        fn2()

立即执行函数

(function (param) {
console.log("立即执行函数",param);
})(10);

运算符

分类：按照操作数的个数可以分为一元二元三元

三元运算符：结果为boolean类型的表达式，可以写成三元表达式

        //三元表达式
        var a=3;
        var b=6;
        var max = a >b ? a : b;
        console.log(max)

delete运算符，可以用来删除对象中的属性

        //delete运算符，可以用来删除对象中的属性
        var obj3 = {x:3,y:7};
        console.log('obj3',obj3)//{x: 3, y: 7}
        delete obj3.x;
        console.log('arr3',obj3);//{y: 7}

        var Obj = new Object();
        Object.defineProperty(obj3,'x',{
            value:100,
            configurable:false,//是否可配置，可删除
            writable:true,//是否可修改
            enumerable:true,//是否可枚举
        })

注意点： 使用Object.defineProperty定义对象的属性时，configurable,writable,enumerable默认值都是false

in运算符

用来判断属性是否属于该对象

  // 使用in运算符判断x是否属于 obj3上的属性
        console.log('z' in obj3);

void运算符

 <a href="javascript: void(0)">百度</a>

捕获异常

     try {
                try {
                    var str = undefined;
                    var result = str.trim();
                } catch (ex) {
                    console.error("内层：", ex);
                }finally {
                    // 不管代码是否发生异常，finally块中的代码都会执行
                    console.log("finally");
                }
            } catch (ex) {
                console.error(ex);
            } finally {
                console.log("外层的finally");
            }

for-in循环

        var obj = { x: 1, y: 2 };
        Object.defineProperty(obj, 'z', {
            value: 3,
            enumerable: true
        });
        for (var key in obj) {
            console.log(obj[key]);
        }

1. 顺序不确定

2. enumerable为false时不会出现

3. for in对象属性受原型链影响