JavaScript学习-数组操作

最新推荐文章于 2024-07-31 08:45:00 发布
最新推荐文章于 2024-07-31 08:45:00 发布
阅读量130 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizengbao/article/details/83182468
版权

文章目录

一、一维数组

1.1 创建数组

1.1.1 直接创建

语法：var arrayName = [元素1,元素2,…,元素n];

var stu = ["张三","李四","王五","赵六","卢大"];

语法：var 数组名=new Array(元素1,元素2,…,元素n);

var stu = new Array("张三","李四","王五","赵六","卢大");

1.1.2 先声明后赋值

语法：var 数组名=new Array();
或者 var 数组名=new Array(length);

var stu = new Array();
// 或者 var stu = new Array(5);
	stu[0] = "张三";
	// 元素赋值
	stu[1] = "李四";
	stu[2] = "王五";
	stu[3] = "赵六";
	stu[4] = "卢大";

1.2 获取

1.2.1 数组长度——length

语法：数组名.length

var stu.length;

1.2.2 数组元素——[]

情况一：只取用一个元素。
语法：数组名[index]

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu[2];
	document.write(stu);
	// 结果为：stu = ["张三","李四","王五","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = "王五"

情况二：向后取用n个。
语法：数组名.splice(index, n)

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.splice(2, 2);
	document.write(stu);
	// 结果为：stu = ["张三","李四","卢大"]
	document.write(stu2);
	// 结果为：stu2 = ["王五","赵六"],此时stu2为数组。

情况三：向前取用n个。
语法：数组名.splice((index + 1)-n, n)
注意：(index + 1)-n >= 0

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.splice((2+1)-2, 2);
	document.write(stu);
	// 结果为：stu = ["张三","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = ["李四","王五"],此时stu2为数组。

情况四：知道开始索引和结束索引。
语法：数组名.slice(start, end)
注意：遵循[start, end) 原理

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.slice(1, 3);
	document.write(stu);
	// 结果为：stu = ["张三","李四","王五","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = ["李四","王五"],此时stu2为数组。

1.2.3 数组元素索引值——indexOf

语法：数组名.indexOf(“数组中的元素”)

var stu = new Array("张三","李四","王五","赵六","卢大");
var wangWuIndex = stu.indexOf("王五");
	document.write(wangWuIndex);
	// 结果为：wangWuIndex = 2
for(i = 0; i < arrayName.length; i++){
	arrayName[i].index=i;              
}

1.3 增加元素——splice

1.3.1 最前面增加——unshift

语法：数组名.unshift(“元素1”,“元素2”)

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.unshift("钱二","陆七");
	document.write(stu);
	// 结果为：stu=["钱二","陆七","张三","李四","王五","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = 7

1.3.2 任意位置增加——splice

语法：数组名.splice(插入位置, 0, “元素1”, “元素2”);
注意：该位置原有元素，会自动向后移动一位。

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.splice(2, 0, "钱二", "陆七");
	document.write(stu);
	// 结果为：stu=["张三","李四","钱二","陆七","王五","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = ""

1.3.3 最后面增加——push

语法：数组名.push(“元素1”,“元素2”)

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.push("钱二","陆七");
	document.write(stu);
	// 结果为：stu=["张三","李四","王五","赵六","卢大","钱二","陆七"]
	document.write(stu2);
	// 结果为：stu2 = 7

1.4 删除元素——splice

1.4.1 最前面删除——splice

语法：数组名.splice(0, 1);

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.splice(0, 1);
	document.write(stu);
	// 结果为：stu=["李四","王五","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = "张三"

1.4.2 任意位置删除——splice

情况一：向后删除
语法：数组名.splice(index, 向后删除元素个数);

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.splice(2, 2);
	document.write(stu);
	// 结果为：stu=["张三","李四","卢大"]
	document.write(stu2);
	// 结果为：stu2 = ["王五","赵六"]

