逻辑与&&、逻辑或||和逻辑非！_逻辑与逻辑或逻辑非-CSDN博客

点击跳转原文

js中逻辑运算符在开发中可以算是比较常见的运算符了，主要有三种：逻辑与&&、逻辑或||和逻辑非！。

当&&和|| 连接语句时，两边的语句会转化为布尔类型（Boolean），然后再进行运算，具体的运算规则如下：

1.&&

1.1两边条件都为true时，结果才为true；
1.2如果有一个为false，结果就为false；
1.3当第一个条件为false时，就不再判断后面的条件

注意：当数值参与逻辑与运算时，结果为true，那么会返回的会是第二个为真的值；如果结果为false，返回的会是第一个为假的值。

2.||

2.1只要有一个条件为true时，结果就为true；
2.2当两个条件都为false时，结果才为false；
2.3当一个条件为true时，后面的条件不再判断

注意：当数值参与逻辑或运算时，结果为true，会返回第一个为真的值；如果结果为false，会返回第二个为假的值；

3.！

3.1当条件为false时，结果为true；反之亦然。

上代码说明：

 
         <!DOCTYPE html>  
        
         <html lang= 
         "en" 
         >  
        
         <head>  
        
         <meta charset= 
         "UTF-8" 
         >  
        
         <title>demo</title>  
        
         <script>  
        
         console.log( 5 && 4 ); 
         //当结果为真时，返回第二个为真的值4  
        
         console.log( 0 && 4 ); 
         //当结果为假时，返回第一个为假的值0  
        
         console.log( 5 || 4 ); 
         //当结果为真时，返回第一个为真的值5  
        
         console.log( 0 || 0 ); 
         //当结果为假时，返回第二个为假的值0  
        
         console.log((3||2)&&(5||0)); 
         //5  
        
         console.log(!5); 
         //false  
        
         </script>  
        
         </head>  
        
         <body>  
        
         </body>  
        
         </html>

补充：逻辑与的优先级是高于逻辑或的；

比如console.log(3||2&&5||0),会先算2&&5的值为5，然后再3||5----3，最后再3||0----3，所以最终结果为3.

补充

表达式a && 表达式b : 计算表达式a（也可以是函数）的运算结果，
如果为 True, 执行表达式b（或函数），并返回b的结果；
如果为 False，返回a的结果；

表达式a || 表达式b :   计算表达式a（也可以是函数）的运算结果，
                      如果为 Fasle, 执行表达式b（或函数），并返回b的结果；
                      如果为 True，返回a的结果；

转换规则:

对象为true；
非零数字为true；

零为false;

非空字符串为true；
空字符串为法false;
其他为false；

例如：
var a = obj || " " ; //如果 obj 为空，a就赋值为 " " ；
var a = check() && do(); //如果check()返回为真，就执行do()，并将结果赋值给 a;

其他网友的补充

今天复习js继承的时候发现了一个问题，先上代码了

 
         <script type= 
         "text/javascript" 
         > 
        
         window.onload =  
         function 
         () { 
        
         var 
         mama, 
        
         mama1, 
        
         test =  
         function 
         (name) { 
        
         debugger; 
        
         this 
         .name = name ||  
         'mama' 
         ; 
        
         }; 
        
         debugger; 
        
         mama =  
         new 
         test(); 
        
         mama1 =  
         new 
         test( 
         "mama1" 
         ); 
        
         alert(mama.name); 
         //name = mama 
        
         alert(mama1.name); 
         // name = mama1 
        
         } 
        
         </script>

在执行构造函数的时候，无参的构造函数返回的name是'mama'，有参数时，实例的name就是参数值了。
这个时候我就有点犯迷糊了，为什么逻辑运算符||能这么用呢？
由于是C#出身，所以对js ||这样用感觉很奇怪。
没辙，不懂先研究，实验实验就知道了。

 
         var 
         b, c, d; 
        
         b =  
         true 
         || 0; 
         //b=true; 
        
         c =  
         false 
         || 0; 
         //c=0; 
        
         d = 1 || 0; 
         //d=1;

换成别的呢？

 
         var 
         b, c, d; 
        
 
            
         b = 1-1 || 1+1;  
         //b=2 
        
 
            
         c =  
         function 
         () {  
         return 
         undefined } ||  
         function 
         () {  
         return 
         1}; 
         //c=function(); 
        
 
            
         d = c(); 
         //d=undefined 
        

 
         var 
         b, c, d; 
        
 
            
         b = 1-1 || 1+1;  
         //b=2 
        
 
            
         c =  
         function 
         () {  
         return 
         1 } ||  
         function 
         () {  
         return 
         undefined}; 
         //c=function(); 
        
 
            
         d = c(); 
         //d=1 
        

1	`b = {} \|\| { a: 1, getA:` `function` `() {` `return` `this` `.a}};` `//b=object`

 
         var 
         b, c, d; 
        
         b = { a: 1, getA:  
         function 
         () {  
         return 
         this 
         .a } } || {};  
         //b=object 
        
         c = b.getA(); 
         //c=1;