javascript运算符的使用

JavaScript都有些什么运算符？有什么要特别注意的？我是个新手，哪个大牛帮我总结下。

javascript具有下列种类的运算符：算术运算符;等同运算符与全同运算符;比较运算符; 2、目的分类：字符串运算符;逻辑运算符;逐位运。

1、javascript具有下列种类的运算符：算术运算符;等同运算符与全同运算符;比较运算符;2、目的分类：字符串运算符;逻辑运算符;逐位运算符;赋值运算符;3、特殊运算符：条件运算符;typeof运算符;创建对象运算符new;delete运算符;void运算符号;逗号运算符;算术运算符：+ 、 - 、* 、 / 、 % 、 -(一元取反) 、 ++ 、等同运算符与全同运算符：== 、 ===、 !== 、 !===比较运算符：< 、 > 、 <= 、 >=字符串运算符：：< 、 > 、 <= 、 >= 、 = 、 +逻辑运算符：&& 、 、 !、赋值运算符：=、 +=、 *=、 -=、 /=规则：

一、一定要注意传递给运算符的数据类型和返回的数据类型!不同的运算符都期望它的运算数表达式计算出的结果符合某种数据类型。例如：对字符串是不能进行乘法运算的，"a" * "b" 是不合法的，但是，在可能的情况下，javascript会把表达式转换成正确的类型，因此，表达式 "3" * "5" 是合法的，javascript将字符串转换成数字执行运算，结果返回的是数字15，而不是字符串"15"。

二、+ 根据运算数的不同，具有不同的表现：字符串 + 字符串 = 字符串(被连接);"a" + "b" = "ab" "5" + "6" = "11"字符串 + 数字 = (字符串转换成数字)字符串(被连接);"a" + 5 = "a5" 5被转换成字符串 "1" + 0 = "10"数字 + 数字 = 数字(相加)5 + 5 = 10。

三、注意运算符的结合性，有些运算符从左到右的结合性;有些从右到左结合性。例如：w = a + b + c 等同于 w = (a + b) + c;w = -b 等同于 w = - ( - ( -b ) ); w = a = b = c 等同于 w= ( a = ( b = c ))一元运算符、赋值运算符、三元运算符的结合性是从右到左的;四、算术运算符规则：“+”：可以进行“加法”与“连接”运算;如果2个运算符中的一个是字符串，javascript就将另一个转换成字符串，然后将2个运算数连接起来。“+”：如果一个运算数是对象，javascript就会将对象转换成数字做加法运算或者字符串做连接运算;“-”“*”“/” 如果2个运算数中的一个是是非数字，则将它转化成数字执行数学运算。“/” 在javascript中，由于所有的数都是浮点数，除法的结果都是浮点数，5 / 2 = 2.5 ;除数为0的结果为正负无穷;0/0为NaN;“%”模运算符：计算第一个运算数对第二个运算数的模，就是第一个运算数被第二个运算数除时，返回余数。如果运算数是非数字的，则转换成数字。“-”一元取反：将运算数取反，如果运算数不是数字，则转化成数字。“++”“”增量运算符/减量运算符号：运算数必须是一个变量、树组的一个元素或对象的一个属性。如果运算数不是数字，则转换成数字。注意：如果“++”位于运算数之前，先对运算数进行增量，然后计算运算数增长后的值。如果“”位于运算数之后，先计算运算数未增长之前的值，然后对运算数增量。例如：i = 1; //赋值给i值1j = ++i; //先将i增量为2，然后将2赋值给j，i的值是2，j的值也是2。i = 1; //赋值给i值1j = i++; //先将i赋值给j，然后对将i值增量到2，i的值是2，j的值是1。减量运算符“”与“++”相同。

五、等同运算符与全同运算符：(一)“==”“!==”等同运算符与非等同运算符：比较2个运算数，返回一个不布尔值。比较数值、字符串、布尔值使用的都是量值。当且仅当两个变量存放的值相等的时候，他们才相等。比较对象、数组、函数的时候，使用的是引用，只有2个变量引用的是同一个对象时，他们才是相等的。两个不同的数组是完全不同的，即使他们具有完全相同的元素。对于存放对象、数组、函数的引用的变量来说，只有当他们引用的是同一个对象、数组、函数的时候，他们才相等。

