程序结构设计

顺序：根据代码的书写顺序，从上至下一行一行一行的执行

选择：根据条件的真假，选择执行某种相应的结果

循环：重复的做某件事

if 的条件的表现方式：

1
2
3
a.  if (条件表达式) {
执行语句;
}
1
2
3
4
5
b. if (条件表达式) {
执行语句;
}else{
语句;
}

通过断点调试观察代码执行顺序

调试：手动执行代码

作用：跟踪代码的执行顺序，以及观察变量的数值

步骤 -> source -> 点文件名 -> 打断点 -> step over

关闭调试 -> 取消断点

1
2
3
4
5
6
7
c. if (条件表达式1) {
语句1;
}else if (条件表达式2) {
语句2;
}else if (条件表达式3) {
语句3;
}

三目运算符：条件运算符

表达式1 ？表达式2 ：表达式3

表达式1是布尔值，根据表达式1的结果，判断返回表达式2还是3

true返回2，false返回3

1
2
3
c = a > b ? a : b;

console.log(c);

例： 

1
2
3
4
5
6
7
var a, b, c, d;
a = 111;
b = 123;
c = 233;
d = a > b ? a : b;
d = c > d ? c : d;
console.log(d);

多分支结构：

1
2
3
4
5
6
7
8
9
switch (匹配值) {
case 被匹配值1；
  语句1;
case 被匹配值2;
  语句2;
case 被匹配值3;
  语句3;
  ...
}

注意：switch 是等值匹配

特点：switch只匹配一次，然后按照顺序执行

break: 跳出switch语句

default: 之前所有case的对立面

循环

执行顺序：先条件再语句，根据条件的真假判断语句是否执行，直到条件为假则跳出

1
2
3
while(条件表达式){
循环体;
}

一个有限次的循环，必须有一个使循环趋近于结束的条件

1
2
3
4
5
6
7
var i = 1;
var sum = 0;
while (i <= 100) {
   sum += i;
   i++;
}
console.log(sum, i);

do while

1
2
3
4
5
do {
语句
}while (条件表达式);

执行顺序：先语句，后条件

while和do…while的异同：

当首次条件成立时, 这俩没有区别，

当首次条件不成立时,do…while要比while多执行一次循环体

例子：

不知道循环次数，建议用while 例：

一张纸的厚度是0.001米,已知珠穆朗玛峰的高度为8848米,假设纸张可以无限对折,

请问对折多少次的纸张厚度可以超过珠穆朗玛峰

1
2
3
4
5
6
7
8
var h = 0.001;
var count = 0;
while (h <= 8848) {
   h *= 2;
   count++;
}

console.log(count);

for循环

for(表达式1；表达式2；表达式3){ //1243243243…

表达式4；

}

表达式1：循环变量的初始化

表达式2：循环的条件

表达式3：使循环趋于结束的条件

表达式4：循环体语句

1
2
3
4
5
var i = 1;
for (sum = 0; i <= 100; i++) {
    sum += i;
}
console.log(sum);

建议知道循环次数，用for

循环嵌套：一个循环的循环体是另一个循环

循环嵌套不要超过3层（实际2层）

1
2
3
4
5
6
for (var j = 1; j <= 9; j++) {
   for (var i = 1; i <= j; i++) {
       document.write(i + 'x' + j + '=' + i * j + '&nbsp&nbsp');
    }
   document.write('<br>');
}

break:跳出本层循环

continue:跳出本次循环

冒泡排序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var arr = [6, 5, 7, 4, 8, 3, 9, 2, 0, 1];
var t;
//外层循环,决定趟数
for (var i = 0; i < arr.length - 1; i++) {
   //内层循环,决定每趟的次数
   for (var j = 0; j < arr.length - i - 1; j++) {
       if (arr[j] < arr[j + 1]) {
           t = arr[j];
           arr[j] = arr[j + 1];
           arr[j + 1] = t;
      }
  }
}
console.log(arr);

核心思想:两两比较

外层循环(趟):N-1

内存循环(次):N-1-(i趟)

选择排序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var arr = [5, 6, 4, 7, 3, 8, 2, 9, 0, 1];
var k;
var t;
//外层循环n-1
for (var i = 0; i < arr.length - 1; i++) {
   //内层循环
   k = i;
   for (var j = i + 1; j < arr.length; j++) {
       if (arr[k] > arr[j]) {
           k = j;
     }
}
     t = arr[i];
     arr[i] = arr[k];
     arr[k] = t;
}
console.log(arr);