JS字符串类型运算符分支

最新推荐文章于 2023-09-23 12:07:44 发布

IT YouZi

最新推荐文章于 2023-09-23 12:07:44 发布

阅读量178

点赞数

文章标签： javascript 前端

本文链接：https://blog.csdn.net/w8789760/article/details/123694241

版权

字符串类型

<script> 
 1.字符串类型 对于字符串类型来说自增或自减会自动进行类型转换
     例如： var str = '10'
           str++    //str=Number(str)+1  自动转换 从string转为number
           console.log(str);

2.NaN 对于转换不成功的string类型数据会变为NaN：
    例如：str = 'ab'
        str++ 
        console.log(str);
3.关于布尔类型:
   例如：var bol  = false   // 1为true 0为false
        bol++      
		number类型 非0和NaN就是true 自动进行转换
        console.log(bol);
4.关于null类型
    例如：var no = null
        no--       
		自动转换对应boolean类型 然后再从boolean转为number
        console.log(no);
5.关于undefined
   例如：var und
        und-- 
		undefined 转换不成功 NaN
        console.log(und);
6.关于Number类型
   例如：var num = 10
        console.log(num++);   //10
        console.log(num--);   //11
        console.log(++num);   //11
        console.log(--num);   //10
        console.log(num);   //10

7.复杂的自增 自减
   例如：var str1 = '123'
        Boolean布尔类型转换
        var bool = Boolean(str1)
        console.log(bool--);  //1
        console.log(--str1);  //122

        123ab
        var str2 = str1+'ab'
        console.log(str2--);  //NaN
        一元运算符只能和变量一起 不能出现其他的运算符
        var num01 = 10
        var bool01 = num01
        console.log(num01++);  //10
        console.log(num01--);  //11
        console.log(bool01++);  //10
        console.log(bool01);  //11
        console.log(Boolean(bool01));  //true
        var yes = 'null'   //字符串
        console.log(yes++);  //NaN
        console.log(Boolean(yes));  //false
        var obj = null
        var bool02 = Boolean(obj)
        console.log(obj--);  //0 obj-- === obj=obj-1
        console.log(++bool02);  //1
        console.log(obj);  //-1
        console.log(Boolean(obj));  //true

        将1进行减减后置 然后转换为boolean类型 再进行++ 最后打印这个number值
        var num03 = 1
        console.log(num03--);  //1
        var bool03 = Boolean(num03)
        console.log(bool03);  //false

        进行++ 进行-- 不管++是前置还是后置都是先转换
        var und = null
        console.log(und++);   //0        先进行了转换 number
        console.log(typeof und);  //null对应是object number类型
    
    </script>

比较运算符

比较运算符 == 返回的都是boolean类型，要么是true 要么是false

==比较是值

  例如：<script>
        console.log(null==undefined);//true
       console.log(typeof null);//object
       console.log(typeof undefined);//undefined
       console.log(typeof null==typeof undefined);//false
       console.log(Boolean(null)==Boolean(undefined));//true  
    </script>

关系运算符

用于进行比较的运算符称作为关系运算符. 关系运算符有: 小于(<)、大于(>)、小于等于(<=)、大于等于(>=)、相等() 、不等(!=)、全等(恒等)(=)、不全等(不恒等)(!==)

关系运算符的比较规则:
1, 数字和数字比较, 直接比较大小
2, 数字和字符串比较, 字符串转换为数字后再比较
3, 字符串和字符串比较, 进行字符的ASCII码值比较

比较注意事项:
1, 布尔值 ture=1, false=0
2, 只要不等于NaN, 就是true,其他有NaN的运算都为false
3, 如果要恒等, 则必须值和类型都要相等;

1.number比较  直接比较大小
2.number和boplean比较  将Boolean转换为number（0 ，1）
3.如果是number类型和字符串类型比较 如果字符串里面储存的是数值 对应的就是数值比较
4.如果对应的字符串里面储存的是字符串 会自动转为number类型 转不了就是NaN
5.字符串和字符串比较  比较的是ascii码  是一套固定的编码 每个字母都有一个对应的编码值（区分大小写）
6.NaN 特性 不能进行比较  返回结果false
7.==比较值  ===比较值的同时还要比较地址

asccii码百度查 a 97 A 65 0 48

 例如：
     <script>
     console.log('a'>'b');//false
     console.log('A'>'B');//false
     console.log('A'=='a');//false
     console.log('a'>1); // 结果是false  字符串转不了

       console.log('123'>12); //true
       console.log(5>4);//true
       //number 自动转换 true对应1   number类型转布尔类型 true
       console.log(true>3);//false
       console.log(true>3);//false
       console.log(true==1);//自动转换booleand也 
    </script>

>= <= 只要满足其中一条

   console.log(true>=1);//true
   console.log(true<=1);//true
   console.log(true<=2);//true

！= 不等于

   console.log(2!=3);//true
   console.log(3!=3);//false

= 赋值

   var b = 20
   var a = b++
   console.log(a);20
   var c = ++b
   console.log(c);22

NaN 特性不能进行比较返回结果false

   var na = Number('ABC')
   console.log(NaN==Number('ABC'));
   console.log(na==NaN);
   console.log(na==na);

恒等===比较值还比较地址 == ==比较值

   var a ='123'//字符串
   var b = 123//number
   console.log(a==b)//true
   console.log(a===b);//false

与同true则为true 其他都是false

与只有当所有有=条件都为true的时候返回才是true

逻辑运算符

1.&&符号

&断路与（效率低不用）

1. &&

例如： console.log(‘A’<‘a’&& 2>1);//true

console.log(‘A’<‘a’&& 2<1);//false

