摘要：字符串在字符串中找到匹配的字面量，只能替換一次出現(xiàn)的匹配項(xiàng)，暫不存在函數(shù)，想要替換多次出現(xiàn)的匹配項(xiàng)，必須使用正則表達(dá)式標(biāo)識(shí)。這符合賦值改變但不破壞繼承屬性的理念。二十七數(shù)組構(gòu)造函數(shù)判斷是否為一個(gè)數(shù)組，能夠正確處理跨域?qū)ο蟆?/p>

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對(duì)象

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

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

limit: 可選， 若傳入，最多返回?cái)?shù)組中l(wèi)imit個(gè)子字符串

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

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

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

注： 若regexp未設(shè)置全局標(biāo)志/g, 則返回一個(gè)對(duì)象(數(shù)組: 存在index和input屬性)，存放第一次匹配相關(guān)的信息；若設(shè)置了/g標(biāo)志，則將所有匹配的子字符串(不包含分組元素)放在一個(gè)數(shù)組中返回； 如果未匹配到任何子字符串，返回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

存在兩個(gè)參數(shù)： search， replacement

search： 字符串或者正則表達(dá)式。

1) 字符串： 在字符串中找到匹配的字面量，只能替換一次出現(xiàn)的匹配項(xiàng)，暫不存在
    (replaceAll函數(shù))，想要替換多次出現(xiàn)的匹配項(xiàng)，必須使用正則表達(dá)式/g標(biāo)識(shí)。
2) 正則表達(dá)式： 對(duì)輸入的字符串進(jìn)行匹配。如果想替換多次，必須使用/g標(biāo)識(shí)

replacement： 字符串或者函數(shù)。

1） 字符串： 描述如何替換找到的匹配項(xiàng))， 使用該字符串替換匹配項(xiàng)，替換字符串中的$
符號(hào)允許使用完全匹配或者匹配分組進(jìn)行替換
2） 函數(shù)： 執(zhí)行替換并提供參數(shù)匹配信息.

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

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

// 使用函數(shù)替換
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èi)容用來(lái)逐字替換匹配項(xiàng)，唯一例外是特殊字符美元符號(hào)($)，它會(huì)啟動(dòng)替換指令

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

匹配的子字符串:

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

$$ 插入單個(gè)$字符

"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為函數(shù)，它需要對(duì)替換匹配項(xiàng)的字符串進(jìn)行處理。簽名如下:

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

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

search: 正則表達(dá)式匹配到的字符串

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

offset（倒數(shù)第二個(gè)參數(shù)）: 匹配到子字符所在原字符串的位置

input(最后一個(gè)參數(shù)): 原字符串

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函數(shù)存在兩個(gè)參數(shù)，第一個(gè)是回調(diào)函數(shù)，第二個(gè)參數(shù)為第一個(gè)參數(shù)（回調(diào)函數(shù)）提供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?)

參數(shù):

proto： 新創(chuàng)建對(duì)象的原型

properties: 可選，通過(guò)描述符給新創(chuàng)建對(duì)象添加屬性

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"

調(diào)用方法： Object.getPrototypeOf(obj)

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

語(yǔ)法： 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

遍歷對(duì)象obj的原型鏈， 返回鍵為propKey的自定義屬性的第一個(gè)對(duì)象

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)
創(chuàng)建或改變obj對(duì)象的propKey鍵的屬性，并通過(guò)propDesc制定這個(gè)屬性的特性，返回修改后的對(duì)象

Object.getOwnPropertyDescriptor(obj, PropKey)
返回obj對(duì)象的propKey鍵自有（非繼承）屬性描述符，如果沒(méi)有該屬性，則返回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;
}

如果一個(gè)對(duì)象obj從原型繼承了不可寫的屬性foo, 在嚴(yán)格模式下，那么不能給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 "#