错误

语法错误

所有语句都不会执行。

通用错误

1.错误语句之前的语句会执行，之后的不会执行。中断执行。
2.不同脚本块相互独立，错误不会互相影响。
image.png
image.png
代码块之间互不影响

运算符

运算步骤
image.png
赋值语句运算=，在最后再运行

+、-（加/减操作符）

  1. // + - * 数学运算
  2. var a = 2,
  3.       b = 5,
  4.       c,
  5.       d,
  7. c = a + b;
  8. d = b - a;
  9. console.log(c); // 7
  10. console.log(d); // 3
  12. // + 字符串拼接
  13. // 任何值 + 字符串 都是字符串
  14. c = 1 + 'str';          // '1str'
  15. c = 'str1' + 'str2';    // 'str1str2'
  16. c = true + 'str';       // 'truestr'
  17. c = undefined + 'str';  // 'undefinedstr'
  18. c = null + 'str';       // 'nullstr'
  19. c = NaN + 'str';        // 'NaNstr'  NaN -> Number数据类型 非数是什么类型 是数字类型
  20. c = 'str' + (1 + 1);    // 'str2' ()改变运算顺序

*、/（乘/除法运算符）

  1. // *、/ 数学运算
  2. var a = 5,
  3.       b = 2,
  4.       c,
  5.     d;
  7. d = a * b;      // 10
  8. d = a * NaN     // NaN
  9. d = a * 'str'   // NaN
  10. c = a / b;      // 2.5
  11. c = 0 / 0;      // NaN
  12. c = 'a' / 'b';  // NaN
  13. c = NaN / 5;    // NaN
  14. c = NaN / NaN;  // NaN
  15. c = 5 / NaN;    // NaN
  16. c = 1 / 0;      // Infinity -> Number数据类型 正无穷
  17. c = -1 / 0;     // -Infinity -> Number数据类型 负无穷

%（取模/取余运算符）

  1. // % 模运算
  2. var a = 5,
  3.       b = 2,
  4.       c;
  6. c = a % b; // 1
  7. c = 4 % 7; // 4
  8. c = 0 % 6; // 0

++、—（递增/递减操作符）

++（—）将其操作数加1（减1）并返回一个值。
如使用后置自增（自减），操作符在操作数后x++（x—），操作数将在自增前返回。先返回，再加1
如使用前置自增（自减），操作符在操作数后++x（—x），操作数将先自增后返回。先加1，再返回

  1. var a = 1;
  2. console.log(a++); // 1
  3. console.log(a);   // 2
  5. var b = 2;
  6. console.log(++b); // 3
  7. console.log(b);   // 3
  9. var c = 3;
  10. console.log(c--); // 3
  11. console.log(c);   // 2
  13. var d = 4;
  14. console.log(--d); // 3
  15. console.log(d);   // 3

练习题

  1. var a = 5,
  2.       b;
  4. /**
  5.  * 1. b = a + 1 
  6.  * 2. a++                 a -> 6
  7.  */
  8. b = a++ + 1;
  9. console.log(b, a); // 6 6
  11. //-------------------------------------------------------------------------------
  13. /**
  14.  * 1. ++a                  a -> 6
  15.  * 2. b = a + 1;
  16.  */
  17. b = ++a + 1;
  18. console.log(b, a);  // 7 6 
  20. //--------------------------------------------------------------------------------
  22. /**
  23.  * 1. a--                 a -> 5
  24.  * 2. 5 + --a            a -> 4
  25.  * 2. --a                 a -> 3
  26.  * 3. b = 5 + 3
  27.  */
  28. b = a-- + --a;
  29. console.log(b, a);  // 8 3
  31. //------------------------------------------------------------------------------
  33. /**
  34.  * 1.--a                    a -> 4
  35.  * 2. 4 + --a            
  36.  * 3. --a                 a -> 3
  37.  * 4. b = 4 + 3
  38.  */
  39. b = --a + --a;
  40. console.log(b, a); // 7 3
  42. //-----------------------------------------------------------------------------
  44. /**
  45.  * 1.    --a                    a -> 4
  46.  * 2. 4 + a++        
  47.  * 3. b = 4 + 4                
  48.  * 4. a++                    a -> 5
  49.  */
  50. b = --a + a++;
  51. console.log(b, a); // 8 5

>、<、>=、<=、==、===、!=、!==(比较运算符)

