let message = "Hello!";
let phrase = message;

let user = {
  name: "John"
};
let admin = user; // 复制引用

admin.name = 'Pete'; //  被通过名为 "admin" 的引用修改了
alert(user.name); // 'Pete'，通过名为 "user" 的引用查看修改

let user = { name: "John" };
let permissions1 = { canView: true };
let permissions2 = { canEdit: true };
// 把 permissions1 和 permissions2 的所有属性都拷贝给 user
Object.assign(user, permissions1, permissions2);
// 现在 user = { name: "John", canView: true, canEdit: true }

let user = {
  name: "John",
  sizes: {   // 该属性是对另一个对象的引用
    height: 182,
    width: 50
  }
};
let clone = Object.assign({}, user);
alert( user.sizes === clone.sizes ); // true，同一个对象
// user 和 clone 共享 sizes 对象
user.sizes.width++;       // 在这里改变一个属性的值
alert(clone.sizes.width); // 51，在这里查看属性的值

let a = {};
let b = a; // 复制引用
alert( a == b ); // true，两个变量指向同一个对象
alert( a === b ); // true
let a = {};
let b = {}; // 两个独立的对象
alert( a == b ); // false

let fruit = prompt("Which fruit to buy?", "apple");
let bag = {
  [fruit + 'Computers']: 5, // 属性名是从 fruit 变量中得到的
};
alert( bag[fruit] ); // 5，相当于 bag.appleComputers = 5

// 两种等价的方法来使用 key 键 来返回它的 value 值
user["name"]; // 括号记法，需要使用引号包括属性名
user.age; // 点记法

let key = "likes pigs";
// 跟 user["likes birds"] = true; 一样
user[key] = true;

// 更改属性值
user.name = "Ben";
// 添加属性
user.gender = "male";

delete user.age;

// projects 是一个对象，将其属性 display 绑定到一个函数中
projects.display = function() {
    // code_block
}
// 调用方法
projects.display();

let user = { name: "John", age: 30 };
alert( "age" in user ); // true，user.age 存在
alert( "blabla" in user ); // false，user.blabla 不存在。

let descriptor = Object.getOwnPropertyDescriptor(obj, propertyName);

let user = {
  name: "John"
};
let descriptor = Object.getOwnPropertyDescriptor(user, 'name');
alert( JSON.stringify(descriptor, null, 2 ) );
/* 返回属性描述符对象
{
  "value": "John",
  "writable": true,
  "enumerable": true,
  "configurable": true
}
*/

Object.defineProperty(obj, propertyName, descriptor)

let user = {};
// 设置属性标志，没有提供标志设置默认为 false
Object.defineProperty(user, "name", {
  value: "John"
});
let descriptor = Object.getOwnPropertyDescriptor(user, 'name');
alert( JSON.stringify(descriptor, null, 2 ) );
/*
{
  "value": "John",
  "writable": false,
  "enumerable": false,
  "configurable": false
}
 */

for (let key in user) {
  clone[key] = user[key]
}

let user = {
  name: "John",
  surname: "Smith",
  get fullName() {
    return `${this.name} ${this.surname}`;
  },
  set fullName(value) {
    [this.name, this.surname] = value.split(" ");
  }
};
// 设置访问器属性的值时 setter 起作用
user.fullName = "Alice Cooper";
// 使用常规的方式 user.fullName 读取访问器属性的值，getter 在幕后起作用
alert(user.fullName);   // John Smith

function User(name, birthday) {
  this.name = name;
  this.birthday = birthday;
  // 年龄是根据当前日期和生日计算得出的
  Object.defineProperty(this, "age", {
    get() {
      let todayYear = new Date().getFullYear();
      return todayYear - this.birthday.getFullYear();
    }
  });
}
let john = new User("John", new Date(1992, 6, 1));
alert( john.birthday );   // birthday 是可访问的
alert( john.age );   // age 也是可访问的

obj.methodName(argument);

let user = {
  name: "John",
  hi() { alert(this.name); }
}
// 将赋值与方法调用拆分为两行
let hi = user.hi;
hi();   // TypeError: Cannot read property 'name' of undefined（错误，因为 this 未定义）

// obj == number 使用 default hint
if (user == 1) { ... };

