2.ECMAScript 基础

1.ECMAScript 语法
熟悉 Java、C 和 Perl 这些语言的开发者会发现 ECMAScript 的语法很容易掌握，因为它借用了这些语言的语法。
Java 和 ECMAScript 有一些关键的语法特性相同，也有一些完全不同。
(1)区分大小写
与 Java 一样，变量、函数名、运算符以及其他一切东西都是区分大小写的。

(2)变量是弱类型的
与 Java 和 C 不同，ECMAScript 中的变量无特定的类型，定义变量时只用 var 运算符，可以将它初始化为任意值。
因此，可以随时改变变量所存数据的类型（尽量避免这样做）。

(3)每行结尾的分号可有可无
Java、C 和 Perl 都要求每行代码以分号（;）结束才符合语法。
ECMAScript 则允许开发者自行决定是否以分号结束一行代码。
如果没有分号，ECMAScript 就把折行代码的结尾看做该语句的结尾（与 Visual Basic 和 VBScript 相似），前提是这样没有破坏代码的语义。
最好的代码编写习惯是总加入分号，因为没有分号，有些浏览器就不能正确运行。

(4)注释与 Java、C 和 PHP 语言的注释相同
有两种类型的注释：
    单行注释以双斜杠开头（//）
    多行注释以单斜杠和星号开头（/*），以星号和单斜杠结尾（*/）

(5)括号表示代码块
从 Java 中借鉴的另一个概念是代码块。
代码块表示一系列应该按顺序执行的语句，这些语句被封装在左括号（{）和右括号（}）之间。



2.ECMAScript 变量
请使用 var 运算符声明变量。变量名需要遵守一些简单的规则。

(1)声明变量
1)无需明确的类型声明
ECMAScript 中的变量是用 var 运算符（variable 的缩写）加变量名定义的。例如：
var test = "hi";
在这个例子中，声明了变量 test，并把它的值初始化为 "hi"（字符串）。
由于 ECMAScript 是弱类型的，所以解释程序会为 test 自动创建一个字符串值，无需明确的类型声明。
2)用同一个 var 语句定义的变量不必具有相同的类型
var test = "hi", age = 25;
3)不一定要初始化
var test;
4)可以存放不同类型的值
var test = "hi";
alert(test);
test = 55;
alert(test);

(2)命名变量
变量名需要遵守两条简单的规则：
    第一个字符必须是字母、下划线（_）或美元符号（$）
    余下的字符可以是下划线、美元符号或任何字母或数字字符

(3)著名的变量命名规则
1)Camel 标记法
首字母是小写的，接下来的字母都以大写字符开头。例如：
var myTestValue = 0, mySecondValue = "hi";

2)Pascal 标记法
首字母是大写的，接下来的字母都以大写字符开头。例如：
var MyTestValue = 0, MySecondValue = "hi";

3)匈牙利类型标记法
在以 Pascal 标记法命名的变量前附加一个小写字母（或小写字母序列），说明该变量的类型。例如，i 表示整数，s 表示字符串，如下所示“
var iMyTestValue = 0, sMySecondValue = "hi";
类型                                       前缀  示例
数组                                              a   aValues
布尔型                                         b   bFound
浮点型（数字）                     f   fValue
函数                                              fn  fnMethod
整型（数字）                          i   iValue
对象                                              o   oType
正则表达式                               re  rePattern
字符串                                         s   sValue
变型（可以是任何类型） v   vValue

(4)变量声明不是必须的
ECMAScript 另一个有趣的方面（也是与大多数程序设计语言的主要区别），是在使用变量之前不必声明。例如：
var sTest = "hello ";
sTest2 = sTest + "world";
alert(sTest2);
在上面的代码中，首先，sTest 被声明为字符串类型的值 "hello"。
接下来的一行，用变量 sTest2 把 sTest 与字符串 "world" 连在一起。
变量 sTest2 并没有用 var 运算符定义，这里只是插入了它，就像已经声明过它一样。

