摘要：字符串在字符串中找到匹配的字面量，只能替換一次出現的匹配項，暫不存在函數，想要替換多次出現的匹配項，必須使用正則表達式標識。這符合賦值改變但不破壞繼承屬性的理念。二十七數組構造函數判斷是否為一個數組，能夠正確處理跨域對象。

var a = new String("abc");
var b = new String("abc");
console.log(a == b) // false
console.log(a === b) // false

Boolean(new Boolean(false)) // true
Number(new Number(123)) // 123
String(new String("abc")) // abc

new Boolean(new Boolean(false)) // true對象

作用: 通過指定邊界(separator)將字符串分割成子字符串，返回字符串組成的數組。

separator: 可選，可以為字符串或正則表達式。不傳的話，將原字符串封裝在數組中返回

limit: 可選， 若傳入，最多返回數組中limit個子字符串

注：若separator為包含子表達式分組的正則表達式，子表達式匹配的字符串也會作為數組中的元素返回。

"a, b   ,   ".split(/(,)/)
# ["a", ",", " b   ", ",", "   "]

作用： 捕獲分組或返回所有匹配的子字符串

注： 若regexp未設置全局標志/g, 則返回一個對象(數組: 存在index和input屬性)，存放第一次匹配相關的信息；若設置了/g標志，則將所有匹配的子字符串(不包含分組元素)放在一個數組中返回； 如果未匹配到任何子字符串，返回null

var a = "-abb--aaab".match(/(a+)b/) // ["ab", "a"]
a.index === 1 // true
a.input === "-abb--aaab" // true
var b = "-abb--aaab".match(/(a+)b/g) // ["ab", "aaab"]
b.index === undefined // true
b.input === undefined // true
var c = "-abb--aaab".match(/(a+)bc/g) // null
c === null // true

存在兩個參數： search， replacement

search： 字符串或者正則表達式。

1) 字符串： 在字符串中找到匹配的字面量，只能替換一次出現的匹配項，暫不存在
    (replaceAll函數)，想要替換多次出現的匹配項，必須使用正則表達式/g標識。
2) 正則表達式： 對輸入的字符串進行匹配。如果想替換多次，必須使用/g標識

replacement： 字符串或者函數。

1） 字符串： 描述如何替換找到的匹配項)， 使用該字符串替換匹配項，替換字符串中的$
符號允許使用完全匹配或者匹配分組進行替換
2） 函數： 執行替換并提供參數匹配信息.

"iixxxixx".replace("i", "o") // oixxxixx
"iixxxixx".replace(/i/, "o") // oixxxixx
"iixxxixx".replace(/i/g, "o") // ooxxxoxx

// 使用$符號
"iixxxixx".replace(/i+/g, "($&)") // (ii)xxx(i)xx
"iixxxixx".replace(/(i+)/g, "($1)") // (ii)xxx(i)xx

// 使用函數替換
function repl(search, group, offset, input) {
    return "{ search: " + search.toUpperCase() + ", group: " + group + ", offset: " + offset + " }";
}
"iixxxixx".replace(/(i+)/g, repl)
// { search: II, group: ii, offset: 0 }xxx{ search: I, group: i, offset: 5 }xx

內容用來逐字替換匹配項，唯一例外是特殊字符美元符號($)，它會啟動替換指令

分組：$n在匹配中插入分組n。n必須大于等于1（$0沒有任何特殊含義）

匹配的子字符串:

1) $` (反引號)插入匹配項之前的文本
2) $& 插入完整的匹配項
3) $" (單引號)插入匹配項之后的文本

$$ 插入單個$字符

"axb cxd".replace(/x/g, "($`,$&,$")"); // a(a,x,b cxd)b c(axb c,x,d)d
""foo" and "bar"".replace(/"(.*?)"/g, "#$1#"); // #foo# and #bar#

如果replacement為函數，它需要對替換匹配項的字符串進行處理。簽名如下:

function replacement (search, group_1, ..., group_n, offset, input){}