情况二：向前删除
语法：数组名.splice((index + 1) -delForwardNumber, delForwardNumber)
注意：((index + 1) - delForwardNumber) >= 0

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.splice((2+1)-2, 2);
	document.write(stu);
	// 结果为：stu=["张三","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = ["李四","王五"]

1.4.3 最后面删除——pop

语法：数组名.pop()

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.pop();
	document.write(stu);
	// 结果为：stu=["张三","李四","王五","赵六"]
	document.write(stu2);
	// 结果为：stu2 = "卢大"

1.5 替换元素——splice

1.5.1 位置知

语法：数组名.splice(插入位置, 向后删除元素数量, “元素1”, “元素2”);

var stu = new Array("张三","李四","王五","赵六","卢大");
var stu2 = stu.splice(2, 1, "钱二", "陆七");
	document.write(stu);
	// 结果为：stu=["张三","李四","钱二","陆七","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = "王五"

1.5.2 元素知

语法：数组名.splice(插入位置, 向后删除元素数量, “元素1”, “元素2”);

var stu = new Array("张三","李四","王五","赵六","卢大");
var index = stu.indexOf("王五");
var stu2 = stu.splice(index, 1, "钱二", "陆七");
	document.write(stu);
	// 结果为：stu=["张三","李四","钱二","陆七","赵六","卢大"]
	document.write(stu2);
	// 结果为：stu2 = "王五"

1.6 数组拼接——concat

语法：新数组对象.concat(数组1,数组2,数组3,数组4,…,数组n,)

var stu1 = new Array("张三","李四");
var stu2 = new Array("王五","赵六","卢大");
var stu3 = new Array("钱二", "陆七");
	stu1.concat(stu2, stu3);
	document.write(stu1);
	// 结果为：stu1=["张三","李四","王五","赵六","卢大","钱二", "陆七"]

1.7 数组转化字符串——join

语法：数组名.join("")

var stu1 = ["张三","李四","王五","赵六","卢大","钱二", "陆七"];
var str = stu1.join(""); 
	document.write(stu1);
	// 结果为：stu1 = ["张三","李四","王五","赵六","卢大","钱二", "陆七"];
	document.write(str);
	// 结果为：str = "张三李四王五赵六卢大钱二陆七"

1.8 数组排序

1.8.1 倒序排列-reverse

语法： 数组名.reverse();

var stu1 = ["张三","李四","王五","赵六","卢大","钱二", "陆七"];
var stu2  = stu1.reverse();
	document.write(stu1);
	// 结果为：stu1 = ["张三","李四","王五","赵六","卢大","钱二", "陆七"];
	document.write(stu2);
	// 结果为：str = ["陆七","钱二","卢大","赵六","王五","李四","张三"]

1.8.2 升降排序-sort

语法：数组名.sort()

var stu1 = ["张三","李四","王五","赵六","卢大","钱二", "陆七"];
//var stu2 = stu1.sort();
	//document.write(stu1);
	// 卢大,张三,李四,王五,赵六,钱二,陆七
	//document.write(stu2);
	// 卢大,张三,李四,王五,赵六,钱二,陆七
function sortNum1(a,b){return a-b;}
function sortNum2(a,b){return b-a;}
//var stu3 = stu1.sort(sortNum1);
	//document.write(stu3);
	// 张三,李四,王五,赵六,卢大,钱二,陆七
var stu4 = stu1.sort(sortNum2);
	document.write(stu4);
	// 张三,李四,王五,赵六,卢大,钱二,陆七
// ====================================
var stu1 = [1,3,0,5,3,8,9];
var stu2 = stu1.sort();
	document.write(stu1);
	// 0,1,3,3,5,8,9
	//document.write(stu2);
	// 0,1,3,3,5,8,9
//function sortNum1(a,b){return a-b;}
	// 或stu1.sort(function(a,b){return a-b;});