注意!应遵循的原则：当两个运算数的类型不同时：将他们转换成相同的类型，1)一个数字与一个字符串，字符串转换成数字之后，进行比较。2)true转换为1、false转换为0，进行比较。3)一个对象、数组、函数 与 一个数字或字符串，对象、数组、函数转换为原始类型的值，然后进行比较。(先使用valueOf，如果不行就使用toString)4)其他类型的组合不星等。想两个运算数类型相同，或转换成相同类型后：1)2个字符串：同一位置上的字符相等，2个字符串就相同。2)2个数字：2个数字相同，就相同。如果一个是NaN，或两个都是NaN，则不相同。3)2个都是true，或者2个都是false，则想同。4)2个引用的是同一个对象、函数、数组，则他们相等，如果引用的不是同一个对象、函数、数组，则不相同，即使这2个对象、函数、数组可以转换成完全相等的原始值。5)2个null，或者2个都是未定义的，那么他们相等。“!=”非等同运算符：与等同运算符检测的结果相反。(二)“===”“!===”全同运算符与非全同运算符号：全同运算符遵循等同运算符的比较规则，但是它不对运算数进行类型转换，当两个运算数的类型不同时，返回false;只有当两个运算数的类型相同的时候，才遵循等同运算符的比较规则进行比较。“!==”非全同运算符与全同运算符比较的结果相反。如果两个运算数的类型或者值不同的时候，返回true。

六、比较运算符：这些比较运算符用于比较不同类型的值，结果返回一个布尔值。“<”“>”“<=”“>=”注意规则：比较的运算数可以是任意类型的，但是只能在数字和运算数上执行。不是数字和字符串的运算数将被转换成数字或字符串。1)如果两个运算数都是数字，或者都可以转换成数字，则按照数字的大小进行比较;2)如果两个运算数都是字符串，或者都可以转换成字符串，则将按照字母顺序进行比较;3)如果字符串遇到数字，则将字符串转换成数字进行比较。4)如果运算数既不能转换成数字，也不能转换成字符串，则返回结果false。

七、字符串运算符：并没有专用的字符串运算符，只是有些运算符在遇到字符串运算数的时候，表现不同。(一)“+”连接2个字符串;1)当2个运算数都是字符串的时候，连接起来;2)当其中有一个是数字的时候，将数字转换成字符串，连接起来;(二)“>”这样的比较运算符通过比较确认两个字符串的顺序，比较采用字符的顺序，较小的位于教大的前面，大写字母位于小写字母之前。(三)“+”的作用方法取决于计算顺序，如：s = 1 + 2 +"var" 则：返回结果3var; 因为先计算1+2，然后将结果3转换成字符串与"var"连接;如：s = "var" + 1 + 2 则：返回结果var12; 因为先计算var与1的连接，在将结果var1与转换成字符串的2连接起来。

八、逻辑运算符：用于执行布尔运算，常常和比较运算符一起使用，来表示复杂的比较运算。“&&” 逻辑与运算、“”逻辑或运算符、“!”逻辑非运算符(一)“&&”当两个运算数都是布尔值的时候，逻辑与对他们进行and操作，即：当且仅当两个布尔值都是true的时候，返回结果true，否则返回false。注意：实际表现“&&”将检测第一个表达式运算数布尔值，如果第一个运算数表达式返回false，则返回左边第一个运算数表达式的值：false;否则将继续检测第二个即右边的运算数表达式，然后返回第二个运算数表达式的值;例如：if (a = b) stop(); 与 (a = b) && stop(); 等价不赞成使用这个方法，因为运算符右边的代码不能保证会被执行，例如：if ((a < b) && (b++ <10) ) stop();如果运算符右边的增量必须的话，却有可能由于前面的返回值而不被执行，一般反对在&&的右边使用具有其他作用的表达式(赋值、函数调用、增减量);将“&&”看作是一个布尔代数的运算符，会更简单与安全。(二)“”当两个运算数都是布尔值的时候，逻辑或对他们进行or操作，即：当两个布尔值有一个是true的时候，返回结果true，否则返回false。注意：实际表现“”将检测第一个表达式运算数布尔值，如果第一个运算数表达式返回true，则返回左边第一个运算数表达式的值：true;否则将继续检测第二个即右边的运算数表达式，然后返回第二个运算数表达式的值;同样不赞成使用这个方法，因为运算符右边的代码不能保证会被执行，一般反对在的右边使用具有其他作用的表达式(赋值、函数调用、增减量);将“”看作是一个布尔代数的运算符，会更简单与安全。(三)“!”逻辑非是一个一元运算符，放在运算数之前，它的目的是对运算数取反。