ECMAScript 的解释程序遇到未声明过的标识符时，用该变量名创建一个全局变量，并将其初始化为指定的值。



3.ECMAScript 关键字
下面是 ECMAScript 关键字的完整列表：
ECMA-262 定义了 ECMAScript 支持的一套关键字（keyword）。
这些关键字标识了 ECMAScript 语句的开头和/或结尾。根据规定，关键字是保留的，不能用作变量名或函数名
ECMAScript 关键字的完整列表：
break
case
catch
continue
default
delete
do
else
finally
for
function
if
in
instanceof
new
return
switch
this
throw
try
typeof
var
void
while
with
注意：如果把关键字用作变量名或函数名，可能得到诸如 "Identifier Expected"（应该有标识符、期望标识符）这样的错误消息。



4.ECMAScript 保留字
ECMA-262 定义了 ECMAScript 支持的一套保留字（reserved word）。
保留字在某种意思上是为将来的关键字而保留的单词。因此保留字不能被用作变量名或函数名。
ECMA-262 第三版中保留字的完整列表如下：
abstract
boolean
byte
char
class
const
debugger
double
enum
export
extends
final
float
goto
implements
import
int
interface
long
native
package
private
protected
public
short
static
super
synchronized
throws
transient
volatile

注意：如果将保留字用作变量名或函数名，那么除非将来的浏览器实现了该保留字，否则很可能收不到任何错误消息。当浏览器将其实现后，该单词将被看做关键字，如此将出现关键字错误。



5.ECMAScript 原始值和引用值
(1)原始值和引用值
在 ECMAScript 中，变量可以存在两种类型的值，即原始值和引用值。
原始值:存储在栈（stack）中的简单数据段，也就是说，它们的值直接存储在变量访问的位置。
引用值:存储在堆（heap）中的对象，也就是说，存储在变量处的值是一个指针（point），指向存储对象的内存处。
为变量赋值时，ECMAScript 的解释程序必须判断该值是原始类型，还是引用类型。
要实现这一点，解释程序则需尝试判断该值是否为 ECMAScript 的原始类型之一，即 Undefined、Null、Boolean、Number 和 String 型。
由于这些原始类型占据的空间是固定的，所以可将他们存储在较小的内存区域 - 栈中。
ECMAScript 中字符串长度不可变，与JAVA String一样。
ECMAScript 有 5 种原始类型（primitive type），即 Undefined、Null、Boolean、Number 和 String。

(2)原始类型
ECMAScript 提供了 typeof 运算符来判断一个值是否在某种类型的范围内。
可以用这种运算符判断一个值是否表示一种原始类型：如果它是原始类型，还可以判断它表示哪种原始类型。



6.ECMAScript 原始类型
ECMAScript 有 5 种原始类型（primitive type），即 Undefined、Null、Boolean、Number 和 String。

(1)typeof 运算符
typeof 运算符有一个参数，即要检查的变量或值。
案例
var sTemp = "test string";
//输出 "string"
alert (typeof sTemp); 
//输出 "number" 
alert (typeof 86);
对变量或值调用 typeof 运算符将返回下列值之一：
undefined - 如果变量是 Undefined 类型的
boolean - 如果变量是 Boolean 类型的
number - 如果变量是 Number 类型的
string - 如果变量是 String 类型的
object - 如果变量是一种引用类型或 Null 类型的
  
  
(2)Undefined 类型
Undefined 类型只有一个值，即 undefined。当声明的变量未初始化时，该变量的默认值是 undefined。
案例一:typeof未初始化的变量返回undefined
var oTemp;
alert(oTemp == undefined);  //输出 true
alert(typeof oTemp2);       //输出 undefined
提示：值 undefined 并不同于未定义的值。但是，typeof 运算符并不真正区分这两种值。
案例二:只有typeof可以用在未声明的变量上
var oTemp;
alert(oTemp2 == undefined); //引起错误
除typeof外，其他运算符只能用于已声明的变量上。
所以判断一个变量是否未定义使用 if(typeof oTemp2 == "undefined")

