版本 276548 / 文本化

  • 版本网址缩略名: Core_JavaScript_1.5_Guide/文本化
  • 版本标题: 文本化
  • 版本 id: 276548
  • 创建于:
  • 创建者: alzhu
  • 是否是当前版本?
  • 评论 1 words added, 1 words removed

修订内容

常数(Literals)

在JavaScript中,你可以使用常数来代替值。他们是固定的值,不是变量,让你从“字面上”理解脚本。这一节介绍了如下常数类型:

  • {{ Anch("Array Literals") }}
  • {{ Anch("Boolean Literals") }}
  • {{ Anch("Floating-Point Literals") }}
  • {{ Anch("Integers") }}
  • {{ Anch("Object Literals") }}
  • {{ Anch("String Literals") }}

数组常数(Literals)

数组常数就是被包围在中括号([])中的,零个以上表达式,每一个表达式是一个数组元素。当你用数组常数建立数组的时候,他会用你给的值来初始化他的元素,他的长度是你设定的元素数。

下面的例子,建立了一个叫coffees的数组,有三个元素,数组的长度为三。

var coffees = ["French Roast", "Colombian", "Kona"];

注意 数组常数是对象初始化器的一种。参见使用对象初始化器

如果在全局脚本中用常数定义了一个数组,则JavaScript每次使用时都要计算数组常数中的表达式的值。也就是说,在函数中使用的常数,每次调用函数是都会被创建。

数组常数也是数组对象。详细请参见数组对象

数组常数中多余的逗号

你不必列出数组常数中的所有元素。如果你在一行中写了两个逗号,数组也为没写上元素预留了空间。下面的例子建立了一个fish数组:

var fish = ["Lion", , "Angel"];

这个数组有两个有值的元素和一个空的元素(fish{{ mediawiki.external("0") }}是"Lion"、fish{{ mediawiki.external("1") }}undefinedfish{{ mediawiki.external("2") }}是"Angel")。

如果你在元素列表的末尾附加了逗号,他们将被忽略。接下来的例子中,数组的长度是3。不存在元素myList{{ mediawiki.external("3") }}。列表中的所有其他的逗号都会对应生成新元素。

var myList = ['home', , 'school', ];

下面的例子中,数组的长度是4,myList{{ mediawiki.external("0") }}myList{{ mediawiki.external("2") }}的值是未定义。

var myList = [ , 'home', , 'school'];

在下面的例子中,数组的长度是4,myList{{ mediawiki.external("1") }}myList{{ mediawiki.external("3") }}的值是未定义。只是最后面的多余逗号被忽略。

var myList = ['home', , 'school', , ];

布尔常数

布尔类型有两个常数值:truefalse

不要把原始的布尔值truefalse与布尔对象的真假值相混淆。布尔对象是围绕原始布尔数据类型的包装。详细请参见布尔对象

整数

整数可以表示为十进制、十六进制和八进制。十进制的整数用不带前导零的数字组成;在其前面加上前导零则为八进制;使用前导字符0x开始的是十六进制整数。十六进制整数的一位可以包括数字(0-9)和字母a-f或A-F。八进制使用数字0-7表示。

八进制整形常数在ECMA-262第三版中已经不推荐使用,并被删除了。为了向前兼容,JavaScript 1.5仍然支持。

一些整形常数的实例:

0、117、-345 (十进制)
015、0001、-077 (八进制)
0x1123、0x00111、-0xF1A7 (十六进制)

浮点常数

浮点常数可以由以下部分组成:

  • 带符号的十进制整数(以“+”或“-”开头);
  • 小数点(“.”);
  • 小数部分(另一个十进制数);
  • 指数。

指数部分是由“e”或“E”后跟带符号整数(以“+”或“-”开头)构成。浮点常数必须包括至少一位数字和一个小数点或“e”(或“E”)。

一些浮点数的例子 3.1415、-3.1E12、.1e12、2E-12。

简单的语法如下:

[数字][.数字][(E|e)[(+|-)]数字]

