01乘法口诀表
/*
row = 1 for (var col = 1; col <= 9; col++)
row = 2 for (var col = 1; col <= 8; col++)
row = 3 for (var col = 1; col <= 7; col++)
.....
row = 9 for (var col = 1; col <= 1; col++)
*/
var strStar = ''; // 保存 口诀表 的 字符串
// 1.生成9行，并且 row 会逐一生成 行号
for (var row = 1; row <= 9; row++) {
//2. 内层循环：负责生成 每一行 里的 星星的个数（列数）
for (var col = 1; col <= 10 - row; col++) {
//strStar += '*\t';
strStar += col + ' * ' + (10 - row) + ' = '+ ( col * (10 - row) ) +'\t';
}
//3. 加入换行符
strStar += '\n';
}
//4. 循环结束后，打印乘法口诀表
console.log(strStar);
02复兴循环
//1.循环
/* 1.1 while循环
如果 条件判断表达式 返回 的是 true，就会执行 if {} 大括号代码
if(条件判断){
}
如果 条件判断表达式 返回 的是 true，就会执行 while{} 大括号里的代码
然后 再来判断 条件判断表达式 返回 的是 true，如果是true，就会再次 执行 while{} 大括号里的代码
然后 再来判断 ...................
知道 最后一次判断 条件判断表达式 返回 的是 false，就结束循环，执行 while{} 后面的代码
while(条件判断){
}
【while 执行顺序】
1.先判断 while 的循环条件
如果 循环条件为 true，则执行循环体代码
接着进入 下一次轮循环条件判断和代码执行，直到退出循环为止
false，则退出循环
【强调】 while (bool) 中 可以写几种代码：
a.直接写一个 bool值
while(true){
if(a==10){
break;
}
}
b.直接写一个 bool值变量
var isCon = true;
while(isCon){
if(a==10){
isCon = false;
}
}
c.直接写一个 条件表达式
var a = 1;
while(a < 10){
a = 10;
}
【while 特点】 先判断后执行~~
*/
/*
1.2 do while 循环
和 while 循环 一抹一样，除了 执行顺序 有调整
【do while特点】 先执行，再判断~~~
【do while循环顺序】
1.先执行 循环代码，再判断 循环条件
如果 循环条件为 true,则 进入下一次循环代码执行 和 判断，直到 循环条件为 false 退出循环为止
false，则立即退出循环
*/
var a = 1;
do {
console.log('a= ' + a);
a++; // a = a + 1
} while (a <= 5);
console.log('循环结束后：a=' + a);
/*
1.3 for 循环：能够比 while 和 dowhile 更好的 规范语法，防止 开发人员 遗漏 循环要素
for(var i = 1; i < 10; i++){
}
【for 执行顺序：】
一、第一轮循环 的顺序
1.创建 循环变量
2.判断 循环条件
3.执行 循环体代码
4.执行 循环条件改变 i++
二、第二轮循环 和 后面每一轮的循环 的执行顺序
2.判断 循环条件
3.执行 循环体代码
4.执行 循环条件改变 i++
*/
//练习：计算 20-100 之间的 偶数 的平均值
var sumNum = 0; // 保存所有偶数和
var count = 0; // 循环的偶数的个数
var avgNum = 0; // 平均值
//生成 20 - 100 之间的整数
for (var i = 20; i <= 100; i++) { // i = 20 21 22 ...... 99, 100
//如果 i 是一个 偶数，那么 就累加 到 sumNum 变量中
if (i % 2 == 0) {
count++; // 累加 偶数 的个数
sumNum += i; // sumNum = sumNum + i;
}
}
avgNum = sumNum / count;
console.log('20-100之间所有偶数和【' + sumNum + '】，偶数个数为【' + count + '】，平均值为【' + avgNum + '】');
/* */
//-----------------------------------------------------------------------------------------------------------
console.log('-------------------------------------------------------------');
//1.continue 退出本次循环
// 准确的说 是 退出 本次循环的 代码 执行 阶段，进入下一个步，循环变量的修改
//2.break 退出整个循环，并且 本次循环后面的代码 也不会执行了！！
// 通俗的说：break结束循环，循环体代码全部都不执行了，包括 break后还没执行的 本次循环的代码
for (var i = 1; i < 5; i++) {
console.log('本次循环开始：i= ' + i);
// if (i == 2) {
// console.log('i==2了，退出整个循环');
// break;
//
03数组初体验
// 变量的特点：一个变量只能保存一个数据
var num = 1;
console.log(num);
// 【数组】
// 本质：就是内存中 一连串的 空间
// 特点：一次可以存放很多的数据
// 【数组构成 三要素】：
// 元素 --- 数组中 存放的 数据
// 下标 --- 数组中 元素的 标识
// length -- 数组中 所有 元素 的 个数
//1.数组创建 并设置 初始值---------------
// 12 2 3
// true false
// 'james' '我爱华为'
var arr = [1, true, ss , '小苍苍','小波波'];
// 0 1 2 3
//2.数组的访问---------------------------
console.log(arr); // 打印 整个数组 数据
//3.数组元素的访问------------------------
console.log('arr[0] = ' + arr[0]); // 访问 数组中 下标 为 0 的元素
console.log('arr[1] = ' + arr[1]); // 访问 数组中 下标 为 1 的元素
console.log('arr[2] = ' + arr[2]); // 访问 数组中 下标 为 2 的元素
//4.数组元素的个数 --- 数组的长度----------
console.log('数组中的元素个数为：' + arr.length);
03数组创建方式
// 数组创建方式
//1.new 的方式 -----------------------------------------
//1.1 创建空数组
var arr = new Array();
//1.2 创建带 初始 长度 的 空数组
var arr = new Array(3);
//a. 访问 未赋值 的空间，得到 undefined
console.log(arr[0]);
//1.3 创建带 初始值 的数组
var arr = new Array(1,2,'小苍苍');
//2.字面量 [ ] 方式 --- 强烈推荐，用的最多 ------------------------------
//2.1 创建空数组
var arr = [];
//2.2 创建 带 初始值的 数组
var arr = [1, 2, '小苍'];
04设置和访问数组元素
//0. 创建了一个数组，里面有5 个元素
var arrCity = ['P城', 'R城', 'G港', '学校', '靶场'];
// 0 1 2 3 4 length = 5
//1.访问 数组的 元素： 通过 数组名[下标] 访问 --------------------
//1.1 直接 打印数组元素
console.log(arrCity[0]); // 访问 arrCity数组的 第0个元素
console.log(arrCity[1]); // 访问 arrCity数组的 第1个元素
console.log(arrCity[2]); // 访问 arrCity数组的 第2个元素
console.log(arrCity[3]); // 访问 arrCity数组的 第3个元素
console.log(arrCity[4]); // 访问 arrCity数组的 第4个元素
// 错误：arrCity(0) 不是通过小括号，是中括号！！！
//1.2 将数组元素 复制一份 存入 变量
var ele3 = arrCity[3];
console.log(ele3);
console.log(arrCity);
//强调：访问 不存在的下标元素
console.log('访问超出最大下标的元素：' + arrCity[5]);
//2.设置 数组的 元素： 通过 数组名[下标] = 新的值 --------------------------
//2.1 设置修改 已存在的下标里的元素
arrCity[3] = '研究所';
console.log(arrCity);
//2.2 设置 超出 最大下标 的元素 ---- 相当于 向数组 中 加一个元素
arrCity[5] = '军事基地';
console.log(arrCity);
//2.3 设置 超出 最大下标 很多 的元素 ---- 相当于 向数组 中加了多个元素，只不过中间的 都为 undefined
arrCity[8] = 'Y城';
console.log(arrCity);
//2.4 访问 下标 为6 和 7 的元素
console.log(arrCity[6]);
console.log(arrCity[7]);
console.log(arrCity[8]);
05数组的小尾巴
//0. 创建了一个数组，里面有5 个元素
var arrCity = ['P城', 'R城', 'G港', '学校', '靶场'];
// 0 1 2 3 4 length = 5
//1. 通过 length 访问数组中 元素的个数
console.log(arrCity.length);
//2. 通过 length 来设置 数组 的 元素个数
//2.1 通过 length 为 数组 增加 空的 元素
arrCity.length = 7; // 因为 此时 数组 最大长度为 5，设置为7 的话，就是 向数组 添加了 3个 空元素
console.log(arrCity);
console.log(arrCity[5]); // undefined
console.log(arrCity[6]); // undefined
console.log(arrCity[7]); // undefined
//2.2 通过 length 为数组 删减 元素
arrCity.length = 3;
console.log(arrCity); // ['P城', 'R城', 'G港']
//注意：如果 设置数组.length = 0,相当于 清空整个数组
06追加元素到数组
//0. 创建了一个数组，里面有5 个元素------------------------------------------------
var arrCity = ['P城', 'R城', 'G港', '学校', '靶场'];
// 0 1 2 3 4 length = 5
//1. 数组名.push(新的值) 可以向数组 中添加 元素！--- 是从数组的 尾部追加元素
arrCity.push('军事基地');
arrCity.push('Z城');
console.log(arrCity);
07删除数组元素
//0. 创建了一个数组，里面有5 个元素------------------------------------------------
var arrCity = ['P城', 'R城', 'G港', '学校', '靶场'];
// 0 1 2 3 4 length = 5
//1.splice( index,count )删除 数组中 指定下标 的元素
// index -- 要删除的元素的开始下标
// count -- 要删除的元素的 个数
arrCity.splice(3,1);
console.log(arrCity);
//2.splice 从指定下标开始，一直删除到最后一个元素
// index
// count -- 如果 第二个参数 不传，则 代表 从 index 一直删到 结尾
arrCity.splice(1); // 从 下标1 开始删除，一直 删到最后一个元素
console.log(arrCity); //[ 'P城' ]
08遍历数组
// 业务：打印 数组里的每个元素，手动打印太麻烦~~
// console.log(arrCity[0]);
// console.log(arrCity[1]);
// console.log(arrCity[2]);
// console.log(arrCity[3]);
// console.log(arrCity[4]);
//0. 创建了一个数组，里面有5 个元素------------------------------------------------
var arrCity = ['P城', 'R城', 'G港', '学校', '靶场'];
// 0 1 2 3 4 length = 5
// 【使用 for 循环 来 遍历 数组里的元素】
//一、正序遍历 数组的元素 0 -> 最后一个下标 -----------------------------------------------
//a. 正序遍历 的第1种方法 ： i < arr.length
// 1.通过 for循环 里的 i，依次生成 数组里元素的 下标
for (var i = 0; i < arrCity.length; i++) { // i = 0 1 2 3 4
// 2.通过 中括号访问法，访问 数组中 对应 i 下标 的元素，并打印出来！
console.log(arrCity[i]);
}
//b. 正序遍历 的第2种方法 ： i <= arr.length - 1
for (var i = 0; i <= arrCity.length - 1; i++) { // i = 0 1 2 3 4
console.log(arrCity[i]);
}
console.log('倒序遍历数组：');
//二、倒序遍历 数组的元素 最后一个下标 -> 0 ---------------------------------------------------------
for (var i = arrCity.length - 1; i >= 0; i--) { // i = 4 3 2 1 0
console.log(arrCity[i]);
}
09将 1 - 100 的数 追加到数组
//0. 将 1 - 100 的数 存入数组--------------------------------------
//1.创建空数组
var arrNum = [];
//2.用 for 循环 生成 1 - 100 之间的数
for(var i = 1; i<=100;i++){
//3.将生成的 数 追加 到 数组中
arrNum.push(i);
}
//4.打印数组
console.log(arrNum); // [1,2,3,4,5,6........98,99,100]
10求数组最大值
// 1. 求数组最大值
var arrNum = [99, 5, 2, 6, 77, 777, 222];
// 0 1 2 3 4 5 6 length = 7
//1.1 擂台思想：准备一个 擂台，里面 放 最大值
var maxNum = arrNum[0]; // 将 要 比较 的 第一个值 存入 "擂台变量"
//1.2 循环 遍历 取出 数组里 的元素，注意：从 下标 为 1 的元素开始取
for(var i = 1; i < arrNum.length; i ++){
//1.3 比较 当前 元素 和 maxNum 里的值 谁大
if(arrNum[i] > maxNum){
//1.4 如果 元素 大于 maxNum里的值，就 将 元素 设置给 maxNum变量 -- 比较强的 坐入王座
maxNum = arrNum[i];
}
}
console.log(maxNum);
// 1. 求数组最小值
var arrNum = [99, 5, 2, 6, 77, 777, 222];
// 0 1 2 3 4 5 6 length = 7
//1.1 擂台思想：准备一个 擂台，里面 放 最小值
var mixNum = arrNum[0]; // 将 要 比较 的 第一个值 存入 "擂台变量"
//1.2 循环 遍历 取出 数组里 的元素，注意：从 下标 为 1 的元素开始取
for(var i = 1; i < arrNum.length; i ++){
//1.3 比较 当前 元素 和 mixNum 里的值 谁小
if(arrNum[i] < mixNum){
//1.4 如果 元素 小于 mixNum 里的值，就 将 元素 设置给 mixNum 变量 -- 比较弱的 坐入王座
mixNum = arrNum[i];
}
}
// 打印最小值
console.log(mixNum);
11翻转数组
// 【题目】翻转数组
//0. 创建了一个数组，里面有5 个元素------------------------------------------------
var arrCity = ['P城', 'R城', 'G港', '学校', '靶场'];
// 0 1 2 3 4 length = 5
//1. 创建一个 空数组，用来保存 原数组的 翻转数据
var arrNewCity = [ ];//['靶场', '学校', 'G港', 'R城', 'P城'];
//2. 倒序遍历 原数组，并 从 后 往前 取出元素 ，追加到 新数组中
for(var i = arrCity.length - 1; i >= 0 ; i--){ // i = 4 3 2 1 0 -1
var ele = arrCity[i];
arrNewCity.push(ele);
}
//3.打印 新数组 和 原数组
console.log('原数组：'+arrCity);
console.log('新数组：'+arrNewCity);
//4.将新数组 赋给 原数组
arrCity = arrNewCity;
console.log('翻转后的原数组：'+arrCity);
// console.log('i=' + i);
12将数组元素拼接成字符串
//【题目】将数组元素拼接成字符串
//0. 创建了一个数组，里面有5 个元素------------------------------------------------
var arrCity = ['小苍苍', '小甜甜', '小狗狗', '小猫猫', '小泽泽'];
// 0 1 2 3 4 length = 5
//1. 准备一个 空字符串
var str = ''; // 如果不设置，就是 undefined
//2. 遍历元素，并将元素 追加到 字符串中
for (var i = 0; i < arrCity.length; i++) {
//3. 将 元素 拼接到 字符串中
str += arrCity[i]; // 相当于 str += '小苍苍' str += '小甜甜' str += '小狗狗' ................
// 为 不是 最后一个元素 的情况 下 追加 字符 '-'
if (i < arrCity.length - 1) {
str += '-';
}
}
//3. 打印字符串
console.log(str);
13删除数组里的指定元素
//0. 创建了一个数组，里面有5 个元素------------------------------------------------
var arrCity = ['小苍苍', '小甜甜', '小苍苍','小狗狗', '小猫猫', '小泽泽'];
// 0 1 2 3 4 length = 5
console.log(arrCity);
// 1. 遍历 数组里的 元素，如果 找到 目标元素，就调用 splice 方法 删除
for(var i = 0; i < arrCity.length;i++){
//2. 如果 遍历的元素 等于 '小苍苍'
if(arrCity[i] == '小苍苍'){
// 3. 调用 数组的 splice 方法 ，根据当前下标 ，删除 1个元素
arrCity.splice(i,1);
}
}
//4.打印 删除 目标元素 后的 数组
console.log(arrCity);
14冒泡排序
// 冒泡排序
// 1. 求数组最小值
var arrNum = [5, 4, 3, 2, 1]; // -> [1,2,3,4,5]
// 0 1 2 3 4 length = 5
console.log('排序前：');
console.log(arrNum);
// 排序的过程，就是 不断 找 最大值的过程，两两相比，将 大的数字 和 小的数字 位置 进行 调换
// 1.外层循环 负责 比较 轮数 控制： 轮数 = 数组元素个数 - 1
for (var lun = 1; lun < arrNum.length; lun++) {
console.log('第' + lun + '轮比较--------------------');
// 2.内层循环 负责 比较的次数
for (var i = 0; i < arrNum.length - lun; i++) {
//console.log('第' + lun + '轮的 第 '+ i +'次比较--------------------');
if (arrNum[i] > arrNum[i + 1]) {
var temp = arrNum[i];
arrNum[i] = arrNum[i + 1];
arrNum[i + 1] = temp;
}
console.log(arrNum);
}
}
// 一共 5个元素，比较 4轮 for(var i = 0 ;i < arr.length - lun;i++)
// 第1轮 比较 4次 内层次数循环 for(var i = 0 ;i < 4;i++) // i = 0 1 2 3
// 第2轮 比较 3次 内层次数循环 for(var i = 0 ;i < 3;i++) // i = 0 1 2
// 第3轮 比较 2次 内层次数循环 for(var i = 0 ;i < 2;i++) // i = 0 1
// 第4轮 比较 1次 内层次数循环 for(var i = 0 ;i < 1;i++) // i = 0
// 冒泡排序
// 1. 求数组最小值
var arrNum = [4, 3, 2, 1]; // -> [1,2,3,4]
// 0 1 2 3 length = 4
console.log('排序前：');
console.log(arrNum);
// 排序的过程，就是 不断 找 最大值的过程，两两相比，将 大的数字 和 小的数字 位置 进行 调换
//第一轮比较：将 数组中 最大的值 放到了 最后面
console.log('第1轮比较：将 数组中 最大的值 放到了 最后面--------------------');
if(arrNum[0] > arrNum[1]){
var temp = arrNum[0]; // temp = 4 , a[0] = 4 , a[1] = 3
arrNum[0] = arrNum[1]; // temp = 4 , a[0] = 3 , a[1] = 3
arrNum[1] = temp; // temp = 4 , a[0] = 3 , a[1] = 4
}
console.log(arrNum);
if(arrNum[1] > arrNum[2]){
var temp = arrNum[1];
arrNum[1] = arrNum[2];
arrNum[2] = temp;
}
console.log(arrNum);
if(arrNum[2] > arrNum[3]){
var temp = arrNum[2];
arrNum[2] = arrNum[3];
arrNum[3] = temp;
}
console.log(arrNum);
//第2轮比较：将 数组中 第二大的值 放到了 倒数第二个位置
console.log('第2轮比较：将 数组中 第二大的值 放到了 倒数第二个位置--------------------');
if(arrNum[0] > arrNum[1]){
var temp = arrNum[0];
arrNum[0] = arrNum[1];
arrNum[1] = temp;
}
console.log(arrNum);
if(arrNum[1] > arrNum[2]){
var temp = arrNum[1];
arrNum[1] = arrNum[2];
arrNum[2] = temp;
}
console.log(arrNum);
//第3轮比较：将 数组中 第3大的值 放到了 倒数第3个位置
console.log('第3轮比较：将 数组中 第3大的值 放到了 倒数第3个位置--------------------');
if(arrNum[0] > arrNum[1]){
var temp = arrNum[0];
arrNum[0] = arrNum[1];
arrNum[1] = temp;
}
console.log(arrNum);