(3)Null 类型
另一种只有一个值的类型是 Null，它只有一个专用值 null，即它的字面量。
值 undefined 实际上是从值 null 派生来的，因此 ECMAScript 把它们定义为相等的。
alert(null == undefined);  //输出 "true"
尽管这两个值相等，但它们的含义不同。undefined 是声明了变量但未对其初始化时赋予该变量的值，null 则用于表示尚未存在的对象。
提示:null 被认为是对象的占位符

(4)Boolean 类型
Boolean 类型是 ECMAScript 中最常用的类型之一。它有两个值 true 和 false （即两个 Boolean 字面量）。
即使 false 不等于 0，0 也可以在必要时被转换成 false，这样在 Boolean 语句中使用两者都是安全的。
var bFound = true;
var bLost = false;

(5)Number 类型
1)ECMA-262 中定义的最特殊的类型是 Number 类型。这种类型既可以表示 32 位的整数，还可以表示 64 位的浮点数。
直接输入的（而不是从另一个变量访问的）任何数字都被看做 Number 类型的字面量。
案例:
var iNum = 86;

2)八进制数和十六进制数
整数也可以被表示为八进制（以 8 为底）或十六进制（以 16 为底）的字面量。
八进制字面量的首数字必须是 0，其后的数字可以是任何八进制数字（0-7）
var iNum = 070;  //070 等于十进制的 56

3)十六进制的字面量，首位数字必须为 0，后面接字母 x，然后是任意的十六进制数字（0 到 9 和 A 到 F）。这些字母可以是大写的，也可以是小写的。
var iNum = 0x1f;  //0x1f 等于十进制的 31
var iNum = 0xAB;  //0xAB 等于十进制的 171
提示：尽管所有整数都可以表示为八进制或十六进制的字面量，但所有数学运算返回的都是十进制结果。

4)浮点数
要定义浮点值，必须包括小数点和小数点后的一位数字（例如，用 1.0 而不是 1）。这被看作浮点数字面量。例如：
var fNum = 5.0;
对于浮点字面量的有趣之处在于，用它进行计算前，真正存储的是字符串。

5)科学计数法
对于非常大或非常小的数，可以用科学计数法表示浮点数，可以把一个数表示为数字（包括十进制数字）加 e（或 E），后面加乘以 10 的倍数。例如：
var fNum = 5.618e
该符号表示的是数 56180000。把科学计数法转化成计算式就可以得到该值：5.618 x (10的7次方)
也可以用科学计数法表示非常小的数，例如 0.00000000000000008 可以表示为 8-e17（这里，10 被升到 -17 次冥，意味着需要被 10 除 17 次）
提示：也可用 64 位 IEEE 754 形式存储浮点值，这意味着十进制值最多可以有 17 个十进制位。17 位之后的值将被裁去，从而造成一些小的数学误差。

6)特殊的 Number 值
Number.MAX_VALUE 和 Number.MIN_VALUE，它们定义了 Number 值集合的外边界。
所有 ECMAScript 数都必须在这两个值之间。不过计算生成的数值结果可以不落在这两个值之间。
当计算生成的数大于 Number.MAX_VALUE 时，它将被赋予值 Number.POSITIVE_INFINITY，意味着不再有数字值。
同样，生成的数值小于 Number.MIN_VALUE 的计算也会被赋予值 Number.NEGATIVE_INFINITY，也意味着不再有数字值。
如果计算返回的是无穷大值，那么生成的结果不能再用于其他计算。

有专门的值表示无穷大，（如你猜到的）即 Infinity。Number.POSITIVE_INFINITY 的值为 Infinity。Number.NEGATIVE_INFINITY 的值为 -Infinity。

