包装对象、Number、Boolean、String

摘要：JavaScript 中的包装对象、Number、Boolean、String 总结

包装对象

包装对象：就是分别与数值、字符串、布尔值对应的 Number、String、Boolean 三个原生对象。这三个原生对象作为构造函数使用（带有 new）是，可以将原始类型的值转为对象；作为普通函数使用（不使用 new）时，可以将任意类型的值强制转为原始类型的值。有时数据类型会发生自动转换，但自动转换是以强制转换为基础的。

var num = new Number(123);
var str = new String("abc");
var boo = new Boolean(true);
console.log(typeof num, typeof str, typeof boo); // object object object

Number(123); // 123
String("abc"); // "abc"
Boolean(true); // true

包装对象的实例方法：valueOf()、toString() Object对象
valueOf() 方法返回包装对象实例对应的原始类型的值。toString() 方法返回对应的字符串形式。
原始类型的值，可以自动转换为包装对象，调用各种对象的方法和参数，使用后这个临时对象立即销毁。临时对象是只读的，无法修改。

var str = 'abc';
str.length // 3

三种包装对象都可以在包装原型上添加自定义方法和属性

Number.prototype.x2 = function() {
  return this.valueOf() * 2;
};
(123).x2() // 246

Boolean 对象

Boolean 对象作为构造函数（使用 new），主要用于生成布尔值的包装对象的实例，但直接对变量赋值更简单清晰。一定要注意：生成的实例是个对象，判断时也是当做对象来判别会返回 true

new Boolean(false) // Boolean {false}
typeof new Boolean(false) // "object"

Boolean 方法（不使用 new）

单独使用时就是一个单纯的工具方法，使用双重的否运算符!!也可以将任意值转为对应的布尔值，所有对象的布尔值都是 true。

// 仅有以下情况为 false
Boolean(undefined) // false
Boolean(null) // false
Boolean(0) // false
Boolean(-0) // false
Boolean(+0) // false
Boolean("") // false
Boolean(NaN) // false
!!undefined // false
!!null // false
!!0 // false
!!-0 // false
!!+0 // false
!!"" // false
!!NaN // false

// 剩下的都为 true
Boolean(1) // true
Boolean("false") // true
// 对象都返回 true
Boolean([]) // true
Boolean({}) // true
Boolean(function(){}) // true
Boolean(/foo/) // true
!!1 // true
!!"false" // true
!![] // true
!!{} // true
!!function(){} // true
!!/foo/ // true

Number 对象

Number 对象是数值对应的包装对象，可以作为构造函数使用，也可以作为工具函数将任意类型的值转化成数值。

new Number(123) // Number {123}
typeof new Number(123) // "object"

对象属性：

Number.POSITIVE_INFINITY：正的无限，指向 Infinity
Number.NEGATIVE_INFINITY：负的无限，指向 -Infinity
Number.NaN：表示非数值，指向 NaN
Number.MAX_VALUE：表示最大的正数，相应的，最小的负数为 -Number.MAX_VALUE
Number.MIN_VALUE：表示最小的正数（即最接近 0 的正数，在 64 位浮点数体系中为5e-324），相应的，最接近 0 的负数为 -Number.MIN_VALUE
Number.MAX_SAFE_INTEGER：表示能够精确表示的最大整数，即 9007199254740991
Number.MIN_SAFE_INTEGER：表示能够精确表示的最小整数，即 -9007199254740991

Number 方法（不使用 new）

使用 Number 函数将原始类型的值整体转换为数值，具体规则如下：
1、Boolean 值，true 转为 1，false 转为 0
2、数字值，不变
3、null 转为 0
4、undefined 转为 NaN
5、字符串有多种情况，而且会自动过滤一个字符串前导和后缀的空格
1）只包含整数数值，忽略字符前面的数字 0，并转为 10 进制数值，符号不变
2）包含有效浮点型数值，忽略字符前面的数字 0，转为浮点型数值，符号不变
3）包含有效的十六进制格式（0x 或 0X 开头）或二进制格式（0b 或 0B 开头）的字符，转换为相同大小的十进制数值
4) 空字符串转为 0
5）其他字符全部转为 NaN

