js基本概念之操作符

一元操作符

只能操作一个值的操作符

• 递增递减操作符

总结：非数值类型的的操作数用Number()转化为数值类型，结果不为NaN时再执行自加减操作

返回：数值、NaN

规则：

  在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减 1 的操作；

var a = "";      // --a结果为 -1
var b = "0";     // --b结果为 -1
var c = "012";   // --c结果为  11
var d = 0;       // --d结果为 -1
var e = null;    // --e结果为 -1

  在应用于布尔值 false,true时，先将其转换为 0,1再执行加减 1 的操作；

var f = false;   // --f结果为 -1
var g = true;    // --g结果为  0

  在应用于浮点数值时，执行加减 1 的操作；

var h = "12.2";  // --h结果为 11.2

  在应用于一个不包含有效数字字符的字符串时，将变量的值设置为 NaN ；

var a = "12as23";   // --a结果为 NaN
var b = undefined;  // --b结果为 NaN
var c = "abc";      // --c结果为 NaN
var d = NaN;        // --d结果为 NaN

  在应用于对象时，先调用对象的 valueOf() 方法（第 5 章将详细讨论）以取得一个可供操作的值。然后对该值应用前述规则。如果结果是 NaN ，则在调用 toString() 方法后再应用前述规则。

• 一元加减操作符

总结：用Number()将其他类型的操作数转化为Number类型，结果不为NaN时再执行

返回：数值、NaN

var s1 = "01";    //-s1结果为 -1, +s1结果为 1
var s2 = "1.1";   // -s2结果为 -1.1, +s2结果为 1.1
var a = null;     // -a结果为0, +a结果为 0
var b = false;    // -b结果为 0， +b结果为 0
var c = true;     // -c结果为 0, +c结果为 0
var d = "";       // -d结果为 0, +d结果为 0
var f = 1.1;      // -f结果为-1.1, +f结果为 1.1
var o = {
    valueOf: function() {
        return -1; 
    }
};                      // -o结果为 1, o结果为 1
var s3 = "z";           // -s3结果为 NaN, +s3结果为 NaN
var s4 = undefined;     // -s4结果为 NaN, +s4结果为 NaN

布尔操作符

• 逻辑非（!）

总结：将其他类型操作数用Boolean()转化为布尔型，再计算

返回：true、false

规则：

   如果操作数是一个对象、非空字符串、任意非 0 数值（包括 Infinity ）、true，则返回 false；

alert(!12345);    // false
alert(!"blue");   // false
alert(!true);     // false

   如果操作数是一个空字符串、数值 0、null、undefined、false，则返回 true ；

alert(!false);    // true
alert(!0);        // true
alert(!NaN);      // true
alert(!"");       // true
alert(!undefined);       // true

•  逻辑与（ &&）

总结：短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。
对于逻辑与操作而言，如果第一个操作数是 false ，则无论第二个操作数是什么值，结果都不再可能是
true 了

返回：true、false 、字符串、数值、对象、null、undefined、NaN

规则：

  如果第一个操作数为true、非0数字、非空字符串、对象、数组，则返回第二个操作数；

var obj = {"name":"123","age":23};
var str = "abcd";
var num = 3;
alert( obj && str );           // 结果为 "abcd"
alert( str && null);           // 结果为 null 
alert( num && undefined );     // 结果为 undefined
alert( str && obj);            // 结果为 {"name":"123","age":23} 
alert( obj && num);            // 结果为 3
alert( true && num);           // 结果为 3
alert( true && false);         // 结果为 false

   如果第一个操作数为false、null、空字符串、undefined、NaN、数字0，则返回第一个操作数；

