原生js 小知识点

#eval 接受一个字符串，并将其内容视为好像原先就写成了代码一样。

function foo(str){
    "use strict";
    eval(str);
    console.log(a);//3

}
foo("var a = 3;");

 

但是在严格模式下，eval会自己增加一个作用域。结果如下：

function foo(str){
    "use strict";
    eval(str);
    console.log(a);//Uncaught ReferenceError: a is not defined

}
foo("var a = 3;");

 

#立即执行表达式

(function foo(num){

    console.log(3,num);

})(45);

也可以写成

(function foo(num){

    console.log(3,num);

}(45));

 

#'use strict';  

规范js的代码格式，建议每个js文件都用之

 

#var ”变量提升“现象，只是声明的提升，定义或者赋值不提升

// var 的情况
console.log(foo); // 输出undefined var foo = 2;  // let 的情况 console.log(bar); // 报错ReferenceError let bar = 2;

PS:const用法：
const PI = 3.14;

 

# ==与===区别

    ===需要参数类型相同，==则不需要类型相同

 

#js的循环

（1）of  in区别

   of: 遍历集合本身，in则遍历每一个键值对；即，in的范围要大一些。

var a = ['A', 'B', 'C'];
a.name = 'Hello';

    of包含：A B C；in包含了A B C name

   XXX

（1）forEach

  var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]); m.forEach(function (value, key, map) { console.log(""+key+"-"+value); });

 

#数组的高阶函数

    （1）map  ：每一个元素做操作

      var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
      var results = arr.map((x)=>{return x^2;}); // [1, 4, 9, 16, 25, 36, 49, 64, 81]
      console.log(results);

     （2）reduce：每2个元素操作，不断迭代

  效果：[x1, x2, x3, x4].reduce(f) = f(f(f(x1, x2), x3), x4)

      var arr = [1, 3, 5, 7, 9];
      arr.reduce(function (x, y) {
          return x * 10 + y;
      }); // 13579

     （3）filter函数：过滤一些元素

   var arr = [1, 2, 4, 5, 6, 9, 10, 15];  var r = arr.filter(function (x) { return x % 2 !== 0; }); r; // [1, 5, 9, 15]

     （4）sort：排序

   var arr = [10, 20, 1, 2]; arr.sort(function (x, y) { if (x < y) { return 1; } if (x > y) { return -1; } return 0; }); // [20, 10, 2, 1]

 

#闭包：闭包经常用于创建含有隐藏数据的函数，闭包就是能够读取其他函数内部变量的函数。

     参看链接https://kb.cnblogs.com/page/110782/。

      http://www.ruanyifeng.com/blog/

 

 

#闭包中的this

https://www.cnblogs.com/nuanriqingfeng/p/5789003.html

 

#call apply

所有函数都有call apply这2个方法。如果不适用他们，那么就需要给函数 显式传入一个上下文对象，略显麻烦。

method.call(obj);//method为方法名，obj为执行此方法的对象。

               function sayHello() {  alert(this.name);  }

               let me = {"name":"leo","age":22};

              sayHello.call(me);

 

call和apply的第一个参数都是对象，call后续的参数是传入的参数序列（不是数组），apply的第二个参数是一个数组。  call(obj,p1,p2,p3);          apply(obj,[p1,p2,p3]);

    function add(c,d){
        return this.a + this.b + c + d;
    }
    var s = {a:1, b:2};
    console.log(add.call(s,3,4)); // 1+2+3+4 = 10
    console.log(add.apply(s,[5,6])); // 1+2+5+6 = 14

#对象属性配置

var myObject = {a:2};

Object.getOwnPropertyDescriptor(myOjbect,"a");  //获取属性的配置

Object.defineProperty(myOjbect,"a",{   //设定属性的配置

    value:2,

    writable:true,

    configurable:true,

    enumerable:true

});

//value :2                值          【好理解】

//writable:true         可写       【好理解】

//enumerable:true  可枚举     【如果设置为false，那么对象（含数组）的for in循环将获取不到该属性，】

//configurable:true   可配置   【 把configurable 修改成false 是单向操作，无法撤销！】

 

PS：通过configurable和writable可以添加一个常量属性。

 

#取消链接的href

  href="javacript:void(0);"

 

 

#XXXX

XXX

   XXX

XXX

 

#XXXX

XXX

   XXX

XXX

 

#XXXX

XXX

   XXX

XXX

 

#XXXX

XXX

   XXX

XXX

 

#XXXX

XXX

   XXX

XXX

 

#XXXX

XXX

   XXX

XXX

 

#XXXX

XXX

   XXX

XXX

 

转载于:https://www.cnblogs.com/dongfangchun/p/8995486.html