九、赋值运算符：(一)“=”是赋值运算符;他总是期望左边的运算数是一个变量、数组的一个元素或对象的一个属性;期望右边是一个任意类型的任意的值;从右到左的结合性，如果一个表达式中有多个赋值运算符，则从最右边开始计算。注意：每一个赋值表达式都有一个值，就是运算符右边的值;(二)可以使用带操作的赋值运算“+=” 左边的值加上右边的值后，赋值于左边的值。“-=”“/=”“*=”方法一样;十、其他运算符：“?:”条件运算符是唯一的一个三元运算符;一个表达式的布尔结果?表达式1(任意类型的任意值)：表达式2(任意类型的任意值);根据第一个运算数的布尔值结果，如果为true，则执行第二个运算数表达式，返回第二个运算数表达式的值;如果第一个运算数的布尔值结果是false，则执行第三个运算数表达式，返回第三个运算数表达式的值。

移位运算符面向的运算对象也是二进制的“位”。可单独用它们处理整数类型（主类型的一种）。左移位运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。“有符号”右移位运算符（>>）则将运算符左边的运算对象向右移动运算符右侧指定的位数。“有符号”右移位运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。Java也添加了一种“无符号”右移位运算符（>>>），它使用了“零扩展”：无论正负，都在高位插入0。这一运算符是C或C++没有的。

若对char，byte或者short进行移位处理，那么在移位进行之前，它们会自动转换成一个int。只有右侧的5个低位才会用到。这样可防止我们在一个int数里移动不切实际的位数。若对一个long值进行处理，最后得到的结果也是long。此时只会用到右侧的6个低位，防止移动超过long值里现成的位数。但在进行“无符号”右移位时，也可能遇到一个问题。若对byte或short值进行右移位运算，得到的可能不是正确的结果（Java 1.0和Java 1.1特别突出）。它们会自动转换成int类型，并进行右移位。但“零扩展”不会发生，所以在那些情况下会得到-1的结果。可用下面这个例子检测自己的实现方案：

//: URShift.java。

// Test of unsigned right shift。

public class URShift {。

　public static void main(String[] args) {。

int i = -1;

i >>>= 10;。

System.out.println(i);。

long l = -1;

l >>>= 10;。

System.out.println(l);。

short s = -1;

s >>>= 10;。

System.out.println(s);。

byte b = -1;

b >>>= 10;。

System.out.println(b);。

　}

} ///:~

移位可与等号（<<=或>>=或>>>=）组合使用。此时，运算符左边的值会移动由右边的值指定的位数，再将得到的结果赋回左边的值。

下面这个例子向大家阐示了如何应用涉及“按位”操作的所有运算符，以及它们的效果：

//: BitManipulation.java。

// Using the bitwise operators。

import java.util.*;。

