Jscript 有三种主要数据类型、两种复合数据类型和两种特殊数据类型。

主要（基本）数据类型是：

• 字符串
• 数值
• 布尔

复合（引用）数据类型是：

• 对象
• 数组

特殊数据类型是：

• Null
• Undefined

字符串数据类型

一个字符串值是排在一起的一串零或零以上的 Unicode 字符（字母、数字和标点符号）。字符串数据类型用来表示 JScript 中的文本。脚本中可以包含字符串文字，这些字符串文字放在一对匹配的的单引号或双引号中。字符串中可以包含双引号，该双引号两边需加单引号，也可以包含单引号，该单引号两边需加双引号。下面是字符串的示例：

				
						"Happy am I; from care I’m free!"
'"Avast, ye lubbers!" roared the technician.' 
"42"
'c'
				
		

请注意，JScript 中没有表示单个字符的类型（如 C++ 的 char）。要表示 Jscript 中的单个字符，应创建一个只包含一个字符的字符串。包含零个字符（""）的字符串是空（零长度）字符串。

数值数据类型

在 Jscript 中整数和浮点值没有差别；JScript 数值可以是其中任意一种（JScript 内部将所有的数值表示为浮点值）。

整型值

整型值可以是正整数，负整数和 0。可以用 10 进制，8 进制和 16 进制来表示。在 Jscript 中大多数字是用十进制表示的。加前缀“0”表示 8 进制的整型值，只能包含 0 到 7 的数字。前缀为“0”同时包含数字“8”或“9”的数被解释为十进制数。

加前缀“0x”（零和x|X）表示 16 进制整型值。可以包含数字 0 到 9，以及字母 A 到 F（大写或小写）。使用字母 A 到 F 表示十进制 10 到 15 的单个数字。就是说 0xF 与 15 相等，同时 0x10 等于 16。

八进制和十六进制数可以为负，但不能有小数位，同时不能以科学计数法（指数）表示。

浮点值

浮点值为带小数部分的数。也可以用科学计数法来表示。这就是说，大写或小写“e”用来表示 10 的次方。Jscript用数值表示的八字节 IEEE754 浮点标准。这意味着数字最大可以到±1.7976931348623157x10³⁰⁸，最小到±5x10^-324。以“0”开始且包含小数点的数字被解释为小数浮点数。

注意以“0x”或“00”开始并包含小数点的数将发生错误。以下是 Jscript 中数字的例子。

另外，JScript包含特殊值数字。它们是：

• NaN （不是数）。当对不适当的数据进行数学运算时使用，例如字符串或未定义值。
• 正无穷大。在JScript中如果一个正数太大的话使用它来表示。
• 负无穷大。在JScript中如果一个负数太大的话使用它来表示。
• 正0和负0。Jscript区分正0和负0。

Boolean数据类型

尽管字符串和数字类型可以有无数不同的值，boolean 数据类型却只有两个值。它们是文字 true 和 false。Boolean值是一个真值，它表示一个状态的有效性（说明该状态为真或假）。

脚本中的比较通常得到一个 Boolean 结果。考虑下一行 Jscript 代码。

				
						y = (x == 2000);
				
		

这里要比较变量 x 的值是否与数字 2000 相等。如果相等，比较的结果为 Boolean 值 true，并将其赋给变量 y。如果x与2000不等，则比较的结果为boolean值false。

Boolean值在结构控制中尤其有用。可以将直接创建 boolean 值的比较与用使用该 boolean 值的语句相组合。考虑下面的JScript代码范例。

				
						if (x == 2000)
    z = z + 1;
else
    x = x + 1;
				
		

当 boolean 值为 true 时，Jscript 中的 if/else 语句执行一个操作（这样，z = z + 1），而当 boolean 值为 false 时执行另一个操作（x = x + 1）。

可以使用任意表达式作比较表达式。任何值为0、null、未定义或空字符串的表达式被解释为 false。其他任意值的表达式解释为 true。例如，可以使用如下表达式：

				
						
								if (x = y + z) // 这可能不是想要的结果 – 如下！
				
		

注意上面的代码并不检查 x 是否与 y+z 相等，因为仅使用了一个等号（赋值）。相反的，上面的代码将 y+z 赋给变量 x，然后检查整个表达式的值是否为零。要检查 x 是否与 y+z 相等，使用如下代码。

				
						
								if (x == y + z) // 这与上面的代码不同！
				
		

Null 数据类型

在 Jscript 中数据类型 null 只有一个值：null。关键字 null 不能用作函数或变量的名称。

