<!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>
</head>
<body>
<script>
// 纯粹的二维数组
// 有一个 二维数组 里边的值全部都是数字，将二维数组中每一个数字 计算 相加之和
// var arr = [[32,32,545],[5,45,75,326,423],[11,22,33]]
// 编写一个函数，传入 数组作为参数， 返回计算结果
// 不纯粹的二维数组
// 有一个 二维数组 里边的值全部都是数字，将二维数组中每一个数字 计算 相加之和
var arr = [[32,32,545],4234,423,[5,45,75,326,423,],434,[11,22,33]]
// 编写一个函数，传入 数组作为参数， 返回计算结果
function sum(a){
var s = 0;;
for(var i=0;i<a.length;i++){
// console.log(a[i]);
if(Array.isArray(a[i])){
for(var j=0;j<a[i].length;j++){
s += a[i][j];
}
}else{
s += a[i];
}
}
return s;
}
var num1 = sum(arr)
console.log(num1); // 6640
console.log(sum([[11,22],33,[44,55],66])); // 231
console.log(sum([[1,2,3],[4,5,6],[7,8,9,10]])); // 55
// 定义一个数组,
// 最终的长度需要为30，
// 按顺序分别赋予从2开始的偶数为值；(通过遍历数组为数组的每一项赋值) push()
// 然后按顺序每五个数求出一个平均值，放在另一个数组中并输出
// var arr1 = [2,4,6,8,10,12,....,60]
// var arr2 = [6,...]
var arr1 = [];
for(var n=1;n<=30;n++){
arr1.push(n*2);
}
console.log(arr1); // [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60]
var arr2 = [];
var he = 0; // 计算 数字相加之和
var ji = 0; // 计数 给 he加了几个值
for(var m in arr1){
he += arr1[m];
ji++;
if(ji%5===0){
arr2.push(he/5);
he = 0;
}
}
console.log(arr2); // [6, 16, 26, 36, 46, 56]
// 通过循环按照顺序为一个 5*5的二维数组arr赋值1-25的整数，然后输出该数组的左下半三角
// 1、循环赋值得到的数组为
// [
// [1,2,3,4,5],
// [6,7,8,9,10],
// [11,12,13,14,15],
// [16,17,18,19,20],
// [21,22,23,24,25]
// ]
// debugger;;
var narr = [];
var numarr = [];
for(var o=1;o<=25;o++){
numarr.push(o);
if(o%5==0){
narr.push(numarr)
numarr = [];
}
}
console.log(narr); //
// 2、最终输出得到的结果 document.wirte()
// 1+
// 6+7+
// 11+12+13+
// 16+17+18+19+
// 21+22+23+24+25+
for(var h=0;h<narr.length;h++){
for(var g=0;g<=h;g++){
document.write(narr[h][g]+'+');
}
document.write('<br>')
}
</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>
</head>
<body>
<script>
var arr1 = [12,66,true,'haha',12,false,true,999,'world',true,456,'haha'];
console.log(arr1);
// indexOf()
// 查找数组中 被查找的值 第一次出现的索引位置
// 此方法 不会改变 原数组
// 此方法的返回值是
// 如果 数组中 存在这个 被查找值 返回 第一次出现的索引(下标)
// 如果 数组中 不存在这个 被查找值 返回 -1
var a = arr1.indexOf('haha');
console.log(a); // 3
var b = arr1.indexOf(true);
console.log(b); // 2
var c = arr1.indexOf(999);
console.log(c); // 7
var d = arr1.indexOf('hello');
console.log(d); // -1
console.log(arr1);
console.log('-----------------华丽的分割线--------------');
// lastIndexOf()
// 查找数组中 被查找的值 最后一次出现的索引位置
// 此方法 不会改变 原数组
// 此方法的返回值是
// 如果 数组中 存在这个 被查找值 返回 最后一次出现的索引(下标)
// 如果 数组中 不存在这个 被查找值 返回 -1
var e = arr1.lastIndexOf('haha');
console.log(e); // 11
var f = arr1.lastIndexOf(true);
console.log(f); // 9
var g = arr1.lastIndexOf(999);
console.log(g); // 7
var h = arr1.lastIndexOf('hello');
console.log(h); // -1
console.log(arr1);
</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>
</head>
<body>
<script>
var arr1 = [12,66,true,'haha',12,false,true,999,'world',true,456,'haha'];
console.log(arr1);
var arr = [];
for(var i in arr1){
if(arr.indexOf(arr1[i]) === -1){
arr.push(arr1[i]);
}
}
console.log(arr); // [12, 66, true, 'haha', false, 999, 'world', 456]
// 封装 实现数组去重的 方法
function notRepetition(narr){
var arr = [];
for(var i in narr){
if(arr.indexOf(narr[i]) === -1){
arr.push(narr[i]);
}
}
return arr;
}
var a1 = notRepetition([1,2,3,4,1,3,4,5,3,2,6]);
console.log(a1); // [1, 2, 3, 4, 5, 6]
</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>
</head>
<body>
<script>
var arr1 = [1,2,3,4,5];
console.log(arr1);
var arr2 = ['a','b','c','d'];
console.log(arr2);
var arr3 = [true,false,'haha',999];
console.log(arr3);
// concat()
// 将 多个数组 合并为 一个数组
// 此方法 不会改变 原数组
// 此方法的返回值是 拼接合并后的数组
var a = arr1.concat(arr2);
console.log(a); // [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd']
console.log(arr1); // [1, 2, 3, 4, 5]
var b = arr3.concat(arr1,arr2);
console.log(b); // [true, false, 'haha', 999, 1, 2, 3, 4, 5, 'a', 'b', 'c', 'd']
console.log(arr3); // [true, false, 'haha', 999]
</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>
</head>
<body>
<script>
// slice()
// 通过 传入参数(索引) 实现 对于数组的截取
// 第一个参数：表示开始截取数组的 索引(下标)，包含此索引位置
// 第二个参数：表示结束截取数组的 索引(下标)，不包含此索引位置
// 第二个参数可以忽略不写，如果没有第二个参数
// 则从 第一个参数索引位置截取到数组的结束
// 第二个参数 可以为 负值
// 数组的最后一项值的索引就对应-1，依次往前推算
// 第二个参数的索引对应的值都不能在第一个参数的索引之前
// 此方法 不会改变 原数组
// 此方法的返回值是 截取数组的值组成的新数组
var arr1 = [11,22,'aa','bb','cc',true,666,999,false];
console.log(arr1);
var a = arr1.slice(3);
console.log(a); // ['bb','cc',true,666,999,false]
var b = arr1.slice(5,7);
console.log(b); // [true,666]
var c = arr1.slice(2,6);
console.log(c); // ['aa','bb','cc',true]
var d = arr1.slice(4,-6);
console.log(d); // ['cc',true,666]
console.log(arr1); // [11, 22, 'aa', 'bb', 'cc', true, 666, 999, false]
console.log('-----------------华丽的分割线--------------');
// splice()
// 删除-替换：从 数组中 删除指定个数的元素(值)，同时可以对被删除的部分进行替换操作
// 第一个参数：表示开始删除数组的 索引(下标)，包含此索引位置
// 第二个参数：表示删除数组值的个数
// 第二个参数可以忽略不写，如果没有第二个参数
// 则从 第一个参数索引位置删除到数组的结束
// 第三个参数及以后的每个参数：
// 都是 用来实现 替换 被删除的部分
// 第二个参数 和 第三个参数及以后的参数 都不是必传，可忽略
// 此方法 会改变 原数组
// 此方法的返回值是 由数组被删除的部分组成的新数组
var arr2 = [11,22,'aa','bb','cc',true,666,999,false];
console.log(arr2);
var aa = arr2.splice(3);
console.log(aa); // ['bb', 'cc', true, 666, 999, false]
console.log(arr2); // [11, 22, 'aa']
var arr3 = [11,22,'aa','bb','cc',true,666,999,false];
console.log(arr3);
var bb = arr3.splice(3,3);
console.log(bb); // ['bb', 'cc', true]
console.log(arr3); // [11, 22, 'aa', 666, 999, false]
var arr4 = [11,22,'aa','bb','cc',true,666,999,false];
console.log(arr4);
var cc = arr4.splice(5,2,'haha','hehe','heihei','enen');
console.log(cc); // [true, 666]
console.log(arr4); // [11, 22, 'aa', 'bb', 'cc', 'haha', 'hehe', 'heihei', 'enen', 999, false]
</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>
</head>
<body>
<script>
// toString()
// 将数组转换成字符串
// 此方法 不会改变 原数组
// 此方法的返回值是 转换后的字符串(将中括号去掉对中括号内部的内容添加了引号)
var arr1 = [11,22,'aa','bb','cc',true,666,999,false];
console.log(arr1)
var str1 = arr1.toString();
console.log(str1); // '11,22,aa,bb,cc,true,666,999,false'
console.log(arr1); // [11, 22, 'aa', 'bb', 'cc', true, 666, 999, false]
console.log('-----------------华丽的分割线--------------');
// join
// 将数组的 值 拼接成 字符串
// 此方法 不会改变 原数组
// 此方法的返回值是 转换后的字符串
var arr2 = [11,22,'aa','bb','cc',true,666,999,false];
console.log(arr2)
// 如果 不传参 和 toString() 方法转换的结果是一样的
var str21 = arr2.join();
console.log(str21); // '11,22,aa,bb,cc,true,666,999,false'
// 如果传入 就会 使用 参数 将 数组的每一项值 进行 拼接 字符串
var str22 = arr2.join(true);
console.log(str22); // 11true22trueaatruebbtruecctruetruetrue666true999truefalse
var str23 = arr2.join(':');
console.log(str23); // '11:22:aa:bb:cc:true:666:999:false'
console.log(arr2); // [11, 22, 'aa', 'bb', 'cc', true, 666, 999, false]
</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>
</head>
<body>
<script>
// forEach()
// 用于遍历数组的方法
// 传入一个函数作为参数，这个函数有 三个形参
// 第一个形参：是表示 数组的 元素(值)
// 第二个形参：是表示 数组值的 索引(下标)
// 第三个形参：是表示 数组本身
// 此方法 不会改变 原数组
// 此方法 没有返回值 也就是说返回值是undefined
var arr1 = [11,22,'aa','bb','cc',true,666,999,false];
console.log(arr1)
var nn = arr1.forEach(function(a,b,c){
console.log(a,b,c);
});
console.log(nn); // undefined
console.log(arr1); // [11, 22, 'aa', 'bb', 'cc', true, 666, 999, false]
var numarr = [2,5,8,9,34,12];
console.log(numarr);
var sum = 0;
numarr.forEach(function(item,index,narr){
sum += item;
});
console.log(sum);
</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>
</head>
<body>
<script>
// filter()
// 过滤数组中 符合条件的 值
// 传入一个函数作为参数，这个函数有 三个形参
// 第一个形参：是表示 数组的 元素(值)
// 第二个形参：是表示 数组值的 索引(下标)
// 第三个形参：是表示 数组本身
// 参数函数中 return 表达式
// 此方法 不会改变 原数组
// 此方法的返回值是
// 参数函数中 return 的表达式 结果 为 true 的 值 组成的 新数组
var numarr = [45,2,66,4,77,12,44,99,77];
console.log(numarr);
var numarr50 = numarr.filter(function(item,index,narr){
return item>=50;
});
console.log(numarr50); // [66, 77, 99, 77]
console.log(numarr); // [45, 2, 66, 4, 77, 12, 44, 99, 77]
</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>
</head>
<body>
<script>
// map()
// 映射数组
// 传入一个函数作为参数，这个函数有 三个形参
// 第一个形参：是表示 数组的 元素(值)
// 第二个形参：是表示 数组值的 索引(下标)
// 第三个形参：是表示 数组本身
// 参数函数中 return 运算表达式
// 此方法 不会改变 原数组
// 此方法的返回值是
// 参数函数中 return 的表达式 每一值参数计算后 结果 组成的 新数组
var numarr = [45,2,66,4,77,12,44,99,77];
console.log(numarr);
var abc = numarr.map(function(item,index,narr){
return item*2; // '*'+item;
});
console.log(abc); // [90, 4, 132, 8, 154, 24, 88, 198, 154]
console.log(numarr); // [45, 2, 66, 4, 77, 12, 44, 99, 77]
</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>
</head>
<body>
<script>
var numarr1 = [44,12,66,39,99,22,8,3];
console.log(numarr1); // [44,12,66,39,99,22,8,3]
// 12 44
// 44 66
// 39 66
// 66 99
// 22 99
// 8 99
// 3 99
// [12,44,39,66,22,8,3,99]
// 12 44
// 39 44
// 44 66
// 22 66
// 8 66
// 3 66
// [12,39,44,22,8,3,66,99]
// 12 39
// 39 44
// 22 44
// 8 44
// 3 44
// [12,39,22,8,3,44,66,99]
// 12 39
// 22 39
// 8 39
// 3 39
// [12,22,8,3,39,44,66,99]
// 12 22
// 8 22
// 3 22
// [12,8,3,22,39,44,66,99]
// 8 12
// 3 12
// [8,3,12,22,39,44,66,99]
// 3 8
// [3,8,12,22,39,44,66,99]
// 规律：
// 有 多少个值参与比较，我们总共比较的轮数 是 值的个数-1 次
// 每进行一轮比较，下一次的比较次数都会比上一次的比较次数 少1次
// 有 多少个值参与比较，我们每一轮比较的次数 都是 值的个数-1 次
// 控制 最终的比较 轮数
for(var i=0;i<numarr1.length-1;i++){ // 2
// 控制 每一轮的比较次数
for(var j=0;j<numarr1.length-1-i;j++){
// 判断 当前这一个 是否 大于 下一个值
// 如果 成立 就需要 交换位置
if(numarr1[j] > numarr1[j+1]){
// 交换位置
var x = numarr1[j];
numarr1[j] = numarr1[j+1];
numarr1[j+1] = x;
}
}
}
console.log(numarr1); // [3, 8, 12, 22, 39, 44, 66, 99]
// 封装 冒泡排序 的方法
function bubblingSort(numarr){
// 控制 最终的比较 轮数
for(var i=0;i<numarr.length-1;i++){ // 2
// 控制 每一轮的比较次数
for(var j=0;j<numarr.length-1-i;j++){
// 判断 当前这一个 是否 大于 下一个值
// 如果 成立 就需要 交换位置
if(numarr[j] > numarr[j+1]){
// 交换位置
var x = numarr[j];
numarr[j] = numarr[j+1];
numarr[j+1] = x;
}
}
}
return numarr;
}
var sarr1 = bubblingSort([2,8,3,6,5,1,7,4]);
console.log(sarr1); // [1, 2, 3, 4, 5, 6, 7, 8]
</script>
</body>
</html>
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