由于无穷大数可以是正数也可以是负数，所以可用一个方法判断一个数是否是有穷的（而不是单独测试每个无穷数）。
可以对任何数调用 isFinite() 方法，以确保该数不是无穷大。例如：
var iResult = iNum * some_really_large_number;
if (isFinite(iResult)) {
    alert("finite");
}
else {
    alert("infinite");
}

NaN，表示非数（Not a Number）。NaN 是个奇怪的特殊值。一般说来，这种情况发生在类型（String、Boolean 等）转换失败时。
例如，要把单词 blue 转换成数值就会失败，因为没有与之等价的数值。与无穷大一样，NaN 也不能用于算术计算。
NaN 的另一个奇特之处在于，它与自身不相等，这意味着下面的代码将返回 false：
alert(NaN == NaN);  //输出 "false"
出于这个原因，不推荐使用 NaN 值本身。函数 isNaN() 会做得相当好：
alert(isNaN("blue"));  //输出 "true"
alert(isNaN("666"));  //输出 "false"

(6)String 类型
1)字符串字面量是由双引号（"）或单引号（'）声明的。
Java 则是用双引号声明字符串，用单引号声明字符。但是由于 ECMAScript 没有字符类型，所以可使用这两种表示法中的任何一种。
var sColor1 = "red";
var sColor2 = 'red';

2)长度
字符串中每个字符都有特定的位置，首字符从位置 0 开始，第二个字符在位置 1，依此类推。这意味着字符串中的最后一个字符的位置一定是字符串的长度减 1：

3)ECMAScript 的字符字面量：
字面量      含义
\n      换行
\t      制表符
\b      空格
\r      回车
\f      换页符
\\      反斜杠
\'      单引号
\"      双引号
\0nnn   八进制代码 nnn 表示的字符（n 是 0 到 7 中的一个八进制数字）
\xnn    十六进制代码 nn 表示的字符（n 是 0 到 F 中的一个十六进制数字）
\unnnn  十六进制代码 nnnn 表示的 Unicode 字符（n 是 0 到 F 中的一个十六进制数字）



6.ECMAScript 类型转换
所有程序设计语言最重要的特征之一是具有进行类型转换的能力。
ECMAScript 给开发者提供了大量简单的类型转换方法。
大部分类型具有进行简单转换的方法，还有几个全局方法可以用于更复杂的转换。
无论哪种情况，在 ECMAScript 中，类型转换都是简短的一步操作。

(1)转换成字符串
1)ECMAScript 的 Boolean 值、数字和字符串的原始值的有趣之处在于它们是伪对象，这意味着它们实际上具有属性和方法。
例如，要获得字符串的长度，可以采用下面的代码：
var sColor = "red";
alert(sColor.length);   //输出 "3"

2)Boolean 类型的 toString() 方法只是输出 "true" 或 "false"，结果由变量的值决定：
var bFound = false;
alert(bFound.toString());   //输出 "false"

3)Number 类型的 toString()
比较特殊，它有两种模式，即默认模式和基模式。采用默认模式，toString() 方法只是用相应的字符串输出数字值（无论是整数、浮点数还是科学计数法）
var iNum1 = 10;
var iNum2 = 10.0;
alert(iNum1.toString());    //输出 "10"
alert(iNum2.toString());    //输出 "10"
注释：在默认模式中，无论最初采用什么表示法声明数字，Number 类型的 toString() 方法返回的都是数字的十进制表示。
因此，以八进制或十六进制字面量形式声明的数字输出的都是十进制形式的。
采用 Number 类型的 toString() 方法的基模式，可以用不同的基输出数字，例如二进制的基是 2，八进制的基是 8，十六进制的基是 16。
基只是要转换成的基数的另一种加法而已，它是 toString() 方法的参数：
var iNum = 10;
alert(iNum.toString(2));    //输出 "1010"
alert(iNum.toString(8));    //输出 "12"
alert(iNum.toString(16));   //输出 "A"
注释：对数字调用 toString(10) 与调用 toString() 相同，它们返回的都是该数字的十进制形式。

