日期：2月3日
1. 循环的别名
别名: for () {
}
别名: while() {
}
break 结束掉离他最近的循环
break 别名： 结束掉指定的循环
2. 循环的别名的使用场景
1：存在于嵌套循环
2、需求中包含 要通过内部循环结束掉外部循环 这样的场景 那么 我们才要使用循环的别名
案例：
a:for (var i = 1; i <= 9; i++) {
for (var j = 1; j <= i; j++) {
// 系统通过内层循环结束掉外层循环
if(i === 6) {
break a;
}
var result = i*j; // 1 --01
result= result < 10 ? "0"+result : result
document.write(j+"*"+i+"="+result+" ")
}
document.write("<br>")
}3.数组
变量： 内存中存储【一个】数值【容器】
数组： 内存中存储【多个】数值【容器】，变量类型 Array 属于复杂数据类型
特点： 存储变量的容器，数组本身也是一个变量
数组定义：数组是一个有序的列表，可以在数组中存放任意的数据，数组的长度可以动态的调整
数组语法：
两部分构成
数组的索引： 0 开始的 并且是有顺序的
数组的值： 每个值都会对应数组一个索引
索引和值的关系：通过索引操作整个数组的值（重要）
数组私有的属性：length 可以记录数组的长度
数组的length 和 索引index 之间的关系：最大索引比长度少1
// 定义空数组
var arr = []
// 数组的操作
// 1.1 向数组中添加数据
arr[0] = "小明"
// 把小明修改成小红
arr[0] = "小红"
arr[2] = 18
// 1.2 获取数组中指定索引位置的内容
var name = arr[0]
var age = arr[2]
var u = arr[1] // 数组中某个元素为空 返回的就是undefined
console.log(name,age,u);
// 1.3 删除数组中指定的内容
delete arr[2] // 将数组的第二个索引位置的内容 清空 长度保留的
// 1.4 清空当前数组所有内容
arr.length = 0复杂数据类型 类型的校验：
Object.prototype.toString.call(arr) [object Array]
value instanceof 复杂数据类型
true: value 属于当前的复杂数据类型
false: value 不属于当前的复杂数据类型
// 校验数组的类型
console.log(typeof arr); // object
console.log(Object.prototype.toString.call(arr)); // [object Array]
console.log(arr instanceof Array); // true 表示arr 属于数组类型
4.数组的遍历
数组的遍历： 将数组的元素 一个一个拿出来 并且每个元素都可以操作
数组遍历两种方式：
方式一 普通for
1. 遍历灵活 可以自由调整 初始遍历的位置/自由调整结束遍历的位置
初始遍历的位置 取决于 for循环的初始值 结束遍历的位置 取决于 条件
2. 写法相对复杂 逻辑自己定义
方式二 增强for for...in..
1. 书写较为简洁
2。 缺点 必须从初始位置遍历到最后
// 定义一个带有初始值的数组
var arr = ['上元教育',true,18]
arr[3] = "xxxx"
arr[4] = "@@@@"
// 数组的遍历
// 方式一 for循环 初始值就是数组的初始索引 最大值 数组的长度-1 每次循环之后 数组的索引值自增1
for(var index = 0;index < arr.length;index++) {
console.log(index,arr[index]);
}
// 方式二 for in 遍历 方式二就是方式一的语法糖【简化写法】
// 系统直接判断出 所遍历的索引就是 从 0 一直到 数组的最大的索引
console.log("---------------------");
for(var index in arr) {
console.log(index,arr[index]);
}
5.数组的排序
数组的排序有很多种，这边介绍两种简单的，需要记住
1 .冒泡排序： 相邻的两个数值进行排列 大的放后边 即为 确定最大值 放在最后面
2. 选择排序：后面的值都和前面的进行比较 确定最小值放在最前面
案例：冒泡排序
var arr = [10,9,8,7,5,4,3,2,1] // [1,2,3,4,5]
/*
// [5,4,3,2,1]
第1轮的比较 i = 0 5 -1-0 4 j<4
4,5,3,2,1
4,3,5,2,1
4,3,2,5,1
4,3,2,1,5
第2轮比较 i = 1 5-1-1 3 j<3
3,4,2,1,5
3,2,4,1,5
3,2,1,4,5
第3轮比较 i = 2 5-1-2 2 j<2
2,3,1,4,5
2,1,3,4,5
第4轮比较 i = 3 5 5-1-3 1 j<1
1,2,3,4,5
通过以上分析： 冒泡排序嵌套循环
外层循环 确定循环多少轮
内存循环 每一轮循环多少次 目的就是为了确定某一个数值的位置
外层循环： 循环次数 数组的长度-1
互换位置
var a = 10
var b = 20
t = a;
a = b
b =t
*/
for(var i = 0;i<arr.length - 1;i++) {
for(var j = 0;j<arr.length-1-i;j++) {
// 相邻的两个数值进行比较 如果前面的> 后面的 前后两个只需要对调
if( arr[j]>arr[j+1]) {
var t = arr[j]
arr[j] = arr[j+1]
arr[j+1] = t
}
}
}
console.log(arr);
案例：选择排序
/*
选择排序：后面的值都和前面的进行比较 确定最小值放在最前面
第1轮比较 确定第1个元素的值 i = 0
4,5,3,2,1 初始 1 5 4 j < 5
3,5,4,2,1
2,5,4,3,1
1,5,4,3,2
第2轮比较 确定第2个元素的值 i = 1
1,4,5,3,2 初始 2 5 3 j < 5
1,3,5,4,2
1,2,5,4,3
第3轮比较 确定第3个元素的值 i=2
1,2,4,5,3 初始 3 5 2 j < 5
1,2,3,5,4
第4轮比较 确定第4个元素的值 i = 3
1,2,3,4,5 初始 4 5 1 j < 5
*/
var arr = [10,9,8,7,5,4,3,2,1]
for(var i = 0;i<arr.length - 1;i++) {
for(var j = i+1;j<arr.length;j++) {
if( arr[i] > arr[j]) {
var t = arr[i]
arr[i] = arr[j]
arr[j] = t;
}
}
}
console.log(arr);6.二维数组
一维数组： 存储变量的容器
一维数组的存储特点： 只存储一行
二维数组： 存储数组的数组 就是二维数据
二维数组的存储特点： 行列结构的存储容器
案例：
// 定义二维数组
// 创建一个空的二维数组
// var arrArr = [];
// arrArr[0] = []
// arrArr[1] = []
// arrArr[2] = []
// arrArr[1][1] = "上元教育"
// 创建一个带有初始值的二维数组
// var arrArr = [];
// arrArr[0] = ["北京","上海","广州"]
// arrArr[1] = ["上元教育","上元会计","上元it"]
// arrArr[2] = ["小明","小红","寒梅"]
// 上述代码可以简写成
var arrArr = [["北京","上海","广州"],["上元教育","上元会计","上元it"],["小明","小红","寒梅"]];
// 修改二维数组的某个值
arrArr[1][0] = "上元建工"
// 获取二维数组的某个值
var xh = arrArr[2][1]
console.log(xh);
// 遍历二维数组
console.log("-------------------------------------");
// 外层循环遍历出每一行
for(var index in arrArr) {
// 遍历出的每一行又是一个数组
var arr = arrArr[index];
// 再来遍历一维数组
for(var index2 in arr) {
console.log(arr[index2]);
}
console.log("################");
}
console.dir(arrArr);
177
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