返回值为布尔值。
如果操作数都是数值，则执行数值比较。
如果操作数都是字符串，则逐个比较字符串中对应字符的编码。
如果有任一操作数是数值，则将另一个操作数转换为数值，执行数值比较。
如果有任一操作数是布尔值，则将其转换为数值再执行比较。

  1. // 1. 两个操作数都是number类型
  2. var bool = 1 > 10;               // false        
  3. var bool = 20 < 100;           // true
  4. var bool = 10 === 10;          // true
  5. var bool = 10 == 10;           // true
  7. // 2. 两个操作数都是string类型
  8. var bool = 'a' > 'b';         // false   a对应的ASCII码 < b对应的ASCII码
  9. var bool = 'abc' > 'aac'; // true            按顺序逐个比较字符的ASCII码 两个字符串比较 不会转换成number再比较
  10. '4.5'>'11' //true 
  12. // 3. 任一操作数是number类型
  13. var bool = 1 == '1';        // true  str -> Number(str)
  14. var bool = 1 !== '1';          // true   全等比较时，不转换操作数，值和数据类型都相同才返回true
  16. // 4. 任一操作数是boolean类型
  17. var bool = true > 0;     // true  boolean -> Number(true) -> 1
  18. var bool = false == 0;     // true     boolean -> Number(false) -> 0
  19. var bool = true > '12';  // false boolean -> Number(true) -> 1  str -> Number('12') -> 12
  21. // NaN与包括自己在内任何东西都不相等
  22. var bool = NaN == NaN; // false

image.png
image.png

&&、||、!(逻辑操作符)

为假的值


假：undefined、null、NaN、’’、0、false。
除以上之外都为真。

&&（逻辑与）

逻辑与操作符真值表：

第一个操作数
 第二个操作数
 结果
true
 true
 true
true
 false
 false
false
 true
 false
false
 false
 false

遇到真就往后走。
遇到假或者走到最后就返回当前值。
要么返回最后一个，要么返回第一个遇到的假值

  1. true && 1;                  // 1
  2. '123' && false;         // false
  3. undefined && 'str'; // undefined
  4. 'str' && NaN;             // NaN
  5. '' && null;                 // ''
  6. 0 && 5;                         // 0

||（逻辑或）


逻辑或操作符真值表：

第一个操作数
 第二个操作数
 结果
true
 true
 true
true
 false
 true
false
 true
 true
false
 false
 false

遇到假就往后走。
遇到真或者走到最后就返回当前值。
要么返回最后一个，要么返回第一个遇到的真值
常用来设置默认值。

  1. true || 1;                  // true
  2. '123' || false;         // '123'
  3. undefined || 'str'; // 'str'
  4. 'str' || NaN;             // 'str'
  5. '' || null;                 // null
  6. 0 || 5;                         // 5
  1. var name=''
  2. console.log(name||'未找到数据')

image.png
默认值是未找到数据,相当于if else

短路原则

短路原则：因为只要有一个为假，并集就是假，之后的就不走了，所以就走到假的那块，并返回，返回所走到的截止的数据本身，不返回前一个
把数据走一遍，走到哪就不走了，就返回它
或者同理

！（逻辑非）

逻辑非操作符始终返回布尔值，无论应用到的是什么数据类型。
逻辑非操作符首先将操作符转换为布尔值，然后再对其取反。
!!(value) === Boolean(value)

  1. !'a';                    // false
  2. !1;                        // false
  3. !NaN;         // true
  5. !!null;             // false
  6. !!undefined;     // false
  7. !!NaN;           // false
  8. !!'';                // false
  9. !!false;             // false
  10. !!0;                    // false

交换两个变量的值

  1. // 交换两个变量的值
  2. // 借助临时变量
  3. var a = 2,
  4.       b = 3,
  5.       temp;
  7. temp = a;
  8. a = b;
  9. b = temp;
  11. //------------------------------------------------------------------------------------------
  13. // 不借助临时变量
  14. var a = 2,
  15.       b = 3;
  17. a = a + b;
  18. b = a - b;
  19. a = a - b;

优先级

判断分支

if…else语句


语法
if (condition) statement1 else statement2
条件（condition）可以是任何表达式，ECMAScript会自动调用Boolean()函数将这个表达式的值转换为布尔值。
如果条件求值为true，则执行语句statement1；
如果条件求值为false，则执行语句statement2。
常用于条件为一个范围。

  1. // 查询成绩等级
  2. var score = 63;
  3. if (score >= 90) {
  4.   console.log('您的成绩等级为A');
  5. }
  6. if (score >= 80 && score < 90) {
  7.   console.log('您的成绩等级为B');
  8. }
  9. if (score >= 70 && score < 80) {
  10.   console.log('您的成绩等级为C');
  11. }
  12. if (score >= 60 && score < 70) {
  13.   console.log('您的成绩等级为D');
  14. }
  15. if (score < 60) {
  16.   console.log('您的成绩不及格');
  17. }
  19. if (score >= 90) {
  20.   console.log('您的成绩等级为A');
  21. } else if (score >= 80 && score < 90) {
  22.   console.log('您的成绩等级为B');
  23. } else if (score >= 70 && score < 80) {
  24.   console.log('您的成绩等级为C');
  25. } else if (score >= 60 && score < 70) {
  26.   console.log('您的成绩等级为D');
  27. } else if (score >=0 && score < 60) {
  28.   console.log('您的成绩不及格');
  29. } else {
  30.   console.log('您的成绩出现异常');
  31. }

条件：互斥性
image.png
完备性，所有情况都有包含，都有处理

