第5章 引用类型（10）基本包装类型
来源：互联网 发布：电棍在淘宝怎么搜索 编辑：程序博客网 时间：2024/05/20 12:46
5.6 基本包装类型
为了便于操作基本类型值，ECMAScript 还提供了3 个特殊的引用类型：Boolean、Number 和String。
这些类型与本章介绍的其他引用类型相似，但同时也具有与各自的基本类型相应的特殊行为。
实际上，每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型的对象，
从而让我们能够调用一些方法来操作这些数据。来看下面的例子。
var s1 = "some text";
var s2 = s1.substring(2);
这个例子中的变量s1 包含一个字符串，字符串当然是基本类型值。
而下一行调用了s1 的substring()方法，并将返回的结果保存在了s2 中。
我们知道，基本类型值不是对象，因而从逻辑上讲它们不应该有方法（尽管如我们所愿，它们确实有方法）。
其实，为了让我们实现这种直观的操作，后台已经自动完成了一系列的处理。
当第二行代码访问s1 时，访问过程处于一种读取模式，也就是要从内存中读取这个字符串的值。
而在读取模式中访问字符串时，后台都会自动完成下列处理。
(1) 创建String 类型的一个实例；
(2) 在实例上调用指定的方法；
(3) 销毁这个实例。
可以将以上三个步骤想象成是执行了下列ECMAScript 代码。
var s1 = new String("some text");
var s2 = s1.substring(2);
s1 = null;
经过此番处理，基本的字符串值就变得跟对象一样了。而且，上面这三个步骤也分别适用于Boolean
和Number 类型对应的布尔值和数字值。
------------------------------------------------------------------------------------------------------------------------------
引用类型与基本包装类型的主要区别就是对象的生存期。
使用new 操作符创建的引用类型的实例，在执行流离开当前作用域之前都一直保存在内存中。
而自动创建的基本包装类型的对象，则只存在于一行代码的执行瞬间，然后立即被销毁。
这意味着我们不能在运行时为基本类型值添加属性和方法。来看下面的例子：
var s1 = "some text";
s1.color = "red";
alert(s1.color); //undefined
在此，第二行代码试图为字符串s1 添加一个color 属性。但是，当第三行代码再次访问s1 时，
其color 属性不见了。问题的原因就是第二行创建的String 对象在执行第三行代码时已经被销毁了。
第三行代码又创建自己的String 对象，而该对象没有color 属性。----------------------------------------------------------------------------------------------------------------------------当然，可以显式地调用Boolean、Number 和String 来创建基本包装类型的对象。
不过，应该在绝对必要的情况下再这样做，因为这种做法很容易让人分不清自己是在处理基本类型还是引用类型的值。
对基本包装类型的实例调用typeof 会返回"object"，而且所有基本包装类型的对象都会被转换为布尔值true。
Object 构造函数也会像工厂方法一样，根据传入值的类型返回相应基本包装类型的实例。例如：
var obj = new Object("some text");
alert(obj instanceof String); //true
把字符串传给Object 构造函数，就会创建String 的实例；
而传入数值参数会得到Number 的实例，传入布尔值参数就会得到Boolean 的实例。
要注意的是，使用new 调用基本包装类型的构造函数，与直接调用同名的转型函数是不一样的。
例如：
var value = "25";
var number = Number(value); //转型函数
alert(typeof number); //"number"
var obj = new Number(value); //构造函数
alert(typeof obj); //"object"
在这个例子中，变量number 中保存的是基本类型的值25，而变量obj 中保存的是Number 的实例。
要了解有关转型函数的更多信息，请参考第3 章。
尽管我们不建议显式地创建基本包装类型的对象，但它们操作基本类型值的能力还是相当重要的。而每个基本包装类型都提供了操作相应值的便捷方法。
---------------------------------------------------------------------------------------------------------------------------------5.6.1 Boolean类型
Boolean 类型是与布尔值对应的引用类型。要创建Boolean 对象，可以像下面这样调用Boolean构造函数并传入true 或false 值。
var booleanObject = new Boolean(true);
Boolean 类型的实例重写了valueOf()方法，返回基本类型值true 或false；
重写了toString()方法，返回字符串"true"和"false"。
可是，Boolean 对象在ECMAScript 中的用处不大，因为它经常会造成人们的误解。
其中最常见的问题就是在布尔表达式中使用Boolean 对象，例如：
<!DOCTYPE html><html><head> <title>Boolean Type Example</title> <script type="text/javascript"> var falseObject = new Boolean(false); var result = falseObject && true; alert(result); //true var falseValue = false; result = falseValue && true; alert(result); //false alert(typeof falseObject); //object alert(typeof falseValue); //boolean alert(falseObject instanceof Boolean); //true alert(falseValue instanceof Boolean); //false </script></head><body></body></html>在这个例子中，我们使用false 值创建了一个Boolean 对象。然后，将这个对象与基本类型值true构成了逻辑与表达式。
在布尔运算中，false && true 等于false。可是，示例中的这行代码是对falseObject 而不是对它的值（false）进行求值。
前面讨论过，布尔表达式中的所有对象都会被转换为true，因此falseObject 对象在布尔表达式中代表的是true。
结果，true && true 当然就等于true 了。
基本类型与引用类型的布尔值还有两个区别。
首先，typeof 操作符对基本类型返回"boolean"，
而对引用类型返回"object"。
其次，由于Boolean 对象是Boolean 类型的实例，所以使用instanceof操作符测试Boolean 对象会返回true，
而测试基本类型的布尔值则返回false。例如：
alert(typeof falseObject); //object
alert(typeof falseValue); //boolean
alert(falseObject instanceof Boolean); //true
alert(falseValue instanceof Boolean); //false
理解基本类型的布尔值与Boolean 对象之间的区别非常重要——当然，我们的建议是永远不要使用Boolean 对象。
5.6.2Number 类型
Number 是与数字值对应的引用类型。要创建Number 对象，可以在调用Number 构造函数时向其中传递相应的数值。
下面是一个例子。
var numberObject = new Number(10);
<!DOCTYPE html><html><head> <title>Number Type Example</title> <script type="text/javascript"> var numberObject = new Number(10); var numberValue = 99; //toString() using a radix alert(numberObject.toString()); //"10" alert(numberObject.toString(2)); //"1010" alert(numberObject.toString(8)); //"12" alert(numberObject.toString(10)); //"10" alert(numberObject.toString(16)); //"a" //toFixed() alert(numberObject.toFixed(2)); //outputs "10.00" numberObject = new Number(99); alert(numberObject.toPrecision(1)); //"1e+2" alert(numberObject.toPrecision(2)); //"99" alert(numberObject.toPrecision(3)); //"99.0" alert(typeof numberObject); //object alert(typeof numberValue); //number alert(numberObject instanceof Number); //true alert(numberValue instanceof Number); //false </script></head><body></body></html>与Boolean 类型一样，Number 类型也重写了valueOf()、toLocaleString()和toString()方法。
重写后的valueOf()方法返回对象表示的基本类型的数值，另外两个方法则返回字符串形式的数值。
我们在第3 章还介绍过，可以为toString()方法传递一个表示基数的参数，告诉它返回几进制
数值的字符串形式，如下面的例子所示。
var num = 10;
alert(num.toString()); //"10"
alert(num.toString(2)); //"1010"
alert(num.toString(8)); //"12"
alert(num.toString(10)); //"10"
alert(num.toString(16)); //"a"
除了继承的方法之外，Number 类型还提供了一些用于将数值格式化为字符串的方法。其中，
toFixed()方法会按照指定的小数位返回数值的字符串表示，例如：
var num = 10;
alert(num.toFixed(2)); //"10.00"
这里给toFixed()方法传入了数值2，意思是显示几位小数。于是，这个方法返回了"10.00"，即
以0 填补了必要的小数位。如果数值本身包含的小数位比指定的还多，那么接近指定的最大小数位的值
就会舍入，如下面的例子所示。
var num = 10.005;
alert(num.toFixed(2)); //"10.01"
能够自动舍入的特性，使得toFixed()方法很适合处理货币值。
但需要注意的是，不同浏览器给这个方法设定的舍入规则可能会有所不同。
在给toFixed()传入0 的情况下，IE8 及之前版本不能正确
舍入范围在{(-0.94,-0.5],[0.5,0.94)}之间的值。对于这个范围内的值，IE 会返回0，而不是-1 或1；
其他浏览器都能返回正确的值。IE9 修复了这个问题。
PS：toFixed()方法可以表示带有0 到20 个小数位的数值。但这只是标准实现的范
围，有些浏览器也可能支持更多位数。
-------------------------------------------------------------------------------------------------------------------------
另外可用于格式化数值的方法是toExponential()，
该方法返回以指数表示法（也称e 表示法）表示的数值的字符串形式。
与toFixed()一样，toExponential()也接收一个参数，而且该参数同样
也是指定输出结果中的小数位数。看下面的例子。
var num = 10;
alert(num.toExponential(1)); //"1.0e+1"
以上代码输出了"1.0e+1"；不过，这么小的数值一般不必使用e 表示法。
如果你想得到表示某个数值的最合适的格式，就应该使用toPrecision()方法。
对于一个数值来说，toPrecision()方法可能会返回固定大小（fixed）格式，也可能返回指数
（exponential）格式；具体规则是看哪种格式最合适。这个方法接收一个参数，即表示数值的所有数字的
位数（不包括指数部分）。请看下面的例子。
var num = 99;
alert(num.toPrecision(1)); //"1e+2"
alert(num.toPrecision(2)); //"99"
aler t(num.toPrecision(3)); //"99.0"
以上代码首先完成的任务是以一位数来表示99，结果是"1e+2"，即100。
因为一位数无法准确地表示99，因此toPrecision()就将它向上舍入为100，这样就可以使用一位数来表示它了。
而接下来的用两位数表示99，当然还是"99"。最后，在想以三位数表示99 时，toPrecision()方法返回了"99.0"。
实际上，toPrecision()会根据要处理的数值决定到底是调用toFixed()还是调用toExponential()。
而这三个方法都可以通过向上或向下舍入，做到以最准确的形式来表示带有正确小数位的值。
PS：toPrecision()方法可以表现1 到21 位小数。某些浏览器支持的范围更大，但这是典型实现的范围。
与Boolean 对象类似，Number 对象也以后台方式为数值提供了重要的功能。
但与此同时，我们仍然不建议直接实例化Number 类型，而原因与显式创建Boolean 对象一样。
具体来讲，就是在使用typeof 和instanceof 操作符测试基本类型数值与引用类型数值时，得到的结果完全不同，如下面的例子所示。
var numberObject = new Number(10);
var numberValue = 10;
alert(typeof numberObject); //"object"
alert(typeof numberValue); //"number"
alert(numberObject instanceof Number); //true
aler t(numberValue instanceof Number); //false
在使用typeof 操作符测试基本类型数值时，始终会返回"number"，而在测试Number 对象时，则会返回"object"。
类似地，Number 对象是Number 类型的实例，而基本类型的数值则不是。
----------------------------------------------------------------------------------------------------------------------------------------------------------
5.6.3 String类型
String 类型是字符串的对象包装类型，可以像下面这样使用String 构造函数来创建。
var stringObject = new String("hello world");
String 对象的方法也可以在所有基本的字符串值中访问到。其中，继承的valueOf()、toLocaleString()和toString()方法，
都返回对象所表示的基本字符串值。
String 类型的每个实例都有一个length 属性，表示字符串中包含多个字符。来看下面的例子。
var stringValue = "hello world";
alert(stringValue.length); //"11"
这个例子输出了字符串"hello world"中的字符数量，即"11"。应该注意的是，即使字符串中包
含双字节字符（不是占一个字节的ASCII 字符），每个字符也仍然算一个字符。
String 类型提供了很多方法，用于辅助完成对ECMAScript 中字符串的解析和操作。
1. 字符方法
两个用于访问字符串中特定字符的方法是：charAt()和charCodeAt()。这两个方法都接收一个
参数，即基于0 的字符位置。其中，charAt()方法以单字符字符串的形式返回给定位置的那个字符
（ECMAScript 中没有字符类型）。例如：
var stringValue = "hello world";
alert(stringValue.charAt(1)); //"e"
字符串"hello world"位置1 处的字符是"e"，因此调用charAt(1)就返回了"e"。如果你想得到
的不是字符而是字符编码，那么就要像下面这样使用charCodeAt()了。
var stringValue = "hello world";
alert(stringValue.charCodeAt(1)); //输出"101"
这个例子输出的是"101"，也就是小写字母"e"的字符编码。
ECMAScript 5 还定义了另一个访问个别字符的方法。在支持此方法的浏览器中，
可以使用方括号加数字索引来访问字符串中的特定字符，如下面的例子所示。
var stringValue = "hello world";
alert(stringValue[1]); //"e"
使用方括号表示法访问个别字符的语法得到了IE8 及Firefox、Safari、Chrome 和Opera 所有版本的支持。
如果是在IE7 及更早版本中使用这种语法，会返回undefined 值（尽管根本不是特殊的undefined 值）。
2. 字符串操作方法
下面介绍与操作字符串有关的几个方法。第一个就是concat()，
用于将一或多个字符串拼接起来，返回拼接得到的新字符串。先来看一个例子。
var stringValue = "hello ";
var result = stringValue.concat("world");
alert(result); //"hello world"
alert(stringValue); //"hello"
在这个例子中，通过stringValue 调用concat()方法返回的结果是"hello world"——但
stringValue 的值则保持不变。实际上，concat()方法可以接受任意多个参数，
也就是说可以通过它拼接任意多个字符串。再看一个例子：
var stringValue = "hello ";
var result = stringValue.concat("world", "!");
alert(result); //"hello world!"
alert(stringValue); //"hello"
这个例子将"world"和"!"拼接到了"hello"的末尾。虽然concat()是专门用来拼接字符串的方法，
但实践中使用更多的还是加号操作符（+）。而且，使用加号操作符在大多数情况下都比使用concat()
方法要简便易行（特别是在拼接多个字符串的情况下）。
----------------------------------------------------------------------------------------------------------------------------------
ECMAScript 还提供了三个基于子字符串创建新字符串的方法：slice()、substr()和substring()。
这三个方法都会返回被操作字符串的一个子字符串，而且也都接受一或两个参数。
第一个参数指定子字符串的开始位置，第二个参数（在指定的情况下）表示子字符串到哪里结束。
具体来说，slice()和substring()的第二个参数指定的是子字符串最后一个字符后面的位置。
而substr()的第二个参数指定的则是返回的字符个数。如果没有给这些方法传递第二个参数，则将字符串的长度作为结束位置。
与concat()方法一样，slice()、substr()和substring()也不会修改字符串本身的值——它们只是
返回一个基本类型的字符串值，对原始字符串没有任何影响。请看下面的例子。
<!DOCTYPE html><html><head> <title>String Type Manipulation Methods Example</title> <script type="text/javascript"> var stringValue = "hello world"; alert(stringValue.slice(3)); //"lo world" alert(stringValue.substring(3)); //"lo world" alert(stringValue.substr(3)); //"lo world" alert(stringValue.slice(3, 7)); //"lo w" alert(stringValue.substring(3,7)); //"lo w" alert(stringValue.substr(3, 7)); //"lo worl" alert(stringValue.slice(-3)); //"rld" alert(stringValue.substring(-3)); //"hello world" alert(stringValue.substr(-3)); //"rld" alert(stringValue.slice(3, -4)); //"lo w" alert(stringValue.substring(3, -4)); //"hel" alert(stringValue.substr(3, -4)); //"" (empty string) </script></head><body></body></html>
这个例子比较了以相同方式调用slice()、substr()和substring()得到的结果，而且多数情
况下的结果是相同的。在只指定一个参数3 的情况下，这三个方法都返回"lo world"，因为"hello"
中的第二个"l"处于位置3。而在指定两个参数3 和7 的情况下，slice()和substring()返回"lo w"
（"world"中的"o"处于位置7，因此结果中不包含"o"），但substr()返回"lo worl"，因为它的第二
个参数指定的是要返回的字符个数。
在传递给这些方法的参数是负值的情况下，它们的行为就不尽相同了。其中，slice()方法会将传
入的负值与字符串的长度相加，substr()方法将负的第一个参数加上字符串的长度，而将负的第二个
参数转换为0。最后，substring()方法会把所有负值参数都转换为0。下面来看例子。
这个例子清晰地展示了上述三个方法之间的不同行为。在给slice()和substr()传递一个负值
参数时，它们的行为相同。这是因为-3 会被转换为8（字符串长度加参数11+(-3)=8），实际上相当
于调用了slice(8)和substr(8)。但substring()方法则返回了全部字符串，因为它将-3 转换成了0。
PS：
IE 的JavaScript 实现在处理向substr()方法传递负值的情况时存在问题，
它会返回原始的字符串。IE9 修复了这个问题。
当第二个参数是负值时，这三个方法的行为各不相同。slice()方法会把第二个参数转换为7，
这就相当于调用了slice(3,7)，因此返回"lo w"。substring()方法会把第二个参数转换为0，使调
用变成了substring(3,0)，而由于这个方法会将较小的数作为开始位置，将较大的数作为结束位置，
因此最终相当于调用了substring(0,3)。substr()也会将第二个参数转换为0，这也就意味着返回
包含零个字符的字符串，也就是一个空字符串。
3. 字符串位置方法
有两个可以从字符串中查找子字符串的方法：indexOf()和lastIndexOf()。这两个方法都是从
一个字符串中搜索给定的子字符串，然后返子字符串的位置（如果没有找到该子字符串，则返回-1）。
这两个方法的区别在于：
indexOf()方法从字符串的开头向后搜索子字符串，而lastIndexOf()方法是从字符串的末尾向前搜索子字符串。
还是来看一个例子吧。
<!DOCTYPE html><html><head> <title>String Type Location Methods Example</title> <script type="text/javascript"> var stringValue = "hello world"; alert(stringValue.indexOf("o")); //4 alert(stringValue.lastIndexOf("o")); //7 alert(stringValue.indexOf("o", 6)); //7 alert(stringValue.lastIndexOf("o", 6)); //4 </script></head><body></body></html>子字符串"o"第一次出现的位置是4，即"hello"中的"o"；最后一次出现的位置是7，即"world"中的"o"。
如果"o"在这个字符串中仅出现了一次，那么indexOf()和lastIndexOf()会返回相同的位置值。
这两个方法都可以接收可选的第二个参数，表示从字符串中的哪个位置开始搜索。
换句话说，indexOf()会从该参数指定的位置向后搜索，忽略该位置之前的所有字符；
而lastIndexOf()则会从指定的位置向前搜索，忽略该位置之后的所有字符。
看下面的例子。
var stringValue = "hello world";
alert(stringValue.indexOf("o", 6)); //7
alert(stringValue.lastIndexOf("o", 6)); //4
在将第二个参数6 传递给这两个方法之后，得到了与前面例子相反的结果。这一次，由于
indexOf()是从位置6（字母"w"）开始向后搜索，结果在位置7 找到了"o"，因此它返回7。
而lastIndexOf()是从位置6 开始向前搜索。结果找到了"hello"中的"o"，因此它返回4。
在使用第二个参数的情况下，可以通过循环调用indexOf()或lastIndexOf()来找到所有匹配的子字符串，
如下面的例子所示：
<!DOCTYPE html><html><head> <title>String Type Location Methods Example 2</title> <script type="text/javascript"> var stringValue = "Lorem ipsum dolor sit amet, consectetur adipisicing elit"; var positions = new Array(); var pos = stringValue.indexOf("e"); while(pos > -1){ positions.push(pos); pos = stringValue.indexOf("e", pos + 1); } alert(positions); //"3,24,32,35,52" </script></head><body></body></html>这个例子通过不断增加indexOf()方法开始查找的位置，遍历了一个长字符串。在循环之外，首先找到了"e"在字符串中的初始位置；而进入循环后，则每次都给indexOf()传递上一次的位置加1。
这样，就确保了每次新搜索都从上一次找到的子字符串的后面开始。每次搜索返回的位置依次被保存在
数组positions 中，以便将来使用。
4. trim()方法
略
5. 字符串大小写转换方法
略
6. 字符串的模式匹配方法
略
7. localeCompare()方法
略
8. fromCharCode()方法
略
9. HTML 方法
略
- 第5章 引用类型（10）基本包装类型
- 引用类型(5)基本包装类型
- 引用类型---基本包装类型
- 第13章 基本包装类型
- 引用类型 与 基本包装类型
- javascript 引用类型 - 基本包装类型（深入理解基本包装类型和基本类型的区别）
- javascript基本类型 引用类型 基本包装类型
- 第五章：引用类型（基本包装类型：Boolean、Number和String）
- 你不知道的JavaScript--Item4 基本类型和基本包装类型（引用类型）
- JavaScript学习--Item4 基本类型和基本包装类型（引用类型）
- JavaScript高级程序设计之引用类型之基本包装类型第5.6讲笔记
- 浅谈JavaScript引用类型——基本包装类型
- 引用类型（三）——基本包装类型（一）
- 引用类型（四）——基本包装类型（二）
- 五、引用类型Ⅱ（RegExp、Function、基本包装类型、单体内置对象）
- DOM笔记（九）：引用类型、基本包装类型和单体内置对象
- 第5章 引用类型（5）Array 类型
- 第5章：引用类型
- 正则表达式一览表
- MySQL使用rand函数实现随机数[转]
- CMAKE安装VTK时报错
- python数据分析师面试题选
- 构造器代理 （二）
- 第5章 引用类型（10）基本包装类型
- CentOS release 6.6 (Final) 编译mesos-1.1.0
- 关于fonts.useso.com导致的页面加载过慢，有时是超时的问题。
- 运营简史：一文读懂互联网运营的20年发展与演变
- MySQL 5.7 新特性大全和未来展望
- struts2+spring Unable to instantiate Action
- Elasticsearch的中文分词插件ik
- Retrofit源码学习笔记(1)一Retrofit
- Unity3D教程之Light光源
