1.函式擴充套件

引數預設值、rest引數、擴充套件運算子、箭頭函式、this繫結、尾呼叫。

函式引數的預設值

ES6 之前，不能直接為函式的引數指定預設值，只能採用變通的方法。

function log(x, y) {
  y = y || 'World';
  console.log(x, y);
}

log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello World

上面程式碼檢查函式log的引數y有沒有賦值，如果沒有，則指定預設值為World。這種寫法的缺點在於，如果引數y賦值了，但是對應的布林值為false，則該賦值不起作用。就像上面程式碼的最後一行，引數y等於空字元，結果被改為預設值。

為了避免這個問題，通常需要先判斷一下引數y是否被賦值，如果沒有，再等於預設值。

if (typeof y === 'undefined') {
  y = 'World';
}

ES6 允許為函式的引數設定預設值，即直接寫在引數定義的後面。

function log(x, y = 'World') {
  console.log(x, y);
}

log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello

可以看到，ES6 的寫法比 ES5 簡潔許多，而且非常自然。

再來看一些例子：

let x='test';
function test2(x,y=x){
	console.log('作用域',x,y)
}
test2('kill');   //'作用域' kill kill
test2('');       //'作用域' undefined let x='test';

//如果沒有定義x，會不會向上查詢x（會的）
let x='test';
function test2(c,y=x){
	console.log('作用域',x,y)
}
test2('kill');   //'作用域' kill test

rest引數

ES6 引入 rest 引數（形式為…變數名），用於獲取函式的多餘引數，這樣就不需要使用arguments物件了。rest 引數搭配的變數是一個數組，該變數將多餘的引數放入陣列中。

function add(...values) {
  let sum = 0;

  for (var val of values) {
    sum += val;
  }

  return sum;
}

add(2, 5, 3) // 10

上面程式碼的add函式是一個求和函式，利用 rest 引數，可以向該函式傳入任意數目的引數。

下面是一個 rest 引數代替arguments變數的例子。

// arguments變數的寫法
function sortNumbers() {
  return Array.prototype.slice.call(arguments).sort();
}

// rest引數的寫法
const sortNumbers = (...numbers) => numbers.sort();

上面程式碼的兩種寫法，比較後可以發現，rest 引數的寫法更自然也更簡潔。

擴充套件運算子

rest是值變成陣列，擴充套件運算子是相反，陣列變成值，看下面示例：

console.log(...[1,2,4]);   //1 2 4
console.log(a,...[1,2,4]);   //a 1 2 4

箭頭函式

基本用法：

ES6 允許使用“箭頭”（=>）定義函式。

var f = v => v;

// 等同於
var f = function (v) {
  return v;
};

如果箭頭函式不需要引數或需要多個引數，就使用一個圓括號代表引數部分。

var f = () => 5;
// 等同於
var f = function () { return 5 };

var sum = (num1, num2) => num1 + num2;
// 等同於
var sum = function(num1, num2) {
  return num1 + num2;
};

如果箭頭函式的程式碼塊部分多於一條語句，就要使用大括號將它們括起來，並且使用return語句返回。

var sum = (num1, num2) => { return num1 + num2; }

由於大括號被解釋為程式碼塊，所以如果箭頭函式直接返回一個物件，必須在物件外面加上括號，否則會報錯。

// 報錯
let getTempItem = id => { id: id, name: "Temp" };

// 不報錯
let getTempItem = id => ({ id: id, name: "Temp" });

尾呼叫

尾呼叫（Tail Call）是函數語言程式設計的一個重要概念，本身非常簡單，一句話就能說清楚，就是指某個函式的最後一步是呼叫另一個函式。

function f(x){
  return g(x);
}

上面程式碼中，函式f的最後一步是呼叫函式g，這就叫尾呼叫。

以下三種情況，都不屬於尾呼叫。

// 情況一
function f(x){
  let y = g(x);
  return y;
}

// 情況二
function f(x){
  return g(x) + 1;
}

// 情況三
function f(x){
  g(x);
}

2.物件擴充套件

簡潔表示法、屬性表示式、擴充套件運算子、Object新增方法

屬性的簡潔表示法

ES6 允許直接寫入變數和函式，作為物件的屬性和方法。這樣的書寫更加簡潔。

//簡潔表示法
let o = 1;
let k = 2;
let es5 = {
	o:o,
	k:k
};
let es6 = {
	o,
	k	
};