var obj = {"name":"123","age":23};
var str = "abcd";
alert( null && str);            // 结果为 null 
alert( NaN && obj);             // 结果为 NaN 
alert( "" && str);              // 结果为 ""
alert( null && false );         // 结果为 null 
alert( false && null );         // 结果为 false 
alert( NaN && undefined );      // 结果为 NaN 
alert( undefined && NaN );      // 结果为 undefined 
alert( "" && NaN );             // 结果为 ""
alert( NaN && "" );             // 结果为 NaN 
alert( 0 && 32 );               // 结果为 0 

• 逻辑或（||）

总结：短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。
对于逻辑与操作而言，如果第一个操作数是 true，就不会再求第二个操作数了

返回：true、false 、字符串、数值、对象、null、undefined、NaN

规则：

   如果第一个操作数是对象、非0数值、非空字符串、true、数组，则返回第一个操作数；

var obj = {"name":"123","age":23};
var str = "abcd";
var num = 3;
var arr = [];
alert( obj || str );           // 结果为 {"name":"123","age":23}
alert( str || null);           // 结果为 "abcd"
alert( num || undefined );     // 结果为 3
alert( str || obj);            // 结果为 "abcd"
alert( obj || num);            // 结果为 {"name":"123","age":23}
alert( true || num);           // 结果为 true
alert( true || false);         // 结果为 true
alert( arr || false);          // 结果为 []

  如果有第一个操作数为空字符串、数字0、NaN、null、undefined、false，则返回第二个操作数；

var obj = {"name":"123","age":23};
var str = "abcd";
var num = 3;
alert( null || obj );           // 结果为 {"name":"123","age":23}
alert( false || null);          // 结果为 null
alert( "" || str );             // 结果为 "abcd"
alert( NaN || obj);             // 结果为 {"name":"123","age":23}
alert( undefined || num);       // 结果为 3
alert( 0 || num);               // 结果为 3
alert( 0 || undefined);         // 结果为 undefined

乘性操作符

• 乘法（*）

总结：如果有一个操作数不是数值，则在后台调用 Number() 将其转换为数值，结果总会遵循以下规则

返回：正常数值、NaN、正负Infinity

规则：

alert( -32 * 12);               // 结果为 -384
alert( -32 * -12 );             // 结果为  384
alert( Number.MAX_VALUE * 2);   // 结果为  Infinity
alert( Number.MIN_VALUE * 2);   // 结果为  0
alert( NaN * 2);                // 结果为  NaN
alert( 12 * NaN);               // 结果为  NaN
alert( Infinity * 0);           // 结果为  NaN
alert( Infinity * 2);           // 结果为  Infinity
alert( Infinity * -2);          // 结果为 -Infinity
alert( Infinity * Infinity);    // 结果为  Infinity
/*
  如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数，而
    如果只有一个操作数有符号，那么结果就是负数。如果乘积超过了 ECMAScript 数值的表示范围，
    则返回 Infinity 或 -Infinity ；
  如果有一个操作数是 NaN ，则结果是 NaN ；
  如果是 Infinity 与 0 相乘，则结果是 NaN ；
  如果是 Infinity 与非 0 数值相乘，则结果是 Infinity 或 -Infinity ，取决于有符号操作数
    的符号；
  如果是 Infinity 与 Infinity 相乘，则结果是 Infinity ；
  如果有一个操作数不是数值，则在后台调用 Number() 将其转换为数值，然后再应用上面的
   规则。
*/

• 除法（/）

总结：如果有一个操作数不是数值，则在后台调用 Number() 将其转换为数值，结果总会遵循以下规则

返回：正常数值、NaN、正负Infinity

规则：

