JS-基础-运算

目录

• 简单运算符
• ++ 与 --
• 比较运算符
• 逻辑运算符

运算符+，-，*，/，()，%，++，--

var a = 1,
    b = 2,
    d = 3;
var c = (a+b) * d;
/* 
 * 1.声明变量c
 * 2.()优先级高，先计算(a+b)
 * 3.将计算的(a+b)的值与d的值相乘
 * 4.将以上计算的结果赋值给a
 */

• +

+ 在JS中有两种不同的用途

1. 数学运算
2. 字符串拼接

- 任何数据类型的值 + 字符串，结果都是字符串

    var c = 's' + 1 + 1;

   var c = 1 + 1 + 's' + (1 + 1);
   /*
    * 按照从左往右的运算顺序：
    *   1.(1 + 1) = 2
    *   2. 1 + 1 = 2
    *   3. 2 + 's' = '2s'
    *   4. '2s' + 2 = '2s2'
    */

• /

var c = 0 / 0; // c = NaN:Not a Number -> NaN属于数字类型

var a = 1 / 0; // a = Infinity -> 属于数字类型
var b = -1 / 0; // b = -Infinity -> 属于数字类型

var a = 1 / 2; // a = 0.5

• % :取余运算符

var a = 4 % 3; //a = 1,4除以3的余数
var b = 5.5 % 2; // b = 1.5
var c = -4 % 2; // -0

递增:++递减:--

• 后置递增：a++,先返回a值，返回值之后a再加一
• 前置递增：++a,会把a值加一后返回
• 递减同理

var a = 1,
    c;
c = a++ + ++a; // c = 4, a = 3
/*
 * 1. a++返回1
 * 2. 1 + (2 + 1)
 * 3. 把4赋值给c
*/

var a = 5,
    c;
c = --a + a++; // a = 5,c = 8
/*
 * 1. --a:5-1,返回4
 * 2. a++:返回4
 * c = 4 + 4
*/

++ 与 +，-- 与 -

1. ++ 和 -- 不同于普通的+1和-1操作。操作符的位置决定了不同的行为
2. a = 4; a++: ++运算符后置，意味着先返回a的值4，之后a=a+1。a--同理。
3. a = 4; ++a: ++运算符前置，意味着返回a = a+1的值5
4. ++ ， --存在的意义：首先是a = a +1或a = a - 1的简便写法，最重要的是有了除运算外的语义。

比较运算符

• > , >= , < , <=

需要注意两点：

1. Number 与 String比较，将String转化成Number再比较
2. String 与String比较，依次从左向右比较每个字符所对应的的ASCII码

'4' > 1;//true
'2.1' > '11';//true 依次比较ASCII码：字符2ASCII > 字符1ASCII，为true则直接返回true

true > false; // true
null >= 0; // true

可以发现不等比较存在着强制数据类型转换，背后的规律也可基本摸清：当两个值进行比较时，如果它俩的数据类型不是Number（两个都是string类型除外），那么就会尽可能的把它俩都转化为数字类型(Number)。当然也有没办法转化为具体数字的情况: 例如 undefined就不能转化数字，Number(undefined) ->NaN，那么NaN和任何值进行不等比较都是false
例如：

• ‘4’ > 1; 把’4’转化为Number 4
• true > false; 把 true 转化Number(true) ->1, false 转化Number(false) -> 0。1 > 0 自然为true
• null >= 0; Number(null) -> 0 ,0>=0 为真

ASCII表

• == , ===

  1. == 是不看数据类型的，也就是说表面的值相等即可。

     == 不会查看数据类型是否相等的原因是：

     1. == 会产生隐式数据类型转换。所以是两个数据类型不同的值进行比较也有可能相等。
     2. ==会把两个比较的值，转化成一个数据类型，再比较是否相等

     1 == '1';//true
     /*
     * 1. 字符串'1' 转化为Number类型的 1
     * 2. 1 == 1 为真
     */
     

     其实通过 == 背后的设计原则

  2. === 要求更严格，要求值和数据类型都相等

     全等要求值和数据类型都相等的原因：

     1. ===不会进行隐式数据类型的转化，也就是说当两个值的数据类型不同时，===直接返回false。
     2. 只有当两个比较变量的数据类型相同时，才去比较其值是否相同

      1 === '1'; // false
      //原因是不会对'1'进行隐式数据类型转化
     