const foo = 'bar';
const baz = {foo};
baz // {foo: "bar"}

// 等同於
const baz = {foo: foo};

上面程式碼表明，ES6 允許在物件之中，直接寫變數。這時，屬性名為變數名, 屬性值為變數的值。下面是另一個例子。

function f(x, y) {
  return {x, y};
}

// 等同於
function f(x, y) {
  return {x: x, y: y};
}

f(1, 2) // Object {x: 1, y: 2}

除了屬性簡寫，方法也可以簡寫。

const o = {
  method() {
    return "Hello!";
  }
};

// 等同於

const o = {
  method: function() {
    return "Hello!";
  }
};

下面是一個實際的例子。

let birth = '2000/01/01';

const Person = {

  name: '張三',

  //等同於birth: birth
  birth,

  // 等同於hello: function ()...
  hello() { console.log('我的名字是', this.name); }

};

這種寫法用於函式的返回值，將會非常方便。

function getPoint() {
  const x = 1;
  const y = 10;
  return {x, y};
}

getPoint()
// {x:1, y:10}

屬性名錶達式

JavaScript 定義物件的屬性，有兩種方法。

//屬性表示式
let a = 'b';
let es5_obj = {
	a:'c'      //es5中key是固定值
};
let es6_obj = {
	[a]:'c';   //相當於b:'c' , es6中此時的key就可以是一個變數或者表示式了
}

// 方法一
obj.foo = true;

// 方法二
obj['a' + 'bc'] = 123;

上面程式碼的方法一是直接用識別符號作為屬性名，方法二是用表示式作為屬性名，這時要將表示式放在方括號之內。

但是，如果使用字面量方式定義物件（使用大括號），在 ES5 中只能使用方法一（識別符號）定義屬性。

var obj = {
  foo: true,
  abc: 123
};

ES6 允許字面量定義物件時，用方法二（表示式）作為物件的屬性名，即把表示式放在方括號內。

let propKey = 'foo';

let obj = {
  [propKey]: true,
  ['a' + 'bc']: 123
};

下面是另一個例子。

let lastWord = 'last word';

const a = {
  'first word': 'hello',
  [lastWord]: 'world'
};

a['first word'] // "hello"
a[lastWord] // "world"
a['last word'] // "world"

表示式還可以用於定義方法名。

let obj = {
  ['h' + 'ello']() {
    return 'hi';
  }
};

obj.hello() // hi

方法的name屬性

函式的name屬性，返回函式名。物件方法也是函式，因此也有name屬性。

const person = {
  sayName() {
    console.log('hello!');
  },
};

person.sayName.name   // "sayName"

上面程式碼中，方法的name屬性返回函式名（即方法名）。

如果物件的方法使用了取值函式（getter）和存值函式（setter），則name屬性不是在該方法上面，而是該方法的屬性的描述物件的get和set屬性上面，返回值是方法名前加上get和set。

const obj = {
  get foo() {},
  set foo(x) {}
};

obj.foo.name
// TypeError: Cannot read property 'name' of undefined

const descriptor = Object.getOwnPropertyDescriptor(obj, 'foo');

descriptor.get.name // "get foo"
descriptor.set.name // "set foo"

有兩種特殊情況：bind方法創造的函式，name屬性返回bound加上原函式的名字；Function建構函式創造的函式，name屬性返回anonymous。

(new Function()).name // "anonymous"

var doSomething = function() {
  // ...
};
doSomething.bind().name // "bound doSomething"

如果物件的方法是一個 Symbol 值，那麼name屬性返回的是這個 Symbol 值的描述。

const key1 = Symbol('description');
const key2 = Symbol();
let obj = {
  [key1]() {},
  [key2]() {},
};
obj[key1].name // "[description]"
obj[key2].name // ""

上面程式碼中，key1對應的 Symbol 值有描述，key2沒有。

屬性的可列舉性和遍歷

可列舉性

物件的每個屬性都有一個描述物件（Descriptor），用來控制該屬性的行為。Object.getOwnPropertyDescriptor方法可以獲取該屬性的描述物件。

let obj = { foo: 123 };
Object.getOwnPropertyDescriptor(obj, 'foo')
//  {
//    value: 123,
//    writable: true,
//    enumerable: true,
//    configurable: true
//  }

描述物件的enumerable屬性，稱為”可列舉性“，如果該屬性為false，就表示某些操作會忽略當前屬性。

目前，有四個操作會忽略enumerable為false的屬性。