alert("abc" / 4);                // 结果为  NaN
alert("24" / 4);                 // 结果为  6
alert( -32 /  NaN);              // 结果为  NaN
alert( NaN / -12 );              // 结果为  NaN
alert( Infinity / Infinity);     // 结果为  NaN
alert( 0 / 0);                   // 结果为  NaN
alert( 0 / -2);                  // 结果为 -0
alert( 0 / 2);                   // 结果为  0
alert( 2 / 0);                   // 结果为  Infinity
alert( Infinity / 2);            // 结果为  Infinity
alert( 2 / Infinity);            // 结果为  0
alert( Infinity / -0);           // 结果为 -Infinity
alert( 0 / Infinity);            // 结果为  0
/*
  如果操作数都是数值，执行常规的除法计算，即两个正数或两个负数相除的结果还是正数，而
   如果只有一个操作数有符号，那么结果就是负数。如果商超过了 ECMAScript 数值的表示范围，
   则返回 Infinity 或 -Infinity ； 
   如果有一个操作数是 NaN ，则结果是 NaN ；
  如果是 Infinity 除以 Infinity ，则结果是 NaN ；
  如果是零除以零，则结果是 NaN ；
  如果是非零的有限数除以0，则结果是 Infinity 或 -Infinity ，取决于有符号操作数的符号；
  如果是 Infinity 除以任何非零数值，则结果是 Infinity 或 -Infinity ，取决于有符号操作
   数的符号；
   如果有一个操作数不是数值，则在后台调用 Number() 将其转换为数值，然后再应用上面的规则。
*/

• 求模

总结：如果有一个操作数不是数值，则在后台调用 Number() 将其转换为数值，结果总会遵循以下规则

返回：正常数值、NaN、正负Infinity

规则：

与另外两个乘性操作符类似，求模操作符会遵循下列特殊规则来处理特殊的值：
  如果操作数都是数值，执行常规的除法计算，返回除得的余数；
  如果被除数是无穷大值而除数是有限大的数值，则结果是 NaN ；
  如果被除数是有限大的数值而除数是零，则结果是 NaN ；
  如果是 Infinity 被 Infinity 除，则结果是 NaN ；
  如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数；
  如果被除数是零，则结果是零；
  如果有一个操作数不是数值，则在后台调用 Number() 将其转换为数值，然后再应用上面的规则。

加性操作符

• 加法（+）

总结：

返回：正常数值、NaN、正负Infinity、字符串

规则：

  如果两个操作数都是数值，则执行常规的算术减法操作并返回结果；

alert(NaN + 4);                      // 结果为  NaN
alert(Infinity + Infinity);          // 结果为  Infinity
alert( -Infinity +  -Infinity);      // 结果为 -Infinity
alert( Infinity + -Infinity );       // 结果为  NaN
alert( +0 + +0);                     // 结果为  0
alert( -0 + -0);                     // 结果为 -0
alert( +0 + -0);                     // 结果为  0
/*
   如果有一个操作数是 NaN ，则结果是 NaN ；
   如果是 Infinity 加 Infinity ，则结果是 Infinity ；
   如果是 -Infinity 加 -Infinity ，则结果是 -Infinity ；
   如果是 Infinity 加 -Infinity ，则结果是 NaN ；
   如果是+0 加+0，则结果是+0；
   如果是-0 加-0，则结果是-0；
   如果是+0 加-0，则结果是+0。
*/

  如果有操作数是字符串，则将非字符串操作数用toString()方法或者String()方法转化为字符串再拼接；

var result1 = 5 + "5";     
var result2 = "5" + "5";
alert(result1);             // 结果为 "55"
alert(result2);             // 结果为 "55"

典型例子：

忽视加法操作中的数据类型是 ECMAScript 编程中最常见的一个错误。

var num1 = 5;
var num2 = 10;
var message1 = "The sum of 5 and 10 is " + num1 + num2;
alert(message1);              // 结果为 "The sum of 5 and 10 is 510"

var message2 = "The sum of 5 and 10 is " + (num1 + num2);
alert(message2);             // 结果为 "The sum of 5 and 10 is 15"

• 减法（-）

总结：

返回：正常数值、NaN、正负Infinity

规则：

  如果两个操作符都是数值，则执行常规的算术减法操作并返回结果；

