第一章

1.1class类及继承

class father {
    constructor(name){
  //构造函数  
    this.name=name;
  }  
    say(){
    console.log("你的名字！"+this.name);
  }
}

class son extends father{
    constructor(name,firstname){
     //super要在this的上面
     super(name);   
     this.firstname=firstname;
  }
    
}

1.2构造函数及原型

创建对象的三种方式，且也有静态成员和实例成员

• 对象字面量：let object = {};
• new object : let father = new object;
• 自定义构造函数

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["Shelby", "Court"];
}

1.3 构造函数和原型

通过原型(prototype)分配的函数时所有对象共享的,原型的作用及共享。prototype原型更像时类中某个一直存在的指针，里面存这共用的方法和属性
原型链：对象找不到方法就去构造函数找，构造函数找不到就去object ,objecth找不到就为null
prototype与proto的关系：构造函数（class）是prototype，而对象中是_proto_属性，_proto_指向prototype,同时也可以使用father.prototype.constructor指回构造函数
给原型对象赋值需注意：原型对象赋对象值会覆盖掉原型对象
this指向问题：构造函数中的this 指向我们实例对象.原型对象里面放的是方法, 这个方法里面的this 指向的是 这个方法的调用者, 也就是这个实例对象.
call用法： 调用这个函数, 并且修改函数运行时的 this 指向 ，fun.call(thisArg, arg1, arg2, ...）

• thisArg this 要指向的对象，不加对象只是调用函数
• arg1 arg2是参数

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["Shelby", "Court"];
}

Person.prototype = {
    constructor : Person,
    sayName : function() {
        alert(this.name);
    }
}
————————————————
版权声明：本文为CSDN博主「尘埃丶落定」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/longyin0528/article/details/80504282

1.4 forEach()、map()、filter()、some()、every()方法

//循环
array.forEach(function(currentValue, index, arr))
//找出指定条件的
array.map(function(currentValue, index, arr))
//过滤值
array.filter(function(currentValue, index, arr))
//是否有符合要求的元素
array.some(function(currentValue, index, arr))
//如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
array.every(function(currentValue, index, arr)，thisvalue)
//用于获取对象自身所有的属性
Object.keys()
//定义对象中新属性或修改原有的属性。
Object.defineProperty(obj, prop, descriptor)

• value: 设置属性的值 默认为undefined
• writable: 当writable属性设置为false时，该属性被称为“不可写”。它不能被重新分配。

var o = {}; // Creates a new object

Object.defineProperty(o, 'a', {
  value: 37,
  writable: false
});

console.log(o.a); // logs 37
o.a = 25; // No error thrown
// (it would throw in strict mode,
// even if the value had been the same)
console.log(o.a); // logs 37. The assignment didn't work.

// strict mode
(function() {
  'use strict';
  var o = {};
  Object.defineProperty(o, 'b', {
    value: 2,
    writable: false
  });
  o.b = 3; // throws TypeError: "b" is read-only
  return o.b; // returns 2 without the line above
}());

• enumerable: enumerable定义了对象的属性是否可以在 for...in 循环和 Object.keys() 中被枚举

var o = {};
Object.defineProperty(o, "a", { value : 1, enumerable:true });
Object.defineProperty(o, "b", { value : 2, enumerable:false });
Object.defineProperty(o, "c", { value : 3 }); // enumerable defaults to false
o.d = 4; // 如果使用直接赋值的方式创建对象的属性，则这个属性的enumerable为true

for (var i in o) {    
  console.log(i);  
}
// 打印 'a' 和 'd' (in undefined order)

Object.keys(o); // ["a", "d"]

o.propertyIsEnumerable('a'); // true
o.propertyIsEnumerable('b'); // false
o.propertyIsEnumerable('c'); // false

• configurable: configurable特性表示对象的属性是否可以被删除，以及除value和writable特性外的其他特性是否可以被修改。

var o = {};
Object.defineProperty(o, "a", { get : function(){return 1;}, 
                                configurable : false } );

// throws a TypeError
Object.defineProperty(o, "a", {configurable : true}); 
// throws a TypeError
Object.defineProperty(o, "a", {enumerable : true}); 
// throws a TypeError (set was undefined previously) 
Object.defineProperty(o, "a", {set : function(){}}); 
// throws a TypeError (even though the new get does exactly the same thing) 
Object.defineProperty(o, "a", {get : function(){return 1;}});
// throws a TypeError
Object.defineProperty(o, "a", {value : 12});

console.log(o.a); // logs 1
delete o.a; // Nothing happens
console.log(o.a); // logs 1