例如:

3.14
2345.789
.3333333333333333333

对象常数

对象常数是由大括号({})括起来的零个或多个对象的属性名-值对。不要再语句的开始处使用对象常数。因为“{”将被解释为块开始标志,这将导致错误或者程序不像你预期的那样执行。

下面是对象常数的例子。car对象的第一个元素是myCar属性;第二个元素是调用了(CarTypes("Honda"));函数的getCar属性;第三个元素是使用了既存变量Salesspecial属性。

var Sales = "Toyota";

function CarTypes(name) {
  if (name == "Honda")
     return name;
  else
     return "Sorry, we don't sell " + name + ".";
}

var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };

document.write(car.myCar); // Saturn
document.write(car.getCar); // Honda
document.write(car.special); // Toyota

另外,你也可以使用数字或字符串常数作为属性名,也可以在一个对象常数中嵌入其他对象常数。示例如下:

var car = { manyCars: {a: "Saab", b: "Jeep"}, 7: "Mazda" };

document.write(car.manyCars.b); // Jeep
document.write(car[7]); // Mazda

注意:

var foo = {a: "alpha", 2: "two"};
document.write(foo.a);    // alpha
document.write(foo[2]);   // two
//document.write(foo.2);  // 出错: missing ) after argument list
//document.write(foo[a]); // 出错: a is not defined
document.write(foo["a"]); // alpha
document.write(foo["2"]); // two

字符串常数

字符串常数是由双引号(")或单引号(')包围起来的零个或多个字符组成的。字符串必须有相同的引号包围起来,也就是必须有两个双引号或两个单引号围起来。下面是字符串的例子:

  • "blah"
  • 'blah'
  • "1234"
  • "one line \n another line"
  • "John's cat"

你可以在字符串常数上调用任何字符串的方法——JavaScript会自动将字符串常数转换为临时字符串对象、调用方法、释放临时对象。你可以在字符串常数上使用String.length属性:

  • "John's cat".length

你应该使用字符串常数,必要的时候再使用字符串对象。关于字符串对象的详细内容请参见 字符串对象

在字符串中使用特殊字符

除了普通字符,字符串还可以包含特殊字符。示例如下:

"one line \n another line"

下表列出了在JavaScript的字符串中可以使用的特殊字符。

字符 含义
\b 退格
\f 换页
\n 换行
\r 回车
\t 水平制表
\v 垂直制表
\' 单引号
\" 双引号
\\ 反斜线(\)
\XXX 使用0到377之间,最多三位八进制数来表示Latin-1编码的字符。例如,\251是八进制的版权符号
\xXX 使用00到FF之间,两位十六进制数来表示Latin-1编码的字符。例如,\xA9是十六进制的版权符号
\uXXXX 使用四位十六进制数来表示Unicode字符。例如,\u00A9是Unicode的版权符号。参见Unicode转义序列

表2.1: JavaScript特殊字符

转义字符

对于没有列在表2.1中的字符,反斜线将被忽略,不推荐这样使用。

你可以通过在双引号前面使用一个反斜线来在字符串中插入一个双引号。这就是双引号的转义。例如:

var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
document.write(quote);

结果如下:

He read "The Cremation of Sam McGee" by R.W. Service.

要直接在字符串中包含反斜线,你必须转义这个反斜线字符。例如,要表示文件路径c:\temp,可以使用如下方法:

var home = "c:\\temp";

{{ PreviousNext("Core_JavaScript_1.5_Guide:常量", "Core_JavaScript_1.5_Guide:Unicode") }}

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Literals", "es": "es/Gu\u00eda_JavaScript_1.5/Literales", "fr": "fr/Guide_JavaScript_1.5/Constantes_litt\u00e9rales", "ja": "ja/Core_JavaScript_1.5_Guide/Literals", "ko": "ko/Core_JavaScript_1.5_Guide/Literals", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Litera\u0142y" } ) }}

修订版来源