//function sortNum2(a,b){return b-a;}
	// 或stu1.sort(function(a,b){return b-a;});
//var stu3 = stu1.sort(sortNum1);
	//document.write(stu3);
	// 0,1,3,3,5,8,9
//var stu4 = stu1.sort(sortNum2);
	//document.write(stu4);
	// 9,8,5,3,3,1,0

二、二维数组

2.1 创建数组

2.1.1 直接创建

语法：var arrayName = [元素1,元素2,…,元素n];

var stu = [["张三","李四","王五","赵六","卢大"],["张三","李四","王五","赵六","卢大"],["张三","李四","王五","赵六","卢大"]];

2.1.2 先声明后赋值

语法：var 数组名=new Array();

// 先声明一维数组。
var stu = new Array(3);
// 再声明每个一维数组的元素为一个一维数组。注意位置。
	for(var k=0;k<3;k++){
		stu[k]=new Array();
	}
// 给二维数组赋值。
	stu[0][0] = "张三",stu[0][1] = "李四",stu[0][2] = "王五",stu[0][3] = "赵六",stu[0][4] = "卢大";

2.2 获取

2.2.1 元素-[index]

语法：arrayName[index][index];

// 字符串
stu[2][1]
// 数组
stu[2]

2.2.2 元素索引值-indexOf

语法：arrayName[index].indexOf(“查找字符串”);

var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
	document.write(stu[0].indexOf("李四"));
	// 结果为：1
	document.write(stu[0].indexOf("李四3"));
	// 结果为：-1
	document.write(stu[2].indexOf("李四3"));
	// 结果为：1

2.3 增加元素——splice

2.3.1 开头-unshift

// ======================数组=================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.unshift(["钱二","陆七"]);
	console.log(stu1);
	// 结果为：4
	console.log(stu);
	// 结果为：stu = [["钱二","陆七"],["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
// ======================字符串=================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[0].unshift("钱二","陆七");
	console.log(stu1);
	// 结果为：7
	console.log(stu);
	// 结果为：stu = [["钱二","陆七","张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.3.2 任意位置-splice

// ======================数组=================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.splice(1, 0, ["钱二","陆七"]);
	console.log(stu1);
	// 结果为：[]
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["钱二","陆七"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
// ======================字符串=================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[1].splice(1, 0, "钱二","陆七");
	console.log(stu1);
	// 结果为：[]
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","钱二","陆七","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.3.3 末尾-push

// ======================数组=================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.push(["钱二","陆七"]);
	console.log(stu1);
	// 结果为：4
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"],["钱二","陆七"]];
// ======================字符串=================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[0].push("钱二","陆七");
	console.log(stu1);
	// 结果为：7
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大","钱二","陆七"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.4 删除元素——splice

2.4.1 开头

// ======================数组=================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.splice(0, 1);
	console.log(stu1);
	// 结果为：stu1 = ["张三","李四","王五","赵六","卢大"]
	console.log(stu);
	// 结果为：stu = [["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
// ======================字符串=================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[0].splice(1, 1);
	console.log(stu1);
	// 结果为：stu1 = ["李四"]
	console.log(stu);
	// 结果为：stu = [["张三","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.4.2 任意位置

// ======================数组=================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.splice(1, 1);
	console.log(stu1);
	// 结果为：stu1 = ["张三2","李四2","王五2","赵六2","卢大2"]
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三3","李四3","王五3","赵六3","卢大3"]];
// ======================字符串=================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[1].splice(1, 1);
	console.log(stu1);
	// 结果为：stu1 = ["李四2"]
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.4.3 末尾

// ======================数组=================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.splice(2, 1);
	console.log(stu1);
	// 结果为：stu1 = ["张三3","李四3","王五3","赵六3","卢大3"]
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"]]
// ======================字符串=================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[0].splice(4, 1);
	console.log(stu1);
	// 结果为：stu1 = ["卢大"]
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.5 替换元素——splice

// ======================数组=================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.splice(1, 1, ["钱二","陆七"]);
	console.log(stu1);
	// 结果为：stu1 = ["张三2","李四2","王五2","赵六2","卢大2"]
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["钱二","陆七"],["张三3","李四3","王五3","赵六3","卢大3"]];
	stu.splice(1, 1, stu1);
	console.log(stu);
	stu = [["张三","李四","王五","赵六","卢大"],["钱二","陆七"],["张三3","李四3","王五3","赵六3","卢大3"]];