alert(NaN - 4);                      // 结果为  NaN
alert(Infinity - Infinity);          // 结果为  NaN
alert( -Infinity -  -Infinity);      // 结果为  NaN 
alert( Infinity - -Infinity );       // 结果为  Infinity 
alert( -Infinity - Infinity );       // 结果为 -Infinity
alert( +0 - +0);                     // 结果为  0
alert( +0 - -0);                     // 结果为 -0
alert( -0 - -0);                     // 结果为  0
/*
   如果有一个操作数是 NaN ，则结果是 NaN ；
   如果是 Infinity 减 Infinity ，则结果是 NaN ；
   如果是 -Infinity 减 -Infinity ，则结果是 NaN ；
   如果是 Infinity 减 -Infinity ，则结果是 Infinity ；
   如果是 -Infinity 减 Infinity ，则结果是 -Infinity ；
   如果是+0 减+0，则结果是+0；
   如果是+0 减-0，则结果是-0；
   如果是-0 减-0，则结果是+0；
*/

  如果有操作数是字符串、布尔值、 null 或 undefined，则先在后台调用 Number() 函数将
其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是 NaN ，则减法的结果
就是 NaN ；

var result1 = 5 - true;       // 4，因为 true 被转换成了 1
var result2 = NaN - 1;        // NaN
var result3 = 5 - 3;          // 2
var result4 = 5 - "";         // 5，因为"" 被转换成了 0
var result5 = 5 - "2";        // 3，因为"2"被转换成了 2
var result6 = 5 - null;       // 5，因为 null 被转换成了 0
var result6 = 5 - [];         // 5，因为 [] 被转换成了 0
var result6 = 5 - [""];       // 5，因为 [""] 被转换成了 0

  如果有一个操作数是对象，则调用对象的 valueOf() 方法以取得表示该对象的数值。如果得到
的值是 NaN ，则减法的结果就是 NaN 。如果对象没有 valueOf() 方法，则调用其 toString()
方法并将得到的字符串转换为数值。

关系操作符

总结：<、>、>=、<=

返回：true、false

规则：

  如果两个操作数都是数值，则执行数值比较。
  如果一个操作数是NaN，则比较结果为总为false；

var str1 = "cd";       
var num = 2;        
alert( NaN > str2 );            // false
alert( NaN <= str2 );           // false
alert( NaN > num );             // false
alert( NaN <= num );            // false

  如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较。

var num = 2;       
var str2 = "a";        
alert( num > str2 );        // false, Number(str2)为NaN，NaN与任何数比较都为false
alert( num >= false );       // true,  Number(false)为0
alert( num <= null );        // false, Number(null)为0
alert( num <= undefined );   // false, Number(undefined)为0

 如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。

var num = 2;       
var str2 = "a";        
alert( true > num );         // false, Number(true)为1
alert( false > str2 );       // false, Number(false)为0，Number(str2)为NaN
alert( true >= null );       // true, Number(true)为1,Number(null)为0
alert( true < undefined );   // false, Number(true)为1,Number(undefined)为NaN

  如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。

var str1 = "cd";       
var str2 = "a";        
alert( str1 > str2 );            // true, 比较的是ASCALL码
alert( "23" > "3" );             // false, 比较的是ASCALL码

 

  如果一个操作数是对象，则调用这个对象的 valueOf() 方法，用得到的结果按照前面的规则执
行比较。如果对象没有 valueOf() 方法，则调用 toString() 方法，并用得到的结果根据前面
的规则执行比较。

相等操作符

• 相等和不相等（==、！=）

总结：

返回：true、false

规则：

 null 和 undefined 是相等的，undefined和null不能被转化成任何值；

alert( null == undefined );        // true
alert( null != undefined  );       // false

  如果 NaN 和任意值不相等，包括自己；

var str = "abc";
var num = 12;
var obj = {"name":"li","age":12}; 
alert( NaN == str );             // false
alert( NaN == num );             // false
alert( NaN == obj  );            // false
alert( NaN == NaN );             // false
alert( NaN == null  );           // false
alert( NaN == undefined  );      // false
alert( NaN == true  );           // false
alert( NaN == false  );          // false
 
