3-1 if else 语句

  1. // 条件为true, 执行if后面的括号代码, 否则执行 else 后面括号代码
  2. if(条件) {
  3.     // todo
  4. }else{
  5.     // todo
  6. }
  8. // 多重判断
  9. if(){
  11. } else if() {
  13. } else {
  15. }
  1. var count = -10;
  2.     if (count>0) {
  3.         console.log(count);
  4.     } else {
  5.         console.log('count 小于或等于 0');
  6.     }
  9.     var sex = prompt();  
  10.     if (sex === '男') {
  11.         alert('这是个男人');
  12.     } else if(sex === '女') {
  13.         alert('这是个女人');
  14.     } else {
  15.         alert('从泰国回来的');
  16.     }

3-2 类型转换

3-2-1隐式转换：运算的过程中, 类型自动进行转换, 称之为隐式类型转换

  1. var a = 2;
  2.     var b = 3;
  4.     if (a+b) {
  5.         console.log('a+b的值大于0');
  6.     } else {
  7.         console.log('a+b的值小于或等于0');
  8.     }

3-2-2 显式转换-其他类型转布尔类型

  • 转换方法 Boolean(变量名) 和 （!!变量名）
  • 转换结果为 true 或者 false
  • 字符串转布尔
  • 数字转布尔
  • undefined 转布尔
  • null 转布尔

  • 对象转布尔

    1. 总结:
    2. - 转换方法 Boolean(变量)或者 !!变量
    3. - 意思上若包含'无','空'的时候转为false,其他为true
    4. - 对象全部为true
    1. //转换方法 Boolean(变量名) 和 （!!变量名）
    2. var a = 5;
    3. var boo1 = Boolean(a);
    4. console.log(boo1);
    6. var boo2 = !!a;
    7. console.log(boo2);
    9. console.log('字符串转布尔-------');
    10. var str1 = 'asdfasdf';
    11. var str2 = '';
    12. var str3 = ' ';
    14. console.log(!!str1); // true
    15. console.log(!!str2); // false
    16. console.log(!!str3); // true
    18. console.log('数字转布尔------');
    19. var num1 = 2323; 
    20. var num2 = 0.8; 
    21. var num3 = 0;  
    22. var num4 = NaN; 
    24. console.log(!!num1); // true
    25. console.log(!!num2); // true
    26. console.log(!!num3); // false
    27. console.log(!!num4); // false
    29. console.log('undefined转布尔------');
    30. var x;
    31. var obj = {a:2,b:3}
    32. var a = null
    33. console.log(!!x);//false
    34. console.log(!!obj)//true
    35. console.log(!!a) //false

    3-2-3 显式转换-其他类型转数字类型

    ```

    • 转换方法 Number(变量);
    • 转换结果: 数字, 0, NaN
    • 字符串转数字
    • 布尔转数字
    • undefined 转数字
    • null 转数字
    • 对象转数字

总结: (1)数字的转换结果有三种: 数字, 0 , NaN (2)其他类型转数字类型的时候, 就拿这三种结果区推断, 会是那一个

  1. ```
  2.  // 其他类型转数字类型
  3.     console.log('字符串转数字');
  4.     var str1 = 'asdfasdf';
  5.     var str2 = '';
  6.     var str3 = ' ';
  7.     var str4 = '666';
  9.     console.log(Number(str1)); // NaN
  10.     console.log(Number(str2)); // 0
  11.     console.log(Number(str3)); //0
  12.     console.log(Number(str4)); // 666
  14.     console.log('布尔类型转数字----=');
  15.     var boo1 = true;
  16.     var boo2 = false;
  17.     console.log(Number(boo1));  // 1
  18.     console.log(Number(boo2));  // 0
  20.     console.log(boo1+boo2);  // 1
  22.     console.log('undefined转数字-----');
  23.     var y = undefined;
  24.     console.log(Number(y)); //NaN
  26.     console.log('null转数字-----');
  27.     var z = null;
  28.     console.log(Number(z));  //0
  30.     console.log('对象转数字-----');
  31.     var obj = {a:2, b:3}
  32.     console.log(Number(obj)); // NaN

3-2-4 显式转换-其他数据类型转字符串类型

  1. (1)有三种方式
  2.   var num = 20;
  3.   - num + ''; // 常用
  4.   - String(num);
  5.   - num.toString();
  6. (2)转换规则: 把变量直接添加双引号,变成字符串
  1. var num = 100;
  2.     var obj = {a:2,b:3};
  3.     var boo = true;
  5.     console.log(num+'');  //"100"
  6.     console.log(String(obj));     //'[object Object]'
  7.     console.log(boo.toString());  //"ture"

3-3 算数运算

3-3-1 加减乘除 + - * / %

  1. // 算术运算符
  2.     var a = 5;
  3.     var b = 3;
  5.     console.log(a+b); // 8
  6.     console.log(a-b); // 2
  7.     console.log(a*b); // 15
  8.     console.log(a/b); // 1.66666
  9.     console.log(a%b); // 2

3-3-2 两个变量相加规则

  1. (1)两个数字相加,直接相加
  2. (2)有一个加数是字符串时,其它变量都转换成字符串,然后进行拼接 
  3. (3)NaN,null,undefined + 数字
  1. var a = 100;
  2.     var str = 'hu';
  3.     var b = '5';
  5.     console.log(a+str);  // 100hu
  6.     console.log(b + null); // 5null
  8.     console.log(a+null);  // 100
  9.     console.log(a+NaN); // NaN
  10.     var c;
  11.     console.log(a+c); // NaN
  1. (4)两个小数相加,有可能出现很多小数 
  2. var a = 0.1;
  3.     var b = 0.2;
  4.     console.log((a*10+b*10)/10);