// ======================字符串=================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[0].splice(1, 1, "钱二","陆七");
	console.log(stu1);
	// 结果为：stu1 = ["李四"]
	console.log(stu);
	// 结果为：stu = [["张三","钱二","陆七","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.6 数组拼接——concat+splice

var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu4 = ["钱二4","陆七4"];
var stu5 = ["钱二5","陆七5"];
var stu1 = stu[1].concat(stu4, stu5);
	console.log(stu1);
	// 结果为：stu1 = ["张三2","李四2","王五2","赵六2","卢大2","钱二4","陆七4","钱二5","陆七5"]
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
	stu.splice(1, 1, stu1);
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2","钱二4","陆七4","钱二5","陆七5"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.7 数组转化字符串——join+replace

// ======================数组——join + replace =================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 =stu.join("");
	console.log(stu1);
	// 结果为：stu1 = "张三,李四,王五,赵六,卢大张三2,李四2,王五2,赵六2,卢大2张三3,李四3,王五3,赵六3,卢大3"
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu2 = stu1.replace(/,/g, "");
	console.log(stu2);
	//stu2 = "张三李四王五赵六卢大张三2李四2王五2赵六2卢大2张三3李四3王五3赵六3卢大3"
	console.log(stu1);
	//stu1 = "张三,李四,王五,赵六,卢大张三2,李四2,王五2,赵六2,卢大2张三3,李四3,王五3,赵六3,卢大3"
// ======================字符串——join =================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[1].join("");
	console.log(stu1);
	// 结果为：stu1 = "张三2李四2王五2赵六2卢大2"
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

2.8 数组排序

2.8.1 倒序排列-reverse

语法： 数组名.reverse();

// ====================== 数组 =================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.reverse();
	console.log(stu1);
	// 结果为：stu1 = [["张三3","李四3","王五3","赵六3","卢大3"],["张三2","李四2","王五2","赵六2","卢大2"],["张三","李四","王五","赵六","卢大"]];
	console.log(stu);
	// 结果为：stu = [["张三3","李四3","王五3","赵六3","卢大3"],["张三2","李四2","王五2","赵六2","卢大2"],["张三","李四","王五","赵六","卢大"]];
// ====================== 字符串 =================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[0].reverse();
	console.log(stu1);
	// 结果为：stu1 = ["卢大", "赵六", "王五", "李四", "张三"]
	console.log(stu);
	// 结果为：stu = [["卢大", "赵六", "王五", "李四", "张三"],["张三2", "李四2", "王五2", "赵六2", "卢大2"],["张三3", "李四3", "王五3", "赵六3", "卢大3"]];

2.8.2 升降排序-sort

语法：数组名.sort()

// ====================== 数组 =================
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu.sort();
	console.log(stu1);
	// 结果为：stu1 = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
	console.log(stu);
	// 结果为：stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
