js运算符

现代js教程学习笔记

运算符

        - 运算符也称为操作符

        - 通过运算符可以对一个或多个值进行运算或操作

在正式开始前，我们先简单浏览一下常用术语。

• 运算元 —— 运算符应用的对象。比如说乘法运算 5 * 2，有两个运算元：左运算元 5 和右运算元 2。有时候人们也称其为“参数”而不是“运算元”。
• 如果一个运算符对应的只有一个运算元，那么它是 一元运算符。比如说一元负号运算符（unary negation）-，它的作用是对数字进行正负转换：
• let x = 1;
• x = -x;

alert( x ); // -1，一元负号运算符生效

• 如果一个运算符拥有两个运算元，那么它是 二元运算符。减号还存在二元运算符形式：
• let x = 1, y = 3;

alert( y - x ); // 2，二元运算符减号做减运算

严格地说，在上面的示例中，我们使用一个相同的符号表征了两个不同的运算符：负号运算符，即反转符号的一元运算符，减法运算符，是从另一个数减去一个数的二元运算符。

表达式

typeof运算符

            - 用来检查一个变量的数据类型

            - 语法：typeof 变量

            - 它会返回一个用于描述类型的字符串作为结果

           

一元运算符

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

            - 一元的+

                - 就是正号，不会对值产生任何影响，但是可以将一个非数字转换为数字

                - 例子：

                    var a = true;

                    a = +a;

加号 + 有两种形式。一种是上面我们刚刚讨论的二元运算符，还有一种是一元运算符。

一元运算符加号，或者说，加号 + 应用于单个值，对数字没有任何作用。但是如果运算元不是数字，加号 + 则会将其转化为数字。

例如：

// 对数字无效

let x = 1;

alert( +x ); // 1

let y = -2;

alert( +y ); // -2

// 转化非数字

alert( +true ); // 1

alert( +"" );   // 0

它的效果和 Number(...) 相同，但是更加简短。

我们经常会有将字符串转化为数字的需求。比如，如果我们正在从 HTML 表单中取值，通常得到的都是字符串。如果我们想对它们求和，该怎么办？

二元运算符加号会把它们合并成字符串：

let apples = "2";

let oranges = "3";

alert( apples + oranges ); // "23"，二元运算符加号合并字符串

如果我们想把它们当做数字对待，我们需要转化它们，然后再求和：

let apples = "2";

let oranges = "3";

// 在二元运算符加号起作用之前，所有的值都被转化为了数字

alert( +apples + +oranges ); // 5

// 更长的写法

// alert( Number(apples) + Number(oranges) ); // 5

为什么一元运算符先于二元运算符作用于运算元？接下去我们将讨论到，这是由于它们拥有 更高的优先级。

               

            - 一元的-

                - 就是负号，可以对一个数字进行符号位取反

                - 例子：

                    var a = 10;

                    a = -a;

                   

            - 自增

                - 自增可以使变量在原值的基础上自增1

                - 自增使用 ++

                - 自增可以使用 前++（++a）后++(a++)

                - 无论是++a 还是 a++都会立即使原变量自增1

                    不同的是++a和a++的值是不同的，

                        ++a的值是变量的新值（自增后的值）

                        a++的值是变量的原值（自增前的值）

            - 自减  

                - 自减可以使变量在原值的基础上自减1

                - 自减使用 --

                - 自减可以使用 前--（--a）后--(a--)

                - 无论是--a 还是 a--都会立即使原变量自减1

                    不同的是--a和a--的值是不同的，

                        --a的值是变量的新值（自减后的值）

                        a--的值是变量的原值（自减前的值）

自增/自减只能应用于变量。试一下，将其应用于数值（比如 5++）则会报错。

二元运算符。算数运算符

            +   对两个值进行加法运算并返回结果

            -  对两个值进行减法运算并返回结果

            *   对两个值进行乘法运算并返回结果

            /   对两个值进行除法运算并返回结果

            %   对两个值进行取余运算并返回结果      5%3 //2

                                                3%5 //3

•             求幂 **.

取余 %

取余运算符是 %，尽管它看起来很像百分数，但实际并无关联。

