昨日複習
-
前置自增是先 自增 後 返回值
-
後置自增是先 返回值 後 自增
-
"==="如果要相等必須 值 和 數據類型 相等
-
switch的結束每一項的結束關鍵字是 break
-
三元表達式的格式爲：條件判斷表達式 ？表達式1 : 表達式2
-
switch的默認項的關鍵詞是 default
1. 循環
循環目的
在實際問題中，有許多 具有規律性的重複操作，因此在程序中要完成這類操作就需要 重複執行某些語句
JS中有三種類型的循環：
- for 循環
- while 循環
- do…while 循環
01 - 循環的目的
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>01 - 循環的目的</title>
<script>
// 循環的目的：可以重複執行某些代碼
console.log('媳婦我錯了');
console.log('媳婦我錯了');
console.log('媳婦我錯了');
console.log('---------------------');
for (var i = 1; i <= 1000; i++) {
console.log('媳婦我錯了');
}
</script>
</head>
<body>
</body>
</html>
2. for循環
在程序中，一組被重複執行的語句稱之爲循環體，能否繼續重複執行。取決於循環的終止條件。由循環體及循環的終止條件組成的語句，稱之爲循環語句
2.1 語法結構
for 循環主要用於把某些代碼循環若干次，通常跟計數有關係
for(初始化變量; 條件表達式; 操作表達式) {
// 循環體
}
| 名稱 | 作用 |
|---|---|
| 初始化變量 | 通常被用於初始化一個計數器，該表達式可以使用 var 關鍵字聲明新的變量，這個變量幫我們來記錄次數。 |
| 條件表達式 | 用於確定每一次循環是否能被執行。如果結果是 true 就繼續循環，否則退出循環。 |
| 操作表達式 | 每次循環的最後都要執行的表達式。通常被用於更新或者遞增計數器變量。當然，遞減變量也是可以的。 |
執行過程
-
初始化變量，初始化操作在整個 for 循環只會執行一次。
執行條件表達式，如果爲true，則執行循環體語句，否則退出循環，循環結束。 -
執行操作表達式，此時第一輪結束。
-
第二輪開始，直接去執行條件表達式（不再初始化變量），如果爲 true ，則去執行循環體語句，否則退出循環。
-
繼續執行操作表達式，第二輪結束。
-
後續跟第二輪一致，直至條件表達式爲假，結束整個 for 循環。
02 - for循環
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>02 - for循環</title>
<script>
// 1. for 重複執行某些代碼， 通常跟計數有關係
// 2. for 語法結構
// for (初始化變量; 條件表達式; 操作表達式) {
// // 循環體
// }
// 3. 初始化變量 就是用var 聲明的一個普通變量， 通常用於作爲計數器使用
// 4. 條件表達式 就是用來決定每一次循環是否繼續執行 就是終止的條件
// 5. 操作表達式 是每次循環最後執行的代碼 經常用於我們計數器變量進行更新（遞增或者遞減）
// 6. 代碼體驗 我們重複打印100局 你好嗎
for (var i = 1; i <= 100; i++) {
console.log('你好嗎');
}
</script>
</head>
<body>
</body>
</html>
03 - for循環執行過程
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>03 - for循環執行過程</title>
<script>
// for 循環的執行過程
for (var i = 1; i <= 100; i++) {
console.log('你好嗎');
}
// 1. 首先執行裏面的計數器變量 var i = 1 .但是這句話在for 裏面只執行一次 index
// 2. 去 i <= 100 來判斷是否滿足條件， 如果滿足條件 就去執行 循環體 不滿足條件退出循環
// 3. 最後去執行 i++ i++是單獨寫的代碼 遞增 第一輪結束
// 4. 接着去執行 i <= 100 如果滿足條件 就去執行 循環體 不滿足條件退出循環 第二輪
</script>
</head>
<body>
</body>
</html>
04 - for循環重複相同代碼
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>04 - for循環重複相同代碼</title>
<script>
// for 循環可以執行相同的代碼
// for (var i = 1; i <= 10; i++) {
// console.log('媳婦我錯了');
// }
// 我們可以讓用戶控制輸出的次數
var num = prompt('請您輸入次數');
for (var i = 1; i <= num; i++) {
console.log('媳婦我錯了');
}
</script>
</head>
<body>
</body>
</html>
2.3 for 循環重複執行相同的代碼
主要是因爲使用了計數器，計數器在每次循環過程中都會有變化。
05 - for循環重複不同的代碼
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>05 - for循環重複不同的代碼</title>
<script>
// for 循環可以重複執行不同的代碼 因爲我們有計數器變量 i 的存在 i每次循環值都會變化
// 我們想要輸出1個人 1~100歲
for (var i = 1; i <= 100; i++) {
console.log('這個人今年' + i + '歲了');
}
for (var i = 1; i <= 100; i++) {
if (i == 1) {
console.log('這個人今年1歲了，他出生了');
} else if (i == 100) {
console.log('這個人今年100歲了，他死了');
} else {
console.log('這個人今年' + i + '歲了');
}
}
</script>
</head>
<body>
</body>
</html>
2.4 for 循環重複某些相同的操作
for循環因爲有了計數器的存在，我們還可以重複的執行某些操作，比如做一些算術運算。
06 - for循環重複某些操作
課堂案例1： 求 1~100 之間所有整數累加和
案例分析：
- 需要循環100次，我們需要一個計數器 i
- 我們需要一個存儲結果的變量 sum，但是初始值一定是0
- 核心算法：1 + 2 + 3 + 4 … ， sum = sum + i
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>06 - for循環重複某些操作</title>
<script>
// for 循環重複執行某些操作 比如說我們做了100次加法運算
var sum = 0; // 求和 的變量
for (var i = 1; i <= 100; i++) {
// sum = sum + i;
sum += i;
}
console.log(sum);
</script>
</head>
<body>
</body>
</html>
07 - for循環案例
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>07 - for循環案例</title>
<script>
// 1. 求1-100之間所有數的平均值 需要一個 sum 和的變量 還需要一個平均值 average 變量
var sum = 0;
var average = 0;
for (var i = 1; i <= 100; i++) {
sum = sum + i;
}
average = sum / 100;
console.log(average);
// 2. 求1-100之間所有偶數和奇數的和 我們需要一個偶數的和變量 even 還需要一個奇數 odd
var even = 0;
var odd = 0;
for (var i = 1; i <= 100; i++) {
if (i % 2 == 0) {
even = even + i;
} else {
odd = odd + i;
}
}
console.log('1~100 之間所有的偶數和是' + even);
console.log('1~100 之間所有的奇數和是' + odd);
// 3. 求1-100之間所有能被3整除的數字的和
var result = 0;
for (var i = 1; i <= 100; i++) {
if (i % 3 == 0) {
// result = result + i;
result += i;
}
}
console.log('1~100之間能夠被3整數的數字的和是：' + result);
</script>
</head>
<body>
</body>
</html>
08 - 求學生成績案例
課堂案例2： 求學生成績
要求用戶輸入班級人數，之後依次輸入每個學生的成績，最後打印出該班級總的成績以及平均成績。
案例分析：
- 彈出輸入框輸入總的班級人數（num）
- 依次輸入學生的成績（保存起來 score），此時我們需要用到 for循環，彈出的次數跟班級總人數有關係條件表達式 i <= num
- 進行業務處理：計算成績。先求總成績（sum），之後求平均成績（average）
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>08 - 求學生成績案例</title>
<!--
-->
<script>
var num = prompt('請輸入班級的總人數:'); // num 總的班級人數
var sum = 0; // 求和的變量
var average = 0; // 求平均值的變量
for (var i = 1; i <= num; i++) {
var score = prompt('請您輸入第' + i + '個學生成績');
if(score == ''){
alert('成績不能爲空，默認爲0');
}else {
// 因爲從prompt取過來的數據是 字符串型的需要轉換爲數字型
sum = sum + parseFloat(score);
}
}
average = sum / num;
// average = average.toFixed(2); // 四捨五入
average = (parseInt(average * 100) / 100).toFixed(2); // 不四捨五入
alert('班級的總人數是 ' + num + '\n班級總的成績是 ' + sum + '\n班級平均分是 ' + average);
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>09 - 一行打印五個星星</title>
<script>
// 一行打印五個星星
// console.log('★★★★★');
// for (var i = 1; i <= 5; i++) {
// console.log('★');
// }
// var str = '';
// for (var i = 1; i <= 5; i++) {
// str = str + '★';
// }
// console.log(str);
var num = prompt('請輸入星星的個數');
var str = '';
for (var i = 1; i <= num; i++) {
str = str + '★'
}
console.log(str);
</script>
</head>
<body>
</body>
</html>
3. 雙重for循環
3.1 雙重for循環概述
很多情況下，單層for循環並不能滿足我們的需求，比如我們要打印一個5行5列的圖形，
打印一個倒直角三角形等，此時就可以通過循環嵌套來實現。
循環嵌套：指在一個循環語句中再定義一個循環語句的語法結構，例如在for循環語句中，可以再嵌套一個for循環，這樣的for循環語句我們稱之爲 雙重for循環
10 - 雙重for循環
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>10 - 雙重for循環</title>
<script>
// 1. 雙重for循環 語法結構
// for (外層的初始化變量; 外層的條件表達式; 外層的操作表達式) {
// for (裏層的初始化變量; 裏層的條件表達式; 裏層的操作表達式) {
// // 執行語句;
// }
// }
// 2. 我們可以把裏面的循環看做是外層循環的語句
// 3. 外層循環循環一次， 裏面的循環執行全部
// 4. 代碼驗證
for (var i = 1; i <= 3; i++) {
console.log('這是外層循環第' + i + '次');
for (var j = 1; j <= 3; j++) {
console.log('這是裏層的循環第' + j + '次');
}
}
</script>
</head>
<body>
</body>
</html>
11 - 打印五行五列星星
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>11 - 打印五行五列星星</title>
<script>
// 打印五行五列星星
var str = '';
for (var i = 1; i <= 5; i++) { // 外層循環負責打印五行
for (var j = 1; j <= 5; j++) { // 裏層循環負責一行打印五個星星
str = str + '★';
}
// 如果一行打印完畢5個星星就要另起一行 加 \n
str = str + '\n';
}
console.log(str);
</script>
</head>
<body>
</body>
</html>
12 - 打印n行n列的星星
課堂案例1： 打印n行n列的星星
要求用戶輸入行數和列數，之後在控制檯打印出用戶輸入行數和列數的星星。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>12 - 打印n行n列的星星</title>
<!--
-->
<script>
// 打印n行n列的星星
var rows = prompt('請您輸入行數:');
var cols = prompt('請您輸入列數:');
var str = '';
for (var i = 1; i <= rows; i++) {
for (var j = 1; j <= cols; j++) {
str = str + '★';
}
str += '\n';
}
console.log(str);
</script>
</head>
<body>
</body>
</html>
13 - 打印倒三角形
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>13 - 打印倒三角形</title>
<script>
// 打印倒三角形案例
var str = '';
for (var i = 1; i <= 10; i++) { // 外層循環控制行數
for (var j = i; j <= 10; j++) { // 裏層循環打印的個數不一樣 j = i
str = str + '★';
}
str += '\n';
}
console.log(str);
</script>
</head>
<body>
</body>
</html>
九九乘法表案例分析
- 一共有9行，但是每行的個數不一樣，因此需要用到雙重 for 循環
- 外層的 for 循環控制行數 i ，循環9次 ，可以打印 9 行
- 內層的 for 循環控制每行公式 j
- 核心算法：每一行 公式的個數正好和行數一致， j <= i;
- 每行打印完畢，都需要重新換一行
for循環小結
- for循環 可以重複執行某些相同的代碼
- for循環 可以重複執行些許不同的代碼，因爲我們有計數器
- for循環 可以重複執行某些操作，比如算術運算符加法操作
- 隨着需求增加，雙重for循環可以做更多、更好看的效果
- 雙重for循環，外層循環一次，內層for循環 全部執行
- for循環 是循環條件和數字直接相關的循環
- 分析要比寫代碼更重要
- 一些核心算法想不到，但是要學會，分析它執行過程
- 舉一反三，自己經常總結，做一些相似的案例
14 - 九九乘法表案例
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>14 - 九九乘法表案例</title>
<script>
var str = '';
for (var i = 1; i <= 9; i++) { // 外層循環控制行數
for (var j = 1; j <= i; j++) { // 裏層循環控制每一行的個數 j <= i
// 1 × 2 = 2
// str = str + '★';
str += j + '×' + i + '=' + i * j + '\t';
}
str += '\n';
}
console.log(str);
</script>
</head>
<body>
</body>
</html>
4. while循環
while語句可以在條件表達式爲真的前提下，循環執行指定的一段代碼，直到表達式不爲真時結束循環。
while (條件表達式）{
// 循環體代碼
}
執行思路：
- 先執行條件表達式，如果結果爲true，則執行循環體代碼；如果爲false，則退出循環，執行後面代碼。
- 執行循環體代碼
- 循環體代碼執行完畢後，程序會繼續判斷執行條件表達式，如果條件仍爲true，則會繼續執行循環體，直到循環條件爲false，整個循環過程纔會結束。
15 - while循環
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>15 - while循環</title>
<script>
// 1. while 循環語法結構 while 當...的時候
// while (條件表達式) {
// // 循環體
// }
// 2. 執行思路 當條件表達式結果爲true 則執行循環體 否則 退出循環
// 3. 代碼驗證
var num = 1;
while (num <= 100) {
console.log('nice'); // nice
num++;
}
// 4. 裏面應該也有計數器 初始化變量
// 5. 裏面應該也有操作表達式 完成計數器的更新 防止死循環
</script>
</head>
<body>
</body>
</html>
16 - while循環案例
課堂案例1：
- 打印人的一生。從1-100歲。
- 求1-100之間所有整數的和。
- 彈出一個提示框， 你愛我嗎？ 如果輸入我愛你，就提示結束，否則，一直詢問。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>16 - while循環案例</title>
<script>
// while循環案例
// 1. 打印人的一生，從1歲到100歲
var i = 1;
while (i <= 100) {
console.log('這個人今年' + i + '歲了');
i++;
}
// 2. 計算 1 ~ 100 之間所有整數的和
var sum = 0;
var j = 1;
while (j <= 100) {
sum += j;
j++
}
console.log(sum);
// 3. 彈出一個提示框， 你愛我嗎？ 如果輸入我愛你，就提示結束，否則，一直詢問。
var message = prompt('你愛我嗎?');
while (message !== '我愛你') {
message = prompt('你愛我嗎?');
}
alert('我也愛你啊！');
</script>
</head>
<body>
</body>
</html>
5. do while循環
是while語句的一個變體。該循環會先執行一次代碼塊，然後對條件表達式進行判斷，如果條件爲真，就會重複執行循環體，否則退出循環。
do {
// 循環體
} while (條件表達式)
17 - do whild循環
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>17 - do whild循環</title>
<script>
// 1.do while 循環 語法結構
do {
// 循環體
} while (條件表達式)
// 2. 執行思路 跟while不同的地方在於 do while 先執行一次循環體 在判斷條件 如果條件表達式結果爲真，則繼續執行循環體，否則退出循環
// 3. 代碼驗證
var i = 1;
do {
console.log('how are you?'); // how are you?
i++;
} while (i <= 100)
// 4. 我們的do while 循環體至少執行一次
</script>
</head>
<body>
</body>
</html>
do while循環案例1：
- 打印人的一生。從1-100歲。
- 求1-100之間所有整數的和。
- 彈出一個提示框， 你愛我嗎？ 如果輸入我愛你，就提示結束，否則，一直詢問。
循環小結
- JS中循環有for、while、do while
- 三個循環很多情況下都可以相互替代使用
- 如果是用來計次數，跟數字相關的，三者使用基本相同，但是我們更喜歡用for
- while 和 do…while 可以做更復雜的判斷條件，比for循環更靈活一些
- while 和 do…while 執行順序不同，while先判斷後執行，do…while是先執行一次，再判斷執行
- while 和 do…while 執行次數不同，do…while至少會執行一次循環體，而while 可能一次也不執行
- 在實際工作中，我們更常用 for循環語句，它寫法更簡潔，所以這個要重點學。
18 - do while循環案例
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>18 - do while循環案例</title>
<script>
// while循環案例
// 1. 打印人的一生，從1歲到100歲
var i = 1;
do {
console.log('這個人今年' + i + '歲了');
i++;
} while (i <= 100)
// 2. 計算 1 ~ 100 之間所有整數的和
var sum = 0;
var j = 1;
do {
sum += j;
j++;
} while (j <= 100)
console.log(sum);
// 3. 彈出一個提示框， 你愛我嗎？ 如果輸入我愛你，就提示結束，否則，一直詢問。
do {
var message = prompt('你愛我嗎?');
} while (message !== '我愛你')
alert('我也愛你啊');
</script>
</head>
<body>
</body>
</html>
6. continue break
6.1 continue 關鍵字
continue關鍵字用於立即跳出本次循環，繼續下一次循環（本次循環體中 continue 之後的代碼就會少執行一次）
例如：喫5個包子，第3個有蟲子，就扔掉第3個，繼續喫第四個第五個包子：其代碼實現如下：
19 - continue
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>19 - continue</title>
<script>
// continue 關鍵字 退出本次（當前次的循環） 繼續執行剩餘次數循環
for (var i = 1; i <= 5; i++) {
if (i == 3) {
continue; // 只要遇見 continue就退出本次循環 直接跳到 i++
}
console.log('我正在喫第' + i + '個包子');
}
// 1. 求1~100 之間， 除了能被7整除之外的整數和
var sum = 0;
for (var i = 1; i <= 100; i++) {
if (i % 7 == 0) {
continue;
}
sum += i;
}
console.log(sum);
</script>
</head>
<body>
</body>
</html>
6.2 break關鍵字
break關鍵字用於立即跳出整個循環（循環結束）。
例如：喫5個包子，喫到第三個發現裏面有半個蟲子，其餘的不吃了，其代碼實現如下：
20 - break
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>20 - break</title>
<script>
// break 退出整個循環
for (var i = 1; i <= 5; i++) {
if (i == 3) {
break;
}
console.log('我正在喫第' + i + '個包子');
}
</script>
</head>
<body>
</body>
</html>
作業
1.1 求100以內所有能被3和7整除的數的和
- 題目描述：
- 把1-100之間所有能夠被3和7同時整除的數找出來，計算累加和
- 題目提示：
- 在算入累加和之前，使用%判定遍歷到的數字是不是可以被3和7整除
1.2 使用for循環打印三角形
-
題目描述：在控制檯一次性打印形狀如下：
☆
☆☆
☆☆☆
☆☆☆☆
☆☆☆☆☆ -
題目提示：利用雙重for循環
1.3 使用for循環打印99乘法表
-
題目描述：使用for循環，打印99乘法表
-
在控制檯打印具體效果如下：
1×1=1
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
1×4=4 2×4=8 3×4=12 4×4=16
1×5=5 2×5=10 3×5=15 4×5=20 5×5=25
1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36
1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49
1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64
1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81 -
題目提示：利用雙重for循環
1.4 用戶登錄驗證
- 題目描述：接收用戶輸入的用戶名和密碼，若用戶名爲 “admin” ,且密碼爲 “123456” ,則提示用戶登錄成功! 否則，讓用戶一直輸入。
- 題目提示：利用while循環或者do while 循環
1.5 求1-100之間個位數不爲3的數的累加和。
- 題目描述：求整數1～100的累加值，但要求跳過所有個位爲3的數。
- 題目提示：
- 使用%判個位數是否爲3
- 用continue實現
2.1 簡易ATM
- 題目描述：
- 裏面現存有 100 塊錢。
- 如果存錢，就用輸入錢數加上先存的錢數, 之後彈出顯示餘額提示框
- 如果取錢，就減去取的錢數，之後彈出顯示餘額提示框
- 如果顯示餘額，就輸出餘額
- 如果退出，彈出退出信息提示框
- 題目提示：通過輸入的數值判斷用戶操作
2.2 求從1 開始第35個能被7和3整除的整數數
- 題目描述：求從1開始第35個能被7和3整除的整數
- 題目提示：通過變量記錄是第幾個可以被3和7整除的數
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>作業</title>
<script>
/ 1.1 求100以內所有能被3和7整除的數的和
var sum = 0;
for (var i = 1; i <= 100; i++) {
if (i % 3 == 0 || i % 7 == 0) {
sum += i;
}
}
console.log(sum); // 2208
console.log('---')
// 1.2 使用for循環打印三角形
var start = '';
for (var i = 1; i <= 5; i++) {
for (var j = 1; j <= i; j++) {
start += '☆';
}
start += '\n';
}
console.log(start);
console.log('---')
// 1.3 使用for循環打印99乘法表
var start = '';
for (var i = 1; i <= 9; i++) {
for (var j = 1; j <= i; j++) {
start += j + '*' + i + '=' + i * j + '\t';
}
start += '\n';
}
console.log(start);
console.log('---')
// 1.4 用戶登錄驗證
do{
user = prompt('請輸入登錄信息：');
password = prompt('請輸入登錄密碼：');
}while(user !== 'admin' && password !== 123456);
alert('登錄成功');
console.log('---')
// 1.5 求1-100之間個位數不爲3的數的累加和。
var sum = 0;
for (var i = 1; i <= 100; i++) {
if (i % 10 == 3) {
continue;
}
sum += i;
}
console.log(sum); // 4570
console.log('---')
// 2.1 簡易ATM
var money = 100;
var moneySum = 0;
var num = parseInt(prompt('請輸入你的操作:' + '\n' +
'1.存錢' + '\n' + '2.取錢' + '\n' + '3.顯示餘額' + '\n' + '4.退出'));
switch (num) {
case 1:
moneySum = money + parseFloat(prompt('請輸入你存錢數'));
alert("存款：" + moneySum);
break;
case 2:
var qu = prompt('輸入你取的錢');
// qu = parseFlot(qu);
// console.log(qu);
// console.log(money);
if (qu > money) {
alert('不好意思，錢不夠');
} else {
alert('餘額爲' + (money - qu));
}
break;
case 3:
alert("餘額：" + money);
break;
case 4:
var flag = prompt("是否繼續？(Y/N)");
while (flag !== ('Y' && 'y')) {
flag = prompt("是否繼續？(Y/N)");
}
alert('退出成功');
break;
default:
alert("輸入錯誤");
break;
}
// 2.2 求從1開始第35個能被7和3整除的整數數
for (var i = 1; i <= 35; i++) {
if (i % 3 == 0 || i % 7 == 0) {
// sum += i;累加和每個被3整除和被7整除的數字做一個累加和
result = console.log('第' + i + '個是被3和被7整除的數,' + '數字是：' + i);
}
}
</script>
</head>
<body>
</body>
</html>
知識總結
for循環語法結構
for循環
for(初始化變量; 條件表達式; 操作表達式 ){
循環體
}
- 初始化變量：通常被用於初始化一個計數器，該表達式可以使用 var 關鍵字聲明新的變量，這個變量幫我們來記錄次數。
- 條件表達式：用於確定每一次循環是否能被執行。如果結果是 true 就繼續循環，否則退出循環。
- 操作表達式：每次循環的最後都要執行的表達式。通常被用於更新或者遞增計數器變量。當然，遞減變量也是可以的。
for循環執行過程
執行過程：
- 初始化變量，初始化操作在整個 for 循環只會執行一次。
- 執行條件表達式，如果爲true，則執行循環體語句，否則退出循環，循環結束。
- 執行操作表達式，此時第一輪結束。
- 第二輪開始，直接去執行條件表達式（不再初始化變量），如果爲 true ，則去執行循環體語句，否則退出循環。
- 繼續執行操作表達式，第二輪結束。
- 後續跟第二輪一致，直至條件表達式爲假，結束整個 for 循環。
雙重for循環執行過程
- 雙重for循環執行過程：
for (外循環的初始; 外循環的條件; 外循環的操作表達式) { for (內循環的初始; 內循環的條件; 內循環的操作表達式) { 需執行的代碼; } } - 外層循環執行一次，內層循環執行完成一遍
while循環
- while循環
while (條件表達式) { // 循環體代碼 } - while循環應該設置計數器，放置循環一直執行
do while循環
- do-while循環
do{ // 循環體代碼 }while( 條件表達式 ) - do-while循環和while循環相比，會在判斷條件表達式之前先去執行一次循環體
命名規範以及語法格式
- 變量、函數的命名必須要有意義
- 變量的名稱一般用名詞
- 函數的名稱一般用動詞
- 操作符的左右兩側各保留一個空格
- 單行註釋前面注意有個空格