2021-04-21JS高级第二天

一、构造函数和原型

1.静态成员和实例成员（成员就是属性和方法）

（1）实例成员就是构造函数内部通过this添加的成员。实例成员只能通过实例化的对象来访问
（2）静态成员在构造函数本身上添加的成员。静态成员只能通过构造函数来访问

 function Star(uname, age) {
     this.uname = uname;  //实例成员
     this.age = age;  //实例成员
     this.sing = function() {  //实例成员
     console.log('我会唱歌');
    }
}
Star.sex = '男';  //静态成员
var ldh = new Star('刘德华', 18);
console.log(Star.sex);//静态成员只能通过构造函数来访问

2.构造函数原型prototype

（1）每一个构造函数都有一个prototype 属性，prototype是一个对象。
（2）一般情况下，我们把构造函数的公共方法放到原型对象prototype里面，实现方法共享。

function Star(uname, age) {
          this.uname = uname;
          this.age = age;
        }

        // 构造函数的公共方法写到原型对象里面
        Star.prototype.sing = function (song) {
          console.log(this.uname + '会唱' + song);
        };
        var WuLei = new Star('吴磊',22);
        WuLei.sing('苦乐年华');

3._proto_对象原型

（1）每个实例对象中都有一个_proto_属性，它指向构造函数中的原型对象prototype。
（2）_proto_对象原型和原型对象 prototype 是等价的。也是对象
（3）实例对象调用方法时，先去查找本身是否有该方法；再去prototype原型对象中查找。

4.constructor属性

（1）对象原型（ __ proto__）和构造函数的原型对象（prototype）里面都有一个属性 constructor 属性，constructor 我们称为构造函数，它指回构造函数本身。
（2）如果给prototype原型对象赋值为一个对象类型的数据,会覆盖原本的对象，则必须手动地把constructor指回原来的构造函数。

     function Star(uname, age) {
          this.uname = uname;
          this.age = age;
        }
        // 对象原型（ __proto__）和构造函数的原型对象（prototype）里面都有一个属
        // 性 constructor 属性 ，constructor 我们称为构造函数，因为它指回构造函数本身。
        Star.prototype = {
          constructor: Star, //在原型对象中手动将constructor属性指向构造函数
          sing: function () {
            console.log('我会唱歌');
          },
          film: function () {
            console.log('我会演电影');
          },
        };
        var star = new Star('吴磊', 22);

5.实例对象原型（ _proto_）、构造函数（prototype）原型对象、constructor属性

（1）构造函数通过prototype指向子属性原型对象prototype。
（2）原型对象prototype通过子属性constructor指向构造函数。
（3）实例对象通过_proto_对象原型与构造函数的原型对象prototype等价。

6.原型链

构造函数（prototype）原型对象也是一个对象，也有对象原型（_proto_），它指向Object的原型对象(prototype)。

原型链.PNG

7.实例对象调用属性和方法时的查找机制

（1）首先查找这个对象自身有没有该属性。
（2）如果没有就查找它的原型对象（也就是 __ proto__指向的 prototype 原型对象）。
（3）如果还没有，就查找原型对象的对象原型（指向的是Object的原型对象）。
（4）_proto_对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线。

8.this指向

构造函数中的this和原型对象的this,都指向我们new出来的实例对象。

9.利用prototype原型对象扩展内置对象方法

（1）构造函数.prototype.新方法( ) = function( ){ }
　　这是给原型对象追加新方法。
（2）构造函数.prototype = { 新方法1 ： function( ) { } ，新方法2 ： function( ) { } }
　　这种形式会覆盖原型对象prototype原本的内容。禁止用这种形式扩展内置对象方法。

        // 为数组添加自定义方法
        Array.prototype.sum = function () {
          var sum = 0;
          for (var i = 0; i < this.length; i++) {
            sum += this[i];
          }
          return sum;
        };

        //实例化数组对象
        var arr = new Array(11,22,33);
        console.log(arr.sum());
      });

10.call( )方法