search與前面介紹的$&（完整的匹配項）相同， offset表示找到匹配項的位置，input是正在被匹配的字符串

search: 正則表達式匹配到的字符串

group： 如果存在分組，該值為匹配到的分組值， 可變參數， 匹配到分組有多少個，這個參數就有多少個， 如果不存在，表示匹配到子字符所在原字符串的位置

offset（倒數第二個參數）: 匹配到子字符所在原字符串的位置

input(最后一個參數): 原字符串

function replaceFunc (match) { return 2 * match; }
"3 peoples and 5 oranges".replace(/d+/g, replaceFunc); // 6 peoples and 10 oranges

function isObject (value) {
    return value === Object(value);
}

forEach函數存在兩個參數，第一個是回調函數，第二個參數為第一個參數（回調函數）提供this

var obj = {
    name: "Jane",
    friends: ["Tarzan", "Cheeta"],
    loop: function () {
        "use strict";
        this.friends.forEach(function (friend) {
            console.log(this.name + " knows " + friend);
        }, this)
    }
}

使用方法： Object.create(proto, properties?)

參數:

proto： 新創建對象的原型

properties: 可選，通過描述符給新創建對象添加屬性

var PersonProto = {
    describe: function () {
        return "Person named " + this.name;
    }
}

var jane = Object.create(PersonProto, {
    name: { value: "Jane", writable: true, configurable: true, enumerable: true }
});

jane.describe() // "Person named Jane"

調用方法： Object.getPrototypeOf(obj)

Object.getPrototypeOf(jane) === PersonProto // true

語法： Object.prototype.isPrototypeOf(obj)

檢查接受者是否是obj的原型（直接或者間接）

var A = {};
var B = Object.create(A);
var C = Object.create(B);
A.isPrototypeOf(C); // true

PersonProto.isPrototypeOf(jane); // true

遍歷對象obj的原型鏈， 返回鍵為propKey的自定義屬性的第一個對象

function getDefiningObject(obj, propKey) {
    while (obj && !Object.prototype.hasOwnProperty.call(obj, propKey)) {
        obj = Object.getPrototypeOf(obj);
    }

    return obj;
}

可以列吃所有自有屬性，也可以列出可枚舉屬性

1) Object.getOwnPropertyNames(obj) 返回obj的所有自有屬性鍵
2) Object.key(obj) 返回obj所有可枚舉的自有屬性鍵

Object.defineProperty(obj, propKey, propDesc)
創建或改變obj對象的propKey鍵的屬性，并通過propDesc制定這個屬性的特性，返回修改后的對象

Object.getOwnPropertyDescriptor(obj, PropKey)
返回obj對象的propKey鍵自有（非繼承）屬性描述符，如果沒有該屬性，則返回undefined.

需求：

1) 就有相同的原型
2) 具有相同的屬性及屬性特性

function copyObject (orig) {
    // 1. copy has same prototype as orig
    var copy = Object.create(Object.getPrototypeOf(orig));

    // 2. copy ass orig"s own properties
    function copyOwnPropertiesFromObjct (target, source) {
        var ownProperties = Object.getOwnPropertyNames(source);
        for (var property of ownProperties) {
            var sourcePropertyDescriptor = Object.getOwnPropertyDescriptor(source, property);
            Object.defineProperty(target, property, sourcePropertyDescriptor);
        }
    }

    copyOwnPropertiesFromObjct(copy, orig);
    return copy;
}

如果一個對象obj從原型繼承了不可寫的屬性foo, 在嚴格模式下，那么不能給obj.foo賦值。

var proto = Object.create({}, { foo : { value: "a", writable: false } });
// var proto = Object.defineProperty({}, "foo", { value: "a", writable: false });
var obj = Object.create(proto);

obj.foo = "b"; // b
obj.foo // a

// IIFE
(function () { "use strict"; obj.foo = "b" }());
// Uncaught TypeError: Cannot assign to read only property "foo" of object "#