<p>
</p>
<h3 name=".E5.B8.B8.E6.95.B0.EF.BC.88Literals.EF.BC.89"> 常数(Literals) </h3>
<p>在JavaScript中,你可以使用常数来代替值。他们是固定的值,不是变量,让你从“字面上”理解脚本。这一节介绍了如下常数类型:
</p>
<ul><li> {{ Anch("Array Literals") }}
</li><li> {{ Anch("Boolean Literals") }}
</li><li> {{ Anch("Floating-Point Literals") }}
</li><li> {{ Anch("Integers") }}
</li><li> {{ Anch("Object Literals") }}
</li><li> {{ Anch("String Literals") }}
</li></ul>
<h4 name=".E6.95.B0.E7.BB.84.E5.B8.B8.E6.95.B0.EF.BC.88Literals.EF.BC.89"> 数组常数(Literals) </h4>
<p>数组常数就是被包围在中括号([])中的,零个以上表达式,每一个表达式是一个数组元素。当你用数组常数建立数组的时候,他会用你给的值来初始化他的元素,他的长度是你设定的元素数。
</p><p>下面的例子,建立了一个叫<code>coffees</code>的数组,有三个元素,数组的长度为三。
</p>
<pre class="eval">var coffees = ["French Roast", "Colombian", "Kona"];
</pre>
<p><b>注意</b> 数组常数是对象初始化器的一种。参见<a href="cn/Core_JavaScript_1.5_Guide/Creating_New_Objects/Using_Object_Initializers">使用对象初始化器</a>。
</p><p>如果在全局脚本中用常数定义了一个数组,则JavaScript每次使用时都要计算数组常数中的表达式的值。也就是说,在函数中使用的常数,每次调用函数是都会被创建。
</p><p>数组常数也是数组对象。详细请参见<a href="cn/Core_JavaScript_1.5_Guide/Predefined_Core_Objects/Array_Object">数组对象</a>。
</p><p><b>数组常数中多余的逗号</b>
</p><p>你不必列出数组常数中的所有元素。如果你在一行中写了两个逗号,数组也为没写上元素预留了空间。下面的例子建立了一个<code>fish</code>数组:
</p>
<pre class="eval">var fish = ["Lion", , "Angel"];
</pre>
<p>这个数组有两个有值的元素和一个空的元素(<code>fish{{ mediawiki.external("0") }}</code>是"Lion"、<code>fish{{ mediawiki.external("1") }}</code>是<code>undefined</code>、<code>fish{{ mediawiki.external("2") }}</code>是"Angel")。
</p><p>如果你在元素列表的末尾附加了逗号,他们将被忽略。接下来的例子中,数组的长度是3。不存在元素<code>myList{{ mediawiki.external("3") }}</code>。列表中的所有其他的逗号都会对应生成新元素。
</p>
<pre class="eval">var myList = ['home', , 'school', ];
</pre>
<p>下面的例子中,数组的长度是4,<code>myList{{ mediawiki.external("0") }}</code>和<code>myList{{ mediawiki.external("2") }}</code>的值是未定义。
</p>
<pre class="eval">var myList = [ , 'home', , 'school'];
</pre>
<p>在下面的例子中,数组的长度是4,<code>myList{{ mediawiki.external("1") }}</code>和<code>myList{{ mediawiki.external("3") }}</code>的值是未定义。只是最后面的多余逗号被忽略。
</p>
<pre class="eval">var myList = ['home', , 'school', , ];
</pre>
<h4 name=".E5.B8.83.E5.B0.94.E5.B8.B8.E6.95.B0"> 布尔常数 </h4>
<p>布尔类型有两个常数值:<code>true</code>和<code>false</code>。
</p><p>不要把原始的布尔值<code>true</code>、<code>false</code>与布尔对象的真假值相混淆。布尔对象是围绕原始布尔数据类型的包装。详细请参见<a href="cn/Core_JavaScript_1.5_Guide/Predefined_Core_Objects/Boolean_Object">布尔对象</a>。
</p>
<h4 name=".E6.95.B4.E6.95.B0">整数</h4>
<p>整数可以表示为十进制、十六进制和八进制。十进制的整数用不带前导零的数字组成;在其前面加上前导零则为八进制;使用前导字符0x开始的是十六进制整数。十六进制整数的一位可以包括数字(0-9)和字母a-f或A-F。八进制使用数字0-7表示。</p>
<p>八进制整形常数在ECMA-262第三版中已经不推荐使用,并被删除了。为了向前兼容,JavaScript 1.5仍然支持。</p>
<p>一些整形常数的实例:</p>
<pre class="eval">0、117、-345 (十进制)
015、0001、-077 (八进制)
0x1123、0x00111、-0xF1A7 (十六进制)
</pre><h4 name=".E6.B5.AE.E7.82.B9.E5.B8.B8.E6.95.B0"> 浮点常数 </h4>
<p>浮点常数可以由以下部分组成:
</p>
<ul><li> 带符号的十进制整数(以“+”或“-”开头);
</li><li> 小数点(“.”);
</li><li> 小数部分(另一个十进制数);
</li><li> 指数。
</li></ul>
<p>指数部分是由“e”或“E”后跟带符号整数(以“+”或“-”开头)构成。浮点常数必须包括至少一位数字和一个小数点或“e”(或“E”)。
</p><p>一些浮点数的例子 3.1415、-3.1E12、.1e12、2E-12。
</p><p>简单的语法如下:
</p>
<pre class="eval">[数字][.数字][(E|e)[(+|-)]数字]
</pre>
<p>例如:
</p>
<pre class="eval">3.14
2345.789
.3333333333333333333
</pre>
<h4 name=".E5.AF.B9.E8.B1.A1.E5.B8.B8.E6.95.B0"> 对象常数 </h4>
<p>对象常数是由大括号({})括起来的零个或多个对象的属性名-值对。不要再语句的开始处使用对象常数。因为“{”将被解释为块开始标志,这将导致错误或者程序不像你预期的那样执行。
</p><p>下面是对象常数的例子。<code>car</code>对象的第一个元素是<code>myCar</code>属性;第二个元素是调用了<code>(CarTypes("Honda"));</code>函数的<code>getCar</code>属性;第三个元素是使用了既存变量<code>Sales</code>的<code>special</code>属性。
</p>
<pre class="eval">var Sales = "Toyota";

function CarTypes(name) {
  if (name == "Honda")
     return name;
  else
     return "Sorry, we don't sell " + name + ".";
}

var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };

