js运算符与表达式**

• 运算符只是一种运算的符号，单独使用无意义，通常与需要计算的数据在一起组成表达式
• 表达式一定有结果，要么直接打印要么存入变量中

js中 + 号 两个作用

1. 字符串连接符 ： 连接字符串
   * 条件 ：+号两边只要有一边是string类型
2. 算术加法
   * 条件 : +号两边都是number类型

<script>
    //1 字符串连接符：将 + 号 两边的字符串连接在一起组成一个新的字符串
    //前提条件：  + 号的两边，只要有一边是string类型
    let name = '马云';
    //console.log ( "我的名字是name" );//此时name是字符串的一部分，无法取到变量的值
    console.log ( "我的名字是:" + name);

    //示例：
    let res1 = '10' + 10;
    console.log ( res1 );//1010

    //2.数学加法
    //前提条件： 当 + 号两边都是number类型的时候，代表数学加法运算
    let res2 = 10 + 10;
    console.log ( res2 );//20

</script>

算术运算符与算术表达式

• 1.算术运算符：数学中的算术运算
  +：加法 -：减法 *：乘法 /：除法 %：求余（求模运算）

• 2.算术运算符只是一种运算的符号，由运算符参与的式子称之为表达式

• 3.算术表达式（运算式）：由算术运算符组成的式子 例如： 数字1 + 数字2

• 4.算术表达式一定会得到一个运算的结果：要么直接打印这个结果（直接量），要么用变量保存

• 5.算术运算符的优先级与小学数学学的一致：小括号>乘除模>加减

<script>
    /**加法*/
    console.log ( 1 + 1 );		//直接打印算术表达式的结果
    let num = 100 + 50;			//用变量保存表达式的结果
    console.log ( num );		//150

    /**减*/
    console.log ( 2 - 1 );		//1 数值

    /**乘法*/
    console.log ( 20 * 3 );		//60

    /**除法
     * 1.如果两数相除的结果是一个无理数（无限不循环小数）或者无限循环小数，则无法完整的表示所有的小数
     一般这种情况不影响开发，可以忽略
     * 2.数学中0不能作为除数，JS里也一样
     如果作为除数会得到一个关键字：Infinity，代表无穷大的意思
     */
    console.log ( 10 / 3 );		//3.333333
    console.log ( 10 / - 2 );	//-5
    console.log ( 10 / 0 );		//Infinity无穷大

    /**求模*/
    console.log ( 10 % 3 );		//1

</script>

复合算术运算符

• +=: 在自身值的基础上再加多少
• -=：在自身值的基础上减多少
• *=: 在自身值的基础上乘多少
• /=: 在自身值的基础上除多少
• %=：在自身值的基础上模多少

<script>
    // +=
    let num1 = 10;
    num1 += 10;				//这行代码相当于 num1 = num1 + 10 的简写形式
    console.log ( num1 );	//20
    
    // -=
    let num2 = 70;
    num2 -= 10; 			//相当于  num2 = num2 - 10;
    console.log(num2);		//60
    
    // *=
    let num3 = 20;
    num3  *=  4;  			//相当于  num3 = num3 * 4;
    console.log(num3);		//80
    
    // /=
    let num4 = 90;
    num4 /= 3;				//相当于 num4 = num4 / 3
    console.log(num4);		//30

    // %=
    let num5 = 10;
    num5 %= 3; 				// num5 = num5 % 3;
    console.log(num5);		//1
    
	// 注意：不管是哪种复合运算，都是左边与右边的结果进行运算
    let num6 = 10;
    num6 -= 10 - 5;			//相当于 num6 = num6 - (10 - 5)
    console.log(num6);		//5

</script>

自增/自减运算符

• 1.自增/自减都称之为自操作运算
  • ++：自增，自己+1
  • –：自减，自己-1
• 2.自操作运算都是一元表达式，即只有一个变量参与运算
• 3.自操作运算不能用于直接量

<script>

    //1.自增运算符 ++
    //后置自增表达式:   num++
    let num1 = 10;
    num1++;					//这行代码相当于 num1 = num1 + 1 的简写形式
    console.log ( num1 );	//11
    
	//2.前置自增
    let num2 = 20;
    ++num2;					//这行代码相当于 num2 = num2 + 1 的简写形式
    console.log( num2 );	//21
   
    
	//注意：以上内容说明：如果自操作是独立一行代码，不参与其他运算或者输出，那么
	//     *** 前置和后置没有区别    
    
    //3.前置和后置区别
    let num3 = num4 = 1;	//1赋值给num4，然后赋值给num3，相同值的不同变量简写初始化
    console.log(num3++);	//1 先保留num3的原始值1，用于输出，然后自增为2
    console.log(++num4);	//2 先运算num4自增，num4为2，然后2用于输出
    
    console.log(num3,num4);	//2 2
    //注意：以上内容说明：如果自操作是与其他操作一起运算，那么
    //     ***前置会先改变自己，后参与其他运算；后置是先保留自己参与运算，后改变自己
      
</script>

<script>
	//1.自减运算符 --
    //自减表达式： num--
    let num5 = 20;
    num5--;					//这行代码相当于 num2 = num2 - 1 的简写形式
    console.log ( num2 );	//19
    
    //2.前置自减
    let num6 = 40;
    --num4;
    console.log( num6 );	//39
    
    //3.自减操作参与其他运算
    let num7 = num8 = 1;
    console.log(num7--,--num8);	//1 0
</script>

关系运算符和关系表达式

1.关系运算符（比较运算符）：比较两个数据之间的关系（某种条件是否成立）
* 八种： > 、>= 、< 、 <= 、== 、 != 、=== 全等 、 !== 不全等
2.关系表达式：由关系运算符组成的式子 例如: 2 > 1
* 只要是表达式，就会有运算结果
3.关系表达式的结果一定是布尔类型：true代表成立，false代表不成立

<script>
    //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.逻辑表达式：表达式1 逻辑运算符 表达式2
2.运算口诀

• 逻辑与表达式&&：一假则假
  • 左右两边同时成立，才为真，否则为假
• 逻辑或表达式||：一真则真
  • 左右两边同时为假，才为假，否则为真
• 逻辑非!：取反

<script>
    //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

</script>

运算符优先级

优先级顺序：

• 1.() 小括号：优先级运算符 作用就是提升优先级：不被拆散
• 2.自增与自减
• 3.算术运算符（先乘除后加减）
• 4.比较运算符
• 5.逻辑运算符
• 6.赋值运算符
• 同级运算符从左往右运算

<script>
        // 括号提升的运算符的优先级，并不改变运算的过程
        let a = 1 + (1 - 1);
        // 先算 1 +
        // 后算 (1 - 1)


        let b = a++ * (a++ + 1);
        // 错误示范：括号提升优先级
        // 1. 先算括号： (a++ + 1) 后置：预留1 + 1  a = 2
        // 2. 后算前面：a++ * (2)  2 * 2 a = 3
        console.log(b);   //3

        // 正确示范：从左往右
        // 1. 先算a++ *  后置：a预留1参与运算 1 *     a = 2
        // 2. 后算(a++ + 1)：后置 a预留2 参与运算（2 + 1）  a = 3
        // 3. 结合 1 * 3 = 3
    </script>