public class BitManipulation {。

　public static void main(String[] args) {。

Random rand = new Random();。

int i = rand.nextInt();。

int j = rand.nextInt();。

pBinInt("-1", -1);。

pBinInt("+1", +1);。

int maxpos = 2147483647;。

pBinInt("maxpos", maxpos);。

int maxneg = -2147483648;。

pBinInt("maxneg", maxneg);。

pBinInt("i", i);。

pBinInt("~i", ~i);。

pBinInt("-i", -i);。

pBinInt("j", j);。

pBinInt("i & j", i & j);。

pBinInt("i | j", i | j);。

pBinInt("i ^ j", i ^ j);。

pBinInt("i << 5", i << 5);。

pBinInt("i >> 5", i >> 5);。

pBinInt("(~i) >> 5", (~i) >> 5);。

pBinInt("i >>> 5", i >>> 5);。

pBinInt("(~i) >>> 5", (~i) >>> 5);。

long l = rand.nextLong();。

long m = rand.nextLong();。

pBinLong("-1L", -1L);。

pBinLong("+1L", +1L);。

long ll = 9223372036854775807L;。

pBinLong("maxpos", ll);。

long lln = -9223372036854775808L;。

pBinLong("maxneg", lln);。

pBinLong("l", l);。

pBinLong("~l", ~l);。

pBinLong("-l", -l);。

pBinLong("m", m);。

pBinLong("l & m", l & m);。

pBinLong("l | m", l | m);。

pBinLong("l ^ m", l ^ m);。

pBinLong("l << 5", l << 5);。

pBinLong("l >> 5", l >> 5);。

pBinLong("(~l) >> 5", (~l) >> 5);。

pBinLong("l >>> 5", l >>> 5);。

pBinLong("(~l) >>> 5", (~l) >>> 5);。

　}

　static void pBinInt(String s, int i) {。

System.out.println(。

　s + ", int: " + i + ", binary: ");。

System.out.print("　 ");。

for(int j = 31; j >=0; j--)。

　if(((1 << j) &　i) != 0)。

System.out.print("1");。

　else

System.out.print("0");。

System.out.println();。

　}

　static void pBinLong(String s, long l) {。

System.out.println(。

　s + ", long: " + l + ", binary: ");。

System.out.print("　 ");。

for(int i = 63; i >=0; i--)。

　if(((1L << i) & l) != 0)。

System.out.print("1");。

　else

System.out.print("0");。

System.out.println();。

　}

} ///:~

程序末尾调用了两个方法：pBinInt()和pBinLong()。它们分别操作一个int和long值，并用一种二进制格式输出，同时附有简要的说明文字。目前，可暂时忽略它们具体的实现方案。

大家要注意的是System.out.print()的使用，而不是System.out.println()。print()方法不会产生一个新行，以便在同一行里罗列多种信息。

除展示所有按位运算符针对int和long的效果之外，本例也展示了int和long的最小值、最大值、+1和-1值，使大家能体会它们的情况。注意高位代表正负号：0为正，1为负。下面列出int部分的输出：

-1, int: -1, binary: 。

　 11111111111111111111111111111111。

+1, int: 1, binary: 。

　 00000000000000000000000000000001。

maxpos, int: 2147483647, binary: 。

　 01111111111111111111111111111111。

maxneg, int: -2147483648, binary: 。

　 10000000000000000000000000000000。

i, int: 59081716, binary: 。

　 00000011100001011000001111110100。

~i, int: -59081717, binary: 。

　 11111100011110100111110000001011。

-i, int: -59081716, binary: 。

　 11111100011110100111110000001100。

j, int: 198850956, binary: 。

　 00001011110110100011100110001100。

i & j, int: 58720644, binary: 。

　 00000011100000000000000110000100。

i | j, int: 199212028, binary: 。

　 00001011110111111011101111111100。

i ^ j, int: 140491384, binary: 。

　 00001000010111111011101001111000。

i << 5, int: 1890614912, binary: 。

　 01110000101100000111111010000000。

i >> 5, int: 1846303, binary: 。

　 00000000000111000010110000011111。

(~i) >> 5, int: -1846304, binary: 。

　 11111111111000111101001111100000。

i >>> 5, int: 1846303, binary: 。

　 00000000000111000010110000011111。

(~i) >>> 5, int: 132371424, binary: 。

　 00000111111000111101001111100000。

数字的二进制形式表现为“有符号2的补值”。

JavaScript里面运算符有哪些?

你在其它主流语言中能见到的运算符，95%以上都能在JavaScript中使用。下面来看下几大类运算符：

1、 算术运算符：+，-，*，/，% 。

举例：45 + 44 = 89 89 - 44 = 45 9 * 3 = 27 9 / 3 = 3 86 % 10 = 6。

