声明对象方式

对象字面量

var obj1={
    name:'xx',
    age:88,
}

new Object()

var obj2 = new Object()
obj2.name='xx'

new 自定义类

function Person(){}
var obj3 = new Person()

对象操作

var message = 'ms'
var info = {
    name:'hyf',
    age:22,
    run:function(){},
    "some friend":'myl',
    [message]:'some info'
}

// 访问属性
var name = info.name
info.run()
console.log(info['some friend'])
var f = 'some friend'
console.log(info[f])

// 修改属性
info.name = 'hyf01'
info.run = function(){}

// 添加新属性
info.newHeight = 178

// 删除属性
delete info.name


// 对象遍历 Object.keys()/for in/for of 默认（遍历可迭代对象）不能遍历对象
console.log(Object.keys(info))
for(var key in info){
    console.log(key)
}

栈内存和堆内存

• 原始类型占据的空间是在栈内存中分配的
• 对象类型占据的空间是在堆内存中分配的

// 值传递
function foo(a){
    a = 200
}
var num = 100
foo(num)
console.log(num) // 100

// 引用传递1：在函数中创建新的对象，但没有对传入对象进行修改
function foo1(a){
    a = {}
}
var obj = {name:'hyf'}
foo1(obj)
console.log(obj) // {name:'hyf'}

// 引用传递2：在函数中对对象进行修改

工厂函数

// 封装一个函数，用于创建一个对象

// 工厂函数，生产出student对象，设计模式
function createStudent(name,age,height){
    var stu = {}
    stu.name=name
    stu.age=age
    stu.height=height
    stu.runing=function(){
        console.log('runing')
    }
    return stu;
}

var stu1 = createStudent('hyf',18,178)

/*
在打印对象时，对象的类型都是Object类型
*/

构造函数

构造函数又称为构造器（constructor）,创建对象时会调用的函数，一般存在于类中，称为构造方法。

• 使用大驼峰
• 原型、原型链、继承

function Student(name,age,height){
    this.name=name
    this.age=age
    this.height=height
    this.runing=function(){
        console.log('runing')
    }
}
var stu1 = new Student('hyf',18,178)

new操作符，执行步骤：

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

function _new() {
    let obj= {}; // 创建的新对象
    // 第一个参数是构造函数
    let [constructor, ...args] = [...arguments];

    // 执行 [[原型]] 连接 ;实际上就是生产了一个新的上下文
    obj.__proto__ = constructor.prototype;

    // 使用apply在obj作用域中调用构造器函数，属性和方法被添加到 this 引用的对象即obj中
    let result = constructor.apply(obj, args);
    if (result && (typeof (result) == "object" || typeof (result) == "function")) {
        // 如果构造函数执行的结果返回的是一个对象，那么返回这个对象
        return result;
    }
    // 如果构造函数返回的不是一个对象，返回创建的新对象
    return obj;
}