3-4 关系运算符(比较运算符)

  1. == 等于
  2. === 恒等于,全等于
  3. == 和 === 的区别
    • == 不同类型的变量进行比较, 不比较变量类型, 类型转换后, 只比较值, 值相等, 则为true, 否则为false
    • === 先比较类型, 若类型不同,结果为false, 若类型相同,再比较值, 值相同, 则为true

  4. 建议尽量使用 ===

    1. var count1 = 100;
    2.  var count2 = '100';
    4.  console.log(count1 == count2);  // 只比较值是否相等
    5.  console.log(count1 === count2);  // 1.先比较类型, 若类型不同,结果为false, 若类型相同,再比较值, 值相同, 则为true

    3-5 逻辑运算符

    3-5-1 逻辑非!, 取反即可

    1. var boo1 = true;
    2.  console.log(!boo1); // false
    4.  var boo2 = false;
    5.  console.log(!boo2); // true
    7.  var count = 100;
    8.  console.log(!count);   // false
    10.  var aa = NaN;
    11.  console.log(!aa);  // true;
    13.  var str = 'asdfsadfsad';
    14.  console.log(!str);  // false
    15.  console.log(!!str);  // true

    3-5-2 逻辑与&&: 中文里并且的意思

    1. (1)对于布尔类型: 两者为true,结果为true
    2. (2)对于其他类型: 前者为true取后者,前者为false取前者
    3. (3)逻辑与的妙用: 
    4. var obj = null;
    5. console.log(obj.a); // 报错
    6. console.log(obj && obj.a); // 防止报错
    1. var boo1 = true;
    2.  var boo2 = false;
    3.  var boo3 = true;
    4.  var boo4 = false;
    6.  console.log(boo1 && boo3);  // 两者为true,结果为true, 其他情况皆为false
    7.  console.log(boo1 && boo2);
    8.  console.log(boo1 && boo4);
    9.  console.log(boo2 && boo3);
    10.  console.log(boo2 && boo4);
    11.  console.log(boo3 && boo4);
    1. var count1 = 0;
    2.  var count2 = 200;
    3.  var count3 = 100;
    5.  console.log(count1 && count2);  // 0
    6.  console.log(count2 && count3);  //100
    8.  // 逻辑与的妙用
    9.  var obj = null;
    10.  // console.log(obj.a); 
    11.  obj && obj.a;

    3-5-3 逻辑或|| : 中文里的或者的意思

    1. (1)对于布尔类型: 一个为true,结果为true
    2. (2)对于其他类型:前者为true取前者, 前者为false取后者
    1. var boo1 = true;
    2.  var boo2 = false;
    3.  var boo3 = true;
    4.  var boo4 = false;
    6.  console.log(boo1 || boo3); // true
    7.  console.log(boo1 || boo2); // true
    8.  console.log(boo1 || boo4); //true
    9.  console.log(boo2 || boo3); //true
    10.  console.log(boo2 || boo4); //false
    11.  console.log(boo3 || boo4); // true
    1. var num1 = 100;
    2.  var str = '';
    3.  var aa = null;
    4.  var obj = {};
    6.  console.log(num1 || str);  // 100
    7.  console.log(obj || num1);  // obj
    8.  console.log(aa || str);  //""

    3-5-4 总结: 逻辑与&& 和 逻辑或 ||, 只需要记住两句话

    1. 逻辑与: 前者为true取后者,前者为false取前者
    2. 逻辑或: 前者为true取前者, 前者为false取后者

    3-6 一元运算

    3-6-1 自加(自减)

    ``` i++ 运算结束后, i自身加1, 简称先运算后+1

++i i先自身+1, 再运算; 先加1后运算

自加或自减, 是在变量运算过程发生, 不需要等到这个句子运行结束;

  1. ```
  2. var i = 10;
  3.    var b = 5 + i++;
  4.    console.log('b=',b);  // 15
  5.    console.log('i=',i);  // 11
  8. var m = 10;
  9.     var b = 5 + ++m;
  10.     console.log('b=',b);  // 16
  11.     console.log('m=',m);  // 11
  1. var i = 16;
  2.     var j = 20; 
  3.     var b = j + i++ + ++i; 
  4.     console.log(b);  // 54
  1.  var i = 1;
  2.     var j = 1;
  3.     var a = 10;
  4.     var b = a + i++;  
  5.    var c = b + ++i + i++ + ++j;      // b=11, c=19

3-6-2 复合赋值 +=, -=,*=, /=, %=

  1. var sum = 10;
  2.     sum += 5; // 等同于sum = sum+5; 可以看做是一种简写
  3. console.log(sum);  //15

3-7 运算符优先级

  1. () => 自加和自减 => 算术运算 => 关系运算(比较运算) => 逻辑运算 => 赋值运算
  2. 同级运算,从左到右执行
  1.  var i = 1;
  2.     var j = 1;
  4.     // () => 自加和自减 => 算术运算 => 关系运算(比较运算) => 逻辑运算 => 赋值运算
  5.     var sum = 20 + i++ + 'abc' || 123 - ++i + ++j + ++j + '123' == 123 * 2/4;   // '21abc'