a % b 的结果是 a 整除 b 的 余数)。

例如：

alert( 5% 2); // 1，5 除以 2 的余数

alert( 8 % 3 ); 
// 2，8 除以 3 的余数

求幂 **

求幂运算 a ** b 是 a 乘以自身 b 次。

例如：

alert( 2 ** 2); 
// 4  (2 * 2，自乘 2 次)

alert( 2 ** 3 ); 
// 8  (2 * 2 * 2，自乘 3 次)

alert( 2** 4 ); 
// 16 (2 * 2 * 2 * 2，自乘 4 次)

在数学上，求幂的定义也适用于非整数。例如，平方根是以 1/2 为单位的求幂：

alert( 4 ** (1/2) ); 
// 2（1/2 次方与平方根相同)

alert( 8 ** (1/3) ); 
// 2（1/3 次方与立方根相同)      

    - 除了加法以外，对非Number类型的值进行运算时，都会先转换为Number然后在做运算。

    - 而做加法运算时，如果是两个字符串进行相加，则会做拼串操作，将两个字符连接为一个字符串。

    - 任何值和字符串做加法，都会先转换为字符串，然后再拼串

通常，加号 + 用于求和。

但是如果加号 + 被应用于字符串，它将合并（连接）各个字符串：

let s = "my" + "string";

alert(s); // mystring

注意：只要任意一个运算元是字符串，那么另一个运算元也将被转化为字符串。

举个例子：

alert( '1' + 2 ); // "12"

alert( 2 + '1' ); // "21"

你看，第一个运算元和第二个运算元，哪个是字符串并不重要。

下面是一个更复杂的例子：

alert(2 + 2 + '1' ); // "41"，不是 "221"

在这里，运算符是按顺序工作。第一个 + 将两个数字相加，所以返回 4，然后下一个 + 将字符串 1 加入其中，所以就是 4 + '1' = 41。

二元 + 是唯一一个以这种方式支持字符串的运算符。其他算术运算符只对数字起作用，并且总是将其运算元转换为数字。

三元运算符：

        ?:

            - 语法：条件表达式?语句1:语句2;

            - 执行流程：

                先对条件表达式求值判断，

                    如果判断结果为true，则执行语句1，并返回执行结果

                    如果判断结果为false，则执行语句2，并返回执行结果

                   

逻辑运算符

        !

            - 非运算可以对一个布尔值进行取反，true变false false边true

            - 当对非布尔值使用!时，会先将其转换为布尔值然后再取反

            - 我们可以利用!来将其他的数据类型转换为布尔值

       

        &&      且

            - &&可以对符号两侧的值进行与运算

            - 只有两端的值都为true时，才会返回true。只要有一个false就会返回false。

            - 与是一个短路的与，如果第一个值是false，则不再检查第二个值

            - 对于非布尔值，它会将其转换为布尔值然后做运算，并返回原值

            - 规则：

                    1.如果第一个值为false，则返回第一个值

                    2.如果第一个值为true，则返回第二个值

       

        ||      或

            - ||可以对符号两侧的值进行或运算

            - 只有两端都是false时，才会返回false。只要有一个true，就会返回true。

            - 或是一个短路的或，如果第一个值是true，则不再检查第二个值

            - 对于非布尔值，它会将其转换为布尔值然后做运算，并返回原值

            - 规则：

                    1.如果第一个值为true，则返回第一个值

                    2.如果第一个值为false，则返回第二个值

               

赋值运算符

        =

            - 可以将符号右侧的值赋值给左侧变量

           

        +=

            - a += 5 相当于 a = a+5

            - var str = "hello";  str += "world";

           

        -=

            - a -= 5  相当于 a = a-5

           

        *=

            - a *= 5 相当于 a = a*5

           

        /=

            - a /= 5 相当于 a = a/5  

   

        %=

            - a %= 5 相当于 a = a%5  

           

下面是一个在复杂语句中使用赋值的例子：

let a = 1;

let b = 2;

let c = 3 - (a = b + 1);

alert( a ); // 3

alert( c ); // 0

上面这个例子，(a = b + 1) 的结果是赋给 a 的值（也就是 3）。然后该值被用于进一步的运算。