加、减、乘、除、取余是最基本的算术运算符，几乎所有编程语言都具有这些运算符。在JavaScript语言中加、减、乘、除、取余分别用’+’， ’-’， ’*’， ’/’, ‘%’字符来表示。它们接收两个数值类型作为操作数进行相应的数学运算，并将运算结果返回。

2、 复值运算符：=

举例：total = num1+num2。

赋值运算符是一个‘=’符号。当浏览器遇到赋值运算符，会先执行运算符右边的表达式，然后将其赋值给左边的变量或表达式。初学者特别要注意，这不是判断相等的运算符，而是赋值运算符。

3、 复合运算符：+=，-=，*=，/=。

举例： value += 5;。

“+=”运算符将相加和赋值操作合并在一起，是一个运算符，所以+=符号中间不能有空格。除了有“+=”运算符，JavaScript还提供了-=，*=和/=运算符；分别表示相减并赋值，相乘并赋值，相除并赋值。

4、 比较运算符==,===,!=,!===,>, <, >=, <=。

举例： if(num1==num2) x>y, x<y, x>=y, x<=y。

比较运算符比较两个对象的大小，判断是不相等，返回布尔类型的值。使用起来简单方便，但是我们需要注意如下几点：

注意1，不要混淆“=”和“==”，如。