switch条件语句


语法

switch (expression) {
case: value1:
statement1
break;
case: value2:
statement2
break;
case: value3:
statement3
break;
default:
statement4
}

每个case（条件/分支）相当于：如果表达式等于后面的值，则执行下面的语句。
break关键字会导致代码执行跳出switch语句。
如果没有break，则代码会继续匹配下一个条件。
default关键字用于在任何条件都没有满足时指定默认执行的语句（相当于else语句）。
常用于条件为定值时。

break不是专门用于switch的，是用来断开循环的，中断

  1. var city = window.prompt('请输入您所在的地区');
  3. switch (city) {
  4.   case '北京':
  5.     console.log('15K');
  6.     break; // 中止当前循环
  7.   case '上海':
  8.     console.log('13K');
  9.     break;
  10.   case '深圳':
  11.     console.log('12K');
  12.     break;
  13.   case '广州':
  14.     console.log('11K');
  15.     break;
  16.   default:
  17.     console.log('9K');
  18. }
  20. switch (true) {
  21.     //填false只走第一个
  22.   case score >= 90 && score <= 100:
  23.     console.log('您的成绩等级为A');
  24.     break;
  25.   case score >= 80 && score < 90:
  26.     console.log('您的成绩等级为B');
  27.     break;
  28.   case score >= 70 && score < 80:
  29.     console.log('您的成绩等级为C');
  30.     break;
  31.   case score >= 60 && score < 70:
  32.     console.log('您的成绩等级为D');
  33.     break;
  34.   case score >= 0 && score < 60:
  35.     console.log('您的成绩不及格');
  36.     break;
  37.   default:
  38.     console.log('您的成绩出现异常');
  39. }

当判断条件是值范围的时候用if，当是多个定值时用switch，switch看着直观

注释

单行注释

  1. // var a = 5;

块注释

  1. /**
  2.  * 逻辑运算
  3.  * 假：undefined、null、NaN、''、0、false
  4.  * 除以上之外都为真
  5.  */

作业

输入星期几，上午下午，出来计划？

  1. var day = window.prompt('请填写星期几');
  2. var time = window.prompt('选择上午或下午');
  3. var days = ['星期一', '星期二', '星期三', '星期四', '星期五', '星期六', '星期日'];
  4. var times = ['上午', '下午'];
  5. var plans = ['计划1', '计划2', '计划3', '计划4',
  6.   '计划5', '计划6', '计划7', '计划8',
  7.   '计划9', '计划10', '计划11', '计划12',
  8.   '计划13', '计划14'];
  9. switch (day) {
  10.   case days[0]:
  11.     if (time == times[0]) {
  12.       console.log(days[0] + times[0] + plans[0]);
  13.     } else if (time == times[1]) {
  14.       console.log(days[0] + times[1] + plans[1]);
  15.     } else {
  16.       console.log('输入格式错误');
  17.     }
  18.     break;
  19.   case days[1]:
  20.     if (time == times[0]) {
  21.       console.log(days[1] + times[0] + plans[2]);
  22.     } else if (time == times[1]) {
  23.       console.log(days[1] + times[1] + plans[3]);
  24.     } else {
  25.       console.log('输入格式错误');
  26.     }
  27.     break;
  28.   case days[2]:
  29.     if (time == times[0]) {
  30.       console.log(days[2] + times[0] + plans[4]);
  31.     } else if (time == times[1]) {
  32.       console.log(days[2] + times[1] + plans[5]);
  33.     } else {
  34.       console.log('输入格式错误');
  35.     }
  36.     break;
  37.   case days[3]:
  38.     if (time == times[0]) {
  39.       console.log(days[3] + times[0] + plans[6]);
  40.     } else if (time == times[1]) {
  41.       console.log(days[3] + times[1] + plans[7]);
  42.     } else {
  43.       console.log('输入格式错误');
  44.     }
  45.     break;
  46.   case days[4]:
  47.     if (time == times[0]) {
  48.       console.log(days[4] + times[0] + plans[8]);
  49.     } else if (time == times[1]) {
  50.       console.log(days[4] + times[1] + plans[9]);
  51.     } else {
  52.       console.log('输入格式错误');
  53.     }
  54.     break;
  55.   case days[5]:
  56.     if (time == times[0]) {
  57.       console.log(days[5] + times[0] + plans[10]);
  58.     } else if (time == times[1]) {
  59.       console.log(days[5] + times[1] + plans[11]);
  60.     } else {
  61.       console.log('输入格式错误');
  62.     }
  63.     break;
  64.   case days[6]:
  65.     if (time == times[0]) {
  66.       console.log(days[6] + times[0] + plans[12]);
  67.     } else if (time == times[1]) {
  68.       console.log(days[6] + times[1] + plans[13]);
  69.     } else {
  70.       console.log('输入格式错误');
  71.     }
  72.     break;
  73.   default:
  74.     console.log('输入格式错误');
  75. }