类和对象

JavaScript 的所有数据都可以看成对象，在 JavaScript 中，不区分类和实例的概念，而是通过原型（prototype）来实现面向对象编程。JavaScript没有“Class”的概念，所有对象都是实例，所谓继承关系不过是把一个对象的原型指向另一个对象而已。

创建一个 JavaScript 对象可以通过以下三种方式:

// 1.对象字面量
var obj1 = {
    name: "why",
    run: function(){
        console.log("run");
    }
}
// 2.Object构造函数
var obj2 = new Object()
obj2.name = "kobe"
// 3.new 其他类
function Person(){}
var obj3 = new Person()

对象属性的增删改查

当使用类中没有的属性时，就会给类添加对应的属性

class Person{}
// 创建对象
let p = new Person()
// 如果对象原来有这个属性属于修改，如果没有这个属性等于添加
p.name = "a"
// 删除属性
delete p.name

有些对象属性可能含有空格，这个时候使.语法是访问不了的，可以使用[]进行访问，比如

var message = "Hello"
var obj = {
    "goof friend": "why",
    [message]: "你好"
}
console.log(obj["goof friend"],obj[message]);

对象的遍历

对象的遍历（迭代）表示获取对象中所有的属性和方法。Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组；

// 第一种方式
var infoKeys = Object.keys(obj)
for (let index = 0; index < infoKeys.length; index++) {
    var key = infoKeys[index];
    var value = obj[key]
    console.log(`key: ${key}, value: ${value}`);
}
// 第二种方式
for (const key in obj) {
    var value = obj[key]
    console.log(`key: ${key}, value: ${value}`);
}

构造函数

为了区分普通函数和构造函数，按照约定，构造函数首字母应当大写。构造函数只能通过new来调用，当调用实例对象调用不存在的属性时，会在这个类中创建这个属性

// 通过这样的构造函数生成的对象，方法都会在不同的内存空间
function Person(name,age){
    this.name = name
    this.age = age
    this.say = function(){
        console.log(name + age + "开始说话")
    }
}
// 通过构造函数创建对象必须使用new进行调用
var p1 = new Person("jack",18)

如果一个函数被使用new操作符调用了，那么它会执行如下操作：

1. 在内存中创建一个新的对象（空对象）；
2. 这个对象内部的[prototype]属性会被赋值为该构造函数的prototype属性;
3. 构造函数内部的this，会指向创建出来的新对象；
4. 执行函数的内部代码（函数体代码）；
5. 如果构造函数没有返回非空对象，则返回创建出来的新对象；

Person.prototype = {
    constructor:Person, //指向自己的构造函数
    com:"属性",
    say:function(){
        console.log(this.age,this.name);
    }
}

如果直接在构造函数上添加函数，称为类方法

// 类方法
function Dog(){}
Dog.running = function(){}
Dog.running()

继承

call()、apply()、bind() 都是用来重定义 this 这个对象的！三个函数在传参时有所不同

var obj={
   name:"xiaozhang",
   objAge:this.age,
   myFun:function(fm,t){
       console.log(this.name + this.age + fm + t);
   }
}

var db = {
   name:"哎呀",
   age:99
}

obj.myFun.call(db,"成都","上海")
obj.myFun.apply(db,["成都","上海"])
obj.myFun.bind(db,"成都","上海")()

call()方法的参数是直接放进去的
apply()方法参数传一个数组
bind()方法传参跟call()一样，但是需要使用()进行调用

继承其实是更改this的指向

function Person(age){
   this.age=age
} 

function Student(age,score){
   Person.call(this,age)
   this.score = score
}

Student.prototype = new Person()
Student.prototype.constructor = Student

获取原型类型

let ary = new Array()
console.log(ary.constructor.name);
//instanceof  判断 当前实例对象是不是 Array这个类或者他的父类创建的
console.log(ary instanceof Array );
// isPrototypeOf 判断当前原型对象的原型是不是ary的原型 
let ary = new Array()
console.log(Array.prototype.isPrototypeOf(ary));
// 判断类和原型中是否有length这个属性 ，
console.log("length" in ary);
// 判断当前对象是否有length这个属性
console.log(ary.hasOwnProperty("length"));

结构实例对象

使用结构数组的方式结构实例对象

class Person{
    constructor(name,age){
        this.name = name
        this.age = age
    }
}

let p = new Person("a",18)
// 结构的变量名需要跟属性名称一样，否则会取不到值
let {name,age} = p;
console.log(name,age);

拷贝对象的值

class Person{
    constructor(name,age){
        this.name = name
        this.age = age
    }
}

let p1 = new Person("a",18)
let p2 = new Person()

// 将p1的值拷贝到p2中
Object.assign(p2,p1)


// 如果类中有多个属性是对象，需要拷贝属性的值
class Person{
    cat={
        age:3
    }
    source=[1,2,3]
}

let p1 = new Person("a",18)
let p2 = new Person()

depCopy(p2,p1)

function depCopy(target,source){
    for (let key in source) {
        let value = source[key]
        // 如果属性是对象需要深层拷贝时，需要创建新的对象，再进行赋值
        if (value instanceof Object) {
            let subTarget = new value.constructor;
            target[key] = subTarget
            depCopy(subTarget,value)
        }else{
            target[key] = value
        }
    }
}

ES6中的类和对象

定义类和构造方法

class Person{
    // 当使用new方法创建对象时，系统会调用此方法
    constructor(age,name){
        this.age = age,
        this.name = name
        this.pen = function(){

        }
    }

    // 方法会被添加到原型上去
    say(){
        console.log(this.name + this.age);
    }

    // 定义静态方法
    static run(){
        console.log("静态方法");
    }
}

// 添加静态属性
 Person.num = 3

let p = new Person(1,"zs")
p.say()

Person.run()

继承

class Person{
    constructor(name){
        this.name = name
    }
} 

class Student extends Person{
    constructor(name,age){
        super(name)
        this.age = age
    }
}