• for…in迴圈：只遍歷物件自身的和繼承的可列舉的屬性。
• Object.keys()：返回物件自身的所有可列舉的屬性的鍵名。
• JSON.stringify()：只序列化物件自身的可列舉的屬性。
• Object.assign()： 忽略enumerable為false的屬性，只拷貝物件自身的可列舉的屬性。

這四個操作之中，前三個是 ES5 就有的，最後一個Object.assign()是 ES6 新增的。其中，只有for...in會返回繼承的屬性，其他三個方法都會忽略繼承的屬性，只處理物件自身的屬性。實際上，引入“可列舉”（enumerable）這個概念的最初目的，就是讓某些屬性可以規避掉for...in操作，不然所有內部屬性和方法都會被遍歷到。比如，物件原型的toString方法，以及陣列的length屬性，就通過“可列舉性”，從而避免被for...in遍歷到。

Object.getOwnPropertyDescriptor(Object.prototype, 'toString').enumerable
// false

Object.getOwnPropertyDescriptor([], 'length').enumerable
// false

屬性的遍歷

ES6 一共有 5 種方法可以遍歷物件的屬性。

（1）for…in

for...in迴圈遍歷物件自身的和繼承的可列舉屬性（不含 Symbol 屬性）。

（2）Object.keys(obj)

Object.keys返回一個數組，包括物件自身的（不含繼承的）所有可列舉屬性（不含 Symbol 屬性）的鍵名。

（3）Object.getOwnPropertyNames(obj)

Object.getOwnPropertyNames返回一個數組，包含物件自身的所有屬性（不含 Symbol 屬性，但是包括不可列舉屬性）的鍵名。

（4）Object.getOwnPropertySymbols(obj)

Object.getOwnPropertySymbols返回一個數組，包含物件自身的所有 Symbol 屬性的鍵名。

（5）Reflect.ownKeys(obj)

Reflect.ownKeys返回一個數組，包含物件自身的所有鍵名，不管鍵名是 Symbol 或字串，也不管是否可列舉。

以上的 5 種方法遍歷物件的鍵名，都遵守同樣的屬性遍歷的次序規則。

• 首先遍歷所有數值鍵，按照數值升序排列。
• 其次遍歷所有字串鍵，按照加入時間升序排列。
• 最後遍歷所有 Symbol 鍵，按照加入時間升序排列。

Reflect.ownKeys({ [Symbol()]:0, b:0, 10:0, 2:0, a:0 })
// ['2', '10', 'b', 'a', Symbol()]

上面程式碼中，Reflect.ownKeys方法返回一個數組，包含了引數物件的所有屬性。這個陣列的屬性次序是這樣的，首先是數值屬性2和10，其次是字串屬性b和a，最後是 Symbol屬性。

Object.is()

ES5 比較兩個值是否相等，只有兩個運算子：相等運算子（==）和嚴格相等運算子（===）。它們都有缺點，前者會自動轉換資料型別，後者的NaN不等於自身，以及+0等於-0。JavaScript 缺乏一種運算，在所有環境中，只要兩個值是一樣的，它們就應該相等。

ES6 提出“Same-value equality”（同值相等）演算法，用來解決這個問題。Object.is就是部署這個演算法的新方法。它用來比較兩個值是否嚴格相等，與嚴格比較運算子（===）的行為基本一致。

Object.is('foo', 'foo')
// true
Object.is({}, {})
// false

不同之處只有兩個：一是+0不等於-0，二是NaN等於自身。

+0 === -0 //true
NaN === NaN // false

Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

Object.assign()

Object.assign方法用於物件的合併，將源物件（source）的所有可列舉屬性，複製到目標物件（target）。

const target = { a: 1 };

const source1 = { b: 2 };
const source2 = { c: 3 };

Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}
Object.assign方法的第一個引數是目標物件，後面的引數都是源物件。

注意，如果目標物件與源物件有同名屬性，或多個源物件有同名屬性，則後面的屬性會覆蓋前面的屬性。

const target = { a: 1, b: 1 };

const source1 = { b: 2, c: 2 };
const source2 = { c: 3 };

Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}

Object.keys()，Object.values()，Object.entries()

Object.keys()

ES5 引入了Object.keys方法，返回一個數組，成員是引數物件自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名。

var obj = { foo: 'bar', baz: 42 };
Object.keys(obj)
// ["foo", "baz"]

ES2017 引入了跟Object.keys配套的Object.values和Object.entries，作為遍歷一個物件的補充手段，供for…of迴圈使用。