(2)转换成数字
ECMAScript 提供了两种把非数字的原始值转换成数字的方法，
parseInt() 和 parseFloat():前者把值转换成整数，后者把值转换成浮点数。
只有对 String 类型调用这些方法，它们才能正确运行；对其他类型返回的都是 NaN。
注意：
1)parseInt() 方法首先查看位置 0 处的字符，判断它是否是个有效数字；如果不是，该方法将返回 NaN，不再继续执行其他操作。
但如果该字符是有效数字，该方法将查看位置 1 处的字符，进行同样的测试。这一过程将持续到发现非有效数字的字符为止。
此时 parseInt() 将把该字符之前的字符串转换成数字。
也就是说：如果一个字符串不符合Number，并不一定输出NaN
var iNum1 = parseInt("12345red");   //返回 12345
var iNum1 = parseInt("0xA");    //返回 10
var iNum1 = parseInt("56.9");   //返回 56
var iNum1 = parseInt("red");    //返回 NaN
2)parseInt() 方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。
基是由 parseInt() 方法的第二个参数指定的，所以要解析十六进制的值，需如下调用 parseInt() 方法：
var iNum1 = parseInt("AF", 16); //返回 175
3)如果十进制数包含前导 0，那么最好采用基数 10，这样才不会意外地得到八进制的值。例如：
var iNum1 = parseInt("010");    //返回 8
var iNum2 = parseInt("010", 8); //返回 8
var iNum3 = parseInt("010", 10);    //返回 10

parseFloat()

parseFloat() 方法与 parseInt() 方法的处理方式相似。
从位置 0 开始查看每个字符，直到找到第一个非有效的字符为止，然后把该字符之前的字符串转换成整数。
不同于parseInt():
1)对于这个方法来说，第一个出现的小数点是有效字符。如果有两个小数点，第二个小数点将被看作无效的。
parseFloat() 会把这个小数点之前的字符转换成数字。
2)字符串必须以十进制形式表示浮点数，而不是用八进制或十六进制。该方法会忽略前导 0，所以八进制数 0102 将被解析为 102。
对于十六进制数 0xA，该方法将返回 NaN，因为在浮点数中，x 不是有效字符。
此外，parseFloat() 方法也没有基模式。
使用 parseFloat() 方法的一些示例：
var fNum1 = parseFloat("12345red"); //返回 12345
var fNum2 = parseFloat("0xA");  //返回 NaN
var fNum3 = parseFloat("11.2"); //返回 11.2
var fNum4 = parseFloat("11.22.33"); //返回 11.22
var fNum5 = parseFloat("0102"); //返回 102
var fNum1 = parseFloat("red");  //返回 NaN

(3)强制类型转换
强制类型转换
您还可以使用强制类型转换（type casting）来处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
cast 有“铸造”之意，很贴合“强制转换”的意思。
ECMAScript 中可用的 3 种强制类型转换如下：
1)Boolean(value) - 把给定的值转换成 Boolean 型；
2)Number(value) - 把给定的值转换成数字（可以是整数或浮点数）；
3)String(value) - 把给定的值转换成字符串；
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。

1)Boolean() 函数
当要转换的值是至少有一个字符的字符串、非 0 数字或对象时，Boolean() 函数将返回 true。
如果该值是空字符串、数字 0、undefined 或 null，它将返回 false。
可以用下面的代码测试 Boolean 型的强制类型转换：
var b1 = Boolean("");       //false - 空字符串
var b2 = Boolean("hello");      //true - 非空字符串
var b1 = Boolean(50);       //true - 非零数字
var b1 = Boolean(null);     //false - null
var b1 = Boolean(0);        //false - 零
var b1 = Boolean(new object()); //true - 对象