let user = {
  name: "John",
  money: 1000,
  [Symbol.toPrimitive](hint) {
    alert(`hint: ${hint}`);
    return hint == "string" ? `{name: "${this.name}"}` : this.money;
  }
};
// 转换演示：
alert(user);   // {name: "John"}（此时 hint 为 string）
alert(+user);   // 1000（此时 hint 为 number）
alert(user + 500);   // 1500（此时 hint 为 default，但依据 number 情况进行转换）

let user = {name: "John"};
alert(user);   // [object Object]
alert(user.valueOf() === user);   // true

let user = {
  name: "John",
  money: 1000,
  // 对于 hint="string"
  toString() {
    return `{name: "${this.name}"}`;
  },
  // 对于 hint="number" 或 "default"
  valueOf() {
    return this.money;
  }
};
alert(user);   // {name: "John"}
alert(+user);   // 1000
alert(user + 500);   // 1500

let obj = {
  // toString 在没有其他方法的情况下处理所有转换
  toString() {
    return "2";
  }
};
alert(obj * 2); // 4，对象被转换为原始值字符串 "2"，之后它被乘法转换为数字 2。

// 该构造器不能被再次调用，只是用于表示函数封装了创建一个特定对象的代码
let user = new function() {
  this.name = "John";
  this.isAdmin = false;
  // code_block
  // 用于创建该对象的其他代码
};

function User(name) {
  if (!new.target) { // 如果你没有通过 new 运行我
    return new User(name); // ……我会给你添加 new
  }
  this.name = name;
}
let john = User("John"); // 将调用重定向到新用户
alert(john.name); // John

function BigUser() {
  this.name = "John";
  return { name: "Godzilla" };  // 返回这个对象，覆盖 this
}
alert( new BigUser().name );  // Godzilla

let animal = {
  eats: true
};
// 构造函数
function Rabbit(name) {
  this.name = name;
}
Rabbit.prototype = animal;   // 为函数设置 prototype 属性，其字面意思是：当创建了一个 new Rabbit 时，把它的 [[Prototype]] 赋值为 animal
let rabbit = new Rabbit("White Rabbit");   // rabbit.__proto__ == animal
alert( rabbit.eats );   // true

// 构造函数
function Rabbit() {}
Rabbit.prototype = {
  eats: true
};
let rabbit = new Rabbit();   // 使用构造函数创建对象
Rabbit.prototype = {};   // 更改引用
alert( rabbit.eats );   // true，并不影响之前创建的对象
Rabbit.prototype.eats = false;   // 直接修改原型对象的内容
alert( rabbit.eats );   // false

function Rabbit() {}
/* default prototype
Rabbit.prototype = { constructor: Rabbit };
*/

function Rabbit(name) {
  this.name = name;
  alert(name);
}
let rabbit = new Rabbit("White Rabbit");
let rabbit2 = new rabbit.constructor("Black Rabbit");

function Rabbit() {}
// 不要将 Rabbit.prototype 整个覆盖
// 可以向其中添加内容
Rabbit.prototype.jumps = true;
// 默认的 Rabbit.prototype.constructor 被保留了下来
// 重新设置构造函数的 prototype 属性，覆盖了原有的 constructor，手动添加它指回构造函数
Rabbit.prototype = {
  jumps: true,
  constructor: Rabbit
};

// 原型链的顶端为 null。
alert(Object.prototype.__proto__); // null

let arr = [1, 2, 3]
alert(arr); // 1,2,3 <-- Array.prototype.toString 的结果

// 向 String.prototype 中添加一个方法，对所有的字符串都是可用的
String.prototype.show = function() {
  alert(this);
};
"BOOM!".show(); // BOOM!

let obj = {
  0: "Hello",
  1: "world!",
  length: 2,
};
obj.join = Array.prototype.join;
alert( obj.join(',') ); // Hello,world!

let animal = {
  eats: true
};
// 创建一个以 animal 为原型的新对象，且添加属性描述器为新对象提供额外的属性
let rabbit = Object.create(animal, {
  jumps: {
    value: true
  }
});
alert(rabbit.eats);   // true
alert(rabbit.jumps);   // true
alert(Object.getPrototypeOf(rabbit) === animal);   // true
Object.setPrototypeOf(rabbit, {});   // 将 rabbit 的原型修改为 {}