let {keys, values, entries} = Object;
let obj = { a: 1, b: 2, c: 3 };

for (let key of keys(obj)) {
  console.log(key); // 'a', 'b', 'c'
}

for (let value of values(obj)) {
  console.log(value); // 1, 2, 3
}

for (let [key, value] of entries(obj)) {
  console.log([key, value]); // ['a', 1], ['b', 2], ['c', 3]
}

Object.values()

Object.values方法返回一個數組，成員是引數物件自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值。

const obj = { foo: 'bar', baz: 42 };
Object.values(obj)
// ["bar", 42]

返回陣列的成員順序，與本章的《屬性的遍歷》部分介紹的排列規則一致。

const obj = { 100: 'a', 2: 'b', 7: 'c' };
Object.values(obj)
// ["b", "c", "a"]

上面程式碼中，屬性名為數值的屬性，是按照數值大小，從小到大遍歷的，因此返回的順序是b、c、a。

Object.entries()

Object.entries()方法返回一個數組，成員是引數物件自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值對陣列。

const obj = { foo: 'bar', baz: 42 };
Object.entries(obj)
// [ ["foo", "bar"], ["baz", 42] ]

除了返回值不一樣，該方法的行為與Object.values基本一致。

如果原物件的屬性名是一個 Symbol 值，該屬性會被忽略。

Object.entries({ [Symbol()]: 123, foo: 'abc' });
// [ [ 'foo', 'abc' ] ]

上面程式碼中，原物件有兩個屬性，Object.entries只輸出屬性名非 Symbol 值的屬性。將來可能會有Reflect.ownEntries()方法，返回物件自身的所有屬性。

Object.entries的基本用途是遍歷物件的屬性。

let obj = { one: 1, two: 2 };
for (let [k, v] of Object.entries(obj)) {
  console.log(
    `${JSON.stringify(k)}: ${JSON.stringify(v)}`
  );
}
// "one": 1
// "two": 2

3.Symbol用法

ES5 的物件屬性名都是字串，這容易造成屬性名的衝突。比如，你使用了一個他人提供的物件，但又想為這個物件新增新的方法（mixin 模式），新方法的名字就有可能與現有方法產生衝突。如果有一種機制，保證每個屬性的名字都是獨一無二的就好了，這樣就從根本上防止屬性名的衝突。這就是 ES6 引入Symbol的原因。

ES6 引入了一種新的原始資料型別Symbol，表示獨一無二的值。它是 JavaScript 語言的第七種資料型別，前六種是：undefined、null、布林值（Boolean）、字串（String）、數值（Number）、物件（Object）。

Symbol 值通過Symbol函式生成。這就是說，物件的屬性名現在可以有兩種型別，一種是原來就有的字串，另一種就是新增的 Symbol 型別。凡是屬性名屬於 Symbol 型別，就都是獨一無二的，可以保證不會與其他屬性名產生衝突。

let a1 = Symbol();
let a2 = Symbol();

let a3 = Symbol.for('a3');
let a4 = Symbol.for('a3');   //key都是a3，key如果是a3時，value也是會相同，如果不是，重新有完全不一樣的值。

let a1 = Symbol.for('abc');
let obj = {
	[a1]:'123',
	'abc':345,
	'c':456
}
console.log('obj',obj);
// 輸出結果
Object:
	abc:345
	c:456
	Symbol(abc):"123"

for(let [key,value] of Object.entries(obj)){
	console.log('let of ',key,value);
}

Object.getOwnPropertySymbols(obj).forEach(function(item){
	console.log(obj[item]);
})

Reflect.owenKeys(obj).forEach(function(item){
	console.('owenkeys',item,obj[item]);
})

4.set-map資料結構

ES6資料結構：Set的用法、Map的用法、WeakSet的用法、WeakMap的用法。

set

ES6 提供了新的資料結構 Set。它類似於陣列，但是成員的值都是唯一的，沒有重複的值。

Set 本身是一個建構函式，用來生成 Set 資料結構。

const s = new Set();

[2, 3, 5, 4, 5, 2, 2].forEach(x => s.add(x));

for (let i of s) {
  console.log(i);
}
// 2 3 5 4

上面程式碼通過add方法向 Set 結構加入成員，結果表明 Set 結構不會新增重複的值。

Set 函式可以接受一個數組（或者具有 iterable 介面的其他資料結構）作為引數，用來初始化。