【开发中不要这样！！！】

链式赋值（Chaining assignments）

另一个有趣的特性是链式赋值：

let a, b, c;

a = b = c = 2 + 2;

alert( a );// 4

alert( b ); 
// 4

alert( c );
// 4

链式赋值从右到左进行计算。首先，对最右边的表达式 2 + 2 求值，然后将其赋给左边的变量：c、b 和 a。最后，所有的变量共享一个值。

同样，出于可读性，最好将这种代码分成几行：

c = 2 + 2;b = c；

a = c;

这样可读性更强，尤其是在快速浏览代码的时候。

原地修改

我们经常需要对一个变量做运算，并将新的结果存储在同一个变量中。

例如：

let n = 2;

n = n + 5;

n =n * 2;

可以使用运算符 += 和 *= 来缩写这种表示。

let n = 2;

n += 5; // 现在 n = 7（等同于 n = n + 5）

n *= 2; // 现在 n = 14（等同于 n = n * 2）
alert( n ); 
// 14

所有算术和位运算符都有简短的“修改并赋值”运算符：/= 和 -= 等。

这类运算符的优先级与普通赋值运算符的优先级相同，所以它们在大多数其他运算之后执行：

let n = 2;

n *= 3 + 5;

alert( n ); // 16 （右边部分先被计算，等同于 n *= 8）            

关系运算符。比较运算符

        - 关系运算符用来比较两个值之间的大小关系的

            >

            >=

            <

            <=

        - 关系运算符的规则和数学中一致，用来比较两个值之间的关系，

            如果关系成立则返回true，关系不成立则返回false。

        - 如果比较的两个值是非数值，会将其转换为Number然后再比较。

        - 如果比较的两个值都是字符串，此时会比较字符串的Unicode编码，而不会转换为Number。

        ==      等于         比较值

        ===     全等于       先比较类型，再比较值

        ！==    不全等于

        ！=     不等于

相等运算符

        ==

            - 相等，判断左右两个值是否相等，如果相等返回true，如果不等返回false

            - 相等会自动对两个值进行类型转换，如果对不同的类型进行比较，会将其转换为相同的类型然后再比较，

                转换后相等它也会返回true

        !=

            - 不等，判断左右两个值是否不等，如果不等则返回true，如果相等则返回false

            - 不等也会做自动的类型转换。

           

        ===

            - 全等，判断左右两个值是否全等，它和相等类似，只不过它不会进行自动的类型转换，

                如果两个值的类型不同，则直接返回false

               

        !==

            - 不全等，和不等类似，但是它不会进行自动的类型转换，如果两个值的类型不同，它会直接返回true

           

        特殊的值：

            - null和undefined

                - 由于undefined衍生自null，所以null == undefined 会返回true。

                    但是 null === undefined 会返回false。

                   

            - NaN

                - NaN不与任何值相等，报告它自身 NaN == NaN //false

               

            - 判断一个值是否是NaN

                - 使用isNaN()函数

               

逗号运算符

位运算符

位运算符把运算元当做 32 位整数，并在它们的二进制表现形式上操作。

这些运算符不是 JavaScript 特有的。大部分的编程语言都支持这些运算符。

下面是位运算符：

• 按位与 ( & )
• 按位或 ( | )
• 按位异或 ( ^ )
• 按位非 ( ~ )
• 左移 ( << )
• 右移 ( >> )
• 无符号右移 ( >>> )

这些运算符很少被使用，一般是我们需要在最低级别（位）上操作数字时才使用。我们不会很快用到这些运算符，因为在 Web 开发中很少使用它们，但在某些特殊领域中，例如密码学，它们很有用。当你需要了解它们的时候，可以阅读 MDN 上的 位操作符 章节。

优先级：

        - 和数学中一样，JS中的运算符也是具有优先级的，

            比如 先乘除 后加减 先与 后或

        - 具体的优先级可以参考优先级的表格，在表格中越靠上的优先级越高，

            优先级越高的越优先计算，优先级相同的，从左往右计算。

        - 优先级不需要记忆，如果越到拿不准的，使用()来改变优先级。