对象的传统表示法
let person = {
"name":"张三",
"say":function(){
alert("你好吗？");
}
}
ES6中的简洁写法
var name = "Zhangsan";
var age = 12;//传统的属性写法
var person = {
"name":name,
"age":age
};console.log(person);
//结果：{name: "Zhangsan", age: 12}//ES6的属性写法
var person = {name,age};
console.log(person);
//结果：{name: "Zhangsan", age: 12}
对象的属性可以这样简写，那么对象的方法表示：
//传统的表示法
var person = {
say:function(){
alert('这是传统的表示法');
}
};//ES6的表示法
var person = {
say(){
alert('这是ES6的表示法');
}
};
属性名可以是表达式
用字面量定义一个对象的时候，可以用变量或者表达式作为对象的属性名或者方法名。
var f = "first";
var n = "Name";
var s = "say";
var h = "Hello";
var person = {
[f+n ] : "Zhang",
[s+h ](){
return "你好吗？";
}
};console.log(person.firstName);
//结果：Zhangconsole.log(person.sayHello());
//结果：你好吗？
es6中的属性名可以有空格：
let foods = {};
foods.dessert = '蛋糕';
foods['hot drink'] = '可乐' //console.log(foods)
创建新对象Object.create()
Object.create() 方法会使用指定的原型对象及其属性去创建一个新的对象。
let breakfast = {
getDrink() {
return'咖啡';
}
};
let dinner = {
getDrink() {
return'牛奶';
}
};
let sunday = Object.create(breakfast);
console.log(sunday.getDrink())
Object.is( )函数
方括号中还可以用变量的形式引入：ES5 比较两个值是否相等，只有两个运算符：相等运算符（==）和严格相等运算符（===）。它们都有缺点，前者会自动转换数据类型，后者的NaN不等于自身，以及+0等于-0。 JavaScript 缺乏一种运算，在所有环境中，只要两个值是一样的，它们就应该相等。
ES6 提出 “Same-value equality” （同值相等）算法，用来解决这个问题。Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等，与严格比较运算符（ === ）的行为基本一致，Object.is()括号中放的是对比的两个值。
+0 === -0//true
NaN === NaN// false
Object.is(+0, -0)// false
Object.is(NaN, NaN)// true
Object.assign()函数
把一个对象的值复制到另一个对象里，Object.assign()方法用于将所有可枚举的属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。
Object.assign(target, ...sources)
参数
target
目标对象。
sources
(多个)源对象。
返回值
目标对象。
如果目标对象中的属性具有相同的键，则属性将被源中的属性覆盖。后来的源的属性将类似地覆盖早先的属性。
let breakfast = {drink: '咖啡'},
foods = {drink: '蛋糕'};Object.assign(
breakfast,
foods
)console.log(breakfast) //{drink: "蛋糕"}
Object.assign( )函数的参数还可以是多个（至少是两个）。
//这个充当目标对象
let target = {"a":1};//这个充当源对象
let origin1 = {"b":2,"c":3};//这个充当源对象
let origin2 = {"d":4,"e":5};Object.assign(target,origin1,origin2);
//打印target对象出来看一下
console.log(target);//结果 {a: 1, b: 2, c: 3, d: 4, e: 5}
Object.getPrototypeOf( )函数
函数作用：获取一个对象的prototype属性。这里的对象我们用一个自定义类实例出来的对象来演示。（这里涉及到了javascript的面向对象，后面拓展）
//自定义一个Person类（函数）
function Person(){}
//函数都有一个预属性prototype对象
Person.prototype = {
//给prototype对象添加一个say方法
say(){
console.log('hello');
}
};//实例化Person对象，赋值给变量allen
let allen = new Person();
//调用类的say方法
allen.say();
//结果：打印出hello//获取allen对象的prototype属性
Object.getPrototypeOf(allen);
//结果：打印{say:function(){.....}}
Object.setPrototypeOf()函数 （现在这个方法只是草案 推荐用__proto__）
设置一个对象的prototype属性。
Object.setPrototypeOf() 方法设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或null。
let breakfast = {
getDrink() {
return '咖啡';
}
};
let dinner = {
getDrink() {
return '牛奶';
}
};
let sunday = Object.create(breakfast);
console.log(sunday.getDrink());
console.log(Object.getPrototypeOf(sunday) === breakfast); // 判断原型是否相同
Object.setPrototypeOf(sunday, dinner);
console.log(sunday.getDrink())
__proto__
let breakfast = {
getDrink() {
return'咖啡';
}
};
let dinner = {
getDrink() {
return'牛奶';
}
};
let sunday = {
__proto__: breakfast
}
console.log(sunday.getDrink());
console.log(Object.getPrototypeOf(sunday) === breakfast);
sunday.__proto__ = dinner;
console.log(sunday.getDrink());
console.log(Object.getPrototypeOf(sunday) === dinner);
super （得到方法返回的内容）
super 关键字用于调用一个对象的父对象上的函数。
let breakfast = {
getDrink() {
return'咖啡';
}
};
let dinner = {
getDrink() {
return'牛奶';
}
};
let sunday = {
__proto__: breakfast,
getDrink() {
return'返回了 ' + super.getDrink();
}
}
console.log(sunday.getDrink())
迭代器 Iterators （轮流交换）
Iterator 函数返回一个对象，它实现了遗留的迭代协议，并且迭代了一个对象的可枚举属性。
function chef(foods) {
let i = 0;
return {
next() {
let done = (i >=foods.length);
let value = !done ? foods[i++] : undefined;
return {
value: value,
done: done
}
}
}
}
let yang =chef(['西红柿', '鸡蛋']);
console.log(yang.next());
console.log(yang.next());
console.log(yang.next());
迭代生成器 Generators
function* chef(){
yield '西红柿'; yield '鸡蛋';
}
let yang = chef();
console.log(yang.next());
还可以以数组的形式传入
function* chef(foods){ for (let i = 0; i<foods.length; i++){
yield foods[i];
}
}let yang = chef(['西红柿', '鸡蛋']);
console.log(yang.next());
Classes 类
ECMAScript 2015 中引入的 JavaScript类主要是 JavaScript 现有的基于原型的继承的语法糖。 类语法不是向JavaScript引入一个新的面向对象的继承模型。JavaScript类提供了一个更简单和更清晰的语法来创建对象并处理继承。
类实际上是个“特殊的函数”，就像你能够定义的函数表达式和函数声明一样，类语法有两个组成部分：类表达式和类声明。
定义一个类的一种方法是使用一个类声明。要声明一个类，你可以使用带有class关键字的类名（这里是“Rectangle”）。
class Rectangle {
constructor(height, width) {
this.height = height;
this.width = width;
}
}
提升
函数声明和类声明之间的一个重要区别是函数声明会声明提升，类声明不会。你首先需要声明你的类，然后访问它，否则像下面的代码会抛出一个ReferenceError：
let p =new Rectangle();
// ReferenceError
class Rectangle {}
声明实例使用类
class Chef {
constructor(food) {
this.food = food;
}
cook() {
console.log(this.food)
}
}
let yang =newChef('番茄');
yang.cook();
类中的 get （得到东西的方法）与 set（设置东西的方法）
class Chef {
constructor(food) {
this.food = food;
this.dish = [];
}
get menu() {
return this.dish;
}
set menu(dish) {
this.dish.push(dish);
}
cook() {
console.log(this.food)
}
}
let yang = new Chef();
console.log(yang.menu = '番茄');
console.log(yang.menu = '鸡蛋');
console.log(yang.menu)
javascript的面向对象
Javascript本身不是一种面向对象的编程语言，在ES5中，它的语法中也没有class（类的关键字），但是，开发者可以利用对象的原型prototype属性来模拟面向对象进行编程开发。
//构造函数模拟创建一个Dog类
function Dog(name){
this.name = name;
}
//把一些属性和方法，定义在prototype对象上
Dog.prototype = {
"type":"动物",
"say":function(){
alert(
"名字叫"+this.name);
}
};
//实例化
var dog = new Dog('旺财');
//调用say方法
dog.say();
//结果：名字叫旺财
上面的案例告诉我们，模拟面向对象编程有几个关键步骤：1、构造函数；2、给prototype对象添加属性和方法；3、实例化；4、通过实例化后的对象调用类的方法或者属性。
