js的运算符与判断循环语句

js的运算符与判断循环语句

算数运算符

+ - * / %

注意⚠️：

+ 运算符比较特殊：进行求和运算或字符串拼接操作

求和: + 两边的操作数都是数值类型，进行求和运算

拼接： + 只要有一边是字符串类型，则执行拼接操作，结果是一个字符串

示例🟢 :

• 数值类型和字符串类型的运算

var num = 10,
	count = 20,
	str = '12',
	sum = 0;
// + 求和还是拼接，由两边的操作数的数据类型决定
sum = num + count + str;  // 3012
sum = num + str + count ;  // 101220
sum = str + (num  + count) ;  // 1230
sum = str + num  * count ;  // 运算符的优先级  12200

• 字符串类型的数值字面量和数值类型可以进行- * / %运算， 字符串类型的数值字面量 会隐式类型转换，转换为等价的数值类型，然后参与运算

• 布尔类型和数值类型运算： 布尔类型进行隐式类型转换 true ===> 1; false ===> 0

console.log(1 + true); // 2
console.log(1 + false); // 1

自增自减

++ --

自增：++

前增量： ++num 首先自身先增加 1， 然后拿着增加后的值参与运算
后增量: num++ 首先拿着之前的值参与运算，然后再自身增加 1

自减：--

前减量： --num 首先自身先减少1， 然后拿着减少加后的值参与运算
后减量: num-- 首先拿着之前的值参与运算，然后再自身减少1

示例：🟢

var num = 10;
var sum = 0;
sum = num + num++ + ++num + num-- + --num + num;
console.log(sum , num);
//sum = 10 + 11 + 12 + 11 + 10 + 10

关系运算符

> >= < <= == === != !==

关系运算的结果是一个布尔值，true / false

== 和 === 的区别

==：相等，只判断值相等，不考虑数据类型

===：全等，考虑值和数据类型：只有值和数据类型都相等才相等

数值类型关系运算

console.log(2 > 1);//true
console.log(2 > 10);//false

字符串类型关系运算

字符串进行比较适合，比较的是字符串对应的ASCII码；把字符串转换为对应的ASCII码，然后进行比较

特殊的字符：0 ：48 a ：97 A ：65

console.log('a'>'A');//true
console.log('a'>'b');//false

字符串和数值类型关系运算

1.字符串类型的数值字面量可以和数值类型进行关系运算，运算之前把字符串类型的数值字面量(隐式类型转换)转换为等价的数值类型，然后参与运算

console.log('10' > 10); // false
console.log('10' < 10); // false
console.log('10' == 10); // true
console.log('10' === 10); // false
console.log('10' != 10); //false
console.log('10' !== 10); //true

2.纯字符串和数值类型没有办法进行关系运算；纯字符串没有等价的数值类型进行转换

console.log('a' < 12); // false
console.log('a' > 12); // false
console.log('a' == 12); // false

逻辑运算符

&& || !

&&逻辑与：左右两边都为真则结果为真，只要一边为假则结果为假

console.log(3 > 2 && 2 < 1);
console.log(3 > 2 && 2 > 1);

||(逻辑或)：左右两边只要有一边为真则结果为真，两边都为假则结果为假

console.log(3 > 5 || 5 > 1);
console.log(3 > 5 || 5 > 10);

！逻辑非：真假互换

console.log(!(3 > 5 && 3 > 1));

1.存在短路情况： 如果左边为假，则直接返回结果为假； 后边的不在执行

示例

var num = 10;
if(3 > 10 && ++num){
  console.log('hello');
}else{
    console.log('ok');//ok
} 
console.log(num); // 10

2.存在短路情况： 如果左边为真，则直接返回结果为真，后边的不在执行

if(30 > 10 || ++num){
    console.log('hello');//hello
}else{
    console.log('no');
}
console.log(num); // 10

3.逻辑运算符的特殊情况

&&左右两边是具体的值，则结果是一个具体的值，存在隐式类型转换

console.log(3 && 0);//0
console.log(0 && 2);//0
console.log(1 && 2);//2
console.log('' && 2);// 
console.log(3 && 3 > 1);// true
console.log(30 > 13 && 1);// 1

console.log(2 || 0);//2
console.log(0 || 10);//10
console.log(0 || '');//
console.log(0 || 3 > 1);//true

赋值运算符

=

复合运算符

+= -= *= /= %=

变量先参与运算，运算后把结果赋值给该变量

var count = 10;
count = count + 30;
//简写
count += 30;

条件运算符

expression ? statement1 : statement2