2)Number() 函数
Number() 函数的强制类型转换与 parseInt() 和 parseFloat() 方法的处理方式相似，只是它转换的是整个值，而不是部分值。
用法                                          结果
Number(false)       0
Number(true)        1
Number(undefined)   NaN
Number(null)        0
Number("1.2")       1.2
Number("12")        12
Number("1.2.3")     NaN
Number(new object())NaN
Number(50)          50

3)String() 函数
String() 是最简单的，因为它可把任何值转换成字符串。
要执行这种强制类型转换，只需要调用作为参数传递进来的值的 toString() 方法，即把 12 转换成 "12"，把 true 转换成 "true"，把 false 转换成 "false"，以此类推。
强制转换成字符串和调用 toString() 方法的唯一不同之处在于，对 null 和 undefined 值强制类型转换可以生成字符串而不引发错误：
var s1 = String(null);  //"null"
var oNull = null;
var s2 = oNull.toString();  //会引发错误
在处理 ECMAScript 这样的弱类型语言时，强制类型转换非常有用，不过应该确保使用值的正确。



7.ECMAScript 引用类型
(1)引用类型
引用类型通常叫做类（class），也就是说，遇到引用值，所处理的就是对象。
注意：从传统意义上来说，ECMAScript 并不真正具有类。
事实上，除了说明不存在类，在 ECMA-262 中根本没有出现“类”这个词。
ECMAScript 定义了“对象定义”，逻辑上等价于其他程序设计语言中的类。

对象是由 new 运算符加上要实例化的对象的名字创建的。例如，下面的代码创建 Object 对象的实例：
var o = new Object();
这种语法与 Java 语言的相似，不过当有不止一个参数时，ECMAScript 要求使用括号。如果没有参数，如以下代码所示，括号可以省略：
var o = new Object;
注意：尽管括号不是必需的，但是为了避免混乱，最好使用括号。

(2)Object 对象
ECMAScript 中的 Object 对象与 Java 中的 java.lang.Object 相似，ECMAScript 中的所有对象都由这个对象继承而来，Object 对象中的所有属性和方法都会出现在其他对象中。

Object 对象具有下列属性：
constructor:对创建对象的函数的引用（指针）。对于 Object 对象，该指针指向原始的 Object() 函数。
Prototype:对该对象的对象原型的引用。对于所有的对象，它默认返回 Object 对象的一个实例。

Object 对象个方法：
hasOwnProperty(property):判断对象是否有某个特定的属性。必须用字符串指定该属性。（例如，o.hasOwnProperty("name")）
IsPrototypeOf(object):判断该对象是否为另一个对象的原型。
PropertyIsEnumerable:判断给定的属性是否可以用 for...in 语句进行枚举。
ToString():返回对象的原始字符串表示。对于 Object 对象，ECMA-262 没有定义这个值，所以不同的 ECMAScript 实现具有不同的值。
ValueOf():返回最适合该对象的原始值。对于许多对象，该方法返回的值都与 ToString() 的返回值相同。
注释：上面列出的每种属性和方法都会被其他对象覆盖。

(3)Boolean 对象
Boolean 对象是 Boolean 原始类型的引用类型。
var oBooleanObject = new Boolean(true);
Boolean 对象将覆盖 Object 对象的 ValueOf() 方法，返回原始值，即 true 和 false。ToString() 方法也会被覆盖，返回字符串 "true" 或 "false"。
遗憾的是，在 ECMAScript 中很少使用 Boolean 对象，即使使用，也不易理解。
问题通常出现在 Boolean 表达式中使用 Boolean 对象时。例如：
var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true; //输出 true
注意：虽然你应该了解 Boolean 对象的可用性，不过最好还是使用 Boolean 原始值，避免发生这一节提到的问题。