包含 null 的变量包含“无值”或“无对象”。换句话说，该变量没有保存有效的数、字符串、boolean、数组或对象。可以通过给一个变量赋 null 值来清除变量的内容。

请注意，在 Jscript 中，null 与 0 不相等（与在 C 和 C++ 中不同）。同时应该指出的是，Jscript中 typeof 运算符将报告 null 值为 Object 类型，而非类型 null。这点潜在的混淆是为了向下兼容。

Undefined 数据类型

如下情况使返回 undefined 值：

• 对象属性不存在，
• 声明了变量但从未赋值。

注意不能通过与 undefined 做比较来测试一个变量是否存在，虽然可以检查它的类型是否为“undefined”。在以下的代码范例中，假设程序员想测试是否已经声明变量 x ：

				
						
								// 这种方法不起作用
if (x == undefined)    // 作某些操作

// 这个方法同样不起作用- 必须检查
// 字符串 "undefined"if (typeof(x) == undefined)    // 作某些操作

// 这个方法有效
if (typeof(x) == "undefined")    // 作某些操作
				
		

考虑将 undefined 值与null做比较。

				
						someObject.prop == null;
				
		

如下情况时，比较的结果为 true，

• 如果属性 someObject.prop 包含 null 值，
• 如果属性 someObject.prop 不存在。
• 要检查一个对象属性是否存在，可以使用新的 in 运算符：

				
						
								if ("prop" in someObject)
// someObject 有属性
						
								 'prop'




								

										
										
										运算符
								
								

										JScript 具有全范围的运算符,包括算术、逻辑、位、赋值以及其他某些运算符。
								
								

										

												

														

																计算
														
														

																逻辑
														
														

																位运算
														
														

																赋值
														
														

																杂项
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
												
												

														

																描述
														
														

																符号
														
														

																描述
														
														

																符号
														
														

																描述
														
														

																符号
														
														

																描述
														
														

																符号
														
														

																描述
														
														

																符号
														
												
												

														

																
																		负值
																
														
														

																-
														
														

																
																		逻辑非
																
														
														

																!
														
														

																
																		按位取反
																
														
														

																~
														
														

																
																		赋值
																
														
														

																=
														
														

																
																		删除
																
														
														

																delete
														
												
												

														

																
																		递增
																
														
														

																++ 
														
														

																
																		小于
																
														
														

																<
														
														

																
																		按位左移
																
														
														

																<< 
														
														

																
																		运算赋值
																
														
														

																
																		
																				oP= 
																
														
														

																
																		typeof 运算符
																
														
														

																typeof
														
												
												

														

																
																		递减
																
														
														

																-- 
														
														

																
																		大于
																
														
														

																>
														
														

																
																		按位右移
																
														
														

																>> 
														
														

																 
														
														

																 
														
														

																
																		void 
																
														
														

																void
														
												
												

														

																
																		乘法
																
														
														

																*
														
														

																
																		小于等于
																
														
														

																<=
														
														

																
																		无符号右移
																
																
																		
																		
																
														
														

																>>> 
														
														

																 
														
														

																 
														
														

																
																		instanceof
																
														
														

																instanceof
														
												
												

														

																
																		除法
																
														
														

																/
														
														

																
																		大于等于
																
														
														

																>=
														
														

																
																		按位与
																
																
																		
																		
																
														
														

																& 
														
														

																 
														
														

																 
														
														

																
																		new
																
														
														

																new
														
												
												

														

																
																		取模运算
																
														
														

																%
														
														

																
																		等于
																
														
														

																==
														
														

																
																		按位异或
																
																
																		
																		
																
														
														

																^ 
														
														

																 
														
														

																 
														
														

																
																		in
																
														
														

																in
														
												
												

														

																
																		加法
																
														
														

																+
														
														

																
																		不等于
																
														
														

																!=
														
														

																
																		按位或
																
																
																		
																		
																
														
														

																| 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
												
												

														

																
																		减法
																
														
														

																-
														
														

																
																		逻辑与
																
														
														

																&&
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
												
												

														

																 
														
														

																 
														
														

																
																		逻辑或
																
														
														

																||
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
												
												

														

																 
														
														

																 
														
														

																
																		条件（三元运算符）
																
														
														

																?: 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
												
												

														

																 
														
														

																 
														
														

																
																		逗号
																
														
														

																,
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
												
												

														

																 
														
														

																 
														
														

																
																		严格相等
																
														
														

																===
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
														

																 
														
												
												

														

																 
														
														

																 
														
														

																
																		非严格相等
																
														
														

																!==