常用JavaScript运算符

运算符也叫操作符，通过运算符可以对一个或者多个值进行运算，并获取运算结果。比如说 typeof 就是一个运算符，该运算符可以来获得一个值得类型,它会将该值得类型以字符串的形式返回。 例如：

1
2
3
var a = 123;
var result = typeof a;
console.log(result);

  • . 算术运算符：

    ​ 1) 当对非Number值进行运算时，会将这些值转换为Number类型，然后再运算(字符串加法除外)。

    ​ 2) 任何值和NaN做运算都得NaN.

    ​ 3) 任何的值和字符串做加法操作，都会先转换为字符串，然后再和字符串做拼串操作,我们可以利用这一特点，来将任意一个数据类型转换为String类型，即任意字符类型加上一个空串即可转化为String类型，这是一种隐式类型转换，由浏览器自动完成，实际上它也是调用了String()函数。

    ​ 4) 任何值做 -，*，/ 运算时都会自动转换为Number；我们可以利用这一特点做隐式转换，可以通过为一个值减0，除1，乘1来将其转换为Number类型。

    • +：加号可以对两个值进行加法运算，并将结果返回

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      result = 456 + 100;
      console.log(result);
      //结果为556
      //注意以下输出结果都是控制台输出结果
      result = true + false;
      //结果为：1      	
      result = true + 1;
      //结果为2
      result = 2 + null;
      //结果为2
      result = 2 + NaN;
      //结果为NaN
      /*如果对两个字符串做加法运算，则会做拼串操作*/
      result = "123" + "456";
      //结果为"123456"
      result = 123 + "12";
      //结果为 "12312"
      result = true + "hello";
      //结果为"truehello"
      var a = 123;
      a = a + "";
      //结果为"123"
      result = 1 + 2 + "3";
      //结果为"33"，从左向右依次计算
      result = "1" + "2" + 3;
      //结果为 "123"

    • -：减号对两个值进行减法运算，并将结果返回

      1
      2
      3
      4
      result = 100 - true;
      //结果为 99
      result = 100 - "1";
      //结果为99(字符串转换为Number)

    • *：乘法运算

      1
      2
      3
      4
      5
      6
      result = 2 * "8";
      //结果为16
      result = 2 * undefined;
      //结果为NaN(undefined转换为Number类型值为NaN)
      result = 2 * null;
      //结果为0

    • /：除法运算

      1
      2
      3
      4
      result = 4 / 2;
      //结果为2
      result = 3 / 2;
      //结果为1.5

    • %：取模运算

      1
      2
      3
      4
      result = 9 %3;
      //结果为0
      result = 9 % 4;
      //结果为1

  • 一元运算符

    • 一元运算符只需要一个操作数

    • +:正号：不会对数值产生任何影响；但可以对其他数据类型使用正号，使其转换为Number，原理与Number()函数一样。

      1
      2
      3
      4
      5
      6
      var a =123;
       a = + a;
      //a的结果为 123
      var a = "18";
      a = + a;
      //a的值为18

    • -：负号：对于Number值取反，对于非Number值，先转换为Number，再运算

      1
      2
      3
      4
      5
      6
      var a =123;
       a = - a;
      //a的结果为 -123
      var a = true;
      a = -a;
      //a的值为 -1

  • .逻辑运算符

    • Js中提供了三种逻辑运算符

    • !:可以对一个值进行非运算，即对一个布尔值进行取反操作。若对非布尔值进行运算，则会先转换为布尔值，再运算；可以对任意数值取两次反来将其变为布尔值.

      1
      2
      3
      4
      5
      6
      var a = true;
      a = !a
      //a的值为false
      var a = "hello"
      a = !! a;
      // a的值为true

    • &&：对运算符两侧的值进行运算并返回；Js中的”与”属于短路的与，如果第一个值为false，则不会看第二个值。非布尔值进行与运算，会现将其转换为布尔值再运算，并且返回原值

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      var a = true && false;
      //a的值为 false
      var a = 1 && 2;
      //a的值为2
      var a = 4 && 5;
      //a的值为5；若两个值都为true，则返回后边的一个
       var a = 0 && 4;
       //a的值为0；如果有false，则返回false对应值
       var a = NaN && 0
       //a的值为NaN
       var a = 0 & NaN;
       //a的值为0；若两个值均为false，则返回靠前的一个

    • ||:可以对两侧的值进行或运算并返回结果，有true返回true，全false则为false，Js中或为短路或，如果第一个值为true，则不会看第二个值。非布尔值进行与运算，会现将其转换为布尔值再运算，并且返回原值。

      1
      2
      3
      4
      var a = 1 || 2;
      //a的值为1
      var a = NaN || 1;
      //a的值为 1； 如果第一个值为false，则直接返回第二个值

  • 赋值运算符

    • =:可以将等号右侧的值赋给左侧变量

      1
      2
      var a =123;
      //a的值为 123

    • += , -= , *= , /= , %=

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      var a += 5;
      //相当于 var a = a + 5;
      var a -= 5;
      //相当于 var a = a -5;
      var a *= 5;
      //相当于 a = a * 5;
      var a /= 5;
      //var a = a / 5;
      var a %= 5;
      //var a = a % 5;

  • 关系运算符

    • 通过关系运算符可以比较两个值之间的大小关系，如果关系成立，会返回true，否则返回false；对于非数值进行比较时，会先将其转换为数字，然后再比较

    • 任何值和NaN做任何比较都是false

    • 如果符号两侧的值都是字符串，不会将其转换为数字进行比较，而是分别比较字符串中字符的Unicode编码(Unicode编码:(http://www.unicode.org/charts/)),比较编码是一位一位进行比较的，可以利用这种方法对英文进行排序。

    • 如果比较两个字符串型数字,可能得不到预期的结果，所以在比较两个字符串型数字是一定一定要注意转型。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
        /* 大于号 > */
        var result = 5 > 5;
        //返回false
        var result = 1 > true;
        //返回false
        var result = 1 >= true;
        //返回true
        var result = 5 > 4;
        //返回true
        /* 大于等于号 >= */
        var result = 5 >= 5;
        //返回true
        /*小于号 < */
        var result = 5 < 4;
        //返回false
        /* 小于等于号 <= */
        var result = 4 <= 5;
        //返回 true
        /*比较字符串型数字,可以加+转型得到正确结果*/
      var result = "11111" < +"5"；

  • 相等运算符

    • 用来比较两个值是否相等 ，若相等会返回true，否则返回false

    • 使用 == 来表示相等运算，当使用 == 来比较两个值时，，如果两个值得类型不同，则会自动进行类型转换，将其转换为相同的类型，然后比较。

    • Js中可以使用isNaN()函数来判断一个变量的值是不是NaN,因为NaN不和任何值相等，包括它本身。

    • !=:不相等，不相等返回true，否则返回false;如果变量类型不同也会进行自动转换

    • ===：全等，和==类似，但不会做类型的自动转换，如果类型不同，直接返回false

    • !==:不全等。和!=类似，不会自动做类型转换，如果类型不同，直接返回true

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      /* -------------- 相等----------------*/
      console.log( 1 == 1 );
      //返回true
      console.log("1" == 1 );
      //返回true
      console.log(true = "1");
      //返回true
      /*特殊值*/
      console.log(null == 0 );
      //返回false
      console。log( undefined == null);
      //返回true
      /*NaN不和任何值相等，包括它本身*/
      console.log( NaN == NaN );
      //false
      console.log(NaN == undefined);
      //false
      console.log(isNaN(NaN))
      //true
      /*--------------不相等-----------------*/
      console.log(5 != 10);
      //true
      console.log("1" != 1);
      //false
      /*---------------全等-----------------*/
      console.log("123" === 123);
      //false
      /*------------不全等-------------------*/
      console.log(1 !== "1");
      //true

  • 条件运算符

    • 条件运算符也叫三元运算符
    • 语法: 条件表达式 ？ 语句1 ：语句2；
    • 条件运算符在执行时，首先对条件表达式进行求值，如果该值为true，则执行语句1并返回结果，否则执行语句2并返回结果。
    • 如果条件表达式的求值结果是一个非布尔值，会现将其转换为布尔值再运算。