精华内容
下载资源
问答
  • 二、关系表达式(比较) 1、关系表达式(左结合): 优先级次于算述表达式 (1)<、>、<=、>=优先级高 (2)==(等于)、!=(不等于)优先级低 2、成立不成立 成立:命题为真(true)...

    一、算述表达式 优先级高 左结合

    赋值表达式 优先级低 右结合

    二、关系表达式(比较)

    1、关系表达式(左结合):

    优先级次于算述表达式

    (1)<、>、<=、>=优先级高

    (2)==(等于)、!=(不等于)优先级低

    2、成立不成立

    成立:命题为真(true)值为1

    不成立:命题为假(false)值为0

    三、条件表达式(三目运算符)

    1、格式:

    表达式1 ? 表达式 2: 表达式3

    2、含义:

    整个表达式的值由表达式1决定;

    若表达式1成立,则整个条件表达式的值为表达式2的值;

    若表达式1不成立,则整个条件表达式的值为表达式3的值。

    例:

    求三数表达式:

    d=x>y?x:y;

    e=d>z?d:z

    d=x>y?(x>z?x:z):(y>z?y:z)

    3、表达式1的成立与不成立

    非0(值为1)——>成立

    0——>不成立

    4、优先级:只高于赋值法

    结合性:

    右结合

    四、逻辑表达式

    1、逻辑表达符

    !(单目)取反  非运算  优先级高于算述运算符

    &&(双目)并且  或运算  优先级低于运算符

    ||(双目)或者  与运算  运算符低于&&

    &&:

    两个表达式都成立时成立  否则不成立

    ||:

    两个表达式其中任何一个成立就成立,只有两个都不成立时不成立

    3、短路问题:

    ||:

    左边成立情况下编译器不计算右边

    &&:

    左边不成立情况下编译器不计算右边

    展开全文
  • 1.1-关系运算符和关系表达式 1.关系运算符:八种 >:大于,左边大于右边 <:小于,左边小于右边 >=:大于等于,左边大于或者等于右边 <=:小于等于,左边小于或者等于右边 ==:等于,...

    01-运算符与表达式

    1.1-关系运算符和关系表达式

    • 1.关系运算符:八种
      • >:大于,左边大于右边
        
      • <:小于,左边小于右边
        
      • >=:大于等于,左边大于或者等于右边
        
      • <=:小于等于,左边小于或者等于右边
        
      • ==:等于,左边等于右边
        
      • !=:不等于,左边不等于右边
        
      • ===:全等,左边等于右边且类型一致
        
      • !==:不全等,左边不等于右边或者类型不一致
        
     <script>
            /**1.关系运算符(比较运算符):比较两个数据之间的关系(某种条件是否成立)
                * 八种: >  >=  <  <=  ==  !=  ===全等 !== 不全等
            * 2.关系表达式:由关系运算符组成的式子    例如:  2 > 1
                    * 只要是表达式,就会有运算结果
             * 3.关系表达式的结果一定是布尔类型:true代表成立,false代表不成立
             */
        
            //1.基本使用
            console.log ( 5 > 3 );//true  成立
            console.log ( 100 < 1 );//false 不成立
        
            //2.相等与不等:只比较数据的值,不比较数据的类型
            //注意:一个 = 号表示赋值运算符  两个 == 是比较运算符,它们作用不一样,不要搞混淆了
             console.log ( 1 == 1 );//true   常用
            console.log ( "1" == 1 );//true  他们的值一样,只是数据类型不一样
        
            //3.全等不全等: 先比较数据的值,再比较数据的类型
            console.log ( "1" === 1 );//false  两者的值虽然相等都是1,但是他们数据类型不一样,所以不成立
        
        
        </script>
    

    1.2-逻辑运算符和逻辑表达式

    • 1.逻辑运算符:三种
      • &&:逻辑与 ,读作并且
      • ||:逻辑或,读作或者
      • !:逻辑非,读作取反
        • true(真)变false(假),false(假)变true(真)
    • 2.逻辑表达式:表达式1 逻辑运算符 表达式2
    • 3.运算口诀
      • 逻辑与表达式&&:一假则假
        • 左右两边同时成立,才为真,否则为假
          • 例如:有为青年找女朋友: 白富美:既要白,又要富,还要美。多个条件需要同时成立
      • 逻辑或表达式||:一真则真
        • 左右两边同时为假,才为假,否则为真
          • 例如:小资青年找女朋友:要么白,要么富,要么美。多个条件任意一个成立即可
      • 逻辑非!:取反
        • 例如:屌丝青年找女朋友:女的。 非xxxx类似于一种否定逻辑
      <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <title>Title</title>
        </head>
        <body>
        
        </body>
        <script>
        
            /* 
                0.关系运算符:某种条件的关系(成立/不成立),例如我的年龄大于你的年龄30>20
                1.逻辑运算符:多个条件之间的关系
                2.逻辑运算符只有三种
                    * && :逻辑与 ,读作并且
                    * || :逻辑或,读作或者
                    * !  :逻辑非,读作取反
                        * true(真)变false(假),false(假)变true(真)
             * 3.逻辑表达式: 表达式1 逻辑运算符 表达式2 
             */
        
            //1.逻辑与&&结果: 一假为假     (左右两边同时成立,才为真,否则为假)
            //表达式1    &&  表达式2       运算结果
            //真              真             真
            //真              假             假
            //假              真             假
            //假              假             假
            console.log ( 100 > 50 && 10 > 9 );		//true  左右两边同时成立
            console.log ( 100 > 500 && 10 > 9 );	//false   因为左边不成立
        
            //普通丈母娘找女婿 : 有车 有房 有存款     三个条件都要满足,缺一不可    
        
        
        
            //2.逻辑或 ||结果 : 一真则真  (左右两边同时为假,才为假,否则为真)
            //表达式1    ||  表达式2    运算结果
            //真               真         真
            //真               假         真
            //假               真         真
            //假               假         假
        
            console.log ( 100 > 500 || 10 > 9 );	//true  只要有一边为真则为真
            console.log ( 100 > 500 || 8 > 9 );		//false 只有两边都不成立才为假
        
            //我的丈母娘找女婿 :要么有车 要么有房  要么有存款   三个条件满足任何一个即可
        
            //3.逻辑非! : 又叫做取反  真变假 假变真
            //    !    表达式   结果
            //               假         真
            //                真      假
            let res = !false;
            console.log ( res );			//true  假变真,真变假
            console.log ( ! ( 2 > 1 ) );	//false     2>1的结果是true    与true相反的就是false
        
            //有的丈母娘找女婿 :只要不是外地的。   `非xxxx`类似于一种否定逻辑
        
        
        </script>
        </html>
    

    1.3-运算符优先级

    • 不需要刻意的去记,因为开发中很少会遇到多个运算符参与的式子,万一遇到也可以通过()来提升优先级
    • 运算符优先级:确定不同运算符的运算规则
      • 1.() 小括号:优先级运算符 作用就是提升优先级:不被拆散
      • 2.自增与自减
      • 3.算术运算符(先乘除后加减)
      • 4.比较运算符
      • 5.逻辑运算符
      • 6.赋值运算符
      • 同级运算符从左往右运算
    <script>
    
        let res = 3 + 2 - 5 * 0;
        console.log ( res );//5
    
        /**运算符优先级:确定不同运算符的运算顺序
         * 1.()      小括号:作用就是提升优先级
         * 2.自增与自减
         * 3.算术运算符(先乘除后加减)
         * 4.比较运算符
         * 5.逻辑运算符
         * 6.赋值运算符
         */
    
    </script>
    

    课堂小菜

    let num = 2;
    let res = num++ * (++num + num - num--);	  //2 *(4 + 4 - 4)  num3
    // ++或--这种自操作:在一个表达式中有多个的情况下,会互相影响(前面影响后面)
    //1.先算num++,后置:先运算后自增 2 * (++num + num - num--),此时num会变成3
    //2.括号提升了优先级:所以先算括号里面的 2 * (4 + num - num--) : num前置:先自增,后参与运算:3-=》4,num == 4
    //3.+和-同级:先算左边 2 * (4 + 4 - num--) :num == 4
    //4.后置--:先参与运算,后自减 2 * (4 + 4 - 4) : num == 3
    
    console.log(res, num);						// 8 3
    

    1.4-js转义符(了解)

    • 转义符: \ 改变原来符号的作用就叫转义符
    <script>
    /**
         * 转义符: `\`  改变原来符号的作用就叫转义符
         *  \" :输出双引号
         *  \t:水平制表符,说人话就是多打几个空格
         *  \n:换行符
         *  \\:显示一个\
         *
         */
        console.log ( "出来混了\\那么多年,从最开始的3万,到后来的五万,最后十五万,\n我也\"没有\"想到\t我最后会欠这么多钱");//出来混了\那么多年,从最开始的3万,到后来的五万,最后十五万,
    //我也"没有"想到    我最后会欠这么多钱
    
    // 重点:记住单引号里面要使用单引号需要转义,双引号里面使用双引号需要转义
    </script>
    

    02-数据类型比较

    1.1-null与undefined比较

    • undefined与null的区别,两个都表示什么都没有
    • null == undefined:成立,他们的值都是空
    • null === undefined:不成立,他们的值相等但是数据类型不同
    <script>
        /*JS总共有六种数据类型,其中五种基本数据类型,一种复杂数据类型
    
          *(1)null与undefined有什么区别
                * null == undefined 成立
                * null === undefined 不成立
    
         */
    
        //1.null与undefined的区别:需要记忆
        console.log ( null == undefined );//true  他们的值都是空
        console.log ( null === undefined );//false  他们的值相等 但是数据类型不同
    
    </script>
    

    1.2-NaN与isNaN

    • 1.NaN:Not a Number 不是一个数字
      • (1)NaN是number数据类型中一个特殊的数值,是数学计算错误得到的一个结果
        • 例如: ‘张三’ - 100,在数学上这是一种错误的计算,它的结果就是NaN
      • (2)NaN与任何数字都不等,包含它本身
      • (3)NaN与任何数字计算得到的都是NaN
    • 2.isNaN(数据):检测一个数据是不是NaN 得到的结果是布尔类型
      • 例如:isNaN(NaN),结果为true
      • 例如:isNaN(123),结果为false,表示123不是NaN
    • 3.了解:number类型浮点数(小数)精度丢失问题
      • (1)小数在进行数学计算时,会有一定的误差,这是计算机本身的bug,不仅是js语言,其他语言也有这个问题
      • (2)解决方案:不要让两个小数比较大小,这种情况一般不会影响正常开发
    <script>
        /*NaN:  not a number 不是一个数字
           * 1.NaN是number数据类型中一个特殊的数值,是数学计算错误得到的一个结果
           * 2.NaN与任何数字都不相等,包括它的本身
           * 3.NaN与任何数字计算得到的都是NaN
          isNaN(数据):判断一个数据是不是NaN,结果为布尔类型  true:是 false:不是
         */
    
        //1.NaN:not a number 不是一个数字
        //NaN是number数据类型中一个特殊的数值,是数学计算错误得到的一个结果
        let num = '张三' - 100;//当某个表达式无法计算(计算错误时),会得到NaN
        console.log ( num );				//NaN
        console.log ( typeof  NaN );		//number
    
        //2.NaN与任何数字都不等,包含它本身
        console.log ( NaN == 0 );			//false
        console.log ( NaN == NaN );			//false
    
        //3.NaN与任何数字计算得到的都是NaN
        console.log ( NaN + 100 );			//NaN
    
        //4.isNaN(数据):检测一个数据是不是NaN  得到的结果是布尔类型
        console.log ( isNaN ( NaN ) );		//true
        console.log ( isNaN ( 123 ) );		//false
        //如果检测的数据不是number类型,js编译器会尝试着将这个数据转化为number类型,然后再判断
        //这种数据类型转换称为隐式转换:下一小节讲解
        console.log ( isNaN ( "abc" ) );	//true
    
        //5.number浮点数(小数)精度丢失
        //小数在进行数学计算时,会有一定的误差,这是计算机本身的bug,不仅是js语言,其他语言也有这个问题
        //解决方案:不要让两个小数比较大小,这种情况一般不会影响正常开发
        console.log ( 0.1 + 0.2 );			//0.300000000000004
        console.log ( 0.1 + 0.2 == 0.3 );	//false
        console.log ( 0.4 + 0.5 );			//0.9
        console.log ( 1.1 - 0.2 );			//0.9000000000000001
    </script>
    

    1.3-字符串比较

    • 1.字符串比较规则是按照字母的顺序挨个进行比较,与字符串长度无关
    • 2.字符串比较区分大小写
    <script>
    	/*
    		1.字符串比较规则,按照字母的顺序,挨个比较
    		2.字符串的比较与长度无关
    		3.字符串的比较区分大小写
    	*/
        
        // 字符串的比较是挨个比较对应顺序位置的字母,与长度无关
        console.log('abc' > 'b');				// false,a比d小,所以abc比d小
        
        // 字符串的比较区分大小写,小写大于大写(与ASCII码表对应)
        console.log('a' > 'A');					// true,a对应ASCII码表为97,A为65
    </script>
    

    03-数据类型转换

    1.1-显式数据类型转换

    • 注意:数据类型的转变并不会改变原来变量的值,而是会产生一个新的值
      • 例如:(1) let num = ‘10’;
      • parseInt(num) :
    • 为什么要有数据类型转换?
      • 有时候想要进行某种计算的时候,由于数据类型不同往往会产生一些错误的结果,为了避免这种结果,我们需要将某种数据类型转化为其他数据类型
        • 例如:prompt()输入框得到的数据的类型是string,如果想要进行数学计算则需要转成number类型,否则会计算出错
    • 什么是显示类型转换:程序员主动转换(可以理解为使用关键字来转换)
      • 这种方式代码易读性更高

    1-其他类型转换成number类型

    <script>
    	/**转换成number
         * 第一种方式:`parseInt()`
         *          * 作用:转换整数
         *          * 从左往右解析,遇到非数字结束(停止解析),将解析好的整数返回
         *          * 如果第一个字符不是数字或者符号就返回NaN
         * 第二种方式:`parseFloat()`
         *          * 作用:转换小数
         *          * 与parseInt()最大的区别就是可以解析字符串的第一个小数点
         * 第三种方式: `Number()`
                   * 作用:布尔类型转换成数字 
         *         * 可以把任意值转换成数值,如果要转换的字符串只要有一个不是数字,返回NaN
         */
        console.log ( Number ( "123" ) );//123
        console.log ( Number ( "123.1.1abc" ) );	//NaN  只要有一个字符不是数字,得到就是NaN
        console.log ( parseInt ( "123.1.1abc" ) );	//123  从左往右解析,遇到非数字结束
        console.log ( parseFloat ( "123.1.1abc" ) );//123.1  与parseInt唯一的区别就是可以识别第一个小数点
    
        //一般数字字符串使用parseInt和parseFloat,其他数据类型转数字使用Number()
        console.log ( Number ( true ) );	//1布尔类型转换number会得到数字0(false)和1(true)
        console.log ( Number ( "" ) );		//0  空字符串转number会得到0
    	//js基础面试题可能会遇到
    	console.log(Number(undefined));		//NaN
        console.log(Number(null));			//0
    </script>
    

    2-其他类型转换成string类型

    • 1.第一种方式:变量名 .toString()
      • 如果变量的值为undefined或者null,则会报错
    • 2.第二种方式:String(变量名)
      • 与第一种方式的唯一区别就是如果变量的值为undefined或者null不会报错,会得到undefined或者null
    <script>
             /**转换成字符串string
             * 第一种方式:`变量名.toString()`
             *      * 如果变量的值为undefined或者null,则会报错
             *  第二种方式:`String(变量名)`
             *      * 与第一种方式的唯一区别就是如果变量的值为undefined或者null不会报错,会得到undefined或者null
             */
            
        
            let a = null;
        
            //1.常用: String (  )
            //特点:可以识别undefined与null
            console.log ( String ( null ) );
            console.log ( typeof String ( a ) );
        
            // //2.   变量名.toString ()
            //特点:无法识别undefined与null,程序会报错
            console.log ( a.toString () );
    </script>
        
    

    3-其他类型转换成boolean类型

    • 只有一种方式: Boolean(变量名)
      • 官网文档中有八种情况得到的false:0、-0、null、false、NaN、undefined、或者空字符串("")、 document.all(js下个阶段会接触的东西)
      • 其他一切均为true
    <script>
        /**转换成boolean
             * 只有一种方式:  `Boolean(变量名)`
             *      * 以下八种情况会得到false,其余的一切数据得到都是true
             *          * 数字0、-0、null、false、undefined、空字符串”“、NaN
             */
        
        console.log ( Boolean ( 0 ) );				//false
        console.log ( Boolean ( -0 ) );				//false
        console.log ( Boolean ( null ) );			//false
        console.log ( Boolean ( false ) );			//false
        console.log ( Boolean ( undefined ) );		//false
        console.log ( Boolean ( '' ) );				//false
        console.log ( Boolean ( NaN ) );			//false
    </script>
    

    1.2-隐式数据类型转换

    显式转换:程序员主动调用语法去转换数据类型,语义更加明确

    隐式转换:运算符两边数据类型不一致,编译器自动帮我们转换一致在计算,这是js的语法特点

    • 隐式转换
      • 1.转成string类型:+号两边如果有一边是字符串,则会把另一边转换成字符串,然后进行拼接
      • 2.转成number类型:以下几种运算符会将任何数据转换成number类型再运算,如果无法转换则为NaN
        • 数学正号 : +num
          • 当 +/-号写在一个变量名的前面,此时表示数学的正/负数
        • 自增自减(++ --)
        • 算术运算符(+ - * / %)
        • 比较运算符(> < >= <= == != === !==)
          • 说明:全等与不全等会先比较值(此时会隐式转换再比较),然后再比较数据类型
      • 3.转成boolean类型:逻辑非(!)会将任何数据转为boolean类型再运算
      • 4.+号有三种含义:数学正负号(转成number)、算术运算符(转成number)、字符串连接符(转成string)
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Document</title>
    </head>
    <body>
        <script>
            /* 
            1. 显式转换 : 程序员主动使用语法来转换(阅读性最高)
    
            2. 隐式转换 : 如果运算符两边数据类型不一致,编译器偷偷的帮我们转成一致再计算。
                (1)其他数据类型转number :
                    数学正号 : +num
                    自增自减: ++ --  
                    算术运算符: + - * / %
                    关系运算符 : > < >= <=
                (2)其他数据类型转string : +
                (3)其他数据类型转boolean : !
            
             */
    
            console.log('100' - 1);			// Number('100') - 1 = 100 - 1 = 99
    
                //1.其他数据类型转number :
                //    数学正号 : +num
                //    自增自减: ++ --  
                //    算术运算符: + - * / %
                console.log(+'10');			// Number('10')
                
                console.log('张三' - 100);	// Number('张三') - 100 = NaN - 100 = NaN
                console.log(10 - '1');		// 10 - Number('1') = 10 - 1 = 9
                
                //2. 其他数据类型转string : +
                console.log('1' + 1);		//'1' + String(1) = '1' + '1' = '11'
    
                /* 
                容易混淆点 : 把算术运算符 + 转换规则  与 连接符 + 转换规则搞混淆
                 */
                console.log('1' + true);	//1true 连接符 ‘1’ + String(true) = '1' + 'true' = '1true'
                console.log(1 + true);		//2 算术运算符  1 + Number(true) = 1 + 1 = 2
    
                console.log(1 + undefined);	//NaN 算术 1 + Number(undefined) = 1 + NaN = NaN
                console.log(1 + null);		//1 算术 1 + Number(null) = 1+ 0 = 1
                console.log('1' + null);	//1null 连接 '1' + String(null) = '1' + 'null' = '1null'
                
                //其他数据类型转boolean : !
                //取反 : true变false false变true
                console.log(!1);			//(1)!Boolean(1) = !true = false
                console.log(!!'');			//(1)!!Boolean('') (2)!!false (3)!true = false
    
    
    //课堂小彩蛋 : 经典js面试题
    console.log(undefined + null);         //	NaN
    console.log(undefined - null);         //  NaN
    console.log(undefined - undefined);     // NaN
    console.log(null - null);             //0            
    
        </script>
    </body>
    </html>
    

    04-流程控制

    • 编程语言都有三大流程控制结构
      • 顺序结构:代码从上往下顺序执行
      • 分支结构:代码选择执行
      • 循环结构:代码重复执行

    05-分支结构

    分支结构作用:代码根据条件执行

    • 为什么要有分支结构?
      • 现实世界中,我们在做某些事情的时候是有前提条件的,例如:我今天考试了,考的好与坏与回家的状态不一样的?
        • 考的好:回家有赏
        • 靠的不好:回家有伤

    1.1-if单分支结构

    • 1.if结构语法:if(条件 true/false){ 条件成立时需要执行的代码 }
    • 2.if结构补充说明:
      • 1.大括号中可以是任何代码,不限数量
      • 2.如果大括号中代码有且只有一行,则可以省略大括号。这种写法代码不规范,不是老司机的作风
    • 3.注意点:小括号中的条件可以是哪些呢
      • (1)关系表达式:结果一定是布尔类型
      • (2)布尔类型的值:true和false
      • (3)其他表达式和值:都会先转换成布尔类型再判断真和假
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    
    
    
    <script>
    
        //1.默认情况下,代码是从上往下执行的(顺序结构)
        console.log ( "我今天考试了" );
        console.log ( "我回家了" );
        console.log ( "爸爸打了我一顿" );
        console.log ( "我睡觉了" );
    
        //需求:考试不及格爸爸才打我,及格了就不打
    
        //2.if分支结构:根据条件来执行代码
    
        /**if结构语法
           if ( 条件   true/false ){
                条件成立时需要执行的代码
            }
         */
    
        //示例1
        if(1>0){
            console.log ( "我被执行了" );
        }
        console.log ( "111" );//只有大括号内的代码才是根据条件执行的,大括号后面的代码还是顺序执行
    
        //需求实现
        let score = 80;
        console.log ( "我今天考试了" );
        console.log ( "我回家了" );
        if(score < 60){
            console.log ( "爸爸打了我一顿" );
        }
        console.log ( "我睡觉了" );
    
        //注意点:小括号中的条件可以是哪些呢
        /*
        (1) [通常]关系表达式:结果一定是布尔类型
        (2) 布尔类型的值:true和false
        (3) 其他表达式和值:都先转换成布尔类型再判断真会和假
         */
        let num = 10;
        if(num){
            //num是10,转换成布尔类型是true,所以会执行大括号代码
            alert('num满足了条件');
        }
    
    </script>
    </body>
    </html>
    

    1.2-if-else双分支结构

    if(条件){
        条件成立时需要执行的代码
    }else{
        条件不成立时需要执行的代码
    }
    
    • 1.if-esle结构语法:用于两种互斥的条件判断
      • 例如:如果(if)我的钱超过100块就洗脚(也就是说钱>=100),否则(else)不洗脚(也就是说钱<100)
    • 2.if-else结构注意点
      • if大括号中的代码与else大括号的代码只会执行一个,不会同时执行
    • if-else语句的作用主要就是为了提高代码的运行效率,虽然可以用两个if语句来代替if-else语句,但是两个if语句需要判断两次,而if-else只需要判断一次
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    
    </body>
    
    <script>
        //需求:(1)如果不及格,爸爸就打我 (2)如果及格,爸爸给我买奥迪
    
        //1.用if实现
        let score = 80;
        console.log ( "我今天考试了" );
        console.log ( "我回家了" );
        if(score >= 60){//及格
            console.log ( "爸爸给我买了一辆奥迪" );
        }
        if(score < 60){//不及格
            console.log ( "爸爸打了我一顿" );
        }
        console.log ( "我睡觉了" );
    
        //2.if-else结构:用于两个互斥的条件
        //优点:只需要一次判断
        /*语法
        if(条件){
            条件成立时需要执行的代码
        }else{
            条件不成立时需要执行的代码
        }
    
        if-else结构注意点:if大括号中的代码与else大括号的代码一定会执行一个,不会同时执行
         */
    
        score = 80;
        console.log ( "我今天考试了" );
        console.log ( "我回家了" );
        if(score >= 60){//及格
            console.log ( "爸爸给我买了一辆奥迪" );
        }else{//不及格
            console.log ( "爸爸打了我一顿" );
        }
    
        console.log ( "我睡觉了" );
    
        //if-else结构注意点:if大括号中的代码与else大括号的代码一定会执行一个,不会同时执行
        //世界上最遥远的距离不是生与死,而是我在if里,你在esle里,看起来那么近却永远不能在一起
        if(5 > 3){
            alert('执行了if中的语句')
        }else{
            alert('执行了else中的语句');
        }
    </script>
    </html>
    

    1.3-if-else if-else多分支结构

    • 1.if-else if-else结构语法:

      if(条件1){
      条件1成立时需要执行的代码
      }else if(条件2){
      条件2成立时需要执行的代码
      }else if(条件3){
      条件3成立时需要执行的代码
      }else{
      以上所有条件都不成立时需要执行的代码
      }

    • 2.注意点:

      • (1) if-else if -else结构中必须以if开头,中间的else if可以是多个,末尾的else可以省略(一般都不会省略)
      • (2)if-else if-else语句中所有的大括号中的代码只会执行其中一个,不会执行多个
    <script>
    
        //需求:(1)如果不及格,爸爸就打我 (2)如果60-70,爸爸给我买奥迪 (3)如果70-80分,爸爸给我买保时捷
        //(4)如果超过80分,爸爸给我买法拉利
    
        /**
         * if-elseif-else结构语法:用于多种条件判断
    
          if(条件1){
                条件1成立时需要执行的代码
          }else if(条件2){
                条件2成立时需要执行的代码
          }else if(条件3){
                条件3成立时需要执行的代码
          }else{
                以上所有条件都不成立时需要执行的代码
          }
    
         * 注意点:
            * (1) if-else if -else结构中必须以if开头,中间的else if可以是多个,末尾的esle可以省略(一般都不会省略)
            * (2)if-else if-else语句中所有的大括号中的代码最多只会执行一个,不会执行多个
    
         */
    
        let score = 50;
        console.log ( "我今天考试了" );
        console.log ( "我回家了" );
    
        if(score >= 80){
            console.log ( "爸爸给我买了一辆法拉利" );
        }else if(score >= 70){						//隐藏条件: score < 80
            console.log ( "爸爸给我买了一辆保时捷" );
        }else if(score >= 60){						//隐藏条件: socre < 70
            console.log ( "爸爸给我买了一辆奥迪" );
        }else{										//隐藏条件: score < 60
            console.log ( "爸爸打了我一顿" );
        }
    
        console.log ( "我睡觉了" );
    
    
    </script>
    
    展开全文
  • 在C#语言的编程中,经常会用到关系表达式逻辑表达式,或者二者的混合运用。 1、关系表达式是由关系运算符组成的。比如:>、、>=、、==、!=。运用这几个运算符构成的表达式就叫做关系表达式。举例如下: int ...

    C#语言的编程中,经常会用到关系表达式和逻辑表达式,或者二者的混合运用。

    1、关系表达式是由关系运算符组成的。比如:><>=<===!=。运用这几个运算符构成的表达式就叫做关系表达式。举例如下:

    int number_01;

    int number_02;

    //输入number_01的值

    Console.Write("请输入number_01的值:");

    number_01=Console.ReadLine();

    //输入number_02的值

    Console.Write("请输入number_02的值:");

    number_02=Console.ReadLine();

    if(number_01==number_02)

    {

    Console.WriteLine("number_01number_02相等");

    }

    if(number_01!=number_02)

    {

    Console.WriteLine("number_01number_02不相等");

    }

    if(number_01>number_02)

    {

    Console.WriteLine("number_01大于number_02");

    }

    if(number_01>=number_02)

    {

    Console.WriteLine("number_01大于或者等于number_02");

    }

    if(number_01<number_02)

    {

    Console.WriteLine("number_01小于number_02");

    }

    if(number_01<=number_02)

    {

    Console.WriteLine("number_01小于或等于number_02");

    }

    2、逻辑表达式是由逻辑运算符组成的。主要有:&|!^

    逻辑与&的规则:

    逻辑与两边的逻辑值都为true,结果才为true;否则为false

    true&true=true

    true&false=false

    false&true=false

    false&false=false

    逻辑或的规则:

    逻辑或两边的逻辑值只要有一个为true,结果就为true

    true|true=true

    true|false=true

    false|true=true

    false|false=false

    逻辑非为取相反的值。

    false=true

    !true=false

    逻辑异或:

    逻辑异或为两边的值相同时为false,其它的情况为true

    true^true=false

    true^false=true

    false^true=true

    false^false=false

    展开全文
  • 例1: 1!=3>4 运算结果为多少? 结果为: 1 例2: ...1、关系运算符有>、=、 ...2、关系逻辑表达式的运算结果是一个逻辑值,1(真),0(假),不存在其他值,它们的值可作为算术值处理; 3、3>

    例1:

    1!=3>4  运算结果为多少?

    结果为: 1

    例2:

    int x;

    x=100;

    printf("%d",x>10);

    结果:1


    分析:

    1、关系运算符有>、<、>=、<=、==、!= 6个,前四个优先级大于后两个;逻辑表达式有!(非)&&(与)||(或);

        优先级:!--算术运算符--关系运算符--&&--||--赋值运算符;

    2、关系、逻辑表达式的运算结果是一个逻辑值,1(真),0(假),不存在其他值,它们的值可作为算术值处理;

    3、3>4运算结果为假(0),1!=0运算结果为真(1);

    4、逻辑表达式中,若某一步已得到整个表达式的结果,后面的部分将不再运算!

        如:int a=1,b=0,c;

              c=a||++b;

              结果b的值仍为0;


             c=b&&a++;

              结果a的值仍为1

    5、a>b>c,在C语言中应写为a>b&&b>c。


    展开全文
  • 一成为管理人员,例如产品研发经理,技术经理,项目经理等继续;二是技术工作之路,成为高级软件工程师、需求工程师等。
  • 条件查询 按关系表达式查询 按逻辑表达式查询
  • 逻辑表达式关系表达式运算.c

    千次阅读 2018-11-27 19:24:11
    逻辑表达式关系表达式 0表示假,1表示真,任何非0的数为真 逻辑表达式是指运算符为或||、与&amp;&amp;、非!的表达式。返回值为0或1,0表示false,非0表示true. 例如!0返回1,0&amp;&amp;1返回0...
  • 算术表达式 算术运算符用于对操作数进行各种算术运算。Python 中的算术运算符如表所示。 在Python 3 中,除法运算符(/)永远返回一个浮点数,因此5/2 的结果将为2.5。 表达式中最常见也最基础的一类就是算术...
  • 关系运算符与关系表达式  >=为同级,优先级较高,== !=优先级较低。 逻辑运算符! && ||优先级依次降低。 ! * / %  + - > =  == != && || 优先级依次降低,先是非,然后是算数运算, 然后是关系...
  • [中国寒龙联盟出品]C语言基础视频教程第五课之算术运算符和算数表达式,关系运算符和关系表达式,逻辑运算符和逻辑表达式,贬值运算符和贬值表达式,自增运算符和自减表达式,逗号运算符和逗号表达式,条件运算符和...
  • 写下判断闰年的表达式,设待判断的年份变量为 year. 闰年的判定(符合下面两条件之一) 1.年份能够被400整除 2.年份能够被4整除,但不能被100整除   让用户输入一个年份,如果是闰年输出true,如果不是则输出false. ...
  • 正则表达式逻辑关系

    万次阅读 2016-10-25 20:08:22
    正则表达式逻辑关系正则表达式之间的逻辑关系可以简单地用与、或、非来描述,如表所示。通常来说,正则表达式可以看做这三种逻辑关系的组合。下面分析这三种逻辑。1.与“与” 是正则表达式中最普遍的逻辑关系。...
  • 逻辑非!运算符,因为它适合布尔变量。 2、整型变量的比较: if (value == 0) if (value != 0) 就用普通的==和!=运算符。 3、浮点型变量的比较: if (x == 0.0) // 错误的可能极大 if ((x&gt;=-...
  • 幕布斯5086720今天使用正则表达式是遇到一个问题, 磨了半天, 发现犯了个低级错误, 因此记录下来加深印象问题描述:我需要把 ^drawable(-[a-zA-Z0-9]+)*$ 和 ^mipmap(-[a-zA-Z0-9]+)*$ 这两个正则表达式用或的关系连接...
  • 逻辑关系说明与在某个位置,某些元素(字符、字符组或者子表达式)必须出现或在某个位置,某个元素或许不出现,或许不出现,或许长度不固定;要出现的,是某几个元素中的一个非在某个位置,某些元素不能出现...
  • 表示或的关系 [] []符号表示其中的字符之间的逻辑是或,比如[abc]表示a|b|c 便捷的写法还有 [a-z] [^a-z] 非a-z (^符号在[]中表示取反,在其他地方表示开头位置) [a-zA-Z0-9] [a-z&&^bc] a-z除了bc 容易理解...
  • jsp el表达式逻辑

    2016-08-30 12:32:56
    类别 运算符  算术运算符 + 、 - 、 * 、 / (或 div )...关系运算符 == (或 eq )、 != (或 ne )、 (或 gt )、 = (或 ge )  逻辑运算符 && (或 and )、 || (或 or )和 ! (或 not )  验证运算符 empty
  • 立即学习:https://edu.csdn.net/course/play/8088/165739?utm_source=blogtoedu ...=优先级(<,,>,>=) 关系表达式的值是一个逻辑值:true of false(1或0) 例:printf("5>3的值为:%d",5>3);//1 &&:与 ||:或 !:非
  • 逻辑非 逻辑表达式求解中,不是所有逻辑运算符都会被执行 &&只有前半段结果为true(1),才执行后半段语句;|| 同理,只有前半部分结果为fales(0)才执行后半段语句 int a=1,b=2,c=3; if(a>5 && (b=5)>1) { \\....... }...
  • 本文约1700字,主要讲了关系运算符和关系表达式,逻辑运算符和逻辑表达式。带你进入C语言的世界,入门C语言,后边将持续更新。可以收藏学习。想了解,请点击该处跳转阅读。 本文全干货,新手必备,感谢你的阅读,祝...
  • 逻辑表达式

    2016-08-25 11:38:30
    2.逻辑表达式可以描述多个条件,并且使用逻辑运算符来指定多个条件之间的关系 符号 含义 && 与 ll 或 ! 非 * 逻辑与表达式逻辑与:由&&连接起来的逻辑表达式,只要当两边的条件都成立的时候,整个逻辑表达式猜...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,571
精华内容 1,828
热门标签
关键字:

关系表达式逻辑表达式