JavaScript易错知识小点

摘要：字符串在字符串中找到匹配的字面量，只能替换一次出现的匹配项，暂不存在函数，想要替换多次出现的匹配项，必须使用正则表达式标识。这符合赋值改变但不破坏继承属性的理念。二十七数组构造函数判断是否为一个数组，能够正确处理跨域对象。

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 "#