document.write(car.myCar); // Saturn
document.write(car.getCar); // Honda
document.write(car.special); // Toyota
</pre>
<p>另外,你也可以使用数字或字符串常数作为属性名,也可以在一个对象常数中嵌入其他对象常数。示例如下:
</p>
<pre class="eval">var car = { manyCars: {a: "Saab", b: "Jeep"}, 7: "Mazda" };

document.write(car.manyCars.b); // Jeep
document.write(car[7]); // Mazda
</pre>
<p>注意:
</p>
<pre class="eval">var foo = {a: "alpha", 2: "two"};
document.write(foo.a);    // alpha
document.write(foo[2]);   // two
//document.write(foo.2);  // 出错: missing ) after argument list
//document.write(foo[a]); // 出错: a is not defined
document.write(foo["a"]); // alpha
document.write(foo["2"]); // two
</pre>
<h4 name=".E5.AD.97.E7.AC.A6.E4.B8.B2.E5.B8.B8.E6.95.B0"> 字符串常数 </h4>
<p>字符串常数是由双引号(")或单引号(')包围起来的零个或多个字符组成的。字符串必须有相同的引号包围起来,也就是必须有两个双引号或两个单引号围起来。下面是字符串的例子:
</p>
<ul><li> "blah"
</li><li> 'blah'
</li><li> "1234"
</li><li> "one line \n another line"
</li><li> "John's cat"
</li></ul>
<p>你可以在字符串常数上调用任何字符串的方法——JavaScript会自动将字符串常数转换为临时字符串对象、调用方法、释放临时对象。你可以在字符串常数上使用<code>String.length</code>属性:
</p>
<ul><li> "John's cat".length
</li></ul>
<p>你应该使用字符串常数,必要的时候再使用字符串对象。关于字符串对象的详细内容请参见 <a href="cn/Core_JavaScript_1.5_Guide/Predefined_Core_Objects/String_Object">字符串对象</a>。
</p>
<h5 name=".E5.9C.A8.E5.AD.97.E7.AC.A6.E4.B8.B2.E4.B8.AD.E4.BD.BF.E7.94.A8.E7.89.B9.E6.AE.8A.E5.AD.97.E7.AC.A6"> 在字符串中使用特殊字符 </h5>
<p>除了普通字符,字符串还可以包含特殊字符。示例如下:
</p>
<pre class="eval">"one line \n another line"
</pre>
<p>下表列出了在JavaScript的字符串中可以使用的特殊字符。
</p>
<table class="fullwidth-table">
<tbody><tr>
<th>字符</th>
<th>含义</th>
</tr>
<tr>
<td>\b</td>
<td>退格</td>
</tr>
<tr>
<td>\f</td>
<td>换页</td>
</tr>
<tr>
<td>\n</td>
<td>换行</td>
</tr>
<tr>
<td>\r</td>
<td>回车</td>
</tr>
<tr>
<td>\t</td>
<td>水平制表</td>
</tr>
<tr>
<td>\v</td>
<td>垂直制表</td>
</tr>
<tr>
<td>\'</td>
<td>单引号</td>
</tr>
<tr>
<td>\"</td>
<td>双引号</td>
</tr>
<tr>
<td>\\</td>
<td>反斜线(\)</td>
</tr>
<tr>
<td>\<i>XXX</i></td>
<td>使用0到377之间,最多三位八进制数来表示Latin-1编码的字符。例如,\251是八进制的版权符号</td>
</tr>
<tr>
<td>\x<i>XX</i></td>
<td>使用00到FF之间,两位十六进制数来表示Latin-1编码的字符。例如,\xA9是十六进制的版权符号</td>
</tr>
<tr>
<td>\u<i>XXXX</i></td>
<td>使用四位十六进制数来表示Unicode字符。例如,\u00A9是Unicode的版权符号。参见<a href="cn/Core_JavaScript_1.5_Guide/Unicode#Unicode_Escape_Sequences">Unicode转义序列</a>。</td>
</tr>
</tbody></table>
<p><small><b>表2.1: JavaScript特殊字符</b></small>
</p>
<h5 name=".E8.BD.AC.E4.B9.89.E5.AD.97.E7.AC.A6"> 转义字符 </h5>
<p>对于没有列在表2.1中的字符,反斜线将被忽略,不推荐这样使用。
</p><p>你可以通过在双引号前面使用一个反斜线来在字符串中插入一个双引号。这就是双引号的转义。例如:
</p>
<pre class="eval">var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
document.write(quote);
</pre>
<p>结果如下:
</p>
<pre class="eval">He read "The Cremation of Sam McGee" by R.W. Service.
</pre>
<p>要直接在字符串中包含反斜线,你必须转义这个反斜线字符。例如,要表示文件路径<code>c:\temp</code>,可以使用如下方法:
</p>
<pre class="eval">var home = "c:\\temp";
</pre>
<p>{{ PreviousNext("Core_JavaScript_1.5_Guide:常量", "Core_JavaScript_1.5_Guide:Unicode") }}
</p>
<div class="noinclude">
</div>
{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Literals", "es": "es/Gu\u00eda_JavaScript_1.5/Literales", "fr": "fr/Guide_JavaScript_1.5/Constantes_litt\u00e9rales", "ja": "ja/Core_JavaScript_1.5_Guide/Literals", "ko": "ko/Core_JavaScript_1.5_Guide/Literals", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Litera\u0142y" } ) }}
恢复到这个版本