== 与 ===总结：

• 原始值与引用值：两个原始值比较比较简单，但是两个引用值进行比较时就变得复杂

• 应用场景：

  • 当严格要求两个变量完全相等时（数据类型与内容都相等），使用=== 判断会更加方便
  • 如果两个变量不要求严格意义上的相等，就可以用== 来判断
  • 由于全等 === 不进行数据类型转换的原因，更推荐使用===，因为 == 的转换中的特例数不胜数，很容易记混。

相等性判断的规则总结

! NaN == NaN 为false。可以看出NaN与 包括自己在内的任何值都不相等。对NaN的分析见此笔记

逻辑运算符

注意： undefined , null , NaN , ‘’ , 0 , false 这些值一定为假
背后的原因是：在逻辑比较和判断的时候，undefined , null , NaN , ‘’ , 0 , false 这些值，都会Number()转换。Number(undefined)->NaN, Number(null) ->0 , Number(’’)->0。可以看出这些值不是被转换为了0，就是NaN。

• &&

  遇到真，就继续往后判断
  遇到假，就直接将假值返回
  原理分析：与运算的目的是判断两个条件是否都成立(为true)。

  • 所以根据这个特性就可以知道为什么 && 遇到真还要继续往后判断。A&&B，光A为true不行，还要看一下后面的B是否为true，如果B为true那么自然可以把B作为整个与运算的结果返回。
  • 也可以知道为什么遇到假，就直接将假值返回。因为 A&&B，按照解析顺序，A若为false，无论B是真是假。与运算的最终结果都是false。那就不用再麻烦检查B的真假了，直接返回A <=> false

  0 && 1 //0,遇到0其值为假，直接返回假值->0
  1 && 1 //1
  1 && 0 // 0,遇到1值为真，继续向后判断，0值为假，返回假值0
  1 && 1 //1
  

• ||

  遇到真，就之间返回这个真值
  遇到假，就继续往后判断
  原理分析：或运算是判断两个条件是否有一个为true的

  • 遇到真，就之间返回这个真值的原因：A || B ，A为true，符合了 || 的目的，那就不用再麻烦看B是真是假，返回A <=> true
    遇到假，就继续往后判断的原因：A || B，A为false，那就要看一看B的真假，如果B是真则整个结果为真，B为假则整个结果为假。返回B <=> true/false

  1 || 0 // 1 遇到1，值为真，直接返回真值->1
  1 || 1 // 1
  0 || 0 //0
  0 || 1 //1 遇到0，值为假，继续向后判断，1为真，直接返回这个真值1
  

• ！

var a = !1; // false
a = !a; //a= a的非值

分支语句

• if语句

  • if结构:对于每一个if语句都要判断一下表达式是否满足条件

  if(a > 0){
      ...
  }
  if(b >0){
      ...
  }
  ...
  

  • if-else结构:适用于有明确的互斥条件的逻辑，遇到一个符合调的分支后，就不检查之后的if分支了

  if(a > 1){
      ...
  }else if( a < 0 && a > -1){
      ...
  }else if(a <= -1){
      ...
  }else{
      ...
  }
  

• switch-case 语句

switch(表达式){
    case 表达式1:
        代码块;
        break;
    case 表达式2:
        代码块;
        break;
        ...
    default:
        代码块;
       
 }

if与switch的选择：

1. 当要判断的变量是否是一个准确的值的时候，switch结构更适合。
2. 当要判断变量出于什么范围的时候，if结构更适合