(4)Number 对象
正如你可能想到的，Number 对象是 Number 原始类型的引用类型。要创建 Number 对象，采用下列代码：
var oNumberObject = new Number(68);
方法：
1)toFixed() 方法
toFixed() 方法返回的是具有指定位数小数的数字的字符串表示。例如：
var oNumberObject = new Number(68);
alert(oNumberObject.toFixed(2));  //输出 "68.00"
toFixed() 方法能表示具有 0 到 20 位小数的数字，超过这个范围的值会引发错误。

2)toExponential() 方法
与格式化数字相关的另一个方法是 toExponential()，它返回的是用科学计数法表示的数字的字符串形式。
与 toFixed() 方法相似，toExponential() 方法也有一个参数，指定要输出的小数的位数。例如：
var oNumberObject = new Number(68);
alert(oNumberObject.toExponential(1));  //输出 "6.8e+1"

3)toPrecision() 方法
toPrecision() 方法根据最有意义的形式来返回数字的预定形式或指数形式。它有一个参数，即用于表示数的数字总数（不包括指数）。
toPrecision() 方法会对数进行舍入。
var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1));  //输出 "7e+1"
如果指定的位数多于需要的位数
var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(3));  //输出 "68.0"

toFixed()、toExponential() 和 toPrecision() 方法都会进行舍入操作，以便用正确的小数位数正确地表示一个数。
提示：与 Boolean 对象相似，Number 对象也很重要，不过应该少用这种对象，以避免潜在的问题。只要可能，都使用数字的原始表示法。

(5)String 对象
String 对象是 String 原始类型的对象表示法，它是以下方式创建的：
var oStringObject = new String("hello world");
String 对象的 valueOf() 方法和 toString() 方法都会返回 String 类型的原始值：
alert(oStringObject.valueOf() == oStringObject.toString()); //输出 "true"

1)length 属性
String 对象具有属性 length，它是字符串中的字符个数：
var oStringObject = new String("hello world");
alert(oStringObject.length);    //输出 "11"
这个例子输出的是 "11"，即 "hello world" 中的字符个数。
注意，即使字符串包含双字节的字符（与 ASCII 字符相对，ASCII 字符只占用一个字节），每个字符也只算一个字符。

2)charAt() 和 charCodeAt() 方法
String 对象还拥有大量的方法。
首先，两个方法 charAt() 和 charCodeAt() 访问的是字符串中的单个字符。这两个方法都有一个参数，即要操作的字符的位置。
charAt() 方法返回的是包含指定位置处的字符的字符串：
var oStringObject = new String("hello world");
alert(oStringObject.charAt(1)); //输出 "e"
字符代码，那么可以调用 charCodeAt() 方法：
var oStringObject = new String("hello world");
alert(oStringObject.charCodeAt(1)); //输出 "101"

3)concat() 方法
oncat() 方法，用于把一个或多个字符串连接到 String 对象的原始值上。该方法返回的是 String 原始值，保持原始的 String 对象不变：
var oStringObject = new String("hello ");
var sResult = oStringObject.concat("world");
alert(sResult);     //输出 "hello world"
alert(oStringObject);   //输出 "hello "
在上面这段代码中，调用 concat() 方法返回的是 "hello world"，而 String 对象存放的仍然是 "hello "。出于这种原因，较常见的是用加号（+）连接字符串，因为这种形式从逻辑上表明了真正的行为：
var oStringObject = new String("hello ");
var sResult = oStringObject + "world";
alert(sResult);     //输出 "hello world"
alert(oStringObject);   //输出 "hello "

4)indexOf() 和 lastIndexOf() 方法
indexOf() 和 lastIndexOf() 方法返回的都是指定的子串在另一个字符串中的位置，如果没有找不到子串，则返回 -1。
这两个方法的不同之处在于，indexOf() 方法是从字符串的开头（位置 0）开始检索字符串。
而 lastIndexOf() 方法则是从字符串的结尾开始检索子串。例如：
var oStringObject = new String("hello world!");
alert(oStringObject.indexOf("o"));      输出 "4"
alert(oStringObject.lastIndexOf("o"));  输出 "7"

