你不知道的JavaScript之原生函数

原生函数

JavaScript 的内建函数（ built-in function），也叫原生函数（ native
function）。

原生函数类型：

• Number()
• String()
• Boolean()
• Function()
• Array()
• Object()
• Symbol()
• Error()
• Date()
• RegExp()

原生函数可以被当作构造函数来使用，但是构造出来的值都是对象类型的：

var str = new String('hello world')
typeof str  // 'object'
Object.prototype.toString.call(str)  // '[object String]'

var str = 'hello world'
typeof str  // 'string'
Object.prototype.toString.call(str)  // '[object String]'

通过构造函数（如 new String("hello world")）创建出来的是封装了基本类型值（如 "hello world"）的封装对象。

内部属性 [[Class]]

所有 typeof 返回值为 "object" 的对象（如数组）都包含一个内部属性 [[Class]]（我们可
以把它看作一个内部的分类，而非传统的面向对象意义上的类）。这个属性无法直接访问，
一般通过 Object.prototype.toString(..) 来查看。

注：以下 toString 表示 Object.prototype.toString
基本类型的 [[Class]]

// 虽然 Null() 和 Undefined() 这样的原生构造函数并不存在，但是内部 [[Class]] 属性值仍
然是 "Null" 和 "Undefined"。
toString.call(undefined)  // '[object Undefined]'
toString.call(null)  // '[object Null]'
toString.call(string)  // '[object String]'
toString.call(new String('hello'))  // '[object String]'
toString.call(number)  // '[object Number]'

基本类型值被各自的封装对象自动包装，所以它们的内部 [[Class]] 属性值分别为 "String"、 "Number" 和 "Boolean"。

封装对象包装

封 装 对 象（ object wrapper） 扮 演 着 十 分 重 要 的 角 色。 由 于 基 本 类 型 值 没 有 .length 和 .toString() 这样的属性和方法，需要通过封装对象才能访问，此时 JavaScript 会自动为
基本类型值包装（ box 或者 wrap）一个封装对象：

var str = 'hello'
hello.length    // 此时会先把简单值封装成对象，就像前面的 new String() 操作之后返回的值，再访问该值的length类型，然后再销毁该包装对象

一般情况下，我们不需要直接使用封装对象。最好的办法是让 JavaScript 引擎自己决定什
么时候应该使用封装对象。换句话说，就是应该优先考虑使用 "abc" 和 42 这样的基本类型
值，而非 new String("abc") 和 new Number(42)。

注意的点：

!!Boolean(false)  // false
!!new Boolean(false)  // true

拆封

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

typeof new String('hello')  // 'object'
typeof String('hello')  // 'string'
new Boolean(false).valueOf()  // false
Boolean(false).valueOf()  // false

原生函数作为构造函数

关于数组（ array）、对象（ object）、函数（ function）和正则表达式，我们通常喜欢以常量的形式来创建它们。实际上，使用常量和使用构造函数的效果是一样的（创建的值都是通过封装对象来包装）。
如前所述，应该尽量避免使用构造函数，除非十分必要，因为它们经常会产生意想不到的结果。

Array(..)

构造函数 Array(..) 不要求必须带 new 关键字。

注：Array 构造函数只带一个数字参数的时候，该参数会被作为数组的预设长度（ length），而
非只充当数组中的一个元素。

var arr = Array(1, 2, 3)
arr  // [1, 2, 3]

// 只传入一个值，当这个词是 number 类型时
var arr = Array(3)
arr  // [3 x empty] -- 稀疏数组

Object(..) Function(..) RegExp()

除非万不得已，否则尽量不要使用 Object(..)/Function(..)/RegExp(..)。

var obj = new Object()
obj.a = 1

var func = new Function('a', 'return a')

var reg = new RegExp('规则', '描述符')

Date(..) Error(..)

相较于其他原生构造函数， Date(..) 和 Error(..) 的用处要大很多，因为没有对应的常量形式来作为它们的替代。
创建日期对象必须使用 new Date()。 Date(..) 可以带参数，用来指定日期和时间，而不带参数的话则使用当前的日期和时间。
Date(..) 主要用来获得当前的 Unix 时间戳（从 1970 年 1 月 1 日开始计算，以秒为单位）。该值可以通过日期对象中的 getTime() 来获得。
从 ES5 开始引入了一个更简单的方法，即静态函数 Date.now()。

new Date()
new Date().getTime() === Date.now()  // 后端

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

在前后端交互的过程中，后端常用来通过抛出全局异常，然后捕获到异常返回给前端对应的数据。

throw new Error()

Symbol(..)

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

ES6 中有一些预定义符号，以 Symbol 的静态属性形式出现，如 Symbol.create、 Symbol.iterator 等，可以这样来使用：

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

obj[Symbol('symbol')] = 'symbol'
// 作为 obj 的静态属性，不能通过 (for .. in) 遍历出来

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

虽然符号实际上并非私有属性（通过 Object.getOwnPropertySymbols(..) 便可以公开获得对象中的所有符号），但它却主要用于私有或特殊属性。很多开发人员喜欢用它来替代有下划线（ _）前缀的属性，而下划线前缀通常用于命名私有或特殊属性。

var obj = {}
obj[Symbol('symbol')] = 'symbolValue'

Object.getOwnPropertySymbols(obj)  // [Symbol(symbolValue)]

原生原型

原生构造函数有自己的 .prototype 对象，如 Array.prototype、 String.prototype 等。这些对象包含其对应子类型所特有的行为特征。

例如，将字符串值封装为字符串对象之后，就能访问 String.prototype 中定义的方法。

String.prototype 中方法

• .indexOf() 返回指定项在字符串中的位置
• .charAt() 同上，兼容性更好，更好用
• .slice(start, count) 截取字符串，从第几位开始，截取几位

var str = 'hello'
str.slice(2, 3)  // 'l'
str.slice(2, -1)  // 'hell'
// 可以通过 slice 把一个数组转化成类数组
var trueArray = Array.prototype.slice.call(arrayLike)

• .substr(start, length) 与 slice 类似
• .substring(start, end) 从第几位截取到第几位

var str = 'hello'
str.substring(2, 3)  // 'l'

• .toUpperCase() .toLowerCase()

• .trim() 去掉空格，返回新字符串

有些原生原型（ native prototype）并非普通对象那么简单

var toString = Object.prototype.toString
typeof Function.prototype  // 'function'
typeof Array.prototype  // 'object'
...
Array.prototype  // [constructor: f, ...]
toString.call(Array.prototype)  // '[object Array]'
String.prototype // [constructor: f, ...]
toString.call(String.prototype)  // '[object String]'