alert( NaN != str );             // true
alert( NaN != num );             // true
alert( NaN != obj  );            // true
alert( NaN != NaN );             // true
alert( NaN != null  );           // true
alert( NaN != undefined  );      // true
alert( NaN != true  );           // true
alert( NaN != false  );          // true

  如果一个操作数是数值，在比较相等性之前先将另一个操作数转换为数值（undefined和null不能被转化成任何值）；

var num = 2;       
var str2 = "2";
var obj = {"name":"li","age":12};         
alert( num == str2 );        // true, Number(str2)为2
alert( num == obj );         // false, obj.toString()不等于2
alert( num == null );        // false, null不能转化
alert( num == undefined );   // false, undefined不能转化
alert( num == false );       // false, Number(false)为0
alert( num == true );        // false, Number(false)为0
alert( num == NaN );         // false, Number(NaN)为NaN

alert( num != str2 );        // false, Number(str2)为2
alert( num != obj );         // true, obj.toString()不等于2
alert( num != null );        // true, null不能转化
alert( num != undefined );   // true, undefined不能转化
alert( num != false );       // true, Number(false)为0
alert( num != true );        // true, Number(false)为0
alert( num != NaN );         // true, Number(NaN)为NaN

  如果有一个操作数是布尔值，则在比较相等性之前先将其转换为数值—— false 转换为 0，而
true 转换为 1;

var num = 2;       
var str2 = "a";
var obj = {"name":"li","age":12};    
alert( true == num );           // false, Number(true)为1
alert( true == str2 );          // false, Number(true)为1
alert( true == obj );           // false, Number(false)为0，Number(str2)为NaN
alert( true == null );          // true, Number(true)为1
alert( true == undefined );     // false, Number(true)为1
alert( true == NaN );           // false
alert( true == true );          // true
alert( true == false );         // false

alert( true != num );           // true, Number(true)为1
alert( true != str2 );          // true, Number(true)为1
alert( true != obj );           // true, Number(false)为0，Number(str2)为NaN
alert( true != null );          // true, Number(true)为1
alert( true != undefined );     // true, Number(true)为1
alert( true != NaN );           // true
alert( true != true );          // false
alert( true != false );         // true

  如果一个操作数是对象，另一个操作数不是，则调用对象的 valueOf() 方法，用得到的基本类
型值按照前面的规则进行比较；

• 全等和不全等（===、！==）

总结：

返回：true、false

规则：

  在比较之前不转换操作数类型之外，全等和不全等操作符与相等和不相等操作符没有什么区别

var result1 = ("55" == 55);     // true，因为转换后相等
var result2 = ("55" === 55);    // false，因为不同的数据类型不相等

var result1 = ("55" != 55);     // false，因为转换后相等
var result2 = ("55" !== 55);    // true，因为不同的数据类型不相等

  null === undefined 会返回 false ，因为它们是不同类型的值

alert(null === undefined);    //false

其他操作符

• 条件操作符

规则：

  遵循与 Java 中的条件操作符相同的语法形式variable = boolean_expression ? true_value : false_value;

var num1 = 2;
var num2 = 1
var max = (num1 > num2) ? num1 : num2;
alert(max);                        //  结果为 2
var min = (num1 < num2) ? num1 : num2;
alert(min);                        //  结果为 1

• 赋值操作符

规则：

  乘/赋值（ *= ）；
  除/赋值（ /= ）；
  模/赋值（ %= ）；
  加/赋值（ += ）；
  减/赋值（ = ）；
  左移/赋值（ <<= ）；
  有符号右移/赋值（ >>= ）；

  无符号右移/赋值（ >>>= ）

• 逗号操作符

var num1=1, num2=2, num3=3;     // 声明多个变量
var num = (5, 1, 4, 8, 0);      // num 的值为 0