| Global（全局对象/属性）
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 this 全局属性 全局对象不是一个类，所以下面的全局属性在自己名称下有单独的参考条目。也就是说，在“undefined”名下可以找到undefined属性的详细信息，而不是在“Global.undefined”下寻找。注意，所有顶层变量也都是全局对象的属性。 Infinity 表示正无穷大的数值。 NaN 非数字值。 undefined 未定义的值。 全局函数 全局对象是一个对象，而不是类。下面列出的全局函数不是任何对象的方法，它们的参考条目出现在函数名下。例如，在“parseInt()”下可以找到parseInt()函数的详细信息，在“Global.parseInt()”下就无法找到该函数的详细信息。 decodeURI( ) 对encodeURI()转义的字符串解码。 decodeURIComponent( ) 对encodeURIComponent()转义的字符串解码。 encodeURI 通过转义某些字符对URl编码。 encodeURIComponent 通过转义某些字符对URI的组件编码。 escape( ) 用转义序列替换某些字符来对字符串编码。 eval( ) 计算JavaScript代码串，返回结果。 isFinite( ) 检测一个值是否是无穷大的数字。 isNaN 检测一个值是否是非数字的值。 parseFloat( ) 从字符串解析一个数字。 parseInt( ) 字符串解析一个整数。 unescape( ) 对用escape()编码的字符串解码。 全局对象 除了上面列出的全局属性和全局函数以外，全局对象还定义了引用JavaScript所有预 定义对象的属性。除了Math外，这些属性都是定义类的构造函数，Math引用的对象不是构造函数。 Array 构造函数Array()。 Boolean 构造函数Boolean()。 Date 构造函数Date()。 Error 构造函数Error()。 EvalError 构造函数EvalError()。 Function 构造函数Function()。 Math 对定义算术函数的对象的引用。 Number 构造函数Number()。 Object 构造函数Object()。 RangeError 构造函数RangeError()。 ReferenceError 构造函数RefereneeError()。 RegExp 构造函数RegExp{)。 String 构造函数String()。 SyntaxError 构造函数SyntaxError()。 TypeError 构造函数TypeError()。 URIError 构造函数URIError()。 描述 全局对象是预定义的对象，作为JavaScript的全局属性和全局函数的占位符。通过使用全局对象，可以访问其他所有预定义的对象、函数和属性。全局对象不是任何对象 的属性，所以它没有名字(之所以选择Global作为这个参考页的标题，只是为了方便 组织，并不是说全局对象名为“Global”)。在顶层lavaScript代码中，可以用关键字 this引用全局对象。但通常不必用这种方式引用全局对象，因为全局对象是作用域 链的头，这意味着所有非限定性的变量和函数名都会作为该对象的属性来查询。例如，当JavaScript代码引用parseInt()函数时，它引用的是全局对象的parstInt 属性。全局对象是作用域链的头，还意味着在顶层JavaScript代码中声明的所有变量 都将成为全局对象的属性。 全局对象只是—个对象，而不是类。既没有Global()构造函数，也无法实例化一个 新的全局对象。 当JavaScript代码嵌入一个特殊环境中时，全局对象通常具有环境特定的属性。实际上，ECMAScript标准没有规定全局对象的类型，JavaScript的实现或嵌入的 JavaScript都可以把任意类型的对象作为全局对象，只要该对象定义了这里列出的基 本属性和函数。例如，在客户端lavagcript中，全局对象是Window对象，表示运行 JavaScript代码的Web浏览器窗口。 示例 在JavaScript核心语言中，全局对象的预定义属性都是不可枚举的，所以可以用for/in循环列出所有隐式或显式声明的全局变量，如下所示： var variables = "" for(var name in this) { variables += name + "\n"; } |
|
可用性 JavaScript 1.3; JScript 3.0; ECMAScript v1 语法 Infinity 描述 nfinity是一个全局属性，它用来存放表示正无穷大的特殊的数值。用for/in循环 不能枚举Infinity属性，用delete运算符不能删除它。注意，Infinity不是常 量，它可以设为其他值。(但Number.POSITIVE_INFINITY是常量。) 参阅 isFinite( ), NaN, Number.POSITIVE_INFINITY |
|
可用性 JavaScript 1.3; JScript 3.0; ECMAScript v1 语法 NaN 描述 NaN是全局属性，引用特殊的非数字值。用for/in循环不能枚举出NaN属性，用 delete运算符不能删除它。注意，NaN不是常量，可以用任意值设置它。 要判断一个值是否是数字，只能用isNaN()函数，因为NaN与所有值都不相等，包括它自己。 参阅 Infinity, isNaN( ), Number.NaN |
|
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 undefined 描述 undefined是全局属性，存放JavaScript的undefined值。它与尝试读取不存在的对象属性的值时返回的值相同。用for/in循环不能枚举出undefined属性，用 delete运算符也不能删除它。注意，undefined不是常量，可以设置为其他值。 只能用==运算符测试一个值是否是未定义的，因为==运算符认为undefined值等价于null。 |
Code（编码/解码操作）
可用性
JavaScript 1.5; JScript 5.5; ECMAScript v3
语法
decodeURI( uri)
参数
uri
一个字符串，含有编码的URI或要其他要解码的文本。
返回值
url的副本，其中十六进制的转义序列被它们表示的字符替换了。
抛出
URIError
说明uti中的一个或多个转义序列被错误地格式化，不能被正确解码。
描述
decodeURI()是一个全局函数，它返回参数uri解码后的副本。它将保留encodeURI() 方法执行的编码操作，详见该函数。
参阅
decodeURIComponent( ), encodeURI( ), encodeURIComponent( ), escape( ), unescape( )
| decodeURIComponent( ) |
URI组件中的未转义字符 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 decodeURI(s) 参数 s 一个字符串，含有编码URl组件或其他要解码的文本。 返回值 s的副本，其中十六进制的转义序列被它们所表示的字符替换。 抛出 URIError 说明s中的一个或多个转义序列被错误地格式化，不能被正确解码。 描述 decodeURIComponent()是一个全局函数，它返回参数s解码后的副本。它将保留encodeURIComponent()方法执行的编码操作，详见该函数的参考页。 参阅 decodeURI( ), encodeURI( ), encodeURIComponent( ), escape( ), unescape( ) |
|
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 encodeURI(uri) 参数 uri 一个字符串，含有URl或其他要编码的文本。 返回值 uri的副本，其中某些字符被十六进制的转义序列替换了。 抛出 URIError 说明uri中含有格式化错误的Unicode替代对，不能被编码。 描述 encodeURI()是全局函数，返回参数uri的编码副本。ASCII的字母和数字不编码， 此外下面的ASCII标点符号也不编码： - _ . ! ~ * ' ( ) 因为encodeURI()的目的是给URl进行完整的编码，所以以下在URl中具有特殊含 义的ASCII标点符号也不转义： ; / ? : @ & = + $ , # uri中的其他字符都将转换成它的UTF—8编码字符，然后用十六进制的转义序列(形式为%xx)对生成的一个、两个或三个字节的字符编码，用它们替换uri中原有的字 符。在这种编码模式中，ASCII字符由一个%xx转义字符替换，在\u0080到\u07ff 之间编码的字符由两个转义序列替换，其他的16位Unicode字符由三个转义序列替 换。 如果使用该方法编码URl，应该确保URI组件(如查询字符串)中不含有URl分隔符，如?和#。如果组件中含有这些符号，应该用encodeURIComponent()方法分别 对各个组件编码。 用方法decodeURI()可以对该方法进行解码操作。在ECMAScriptv3之前，可以用 escape()和unescape()方法(反对使用)执行相似的编码解码操作。 示例 // 返回 http://www.isp.com/app.cgi?arg1=1&arg2=hello%20world encodeURI("http://www.isp.com/app.cgi?arg1=1&arg2=hello world"); encodeURI("\u00a9"); // 版权字符编码为 %C2%A9 参阅 decodeURI( ), decodeURIComponent( ), encodeURIComponent( ), escape( ), unescape( ) |
| encodeURIComponent( ) |
转义URI组件中的字符 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 encodeURIComponent(s) 参数 s 一个字符串，含有URI的一部分或其他要编码的文本。 返回值 s的副本，其中某些字符被十六进制的转义序列替换了。 抛出 URIError 说明s中含有格式化错误的Unicode替代对，不能被编码。 描述 encodeURIComponent()是全局函数，返回参数s的编码副本。ASCII的字母和数字不编码，此外下面的ASCII标点符号也不编码： - _ . ! ~ * ' ( ) 其他字符(如“／”、“：”、“#”这样用于分隔URI各种组件的标点符号)，都由一个或多个十六进制的转义序列替换。关于使用的编码模式，请参阅“encodeURI()”的 描述。 注意encodeURIComponent()和encodeURI()之间的差别，前者假定它的参数是URl的一部分(如协议、主机名、路径或查询字符串)。因此，它将转义用于分隔URl各个部分的标点符号。 示例 encodeURIComponent("hello world?"); // 返回 hello%20world%3F 参阅 decodeURI( ), decodeURIComponent( ), encodeURI( ), escape( ), unescape( ) |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1; ECMAScript v3反对使用 语法 escape(s) 参数 s 要被转义或编码的字符串。 返回值 编码了的s的副本，其中某些字符被替换成了十六进制的转义序列。 描述 escape()是全局函数。它返回一个含有s的编码版本的新字符串。s自身并没有被修改。 在escape()返回的字符串中，除了ASCII字母、数字和标点符号@、*、_、+、-、.、和\之外，所有字符都由形为%xx或%uxxxx(x表示十六进制的数字)的转义序列 替代。从\u0000到\u00ff的Unicode字符由转义序列%xx替代，其他所有Unicode 字符由%uxxxx序列替代。 使用函数unescape()可以对escape()编码的字符串进行解码。 在客户端JavaScript中，escape()通常是对cookie值编码，它们含有的标点符号具有限制。参阅客户端参考手册部分的“Document.cookie”参考页。 虽然ECMAScript的第一个版本标准化了escape()函数，但是ECMAScriptv3反对使用该方法，并从标准中删除了它。ECMAScript的实现可能实现了该函数，但它不是必需的。在JavaScript 1.5和JScript 5.5及其后的版本中，应该用encodeURI()和 encodeURIComponent()代替escape()。 示例 escape("Hello World!"); // 返回 "Hello%20World%21" 参阅 encodeURI( ), encodeURIComponent( ), String, escape( ); Document.cookie in the client-side reference section |
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1; ECMAScript v3反对使用
语法
unescape(s)
参数
s
要解码或“反转义”的字符串。
返回值
s解码后的一个副本。
描述
unescape()是全局函数，对escape()编码的字符串解码。该函数是通过找到形式为 %xx和%uxxxx的字符序列(这里x表示十六进制的数字)，用Unicode字符\uOOxx 和\uxxxx替换这样的字符序列进行解码的。
虽然ECMAScript的第一个版本标准化了unescape()，但ECMAScriptv3从标准中删除了它，反对使用该方法。虽然ECMAScript的实现可能实现了该函数，但这不是必需的。在JavaScript 1.5和JScript 5.5及其后的版本中，应该用decodeURI()和decodeURIComponent()代替unescape()。详见“escape()”。
参阅
decodeURI( ), decodeURIComponent( ), escape( ), String
|
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 继承于 Error 构造函数 new URIError( ) new URIError(message) 参数 message 提供异常细节的错误消息(可选)。如果设置了该参数，它将作为URIError对象的message属性的值。 返回值 新构造的URIError对象。如果指定了参数message,该Error对象将它作为message 属性的值，否则，它将用实现定义的默认字符串作为该属性的值。如果不用new运算符，而把URIError()构造函数当作函数调用，它的行为与使用new运算符调用时一样。 属性 message 提供异常细节的错误消息。该属性存放传递给构造函数的字符串，或存放实现定义的默认字符串。详见“Error.message”。 name 声明异常类型的字符串。所有URIError对象的name属性都继承值“URIError”。 描述 如果指定的字符串含有不合法的十六进制转义序列，则decodeURI()或decodeURIComponent()方法就会抛出URIError类的实例。如果指定的字符串含有不合法的 Unicode替代对，encodeURI()或encodeURIComponent()方法也会抛出该异常。关于抛出和捕捉异常的细节，请参阅“Error”。 参阅 Error, Error.message, Error.name |
Eval（Eval方法）
| eval( ) |
执行字符串中的JavaScript代码 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 eval(code) 参数 code 执行字符串中的JavaScript代码。 返回值 计算code得到的值(如果存在的话)。 抛出 SyntaxError 说明code中没有合法的JavaScript表达式或语句。 EvalError 说明非法调用了eval()，例如使用的标识符不是“eval”。参阅下面描述的对该 函数的限制。 其他异常 如果传递给eval()的JavaScript代码生成了一个异常，eval()将把那个异常传递给调用者。 描述 eval()是全局方法，它将执行含有JavaScript代码的字符串。如果code含有一个表达式，eval()将计算这个表达式，并返回它的值。如果code含有一个或多个JavaScript语句，eval()将执行这些语句，如果最后一个语句有返回值，它还会返回这个值。如果code没有返回任何值，eval()将返回undefined。最后，如果code 抛出了一个异常，eval()将把这个异常传递给调用者。 虽然eval()给JavaScript语言提供了非常强大的功能，但在实际程序中极少用它。常见的用法是编写作为递归的JavaScript解释器的程序，或者编写动态生成并计算 JavaScript代码的程序。 大部分使用字符串参数的JavaScript函数和方法都会接受其他类型的参数，在继续操作之前把这些参数值转换成字符串。但eval()的行为不是这样。如果code参数不是原始的字符串，它将不作任何改变地返回。所以，要注意，当打算传递给eval()原始字符串值时，不要粗心地给它传递String对象。 考虑到实现的效率，ECMAScriptv3标准给eval()方法的使用加上了一条与众不同的限制。如果试图覆盖eval属性或把eval()方法赋予另一个属性，并通过该属性调用它，则ECMAScript实现允许抛出一个EvalError异常。 示例 eval("1+2"); // 返回 3 // 用客户端JavaScrlpt的方法提示用户输入表达式并显示出计算结果 // 详见客户端的方法Window.alert()和Window.prompt() try { alert("Result: " + eval(prompt("Enter an expression:",""))); } catch(exception) { alert(exception); } var myeval = eval; // 抛出EvalError异常 myeval("1+2"); //抛出EvalError异常 |
| EvalError |
在不正确使用eval()时抛出 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 从…继承/覆盖 继承于 Error 构造函数 new EvalError( ) new EvalError(message) 参数 message 提供异常的详细信息的错误消息，可选。如果设置了该参数，它将用作EvalError对象的message属性的值。 返回值 新构造的EvalError对象。如果指定了参数message，Error对象将用它作为message 属性的值，否则，它将用实现定义的默认字符串作为该属性的值。如果把 EvalError()构造函数当作函数调用且不带有new运算符，它的行为与使用new运算符调用时一样。 属性 message 提供异常的详细信息的错误消息。该属性存放传递给构造函数的字符串，或存放实现定义的默认字符串。详见“Error.message”。 name 声明异常类型的字符串。所有EvalError对象的name属性都继承值“EvalError”。 描述 当在其他名称下调用全局函数eval()时，EvalError类的一个实例就会被抛出。关于调用eval()函数的限制，请参阅“eval()”。关于抛出和捕捉异常的细节，请参阅 “Error”。 参阅 Error, Error.message, Error.name |
Variant（数据类型操作）
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 parseFloat(s) 参数 s 要被解析并转换成数字的字符串。 返回值 解析后的数字，如果字符串s没有以一个有效的数字开头，则返回NaN。在JavaScript 1.0中，当s不能被解析成数字时，parseFloat()返回的是0而不是NaN。 描述 方法parseFloat()将对字符串s进行解析，返回出现在s中的第一个数字。当parseFloat()在s中遇到了一个不是有效数字的字符时，解析过程就停止了，解析的结果也将在此时返回。如果s的开头是一个parseFloat()不能解析的数字，该函数将返回NaN。可以用函数isNaN()来检测这个值。如果只想解析数字的整数部分，则使用parseInt()方法而不是parseFloat()方法。 Bug NaN不受JavaScript 1.0的支持，所以在该版本中，当它不能解析s时，parseFloat()返回零。这意味着在JavaScript 1.0中，如果parseFloat()的返回值为0，必须对s 执行额外的测试，以决定它表示为零还是根本不表示任何数。 参阅 isNaN( ), parseInt( ) |
|
可用性 JavaScript 1.0; JScript 1.1; ECMAScript v1 语法 parseInt(s) parseInt(s, radix) 参数 s 被解析的字符串。 radix 可选的整数参数，表示要解析的数字的基数。如果省略了该参数或者它的值为0，数字将以10为基数来解析。如果它以“Ox”或“OX'’开头，则以16为基数。 如果该参数小于2或大于36，则parseInt()返回NaN。 返回值 解析后的数字，如果字符串s不是以一个有效的整数开头，则返回NaN。在JavaScript 1.0中，当parseInt()不能解析s时，它返回的是0而不是NaN。 描述 方法parseInt()将对字符串s进行解析，并且返回出现在s中的第一个数字(可以具有减号)。当parseInt()在s中遇到的字符不是指定的基数radix可以使用的有 效数字时，解析过程就停止，解析的结果也将在此时返回。如果s的开头是parseInt()不能解析的数字，该函数将返回NaN。可以用函数isNaN()来检测这个 值。 参数radix指定的是要解析成的数字的基数。如果将它设置为10，parseInt()就会 将字符串解析成十进制的数。将它设置为8，那么解析的结果就是八进制(使用0～ 7八个数字)的数。将它设置为16，解析的结果就是十六进制(使用数字0—9和字 母A—F表示)的值。radix的值可以是2～36之间的任意一个整数。 如果radix的值为0，或者没有设置radix的值，那么parseInt()将根据字符串s 来判断数字的基数。如果s(在可选的减号后)以0x开头，那么parseInt()将把s 的其余部分解析成十六进制的整数。如果s以0开头，那么ECMAScriptv3标准允许 parseInt()的一个实现把其后的字符解析成八进制的数字或十进制的数字。如果s 以1—9之间的数字开头，parseInt()将把它解析成十进制的整数。 示例 parseInt("19", 10); // 返回 19 (10 + 9) parseInt("11", 2); // 返回 3 (2 + 1) parseInt("17", 8); // 返回 15 (8 + 7) parseInt("1f", 16); // 返回 31 (16 + 15) parseInt("10"); // 返回 10 parseInt("0x10"); // 返回 16 parseInt("010"); //不明确：返回10或8 Bug 在没有指定radix时，ECMAScriptV3允许实现将以“0”(但不是“OX”或“OX”) 开头的字符串解析为八进制或十进制的数。要避免这种二义性，应该明确指定基数，或只有确定所有要解析的数字都是以“OX”或“OX”开头的十进制数或十六进制数 时，才可以不指定基数。 JavaScript 1.0不支持NaN，所以在这个版本中，当parseInt()不能解析s时，返回0而不是NaN。在JavaScript 1.0中，parseInt()不能区分错误的输入与合法的输入“0”。 参阅 isNaN( ), parseFloat( ) |
可用性
JavaScript 1.1; JScript 1.0; ECMAScript v1
语法
isNaN(x)
参数
x
要检测的值。
返回值
如果x是特殊的非数字值NaN(或者能被转换为这样的值)，返回值就是true。如果 x是其他值，返回值是false。
描述
isNaN()可以通过检测参数来判断值是否是NaN，该值表示一个非法的数字(如被0 除后得到结果)。这个函数是必需的，因为把NaN与任何值(包括它自身)进行比较 得到的结果都是false，所以要检测一个值是否是NaN，不能使用==或===运算符
isNaN()通常用于检测方法parseFloat()和parseInt()的结果，以判断它们表示的是否是合法数字。也可以用isNaN()来检测算术错误，如用0作除数。
示例
isNaN(0); // 返回 false
isNaN(0/0); // 返回 true
isNaN(parseInt("3")); // 返回 false
isNaN(parseInt("hello")); // 返回 true
isNaN("3"); // 返回 false
isNaN("hello"); // 返回 true
isNaN(true); // 返回 false
isNaN(undefined); // 返回 true
参阅
isFinite( ), NaN, Number.NaN, parseFloat( ), parseInt( )
| Array.toString( ) |
将数组转换成一个字符串 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 从…继承/覆盖 Overrides Object.toString( ) 语法 array.toString( ) 返回值 array的字符串表示。 抛出 TypeError 调用该方法时，若对象不是Array，则抛出该异常。 描述 数组的toString()方法将把数组转换成一个字符串，并且返回这个字符串。当数组 用于字符串环境中时，JavaScript会调用这一方法将数组自动转换成一个字符串。但 在某些情况下，需要明确地调用这个方法。 toString()在把数组转换成字符串时，首先要将数组的每个元素都转换成字符串 (通过调用这些元素的toString()方法)。当每个元素都被转换成字符串时，它就以 列表的形式输出这些字符串，字符串之间用逗号分隔。返回值与没有参数的join() 方法返回的字符串相同。 Bug 在Netscape实现中，如果把语言版本明确地设置为1.2，toString()将会返回用逗号和空格分隔的数组元素列表，这个列表采用数组直接量表示法，用方括号括起元素。例如，在把<script>标记的language性质明确地设置为“JavaScript l.2”时， 就会发生这种情况。 参阅 Array.toLocaleString( ), Object.toString( ) |
| Boolean.toString( ) |
将布尔值转换成字符串 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 从…继承/覆盖 覆盖 Object.toString( ) 语法 b.toString( ) 返回值 根据原始布尔值或者Boolean对象b存放的值返回字符串"true"或"false"。 抛出 TypeError 如果调用该方法时，对象不是Boolean，则抛出该异常。 |
| Date.toDateString( ) |
返回Date对象日期部分作为字符串 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 date.toDateString( ) 返回值 date的日期部分的字符串表示，由实现决定，可以读懂，以本地时间表示。 参阅 Date.toLocaleDateString( ), Date.toLocaleString( ), Date.toLocaleTimeString( ), Date.toString( ),Date.toTimeString( ) |
| Date.toGMTString( ) |
将Date转换为世界时字符串 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1; deprecated by ECMAScript v3 语法 date.toGMTString( ) 返回值 Date对象date所指定的日期和时间的字符串表示。这个日期在转换成字符串之前由本地时区转换成了GMT时区。 描述 不赞成使用方法toGMTString()，而赞同使用Date.toUTCString()。 从ECMAScriptv3起，JavaScript的实现不再要求使用该函数，而用toUTCString()代替它。 参阅 Date.toUTCString( ) |
| Date.toLocaleDateString( ) |
返回Date对象的日期部分作为本地已格式化的字符串 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 date.toLocaleDateString( ) 返回值 date的日期部分的字符串表示，由实现决定，可以读懂，以本地时间表示，根 据本地规约格式化。 参阅 Date.toDateString( ), Date.toLocaleString( ), Date.toLocaleTimeString( ), Date.toString( ), Date.toTimeString( ) |
|
| Date.toLocaleString( ) |
将Date转换为本地已格式化的字符串 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.toLocaleString( ) 返回值 Date对象dace指定的日期和时间的字符串表示。该日期和时间用本地时间区表示， 根据本地规约格式化。 用法 方法toLocaleString()可以将日期转换成用本地时间区表示的字符串。该方法的日期和时间格式还使用地方规约，所以在不同平台上以及不同国家之间，日期和时间的格式都有所不同。它返回的字符串格式通常都是用户想要的日期和时间格式。 参阅 Date.toLocaleDateString( ), Date.toLocaleTimeString( ), Date.toString( ), Date.toUTCString( ) |
|
| Date.toLocaleTimeString( ) |
返回Date对象的时间部分作为本地已格式化的字符串 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 date.toLocaleTimeString( ) 返回值 date的时间部分的字符串表示，由实现决定，可以读取的，以本地时区表示，根 据本地规约格式化。 参阅 Date.toDateString( ), Date.toLocaleDateString( ), Date.toLocaleString( ), Date.toString( ), Date.toTimeString( ) |
|
| Date.toString( ) |
将Date转换为字符串 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 覆盖 Object.toString( ) 语法 date.toString( ) 返回值 date的字符串表示，是人们可以读取的，用本地时间表示。 描述 方法toStrzng()返回一个人们可以读取的、由实现决定的日期的字符串表示。它与 toUTCString()的不同，toString()以本地时间表示日期。而它与toLocaleString()的不同之处在于它不使用地方规约采用的形式表示日期和时间。 参阅 Date.parse( ), Date.toDateString( ), Date.toLocaleString( ), Date.toTimeString( ), Date.toUTCString( ) |
|
| Date.toTimeString( ) |
返回Date对象日期部分作为字符串 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 date.toTimeString( ) 返回值 date的时间部分的字符串表示，由实现决定，可以读取；以本地时间表示。 参阅 Date.toString( ), Date.toDateString( ), Date.toLocaleDateString( ), Date.toLocaleString( ),Date.toLocaleTimeString( ) |
|
| Date.toUTCString( ) |
将Date转换为字符串(世界时) |
| |
|
|
| |
|
|
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.toUTCString( ) 返回值 date的字符串表示，可以读取，用世界时表示。 描述 方法toUTCString()返回一个人们可以读取的、由实现决定的日期的字符串表示。它以世界时表示。 参阅 Date.toLocaleString( ), Date.toString( )
| Error.toString( ) |
把Error对象转换成字符串 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 从…继承/覆盖 覆盖 Object.toString( ) 语法 error.toString( ) 返回值 实现定义的字符串。ECMAScript标准除了规定该方法的返回值是字符串外，没有再 做其他规定。尤其是，它不要求返回的字符串包含错误名或错误消息。 |
| Function.toString( ) |
把函数转换成字符串 |
可用性 JavaScript 1.0; JScript 2.0; ECMAScript v1 语法 function.toString( ) 返回值 表示函数的字符串。 抛出 TypeError 如果调用该函数的对象不是Function，则抛出该异常。 描述 Function对象的方法toString()可以以一种与实现相关的方式将函数转换成字符串。 在Netscape实现中，该方法返回一个含有有效JavaScript代码的字符串，即包括关键字function、参数列表和函数的完整主体的代码。 |
| Number.toLocaleString( ) |
把数字转换成本地格式的字符串 |
可用性 JavaScript 1.5; JScript 5.5, ECMAScript v3 语法 number.toLocaleString( ) 返回值 数字的字符串表示，由实现决定，根据本地规范进行格式化。可能影响到小数点或千分位分隔符采用的标点符号。 抛出 TypeError 调用该方法的对象不是Number时抛出的异常。 参阅 Number.toExponential( ), Number.toFixed( ), Number.toPrecision( ), Number.toString( ) |
|
| Number.toString( ) |
将—个数字转换成字符串 |
可用性 JavaScript 1.1; JScript 2.0, ECMAScript v1 从…继承/覆盖 覆盖 Object.toString( ) 语法 number.toString(radix) 参数 radix 可选的参数，指定表示数字的基数，是2～36之间的整数。如果省略了该参数， 使用基数10。但要注意，如果该参数是10以外的其他值，则ECMAScript标准 允许实现返回任意值。 返回值 数字的字符串表示。 抛出 TypeError 调用该方法的对象不是Number时抛出的异常。 描述 Number对象的方法toString()可以将数字换成字符串。当省略了radix参数或指定它的值为10时，该数字将被转换成基数为10的字符串。如果radix是其他值，该方法将返回由实现定义的字符串。Netscape实现和JScript 3.0后的Microsoft实现都支持radix参数，并返回以指定基数表示的字符串。 参阅 Number.toExponential( ), Number.toFixed( ), Number.toLocaleString( ), Number.toPrecision( ) |
| Object.toString( ) |
定义一个对象的字符串表示 |
可用性 JavaScript 1.0; JScript 2.0; ECMAScript v1 语法 object.toString( ) 返回值 表示对象的字符串。 描述 这里的方法toString()并不是在JavaScript程序中经常显示调用的那个toString()方法。它是在对象中定义的一个方法，当系统需要把对象转换成字符串时就会调用它。 当在字符串环境中使用对象时，JavaScript系统就会调用toString()方法把那个对象转换成字符串。例如，假定—个函数期望得到的参数是字符串，那么把对象传递给它时，系统就会将这个对象转换成字符串： alert(my_object); 同样，在用运算符“+”连接字符串时，对象也会被转换成字符串： var msg = 'My object is: ' + my_object; 调用方法toStrlng()时不给它传递任何参数，它返回的应该是一个字符串。要使这个字符串有用，它的值就必须以调用toString()方法的对象的值为基础。 当用JavaScript自定义一个类时，为这个类定义一个toString()方法很有用。如果没有给它定义toString()方法，那么这个对象将继承Object类的默认toString()方法。这个方法返回的字符串形式如下： [object class] 这里，class是一个对象类，其值可以是“Object”、“String”、“Number”、“Function”、 “Window”、“Document”，等等。这种行为有时对确定未知对象的类型或类有用。但由于大多数对象都有自定义的tostring()版本，所以必须明确地对对象o调用 Object.toString()，代码如下所示： Object.prototype.toString.apply(o); 注意，这种识别未知对象的方法只适用于内部对象。如果你定义了自己的对象类，那么它的类是“Object”。在这种情况下，可以用Obiect.constructor属性获取更多有关对象的信息。 在调试JavaScript程序时，toString()方法非常有用，使用它可以输出对象，查看它们的值。因此，为你创建的每个对象类都定义toString()方法很有用。 虽然tostring()方法通常由系统自动调用，但你也可以自己调用它。例如，在JavaScript不能自动把对象转换成字符串的环境中，可以明确地调用toString()方法来实现这一点： y = Math.sqrt(x); // 计算一个数 ystr = y.toString( ); // 转换为—个字符串 注意，在这个例子中，数字具有内部的toStrlng()方法，可以用该方法进行强制性的转换。 在其他的环境中，即使JavaScript可以自动地进行转换，你也可以调用toString()方法，因为对toString()的明确调用可以使代码更加清晰： alert(my_obj.toString( )); 参阅 Object.constructor, Object.toLocaleString( ), Object.valueOf( )
| RegExp.toString( ) |
把正则表达式转换成字符串 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 从…继承/覆盖 覆盖 Object.toString( ) 语法 regexp.toString( ) 返回值 regexp的字符串表示。 抛出 TypeError 调用该方法的对象不是RegExp时，抛出该异常。 描述 RegExp.toString()方法将以正则表达式直接量的形式返回正则表达式的字符串表示。 注意，不允许用实现添加转义序列，这样可以确保返回的字符串是合法的正则表达式直接量。考虑由表达式new RegExp("/","g")创建的正则表达式。RegExp.toString()的一种实现对该正则表达式返回“///g”，此外它还能添加转义序列，返回“/\//g”。 |
|
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 Overrides Object.toString( ) 语法 string.toString( ) 返回值 string的原始字符串值。一般不会调用该方法。 抛出 TypeError 调用该方法的对象不是String时抛出该异常。 参阅 String.valueOf( ) |
Object（对象超类）
| Object |
含有所有JavaScript对象的特性的超类 |
| Object.constructor |
对象的构造函数 |
| Object.hasOwnProperty( ) |
检查属性是否被继承 |
| Object.isPrototypeOf( ) |
一个对象是否是另一个对象的原型 |
| Object.propertyIsEnumerable( ) |
是否可以通过for/in循环看到属性 |
| Object.toLocaleString( ) |
返回对象的本地字符串表示 |
| Object.toString( ) |
定义一个对象的字符串表示 |
| Object.valueOf( ) |
指定对象的原始值 |
| Object |
含有所有JavaScript对象的特性的超类 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 构造函数 new Object( ) new Object(value) 参数 value 可选的参数，声明了要转换成Number对象、Boolean对象或String对象的原始值(即数字、布尔值或字符串)。JavaScript 1.1之前的版本和ECMAScript Vl不支持该对象。 返回值 如果没有给构造函数传递value参数，那么它将返回一个新创建的Object实例。如果指定了原始的value参数，构造函数将创建并返回原始值的包装对象，即Number对象、Boolean对象或String对象。当不使用new运算符，将Object()构造函数作为函数调用时，它的行为与使用new运算符时一样。 属性 constructor 对一个JavaScript函数的引用，该函数是对象的构造函数。 方法 hasOwnProperty( ) 检查对象是否有局部定义的(非继承的)、具有特定名字的属性。 isPrototypeOf( ) 检查对象是否是指定对象的原型。 propertyIsEnumerable( ) 检查指定的属性是否存在，以及是否能用for/in循环枚举。 toLocaleString( ) 返回对象地方化的字符串表示。该方法的默认实现只调用toString()方法，但子类可以覆盖它，提供本地化。 toString( ) 返回对象的字符串表示。Object类提供的该方法的实现相当普通，并且没有提供更多有用的信息。Object的子类通过定义自己的toString()方法覆盖了这一方法(toString()方法能够生成更有用的结果)。 valueOf( ) 返回对象的原始值(如果存在)。对于类型为Object的对象，该方法只返回对象自身。Object的子类(如Number和Boolean)覆盖了该方法，返回的是与对象相关的原始数值。 描述 Object类是JavaScript语言的内部数据类型。它是其他JavaScript对象的超类，因此其他对象都继承了Object类的方法和行为。 除了用上面所示的Object()构造函数，还可以用Object直接量语法创建并初始化对象。 参阅 Array, Boolean, Function, Function.prototype, Number, String |
|
| Object.constructor |
对象的构造函数 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 语法 object.constructor 描述 对象的constructor属性引用了该对象的构造函数。例如，如果用Array()构造函 数创建一个数组，那么a.constructor引用的就是Array： a = new Array(1,2,3); // 创建一个对象 a.constructor == Array //计算结果为true onstructor属性常用于判断未知对象的类型。给定了一个未知的值，就可以使用typeof运算符来判断它是原始的值还是对象。如果它是对象，就可以使用constructor属性来判断对象的类型。例如，下面的函数用来判断一个给定的值是否是数组： function isArray(x) { return ((typeof x == "object") && (x.constructor == Array)); } 但是要注意，虽然这种方法适用于JavaScript核心语言的内部对象，但对于“主对象”，如Window这样的客户端JavaScript对象，这种方法就不一定适用了。Object.toString()方法的默认实现提供了另一种判断未知对象类型的方法。 参阅 Object.toString( ) |
|
|
| |
|
|
|
|
| Object.hasOwnProperty( ) |
检查属性是否被继承 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 object.hasOwnProperty(propname) 参数 propname 一个字符串，包含object的属性名。 返回值 如果object有propname指定的非继承属性，则返回true。如果object没有名为 propname指定的属性，或者它从原型对象继承了这一属性，则返回false。 描述 JavaScript对象既可以有自己的属性，又可以从原型对象继承属性。 hasOwnProperty()方法提供了区分继承属性和非继承的局部属性的方法。 示例 var o = new Object( ); // 创建对象 o.x = 3.14; // 定义非继承的局部属性y o.hasOwnProperty("x"); // 返回 true: x 是O的局部属性 o.hasOwnProperty("y"); // 返回 false: o 没有属性y o.hasOwnProperty("toString"); // 返回 false: toString属性是继承的 参阅 Function.prototype, Object.propertyIsEnumerable( )
| Object.isPrototypeOf( ) |
一个对象是否是另一个对象的原型 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 object.isPrototypeOf(o) 参数 o 任意对象。 返回值 如果object是O的原型，则返回true。如果o不是对象，或者object不是o的原 型，则返回false。 描述 JavaScript对象继承了原型对象的属性。一个对象的原型是通过用于创建并初始化该对象的构造函数的prototype属性引用的。isPrototypeOf()方法提供了判断一个对象是否是另一个对象原型的方法。该方法可以用于确定对象的 类。 示例 var o = new Object( ); // 创建一个对象 Object.prototype.isPrototypeOf(o) // true: o 是一个对象 Function.prototype.isPrototypeOf(o.toString); // true: toString 是一个函数 Array.prototype.isPrototypeOf([1,2,3]); // true: [1,2,3] 是一个数组 //下面是执行同样测试的另一种方法 (o.constructor == Object); // true: o was created with Object( ) constructor (o.toString.constructor == Function); // true: o.toString is a function /原型则对象本身于原型对象。下面的调用返回true //说明函数继 Function.prototype和Object.prototyp属性. Object.prototype.isPrototypeOf(Function.prototype); 参阅 Function.prototype, Object.constructor |
| Object.propertyIsEnumerable( ) |
是否可以通过for/in循环看到属性 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 object.propertyIsEnumerable(propname) 参数 propname 一个字符串，包含object原型的名字。 返回值 如果object具有名为propname的非继承属性，而且该属性是可枚举的(即用for/in循环可以枚举出它)，则返回true。 描述 用for/in语句可以遍历一个对象“可枚举”的属性。但并非—个对象的所有属性都是可枚举的，通过JavaScript代码添加到对象的属性是可枚举的，而内部对象的预定义属性(如方法)通常是不可枚举的。propertylsEnumerable()方法提供了区分可枚举属性和不可枚举属性的方法。但要注意，ECMAScript标准规定，propertyIsEnumerable()方法不检测原型链，这意味着它只适用于对象的局部属性，不能检测继承属性的可枚举性。 示例 var o = new Object( ); // 创建一个对象 o.x = 3.14; // 定义—个属性 o.propertyIsEnumerable("x"); // true属性x是局部的、可枚举的 o.propertyIsEnumerable("y"); //false：o没有属性y o.propertyIsEnumerable("toString"); //false：toStrlng属性是继承的 Object.prototype.propertyIsEnumerable("toString"); // false: 枚举的 Bug 当标准限制propertylsEnumerable()方法只能检测非继承属性时，明显是错的。 Internet Explorer 5.5按标准实现了该方法。Nestacpe 6.0实现的propertyIsEnumerable()方法考虑了原型链。虽然这种方法可取，但它与标准冲突，所以Netscape 6.1修改了它，以便与IE 5.5匹配。由于标准中有这个错误，因此该方法不是那么有用。 参阅 Function.prototype, Object.hasOwnProperty( ) |
| Object.toLocaleString( ) |
返回对象的本地字符串表示 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 object.toString( ) 返回值 表示对象的字符串。 描述 该方法用于返回对象的字符串表示，本地化为适合本地的形式。Object类提供的默认的toLocaleString()方法只调用toString()方法，返回非本地化的字符串。但其他类(包括Array、Date和Number)定义了自己的toLocaleString()版本，指定本地化字符串的转换。在定义自己的类时，也可以覆盖该方法。 参阅 Array.toLocaleString( ), Date.toLocaleString( ), Number.toLocaleString( ), Object.toString( )
| Object.toString( ) |
定义一个对象的字符串表示 |
可用性 JavaScript 1.0; JScript 2.0; ECMAScript v1 语法 object.toString( ) 返回值 表示对象的字符串。 描述 这里的方法toString()并不是在JavaScript程序中经常显示调用的那个toString()方法。它是在对象中定义的一个方法，当系统需要把对象转换成字符串时就会调用它。 当在字符串环境中使用对象时，JavaScript系统就会调用toString()方法把那个对象转换成字符串。例如，假定—个函数期望得到的参数是字符串，那么把对象传递给它时，系统就会将这个对象转换成字符串： alert(my_object); 同样，在用运算符“+”连接字符串时，对象也会被转换成字符串： var msg = 'My object is: ' + my_object; 调用方法toStrlng()时不给它传递任何参数，它返回的应该是一个字符串。要使这个字符串有用，它的值就必须以调用toString()方法的对象的值为基础。 当用JavaScript自定义一个类时，为这个类定义一个toString()方法很有用。如果没有给它定义toString()方法，那么这个对象将继承Object类的默认toString()方法。这个方法返回的字符串形式如下： [object class] 这里，class是一个对象类，其值可以是“Object”、“String”、“Number”、“Function”、 “Window”、“Document”，等等。这种行为有时对确定未知对象的类型或类有用。但由于大多数对象都有自定义的tostring()版本，所以必须明确地对对象o调用 Object.toString()，代码如下所示： Object.prototype.toString.apply(o); 注意，这种识别未知对象的方法只适用于内部对象。如果你定义了自己的对象类，那么它的类是“Object”。在这种情况下，可以用Obiect.constructor属性获取更多有关对象的信息。 在调试JavaScript程序时，toString()方法非常有用，使用它可以输出对象，查看它们的值。因此，为你创建的每个对象类都定义toString()方法很有用。 虽然tostring()方法通常由系统自动调用，但你也可以自己调用它。例如，在JavaScript不能自动把对象转换成字符串的环境中，可以明确地调用toString()方法来实现这一点： y = Math.sqrt(x); // 计算一个数 ystr = y.toString( ); // 转换为—个字符串 注意，在这个例子中，数字具有内部的toStrlng()方法，可以用该方法进行强制性的转换。 在其他的环境中，即使JavaScript可以自动地进行转换，你也可以调用toString()方法，因为对toString()的明确调用可以使代码更加清晰： alert(my_obj.toString( )); 参阅 Object.constructor, Object.toLocaleString( ), Object.valueOf( ) |
| Object.valueOf( ) |
指定对象的原始值 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 语法 object.valueOf( ) 返回值 与对象object相关的原始值(如果存在)。如果没有值与object相关，则返回对象自身。 描述 对象的valueOf()方法返回的是与那个对象相关的原始值(如果这样的值存在)。对于类型为Object的对象来说，由于它们没有原始值，因此该方法返回的是这些对象自身。 对于类型为Number的对象，valueOf()返回该对象表示的原始数值。同样，对于Boolean对象来说，该方法返回与对象相关的布尔值。对于String对象来说，返回与 对象相关的字符串。 其实，几乎没有必要自己调用valueOf()方法。在期望使用原始值的地方，JavaScript会自动地执行转换。事实上，由于方法valueOf()是被自动调用的，因此要分辨究 竟是原始值还是与之相应的对象非常困难。虽然使用typeof运算符可以显示字符串和String对象之间的区别，但在实际应用中，它们在JavaScript代码中的作用是一样的。 Number对象、Boolean对象和String对象的valueOf()方法可以将这些包装对象转 换成它们表示的原始值。在调用构造函数Obioct()时，如果把数字、布尔值或字符 串作为参数传递给它，它将执行相反的操作，即将原始值打包成相应的对象。几乎在所有的环境中，JavaScript都可以自动地实现原始值和对象之间的转换，所以一般说 来没有必要用这种方法调用构造函数Object()。 在某些环境中，你可以为自己的对象定制一个valueOf()方法。例如，你可以定义 一个JavaScript对象来表示复数(即一个实数加一个虚数)。作为这个对象的一部分， 要给它定义执行复数的加法、乘法等其他运算的方法。不过，还有一种功能是你想要的，即像处理常规实数一样处理复数，舍弃它的虚数部分。可以使用下面的代码实现 这一点： Complex.prototype.valueOf = new Function("return this.real"); 有了这个为Complex对象定义的valueOf()方法，就可以把复数对象传递给方法 Math.sqrt()，它将计算复数的实数部分的平方根。 参阅 Object.toString( ) |
Arguments（函数参数对象）
| arguments[ ] |
函数参数的数组 |
|
| Arguments |
一个函数的参数和其他属性 |
|
| Arguments.callee |
当前正在运行的函数 |
|
| Arguments.length |
传递给函数的参数的个数 |
|
|
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 语法 arguments 描述 arguments[]数组只在函数体内定义。在函数体内，arguments引用该函数的 Arguments对象。该对象有带编号的属性，并作为一个存放传递给函数的所有参数的 数组。标识符arguments本质上是一个局部变量，在每个函数中都会被自动声明并 初始化。它只在函数体中才能引用Arguments对象，在全局代码中没有定义。 参阅 Arguments |
|
|
| Arguments |
一个函数的参数和其他属性 |
|
|
| |
|
|
|
|
|
| |
|
|
|
|
|
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 从…继承/覆盖 继承于 Object 语法 arguments arguments[n] 元素 Arguments对象只在函数体中定义。虽然技术上说来，它不是数组，但Arguments对 象有带编号的属性，这些属性可以作为数组元素，而且它有length属性，该属性声 明了数组元素的个数。它的元素是作为参数传递给函数的值。元素0是第—个参数， 元素1是第二个参数，以此类推。所有作为参数传递的值都会成为Arguments对象的 数组元素，无论函数声明中是否有这些参数的名字。 属性 callee 对当前正在执行的函数的引用。 length 传递给函数的参数个数，同时也是Arguments对象中的数组元素个数。 描述 当一个函数被调用时，会为该函数创建一个Arguments对象，局部变量arguments也 会自动地初始化以便引用那个Arguments对象。Arguments对象的主要用途是提供一 种方法，用来确定传递给函数的参数个数并且引用未命名的参数。除了数组元素和属 性length之外，属性callee可以使未命名的函数引用自身。 大多数情况下，可以将Arguments对象看做是具有callee属性的数组。但它不是Array类的实例，Arguments.1ength属性没有Array.1ength属性的专有行为，所以不能用它来改变数组的大小。 Arguments对象有一个非常特殊的特性。当函数具有命名的参数时，Arguments对象的数组元素是存放函数参数的局部变量的同义词。Arguments对象和参数名提供了引用同一个变量的两种不同方法。用参数名改变参数值，会改变用Arguments对象得到的值，改变用Arguments对象得到的参数值，也会改变用参数名得到的值。 参阅 Function
| Arguments.callee |
当前正在运行的函数 |
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v1 语法 arguments.callee 描述 属性arguments.callee引用当前正在运行的函数。它给未命名的函数提供了一种自 我引用的方式。该属性只在函数体内被定义。 示例 //一个未命名的函数直接量使用callee属性引用它自身 // 以便它能够递归 var factorial = function(x) { if (x < 2) return 1; else return x * arguments.callee(x-1); } var y = factorial(5); // 返回 120
| Arguments.length |
传递给函数的参数的个数 |
可用性 JavaScript 1.1; JScript 2; ECMAScript v1 语法 arguments.length 描述 Arguments对象的属性length声明了传递给当前函数的参数的个数。该属性只在函数体内被定义。 注意：这个属性声明的是实际传递给函数的参数个数，而不是期望传递的参数个数。还要注意该属性不具备Array.length属性的专有行为。 示例 // 使用Arguments对象来检查是否正确传递了#参数 function check(args) { var actual = args.length; //参数的实际个数 var expected = args.callee.length; //期望的参数个数 if (actual != expected) { //如果他们不匹配，则抛出异常 throw new Error("Wrong number of arguments: expected: " + expected + "; actually passed " + actual); } } //一个演示如何使用以上函数的函数 function f(x, y, z) { check(arguments); // 检查参数个数是否正确 return x + y + z; // 继续使用函数 } 参阅 Array.length, Function.length |
Array（数组对象）
| Array |
对数组的内部支持 |
| Array.concat( ) |
连接数组 |
| Array.join( ) |
将数组元素连接起来以构建一个字符串 |
| Array.length |
数组的大小 |
| Array.pop( ) |
删除并返回数组的最后一个元素 |
| Array.push( ) |
给数组添加元素 |
| Array.reverse( ) |
颠倒数组中元素的顺序 |
| Array.shift( ) |
将元素移出数组 |
| Array.slice( ) |
返回数组的一部分 |
| Array.sort( ) |
对数组元素进行排序 |
| Array.splice( ) |
插入、删除或替换数组的元素 |
| Array.toLocaleString( ) |
把数组转换成局部字符串 |
| Array.toString( ) |
将数组转换成一个字符串 |
| Array.unshift( ) |
在数组头部插入一个元素 |
|
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 从…继承/覆盖 继承于 Object 构造函数 new Array( ) new Array(size) new Array(element0, element1, ..., elementn) 参数 size 期望的数组元素个数。返回的数组，1ength域将被设为size的值。 element0, ... elementn 两个或多个值的参数列表。当使用这些参数来调用构造函数Array()时，新创建的数组的元素就会被初始化为这些值，它的length域也会被设置为参数的个数。 返回值 新创建并被初始化了的数组。如果调用构造函数Array()时没有使用参数，那么返回的数组为空，length域为0。当调用构造函数时只传递给它一个数字参数，该构造函数将返回具有指定个数、元素为undefined的数组。当用其他参数调用Array{)时， 该构造函数将用参数指定的值初始化数组。当把构造函数作为函数调用，不使用new运算符时，它的行为与使用new运算符调用它时的行为完全一样。 抛出 RangeError 当只传递给Array()构造函数一个整数参数size时，如果size是负数，或者大子232 -1，将抛出RangeError异常。 直接量语法 ECMAScript v3规定了数组直接量的语法，JavaScript 1.2和JScript 3.0实现了它。可以把—个用逗号分隔的表达式列表放在方括号中，创建并初始化—个数组。这些表达式的值将成为数组元素。例如： var a = [1, true, 'abc']; var b = [a[0], a[0]*2, f(x)]; 属性 length 一个可读可写的整数，声明了数组中的元素个数。如果数组中的元素不连续，它就是比数组中的最后—个元素的下标大1的整数。改变这个属性的值将截断或扩展数组。 方法 concat( ) 给数组添加元素。 join( ) 将数组中所有元素都转换为字符串，然后连接在一起。 pop( ) 从数组尾部删除一个项目。 push( ) 把一个项目添加到数组的尾部。 reverse( ) 在原数组上颠倒数组中元素的顺序。 shift( ) 将数组的头部元素移出数组头部。 slice( ) 返回一个数组的子数组。 sort( ) 在原数组上对数组元素进行排序。 splice( ) 插入、删除或替换一个数组元素。 toLocaleString( ) 把数组转换为一个局部字符串。 toString( ) 把数组转换为字符串。 unshift( ) 在数组的头部插入一个元素。 描述 数组是JavaScript的基本语句特性。 参阅 |
|
|
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 语法 array.concat(value, ...) 参数 value, ... 要增加到array中的值，可以是任意多个。 返回值 一个新数组，是 描述 方法concat()将创建并返回一个新数组，这个数组是将所有参数都添加到array中生成的。它并不修改array。如果要进行concat()操作的参数是一个数组，那么添加的是数组中的元素，而不是数组。 示例 var a = [1,2,3]; a.concat(4, 5) //返回 [1,2,3,4,5] a.concat([4,5]); //返回 [1,2,3,4,5] a.concat([4,5],[6,7]) //返回 [1,2,3,4,5,6,7] a.concat(4, [5,[6,7]]) //返回 [1,2,3,4,5,[6,7]] 参阅 Array.join( ), Array.push( ), Array.splice( ) |
|
|
| |
|
|
|
|
| Array.join( ) |
将数组元素连接起来以构建一个字符串 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 语法 array.join( ) array.join(separator) 参数 separator 在返回的字符串中用于分隔数组元素的字符或字符串，它是可选的。如果省略了这个参数，用逗号作为分隔符。 返回值 —个字符串，通过把array的每个元素转换成字符串，然后把这些字符串连接起来，在两个元素之间插入separator字符串而生成。 描述 方法join()将把每个数组元素转换成一个字符串，然后把这些字符串连接起来，在两个元素之间插入指定的separator字符串。返回生成的字符串。 可以用String对象的split()方法执行相反的操作，即把一个字符串分割成数组元素。 示例 a = new Array(1, 2, 3, "testing"); s = a.join("+"); // s 是字符串"1+2+3+testing" 参阅 String.split( ) |
|
可用性 JavaScript 1.1, JScript 2.0; ECMAScript v1 语法 array.length 描述 数组的length属性总是比数组中定义的最后一个元素的下标大一。对于那些具有连续元素，而且以元素0开始的常规数组来说，属性length声明了数组中的元素个数。 数组的length属性在用构造函数Array()创建数组时初始化。给数组添加新元素时，如果必要，将更新length的值： a = new Array( ); // a.length 被初始化为 0 b = new Array(10); // b.length 被初始化为 10 c = new Array("one", "two", "three"); // c.length 被初始化为 3 c[3] = "four"; // c.length 被更新为 4 c[10] = "blastoff"; // c.length 变为 11 设置属性length的值可以改变数组的大小。如果设置的值比它的当前值小，数组将被截断，其尾部的元素将丢失。如果设置的值比它的当前值大，数组将增大，新元素被添加到数组尾部，它们的值为undefined。 |
| Array.pop( ) |
删除并返回数组的最后一个元素 |
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v3 语法 array.pop( ) 返回值 array的最后一个元素。 描述 方法pop()将删除array的最后一个元素，把数组长度减1，并且返回它删除的元素的值。如果数组已经为空，则pop()不改变数组，返回undefined。 示例 方法pop()和方法push()可以提供先进后出(FILO)栈的功能。例如： var stack = []; // 栈：[] stack.push(1, 2); // 栈: [1,2] 返回 2 stack.pop( ); // 栈: [1] 返回 2 stack.push([4,5]); // 栈: [1,[4,5]] 返回 2 stack.pop( ) // 栈: [1] 返回 [4,5] stack.pop( ); // 栈: [] 返回 1 参阅 Array.push( ) |
|
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v3 语法 array.push(value, ...) 参数 value, ... 要添加到array尾部的值，可以是一个或多个。 返回值 把指定的值添加到数组后的新长度。 描述 方法push()将把它的参数顺次添加到array的尾部。它直接修改array,而不是创 建——个新的数组。方法push()和方法pop()用数组提供先进后出栈的功能。参阅 “Array.pop()”中的示例。 Bug 在JavaScript的Netscape实现中，如果把语言版本明确地设置为1.2，该函数将返回 最后添加的值，而不是返回新数组的长度。 参阅 Array.pop( ) |
| Array.reverse( ) |
颠倒数组中元素的顺序 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 语法 array.reverse( ) 描述 Array对象的方法reverse()将颠倒数组中元素的顺序。它在原数组上实现这一操 作，即重排指定的array的元素，但并不创建新数组。如果对array有多个引用，那么通过所有引用都可以看到数组元素的新顺序。 示例 a = new Array(1, 2, 3); // a[0] == 1, a[2] == 3; a.reverse( ); // Now a[0] == 3, a[2] == 1; |
| Array.shift( ) |
将元素移出数组 |
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v3 语法 array.shift( ) 返回值 数组原来的第一个元素。 描述 方法shift()将把array的第—个元素移出数组，返回那个元素的值，并且将余下 的所有元素前移一位，以填补数组头部的空缺。如果数组是空的，shift()将不进行 任何操作，返回undefined。注意，该方法不创建新数组，而是直接修改原有的数组。 方法shift()和方法Array.pop()相似，只不过它在数组头部操作，而不是在尾部 操作。该方法常常和unshift()一起使用。 示例 var a = [1, [2,3], 4] a.shift( ); // 返回 1; a = [[2,3], 4] a.shift( ); // 返回 [2,3]; a = [4] 参阅 Array.pop( ), Array.unshift( )
|
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 语法 array.slice(start, end) 参数 start 数组片段开始处的数组下标。如果是负数，它声明从数组尾部开始算起的位置。 也就是说，-1指最后一个元素，-2指倒数第二个元素，以此类推。 end 数组片段结束处的后一个元素的数组下标。如果没有指定这个参数 包含从start开始到数组结束的所有元素。如果这个参数是负数， 从数组尾部开始算起的元素。 返回值 一个新数组，包含从start到end(不包括该元素)指定的array元素。 描述 方法slice()将返回数组的一部分，或者说是一个子数组。返回的数组包含从start 开始到end之间的所有元素，但是不包括end所指的元素。如果没有指定end，返回 的数组包含从start开始到原数组结尾的所有元素。 注意：该方法并不修改数组。如果想删除数组中的一段元素，应该使用方法Array.splice。 示例 var a = [1,2,3,4,5]; a.slice(0,3); // 返回 [1,2,3] a.slice(3); // 返回 [4,5] a.slice(1,-1); // 返回 [2,3,4] a.slice(-3,-2); // 返回 [3]; IE 4存在的Bug: 返回[1,2,3] Bug 在Internet Explorer 4中，参数start不能为负数。 参阅 Array.splice( ) |
| Array.sort( ) |
对数组元素进行排序 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 语法 array.sort( ) array.sort(orderfunc) 参数 orderfunc 用来指定按什么顺序进行排序的函数，可选。 返回值 对数组的引用。注意，数组在原数组上进行排序，不制作副本。 描述 方法sort()将在原数组上对数组元素进行排序，即排序时不创建新的数组副本。如 果调用方法sort()时没有使用参数，将按字母顺序(更为精确地说，是按照字符编 码的顺序)对数组中的元素进行排序。要实现这一点，首先应把数组的元素都转换成 字符串(如果有必要的话)，以便进行比较。 如果想按照别的顺序进行排序，就必须提供比较函数，该函数要比较两个值，然后返 回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数a和b，其返回值如下：
- 如果根据你的评判标准，a小于b，在排序后的数组中a应该出现在b之前，就返回一个小于0的值。
- 如果a等于b，就返回0。
- 如果a大于b，就返回一个大于0的值。
注意，数组中undefined的元素都排列在数组末尾。即使你提供了自定义的排序函数 也是这样，因为undefined值不会被传递给你提供的orderfunc。 示例 下面的代码展示了如何编写按数字顺序，而不是按字母顺序对数组进行排序的比较函数： // 按照数字顺序排序的排序函数 function numberorder(a, b) { return a - b; } a = new Array(33, 4, 1111, 222); a.sort( ); // 按照字母顺序的排序结果为: 1111, 222, 33, 4 a.sort(numberorder); // 按照数字顺序的排序结果为: 4, 33, 222, 1111
| Array.splice( ) |
插入、删除或替换数组的元素 |
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v3 语法 array.splice(start, deleteCount, value, ...) 参数 start 开始插入和(或)删除的数组元素的下标。 deleteCount 从start开始，包括start所指的元素在内要删除的元素个数。这个参数是可选的，如果没有指定它，splice()将删除从start开始到原数组结尾的所有元素。 value, ... 要插人数组的零个或多个值，从start所指的下标处开始插入。 返回值 如果从array中删除了元素，返回的是含有被删除的元素的数组。但是要注意，由于存在—个bug，因此在JavaScriptl.2的Netscape实现中，返回的并不总是数组。 描述 方法splice()将删除从start开始(包括start所指的元素在内)的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。位于插入或删除的元素之后的数组元素都会被移动，以保持它们与数组其他元素的连续性。注意， 虽然spllce()方法与slice()方法名字相似，但作用不同，方法splice()直接修改数组。 示例 读了下面的例子，就很容易理解splice()的操作了： var a = [1,2,3,4,5,6,7,8] a.splice(4); // 返回 [5,6,7,8]; a is [1,2,3,4] a.splice(1,2); // 返回 [2,3]; a is [1,4] a.splice(1,1); // Netscape/JavaScript 1.2 返回 4 ，应该返回 [4] a.splice(1,0,2,3); // Netscape/JavaScript 1.2 返回 undefined ，应该返回 [] Bug 方法splice()假定在各种情况下均返回一个包含已删除元素的数组。但是，在 Netscape的JavaScript 1.2解释器中，如果删除的是单个元素，那么该方法返回的是 元素，而不是包含那个元素的数组。如果没有删除任何元素，它不是返回一个空数组， 而是什么都不返回。只要把语言版本明确地设置为1.2，JavaScript的Netscape实现 都有这种bug行为。 参阅 Array.slice( ) |
| Array.toLocaleString( ) |
把数组转换成局部字符串 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v1 从…继承/覆盖 覆盖 Object.toLocaleString( ) 语法 array.toLocaleString( ) 返回值 数组array的局部字符串表示。 抛出 TypeError 调用该方法时，如果对象不是Array，则抛出异常。 描述 数组的方法toString()将返回数组的局部字符串表示。它首先调用每个数组元素的toLocaleString()方法，然后用地区特定的分隔符把生成的字符串连接起来，形成一个字符串。 参阅 Array.toString( ), Object.toLocaleString( ) |
| Array.unshift( ) |
在数组头部插入一个元素 |
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v3 语法 array.unshift(value, ...) 参数 value, ... 要插入数组头部的一个或多个值。 返回值 数组的新长度 描述 方法unshift()将把它的参数插入array的头部，并将已经存在的元素顺次地移到 较高的下标处，以便留出空间。该方法的第一个参数将成为数组新的元素0，如果还 有第二个参数，它将成为新的元素1，以此类推。注意，unshift()不创建新数组， 而是直接修改原有的数组。 示例 方法unshift()通常和方法shift()一起使用。例如： var a = []; // a:[] a.unshift(1); // a:[1] 返回 1 a.unshift(22); // a:[22,1] 返回 2 a.shift( ); // a:[1] 返回 22 a.unshift(33,[4,5]); // a:[33,[4,5],1] 返回 3 参阅 Array.shift( ) |
Boolean（布尔对象）
| Boolean |
对布尔值的支持 |
|
| Boolean.toString( ) |
将布尔值转换成字符串 |
|
| Boolean.valueOf( ) |
Boolean对象的布尔值 |
|
|
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 从…继承/覆盖 继承于 Object 构造函数 new Boolean(value) //构造函数 Boolean(value) //转换函数 参数 value 由布尔对象存放的值或者要转换成布尔值的值 返回值 当作为一个构造函数(带有运算符new)调用时，Boolean()将把它的参数转换成一个布尔值，并且返回一个包含该值的Boolean对象。如果作为一个函数(不带有运算符new)调用的，Boolean()只将它的参数转换成一个原始的布尔值，并且返回这个值。 0、NaN、null、空字符串""和undefined都将转换成false。其他的原始值，除了false(但包括字符串"false")，以及其他的对象和数组都会被转换成true。 方法 toString( ) 根据Boolean对象代表的布尔值返回"true"或"false"。 valueOf( ) 返回Boolean对象中存放的原始布尔值。 描述 在JavaScript中，布尔值是一种基本的数据类型。Boolean对象是一个将布尔值打包的布尔对象。Boolean对象主要用于提供将布尔值转换成字符串的toString()方法。 当调用toString()方法将布尔值转换成字符串时(通常是由JavaScript隐式地调用)，JavaScript会内在地将这个布尔值转换成一个临时的Boolean对象，然后调用这个对象的toString()方法。 参阅 Object |
|
|
| Boolean.toString( ) |
将布尔值转换成字符串 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 从…继承/覆盖 覆盖 Object.toString( ) 语法 b.toString( ) 返回值 根据原始布尔值或者Boolean对象b存放的值返回字符串"true"或"false"。 抛出 TypeError 如果调用该方法时，对象不是Boolean，则抛出该异常。 |
|
|
|
|
| Boolean.valueOf( ) |
Boolean对象的布尔值 |
|
|
| |
|
|
|
|
|
|
| |
|
|
|
|
|
|
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 从…继承/覆盖 覆盖方法 Object.valueOf( ) 语法 b.valueOf( ) 返回值 Boolean对象b存放的原始布尔值。 抛出 TypeError 如果调用该方法时，对象不是Boolean，则抛出该异常。 Date（日期/时间对象）
| Date |
操作日期和时间的对象 |
| Date.getDate( ) |
返回一个月中的某一天 |
| Date.getDay( ) |
返回一周中的某一天 |
| Date.getFullYear( ) |
返回Date对象的年份字段 |
| Date.getHours( ) |
返回Date对象的小时字段 |
| Date.getMilliseconds( ) |
返回Date对象的毫秒字段 |
| Date.getMinutes( ) |
返回Date对象的分钟字段 |
| Date.getMonth( ) |
返回Date对象的月份字段 |
| Date.getSeconds( ) |
返回Date对象的秒字段 |
| Date.getTime( ) |
返回Date对象的毫秒表示 |
| Date.getTimezoneOffset( ) |
判断与GMT的时间差 |
| Date.getUTCDate( ) |
返回该天是一个月的哪一天(世界时) |
| Date.getUTCDay( ) |
返回该天是星期几(世界时) |
| Date.getUTCFullYear( ) |
返回年份(世界时) |
| Date.getUTCHours( ) |
返回Date对象的小时字段(世界时) |
| Date.getUTCMilliseconds( ) |
返回Date对象的毫秒字段(世界时) |
| Date.getUTCMinutes( ) |
返回Date对象的分钟字段(世界时) |
| Date.getUTCMonth( ) |
返回Date对象的月份(世界时) |
| Date.getUTCSeconds( ) |
返回Date对象的秒字段(世界时) |
| Date.getYear( ) |
返回Date对象的年份字段(世界时) |
| Date.parse( ) |
解析日期/时间字符串 |
| Date.setDate( ) |
设置一个月的某一天 |
| Date.setFullYear( ) |
设置年份，也可以设置月份和天 |
| Date.setHours( ) |
设置Date对象的小时字段、分钟字段、秒字段和毫秒字段 |
| Date.setMilliseconds( ) |
设置Date对象的毫秒字段 |
| Date.setMinutes( ) |
设置Date对象的分钟字段和秒字段 |
| Date.setMonth( ) |
设置Date对象的月份字段和天字段 |
| Date.setSeconds( ) |
设置Date对象的秒字段和毫秒字段 |
| Date.setTime( ) |
以毫秒设置Date对象 |
| Date.setUTCDate( ) |
设置一个月中的某一天(世界时) |
| Date.setUTCFullYear( ) |
设置年份、月份和天(世界时) |
| Date.setUTCHours( ) |
设置Date对象的小时字段、分钟字段、秒字段和毫秒字段(世界时) |
| Date.setUTCMilliseconds( ) |
设置Date对象的毫秒字段(世界时) |
| Date.setUTCMinutes( ) |
设置Date对象的分钟字段和秒字段(世界时) |
| Date.setUTCMonth( ) |
设置Date对象的月份字段和天数字段(世界时) |
| Date.setUTCSeconds( ) |
设置Date对象的秒字段和毫秒字段(世界时) |
| Date.setYear( ) |
设置Date对象的年份字段 |
| Date.toDateString( ) |
返回Date对象日期部分作为字符串 |
| Date.toGMTString( ) |
将Date转换为世界时字符串 |
| Date.toLocaleDateString( ) |
回Date对象的日期部分作为本地已格式化的字符串 |
| Date.toLocaleString( ) |
将Date转换为本地已格式化的字符串 |
| Date.toLocaleTimeString( ) |
返回Date对象的时间部分作为本地已格式化的字符串 |
| Date.toString( ) |
将Date转换为字符串 |
| Date.toTimeString( ) |
返回Date对象日期部分作为字符串 |
| Date.toUTCString( ) |
将Date转换为字符串(世界时) |
| Date.UTC( ) |
将Date规范转换成毫秒数 |
| Date.valueOf( ) |
将Date转换成毫秒表示 |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 从…继承/覆盖 继承于 Object 构造函数 new Date( ) new Date(milliseconds) new Date(datestring) new Date(year, month, day, hours, minutes, seconds, ms) 没有参数的构造函数Date()将把创建的Date对象设置为当前的日期和时间。如果传 递给它的参数是一个数字，那么这个数字将被作为日期的内部数字表示，其单位是毫秒，就像方法getTime()的返回值一样。如果传递给它的参数是一个字符串，它就 是日期的字符串表示，其格式就是方法Date.parse()接受的格式。否则，传递给该构造函数的参数是2～7个数字，它们分别指定了日期和时间的各个字段。除了前两 个字段(年和月字段)外，其他所有字段都是可选的。注意，声明这些日期和时间的 字段使用的都是本地时间，而不是UTC时间(类似于GMT时间)。参阅静态方法 Date.UTC()。 Date()还可以作为普通函数被调用，而不带有运算符new。以这种方式调用时， Date()将忽略传递给它的所有参数，返回当前日期和时间的字符串表示。 参数 milliseconds 期望的日期距1970年1月1日午夜(UTC)的毫秒数。例如，假定传递的参数值为5000，那么创建的Date对象代表日期的就是1970年1月1日午夜过5秒。 datestring 一个字符串，声明了日期，也可以同时声明时间。这个字符串的格式应该是方法Date.parse()能够接受的。 year 年份，一个四位数。例如，2001指的是2001年。为了与早期的JavaScript实现 兼容，如果它的值在0～99之间，则给它加上1900。 month 月份，0(代表一月)到11(代表十二月)之间的一个整数。 day 一个月的某一天，1～31之间的一个整数。注意，这个参数将1作为它的最小值 而其他参数则以0为最小值。该参数是可选的。 hours 小时，0(午夜)到23(晚上11点)之间的一个整数。该参数是可选的。 minutes 分钟，0～59之间的一个整数。该参数是可选的。 seconds 秒，0～59之间的一个整数。该参数是可选的。 ms 毫秒，0～999之间的一个整数。该参数是可选的。 方法 Date对象没有可以直接读写的属性，所有对日期和时间值的访问都是通过方法执行的。Date对象的大多数方法采用两种形式，一种是使用本地时间进行操作，另一种是使用世界(UTC或GMT)时进行操作。如果方法的名字中有“UTC"，它将使用世界时进行操作。下面将这些方法对列在一起。例如，get[UTC]Day()指方法getDay() 和getUTCDay()。 只有Date对象才能调用Date方法，如果用其他类型的对象调用这些方法，将抛出异常TypeError。 get[UTC]Date( ) 返回Date对象所代表的月中的某一天，采用本地时间或世界时。 get[UTC]Day( ) 返回Date对象所代表的一周中的某一天，采用本地时间或世界时。 get[UTC]FullYear( ) 返回日期中的年份，用四位数表示，采用本地时间或世界时。 get[UTC]Hours( ) 返回Date对象的小时字段，采用本地时间或世界时。 get[UTC]Milliseconds( ) 返回lDate对象的毫秒字段，采用本地时间或世界时。 get[UTC]Minutes( ) 返回Date对象的分钟字段，采用本地时间或世界时。 get[UTC]Month( ) 返回Date对象的月份字段，采用本地时间或世界时。 get[UTC]Seconds( ) 返回Date对象的秒字殴，采用本地时间或世界时。 getTime( ) 返回Date对象的内部毫秒表示。注意，该值独立于时区，所有没有单独的 getUTCtime()方法。 getTimezoneOffset( ) 返回这个日期的本地时间和UTC表示之间的时差，以分钟为单位。注意，是否是夏令时或在指定的日期中夏令时是否有效，将决定该方法的返回值。 getYear( ) 返回Date对象的年份。一般不使用这种方法，推荐使用的方法是getFullYear()。 set[UTC]Date( ) 设置Date对象的月中的某一天，采用本地时间或世界时。 set[UTC]FullYear( ) 设置Date对象的年份字段(月份和天数字段可选)，采用本地时间或世界时。 set[UTC]Hours( ) 设置Date对象的小时字段(分钟、秒和毫秒字段可选)，采用本地时间或世界时。 set[UTC]Milliseconds( ) 设置Date对象的毫秒字段，采用本地时间或世界时。 set[UTC]Minutes( ) 设置Date对象的分钟字段(秒和毫秒字段可选)，采用本地时间或世界时。 set[UTC]Month( ) 设置Date对象的月份字段(一个月的天数字段可选)，采用本地时间或世界时。 set[UTC]Seconds( ) 设置Date对象的秒字段(毫秒字段可选)，采用本地时间或世界时。 setTime( ) 使用毫秒的形式设置Date对象的各个字段。 setYear( ) 设置Date对象的年份字段。该方法被反对使用，推荐使用的方法是setFullYear()。 toDateString( ) 返回日期的日期部分的字符串表示，采用本地时间。 toGMTString( ) 将Date对象转换成一个字符串，采用GMT时间区。该方法被反对使用，推荐使 用的方法是toUTCString()。 toLocaleDateString( ) 返回表示日期的日期部分的字符串，采用地方日期，使用地方日期格式化规约。 toLocaleString( ) 将Date对象转换成·个字符串，采用本地时间和地方日期的格式化规约。 toLocaleTimeString( ) 返回日期的时间部分的字符串表示，采用本地时间，使用本地时间的格式化规约。 toString( ) 将Date对象转换成—个字符串，采用本地时间。 toTimeString( ) 返回日期的时间部分的字符串表示，采用本地时间。 toUTCString( ) 将Date对象转换成一个字符串，采用世界时。 valueOf( ) 将Date对象转换成它的内部毫秒格式。 静态方法 除了上面列出的实例方法之外，Date对象还定义了两个静态方法。这两个方法由构造函数Date()自身调用，而不是由Date对象调用： Date.parse( ) 解析日期和时间的字符串表示，返回它的内部毫秒表示。 Date.UTC( ) 返回指定的UTC日期和时间的毫秒表示。 描述 Date对象是JavaScript语言的一种内部数据类型。它由语法new Date()语法创建， 在前面的构造函数部分中已经说明了这种语法。 创建了Date对象后，就可以使用多种方法来操作它。大多数方法只能用来设置或者获取对象的年份字段、月份字段、天数字段、小时字段、分钟字段以及秒字段，采用本地时间或UTC(世界时或GMT)时间。方法toString()以及它的变种可以把日期转换成人们能够读懂的字符串。所谓Date对象的内部表示就是距1970年1月1日午夜(GMT时间)的毫秒数，方法getTime()可以把Date对象转换为内部表示，方法 setTime()可以把它从内部表示转换成其他形式。采用标准的毫秒格式时，日期和时间由一个整数表示，这使得日期算术变得格外简单。ECMAScript标准要求Date对象能够把1970年1月1日前后10亿天中的任意日期和时间表示为毫秒。这个范围在正 负273～785年之间，所以JavaScript的时钟不会超过275755年。 示例 一旦创建了Date对象，就可以用各种方法操作它： d = new Date( ); // 获取当前日期和时间 document.write('Today is: " + d.toLocaleDateString( ) + '. '); // 显示日期 document.write('The time is: ' + d.toLocaleTimeString( )); // 显示时间 var dayOfWeek = d.getDay( ); // 获取一周中的第几天 var weekend = (dayOfWeek == 0) || (dayOfWeek == 6); // 判断是否是周末 Date对象的另一种常见用法是用某个时间的毫秒表示减去当前时间的毫秒表示来判断 两个时间的时差。下面的例子说明了这种用法： <script language="JavaScript"> today = new Date( ); // 创建时间对象 christmas = new Date( ); // 获取当前日期对象 christmas.setMonth(11); // 把月份设置为11月 christmas.setDate(25); // 把日期设置为25号 // 如果圣诞节已经过了，计算当前日期和圣诞节之间的毫秒数 // 把它转换成天数 //输出消息 if (today.getTime( ) < christmas.getTime( )) { difference = christmas.getTime( ) - today.getTime( ); difference = Math.floor(difference / (1000 * 60 * 60 * 24)); document.write('Only ' + difference + ' days until Christmas!<p>'); } </script> // 此处是其余和HTML文档 <script language="JavaScript"> // 下面用Data对象计时 // 用1000除它，把毫秒转换成秒 now = new Date( ); document.write('<p>It took ' + (now.getTime( )-today.getTime( ))/1000 + 'seconds to load this page.'); </script> 参阅 Date.parse( ), Date.UTC( ) |
|
| Date.getDate( ) |
返回一个月中的某一天 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.getDate( ) 返回值 指定Date对象dace所指的月份中的某一天，使用本地时间。返回值是1～31之间的 一个整数。 |
|
|
|
|
|
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.getDay( ) 返回值 指定Date对象date所指的一个星期中的某一天，使用本地时间。返回值是0(周日) 到6(周六)之间的一个整数。 |
|
|
|
|
|
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getFullYear( ) 返回值 当dace用本地时间表示时返回的年份。返回值是一个四位数，表示包括世纪值在内的完整年份，而不是两位数的缩写形式。 |
|
|
|
| |
|
|
|
| |
|
|
|
|
|
|
|
| Date.getHours( ) |
返回Date对象的小时字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.getHours( ) 返回值 指定Date对象date的小时字段，以本地时间表示。返回值是0(午夜)到23(晚上 11点)之间的一个整数。 |
|
| Date.getMilliseconds( ) |
返回Date对象的毫秒字段 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getMilliseconds( ) 返回值 指定Date对象date的毫秒字段，用本地时间表示。返回值在0～999之间。 |
|
| Date.getMinutes( ) |
返回Date对象的分钟字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.getMinutes( ) 返回值 指定的Date对象date的分钟字段，以本地时间表示。返回值在0～59之间。 |
| Date.getMonth( ) |
返回Date对象的月份字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.getMonth( ) 返回值 指定的Date对象date的月份字段，以本地时间表示。返回值在0(一月)到11(十二月)之间。
| Date.getSeconds( ) |
返回Date对象的秒字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.getSeconds( ) 返回值 指定的Date对象date的秒字段，以本地时间表示。返回值在0～59之间。 |
|
|
|
|
|
|
| Date.getTime( ) |
返回Date对象的毫秒表示 |
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1
语法
date.getTime( )
返回值
指定的Date对象date的毫秒表示，也就是date指定的日期和时间距1970年1月1 日午夜(GMT时间)之间的毫秒数
描述
方法getTime()可以将日期和时间转换戍一个整数。这在比较两个Date对象或者要判断两个日期之间的时差时非常有用。注意，日期的毫秒表示独立于时区，所以除了这个方法外，没有getUTCTime()方法。不要混淆getTime()方法和getDay()及 getDate()方法，getDay()和getDate()返回的分别是一周的第几天和一个月的第几天。
可以使用Date.parse()或Date.UTC()将日期和时间转换成它们的毫秒表示，在此之前无须先创建一个Date对象。
参阅
Date, Date.parse( ), Date.setTime( ), Date.UTC( )
| Date.getTimezoneOffset( ) |
判断与GMT的时间差 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.getTimezoneOffset( ) 返回值 本地时间与GMT时间之间的时差，以分钟为单位。 描述 getTimezoneOffset()返回的是本地时间和GMT时间或UTC时间之间相差的分钟数。实际上，该函数告诉了你运行JavaScript代码的时区，以及指定的时间是否是夏令时。 返回值以分钟计，而不是以小时计，原因是某些国家所占有的时区甚至不到一个小时的间隔。 |
|
| Date.getUTCDate( ) |
返回该天是一个月的哪一天(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getUTCDate( ) 返回值 当date对象用世界时表示时，返回值是该月中的哪一天(是1～31的一个值)。 |
| Date.getUTCDay( ) |
返回该天是星期几(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getUTCDay( ) 返回值 当date对象用世界时表示时，返回值是该星期中的哪一天。该值在0(星期天)到6(星期六)之间。
| Date.getUTCFullYear( ) |
返回年份(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getUTCFullYear( ) 返回值 当date对象是用世界时表示时所代表的年份。该值是四位数，而不是两位数的缩写。 |
| Date.getUTCHours( ) |
返回Date对象的小时字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getUTCHours( ) 返回值 当date对象用世界时表示时的小时字段，该值在0(午夜)到23(晚上11点)之间。 |
| Date.getUTCMilliseconds( ) |
返回Date对象的毫秒字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getUTCMilliseconds( ) 返回值 当date对象是用世界时表示时的毫秒字段。 |
| Date.getUTCMinutes( ) |
返回Date对象的分钟字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getUTCMinutes( ) 返回值 dsce对象用世界时表示时的分钟字段，该值是0～59之间的整数。
| Date.getUTCMonth( ) |
返回Date对象的月份(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getUTCMonth( ) 返回值 当date对象用世界时表示时的月份，该值是0(一月)到11(十二月)之间的一个整数。注意，Date对象以1代表某个月的第一天，而不是像月份字段那样使用0代表一年的第一个月。 |
| Date.getUTCSeconds( ) |
返回Date对象的秒字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.getUTCSeconds( ) 返回值 当dace对象用世界时表示时的秒字段，该值是0～59之间的—个整数。 |
| Date.getYear( ) |
返回Date对象的年份字段(世界时) |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1; ECMAScript v3反对使用 语法 date.getYear( ) 返回值 指定Date对象date的年份字段减去1900。 描述 方法getyear()返回的是指定的Date对象的年份字段减去1900后的值。从 ECMAScriptv3起，JavaScript的实现就不再要求使用该函数，而使用getFullYear() 函数代替它。 Bug 在JavaScriptl.0到1.2的Netscape实现中，只将1900和1999之间的年份减去1900。
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Date.parse(date) 参数 date 含有要解析的日期和时间的字符串。 返回值 指定的日期和时间距1970年1月1日午夜(GMT时间)之间的毫秒数。 描述 Date.parse()是Date对象的静态方法。一般通过Date构造函数，采用Date.parse()的形式调用它，而不是通过date对象，采用date.parse()调用该方法。 Date.parse()只有一个字符串型的参数。它将解析这个字符串中的日期，然后返回它的毫秒形式，这种形式可以直接使用，也可以用于创建一个新的Date对象，还可以用Date.setTime()方法来设置一个已经存在的日期。 ECMAScript标准没有规定Date.parse()方法解析的字符串的格式，只是说该方法能解析Date.toString()方法和Date.toUTCString()方法返回的字符串。但是，这些函数根据实现来格式化日期，所以以某种方式编写所有JavaScript实现都能理解的日期是不可能的。 参阅 Date, Date.setTime( ), Date.toGMTString( ), Date.UTC( ) |
|
| Date.setDate( ) |
设置一个月的某一天 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.setDate(day_of_month) 参数 day_of_month 1～31之间的整数，作为date中月中某一天字段的新值(以本地时间计)。 返回值 调整过的日期的毫秒表示。在ECMAScript标准化之前，该方法什么都不返回。 |
| Date.setFullYear( ) |
设置年份，也可以设置月份和天 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setFullYear(year) date.setFullYear(year, month) date.setFullYear(year, month, day) 参数 year 在date中设置的年份，用本地时间表示。该参数应该是一个包含世纪值的完整年份，如1999，而不仅是年份的缩写，如99。 month 可选的整数，在0～11之间，用作date的月份字段的新值(以本地时间计)。 day 可选的整数，在1～31之间，用作date的天数字段的新值(以本地时间计)。 返回值 调整过的日期的内部毫秒表示。 |
| Date.setHours( ) |
设置Date对象的小时字段、分钟字段、秒字段和毫秒字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.setHours(hours) date.setHours(hours, minutes) date.setHours(hours, minutes,seconds) date.setHours(hours, minutes, seconds, millis) 参数 hours 0(午夜)到23(晚上11点)之间的整数，用作date的小时宇段的新值(以本地时间计)。 minutes 可选的整数，在0～59之间，用作date的分钟字段的新值(以本地时间计)。 ECMAScript标准化前，不支持该参数。 seconds 可选的整数，在0～59之间，用作date的秒字段的新值(以本地时间计)。 ECMAScript标准化前，不支持该参数。 millis 可选的整数，在0～999之间，用作date的毫秒字段的新值(以本地时间计)。 ECMAScript标准化前，不支持该参数。 返回值 调整过的日期的毫秒表示。在ECMAScript标准化前，该方法不返回值。 |
| Date.setMilliseconds( ) |
设置Date对象的毫秒字段 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setMilliseconds(millis) 参数 millis 用于设置date的毫秒字段，用本地时间表示。该参数是0～999之间的整数。 返回值 调整过的日期的内部毫秒表示。 |
| Date.setMinutes( ) |
设置Date对象的分钟字段和秒字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.setMinutes(minutes) date.setMinutes(minutes, seconds) date.setMinutes(minutes, seconds, millis) 参数 minutes 0～59之间的整数，用于设置Date对象date的分钟字段(以本地时间计) seconds 可选的整数，在0～59之间，用做date的秒字段的新值(以本地时间计)。 ECMAScript标准化前，不支持该参数。 millis 可选的整数，在0到999之间，用作date的毫秒字段的新值(以本地时间计)。 ECMAScript标准化前，不支持该参数。 返回值 0～59之间的整数，用于设置Date对象date的分钟字段(以本地时间计)。 |
| Date.setMonth( ) |
设置Date对象的月份字段和天字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.setMonth(month) date.setMonth(month, day) 参数 month 0(一月)到11(十二月)之间的整数，用于设置Date对象date的月份字段。 注意，月份从0开始编号，而月中的某一天则从1开始编号。 day 可选的整数，在1～31之间，用做date的天数字段的新值(以本地时间计)。 ECMAScript标准化前，不支持该参数。 返回值 调整过的日期的毫秒表示。在ECMAScript标准化前，该方法不返回值。
| Date.setSeconds( ) |
设置Date对象的秒字段和毫秒字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.setSeconds(seconds) date.setSeconds(seconds, millis) 参数 seconds 0～59之间的一个整数，用于设置Date对象date的秒字段。 millis 可选的整数，在0～999之间，用做date的毫秒字段的新值(以本地时间计)。 ECMAScript标准化前，不支持该参数。 返回值 调整过的日期的毫秒表示。在ECMAScript标准化前，该方法不返回值。 |
|
| Date.setTime( ) |
以毫秒设置Date对象 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 date.setTime(milliseconds) 参数 milliseconds 要设置的日期和时间距GMT时间1970年1月1日午夜之间的毫秒数。这种类型的毫秒值可以传递给Date()构造函数，可以通过调用Date.UTC()和 Date.parse()方法获得该值。以毫秒形式表示日期可以使它独立于时区。 返回值 参数milliseconds。在ECMAScript标准化前，该方法不返回值。
| Date.setUTCDate( ) |
设置一个月中的某一天(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setUTCDate(day_of_month) 参数 day_of_month 要给date设置的一个月中的某一天，用世界时表示。该参数是1～31之间的整数。 返回值 调整过的日期的内部毫秒表示。 |
| Date.setUTCFullYear( ) |
设置年份、月份和天(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setUTCFullYear(year) date.setUTCFullYear(year, month) date.setUTCFullYear(year, month, day) 参数 year 要给date设置的年份值，用世界时表示。该参数应该是含有世纪值的完整年份， 如1999，而不只是缩写的年份值，如99。 month 可选的整数，在0～11之间，用作date的月份字段的新值(以世界时计)。 day 可选的整数，在1～31之间，用作date的天字段的新值(以世界时计)。 返回值 调整过的日期的内部毫秒表示。 |
| Date.setUTCHours( ) |
设置Date对象的小时字段、分钟字段、秒字段和毫秒字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setUTCHours(hours) date.setUTCHours(hours, minutes) date.setUTCHours(hours, minutes, seconds) date.setUTCHours(hours,minutes, seconds, millis) 参数 hours 要设置的date的小时字段的值，用世界时表示。该参数应该是0(午夜)到23 (晚上11点)之间的一个整数。 minutes 可选的整数，在0～59之间，用作date的分钟字段的新值(以世界时计)。 seconds 可选的整数，在0～59之间，用作date的秒字段的新值(以世界时计)。 millis 可选的整数，在0～999之间，用作date的毫秒字段的新值(以世界时计)。 返回值 调整过的日期的内部毫秒表示。 |
| Date.setUTCMilliseconds( ) |
设置Date对象的毫秒字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setUTCMilliseconds(millis) 参数 millis 要设置的date的毫秒字段的值，用世界时表示。该参数是0～999之间的整数。 返回值 调整过的日期的内部毫秒表示。
| Date.setUTCMinutes( ) |
设置Date对象的分钟字段和秒字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setUTCMinutes(minutes) date.setUTCMinutes(minutes, seconds) date.setUTCMinutes(minutes, seconds, millis) 参数 minutes 要设置的date的分钟字段的值，用世界时表示。该参数应该是0～59之间的一个整数。 seconds 可选的整数，在0～59之间，用作date的秒字段的新值(以世界时计)。 millis 可选的整数，在0～999之间，用作date的毫秒字段的新值(以世界时计)。 返回值 调整过的日期的内部毫秒表示。 |
| Date.setUTCMonth( ) |
设置Date对象的月份字段和天数字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setUTCMonth(month) date.setUTCMonth(month, day) 参数 month 要设置的date的月份字段的值，用世界时表示。该参数是0(一月)到11(十 二月)之间的整数。注意，月份从0开始编码，而月中的某一天则从1开始编码。 day 可选的整数，在1～31之间，用作date的天字段的新值(以世界时计)。 返回值 调整过的日期的内部毫秒表示。 |
| Date.setUTCSeconds( ) |
设置Date对象的秒字段和毫秒字段(世界时) |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v1 语法 date.setUTCSeconds(seconds) date.setUTCSeconds(seconds, millis) 参数 seconds 要设置的date的秒字段的值，用世界时表示。该参数应该是0～59之间的一个整数。 millis 可选的整数，在0～999之间，用作date的毫秒字段的新值(以世界时计)。 返回值 调整过的日期的内部毫秒表示。
| Date.setYear( ) |
设置Date对象的年份字段 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1; ECMAScript v3返回使用 语法 date.setYear(year) 参数 year 要设置的Date对象date的年份字段的值，是一个整数。如果这个值在0～99之 间，包括0和99，将给它加上1900，作为1900～1999间的值处理。 返回值 调整过的日期的毫秒表示。在ECMAScript标准化前，该方法不返回值。 描述 方法setYear()可以设置指定的Date对象的年份字段，对于1900～1999之间的年份，带有特殊的行为。 从ECMAScriptv3起，JavaScript实现不再要求使用该函数，而使用setFullYear() 函数代替它。
| Date.UTC( ) |
将Date规范转换成毫秒数 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Date.UTC(year, month, day, hours, minutes, seconds, ms) 参数 year 四位数表示的年份值。如果该参数在0～99之间(包括0和99)，它将加上1900， 作为1900～1999之间的年份处理。 month 月份值，是0(一月)到11(十二月)之间的整数。 day —个月中的某一天，是1～31之间的整数。注意，该参数的最小值是1，而其他 参数的最小值则是0。该参数是可选的。 hours 小时值，是0(午夜)到23(晚上11点)之间的整数。该参数是可选的。 minutes 分钟值，是0～59之间的整数。该参数是可选的。 seconds 是0～59之间的整数。该参数是可选的。 ms 毫秒数。该参数是可选的。在ECMAScript标准化前，忽略该参数。 返回值 指定的世界时的毫秒表示。简而言之，该方法返回指定的时间距GMT时间1970年1 月1日午夜的毫秒数。 描述 Date.UTC()是一种静态方法，它通过构造函数Date()调用，而不是通过某个Date 对象调用 Date.UTC()方法的参数指定日期和时间，它们都是UTC时间，处于GMT时区。指 定的UTC时间将转换成毫秒的形式，这样构造函数Date()和方法Date.setTime() 就可以使用它了。 Date.UTC()能接受的日期和时间格式，构造函数Date()也可以接受。区别在于构 造函数Date()假定这些参数是本地时间，而Date.UTC()却假定它们是世界时(GMT 时间)。要创建使用UTC时间规约的Date对象，可以使用如下的代码： d = new Date(Date.UTC(1996, 4, 8, 16, 30)); 参阅 Date, Date.parse( ), Date.setTime( ) |
| Date.valueOf( ) |
将Date转换成毫秒表示 |
可用性 JavaScript 1.1; ECMAScript v1 从…继承/覆盖 Overrides Object.valueOf( ) 语法 date.valueOf( ) 返回值 date的毫秒表示。返回值和方法Date.getTime{)返回的值相等。 |
Error（错误对象）
| Error |
普通异常 |
|
| Error.message |
可以读取的错误消息 |
|
| Error.name |
错误的类型 |
|
| Error.toString( ) |
把Error对象转换成字符串 |
|
| EvalError |
在不正确使用eval()时抛出 |
|
| SyntaxError |
抛出该错误用来通知语法错误 |
|
| RangeError |
在数字超出合法范围时抛出 |
|
| ReferenceError |
在读取不存在的变量时抛出 |
|
| TypeError |
当一个值的类型错误时，抛出该异常 |
|
| URIError |
由URl的编码和解码方法抛出 |
|
|
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 从…继承/覆盖 继承于 Object 构造函数 new Error( ) new Error(message) 参数 message 提供异常的详细信息的错误消息，可选。 返回值 新构造的Error对象。如果指定了参数message，该Error对象将它作为message属性的值；否则，它将用实现定义的默认字符串作为该属性的值。如果把Error构造函数当作函数调用时不使用new运算符，它的行为与使用new运算符调用时一样。 属性 message 提供异常详细信息的错误消息。该属性存放传递给构造函数的字符串，或实现定义的默认字符串。 name 声明异常类型的字符串。对于Error类的实例和所有子类来说，该属性声明了用于创建实例的构造函数名。 方法 toString( ) 返回一个表示Error对象的字符串 描述 Error类的实例表示错误或异常，通常与throw语句和try/catch语句一起使用。属性name声明了异常的类型，message属性可提供人们能够读取的异常的详细信息。 JavaScript解释器从不直接抛出Error对象，而是抛出Error子类(如SyntaxError或RangeError)的实例。在代码中，你会发现抛出Error对象指示异常非常方便，或者也可以用原始字符串或数字的形式抛出错误消息或错误代码。 注意，ECMAScript标准为Error类定义了toString()方法(Error的所有子类都继 承了该方法)，但并不要求该方法返回含有message属性的字符串。因此，不能期望 toString()方法可以把Error对象转换成人们可以读懂的字符串。要把错误消息显 示给用户，应该明确地使用Error对象的name属性和message属性。 示例 可以用下列代码指示一个异常: function factorial(x) { if (x < 0) throw new Error("factorial: x must be >= 0"); if (x <= 1) return 1; else return x * factorial(x-1); } 如果捕捉到了一个异常，可以用下列代码把它显示给用户(这段代码使用了客户端 Window.alert()方法)： try { &*(&/* an error is thrown here */ } catch(e) { if (e instanceof Error) { // 判断是否为Error或子类的—个实例 alert(e.name + ": " + e.message); } } 参阅 EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError |
|
|
| Error.message |
人们可以读取的错误消息 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 error.message 描述 Error对象(或Error子类的实例)的message属性用于存放包含发生的错误或异常的详细情况的字符串，该字符串是人们可以读取的。如果传递给Error()构造函数一个消息参数，该消息将成为message属性的值。如果没有消息参数传递给Error()参 数，Error对象将继承实现为该属性定义的默认值(可能是空串)。 |
|
|
|
|
|
|
|
|
|
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 error.name 描述 Error对象(或Error子类的实例)的name属性声明了发生的错误或异常的类型。所有Error对象都从它们的构造函数中继承这一属性。该属性的值与构造函数名相同。因 此，SyntaxError对象的name属性值为“SyntaxError”，EvalError对象的name属性为“EvalError”。 |
|
|
|
|
|
|
|
| SyntaxError |
抛出该错误用来通知语法错误 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 从…继承/覆盖 继承于 Error 构造函数 new SyntaxError( ) new SyntaxError(message) 参数 message 提供异常细节的错误消息(可选)。如果设置了该参数，它将作为SyntaxError对象的message属性的值。 返回值 新构造的SyntaxError对象。如果指定了参数message，该Error对象将它作为message 属性的值，否则，它将用实现定义的默认字符串作为该属性的值。如果不用new运算符，把SyntaxError()构造函数当作函数调用，它的行为与使用new运算符调用时一样。 属性 message 提供异常细节的错误消息。该属性存放传递给构造函数的字符串，或存放实现定义的默认字符串。详见“Error.message”。 name 声明异常类型的字符串。所有SyntaxEfror对象的name属性都继承值“SyntaxError”。 描述 SyntaxError类的一个实例会被抛出以通知JavaScript代码中的语法错误。eval()方法、Function()构造函数和RegExp()构造函数都可能抛出这种类型的异常。关于抛出和捕捉异常的细节，请参阅“Error”。 参阅 Error, Error.message, Error.name |
|
|
|
|
|
|
| RangeError |
在数字超出合法范围时抛出</td> |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 继承于 Error 构造函数 new RangeError( ) new RangeError(message) 参数 message 可选的错误消息，提供异常的详细情况。如果指定了该参数，它将作为 RangeError对象的message属性的值。 返回值 新构造的RangeError对象。如果指定了参数message，该Error对象把它作为message属性的值，否则，它将用实现定义的默认字符串作为该属性的值。如果不用new运算符，把RangeError()构造函数当作函数调用，那么它的行为与使用new运算符调用时一样。 属性 message 提供异常细节的错误消息。该属性存放传递给构造函数的字符串，或实现定义的默认字符串。详见“Error.message”。 name 声明异常类型的字符串。所有RangeError对象的name属性都继承值“RangeError”。 描述 当数字超出合法范围时，RangeError类的一个实例就会被抛出。例如，把数组的length 属性设置成一个负数，就会使RangeError对象被抛出。关于抛出和捕捉异常的细节， 请参阅“Error”。 参阅 Error, Error.message, Error.name |
|
|
|
|
|
| ReferenceError |
在读取不存在的变量时抛出 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 从…继承/覆盖 继承于 Error 构造函数 new ReferenceError( ) new ReferenceError(message) 参数 message 可选的错误消息，提供异常的详细情况。如果指定了该参数，它将作为 ReferenceError对象的message属性的值。 返回值 新构造的ReferenceError对象。如果指定了参数message，该Error对象把它作为 message属性的值，否则，它将用实现定义的默认字符串作为该属性的值。如果不用 new运算符，把ReferenceError()构造函数当作函数调用，它的行为与使用new 运算符调用时一样。 属性 message 提供异常细节的错误消息。该属性存放传递给构造函数的字符串，或实现定义的 默认字符串。详见“Error.message”。 name 声明异常类型的字符串。所有ReferenceError对象的name属性都继承值“ReferenceError”。 描述 在读取一个不存在的变量的值时，ReferenceError类的一个实例就会抛出。关于抛出和捕捉异常的细节，请参阅“Error"。 参阅 Error, Error.message, Error.name |
|
|
|
| TypeError |
当一个值的类型错误时，抛出该异常 |
|
|
|
| |
|
|
|
|
|
|
|
|
|
|
| |
|
|
|
|
|
|
|
|
|
|
可用性 JavaScript 1.5; JScript 5.5; ECMAScript 从…继承/覆盖 继承于 Error 构造函数 new TypeError( ) new TypeError(message) 参数 message 提供异常细节的错误消息(可选)。如果设置了该参数，它将作为TypeError对象的message属性的值。 返回值 新构造的TypeError对象。如果指定了参数message，该Error对象将它作为message属性的值，否则，它将用实现定义的默认字符串作为该属性的值。如果不用new运算符，则把TypeError()构造函数当作函数调用，它的行为与使用new运算符调用时一样。 属性 message 提供异常细节的错误消息。该属性存放传递给构造函数的字符串，或存放实现定义的默认字符串。详见“Error.message”。 name 声明异常类型的字符串。所有TypeError对象的name属性都继承值“TypeError”。 描述 当一个值的类型与要求不符时，TypeError类的一个实例就会被抛出。在访问值为 null或undefined的属性时，这种情况经常发生。如果由一个对象(其他类的实例) 调用另一个类定义的方法，或者对于不是构造函数的值使用new运算符时，也会发生这种情况。当调用内部函数或方法时，如果传递的参数多于期望的个数，JavaScript 的实现也允许抛出TypeError异常。关于抛出和捕捉异常的细节，请参阅“Error”。 参阅 Error, Error.message, Error.name |
|
|
| EvalError |
在不正确使用eval()时抛出 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 从…继承/覆盖 继承于 Error 构造函数 new EvalError( ) new EvalError(message) 参数 message 提供异常的详细信息的错误消息，可选。如果设置了该参数，它将用作EvalError对象的message属性的值。 返回值 新构造的EvalError对象。如果指定了参数message，Error对象将用它作为message 属性的值，否则，它将用实现定义的默认字符串作为该属性的值。如果把 EvalError()构造函数当作函数调用且不带有new运算符，它的行为与使用new运算符调用时一样。 属性 message 提供异常的详细信息的错误消息。该属性存放传递给构造函数的字符串，或存放实现定义的默认字符串。详见“Error.message”。 name 声明异常类型的字符串。所有EvalError对象的name属性都继承值“EvalError”。 描述 当在其他名称下调用全局函数eval()时，EvalError类的一个实例就会被抛出。关于调用eval()函数的限制，请参阅“eval()”。关于抛出和捕捉异常的细节，请参阅 “Error”。 参阅 Error, Error.message, Error.name |
|
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 继承于 Error 构造函数 new URIError( ) new URIError(message) 参数 message 提供异常细节的错误消息(可选)。如果设置了该参数，它将作为URIError对象的message属性的值。 返回值 新构造的URIError对象。如果指定了参数message,该Error对象将它作为message 属性的值，否则，它将用实现定义的默认字符串作为该属性的值。如果不用new运算符，而把URIError()构造函数当作函数调用，它的行为与使用new运算符调用时一样。 属性 message 提供异常细节的错误消息。该属性存放传递给构造函数的字符串，或存放实现定义的默认字符串。详见“Error.message”。 name 声明异常类型的字符串。所有URIError对象的name属性都继承值“URIError”。 描述 如果指定的字符串含有不合法的十六进制转义序列，则decodeURI()或decodeURIComponent()方法就会抛出URIError类的实例。如果指定的字符串含有不合法的 Unicode替代对，encodeURI()或encodeURIComponent()方法也会抛出该异常。关于抛出和捕捉异常的细节，请参阅“Error”。 参阅 Error, Error.message, Error.name |
Function（函数对象）
| Function |
JavaScript的函数 |
|
| Function.apply( ) |
将函数作为一个对象的方法调用 |
|
| Function.arguments[] |
传递给函数的参数 |
|
| Function.call( ) |
将函数作为对象的方法调用 |
|
| Function.caller |
调用当前函数的函数 |
|
| Function.length |
已声明的参数的个数 |
|
| Function.prototype |
对象类的原型 |
|
| Function.toString( ) |
把函数转换成字符串 |
|
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 从…继承/覆盖 继承于 Object 语法 function functionname(argument_name_list) // 函数定义语句 { body } function (argument_name_list) { body } // 未命名的函数直接量，JavaScript 1.2引入 functionname(argument_value_list) // 函数调用 构造函数 new Function(argument_names..., body) // avaScript 1.1和其后的版本支持它 参数 argument_names... 任意多个字符串参数，每个字符串命名一个或多个要创建的Function对象的参数。 body 一个字符串，指定函数的主体，可以含有任意多条JavaScript语句，这些语句之间用分号隔开，可以给该构造函数引用前面的参数设置的任何参数名。 返回值 新创建的Function对象。调用该函数，将执行body指定的JavaScript代码。 抛出 SyntaxError 说明在参数body或某个argument_names参数中存在JavaScript语法错误。 属性 arguments[] 一个参数数组，元素是传递给函数的参数。反对使用该属性。 caller 对调用当前函数的Function对象的引用，如果当前函数由顶层代码调用，这个属性的值为null。反对使用该属性。 length 在声明函数时指定的命名参数的个数。 prototype 一个对象，用于构造函数，这个对象定义的属性和方法由构造函数创建的所有对象共享。 方法 apply( ) 将函数作为指定对象的方法来调用，传递给它的是指定的参数数组。 call( ) 将函数作为指定对象的方法来调用，传递给它的是指定的参数。 toString( ) 返回函数的字符串表示。 描述 函数是JavaScript的一种基本数据类型。注意，虽然可以用这里介绍的Function()构造函数创建函数对象， 但这样做效率不高，在大多数情况下，建议使用函数定义语句或函数直接量来定义函数。 在JavaScriptl.1及以后版本中，函数主体会被自动地给予一个局部变量arguments，它引用一个Arguments对象。该对象是一个数组，元素是传递给函数的参数值。不要将这一属性和上面介绍的反对使用的属性argumentsl)相混淆。详见“Arguments”的参考页。 参阅 Arguments |
|
|
|
| Function.apply( ) |
将函数作为一个对象的方法调用 |
|
|
| |
|
|
|
|
|
|
| |
|
|
|
|
|
|
可用性
JavaScript 1.2; JScript 5.5; ECMAScript v3
语法
function.apply(thisobj, args)
参数
thisobj
调用function的对象。在函数主体中，thisobj是关键字this的值。
args
一个数组，它的元素是要传递给函数function的参数值。
返回值
调用函数function的返回值。
抛出
TypeError
如果调用该函数的对象不是函数，或参数args不是数组和Arguments对象，则抛出该异常。
描述
apply()将指定的函数function作为对象thisobj的方法来调用，传递给它的是存放在数组args中的参数，返回的是调用function的返回值。在函数体内，关键字this引用thisobj对象。
参数args必须是数组或Arguments对象。如果想单独指定传递给函数的参数，而不是指定数组元素，请使用Function.call()方法。
示例
// 在对象上应用默认的Object.toString()方法，
/ /该对象用该方法的版本覆盖了它。注意，没有参数
Object.prototype.toString.apply(o);
//使用数组中用来查找最大元素的方法来调用Math.max()
// 注意本例中第一个参数没有什么作用
var data = [1,2,3,4,5,6,7,8];
Math.max.apply(null, data);
参阅
Function.call( )
| Function.arguments[] |
传递给函数的参数 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1; deprecated by ECMAScript v3 语法 function.arguments[i] function.arguments.length 描述 Function对象的arguments属性是一个参数数组，它的元素是传递给函数的参数。只在执行函数时，它才被定义。arguments.1ength声明的是数组中的元素个数。 反对使用该属性，赞成使用Arguments对象。虽然ECMAScriptVl支持Function.arguments属性，但ECMAScriptv3删除了它，遵守该标准的实现不再支持该属性。 因此，在新的JavaScript代码中，不再应该使用它。 参阅 Arguments |
|
| Function.call( ) |
将函数作为对象的方法调用 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 function.call(thisobj, args...) 参数 thisobj 调用function的对象。在函数主体中，thisobj是关键字this的值。 args... 任意多个参数，这些参数将传递给函数function。 返回值 调用函数function的返回值。 抛出 TypeError 如果调用该函数的对象不是函数，则抛出该异常。 描述 call()将指定的函数function作为对象thisobj的方法来调用，把参数列表中thisobj后的参数传递给它，返回值是调用函数后的返回值。在函数体内，关键字this引用thisobj对象。 如果指定数组中传递给函数的参数，请使用Function.apply()方法。 示例 // 在对象上调用默认的object.toStrlng()方法，该对象用该方法的版本覆盖了自己 // 注意没有参数. Object.prototype.toString.call(o); 参阅 Function.apply( ) |
| Function.caller |
调用当前函数的函数 |
可用性 JavaScript 1.0, JScript 2.0; deprecated by ECMAScript 语法 function.caller 描述 在JavaScript的早期版本中，Function对象的caller属性是对调用当前函数的函数的引用。如果该函数是从JavaScript程序的顶层调用的，caller的值就为null。该属性只能在函数内部使用(例如，caller属性只有在函数执行时才会有定义)。 Function.caller属性不属于ECMAScript标准，在遵守该标准的实现中，不需要该属性。不应该再使用它。 |
| Function.length |
已声明的参数的个数 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 语法 function.length 描述 函数的length属性在定义函数时声明已命名的参数的个数。实际调用函数时，传递给它的参数个数既可以比它多，也可以比它少。不要混淆了Function对象和Arguments对象的length属性，后者声明的是实际传递给函数的参数个数。参阅 “Arguments.1ength”中的示例。 参阅 Arguments.length |
| Function.prototype |
对象类的原型 |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 语法 function.prototype 描述 属性prototype是在函数作为构造函数时使用的。它引用的是作为整个对象类的原型的对象。由这个构造函数创建的任何对象都会继承属性prototype引用的对象的所有属性。 Bug JavaScript 1.1要求，在给原型对象赋值之前，要先使用一次该构造函数。 参阅
| Function.toString( ) |
把函数转换成字符串 |
可用性 JavaScript 1.0; JScript 2.0; ECMAScript v1 语法 function.toString( ) 返回值 表示函数的字符串。 抛出 TypeError 如果调用该函数的对象不是Function，则抛出该异常。 描述 Function对象的方法toString()可以以一种与实现相关的方式将函数转换成字符串。 在Netscape实现中，该方法返回一个含有有效JavaScript代码的字符串，即包括关键字function、参数列表和函数的完整主体的代码。 |
Math（数学对象）
|
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1
语法
Math.acos(x)
参数
x
-1.0 和1.0.之间的数。
返回值
指定的值x的反余弦值。返回的是0到 之间的弧度值。
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1
语法
Math.asin(x)
参数
x
-1.0 和1.0.之间的数。
返回值
指定的值x的反正弦值。返回的是-/2和/2之间的弧度值。
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.atan(x) 参数 x 任意数。 返回值 指定的值x的反正切值。返回的是 -/2 和/2 之间的弧度值。 |
| Math.atan2( ) |
计算从x轴到一个点之间的角度 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.atan2(y, x) 参数 y 指定点的Y坐标。 x 指定点的X坐标。 返回值 - 和 之间的值，是从X轴正向逆时针旋转到点(x，y)时经过的角度。 (x, y). 描述 函数Math.atan2()计算的是y/x的反正切值。参数y可以看作一个点的Y坐标，x 可以看作该点的X坐标。注意这个函数的参数顺序，Y坐标在X坐标之前传递。 |
|
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.ceil(x) 参数 x 任意数或表达式。 返回值 大于等于x，并且与它最接近的整数。 描述 Math.ceil()执行的是向上取整计算，它返回的是大于等于函数参数，并且与之最接近的整数。Math.ceil()执行的操作不同于Math.round()，Math.ceil()总是上舍入，而Math.round()可以上舍入或下舍入到最接近的整数。还要注意， Math.ceil()不会将负数舍人为更小的负数，而是向0舍入。 示例 a = Math.ceil(1.99); // 结果是 2.0 b = Math.ceil(1.01); // 结果是 2.0 c = Math.ceil(1.0); // 结果是 1.0 d = Math.ceil(-1.99); // 结果是 -1.0 |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.cos(x) 参数 x 一个角的弧度值。要把角度转换成弧度，只需把角度值乘以0.017453293 (2/360). 返回值 指定的值x的余弦值。返回的是-1.0 和 1.0. |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.E 描述 E代表算术常量e，即自然对数的底数，其值近似于2.71828。 |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.exp(x) 参数 x 数值或表达式，被用作指数。 返回值 ex, e 的x次幂。这里e代表自然对数的底数，其值近似为2.71828。 |
| Math.floor( ) |
对一个数下舍入 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.floor(x) 参数 x 任意的数值或表达式。 返回值 小于等于x，并且与它最接近的整数。 描述 Math.floor()执行的是向下取整计算，它返回的是小于等于函数参数，并且与之最接近的整数。 Math.floor()将一个浮点值下舍人为最接近的整数。Math.floor()执行的操作不同于Math.round()，它总是进行下舍人，而不是上舍入或下舍人到最接近的整数。还要注意，Math.floor()将负数舍入为更小的负数，而不是向0进行舍入。 示例 a = Math.floor(1.99); // 结果为1.0 b = Math.floor(1.01); // 结果为1.0 c = Math.floor(1.0); // 结果为1.0 d = Math.floor(-1.01); // 结果为 -2.0
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.LN10 描述 Math.LN10 is loge2, 即10的自然对数，其值近似为2.3025850929940459011. |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.LN2 描述 Math.LN2 is loge2，即2的自然对数，其值近似为0.69314718055994528623. |
| Math.log( ) |
计算一个数的自然对数 |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.log(x) 参数 x 任何大于0的数值或表达式。 返回值 x的自然对数。 描述 Math.log( )计算logex的值，即它的参数的自然对数。参数值必须大于0。
可以使用下面的公式，计算一个以10为底的对数值和以2为底的对数值： log10x = log10e·logex log2x = log2e·logex 这些公式可以转化成如下的JavaScript函数： function log10(x) { return Math.LOG10E * Math.log(x); } function log2(x) { return Math.LOG2E * Math.log(x); }
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.LOG10E 描述 Math.LOG10E 表示常量 log10e,t即以2为底数e的对数。其值近似为 0.43429448190325181667. |
| Math.LOG2E |
算术常量log2e |
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.LOG2E 描述 Math.LOG2E 表示常量 log2e, 即以10为底的e的对数，其值近似为1.442695040888963387。 |
| Math.max( ) |
返回最大的参数 |
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1;在ECMAScript v3中增强
语法
Math.max(args...)
参数
args...
0个或多个值。在ECMAScriptv3之前，该方法只有两个参数。
返回值
参数中最大的值。如果没有参数，返回-Infinity。如果有一个参数为NaN，或是不 能转换成数字的非数字值，则返回NaN。
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1; 在ECMAScript v3中的获得增强 语法 Math.min(args...) 参数 args... 0个或多个值。在ECMAScriptv3之前，该函数只有两个参数。 返回值 参数中最小的值。如果没有参数，返回Infinity。如果有一个参数为NaN，或是不能转换成数字的非数字值，则返HNaN。 |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.PI 描述 Math.PI表示的是常量 或 pi，即圆的周长和它的直径之比，这个值近似为3.14159265358979。 |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.pow(x, y) 参数 x 底数。 y 幂数。 返回值 x的y次幂, xy. 描述 Math.pow()计算x的y次幂。x和y可以是任意值。但如果结果是虚数或复数， Math.pow()将返回NaN。在实际应用中，这就意味着如果x是一个负数，那么y就 应该是一个正整数或是一个负整数。还要记住，指数过大会引起浮点溢出，此时该方法将返回Infinity。 |
|
可用性 JavaScript 1.1; JScript 1.0; ECMAScript v1 语法 Math.random( ) 返回值 返回一个0.0 和 1.0之间的一个伪随机数。 |
| Math.round( ) |
舍入到最接近的整数 |
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1
语法
Math.round(x)
参数
x
任意数。
返回值
与x最接近的数。
描述
Math.round( )将把它的参数上舍入或下舍入到与它最接近的整数。对于0.5，它将上舍入。例如，2.5将被舍入为3，-2.5将被舍入为-2。
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.sin(x) 参数 x 一个以弧度表示的角。将角度乘以0.017453293 (2/360)即可转换成弧度。 返回值 x的正弦值。 |
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1
语法
Math.sqrt(x)
参数
x
大于等于0的数。
返回值
x的平方根。如果x小于0，返回NaN。
描述
Math．sqrt()计算数字的平方根。注意，用Math.pow()可以计算一个数的任意次根。例如：
Math.cuberoot = function(x){ return Math.pow(x,1/3); }
Math.cuberoot(8); // 返回 2
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1
语法
Math.SQRT1_2
描述
Math.SQRT1_2就是常量1/ ，即2的平方根，它的值近似于0.7071067811865476。
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.SQRT2 描述 Math.SQRT2就是常量 ，即2的平方根，它的值近似于1.414213562373095。 |
|
可用性 JavaScript 1.0; JScript 1.0; ECMAScript v1 语法 Math.tan(x) 参数 x 一个以弧度表示的角。将角度乘以0.017453293 (2/360)即可转换成弧度。 返回值 指定的角x的正切值。 |
Number（数字对象）
| Number |
对数字的支持 |
|
| Number.MAX_VALUE |
最大数值 |
|
| Number.MIN_VALUE |
最小数值 |
|
| Number.NaN |
特殊的非数字值 |
|
| Number.NEGATIVE_INFINITY |
负无穷大 |
|
| Number.POSITIVE_INFINITY |
正无穷大 |
|
| Number.toExponential( ) |
用指数计数法格式化数字 |
|
| Number.toFixed( ) |
采用定点计数法格式化数字 |
|
| Number.toLocaleString( ) |
把数字转换成本地格式的字符串 |
|
| Number.toPrecision( ) |
格式化数字的有效位 |
|
| Number.toString( ) |
将—个数字转换成字符串 |
|
| Number.valueOf( ) |
返回原始数值 |
|
| |
可用性 JavaScript 1.1; JScript 2.0; ECMAScript v1 从…继承/覆盖 继承于 Object 构造函数 new Number(value) Number(value) 参数 value 要创建的Number对象的数值，或是要转换成数字的值。 返回值 当Number()和运算符new一起作为构造函数使用时，它返回一个新创建的Number对象。如果不用new运算符，把Number()作为一个函数来调用，它将把自己的参数转换成一个原始的数值，并且返回这个值(如果转换失败，返回NaN)。 常量 Number.MAX_VALUE 可表示的最大的数。 Number.MIN_VALUE 可表示的最小的数。 Number.NaN 非数字值。 Number.NEGATIVE_INFINITY 负无穷大；溢出时返回该值。 Number.POSITIVE_INFINITY 正无穷大；溢出时返回该值。 方法 toString( ) 把数字转换成字符串，使用指定的基数。 toLocaleString( ) 把数字转换成字符串，使用本地数字格式规约。 toFixed( ) 把数字转换成字符串，结果的小数点后有指定位数的数字。 toExponential( ) 把数字转换成字符串，结果采用指数计数法，小数点后有指定位数的数字。 toPrecision( ) 把数字转换成字符串，结果中包含指定位数的行效数字。采用指数计数法或定点计数法，由数字的大小和指定的有效数字位数决定采用哪种方法。 描述 在JavaScript中，数字是—种基本的数据类型。在JavaScriptl.1中，JavaScript 还支持Number对象，该对象是原始数值的包装对象。JavaScript在必要时会自动地进行原始数据和对象之间的转换。在JavaScript 1.1中，可以用构造函数Number() 明确地创建一个Number对象，尽管这样做并没有什么必要。 构造函数Number()还可以不与运算符new—起使用，而直接作为转换函数来使用。 以这种方式调用Number()时，它会把自己的参数转换成一个数字，然后返回转换后的原始数值(或NaN)。 构造函数Number()通常还用作5个有用的数字常量的占位符，这5个有用的数字常量分别是可表示的最大的数、可表示的最小的数、正无穷大、负无穷大和特殊的非数 字值。注意，这些值都是构造函数Number()自身的属性，而不是单独的Number对象的属性。例如，可以采用如下的形式使用属性MAX_VALUE： var biggest = Number.MAX_VALUE 但是却不能使用： var n = new Number(2); var biggest = n.MAX_VALUE 作为比较，看一下toStrlng()和Number对象的其他方法，它们是每个Number对象的方法，而不是Number()构造函数的方法。前面提到过，在必要时，JavaScript 会自动地把原始数值转换成Number对象。这就是说，调用Number方法的既可以是Number对象，也可以是原始数字值。 var value = 1234; var binary_value = n.toString(2); 参阅 Infinity, Math, NaN |
|
| |
可用性 JavaScript 1.1; JScript 2.0, ECMAScript v1 语法 Number.MAX_VALUE 描述 Number.MAX_VALUE是JavaScript中可表示的最大的数。它的值近似为1.79E+308。 |
|
|
|
|
| |
可用性 JavaScript 1.1; JScript 2.0, ECMAScript v1 语法 Number.MIN_VALUE 描述 Number.MIN_VALUE是JavaScript中可表示的最小的数(接近0，但不是负数)。它的值近似为5E-324. |
|
|
|
| Number.NaN |
特殊的非数字值 |
|
|
| |
|
|
|
|
|
|
|
|
|
| |
|
|
|
|
|
|
|
|
|
可用性
JavaScript 1.1; JScript 2.0, ECMAScript v1
语法
Number.NaN
描述
Number.NaN是一个特殊值，说明某些算术运算(如求负数的平方根)的结果不是数字。方法parseInt()和parseFloat()在不能解析指定的字符串时就返回这个值。 对于一些常规情况下返回有效数字的函数，也可以采用这种方法，用Number.NaN说明它的错误情况。
JavaScript以NaN的形式输出Number.NaN。注意，NaN与其他数值进行比较的结果 总是不相等的，包括它自身在内。因此，不能通过与Number.NaN比较来检测一个值是不是数字，而只能调用函数isNaN()来比较。在ECMAScriptv v1其后的版本中， 还可以用预定义的全局常量NaN代替Number.NaN。
参阅
isNaN( ), NaN
| Number.NEGATIVE_INFINITY |
负无穷大 |
可用性 JavaScript 1.1; JScript 2.0, ECMAScript v1 语法 Number.NEGATIVE_INFINITY 描述 Number.NaN是一个特殊值，说明某些算术运算(如求负数的平方根)的结果不是数字。方法parseInt()和parseFloat()在不能解析指定的字符串时就返回这个值。 对于一些常规情况下返回有效数字的函数，也可以采用这种方法，用Number.NaN说明它的错误情况。 JavaScript以NaN的形式输出Number.NaN。注意，NaN与其他数值进行比较的结果总是不相等的，包括它自身在内。因此，不能通过与Number.NaN比较来检测一个值是不是数字，而只能调用函数isNaN()来比较。在ECMAScriptv v1其后的版本中， 还可以用预定义的全局常量NaN代替Number.NaN。 参阅 Infinity, isFinite( ) |
| Number.POSITIVE_INFINITY |
正无穷大 |
可用性 JavaScript 1.1; JScript 2.0, ECMAScript v1 语法 Number.POSITIVE_INFINITY 描述 属性Number.POSITIVE_INFINITY是一个特殊值，它在算术运算或函数生成了一个比JavaScript能表示的最大的数还大的数(也就是比Number.MAX_VALUE还大的数)时返回。注意，当数字向下溢出或比Number.MIN_VALUE还小时，JavaScript将它们转换成零。 JavaScript显示POSITIVE_INFINITY时使用的是Infinity。这个值的算术行为和无穷大非常相似。例如，任何数乘无穷大结果仍为无穷大，任何数被无穷大除结果为0。 在ECMAScript vl和其后的版本中，还可以用Infinity代替Number.POSITIVE_INFINITY。 参阅 Infinity, isFinite( ) |
| Number.toExponential( ) |
用指数计数法格式化数字 |
可用性
JavaScript 1.5; JScript 5.5, ECMAScript v3
语法
number.toExponential(digits)
参数
digits
小数点后的数字位数，值在0～20之间，包括0和20，有些实现可能支持更大的数值范围。如果省略了该参数，将使用尽可能多的数字。
返回值
number的字符串表示，采用指数计数法，即小数点之前有一位数字，小数点后有digits位数字。该数字的小数部分将被舍人，必要时用0补足，以便它达到指定的 长度。
抛出
RangeError
digits太小或太大时抛出的异常。0～20之间(包括0和20)的值不会引发RangeError。有些实现允许支持更大范围或更小范围内的值。
TypeError
调用该方法的对象不是Number时抛出的异常。
示例
var n = 12345.6789;
n.toExponential(1); // 返回 1.2e+4
n.toExponential(5); // 返回 1.23457e+4
n.toExponential(10); // 返回 1.2345678900e+4
n.toExponential( ); // 返回 1.23456789e+4
参阅
Number.toFixed( ), Number.toLocaleString( ), Number.toPrecision( ), Number.toString( )
| Number.toFixed( ) |
采用定点计数法格式化数字 |
可用性 JavaScript 1.5; JScript 5.5, ECMAScript v3 语法 number.toFixed(digits) 参数 digits 小数点后的数字位数，是0～20之间的值，包括0和20，有些实现可以支持更 大的数值范围。如果省略了该参数，将用0代理。 返回值 number的字符串表示，不采用指数计数法，小数点后有固定的digics位数字。如果 必要，该数字会被舍入，也可以用0补足，以便它达到指定的长度。如果number大 于le+21，该方法只调用Number.toString()，返回采用指数计数法表示的字符串。 抛出 RangeError digits太小或太大时抛出的异常。0～20之间(包括0和20)的值不会引发 RangeError。有些实现支持更大范围或更小范围内的值。 TypeError 调用该方法的对象不是Number时抛出的异常。 示例 var n = 12345.6789; n.toFixed( ); // 返回 12346，注意舍入，没有小数部分 n.toFixed(1); // 返回 12345.7，注意舍入 n.toFixed(6); // 返回 12345.678900，注意补零 (1.23e+20).toFixed(2); // 返回 123000000000000000000.00 (1.23e-10).toFixed(2) // 返回 0.00 参阅 Number.toExponential( ), Number.toLocaleString( ), Number.toPrecision( ), Number.toString( ) |
| Number.toPrecision( ) |
格式化数字的有效位 |
可用性
JavaScript 1.5; JScript 5.5, ECMAScript v3
语法
number.toPrecision(precision)
参数
precision
返回的字符串中的有效位数，是1～21之间(包括1和21)的值。有些实际允许有选择地支持更大或更小的precision。如果省略了该参数，将调用方法toString()，而不是把数字转换成十进制的值。
返回值
number的字符串表示，包含precision个有效数字。如果precision足够大，能够包括number整数部分的所有数字，那么返回的字符串将采用定点计数法。否则，采用指数计数法，即小数点前有一位数字，小数点后有precision-l位数字。必要时， 该数字会被舍入或用0补足。
抛出
RangeError
digits太小或太大时抛出的异常。1～21之间(包括1和21)的值不会引发 RangeError。有些实现支持更大范围或更小范围内的值。
TypeError
调用该方法的对象不是Number时抛出的异常。
示例
var n = 12345.6789;
n.toPrecision(1); // 返回 1e+4
n.toPrecision(3); // 返回 1.23e+4
n.toPrecision(5); // 返回 12346:注意舍入
n.toPrecision(10); // 返回 12345.67890:注补L零
参阅
Number.toExponential( ), Number.toFixed( ), Number.toLocaleString( ), Number.toString( )
| Number.toLocaleString( ) |
把数字转换成本地格式的字符串 |
可用性 JavaScript 1.5; JScript 5.5, ECMAScript v3 语法 number.toLocaleString( ) 返回值 数字的字符串表示，由实现决定，根据本地规范进行格式化。可能影响到小数点或千分位分隔符采用的标点符号。 抛出 TypeError 调用该方法的对象不是Number时抛出的异常。 参阅 Number.toExponential( ), Number.toFixed( ), Number.toPrecision( ), Number.toString( ) |
| Number.toString( ) |
将—个数字转换成字符串 |
可用性 JavaScript 1.1; JScript 2.0, ECMAScript v1 从…继承/覆盖 覆盖 Object.toString( ) 语法 number.toString(radix) 参数 radix 可选的参数，指定表示数字的基数，是2～36之间的整数。如果省略了该参数， 使用基数10。但要注意，如果该参数是10以外的其他值，则ECMAScript标准 允许实现返回任意值。 返回值 数字的字符串表示。 抛出 TypeError 调用该方法的对象不是Number时抛出的异常。 描述 Number对象的方法toString()可以将数字换成字符串。当省略了radix参数或指定它的值为10时，该数字将被转换成基数为10的字符串。如果radix是其他值，该方法将返回由实现定义的字符串。Netscape实现和JScript 3.0后的Microsoft实现都支持radix参数，并返回以指定基数表示的字符串。 参阅 Number.toExponential( ), Number.toFixed( ), Number.toLocaleString( ), Number.toPrecision( ) |
| Number.valueOf( ) |
返回原始数值 |
可用性
JavaScript 1.1; JScript 2.0, ECMAScript v1
从…继承/覆盖
覆盖 Object.valueOf( )
语法
number.valueOf( )
返回值
Number对象的原始数值。几乎没有必要明确调用该方法。
抛出
TypeError
调用该方法的对象不是Number时抛出的异常。
参阅
Object.valueOf( )
RegExp（正则表达式对象）
| RegExp |
用于模式匹配的正则表达式 |
|
| RegExp.exec( ) |
通用的匹配模式 |
|
| RegExp.global |
正则表达式是否全局匹配 |
|
| RegExp.ignoreCase |
正则表达式是否区分大小写 |
|
| RegExp.lastIndex |
下次匹配的起始位置 |
|
| RegExp.source |
正则表达式的文本 |
|
| RegExp.test( ) |
检测一个字符串是否匹配某个模式 |
|
| RegExp.toString( ) |
把正则表达式转换成字符串 |
|
| |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 直接量语法 /pattern/attributes 构造函数 new RegExp(pattern, attributes) 参数 pattern 一个字符串，指定了正则表达式的模式或其他正则表达式。 attributes 一个可选的字符串，包含属性“g”、“i”和“m”，分别用于指定全局匹配、区分大小写的匹配和多行匹配。ECMAScript标准化之前，不支持m属性。如果 pattern是正则表达式，而不是字符串，则必须省略该参数。 返回值 一个新的RegExp对象，具有指定的模式和标志。如果参数pattern是正则表达式而不是字符串，那么RegExp()构造函数将用与指定的RegExp相同的模式和标志创建 一个新的RegExp对象。如果不用new运算符，将RegExp()作为函数调用，那么它 的行为与用new运算符调用时一样，只是当pactern是正则表达式时，它只返回 pattern，而不再创建一个新的RegExp对象。 抛出 SyntaxError 如果pattern不是合法的正则表达式，或attributes含有“g”、“i”、“m”之 外的字符，抛出该异常。 TypeError 如果pattern是RegExp对象，但没有省略attributes参数，抛出该异常。 实例属性 global RegExp对象是否具有性质g。 ignoreCase RegExp对象是否具有性质i。 lastIndex 上次匹配后的字符位置，用于在一个字符串中进行多次匹配。 multiline RegExp对象是否具有m性质。 source 正则表达式的源文本。 方法 exec( ) 执行强大的、通用的模式匹配。 test( ) 检测一个字符串是否含有某个模式。 描述 RegExp对象表示一个正则表达式，它是对字符串执行模式匹配的强大工具。 参阅 |
|
| RegExp.exec( ) |
通用的匹配模式 |
|
|
| |
|
|
|
|
|
|
| |
|
|
|
|
|
|
可用性
JavaScript 1.2; JScript 3.0; ECMAScript v3
语法
regexp.exec(string)
参数
string
要检索的字符串。
返回值
—个数组，存放的是匹配的结果。如果没有找到匹配，值为null。返回的数组的格式在下面介绍。
抛出
TypeError
调用该方法的对象不是RegExp时，抛出该异常。
描述
在所有的RegExp模式匹配方法和String模式匹配方法中，exec()的功能最强大。它是一个通用的方法，使用起来比RegExp.test()、String.search()、String.replace()和String.match()都复杂。
exec()将检索字符串string，从中得到与正则表达式regexp相匹配的文本。如果exec()找到了匹配的文本，它就会返回一个结果数组。否则，返回null。这个返回数组的第0个元素就是与表达式相匹配的文本。第1个元素是与regexp的第一个子表达式相匹配的文本(如果存在)。第2个元素是与regexp的第二个子表达式相匹配的文本，以此类推。通常，数组的length属性声明的是数组中的元素个数。除了数组元素和length属性之外，exec()还返回两个属性。index属性声明的是匹配文本的第一个字符的位置。input属性指的就是string。在调用非全局RegExp对象的exec()方法时，返回的数组与调用方法String.match()返回的方法相同。
在调用非全局模式的exec()方法时，它将进行检索，并返回上述结果。不过，当regexp是一个全局正则表达式时，exec()的行为就稍微复杂一些。它在regexp的属性lastlndex指定的字符处开始检索字符串string。当它找到了与表达式相匹配的文本时，在匹配之后，它将把regexp的lastlndex属性设置为匹配文本的第一个字符的位置。这就是说，可以通过反复地调用exec()方法来遍历字符串中的所有匹配文本。当exec()再也找不到匹配的文本时，它将返回null，并且把属性lastlndex重置为0。如果在另一个字符串中完成了一次模式匹配之后要开始检索新的字符串，就必须手动地把lastlndex属性重置为0。
注意，无论regexp是否是全局模式，exec()都会将完整的细节添加到它返回的数组中。这就是exec()和String.match()的不同之处，后者在全局模式下返回的信息要少得多。事实上，在循环中反复地调用exec()方法是惟一种获得全局模式的完整模式匹配信息的方法。
示例
可以在循环中使用exec()来检索—个字符串中的所有匹配文本。例如：
var pattern = /\bJava\w*\b/g;
var text = "JavaScript is more fun than Java or JavaBeans!";
var result;
while((result = pattern.exec(text)) != null) {
alert("Matched `" + result[0] +
"' at position " + result.index +
" next search begins at position " + pattern.lastIndex);
}
Bug
在JScript 3.0中，exec()不能正确地使用和设置属性lastIndex，因此这时不能将全局模式的exec()用于循环中，就像上面那个例子所示的一样。
参阅
RegExp.lastIndex, RegExp.test( ), String.match( ), String.replace( ), String.search( ); Chapter 10
| RegExp.global |
正则表达式是否全局匹配 |
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v3 语法 regexp.global 描述 RegExp对象的属性global是一个只读的布尔值。它声明了给定的正则表达式是否执行全局匹配，如创建它时是否使用了性质g。 |
| RegExp.ignoreCase |
正则表达式是否区分大小写 |
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v3 语法 regexp.ignoreCase 描述 RegExp对象的属性ignoreCase是一个只读的布尔值。它声明了—个给定的正则表达式是否执行区分大小写的匹配，例如创建它时是否使用了性质i。 |
| RegExp.lastIndex |
下次匹配的起始位置 |
可用性 JavaScript 1.2; JScript 5.5; ECMAScript v3 语法 regexp.lastIndex 描述 RegExp对象的属性lastIndex是一个可读可写的值。对于设置了g性质的正则表达式来说，该属性存放的是—个整数，它声明了紧接着上次找到的匹配文本的字符的位置。上次匹配的结果是由方法RegExp.exec()或RegExp.test()找到的，它们都以lastIndex属性所指的位置作为下次检索的起始点。这样，就可以通过反复调用这两个方法来遍历一个字符串中的所有匹配文本。注意，不具有性质g和不表示全局模式的RegExp对象不能使用lastlndex属性。 由于这一属性是可读可写的，所以只要目标字符串的下一次搜索开始，就可以对它进行设置。当方法exec()或test()再也找不到可以匹配的文本时，它们会自动地把 lastIndex属性重置为0。如果在成功的匹配了某个字符串之后就开始检索另一个字符串，需要明确地把这个属性设为0。 参阅 RegExp.exec( ), RegExp.test( ) |
|
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 语法 regexp.source 描述 RegExp对象的属性source是一个只读的字符串。它存放的是RegExp模式的文本。 该文本中不包括正则表达式直接量使用的定界符，也不包括性质g、i、m。 |
| RegExp.test( ) |
检测一个字符串是否匹配某个模式 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 语法 regexp.test(string) 参数 string 要检测的字符串。 返回值 如果字符串string中含有与regexp匹配的文本，就返回true，否则返回false。 抛出 TypeError 调用该方法的对象不是RegExp时，抛出该异常。 描述 方法test()将检测字符串string，看它是否含有与regexp相匹配的文本。如果 string中含有这样的文本，该方法将返回true，否则，返回false。调用RegExp对象r的test()方法，给它传递字符串s，等价于下面的表达式： (r.exec(s) != null) 示例 var pattern = /java/i; pattern.test("JavaScript"); // 返回 true pattern.test("ECMAScript"); // 返回 false 参阅 RegExp.exec( ), RegExp.lastIndex, String.match( ), String.replace( ), String.substring( ) |
| RegExp.toString( ) |
把正则表达式转换成字符串 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 从…继承/覆盖 覆盖 Object.toString( ) 语法 regexp.toString( ) 返回值 regexp的字符串表示。 抛出 TypeError 调用该方法的对象不是RegExp时，抛出该异常。 描述 RegExp.toString()方法将以正则表达式直接量的形式返回正则表达式的字符串表示。 注意，不允许用实现添加转义序列，这样可以确保返回的字符串是合法的正则表达式直接量。考虑由表达式new RegExp("/","g")创建的正则表达式。RegExp.toString()的一种实现对该正则表达式返回“///g”，此外它还能添加转义序列，返回“/\//g”。 |
String（字符串对象）
可用性
JavaScript 1.0; JScript 1.0; ECMAScript v1
从…继承/覆盖
继承于 Object
构造函数
new String(s) // 构造函数
String(s) // 构造函数
参数
s
要存储在String对象中或转换成原始字符串的值。
返回值
当String()与new运算符一起作为构造函数使用时，返回一个新创建的String对象，存放的是字符串s或s的字符串表示。当不用new运算符调用String()时，它只把s转换成原始的字符串，并返回转换后的值。
属性
length
字符串中的字符数。
方法
charAt( )
抽取字符串中指定位置处的字符。
charCodeAt( )
返回字符串中指定位置处的字符编码。
concat( )
把一个或多个值连接到字符串上。
indexOf( )
在字符串中检索一个字符或一个子串。
lastIndexOf( )
在字符串中向后检索一个字符或一个子串。
match( )
用正则表达式执行模式匹配。
replace( )
用正则表达式执行查找、替换操作。
search( )
检索字符串中与正则表达式匹配的子串。
slice( )
返回字符串的一个片段或一个子串。
split( )
把字符串分割成一个字符串数组，在指定的分界字符处或正则表 达式处执行分割。
substring( )
从字符串中抽取一个子串。
substr( )
从字符串中抽取一个子串。该方法是substring()的一个变体。
toLowerCase( )
将字符串中的所有字符都转换成小写的，然后返回一个副本。
toString( )
返回原始的字符串值。
toUpperCase( )
将字符串中的所有字符都转换成大写的，然后返回一个副本。
valueOf( )
返回原始字符串值。
静态方法
String.fromCharCode( )
用作为参数而传递的字符代码创建一个新的字符串。
HTML 方法
从JavaScript 1.0和JScript 1.0起，String类定义了许多方法，返回的字符串是把它放在HTML标记中修改后得到的。虽然ECMAScript没有标准化这些方法，但它们在客户端和服务器端动态生成HTML的脚本代码中非常有用。用这些非标准的方法，就可以为黑体的红色超链接创建常见HTML源代码，如下所示：
var s = "click here!";
var html = s.bold( ).link("javascript:alert('hello')").fontcolor("red");
因为这些方法没有被标准化，所以它们没有单独的参考页：
anchor( name)
在<a name=>环境中返回字符串的一个副本。
big( )
在<big>环境中返回字符串的一个副本。
blink( )
在<blink>环境中返回字符串的一个副本。
bold( )
在<b>环境中返回字符串的一个副本。
fixed( )
在<tt>环境中返回字符串的一个副本。
fontcolor( color)
在<font color=>环境中返回字符串的一个副本。
fontsize( size)
在<font size=>环境中返回字符串的一个副本。
italics( )
在<i>环境中返回字符串的一个副本。
link( url)
在<a href=>环境中返回字符串的一个副本。
small( )
在<small>环境中返回字符串的一个副本。
strike( )
在<strike>环境中返回字符串的一个副本。
sub( )
在<sub>环境中返回字符串的一个副本。
sup( )
在<sup>环境中返回字符串的一个副本。
描述
字符串是JavaScript的一种基本数据类型。String类提供了操作原始字符串值的方法。 String对象的length属性声明了该字符串中的字符数。类String定义了大量操作字符串的方法， 例如从字符串中提取字符或子串，或者检索字符或子串。注意，JavaScript的字符串是不可变(immutable)的，String类定义的方法都不能改变字符串的内容。像String.toUpperCase()这样的方法，返回的是全新的字符串，而不是修改原始字符串。
在JavaScript 1.2及其后版本的Netscape实现中，字符串的行为就像只读的字符数组。 例如，从字符串s中提取第三个字符，可以用s[2]代替更加标准的s.charAt(2)。 此外，对字符串应用for/in循环时，它将枚举字符串中每个字符的数组下标(但要注意，ECMAScript标准规定，不能枚举length属性)。因为Netscape实现中的字符 串的数组行为不标准，所以应该避免使用它。
参阅
| String.charAt( ) |
返回字符串中的第n个字符 |
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 语法 string.charAt(n) 参数 n 应该返回的字符在string中的下标。 返回值 字符串string的第n个字符。 描述 方法String.charAt()返回字符串string中的第n个字符。字符串中第一个字符的下标值是0。如果参数n不在0和string.length-1之间，该方法将返回一个空字符串。注意，JavaScript并没有一种有异于字符串类型的字符数据类型，所以返回的字符是长度为1的字符串。 参阅 String.charCodeAt( ), String.indexOf( ), String.lastIndexOf( ) |
| String.charCodeAt( ) |
返回字符串中的第n个字符的代码 |
可用性
JavaScript 1.2; JScript 5.5; ECMAScript v1
语法
string.charCodeAt(n)
参数
n
返回编码的字符的下标。
返回值
string中的第n个字符的Unicode编码。这个返回值是0～65535之间的16位整数。
描述
方法charCodeAt()与charAt()执行的操作相似，只不过前者返回的是位于指定位置的字符的编码，而后者返回的则是含有字符本身的子串。如果n是负数，或者大于等于字符串的长度，则charCodeAt()返回NaN。
要了解从Unicode编码创建字符串的方法，请参阅String.fromCharCode()。
Bug
JavaScript 1.2(例如，由Netscape 4.0实现)对16位Unicode字符和字符串没有提供完全的支持。
参阅
String.charAt( ), String.fromCharCode( )
可用性
JavaScript 1.2; JScript 3.0; ECMAScript v3
语法
string.concat(value, ...)
参数
value, ...
要连接到string上的一个或多个值。
返回值
把每个参数都连接到字符串string上得到的新字符串。
描述
方法concat()将把它的所有参数都转换成字符串(如果必要)，然后按顺序连接到字符串string的尾部，返回连接后的字符串。注意，string自身并没有被修改。
String.concat()与Array.concat()很相似。注意，使用“+”运算符来进行字符串的连接运算通常更简便一些。
参阅
Array.concat( )
| String.fromCharCode( ) |
从字符编码创建—个字符串 |
可用性
JavaScript 1.2; JScript 3.0; ECMAScript v1
语法
String.fromCharCode(c1, c2, ...)
参数
c1, c2, ...
零个或多个整数，声明了要创建的字符串中的字符的Unicode编码。
返回值
含有指定编码的字符的新字符串。
描述
这个静态方法提供了一种创建字符串的方式，即字符串中的每个字符都由单独的数字Unicode编码指定。注意，作为—种静态方法，fromcharCode()是构造函数 String()的属性，而不是字符串或String对象的方法。
String.charCodeAt()是与String.fromCharCode()配套使用的实例方法，它提 供了获取字符串中单个宁符的编码的方法。
示例
// 创建字符串"hello"
var s = String.fromCharCode(104, 101, 108, 108, 111);
Bug
JavaScript 1.2(例如，由Netscape 4.0实现)没有对16位Unicode编码的字符和字符串提供完全的支持。
参阅
String.charCodeAt( )
|
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 语法 string.indexOf(substring) string.indexOf(substring,start) 参数 substring 要在字符串string中检索的子串。 start 一个可选的整数参数，声明了在字符串String中开始检索的位置。它的合法取值是0(字符串中的第一个字符的位置)到string.length-1(字符串中的最后一个字符的位置)。如果省略了这个参数，将从字符串的第一个字符开始检索。 返回值 如果在string中的start位置之后存在substring返回出现的第一个substring 的位置。如果没有找到子串substring返回-1。 描述 方法string.indexOf()将从头到尾的检索字符串string，看它是否含有子串 substring。开始检索的位置在字符串string的start处或string的开头(没有 指定start参数时)。如果找到了一个substring那么String.indexOf()将返回 substring的第一个字符在string中的位置。string中的字符位置是从0开始的。 如果在string中没有找到substring，那么String.indexOf()方法将返回-1。 Bug 在JavaScript 1.0和1.1中，如果start的值大于字符串string的长度，indexOf()将返回一个空字符串，而不是返回-1。 参阅 String.charAt( ), String.lastIndexOf( ), String.substring( ) |
|
| String.lastIndexOf( ) |
从后向前检索一个字符串 |
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 语法 string.lastIndexOf(substring) string.lastIndexOf(substring, start) 参数 substring 要在字符串string中检索的子串。 start 一个可选的整数参数，声明了在字符串string中开始检索的位置。它的合法取值是0(字符串中的第一个字符的位置)到string.1ength-1(字符串中的最后一个字符的位置)。如果省略了这个参数，将从字符串的最后一个字符处开始检索。 返回值 如果在string中的start位置之前存在substring那么返回的就是出现的最后一个substring的位置。如果没有找到子串substring那么返回的是-1。 描述 方法String.1astIndexOf()将从尾到头的检索字符串string看它是否含有子串 substring。开始检索的位置在字符串string的start处或string的结尾(没有 指定start参数时)。如果找到了一个substring，那么String.lastIndexOf()将返回substring的第一个字符在string中的位置。由于是从尾到头的检索一个字符串，所以找到的第一个substrlng其实是strlng中出现在位置start之前的最后一个substring。 如果在string中没有找到substring，那么该方法将返回-1。 注意，虽然String.1astIndexOf()是从尾到头的检索字符串string，但是它返回的字符位置仍然是从头开始计算的。字符串中第一个字符的位置是0，最后—个字符的位置是string.1ength-1。 参阅 String.charAt( ), String.indexOf( ), String.substring( ) |
|
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 语法 string.length 描述 属性String.1ength是一个只读整数，它声明了指定字符串string中的字符数。对于任何一个字符串s，它最后一个字符的下标都是s.1ength-1。用for/in循环不能枚举出字符串的length属性，用delete运算符也不能删除它。 |
| String.localeCompare( ) |
用本地特定的顺序来比较两个字符串 |
可用性 JavaScript 1.5; JScript 5.5; ECMAScript v3 语法 string.localeCompare(target) 参数 target 要以本地特定的顺序与string进行比较的字符串。 返回值 说明比较结果的数字。如果string小于target，则localeCompare()返回小于0的数。如果string大干target，该方法返回大于0的数。如果两个字符串相等，或根据本地排序规约没有区别，该方法返回0。 描述 把<和>运算符应用到字符串时，它们只用字符的Unicode编码比较字符串，而不考虑当地的排序规约。以这种方法生成的顺序不一定是正确的。例如，西班牙语中，其中字母“ch”通常作为出现在字母“c”和“d”之间的字符来排序。 localeCompare()方法提供的比较字符串的方法，考虑了默认的本地排序规约。 ECMAScript标准没有规定如何进行本地特定的比较操作，它只规定该函数采用底层 操作系统提供的排序规约。 示例 可以用下列代6马，按照地方特定的排序规约对一个字符串数组排序。 var strings; // 要排序的字符串数组，可以在任何地方初始化 strings.sort(function(a,b) { return a.localeCompare(b) });
| String.match( ) |
找到一个或多个正则表达式的匹配 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 语法 string.match(regexp) 参数 regexp 声明了要匹配的模式的RegExp对象。如果该参数不是RegExp对象，则首先将把它传递给RegExp()构造函数，把它转换成RegExp对象。 返回值 存放匹配结果的数组。该数组的内容依赖于regexp是否具有全局性质g。下面详细说明了这个返回值。 描述 方法match()将检索字符串string，以找到一个或多个与regexp匹配的文本。这个方法的行为很大程度上依赖于regexp是否具有性质g。 如果regexp没有性质g，那么match()就只能在string中执行一次匹配，如果没有找到任何匹配的文本，match()将返回null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。该数组的第0个元素存放的是匹配文本，其余的元素存放的是与正则表达式的子表达式匹配的文本。除了这些常规的数组元素之外，返回的数组还含有两个对象属性。index属性声明的是匹配文本的起始字符在string中的位置，input属性声明的是对string的引用。 如果regexp具有标志g，那么match()将执行全局检索，找到string中的所有匹配子串。如果没有找到任何匹配的子串。它将返回null。如果找到了一个或多个匹配子串，它将返回一个数组。不过，全局匹配返回的数组的内容与前者大不相同，它的数组元素存放的是string中的所有匹配子串，而且它也没有index属性和input属性。注意，在全局匹配的模式下，match()既不提供与子表达式匹配的文本的信息，也不声明每个匹配子串的位置。如果你需要这些全局检索的信息，可以使用RegExp.exec()。 示例 下面的全局匹配可以找到字符串中的所有数字： "1 plus 2 equals 3".match(/\d+/g) // 返回 ["1", "2", "3"] 下面的非全局匹配使用了更加复杂的正则表达式，它具有几个用括号括起来的子表达式。与该表达式匹配的是一个URL，与它的子表达式匹配的是那个URL的协议部分、主机部分和路径部分： var url = /(\w+):\/\/([\w.]+)\/(\S*)/; var text = "Visit my home page at http://www.isp.com/~david"; var result = text.match(url); if (result != null) { var fullurl = result[0]; // 包含"http://www.isp.com/~david" var protocol = result[1]; // 包含"http" var host = result[2]; // 包含"www.isp.com" var path = result[3]; // 包含"~david" } 参阅 RegExp, RegExp.exec( ), RegExp.test( ), String.replace( ), String.search( ) |
| String.replace( ) |
替换一个与正则表达式匹配的子串 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 语法 string.replace(regexp, replacement) 参数 regexp 声明了要替换的模式的RegExp对象。如果该参数是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换成RegExp对象。 replacement 一个字符串，声明的是替换文本或生成替换文本的函数。详见描述部分。 返回值 一个新字符串，是用replacemenc替换了与regexp的第一次匹配或所有匹配之后得到的。 描述 字符串string的方法replace()执行的是查找并替换的操作。它将在string中查找与regexp相匹配的子串，然后用replacement替换这些子串。如果regexp具有全局性质g，那么replace()将替换所有的匹配子串。否则，它只替换第一个匹配子串。 replacement可能是字符串或函数。如果它是一个字符串，那么每个匹配都将由字符 串替换。但replacement中的$字符具有特殊的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。
| Characters |
Replacement |
| $1, $2, ... $99 |
与regexp中的第1到第99个子表达式相匹配的文本 |
| $& |
与regexp相匹配的子串 |
| $` |
位于匹配子串左侧的文本 |
| $' |
位于匹配子串右侧的文本 |
| $$ |
直接量$符号 |
ECMAScript v3规定，replace()方法的参数replacement可以是函数而不是字符串，JavaScipt 1.2和JScript 5.5实现了这一特性。在这种情况下，每个匹配都调用该函数，它返回的字符串将作为替换文本使用。该函数的第一个参数是匹配模式的字 符串。接下来的参数是与模式中的子表达式匹配的字符串，可以有0个或多个这样的参数。接下来参数是一个整数，声明了匹配在string中出现的位置。最后一个参数是string自身。 示例 要确保单词“JavaScript'’中的大写字符是正确的，可用下列代码： text.replace(/javascript/i, "JavaScript"); 要将名字“Doe，John”转换成“JohnDoe”的形式，可用下列代码： name.replace(/(\w+)\s*,\s*(\w+)/, "$2 $1"); 用花引号替换直引号，可用下列代码： text.replace(/"([^"]*)"/g, "``$1''"); 使字符串中所有单词的第一个字母都是大写的，可用下列代码： text.replace(/\b\w+\b/g, function(word) { return word.substring(0,1).toUpperCase( ) + word.substring(1); }); 参阅 RegExp, RegExp.exec( ), RegExp.test( ), String.match( ), String.search( ) |
| String.search( ) |
检索与正则表达式相匹配的子串 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 语法 string.search(regexp) 参数 regexp 要在字符串string中检索的RegExp对象，该对象具有指定的模式。如果该参数不是RegExp对象，则首先将它传递给RegExp()构造函数，把它转换成 RegExp对象。 返回值 string中第一个与regexp相匹配的子串的起始位置。如果没有找到任何匹配的子 串，则返回-1。 描述 方法search()将在字符串string中检索与regexp相匹配的子串，并且返回第一个匹配子串的第一个字符的位置。如果没有找到任何匹配的子串，则返回-1。 search()并不执行全局匹配，它将忽略标志g。它也忽略regexp的lastIndex属性，并且总是从字符串的开始进行检索，这意味着它总是返回string的第一个匹配的位置。 示例 var s = "JavaScript is fun"; s.search(/script/i) // 返回 4 s.search(/a(.)a/) // 返回 1 参阅 RegExp, RegExp.exec( ), RegExp.test( ), String.match( ), String.replace( ) |
| String.slice( ) |
抽取一个子串 |
可用性 JavaScript 1.2; JScript 3.0; ECMAScript v3 语法 string.slice(start, end) 参数 start 要抽取的片段的起始下标。如果是负数，那么该参数声明了从字符串的尾部开始算起的位置。也就是说，-1指字符串中的最后一个字符，-2指倒数第二个字符，以此类推。 end 紧接着要抽取的片段的结尾的下标。如果没有指定这一参数，那么要抽取的子串包括start到原字符串结尾的字符串。如果该参数是负数，那么它声明了从字符串的尾部开始算起的位置。 返回值 一个新字符串，包括字符串string从start开始(包括start)到end为止(不包 括end)的所有字符。 描述 方法slice()将返回一个含有字符串string的片段的字符串或返回它的一个子串。 但是该方法不修改string。 String对象的方法slice()、substring()和substr()(不建议使用)都返回字符串的指定部分。slice()比substring()要灵活一些，因为它允许使用负数作为参数。slice()与substr()有所不同， 因为它用两个字符的位置指定子串，而substr()则用字符位置和长度来指定子串。还要注意的是，String.slice()与Array.slice()相似。 示例 var s = "abcdefg"; s.slice(0,4) // 返回 "abcd" s.slice(2,4) // 返回 "cd" s.slice(4) // 返回 "efg" s.slice(3,-1) // 返回 "def" s.slice(3,-2) // 返回 "de" s.slice(-3,-1) // 应该返回 "ef";返回"abcdef" in IE 4 Bug 在JScript 3.0(InternetExplorer 4)中，参数start的值是不能是负数。负的start值指定的不是从字符串尾部开始算起的字符位置，而是指定第0个字符的位置。 参阅 Array.slice( ), String.substring( )
| String.split( ) |
将字符串分割成字符串数组 |
可用性 JavaScript 1.1; JScript 3.0; ECMAScript v1; 在ECMAScript v3中得到增强 语法 string.split(delimiter, limit) 参数 delimiter 字符串或正则表达式，从该参数指定的地方分割string。ECMAScript V3标准化了正则表达式作为定界符使用时的用法，JavaScript 1.2和JScript 3.0实现了它。JavaScriptl.1没有实现它。 limit 这个可选的整数指定了返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数字。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。ECMAScriptv3标准化了该参数，JavaScript 1.2和JScript 3.0实现了它。JavaScript 1.1没有实现它。 返回值 一个字符串数组，是通过在delimiter指定的边界处将字符串string分割成子串创建的。返回的数组中的子串不包括delimiter自身，但下面列出的情况除外。 描述 方法split()将创建并返回一个字符串数组，该数组中的元素是指定的字符串string 的子串，最多具有limit个。这些子串是通过从头到尾检索字符串中与delimiter 匹配的文本，在匹配文本之前和之后分割string得到的。返回的子串中不包括定界符 文本(下面提到的情况除外)。如果定界符从字符串开头开始匹配，返回的数组的第一个元素是空串，即出现在定界符之前的文本。同样，如果定界符与字符串的结尾匹 配，返回的数组的最后一个元素也是空串(假定与limit没有冲突)。 如果没有指定delimiter，那么它根本就不对string执行分割，返回的数组中只有一个元素，而不分割字符串元素。如果delimiter是一个空串或与空串匹配的正则表 达式，那么string中的每个字符之间都会被分割，返回的数组的长度与字符串长度相 等(假定王imic不小于该长度)。(注意，这是一种特殊情况，因为没有匹配第一个字符之前和最后一个字符之后的空串。) 前面说过，该方法返回的数组中的子串不包括用于分割字符串的定界符文本。但如果delimiter是包括子表达式的正则表达式，那么返回的数组中包括与这些子表达式匹 配的子串(但不包括与整个正则表达式匹配的文本)。 注意，String.split()执行的操作与Array.join()执行的操作相反。 示例 在使用结构复杂的字符串时，方法split()最有用。例如： "1:2:3:4:5".split(":"); // 返回 ["1","2","3","4","5"] "|a|b|c|".split("|"); // 返回 ["", "a", "b", "c", ""] split()方法的另—个常见用法是解析命令和与之相似的字符串，用空格将它们分割 成单词： var words = sentence.split(' '); 关于delimiter是一个空格的情况，详见“Bug'’小节。用正则表达式作为定界符， 很容易把字符串分割成单词： var words = sentence.split(/\s+/); 要把字符串分割成字符数组，可以用空串作为定界符。如果只想把字符串的前一部分 分割成字符数组，需要使用limit参数： "hello".split(""); // 返回 ["h","e","l","l","o"] "hello".split("", 3); // 返回 ["h","e","l"] 如果想使返回的数组包括定界符或定界符的一个或多个部分，可以使用带子表达式的正则表达式。例如，下面的代码将在HTML标记处分割字符串，返回的数组中包括这些标记： var text = "hello <b>world</b>"; text.split(/(<[^>]*>)/); // 返回 ["hello ","<b>","world","</b>",""] Bug 在JavaScript的Netscape实现中，如果明确地把语言版本设置为1.2，split()方法具有特殊的行为，即如果delimiter 是一个空格，该方法将在空格处分割字符串，忽略字符串开头和结尾处的空白。 参阅 Array.join( ), RegExp; Chapter 10 |
|
可用性 JavaScript 1.2; JScript 3.0; 不赞成使用 语法 string.substr(start, length) 参数 start 要抽取的子串的起始下标。如果是一个负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1指字符串中的最后—个字符，-2指倒数第二个字符，以此类推。 length 子串中的字符数。如果省略了这个参数，那么返回从string的开始位置到结尾的子串。 返回值 一个字符串的副本，包括从string的start处(包括start所指的字符)开始的1ength个字符。如果没有指定length，返回的字符串包含从start到string结尾的字符。 描述 substr()将在string中抽取并返回一个子串。但是它并不修改string。 注意，substr()指定的是子串的开始位置和长度，它是String.substring()和String.splice()的一种有用的替代方法，后两者指定的都是起始字符的位置。但要注意，ECMAScript没有标准化该方法，因此反对使用它。 示例 var s = "abcdefg"; s.substr(2,2); // 返回 "cd" s.substr(3); // 返回 "defg" s.substr(-3,2); // 应该返回 "ef"; 在IE4中返回 "ab" Bug 在lScript 3.0(Internet Explorer 4)中，参数start的值不能为负数。负的start值指定的不是从字符串尾部开始算起的字符位置，而是第0个字符的位置。 参阅 String.slice( ), String.substring( )
| String.substring( ) |
返回字符串的一个子串 |
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 语法 string.substring(from, to) 参数 from 一个整数，声明了要抽取的子串的第一个字符在string中的位置。 to 一个可选的整数，比要抽取的子串的最后一个字符在string中的位置多1。如果省略了该参数，返回的子串直到字符串的结尾。 返回值 一个新字符串，其长度为to-from，存放的是字符串string的一个子串。这个新字符串含有的字符是从string中的from处到to-1处复制的。 描述 String.substring()将返回字符串string的子串，由from到to之间的字符构成， 包括位于from的字符，不包括位于to的字符。 如果参数from与to相等，那么该方法返回的就是一个空串(即长度为0的字符串)。 如果from比to大，那么该方法在抽取子串之前会先交换这两个参数。 要记住，该子串包括from处的字符，不包括to处的字符。虽然这样看来有违直觉， 但这种系统一个值得注意重要特性是，返回的子串的长度总等于to-from。 Bug 在JavaScript的Netscape实现中，如果明确地把语言版本设置为1.2(如把<script>标记的language性质设置为1.2)，那么如果from比to大，该方法不能正确地交换它的参数，而是返回空串。 参阅 String.charAt( ), String.indexOf( ), String.lastIndexOf( ), String.slice( ), String.substr( )
| String.toLocaleLowerCase( ) |
把字符串转换小写 |
可用性 JavaScript 1.5; JScript 5.5, ECMAScript v3 语法 string.toLocaleLowerCase( ) 返回值 string的一个副本，按照本地方式转换成小写字母。只有几种语言(如土耳其语)具有地方特有的大小写映射，所以该方法的返回值通常与toLowerCase()一样。 参阅 String.toLocaleUpperCase( ), String.toLowerCase( ), String.toUpperCase( )
| String.toLocaleUpperCase( ) |
将字符串转换成大写 |
可用性 JavaScript 1.5; JScript 5.5, ECMAScript v3 语法 string.toLocaleUpperCase( ) 返回值 string的一个副本，按照本地方式转换成了大写字母。只有几种语言(如土耳其语) 具有地方特有的大小写映射，所以该方法的返回值通常与toUpperCase()一样。 参阅 String.toLocaleLowerCase( ), String.toLowerCase( ), String.toUpperCase( )
| String.toLowerCase( ) |
将字符串转换成小写 |
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 语法 string.toLowerCase( ) 返回值 string的一个副本，其中所有大写字符都被转换成了小写字符。
| String.toUpperCase( ) |
将字符串转换成大写 |
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 语法 string.toUpperCase( ) 返回值 string的一个副本，其中所有小写字符都被转换成了大写的。 |
|
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 Overrides Object.valueOf( ) 语法 string.valueOf( ) 返回值 string的原始字符串值。 抛出 TypeError 调用该方法的对象不是String时抛出该异常。 参阅 String.toString( ) |
| String.toString( ) |
返回字符串 |
可用性 JavaScript 1.0; JScript 1.0, ECMAScript v1 Overrides Object.toString( ) 语法 string.toString( ) 返回值 string的原始字符串值。一般不会调用该方法。 抛出 TypeError 调用该方法的对象不是String时抛出该异常。 参阅 String.valueOf( ) |
|