if ( num1 = num2 ) {。

//除了num2为0的情况，其它情况都会执行。

注意2，“=”、“==”和“===”的区别。

一个等号“=”是赋值运算符；两个等号“==”是相等比较的运算符(字符6和数字6会认为是相等的)；三个等号“===”是严格的相等比较运算符(字符6和数字6不会认为是相等的，即要内容和数据类型完全一致)。

5、 逻辑运算符：&&，||， ！

举例：if (x === y && m === n ) { … }。

逻辑与由两个’&’组成，中间不能有空格；表示两个操作数都为true时，结果才为true。

逻辑或由两个’|’组成，与逻辑与相反，逻辑或只需操作数有一个为true，则结果为true。

逻辑非是一个感叹号，操作数为true，则结果为false，操作数为false，则结果为true。

6、 一元运算符：++，--

举例：intValue++; intValue--; ++intValue; --intValue;。

自增运算符给变量加1，运算效果和intValue = intValue + 1、intValue += 1一样。自增运算符“++”是一元运算符，表示它只需要一个操作数。自增运算符又可分为前置自增和后置自增运算，即运算符++即可以放在操作数前边，也可以放在操作数后面，如前置自增++intValue和后置自增intValue++；

与自增运算符相反，自减运算符给变量减1，运算结果和intValue = intValue - 1、intValue -= 1的一样。自减运算符也是一元运算符，同样也有前置自减和后置自减的用法。

一元运算符出现的位置很重要，会影响自增运算的返回值。如前置++在计算后会返回变量增加后的值，而后置++会返回变量未增加前的值。

7、 三元运算符：? :

格式：条件表达式 ？ 表达式1 ： 表达式2;。

三元运算符有疑问号?和冒号:组成。三元运算符的三个操作数如上示例，分别为条件表达式、表达式1和表达式2。当条件表达式为true时，表达式1会被执行；否则，表达式2将会被执行。这个逻辑和if-else语句很相似。

8、 位运算符：~、&、|、^、<<、>>、>>>。

举例：~num, num1 & num2, num1 | num2, num1 ^ num2, -10<<2。

位运算符实际就是对二进制进行与或非、左移、右移运行。

上述是从教程网站秒秒学上总结来的运算符各类，我感觉基本的运算符都囊括了，希望对你有帮助。

javascript如何使用

运算符是完成操作的一系列符号,在javascript中有赋值去运算符,算术运算符,字符串去处符,逻辑运算符,比较运算符,条件运算符及位运算符,(其中位去处符几乎很少用到,也已超出我们介绍的内容).。

1.赋值运算符

赋值运算符通常被用于在一个表达式中进行赋值,如example="this。

is

book";其中"="就是一个赋值运算符.。

2.算术运算符

javascript中的算术运算符有双目运算符和单目运算符.。

标准的双目运算符有五种:+(加),-(减),*(乘),/(除),%(取模)。

3.比较运算符

比较运算符的基本操作过程是,首先对它的操作数进行比较,然后再返回一个true或false值.。

4.逻辑运算符

主要将布尔值作为操作数,而且同比较去处符一样,也返回布尔值.。

5.字符串运算符

字符串运算符为+,主要用于两个字符串的组合,例如"this。

is

"+"book"

//结果为"this

is

book"

6.条件运算符

条件运算符与前面介绍过的运算符有所不同,因为条件表达式会根据条件计算出一个或两个不同的值,其结构为(条件)?结果1:结果2。望采纳。

javascript中的new运算符怎么样使用啊，含义是什么。。。？多谢了啊

1、字符串的创建

创建一个字符串有几种方法。最简单的是用引号将一组字符包含起来，可以将其赋值给一个字符串变量。

var myStr = "Hello, String!";。

我们在上面脚本创建了字符串，但本质上，它们并不是真正的字符串对象，准确地说，它们是字符串类型的值。要创建一个字符串对象，可使用如下语句：var strObj = new String("Hello, String!");。

使用typeof运算符查看会发现，上面的myStr类型为string，而strObj类型为object。

如果想知道字符串的长度，使用其length属性：string.length。

得到字符串的指定位置的字符使用方法：string.charAt(index);。

2、字符串的拼接

非常简单，就用一个"+"将两个字符串"相加"：

var longString = "One piece " + "plus one more piece.";。

要将多个字符串累积为一个字符串，还可以使用"+="操作符：

var result = "";。

result += "My name is Anders"。

result += " and my age is 25"; 。

要在字符串中添加换行符，需要使用转义字符"/n"：

var confirmString = "You did not enter a response to the last " +。

"question./n/nSubmit form anyway?";。

var confirmValue = confirm(confirmString);。

但这种方法只能用在像警告、确认对话框之类的情况下，如果将这段文本作为HTML内容呈现，就无效了，此时用"<br>"代替它：

var htmlString = "First line of string.<br>Second line of string.";。

document.write(htmlString);。

String对象还提供了方法concat()，它完成与"+"相同的功能：

string.concat(value1, value2, ...)。

不过concat()方法显然不如"+"来得直观简洁。

3、访问字符串的子串

使用substring()或slice()方法(NN4+, IE4+)，下面说明它们的具体用法。

substring()的原型为： string.substring(from, to)。

第一个参数from指定了子字符串在原字符串中的起始位置(基于0的索引)；第二个参数to是可选的，它指定了子字符串在原字符串的结束位置(基于0的索引)，一般情况下，它应比from大，如果它被省略，那么子字符串将一直到原字符串的结尾处。

如果参数from不小心比参数to大了会怎样？JavaScript会自动调解子字符串的起止位置，也就是说，substring()总是从两个参数中较小的那个开始，到较大的那个结束。不过要注意，它包含起始位置的那个字符，但不包含结束位置的那个字符。

var fullString = "Every dog has his day.";。

var section = fullString.substring(0, 4); // section is "Ever".。

slice()的原型为： string.slice(start, end)。

参数start表示子串的起始位置，如果为负数，那么可以理解为倒数第几个开始，例如-3表示从倒数第三个开始；参数end表示结束位置，与start一样，它也可以为负数，其含义也表示到倒数第几个结束。slice()的参数可以为负数，所以要比substring()更加灵活，但没那么宽容了，如果start比end要大，它将返回一个空字符串(示例略)。

还有一个方法是substr()，其原型为： string.substr(start, length)。

从原型可以看出它的参数的含义，start表示起始位置，length则表示子字符串的长度。JavaScript标准不提倡使用该方法。

4、字符串的大小写转换

使用toLowerCase()和toUpperCase()方法：

var city = "ShanGHai";。

city = city.toLowerCase(); // city is "shanghai" now.。

5、判断两个字符串是否相等

先将用户的输入值全部转换为大写（或小写），然后再行比较：

var name = document.form1.txtUserName.value.toLowerCase();。

if(name == "urname")。

// statements go here.。

JavaScript有两种相等运算符。一种是完全向后兼容的，标准的"=="，如果两个操作数类型不一致，它会在某些时候自动对操作数进行类型转换，考虑下面的赋值语句：

var strA = "i love you!";。

var strB = new String("i love you!");。

这两个变量含有相同的字符序列，但数据类型却不同，前者为string，后者为object，在使用"=="操作符时，JavaScript会尝试各种求值，以检测两者是否会在某种情况下相等。所以下面的表达式结果为true： strA == strB。

第二种操作符是"严格"的"==="，它在求值时不会这么宽容，不会进行类型转换。所以表达式strA === strB的值为false，虽然两个变量持有的值相同。

有时代码的逻辑要求你判断两个值是否不相等，这里也有两个选择："!="和严格的"!=="，它们的关系就类似于"=="和"==="。

讨论：

"=="和"!="在求值时会尽可能地寻找值的匹配性，但你可能还是想在比较前进行显式的类型转换，以"帮助"它们完成工作。比如，如果想判断一个用户的输入值（字符串）是否等于一个数字，你可以让"=="帮你完成类型转换：

if(document.form1.txtAge.value == someNumericVar) { ... }。

也可以提前转换：

if(parseInt(document.form1.txtAge.value) == someNumericVar) { ... }。

如果你比较习惯于强类型的编程语言(比如C#,Java等)，那么这里你可以延续你的习惯(类型转换)，这样也会增强程序的可读性。

有一种情况需要注意，就是计算机的区域设置。如果用"<"和">"来比较字符串，那么JavaScript把它们作为Unicode来比较，但显然，人们在浏览网页时不会把文本当作Unicode来阅读:) 比如在西班牙语中，按照传统的排序，"ch"将作为一个字符排在"c"和"d"之间。localeCompare()提供了一种方式，可以帮助你使用默认区域设置下的字符排序规则。

var strings; // 要排序的字符串数组，假设已经得到初始化。

strings.sort(function(a,b) { return a.localeCompare(b) }); // 调用sort()方法进行排序。

6、字符串的查找

使用string的indexOf()方法：

strObj.indexOf(subString[, startIndex])。

strObj为要进行判断的字符串，subString为要在strObj查找的子字符串，startIndex是可选的，表示查找的开始位置(基于0的索引)，如果startIndex省略，则从strObj开始处查找，如果startIndex小于0，则从0开始，如果startIndex大于最大索引，则从最大索引处开始。

indexOf()返回strObj中subString的开始位置，如果没有找到，则返回-1。在脚本中，可以这么使用：

if(largeString.indexOf(shortString) != -1)。

// 如果包含，进行相应处理；

也许一个字符串会包含另一字符串不止一次，这时第二个参数startIndex也许会派上用场，下面这个函数演示如何求得一个字符串包含另外一个字符串的次数：

function countInstances(mainStr, subStr)。

var count = 0;

var offset = 0;。

do

offset = mainStr.indexOf(subStr, offset);。

if(offset != -1)。

count++;

offset += subStr.length;。

}while(offset != -1)。

return count;

String对象有一个与indexOf()对应的方法，lastIndexOf()：

strObj.lastIndexOf(substring[, startindex])。

strObj为要进行判断的字符串，subString为要在strObj查找的子字符串，startIndex是可选的，表示查找的开始位置(基于0的索引)，如果startIndex省略，则从strObj末尾处查找，如果startIndex小于0，则从0开始，如果startIndex大于最大索引，则从最大索引处开始。该方法自右向左查找，返回subString在strObj中最后出现的位置，如果没有找到，返回-1。

new运算符是对象实例化运算符，其功能是实例化一个对象，即为对象分配内存。

在创建对象时，其中有一步是声明对象，如：Point(类名) p1(对象名)，这只确定了对象。

的名称和它所属的类，并没有为对象分配内存，此时对象还不是类的实例。只有通过new操作，即p1=new Point才能为对象分配储存空间，是该对象成为类的实例。

原文地址：http://www.qianchusai.com/k22beijv.html