if 分支语句
+ 概念: 根据条件决定是否执行某一段代码, 或者决定执行哪一段代码
语法形式:
1. if 语句
=> if (条件) { 代码段 }
=> 意义: 条件为 ture 的时候, {} 内的代码段执行, 否则不执行
2. if else 语句
=> if (条件) { 代码段 } else { 代码段 }
=> 意义: 条件为 true, 执行 if 后面的 {} 内的代码, 否则执行 else 后面 {} 内的代码
=> 注意: 两个 {} 内的代码, 能且只能执行一个
3. if else if ... 语句
=> if (条件) { 代码段 } else if (条件) { 代码段 } ...
=> 意义: 从第一个 if 开始依次判断每一个条件, 哪一个条件成立, 执行哪一个条件 后面 {} 内的代码
只要前面的 if 条件成立了, 那么后面的就都不管了
如果所有条件都不成立, 那么都不执行
=> 注意: 多个 {} 内的代码, 最多只能执行一个
4. if else if else 语句
=> if (条件) { 代码段 } else if (条件) { 代码段 } ... else { 代码段 }
=> 意义: 从第一个 if 开始依次判断每一个条件, 哪一个条件成立, 执行哪一个条件 后面 {} 内的代码
只要前面的 if 条件成立了, 那么后面的就都不管了
如果所有条件都不成立, 执行 else 后面 {} 内的代码
=> 注意: 多个 {} 内的代码, 能且只能执行一个
<script>
console.log('start')
// 1. if 语句
// var age = 16
// if (age >= 18) {
// console.log('去网吧')
// }
// 2. if else 语句
// var age = 16
// if (age >= 18) {
// console.log('去网吧')
// } else {
// console.log('借一个身份证')
// }
// 3. if else if 语句
// var age = 5
// if (age >= 18) {
// console.log('上大学')
// } else if (age >= 12) {
// console.log('中学')
// } else if (age >= 6) {
// console.log('小学')
// }
// 4. if else if else 语句
var age = 5
if (age >= 18) {
console.log('上大学')
} else if (age >= 12) {
console.log('中学')
} else if (age >= 6) {
console.log('小学')
} else {
console.log('在家和小姨一起玩')
}
console.log('end')
</script>if语句的小联系
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
if 小练习
+ 当 if 各种语句, 代码段只有一句话的时候, 可以省略 {} 不写
=> 当你需要省略的时候, 那么 else 必须换行
*/
// 练习1: 判断一个数字是偶数还是奇数
// 需求: 一个数字和 2 取余是否为 0
// var n = 13
// if (n % 2 === 0) {
// console.log('偶数')
// } else {
// console.log('奇数')
// }
// () 内的判断的内容是 n % 2 的结果
// n % 2 的结果就是 1 或者 0
// () 内判断的内容就是 1 或者 0
// if (n % 2) {
// // 这里的代码能执行, 说明 n % 2 是 1
// console.log('奇数')
// } else {
// // 这里的代码能执行, 说明 n % 2 是 0
// console.log('偶数')
// }
// if (n % 2) console.log('奇数')
// else console.log('偶数')
// 练习2: 判断一个数字是否在某一个区间内
// 例子: 判断数字是否在 [10, 20] 之间
// 数学角度: 10 <= 数字 <= 20
// 代码角度: 需要同时满足两个条件, 10 <= 数字, 数字 <= 20
// var n = 500
// 第一步: 10 <= n 得到的结果是 true 或者 false
// 第二步: 布尔 <= 20 得到的结果一定是 true
// if (10 <= n <= 20) {
// console.log(n + ' 确实在 [10, 20] 之间')
// }
// var n = 5
// if (10 <= n && n <= 20) console.log(n + ' 确实在 [10, 20] 之间')
// 练习3: 根据成绩在控制台输出一些字母
// 90 以上 A
// 80 ~ 89 B
// 70 ~ 79 C
// 60 ~ 69 D
// 60 以下 E
// var score = 59
// if (score >= 90) {
// console.log('A')
// } else if (score >= 80) {
// console.log('B')
// } else if (score >= 70) {
// console.log('C')
// } else if (score >= 60) {
// console.log('D')
// } else {
// console.log('E')
// }
// 练习4: 判断一个年份数字是不是闰年
/*
闰年
能被四整除不能被100整除
能被400整除
闰年: year 是 4 的倍数，且 year 不是 100 的倍数的
闰年：year 是 400 的倍数
闰年: year % 4 === 0 && year % 100 !== 0
闰年：year % 400 === 0
*/
// var year = 1900
// // 书写条件
// if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
// console.log(year + ' 是闰年')
// } else {
// console.log(year + ' 是平年')
// }
</script>
</body>
</html>
switch分支语句
单词:
switch: 游戏机, 岔道
case: 方案, 情况
break: 打断, 结束
default: 默认
分支语句 - switch
+ 概念: 根据你要判断的数据决定执行哪一段代码
=> 把你的数据做出很多种匹配情况, 决定执行哪一种情况
基本语法:
switch (数据) {
case 情况一:
满足情况一的时候执行的代码
break
case 情况二:
满足情况二的时候执行的代码
break
default:
所有条件都不满足的时候执行的代码
}
=> 注意1: () 内的内容不会在转换成布尔了, 都会拿到一个最终结果, 进入到 switch 中去判断
=> 注意2: 要判断的数据和每一个 case 必须是 值和数据类型(===) 都一样才叫做满足条件
=> 注意3: case 位置尽量不写表达式, 因为会按照表达式的结果来进行条件判断
=> 注意4: switch 不负责做范围性的判断
=> 注意5: default 可以不写, 不写的时候, 所有 case 都不满足就没有 代码执行
=> 注意6: break 如果不写会发生 break 穿透效果
-> 穿透效果: 不管下一个 case 是不是满足, 都会直接执行代码, 直到遇到下一个 break 或者代码整体执行完毕为止
小练习
var week = 0
switch (week) {
case 0:
console.log('星期日')
case 1:
console.log('星期一')
case 2:
console.log('星期二')
case 3:
console.log('星期三')
case 4:
console.log('星期四')
case 5:
console.log('星期五')
case 6:
console.log('星期六')
default:
console.log('你判断的数据不是 0 ~ 6 的数字')
}
console.log('后续代码')<script>
/*
switch 小练习
*/
// 练习1: 根据成绩在控制台输出一些字母
// 90 以上 A
// 80 ~ 89 B
// 70 ~ 79 C
// 60 ~ 69 D
// 60 以下 E
/*
A: 90 91 92 ... 99
B: 80 81 81 ... 89
C: 70 71 72 ... 79
D: 60 61 62 ... 69
E: 5x 4x 3x 2x 1x x 0
把成绩除以 10 取整
*/
// var score = 55
// switch (parseInt(score / 10)) {
// case 10:
// case 9:
// console.log('A')
// break
// case 8:
// console.log('B')
// break
// case 7:
// console.log('C')
// break
// case 6:
// console.log('D')
// break
// default:
// console.log('E')
// }
// 练习2: 根据 1 ~ 12 这些数字输出当月多少天(2月暂时按照28天计算)
var month = 9
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
console.log('31')
break
case 4:
case 6:
case 9:
case 11:
console.log('30')
break
case 2:
console.log('28')
break
}
</script>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
练习:
+ 根据年月日三个变量信息, 判断是当年的第几天
+ 示例:
var year = 2022
var month = 3
var date = 1
结果: 2022 年 3 月 1 日是当年的第 60 天
分析:
+ 判断闰年, 为了 2 月是 28 天还是 29 天 year
+ 确定叠加多少个整月天数 month
+ 叠加当月的天数 date
思路:
+ 不管闰年, 2 月都加 28 天
+ 不管天数
+ 只考虑月份叠加
分析月份如何叠加
+ case 12 月份 叠加 11 月 +30
+ ...
+ case 4 月份 叠加 3 月 +31
+ case 3 月份 叠加 2 月 +28
+ case 2 月份 叠加 1 月 +31
*/
// var year = 2020
// var month = 12
// var date = 31
// 初始变量不设置为 0, 就是当月日期
// var total = date
// 开始叠加月份
// switch (month) {
// case 12: total += 30
// case 11: total += 31
// case 10: total += 30
// case 9: total += 31
// case 8: total += 31
// case 7: total += 30
// case 6: total += 31
// case 5: total += 30
// case 4: total += 31 // 叠加 3 月
// case 3:
// // 需要叠加 2 月份的整月天数, 判断一下闰年
// total += year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28
// case 2: total += 31 // 叠加 1 月
// }
// console.log(total)
/*
练习:
+ 根据年月日三个变量信息, 判断是当年的第几天
+ 示例:
var year = 2022
var month = 3
var date = 1
结果: 2022 年 3 月 1 日是当年的第 60 天
+ 要求: 不能使用 switch 语句
分析:
+ 一个 if 语句只能执行一次, 多个 if 语句
+ 月份的叠加
=> 2 月 叠加 1 月
=> 3 月 叠加 1 月 和 2 月
=> 4 月 叠加 1 月 和 2 月 和 3 月
=> 规律:
1. 只要大于 1, 就得叠加 31
2. 只要大于 2, 就得叠加 28
*/
var year = 2020
var month = 12
var date = 31
// 直接那日期当做基础数据开始叠加
var total = date
if (month > 1) total += 31
if (month > 2) total += year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28
if (month > 3) total += 31
if (month > 4) total += 30
if (month > 5) total += 31
if (month > 6) total += 30
if (month > 7) total += 31
if (month > 8) total += 31
if (month > 9) total += 30
if (month > 10) total += 31
if (month > 11) total += 30
console.log(total)
</script>
</body>
</html>
循环语句 while
循环: 重复的执行某一段代码
+ 代码内的循环就是数数
+ 通过数字的变化决定循环的次数
循环三要素
1. 开始: 从几开始数数
2. 结束(条件): 数到多少结束
3. 步长: 数数的间隔
while 语句:
+ while (条件) { 代码段 }
+ 当条件满足的时候, 执行 {} 内的代码段
=> 执行完毕代码段以后, 再次进行条件判断
=> 如果条件满足, 再次执行 {} 内的代码段
=> 以此类推, 直到条件不满足为止
=> 循环结束
循环内注意的事项:
+ 一定要改变初始值
循环次数的问题: 什么东西决定循环的次数
开始 结束 步长 次数
1 <=3 +1 3
2 <=3 +1 2
1 <=2 +1 2
1 <=3 +2 2
循环给我们提供了什么东西 ?
1. 重复执行代码的能力
2. 一组有规律的数字
=> 在循环内, 循环控制变量就是一组有规律的数字
循环里和循环外的 循环控制变量
+ 在循环里, 循环控制变量一定是条件为 true
+ 在循环外, 循环控制变量一定是条件为 false
console.log('start')
// 基本 while 语句
// 需求: 我需要一个三次的循环
// 1. 确定循环的开始
var n = 1
// 2. 确定循环的结束(条件)
while (n <= 20) {
console.log('执行代码', n)
// 3. 确定循环的步长
n++
}
console.log('end', n)
while循环小练习
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
while 小练习
*/
// 练习1: 在控制台输出 1 ~ 100 之间 3 的倍数
// 方案1: 基础循环
// 1. 拿到 1 ~ 100 之间的所有数字
// 循环开始: 1
// 循环结束: <= 100
// 循环步长: +1
// var n = 1
// while (n <= 100) {
// // 判断, 如果当前这个 n % 3 === 0 才进行输出
// if (n % 3 === 0) console.log(n)
// n++
// }
// 方案2: 直接锁定数字
// 第一个 3的倍数是 3
// var n = 3
// while (n <= 100) {
// console.log(n)
// // 步长设置为 +3
// n += 3
// }
// 练习2: 求 1 ~ 10 之间 3的倍数的 和
// 3 + 6 + 9 === 18
// 1. 拿到 1 ~ 10 之间所有 3 的倍数
var n = 3
// 2. 准备一个初始值, 接受最后求和结果
// 问题: 初始值写在循环外面还是循环里面 ? 外面
var sum = 0
while (n <= 10) {
// console.log(n)
// 因为 n 就是每一个 3 的倍数
// 把 n 叠加到 sum 身上即可
sum += n
n += 3
}
console.log(sum)
</script>
</body>
</html>
循环语句 do while
+ 循环语句的一种
+ while 循环
while (条件) { 代码段 }
+ do while 循环
do { 代码段 } while (条件)
执行过程
+ 首先: 先执行一遍 {} 内的代码, 再开始条件判断
=> 如果条件满足就再次执行 {} 内的代码, 然后条件判断
=> 以此类推, 直到条件不满足的时候
=> 直接结束循环
和 while 的区别
+ 当初始内容在条件内的时候, while 和 do while 循环没有区别
+ 当初始内容在条件外的时候
=> while 循环一次都不会执行
=> do while 循环会执行一次
*/
// console.log('start')
// var n = 10
// do {
// console.log('我执行了')
// n++
// } while (n <= 3)
// console.log('end')
小案例：页面加一个密码
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
do while 小练习
+ 页面加一个密码
*/
// 知识点: prompt
// 语法: prompt('提示文本内容')
// 表现形式: 一个弹出层, 一个文本框, 一个取消按钮, 一个确定按钮
// 返回值:
// 你点击的是取消按钮, 返回值是 null(不管写不写内容都是 null)
// 你点击的是确定按钮, 返回值是 文本框内 输入的内容(不管你写什么, 都是字符串类型)
// var res = prompt('你的银行卡密码是多少 ?')
// console.log(res)
// console.log(typeof res)
/*
实现业务的逻辑
1. 打开页面就要弹出一个输入框, 让用户输入密码
2. 开始判断你输入的对不对
=> 如果不对, 再次执行弹出输入框的代码
=> 再次判断
=> 如果对, 不再执行弹出输入框的代码
*/
do {
// 弹出输入框
var res = prompt('你爱不爱我 ?')
} while (res !== 'yes')
alert('滚犊子')
</script>
</body>
</html>
循环语句 for
循环语句的一种
语法:
for (初始变量; 条件判断; 修改初始值) { 代码段 }
原始形态:
初始变量
for (条件判断) {
修改初始值
}
console.log('start')
for (var n = 1; n <= 20; n++) {
// 在这个 {} 内只需要书写重复执行的代码即可, 不需要考虑修改初始值的问题
console.log('我执行了', n)
}
console.log('end')
for循环小练习
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
for 小练习
*/
// 1. 寻找三次自幂数(水仙花数字)
// 三次自幂数:
// + 保证是一个 三位数
// + 数字每一位的 三次幂之和 和 这个数字 相等
// 示例: 153
// + 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3
// + 1 + 125 + 27
// + 153
// 步骤1: 拿到 所有三位数
// for (var i = 100; i <= 999; i++) {
// // 步骤2: 提取出每一位的数字
// // 2-1. 提取百位数字
// var a = parseInt(i / 100)
// // 2-2. 提取十位数字
// var b = parseInt(i % 100 / 10)
// // 2-3. 提取各位数字
// var c = i % 10
// // 步骤3: 开始判断
// // 取幂运算符 **
// // 底数 ** 指数
// if (a ** 3 + b ** 3 + c ** 3 === i) console.log(i + ' 是三次自幂数')
// }
// 练习2: 要求在页面上输出 1000 ~ 2000 之间所有的闰年, 四个一换行
// 步骤1: 拿到 1000 ~ 2000 之间 所有的闰年在页面上输出
// 步骤2: 准备一个计数器, 每输出一个计数器++
// 准备一个计数器变量
// var total = 0
// // 书写步长的时候 +4
// for (var i = 1000; i <= 2000; i += 4) {
// // 判断是否是闰年
// // 所有的 i 都必然是 4 的倍数
// if (i % 100 !== 0 || i % 400 === 0) {
// // 页面输出
// document.write(i + ' ')
// // 每输入一个, 计数器++
// total++
// // 当计数器到达 4 8 12 ... 需要输出一个换行
// total % 4 === 0 && document.write('<br>')
// }
// }
// console.log(total)
// 练习3: 求最大公约数
/*
示例: 求 18 和 12 的最大公约数
+ 公约数: 1 2 3 6
+ 最大公约数: 6
+ 最大公约数的取值范围
1 ~ 相对小的那个数字
*/
var max = 18
var min = 12
// 我只要提前准备一个变量, 接受
var res
// 循环
// for (var i = 1; i <= min; i++) {
// // 开始判断
// if (max % i === 0 && min % i === 0) {
// // console.log(i)
// // 找到一个公约数赋值一次
// res = i
// }
// }
// 倒着循环
for (var i = min; i >= 1; i--) {
console.log(i)
// 开始判断
if (max % i === 0 && min % i === 0) {
res = i
// 因为是从大向小查找, 找到的第一个公约数就是最大公约数
// 只要找到一个就可以直接结束循环了
break
}
}
console.log(res)
</script>
</body>
</html>
循环控制语句的暂停
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
循环控制语句
1. break: 是一个关键字
=> 当你在循环内遇到这个 break 的时候, 会直接结束本次循环
2. continue: 是一个关键字
=> 当你在循环内遇到这个 continue 的时候, 会直接结束循环的本次, 去到下一次
3. 循环控制标记语法
=> 可以在循环开始确立标记
=> 在循环内 break 和 continue 关键字在书写的时候, 后面加上标记
=> 直接回到标记位置
=> 标记书写
标记:
*/
// 1. break
// for (var i = 1; i <= 5; i++) {
// console.log('我吃了第 ' + i + ' 个包子')
// if (i === 3) {
// console.log('我吃饱了')
// // 在需要的时候书写一个 break 关键字
// break
// }
// }
// 2. continue
// for (var i = 1; i <= 5; i++) {
// console.log('我拿起了第 ' + i + ' 个包子')
// if (i === 3) {
// console.log('这个包子掉地下了')
// continue
// }
// console.log('我吃掉了第 ' + i + ' 个包子')
// console.log('-------------------------')
// }
// 3. 标记语法
// a 相当于给 外层 for 循环加了一个标记
a:
for (var i = 1; i <= 5; i++) {
console.log('我拿起了第 ' + i + ' 个包子')
// 循环嵌套
b:
for (var j = 1; j <= 3; j++) {
console.log('吃第 ' + i + ' 个包子的第 ' + j + ' 口')
if (i === 3 && j === 1) {
console.log('发现了半条虫子')
// 直接结束有标记的循环
break a
}
}
console.log('第 ' + i + ' 个包子吃完了')
console.log('---------------------')
}
</script>
</body>
</html>
小案例：最大公约数和最小公倍数
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
最大公约数 和 最小公倍数
*/
// 最大公约数, 辗转相除法
/*
逻辑: 两个数字相除, 如果可以整除, 相对小的数字就是最大公约数
=> 当不能整除的时候交换
=> 把小的数字变成大的, 用原先两个数字的余数代替小的数字
=> 重复以上步骤
示例: 18 和 12
=> max = 18, min = 12
1. max % min 不能整除
-> 进行替换
-> max = 12
-> min = 6
2. max % min 能整除
-> 此时 6 就是 18 和 12 的最大公约数
示例: 27 和 19
=> max = 27, min = 19
1. max % min 不能整除
-> max = 19
-> min = 8
2. max % min 不能整除
-> max = 8
-> min = 3
3. max % min 不能整除
-> max = 3
-> min = 2
4. max % min 不能整除
-> max = 2
-> min = 1
5. max % min 整除
-> 1 就是 27 和 19 的最大公约数
代码:
+ 当 max 和 min 取余不为 0 的时候
=> 执行一段代码(重复执行)
+ 当 max 和 min 取余为 0 的时候
=> 结束循环
*/
// var max = 27
// var min = 19
// // 开启循环
// while (max % min !== 0) {
// // 执行一段代码
// // max 和 min 的从新赋值
// // 准备临时变量保存两个数字的余数
// var tmp = max % min
// // 把 min 的值赋值给 max
// max = min
// // 把 临时变量 的值赋值给 min
// min = tmp
// }
// // 代码来到这里, 说明 max % min === 0 为 true
// console.log(min + ' 就是最大公约数')
// 最小公倍数
/*
分析: 10 和 15 的最小公倍数
+ 公倍数 30 60 90 120 150 ....
+ 最小公倍数 30
+ 最小公倍数取值范围:
最小就是 相对大的那个数字
最大就是 两数乘积
步长就是 相对大的那个数字
*/
var min = 10
var max = 15
// 准备一个变量接受结果
var res = 0
for (var i = max; i <= min * max; i += max) {
// 判断是不是公倍数就可以了
// 因为循环的步长就是 max, 所以这里得到的所有的 i 都是 max 的倍数
// 只要这个数字同时还是 min 的倍数, 那么就是公倍数了
if (i % min === 0) {
res = i
// 又因为我们是从小到大循环的, 那么找到的第一个就是最小公倍数
break
}
}
console.log(min + ' 和 '+ max + ' 的最小公倍数就是 : ' + res)
</script>
</body>
</html>
认识质数
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
质数
+ 除了 1 和 自己本身, 其他不能整除
逻辑: 你是如何确定一个数字是质数的 ?
+ 假设: 7
=> 7 % 2 不能整除
=> 7 % 3 不能整除
=> 7 % 4 不能整除
=> 7 % 5 不能整除
=> 7 % 6 不能整除
+ 结果
=> 如果是质数, 需要在过程后才能知道, 使得循环可以正常结束
=> 如果不是质数, 可能在过程中就知道了, 使得循环被打断从而非正常结束
+ 代码:
=> 从 2 到 自己-1 依次去整除尝试
*/
// 方案1: 假设法(开关)
// var n = 8
// // 步骤1: 定义一个变量, 假设这个数字是质数
// var flag = true // 假设 n 是质数
// // 步骤2: 求证我的假设
// // 从 2 到 自己-1 依次去取余, 只要有一个为 0 了
// // 假设错误, 推翻我的假设
// for (var i = 2; i <= n - 1; i++) {
// // 依次取余
// if (n % i === 0) {
// // 推翻我的假设
// flag = false
// // 只要有一个推翻了, 后面不需要了
// break
// }
// }
// // 循环结束以后
// // 如果 flag === true 说明从头到尾没有被推翻过假设
// // 说明所有的数字都不能整除, 那么就是一个质数
// // 如果 flag === false 说明从头到尾至少有一个推翻过假设
// // 说明至少有一个数字整除了, 那么肯定不是一个质数
// if (flag) {
// console.log(n + ' 是质数')
// } else {
// console.log(n + ' 不是质数')
// }
// var n = 7
// // 步骤1: 定义一个变量, 假设这个数字是质数
// var flag = true
// // 步骤2: 求证我的假设
// // 问题: 有必要循环到 n-1 吗 ? 只要到达自己的一半即可
// for (var i = 2; i <= n / 2; i++) {
// if (n % i === 0) {
// flag = false
// break
// }
// }
// 循环结束以后
// if (flag) {
// console.log(n + ' 是质数')
// } else {
// console.log(n + ' 不是质数')
// }
// 方案2: 计数法
// var n = 7
// // 步骤1: 准备一个计数器
// var total = 0
// // 步骤2: 循环依次去尝试每一个数字是否能整除
// // 不能整除什么都不做, 如果可以整除计数器++
// for (var i = 2; i <= n / 2; i++) {
// if (n % i === 0) {
// total++
// break
// }
// }
// 如果 total 还是 0, 说明没有整除的, 是一个质数
// 如果 total 是 1, 说明至少有一个整除了, 不是一个质数
// 方案3: 打断循环法
// 如果循环正常结束了, 说明 是质数
// 如果循环非正常结束, 说明 不是质数
// 如何判断一个循环是不是正常结束
// for (var i = 0; i <= 5; i++) {
// if (i === 3) break
// }
// 循环结束以后
// 如何判断循环是不是正常结束的
// 当 i <= 5 为 false, 说明循环正常结束了
// 当 i <= 5 为 true, 说明是在某一次循环中被打断了
// 使用循环一模一样的条件来判断, 如果为 false, 说明循环正常结束了, 如果为 true 说明非正常结束
// 使用循环完全相反的条件来判断, 如果为 true 说明循环正常结束了, 如果为 false 说明非正常结束
// console.log(i, i <= 5)
var n = 129
for (var i = 2; i <= n / 2; i++) {
if (n % i === 0) break
}
// 判断循环是不是正常结束
i > n / 2 ? console.log(n + ' 是质数') : console.log(n + ' 不是质数')
</script>
</body>
</html>
循环嵌套的案例
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<style>
span {
display: inline-block;
width: 120px;
height: 30px;
text-align: left;
}
</style>
</head>
<body>
<script>
/*
循环嵌套案例
+ 在一个循环内再次书写一个循环
+ 注意: 里外层循环不要使用一个变量控制
*/
// for (var i = 1; i <= 3; i++) {
// console.log(i)
// for (var j = 1; j <= 3; j++) {
// console.log(' - ', j)
// }
// }
/*
使用 * 在页面出现一个 9 * 9 的正方形
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
*/
// 1. 在页面输出一个 *
// document.write('*')
// 2. 在页面输出一行 *
// for (var i = 1; i <= 9; i++) {
// document.write('* ')
// }
// document.write('<br>')
// 3. 在页面输出 9 行 *
// 步骤2 重复九次
// for (var j = 1; j <= 9; j++) {
// for (var i = 1; i <= 9; i++) {
// document.write('* ')
// }
// document.write('<br>')
// }
/*
使用 * 在页面上出现以下三角形
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
规律:
=> 第 1 行 1个
=> 第 2 行 2个
=> 第 3 行 3个
=> ...
=> 第 9 行 9个
*/
// outer 循环控制多少行, 不能动
// outer:
// for (var i = 1; i <= 9; i++) {
// // inner 决定每一行多少个
// // 当 i === 1 的时候 第 1 行, inner 循环应该循环 1 次 j = 1; j <= 1 1次
// // 当 i === 2 的时候 第 2 行, inner 循环应该循环 2 次 j = 1; j <= 2 2次
// // 当 i === 3 的时候 第 3 行, inner 循环应该循环 3 次 j = 1; j <= 3 3次
// // ...
// // 当 i === 9 的时候 第 9 行, inner 循环应该循环 9 次 j = 1; j <= 9 9次
// inner:
// for (var j = 1; j <= i; j ++) {
// document.write('* ')
// }
// document.write('<br>')
// }
/*
使用 * 出现以下三角形
* * * * * * * * *
* * * * * * * *
* * * * * * *
* * * * * *
* * * * *
* * * *
* * *
* *
*
*/
// for (var i = 1; i <= 9; i++) {
// // 当 i === 1 的时候, 第 1 行, inner 循环应该是 9 次 j = 1; j <= 9 9次
// // 当 i === 2 的时候, 第 2 行, inner 循环应该是 8 次 j = 2; j <= 9 8次
// // 当 i === 3 的时候, 第 3 行, inner 循环应该是 7 次 j = 3; j <= 9 7次
// // 当 i === 9 的时候, 第 9 行, inner 循环应该是 1 次 j = 9; j <= 9 1次
// for (var j = i; j <= 9; j++) {
// document.write('* ')
// }
// document.write('<br>')
// }
/*
使用 * 出现以下三角形
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
*/
// for (var i = 1; i <= 9; i++) {
// for (var j = i; j <= 9; j++) {
// document.write(' ')
// }
// for (var k = 1; k <= i; k++) {
// document.write('* ')
// }
// document.write('<br>')
// }
// 当 i === 1 的时候, j 的循环会出现第一行, 9 个空格, k 的循环会出现第一行 1 个 * 号
// 输出一个换行
// 当 i === 2 的时候, j 的循环会出现第二行, 8 个空格, k 的循环会出现第二行 2 个 * 号
// 输出一个换行
/*
九九乘法表
*/
for (var i = 1; i <= 9; i++) {
for (var j = 1; j <= i; j++) {
document.write('<span>' + j + ' * ' + i + ' = ' + (i*j) + ' </span>')
}
document.write('<br>')
}
</script>
</body>
</html>