// ====================== 字符串 =================	
var stu = [["张三","李四","王五","赵六","卢大"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];
var stu1 = stu[0].sort();
	console.log(stu1);
	// 结果为：stu1 = ["卢大", "张三", "李四", "王五", "赵六"]
	console.log(stu);
	// 结果为：stu = [["卢大", "张三", "李四", "王五", "赵六"],["张三2","李四2","王五2","赵六2","卢大2"],["张三3","李四3","王五3","赵六3","卢大3"]];

// ====================== 数组 =================
var stu = [[1,2,3,4,5],[6,7,8,10,9],[11,13,15,16,17]];
var stu1 = stu.sort();
	console.log(stu1);
	// 结果为：stu1 = [[1,2,3,4,5],[11,13,15,16,17],[6,7,8,10,9]];
	console.log(stu);
	// 结果为：stu = [[1,2,3,4,5],[11,13,15,16,17],[6,7,8,10,9]];
// ====================== 字符串 =================	
var stu = [[1,2,3,4,5],[6,7,8,10,9],[11,13,15,16,17]];
var stu1 = stu[0].sort();
	console.log(stu1);
	// 结果为：stu1 = [10, 6, 7, 8, 9]
	console.log(stu);
	// 结果为：stu = [[1,2,3,4,5],[10, 6, 7, 8, 9],[11,13,15,16,17]];	

function sortNum1(a,b){return a-b;}
function sortNum2(a,b){return b-a;}
// ====================== 升序 =================
var stu = [[1,2,3,4,5],[6,7,8,10,9],[11,13,15,16,17]];
var stu1 = stu[1].sort(sortNum1);
	console.log(stu1);
	// 结果为：stu1 = [6, 7, 8, 9, 10]
	console.log(stu);
	// 结果为：stu = [[1,2,3,4,5],[6, 7, 8, 9, 10],[11,13,15,16,17]];
// ====================== 降序 =================
var stu = [[1,2,3,4,5],[6,7,8,10,9],[11,13,15,16,17]];
var stu1 = stu[1].sort(sortNum2);
	console.log(stu1);
	// 结果为：stu1 = [10, 9, 8, 7, 6]
	console.log(stu);
	// 结果为：stu = [[1,2,3,4,5],[10, 9, 8, 7, 6],[11,13,15,16,17]];
绝世小熊熊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript--学习笔记--数组
m0_65371373的博客
02-09 859
个人学习笔记
【JavaScript】-- 数组介绍（超详细）
qq_48802092的博客
08-14 789
JS中的数组就是一个有序列表的集合，用于存放多个值。
js动态获取数据数组
qq_25598453的博客
01-14 2586
利用“[]”来动态获取指定的字段数据 var a = [&amp;amp;quot;id&amp;amp;quot;,&amp;amp;quot;name&amp;amp;quot;,&amp;amp;quot;age&amp;amp;quot;]; var b = [{&amp;amp;quot;id&amp;amp;quot;:1,&amp;amp;quot;name&amp;amp;quot;:&amp;
【js】内置对象array的常见方法的使用
tyrantForever的博客
07-25 151
<html> <head> </head> <script type="text/javascript"> //数组 var stuName1 = new Array(); stuName1[1] = "小强1"; stuName1[2] = "小强2"; //alert(stu...
javascript学习 - 数组应用
paofuluolijiang的博客
07-31 901
之前的学习中，如果我们要存储一个值，一般都是通过变量来存储。但如果我们现在想要存储一系列的值，又该如何存储呢，你可能会说可以用多个变量来进行存储。这种方法也可以，但如果你想，一旦值过多，那岂不是就要多个变量，到时候管理就很混乱了。这时候就想，有没有一个可以存储多个值的数据结构，方便我们进行多个值的存储管理呢？针对上面这一需求，提出了数组这一数据结构。数组是指一组数据的集合，数组中的每个数据被称为元素，而且数组中可以存放任意类型的元素。
JavaScript--数组学习笔记
weixin_45960356的博客
07-17 189
JavaScript--数组学习笔记
JavaScript学习-数组初识
qq_43368682的博客
07-18 245
JavaScript数组初识简介创建数组方式1、字面量定义2.对象定义（数组的构造函数）关于数组的一些操作1、打印结果2、数组长度操作3、数组元素操作4、循环打印数组 简介 想要存储多个值，就可以使用数组，数组（Array）属于内置对象。 数组的元素可以是任意的数据类型，也可以是对象，也可以是函数，也可以是数组。 数组的元素中，如果存放的是数组，我们就称这种数组为二维数组。 创建数组方式 1、字面量定义 var city=["广州","上海","北京","扬州"]; console.log(city);
JavaScript基础--数组
JJ_Smilewang的博客
04-28 389
根据前面所学，我们知道，变量可以储存值，但是一次只能储存一个值，可是事实中，有时我们需要储存很多值，比如储存一个班所有学生的成绩，这时变量就无法作用了。我们需要请出JS中一个新的内容---数组（Array）。 数组：指的是一组数据的集合，集合中每个数据称为元素，数组中可以存放任意类型的元素，但是我们一般同一个数组放相同类型的数据。 // 普通变量一次只能存储一个值 var num=100; // 数组一次可以存储多个值 var arr=[100,96,88,90]; 1. 创建数组 JS中给我
JavaScript-数组（Array）
StupidlyGrass的博客
01-16 4851
JavaScript数组（Array）
JavaScript-数组
m0_64105917的博客
06-13 570
数组
JavaScript-数组-循环-bloco-4.2
02-18
在JavaScript编程语言中，数组是一种数据结构，它允许我们存储多个值在一个单一的变量中。在处理数组时，循环是必不可少的操作，它...通过这样的学习，开发者可以更好地掌握JavaScript中处理数组的方法，提升编程能力。
js代码-数组操作实践
07-16
在提供的`main.js`文件中，可能包含了具体实现这些数组操作的示例代码，而`README.txt`文件可能对这些示例进行了简要说明，学习时可以结合这两个文件加深理解。通过实践，你将更深入地掌握JavaScript中的数组操作。
03--数组.pptx
11-05
【数组】是编程语言中非常基础且重要的数据结构，它允许我们存储一组具有相同类型的数据。在本课中，我们将深入理解数组的概念、创建...通过深入学习数组，我们可以更有效地管理和处理数据，提升代码的效率和可读性。
js代码-数组对象根据某个值相同合并分组
07-14
在JavaScript编程中，数组对象的处理是常见的任务之一。当我们需要根据数组中对象的某个特定属性值进行分组和合并时...在阅读和学习`main.js`文件时，应重点研究`reduce()`的实现逻辑以及如何根据特定属性值进行操作。
JavaScript学习笔记之数组基本操作示例
10-17
本篇学习笔记将深入探讨JavaScript数组的基本操作，包括定义、连接、排序、添加、删除和修改元素。 一、数组定义 在JavaScript中，定义数组有以下两种方式： 1. 直接通过方括号[]创建：`var a = [1, 2, 3];` 2. ...
基于ASP.NET+MVC5+EF6开发企业网站.zip
08-22
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助 【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无VIP，此资源可私信获取】 【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能 #注 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担 2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于整理和收集资料耗费时间的酬劳 3. 积分资源不提供使用问题指导/解答
Steam家庭共享同时玩工具.bat
最新发布
08-22
Steam家庭共享：两个人同时玩同一个游戏
基于Mysql和JAVA的股票交易系统.zip
08-22
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助 【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无VIP，此资源可私信获取】 【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能 #注 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担 2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于整理和收集资料耗费时间的酬劳 3. 积分资源不提供使用问题指导/解答
这个库用于存储及在组内共享《肖像印》项目数据.zip
08-22
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助 【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无VIP，此资源可私信获取】 【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能 #注 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担 2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于整理和收集资料耗费时间的酬劳 3. 积分资源不提供使用问题指导/解答
JavaScript语法基础-数组元素访问
在数组操作方面，JavaScript 提供了访问数组元素的方法。数组是一种数据结构，可以存储多个值。访问数组元素通常通过索引完成，索引是从0开始的整数。例如，如果有一个名为 `emp` 的数组，可以通过 `emp["Ryan Dias...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值