Number(true) // 1
Number(false) // 0
Number(324) // 324
Number(null) // 0
Number(undefined) // NaN
Number(" \t\v\r03.24\n") // 3.24
Number(" 0324") // 324
Number(" 0324.123") // 324.123
Number(" 0xf") // 15
Number("0b11") // 3
Number("") // 0

如果参数是对象，则调用对象的 valueOf 方法，如果返回原始类型的值，则直接对该值使用 Number 函数。如果 valueOf 方法返回的还是对象，则改为调用对象自身的 toString 方法。如果 toString 方法返回原始类型的值，则对该值使用 Number 函数。如果 toString 方法返回的是对象，就报错。

parseInt (处理字符串)

parseInt 函数解析一个参数（必要时先调用 toString 转换为字符串）并返回一个整数。但 parseInt 是逐个解析字符，比 Number 的效率要低。parseInt 也会自动过滤一个字符串前导和后缀的空格，但如果第一个非空字符不是数字或者正负负号，就会返回 NaN，空字符串也会返回 NaN。如果有效字符以”0x”或”0X”开头，parseInt 会以十六进制来保存有效字符，否则默认以十进制保存有效字符。
···
parseInt(“ 00321 “) // 321
parseInt(“\t\v\r -00321 “) // -321
parseInt(“0324.123”) // 324
parseInt(“0324a123”) // 324
parseInt(“0x324a123”) // 52732195
parseInt(“0a324a123”) // 0
parseInt(“a123”) // NaN
parseInt(“”) // NaN
···
parseInt() 方法还有基模式，传递第二个参数(2~36 整数)可以指定对应进制的有效字符串转换成十进制整数。

parseInt("AF") // NaN
parseInt("AF", 16) // 175
parseInt("0123", 8) // 83
parseInt("   -1010", 2) // -10
parseInt(" -010- ", 2) // -2
parseInt(021) // 17
parseInt(021, 8) // 15
parseInt(1/0) // NaN
parseInt(Infinity) // NaN

有些非常大或非常小的数字会以包含 e 的科学计数法来表示：6.78e+22 表示 67800000000000000000000。此时，使用 parseInt 就会得到错误结果 6。parseInt 也不识别 Infinity。parseInt 不应替代 Math.floor。
parseInt 也可以处理对象，跟 Number 类似，但不同的是：parseInt 先调用 toString 方法，如果返回原始类型的值，则直接对该值使用 parseInt 函数。但如果返回一个对象，就调用自身的 valueOf 方法。如果 valueOf 方法返回的是原始类型的值，直接使用 parseInt 处理该值。但如果还是返回一个对象，就报错。

parseFloat (处理字符串)

parseFloat 函数解析一个参数（必要时先调用 toString 转换为字符串）并返回一个浮点数。它同样会自动过滤字符串前导和后缀的空格，但它会识别正负号(+、-)、数字(0~9)、科学计数法中的指数(e、E)和小数点(.)，再遇到其他字符或第二个小数点（.）时会返回已识别的数值。如果第一个有效字符不能被解析为数字就返回 NaN。parseFloat 可以识别 Infinity，并返回 Infinity。

parseFloat(3.14)
parseFloat('3.14')
parseFloat('  3.14  ')
parseFloat('314e-2')
parseFloat('0.0314E+2')
parseFloat('3.14some non-digit characters')
parseFloat(1/0) // Infinity
parseFloat(Infinity) // Infinity

parseFloat 处理对象的机制与 parseInte 一致，只不过处理值时改成用 parseFloat 方法。但 parseFloat 方法没有第二个参数，

实例方法

1、Number.prototype.toString 方法将一个数值转为字符串形式。数字以 0b、0、0x 开头，会将数字先以二、八、十六进制先转换为十进制，再转换为对应字符串。如果有超出进制的数出现，就直接以默认十进制转换为字符。如果参数不是任何进制的有效数字，就会报错。

(0b1010).toString() // "10" 以二进制处理
(0b1012).toString() // 报错 无效数字
(0217).toString() // "143" 以八进制处理
(0218).toString() // "218" 有 8 以十进制处理
(0x21).toString() // "33" 以十六进制处理
(0x2g).toString() // 报错 无效数字

toString 还方法可以接受一个参数，表示输出的进制。可以使用该方法对数字进行进制的转换：