2.或 || 一个为true就是true 断路或 |

例如： console.log(‘A’<‘a’|| 2<1);//true

console.log(‘A’>‘a’|| 2<1);//false

3.非！取反 true变false false变成true

例如 console.log(!(‘A’>‘a’));//true 取反

console.log(!(‘A’<‘a’));//false 取反

undefined转number 为NaN

undefined值不需要转换的为！=

例如：console.log(number1!=number2 && number1<number2);//false

console.log(number1!=number2 || number1<number2);//true

console.log(number1<number2 || !(number1<number2));//true

number非0和NaN 就是true

三元运算符三目运算符

1. 布尔类型表达式? true的结果： false的结果

表达式的概念:
由运算符和操作数（变量或常量）组成的式子
算术运算符组成的式子叫算术表达式，如：2+3；
关系运算符组成的式子叫关系表达式或者条件表达式，如：a>5；
逻辑运算符组成的式子叫做逻辑表达式，如：a&&b

<script>
        console.log(!0?10:20);
        console.log(1!=1?10:20);
        var number = 1!=1?0:null
        console.log(number?'a':'b');//b
        var number2 = 'a'>'B'?12+'3':45/2
        console.log(number2);//123
        console.log(typeof number2);//string    
    </script>

赋值运算符:

赋值运算符用等于号(=)表示，就是把右边的值赋给左边的变量。
复合赋值运算符通过 x=的形式表示，x 表示算术运算符。
如: +=, -=, *=, /=, %=等

逻辑分支

浏览器解析的结构为顺序结构从上到下从左到右

分支结构多个分支进行其中一个

if表达式（布尔类型表达式）{
// 第一分支
// }else{
//不满足进入的分支
// }
//如果我有10块钱，我就坐公交，如果没有我就步行

 例如：
<script>
   var myMoney = 20
   if(myMoney>=10){
       console.log('坐公交');
   }else{
       console.log('步行');
   }
    </script>

多个分支

 例如：<script>
        if(myMoney==20){//一旦进行其中一个分支就不会再进行下一个
            console.log('上网'); .............弹出
        }else if(myMoney>200){
            console.log('唱ktv');
        }else if(myMoney>1000){
            console.log('买个手机');
        }else{
            console.log('搬砖');
        }
    </script>

简写化
分支块里面执行的语句只有一句就可以省略对应的{}

 <script>
     if(myMoney)
        console.log('有钱任性');//弹出
     else{
        console.log('没钱搬砖');
        console.log('hello world');
        } 
    </script>

循环结构多个循环

条件会找先满足的if块如果都不满足就进入else块

保持缩进代码规范方便他人阅读

不建议不写{} 代码不够规范

分支语句嵌套无限嵌套的但是嵌套的越多，它的时间复杂度就越大（执行的越慢)

    var t1 = 10=='10'   //true
    var t2 = 20!=='20'?0:1   //0  false
    var t3 = 30+'10'==3010?null:10   //null false

 <script>
           if(t1){
            console.log("进入第一个if块");
            if(t2){
                console.log("进入第二个if块");
                if(t3){
                    console.log("进入第三个if块");
                }else{
                    console.log("进入第三个else块");
                }
            }else{
                console.log("进入第二个else块");
            }
        }else{
            console.log("进入第一个else块");
        }
    </script>

程序的三大流程控制：

我们的计算机在执行一个程序的时候，最基本的方式是一条语句接一条语句的执行。但不可能所有的问题都能用顺序执行方式就能解决，总会有一些跳转。
采用结构化的程序设计，可以大大提高开发程序的速度、提高程序的可读性、程序运行的速度和效率。
结构化程序是由若干个基本结构组合而成，每一个结构可以包含若干条语句和其它基本结构。共有三种基本结构:

顺序：从上朝下执行的代码就是顺序

分支(选择)：根据不同的情况，执行对应代码

循环：重复做一件事情

IF单分支

if条件判断语句的写法:
if (表达式){
执行语句
}
当括号内的表达式结果成立(为true时)，则执行大括号内的语句，否则不执行。

注意：

if后面的()不能省略。
一条执行语句可以省略{}, 多条时不能省略{}, 建议不管是一条还是多条都写上{}
IF双分支语句
if双分支语句的写法:
if(表达式){
执行语句1
}
else{
执行语句2
}
当if括号内的表达式结果成立，进入执行语句1，否则进入执行语句2;
IF多分支语句

if多分支语句的写法:
if(表达式){
执行语句1
}
else if(表达式2){
执行语句2
}
else if(表达式3){
执行语句3
}
else{
执行语句n
}
从上往下，满足哪个条件就执行其相对应的语句，都不满足时，执行最后的else的语句，只能进入其中之一。
IF的嵌套

将整个if语句块插入另一个if语句块中
if (表达式1) {
if (表达式2) {
if (表达式3){
语句;
} else{
语句;
}
} else{
语句;
}
}
注意: 嵌套if时，内层的每一对if-else代码要缩进且对齐；编写代码时，else要与最近的if配对

Switch语句的写法:

属于分支结果

if里面的表达式Boolean表达式

switch为值表达式有确定的值

switch case 一起连用

switch(表达式) {
case 常量1: 语句; break;
case 常量2: 语句; break;
…
case 常量n: 语句; break;
default:语句; break;
}

当不存在break的时候他会从匹配的选项走到底

表达式的结果等于哪个case的常量，则执行其后的语句，执行完break就跳出switch结构，都不满足则执行default的语句。
break的作用：是跳出switch结构，如果没有break，则继续执行下面分支的的语句（而不进行判断）。
注意case穿透，要加break
switch的应用场景: 表达式为固定值, 不能判断范围