5)localeCompare() 方法
下一个方法是 localeCompare()，对字符串进行排序。该方法有一个参数 - 要进行比较的字符串，返回的是下列三个值之一：
如果 String 对象按照字母顺序排在参数中的字符串之前，返回负数。
如果 String 对象等于参数中的字符串，返回 0
如果 String 对象按照字母顺序排在参数中的字符串之后，返回正数。
注释：如果返回负数，那么最常见的是 -1，不过真正返回的是由实现决定的。
如果返回正数，那么同样的，最常见的是 1，不过真正返回的是由实现决定的。
示例如下：
var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = sTestString.localeCompare("brick");
if(iResult < 0) {
  alert(oStringObject1 + " comes before " + oStringObject2);
} else if (iResult > 0) {
  alert(oStringObject1 + " comes after " + oStringObject2);
} else {
  alert("The two strings are equal");
}
在这段代码中，字符串 "yellow" 与 3 个值进行了对比，即 "brick"、"yellow" 和 "zoo"。
由于按照字母顺序排列，"yellow" 位于 "brick" 之后，所以 localeCompare() 返回 1；
"yellow" 等于 "yellow"，所以 localeCompare() 返回 0；
"zoo" 位于 "yellow" 之后，localeCompare() 返回 -1。
再强调一次，由于返回的值是由实现决定的，并不一定是1，-1, 0;

6)slice() 和 substring()
ECMAScript 提供了两种方法从子串创建字符串值，即 slice() 和 substring()。
与 concat() 方法一样，slice() 和 substring() 方法都不改变 String 对象自身的值。它们只返回原始的 String 值，保持 String 对象不变。
var oStringObject = new String("hello world");
alert(oStringObject.slice("3"));        //输出 "lo world"
alert(oStringObject.substring("3"));        //输出 "lo world"
alert(oStringObject.slice("3", "7"));       //输出 "lo w"
alert(oStringObject.substring("3", "7"));   //输出 "lo w"
事实上，这两个方法并不完全相同，不过只在参数为负数时，它们处理参数的方式才稍有不同。
对于负数参数，slice() 方法会用字符串的长度加上参数，substring() 方法则将其作为 0 处理（也就是说将忽略它）。例如：
var oStringObject = new String("hello world");
alert(oStringObject.slice("-3"));       //输出 "rld"
alert(oStringObject.substring("-3"));   //输出 "hello world"
alert(oStringObject.slice("3, -4"));        //输出 "lo w"
alert(oStringObject.substring("3, -4"));    //输出 "hel"

7)toLowerCase()、toLocaleLowerCase()、toUpperCase() 和 toLocaleUpperCase()
toLowerCase() 和 toUpperCase() 方法是原始的，是以 java.lang.String 中相同方法为原型实现的。
toLocaleLowerCase() 和 toLocaleUpperCase() 方法是基于特定的区域实现的（与 localeCompare() 方法相同）。
var oStringObject = new String("Hello World");
alert(oStringObject.toLocaleUpperCase());   //输出 "HELLO WORLD"
alert(oStringObject.toUpperCase());     //输出 "HELLO WORLD"
alert(oStringObject.toLocaleLowerCase());   //输出 "hello world"
alert(oStringObject.toLowerCase());     //输出 "hello world"
提示：记住，String 对象的所有属性和方法都可应用于 String 原始值上，因为它们是伪对象。

(6)instanceof 运算符
在使用 typeof 运算符时采用引用类型存储值会出现一个问题，无论引用的是什么类型的对象，它都返回 "object"。
ECMAScript 引入了另一个 Java 运算符 instanceof 来解决这个问题。
instanceof 运算符与 typeof 运算符相似，用于识别正在处理的对象的类型。
与 typeof 方法不同的是，instanceof 方法要求开发者明确地确认对象为某特定类型。例如：
var oStringObject = new String("hello world");
alert(oStringObject instanceof String); //输出 "true"