(0b1010).toString(10) // "10"
(0b1010).toString(2) // "1010"
(0b1010).toString(8) // "12"
(0b1010).toString(16) // "a"
(10).toString() // "10"
(10).toString(2) // "1010"
(10).toString(8) // "12"
(10).toString(16) // "a"

可以直接对一个小数使用 toString 方法

10..toString(2) // "1010" JavaScript 会把第一个点理解成小数点（即 10.0），把第二个点理解成调用对象属性
10.5.toString() // "10.5"
10.5.toString(2) // "1010.1"
10.5.toString(8) // "12.4"
10.5.toString(16) // "a.8"

2、Number.prototype.toFixed 将一个数转为指定位数的小数，返回这个小数对应的字符串，参数为指定的小数位数，有效范围为 0 到 20

(10).toFixed(2) // "10.00"
10.005.toFixed(2) // "10.01"

3、Number.prototype.toExponential 将一个数转为科学计数法形式，参数表示小数点后有效数字的位数，范围为 0 到 20

(10).toExponential()  // "1e+1"
(10).toExponential(1) // "1.0e+1"
(10).toExponential(2) // "1.00e+1"

4、Number.prototype.toPrecision 将一个数转为指定位数的有效数字，参数为有效数字的位数，范围是 1 到 21，四舍五入时不太可靠，跟浮点数不是精确储存有关

String 对象

字符串的包装对象是一个类似数组的对象

new String("abc") // String {0: "a", 1: "b", 2: "c", length: 3}
typeof new String("abc") // "object"

String.fromCharCode 是 String 对象提供的静态方法，其参数是一系列 Unicode 码点（不能大于 0xFFFF），返回对应的字符串

String.fromCharCode(104, 101, 108, 108, 111) // "hello"

String 方法（不使用 new）

String 函数可以将任意类型的值转化成字符串，转化原始数据类型时就是在原来值上添加引号(“”)：

String(123) // "123"
String('abc') // "abc"
String(true) // "true"
String(undefined) // "undefined"
String(null) // "null"
String(Symbol(1)) // "Symbol(1)"

String 方法转换对象的规则，与 Number 方法基本相同，但是互换了 valueOf 方法和 toString 方法的执行顺序。String 是先调用 toString 方法，如果返回原始类型的值，就用 String 处理值。如果返回的是个对象，就调用 valueOf 方法。如果 valueOf 方法返回的值是原始类型，就用 String 方法处理该值。但如果还是返回一个对象，就报错。

实例对象的属性和方法

字符串的方法一般不会修改原始字符串
1.length 属性返回字符串长度

2.charAt 方法返回指定位置的字符，参数是从0开始编号的位置。该方法完全可以用数组下标替代，如果参数为负数，或大于等于字符串的长度，charAt 返回空字符串

"abc".charAt(1) // "b"
"abc"[1] // "b"

3.charCodeAt 方法返回给定位置字符的 Unicode 码点（十进制），相当于 String.fromCharCode 的逆操作

"hello".charCodeAt(0) // 104

4.concat 方法用于连接两个或多个字符串，返回一个新字符串。如果参数不是字符串，concat 方法会将其先转为字符串，然后再连接

var string1 = "abc";
var string2 = "def";
var string3 = string1.concat(string2);
var string4 = string1.concat(string2, "ghi");
console.log(string1, string2, string3, string4) // "abc" "def" "abcdef" "abcdefghi"

5.slice 方法用于从原字符串取出子字符串并返回，不改变原字符串。它的第一个参数是索引起始位置，第二个参数是结束位置（不含该位置）；如果参数是负值，该负值加上字符串长度；如果第一个参数大于第二个参数，返回一个空字符串

var str = "hello world";
str.slice(1); // "ello world"
str.slice(1, 7); // "ello w"
str.slice(-10, -4); // "ello w"
str.slice(7, 1); // ""

6.substring 方法作用与 slice 相同，第一个参数表示索引起始位置，第二个表示结束位置（不包含）；如果参数是负数，自动将负数转为 0；如果第二个参数大于第一个参数，自动交换两个参数的位置（前小后大）

str.substring(1); // "ello world"
str.substring(1, 7); // "ello w"
str.substring(7, 1); // "ello w"
str.substring(-6, 4); // "hell"
str.substring(10, -4); // "hello worl"