expression 表达式的结果为真，则执行 ? 后边的代码 statement1 ; 如果表达式结果为假， 执行 : 后边的代码 statement2

运算符 优先级 ：
( ) > 算数运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符

示例

let num = 3 > 10 ? 'hello' : 'world';
console.log(num);

js的语句

语句：JavaScript 语句向浏览器发出的命令。语句的作用是告诉浏览器该做什么

if语句 if-else

1. 单一的if语句

if(expression){
    //expression 表达式 条件成立 ， 执行此处的代码
} 

示例：

 if(1 > 12){
    console.log('吃面条');
 }
if(10){
    console.log('吃面条');
 }
if (1 > 12 || 21) {
    console.log('吃面条');
}

2. if-else 语句：二选一

if(expression){
    // expression 表达式 条件成立 ， 执行此处的代码
}else{
    // 表达式 条件不成立 ， 执行else此处的代码
}

示例：

if(3 > 10){
    console.log('自驾游');
}else{
    console.log('11路');
}

3. if-else 嵌套使用 多选一

if(exp1){
    // exp1 表达式1 成立， 执行此处代码， 后边的代码不在执行
}else if(exp2){
    // exp1 表达式1 不成立，exp2 成立， 执行此处代码， 后边的代码不在执行
}else if(exp3){
    // exp1 和 exp2  不成立，exp3 成立， 执行此处代码， 后边的代码不在执行
}else{
    // 以上条件 exp1 和 exp2 ， exp3都不成立，执行else里边的代码
    // else 是可选项
}

示例：

var num = 'a';
if(num > 10){
    console.log('待遇');
}else if(num < 10){
    console.log('飞机');
}else if(num == 10){
    console.log('可乐');
}else{
    console.log('回家了');
} 

switch语句

语法结构

switch(expression){
    case value1:
        代码1;
        break;
    case value2:
        代码2;
        break;
    case value3:
        代码3;
        break;
    default:
        代码4;
}

结构解析

expression : 这是一个表达式，但是表达式经过计算得到的是具体的结果， 不能表示区间
case：就是具体的条件 ; case 后边的值value 就是表达式的结果之一，只要满足条件，则执行该case中的代码(如果没有break语句，则会执行后边所有的代码)
break: 语句 终止代码执行，跳出case语句
default: 类似else

示例:

var str = 'black';
 switch (str) {
     case 'red': console.log('红色');
         break;
     case 'black': console.log('黑色');
         break;
     case 'green': console.log('绿色');
         break;
     default:
         console.log('彩色');
 }

示例：

let score = 98;
switch(parseInt(score / 10)){
    case 10:console.log('王者'); break;
    case 9:console.log('星耀'); break;
    case 8:console.log('钻石'); break;
    case 7:console.log('黄金'); break;
    case 6:console.log('青铜'); break;
    default:console.log('黑铁')
}

for( ) 循环

语法结构

for (initialization; condition; final-expression){
    statement
}
initialization（表达式1）： 循环变量的初始值 
condition(表达式2) ： 循环的控制语句（循环的控制条件）
final-expression (表达式3): 用来更新循环变量，终止循环的条件
statement ： 循环体， 执行的代码块

示例

for(let i = 5; i < 6; i++){
   console.log(i);
}
// 5
for(let i = 1; i < 6; i += 2){
   console.log(i);
}
// 1 3 5

for循环的嵌套

for(let i = 0; i < n; i++){
    for(let j = 0;  j < m; j++){
      ...
    }
}

示例

for (let i = 0; i < 5; i++) {
    //  循环体 是一个新的循环
    for (let j = 0; j < 3; j++) {
        console.log('i =' ,i, '====', 'j=',j);
    }
}

while( ) 循环

语法结构

// 循环的初始值在while 语句的外部定义
// 表达式是循环的判断条件
while(表达式){
    // 循环体
    //  控制循环的终止条件在循环体内部， 在循环内部更新循环的初始值
}

条件不满足时，循环体一次都不执行

示例

let i = 1; // 定义循环的初始值
while(i < 6){ // 循环的判断条件
    console.log(i);
    i++;    // 更新循环初始值
}

do-while( ) 循环

语法结构

 // 循环的初始值在do-while 语句的外部定义
do{
    // 循环体
    //  控制循环的终止条件在循环体内部， 在循环内部更新循环的初始值
}while(表达式) // 表达式是循环的判断条件

不管条件是否满足，循环体至少执行一次

示例

let i = 10;
do{
    console.log(i);
    i += 2;
}while(i < 10)
// 10