// 例一
const set = new Set([1, 2, 3, 4, 4]);
[...set]
// [1, 2, 3, 4]

// 例二
const items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
items.size // 5

// 例三
const set = new Set(document.querySelectorAll('div'));
set.size // 56

// 類似於
const set = new Set();
document
 .querySelectorAll('div')
 .forEach(div => set.add(div));
set.size // 56

上面程式碼中，例一和例二都是Set函式接受陣列作為引數，例三是接受類似陣列的物件作為引數。

Set 內部判斷兩個值是否不同，使用的演算法叫做“Same-value-zero equality”，它類似於精確相等運算子（===），主要的區別是NaN等於自身，而精確相等運算子認為NaN不等於自身。

let set = new Set();
let a = NaN;
let b = NaN;
set.add(a);
set.add(b);
set // Set {NaN}

上面程式碼向 Set 例項添加了兩個NaN，但是隻能加入一個。這表明，在 Set 內部，兩個NaN是相等。

另外，兩個物件總是不相等的。

let set = new Set();

set.add({});
set.size // 1

set.add({});
set.size // 2

上面程式碼表示，由於兩個空物件不相等，所以它們被視為兩個值。

Set 例項的屬性和方法

Set 結構的例項有以下屬性。

• Set.prototype.constructor：建構函式，預設就是Set函式。
• Set.prototype.size：返回Set例項的成員總數。

Set 例項的方法分為兩大類：操作方法（用於操作資料）和遍歷方法（用於遍歷成員）。下面先介紹四個操作方法。

• add(value)：新增某個值，返回 Set 結構本身。
• delete(value)：刪除某個值，返回一個布林值，表示刪除是否成功。
• has(value)：返回一個布林值，表示該值是否為Set的成員。
• clear()：清除所有成員，沒有返回值。

上面這些屬性和方法的例項如下。

s.add(1).add(2).add(2);
// 注意2被加入了兩次

s.size // 2

s.has(1) // true
s.has(2) // true
s.has(3) // false

s.delete(2);
s.has(2) // false

下面是一個對比，看看在判斷是否包括一個鍵上面，Object結構和Set結構的寫法不同。

// 物件的寫法
const properties = {
  'width': 1,
  'height': 1
};

if (properties[someName]) {
  // do something
}

// Set的寫法
const properties = new Set();

properties.add('width');
properties.add('height');

if (properties.has(someName)) {
  // do something
}

遍歷操作

Set 結構的例項有四個遍歷方法，可以用於遍歷成員。

• keys()：返回鍵名的遍歷器
• values()：返回鍵值的遍歷器
• entries()：返回鍵值對的遍歷器
• forEach()：使用回撥函式遍歷每個成員

WeakSet

WeakSet 結構與 Set 類似，也是不重複的值的集合。但是，它與 Set 有兩個區別。

首先，WeakSet 的成員只能是物件，而不能是其他型別的值。

const ws = new WeakSet();
ws.add(1)
// TypeError: Invalid value used in weak set
ws.add(Symbol())
// TypeError: invalid value used in weak set

上面程式碼試圖向 WeakSet 新增一個數值和Symbol值，結果報錯，因為 WeakSet 只能放置物件。

其次，WeakSet 中的物件都是弱引用，即垃圾回收機制不考慮 WeakSet 對該物件的引用，也就是說，如果其他物件都不再引用該物件，那麼垃圾回收機制會自動回收該物件所佔用的記憶體，不考慮該物件還存在於 WeakSet 之中。

map

JavaScript 的物件（Object），本質上是鍵值對的集合（Hash 結構），但是傳統上只能用字串當作鍵。這給它的使用帶來了很大的限制。

const data = {};
const element = document.getElementById('myDiv');

data[element] = 'metadata';
data['[object HTMLDivElement]'] // "metadata"

上面程式碼原意是將一個 DOM 節點作為物件data的鍵，但是由於物件只接受字串作為鍵名，所以element被自動轉為字串[object HTMLDivElement]。

為了解決這個問題，ES6 提供了 Map 資料結構。它類似於物件，也是鍵值對的集合，但是“鍵”的範圍不限於字串，各種型別的值（包括物件）都可以當作鍵。也就是說，Object 結構提供了“字串—值”的對應，Map 結構提供了“值—值”的對應，是一種更完善的 Hash 結構實現。如果你需要“鍵值對”的資料結構，Map 比 Object 更合適。

const m = new Map();
const o = {p: 'Hello World'};

