原生函数----《你不知道的js》

310 阅读8分钟

原生函数可以被当做构造函数来使用,但通过构造函数创建出来的是封装了基本类型的封装对象

var a = new String("abc");
typeof a; // "object"
a instanceof String; // true
Obejct.prototype.toString.call(a); // "[object String]"

可以这样来查看封装对象:

console.log(a);

由于不同的浏览器在开发控制台中显示对象的方式不同(对象序列化),所以结果也不同。

chrome 显示:String{0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"};老版本:String{0: "a", 1: "b", 2: "c"}。最新版本的firefox: String["a","b","c"];老版本:"abc",并且可以点击打开对象查看器。输出结果随浏览器变换而变化。

注:new String("abc")创建的是字符串"abc"的封装对象,而非基本类型值"abc"。

一、内部属性[[Class]]

所有typeof返回值为“object”对象(如数组)都包含一个内部属性[[Class]]。这个属性无法直接访问,一般通过Object.prototype.toString(..)来查看

Object.prototype.toString.call([1, 2, 3]); // "[object Array]"
Object.prototype.toString.call(/regex-literal/i); // "[object RegExp]"

上例中,数组的内部[[Class]]属性值是"Array",正则表达式的值是"RegExp"。多数情况下,对象的内部[[Class]]属性和创建该对象的内建原生构造函数相对应,但并非总是如此。

Object.prototype.toString.call(null); // "[object Null]"
Object.prototype.toString.call(undefined); // "[object Undefined]"

虽然Null()和Undefined()这样的原生构造函数并不存在,但内部[[Class]]属性值仍然是"Null"和"Undefined"。

其他基本类型值(如字符串、数字和布尔)的情况有所不同,通常称为包装:

Object.prototype.toString.call("abc"); // "[object String]"
Object.prototype.toString.call(42); // "[object Number]"
Object.prototype.toString.call(true); // "[object Boolean]"

上例中基本类型值被各自的封装对象自动包装,所以他们内部[[Class]]属性值分别为"String"、"Number"、"Boolean"

二、封装对象包装

由于基本类型值没有.length和.toString()这样的属性和方法,需要通过封装对象才能访问,此时js会自动为基本类型值包装(box或wrap)一个封装对象:

var a = "abc";
a.length; // 3
a.toUpperCase(); // "ABC"
  • 封装对象释疑 使用封装对象时有些地方需要特别注意
var a = new Boolean(false);
if(!a) {
    console.log("Oops"); // 执行不到这里
}

我们为false创建了一个封装对象,然而该对象是真值,所以这里使用封装对象得到的结果和使用false截然相反。

如果想要自行封装基本类型值,可以使用Object(..)函数(不带new关键字)

var a = "abc";
var b = new String(a);
var c = Object(a);

typeof a; // "string"
typeof b; // "object"
typeof c; // "object"

b instanceof String; // true
c instanceof String; // true

Obejct.prototype.toString.call(b); // "[object String]"
Obejct.prototype.toString.call(c); // "[object String]"

一般不推荐直接使用封装对象,但他们偶尔会派上用场

三、拆封

如果想要得到封装对象中的基本类型值,可以使用valueOf()函数:

var a = new String("abc");
var b = new Number(42);
var c = new Boolean(true);

a.valueOf(); // "abc"
b.valueOf(); // 42
c.valueOf(); // true

在需要用到封装对象的基本类型值的地方会发生隐式拆封

var a = new String("abc");
var b = a+ ""; // b的值为"abc"
typeof a; // "object"
typeof b; // "string"

四、原生函数作为构造函数

关于数组、对象、函数和正则表达式,我们通常喜欢以常量的形式来创建它们。实际上,使用常量和使用构造函数的效果是一样的(创建的值都是通过封装对象来包装)

如前所述,应该尽量避免使用构造函数,除非十分必要,因为它们经常产生意想不到的结果。

1、Array(..)

var a = new Array(1,2,3);
a; // [1,2,3]
var b = [1,2,3];
b;// [1,2,3]

构造函数Array(..)不要求必须带new关键字。不带时,会被自动补上。因此Array(1,2,3)和new Array(1,2,3)效果是一样的

var a = new Array(3);
a.length; // 3
a;

a 在Chrome中显示为[undefined x 3],这意味着它有三个值为undefined的单元,但实际上单元并不存在

var a = new Array(3);
var b = [undefined, undefined, undefined];
var c = [];
c.length = 3;
a; 
b;
c;

我们可以创建包含空单元的数组,如c。只要将length属性设置为超过实际单元数的值,就能隐式的制造出空单元。另外还可以通过delete b[1]在数组b中制造出一个空单元

b在当前版本的Chrome中显示为[undefined, undefined, undefined],而a和c则显示为[undefined x 3],firefox中a,c显示为[,,,]。这其中有三个逗号代表四个空单元,而不是三个。

firefox在输出结果后面多添加了一个,原因是从ES5规范开始就允许在列表(数组值、属性列表等)末尾多加一个逗号,目的是为了让复制粘贴结果更为准确

上例中a和b的行为有时相同,有时又大相径庭:

a.join("-"); // "--"
b.join("-"); // "--"

a.map(function(v,i){ return i; }); // [ undefined x 3 ]
b.map(function(v,i){ return i; }); // [ 0, 1, 2 ]

a.mp(..)之所以执行失败,是因为数组中并存在任何单元,所以map(..)无从遍历。而join(..)却不一样

function fakeJoin(arr, connector) {
    var str = "";
    for(var i = 0; i < arr.length; i++) {
        if (i > 0) {
            str += connector;
        }
        if (arr[i] !== undefined) {
            str += arr[i];
        }
    }
    return str;
}
var a = new Array(3);
fakeJoin(a, "-"); // "--"

从中可以看出,join(..)首先假定数组不为空,然后通过length属性值来遍历其中的元素。而map(..)并不做这样的假设,因此结果也往往在预期之外,并可能导致失败。

我们可以通过下述方式来创建包含undefined单元(而非“空单元”)的数组:

var a = Array.apply(null, { length: 3 });
a; // [undefined,undefined,undefined]

Array.apply(..)调用Array(..)函数,并将{length:3}作为函数的参数。

我们可以设想apply(..)内部该数组参数名为arr,for循环遍历数组:arr[0]、arr[1]、arr[2]。由于{ length: 3 }中并不存在这些属性,所以返回值为undefined。

我们执行的实际上是Array(undefined,undefined,undefined),所以结果是单元值为undefined的数组,而非空单元数组。

虽然Array.apply(null, { length: 3 })在创建undefined值的数组时有些奇怪和繁琐,但其结果远比Array(3)更准确可靠。

2、Object(..)、Function(..)和RegExp(..)

除非万不得已,否则尽量不要使用Object(..)、Function(..)和RegExp(..)

var c = new Object();
c.foo = "bar";
c; // { foo: "bar"}
var d = { foo: "bar" }
d; // { foo: "bar" }

var e = new Function("a", "return a * 2;");
var f = function(a) { return a * 2; }
function g(a) { return a * 2; }
var h = new RegExp("^a*b+", "g"); // 动态定义正则表达式时很有用
var i = /^a*b+/g;

3、Date(..)和Error(..)

创建日期对象必须使用new Date()。Date(..)可以带参数,用来指定日期和时间,而不带参数的话则可以使用当前的日期和时间。

Date(..)主要用来获得当前Unix时间戳,该值可以通过日期对象中的getTime()来获得。

从ES5开始引入Date.now(),ES5之前使用:

if (!Date.now) {
    Date.now = function() {
        return (new Date()).getTime();
    }
}

构造函数Error(..)可不带new关键字

创建错误对象主要是为了获得当前运行栈的上下文(大部分js引擎通过只读属性.stack来访问)。栈上下文信息包括函数调用栈信息和产生错误的代码行号,以便于调试。

错误对象通常与throw一起使用:

function foo(x) {
    if(!x) {
        throw new Error("x wasn't provided");
    }
}

4、Symbol(..)

符号是具有唯一性的特殊值(并非绝对),用它来命名对象属性不同导致重名。

符号可以用作属性名,但无论是在代码还是开发控制台中都无法查看和访问它的值,只会显示为诸如Symbol(Symbol.create)这样的值。

ES6有一些预定义符号,以Symbol的静态属性形式出现,如Symbol.create、Symbol.iterator

obj[Symbol.iterator] = function() { /*..*/}

我们可以使用Symbol(..)原生构造函数来定义符号。但它比较特殊,不能带new关键字,否则会出错:

var mysym = Symbol("my own symbol");
mysym; // Symbol(my own symbol)
mysym.toString(); // "Symbol(my own symbol)"
typeof mysym; // "symbol"

var a = {};
a[mysym] = "foobar";

Object.getOwnPropertySymbols(a); // [ Symbol(my own symbol) ]

虽然符号实际上并非富有属性(通过Object.getOwnPropertySymbols(..)便可以公开获得对象中所有符号),但它主要用于私有或特殊属性。

5、原生原型

  • String#indexOf(..)

    在字符串中找到指定子字符串的位置

  • String#charAt(..)

    获得字符串指定位置上的字符

  • String#substr(..)、String#substring(..)、String#slice(..)

    获得字符串的指定部分

  • String#toUpperCase()和String#toLowerCase()

    将字符串转为大写或小写

  • String#trim()

    去掉字符串前后的空格,返回新的字符串。

以上方法并不改变原字符串的值,而是返回一个新字符串

其他构造函数的原型包含他们各自类型所持有的行为特征,如Number#toFixed(..)(将数字转换为指定长度的整数字符串)和Array#concat(..)(合并数组)。所有的函数都可以调用Function.prototype中的apply(..)、call(..)、bind(..)

然而有些原生原型并非普通对象那么简单:

typeof Function.prototype; // "function"
Function.prototype(); // 空函数
RegExp.prototype.toString(); // "/(?:)/" ---空正则表达式
"abc".match(RexgExp.prototype); // [""]

我们可以修改他们(不仅仅是添加属性):

Array.isArray(Array.prototype); // true
Array.prototype.push(1,2,3); // 3
Array.prototype; // [1,2,3]
// 需要将Array.prototype设置回空,否则会导致问题
Array.prototype.length = 0;

将原型作为默认值

Function.prototype是一个空函数,RegExp.prototype是一个“空”的正则表达式,而Array.prototype是一个空数组。对未赋值的变量来说,他们是很好的默认值。

function isThisCool(vals, fn, rx) {
    vals = vals || Array.prototype;
    fn = fn || Function.prototype;
    rx = rx || RegExp.prototype;
    return rx.test(
        vals.map(fn).join("")
    )
}
isThisCool(); // true
isThisCool(
    ["a","b","c"],
    function(v){ return v.toUpperCase(); }
); // false

这种方法的一个好处是.prototype已被创建并且仅创建一次。相反,如果将[]、function(){}和/(?:)/作为默认值,则每次调用isThisCool(..)时他们会被创建一次(具体创建与否取决于js引擎),这样无疑会造成内存和CPU资源的浪费

注意:如果默认值随后会被更改,就不要使用Array.prototype。