方法名.call (this的指向, 参数1，参数2）

call( )方法可以调用函数；改变函数的this指向。

      function fn(x, y) {
          console.log(x + y);
          console.log(this);
        }

        var o = {};

        fn.call(o,1,2);//调用函数，并将fn函数的this指向改为对象o

11.子构造函数继承父构造函数

核心：（1）在子构造函数里调用父构造函数；把父构造函数的this指向修改为子构造函数。
　　　（2）把父构造函数的实例化对象赋值给子原型对象。
　　　（3）用对象赋值的方法会覆盖子原型对象的内容，要手动把子原型对象的constructor属性指回子构造函数。

           function Father(uname,age){
                this.uname = uname;
                this.age = age;
            }

            function Son(u_uname,a_age,weight){
                Father.call(this,u_uname,a_age);//1.子构造函数调用父构造函数
                this.weight = weight;
            }

            Son.prototype = new Father();//2.将父构造函数的实例对象赋值给子原型对象
            Son.prototype.constructor = Son;//3.将子原型对象的constructor属性指回子构造函数

            // 实例化子构造函数
            var son = new Son('吴磊',22,'60kg')
            console.log(son);

12.类class的本质是构造函数。

二、ES5新增的方法

forEach、filter、some方法的后面两个参数可以省略，只写一个参数就代表每个数组元素。

1.数组方法forEach( )遍历数组（对象也有）

数组名.forEach( function(item, index , array ) { } )
item：每一个数组元素
index：每一个数组元素的索引号
array：数组对象本身

var arr = [0, 1, 2];
      arr.forEach(function (item, index, array) {
        console.log('每一个数组元素' + item);
        console.log('每一个元素的索引号' + index);
        console.log('数组对象本身' + array);
      });

2.数组方法filter( )筛选数组元素

var 新数组名 = 数组名.filter( function( item, index , array ) { } )
item：每一个数组元素
index：每一个数组元素的索引号
array：原数组对象本身

注意：filter( )方法会遍历原数组，并把所有符合要求的元素筛选出来,一定要加return，返回值是一个新数组。

        var arr = [10,22,35,40];
        var newArr = arr.filter(function(item,index,array){
            return item% 2 == 0;//返回偶数装到新数组中
        })
        console.log(newArr);

3.数组方法some( )查找是否有满足条件的数组元素

var flag = 数组名.some( function( item, index , array ) { } )
item：每一个数组元素
index：每一个数组元素的索引号
array：原数组对象本身

注意：（1）some( )方法会遍历数组，判断是否有元素满足要求，返回值是布尔值。
　　　（2）some( )方法查找到第一个满足要求的元素后，立即停止循环遍历。
　　　（3）return true可以停止some( )方法的循环。另外两个方法不行。
　　　（4）注意return true 的位置，写到 if 判断语句中。

      var arr = [12, 45, 2, 67];
      var flag = arr.some(function (item, index, array) {
        if(item>= 100)
        return true;//判断是否有满足要求的条件
      });
      console.log(flag);

实际应用：查询并操作数组中的唯一元素时，用some()效率更高。

          var arr = [];
          data.some(function (value) {
            if (product.value === value.pname) {
              arr.push(value);
              return true;
            }
          }

4.字符串方法trim( )去除字符串两侧空格

字符串.trim( )

注意：trim( )方法可以去除字符串两侧的空格，但不会对字符串中间的空格有影响。返回值是一个新字符串。

5.获取对象的属性名

var arr = Object.keys(对象名)
注意：返回值是一个数组，里面是对象的属性名集合。

 var obj = {
     id: 1,
     pname: '小米',
     price: 1999,
     num: 2000
};
var result = Object.keys(obj)
console.log(result)//[id，pname,price,num]

6.修改与设置对象的属性

Object.defineProperty( 要修改的对象，要修改或新增的属性，｛｝)

三个参数都是必须属性，第三个参数是对象，属性如下：
（1）value:修改或新增的属性的值
（2）writable：true / false。默认值为false ，不允许修改这个属性值。
（3）enumerable：true / false。默认值为false ，不允许遍历这个属性。
（4）configurable: true / false。默认值为false，不允许删除这个属性。并且configurable的值不能二次修改。

      var WuLei = {
          uname: '吴磊',
          age: 22,
          height: 183,
        };

        // 添加属性
        Object.defineProperty(WuLei, 'hobby', {
          value: '撸铁',
          writeable: false,
          enumerable: false,
          configurable: false
        });

        // writeable设置为false,则不允许再修改hobby的value值
        WuLei.hobby = '撸串'
        console.log( WuLei.hobby);

        //enumerable设置为false，获取WuLei的属性名集合时，就没有hobby
        var arr = Object.keys(WuLei);
        console.log(arr);

        // configurable设置为false,不允许删除hobby属性
        delete WuLei.hobby;
        console.log(WuLei);

7. map 函数

var newArr = arr.map(function(item,value,arr){ })

（1）map方法会遍历数组，每个数组元素都会执行回调函数。
（2）map方法的回调函数中，必须有 return，返回的数据被 存入新数组中。
（3）map方法返回值是一个 新数组，不会改变原来数组。

8. filter和map的区别

let arr=[2,4,1,5,3,1];

let res1=arr.map(function (item,index,array) {
  // return array[index]; //用这种方法也可以获取到当前处理的元素
  return item>1;
});

let res2=arr.filter(function (item,index,array) {
  return item>1;
});
console.log(res1,res2);//[ true, true, false, true, true, false ] [ 2, 4, 5, 3 ]

map的结果只是对当前元素调用函数后（x是否大于1）的结果。而filter 会将结果为true的数组存到新的数组里面。

三、补充

1.for... in

for (index in 数组/对象)

for...in 语句用于对数组或者对象的属性进行循环操作。

for ... in 循环中的代码每执行一次，就会对数组的元素或者对象的属性进行一次操作。

var x
var mycars = new Array()
mycars[0] = "Saab"
mycars[1] = "Volvo"
mycars[2] = "BMW"

for (x in mycars)
{
document.write(mycars[x] + "
")
}

2.for ... of

for( const value of 被遍历的数据)

①for...of 语句用于循环遍历。
②在 ES6 中引入的 for...of 循环，以替代 for...in 和 forEach() ，并支持新的迭代协议。
③for...of 允许遍历 Arrays（数组）, Strings（字符串）, Maps（映射）, Sets（集合）等可迭代的数据结构等。
④不能遍历对象Object。

function args() {
  for (const arg of arguments) {
    console.log(arg);
  }
}
 
args('a', 'b', 'c');
// Output:
// a
// b
// c

const arr = ['mini', 'mani', 'mo'];
for (const value of arr) {
  console.log(value);
}
 
// Output:
// mini
// mani
// mo

小结

（1）构造函数有原型对象prototype
（2）原型对象prototype有constructor属性，指向构造函数
（3）构造函数可以通过原型对象prototype添加方法。
（4）构造函数的实例对象有_proto_属性，指向构造函数的原型对象prototype