m.set(o, 'content')   //  map中set相當於 set中 add方法 
m.get(o) // "content"

m.has(o) // true
m.delete(o) // true
m.has(o) // 

上面程式碼使用 Map 結構的set方法，將物件o當作m的一個鍵，然後又使用get方法讀取這個鍵，接著使用delete方法刪除了這個鍵。

上面的例子展示瞭如何向 Map 新增成員。作為建構函式，Map 也可以接受一個數組作為引數。該陣列的成員是一個個表示鍵值對的陣列。

const map = new Map([
  ['name', '張三'],
  ['title', 'Author']
]);

map.size // 2
map.has('name') // true
map.get('name') // "張三"
map.has('title') // true
map.get('title') // "Author"

上面程式碼在新建 Map 例項時，就指定了兩個鍵name和title。

5.map-set與陣列和物件的比較

Map與Array的對比、Set與Array的對比

//資料結構橫向對比，增刪改成
let set = new Set();
let map = new Map();
let array = [];

//增
set.add({t:1});
map.set('t',1);
array.push({t:1});

console.log('map-array',map,array);

//查
let set_exist = set.has({t:1});
let map_exist = map.has('t');
let array_exist = array.find(item=>item.t);

//改
set.forEach(item=>item.t?item.t=2:"");
map.set('t',2);
array.forEach(item=>item.t?item.t=2:"");

// 刪
set.forEach(item=>item.t?set.delete(item):'')

map.delete('t');

let index = array.findIndex(item => item.t);
array.splice(index,1);

Map與Object的對比、Set與Object的對比

//map,set,object對比
let item = {t:1};
let map = new Map();
let set = new Set();
let obj = {};

//增
map.set('t',1);
set.add(item);
obj['t'] = 1

//查
let set_exist = set.has(item);
let map_exist = map.has('t');
't' in obj;

//改
map.set('t',2);
item.t =2;
obj['t']=2;

//刪
map.delete('t');
set.delete(item);
delete obj['t'];

總結：優先使用map，能用map不使用陣列，唯一性使用set，最好放棄使用object和陣列。

6.Proxy和Reflect

Proxy 用於修改某些操作的預設行為，等同於在語言層面做出修改，所以屬於一種“超程式設計”（meta programming），即對程式語言進行程式設計。

let obj = {
	time:'2017-03-11',
	name:'net',
	_r:123
};

//代理物件
let monitor = new Proxy(obj,{
	// 攔截物件屬性的讀取
	get(target,key){
		return target[key].replace('2017','2018')
	}
	// 攔截物件設定屬性
	set(target,key,value){
		if(key==='name'){
			return target[key]=value;
		}else{
			return target[key];
		}
	}
	//攔截key in object操作(只暴露name屬性)
	has(target,key){
		if(key==='name'){
			return target[key];
		}else{
			return false;
		}
	}
	//攔截刪除操作 【indexOf() 方法可返回某個指定的字串值在字串中首次出現的位置。】
	deleteProperty(target,key){
		if(key.indexOf('_')>-1){
			delete target[key];
			return true;
		}else{
			return target[key];
		}
	}
	//攔截Object.keys、Object.getOwnPropertySymbols、Object.getOwnPropertyNames
	ownKeys(target){
		return Object.keys(target).filter(item=>item!='time'); //time不進行返回
	}
});

monitor.time;   //2018-03-11

monitor.time = '2018';
monitor.time;   //2018-03-11 沒有變化，不然就是2018了。
monitor.name = 'mukewang';
monitor.name; //mukewang

'name' in monitor;   //false
'time' in monitor;   //false

delete monitor.time;
monitor;   //{time:"2017-03-11",name:"mukewang",_r:123} //還在

Object.keys(monitor);   //["name","_r"]

let obj = {
	time:'2017-03-11',
	name:'net',
	_r:123
};

Reflect.get(obj,'time');   // 2017-03-11
Reflect.set(obj,'name','mukewang');
Reflect.has(obj,''name'');   //true

使用示例：

function validator(target,validator){
	return new Proxy(target,{
		_validator:validator,   //儲存下配置選項
		set(target,key,value,proxy){
			if(target.hasOwnProperty(key)){
				let va = this._validator[key];
				if(!!va(value)){
					return Reflect.set(target,key,value,proxy)
				}else{
					throw Error(`不能設定${key}到${value}`)
				}
			}else{
				throw Error(`${key} 不存在`)
			}
		}
	})
}