7.substr 方法从原字符串取出子字符串并返回，第一个参数表示索引起始位置，第二个参数是子字符串的长度。如果第一个参数为负值，加上字符串长度表示起始索引；如果第二个参数是负数，将被自动转为 0，取 0 个就返回空字符串

str.substr(1); // "ello world"
str.substr(1, 7); // "ello wo"
str.substr(-6, 4); // " wor"
str.substr(10, -4); // ""

8.trim 方法用于去除字符串两端的空格(还包括制表符 \t、\v、换行符 \n 和回车符 \r)，返回一个新字符串

var str = "   hello world   ";
str.trim(); // hello world
"\r\nabc \t".trim() // "abc"

9.indexOf 方法用于确定一个字符串在另一个字符串中的位置，返回匹配开始的索引位置。第二个参数可选，表示从该位置开始向后匹配。如果未匹配到，返回 -1。lastIndexOf 与 indexOf 作用相似，但顺序是从后往前查找

str.indexOf("o"); // 4
str.indexOf("o", 5); // 7
str.lastIndexOf("o"); // 7
str.lastIndexOf("o", 5); // 4

10.toLowerCase 方法用于将一个字符串全部转为小写，toUpperCase 则是全部转为大写。通过 call 方法也可以将布尔值或数组转为大写字符串

var STR = str.toUpperCase(); // "HELLO WORLD"
var str = STR.toLowerCase(); // "hello world"
String.prototype.toUpperCase.call(true) // "TRUE"
String.prototype.toUpperCase.call(["a", "b", "c"]) // "A,B,C"

11.localeCompare 方法用于比较两个字符串。它返回一个整数，如果小于 0，表示第一个字符串小于第二个字符串；如果等于 0，表示两者相等；如果大于 0，表示第一个字符串大于第二个字符串。该方法采用底层操作系统提供的本地排序规则

"str".localeCompare("rst"); // 1
"str".localeCompare("str"); // 0
"str".localeCompare("trs"); // -1
"str".localeCompare("Rst"); // 1

12.match 方法用于匹配是否含某个子字符串，返回一个数组，成员为匹配的第一个字符串。如果没有，返回 null。返回数组还有 index 属性和 input 属性，分别表示匹配字符串开始的位置和原始字符串

str.match("xiao"); // null
str.match("wo"); // ["wo", index: 6, input: "hello world"]

13.search 方法用于匹配是否含某个子字符串返回值为匹配的第一个位置。如果没有找到匹配，则返回-1

str.search("xiao"); // -1
str.search("wo"); // 6

14.replace 方法用于替换匹配的子字符串，默认只替换第一个

str.replace("wo", "ni"); // "hello nirld"

15.split 方法按照给定规则分割字符串，返回一个由分割出来的子字符串组成的数组；如果省略参数，则返回数组的唯一成员就是原字符串；如果分割规则为空字符串，则返回数组的成员是原字符串的每一个字符；split 方法还可以接受第二个参数，限定返回数组的最大成员数

var str = "-a-b-c-";
str.split(); // ["-a-b-c-"]
str.split(""); // ["-", "a", "-", "b", "-", "c", "-"]
str.split("-"); // ["", "a", "b", "c", ""]
str.split("-", 3); // ["", "a", "b"]
str.split("-", 6); // ["", "a", "b", "c", ""]

自动转换

JavaScript 会在三种情况下自动转换数据类型：
1、不同类型的数据互相运算
2、对非布尔值类型的数据求布尔值
3、对非数值类型的值使用一元运算符 + 和 -

自动转换为布尔值

当使用if条件语句或者条件（三元）运算符...?...:...或者双重的否运算符!!时，都会自动调用 Boolean() 函数

自动转换为字符串

转换为字符串的具体规则是，先将复合类型的值转为原始类型的值，再将原始类型的值转为字符串。主要发生在字符串进行加法运算的时候，需要将非字符串值转换为字符串。

自动转换为数值

除了加法 + 在有字符串的情况下会使另一个值也转成字符串，其他运算符都会自动调用 Number() 函数将其它类型转换成数值。一元运算符 + 和 - 也会使值转换成数值。

包装对象
Boolean 对象
Number 对象
String 对象
数据类型的转换