Javascript学习之数组

数组

数组(array)是一个有序的数据集合，我们可以通过数组名称(name)和索引(index)进行访问。

创建数组

let arrAge = new Array(20,21,22,23,24,21,20);
let arrAge2 = Array(20,21,22,23,24,21,20);
let arrAge3 = [20,21,22,23,24,21,20];

填充数组

let arrDemo = [];
arrDemo[0] = "java";
arrDemo[1] = "python";
arrDemo[2] = "javaScript";
console.log(arrDemo);   // [ 'java', 'python', 'javaScript' ]

访问数组元素

可以通过方括号[ ]来访问数组元素。

let subj = ['java','python','javaScript'];
console.log(subj[1]);   // python
console.log(subj['length']);  // 3

遍历数组

// 遍历数组
let arrNum = [12,13,14,15,16];
for(let i=0; i < arrNum.length; i++){
    console.log(arrNum[i]);
}

for (let key in arrNum) {
    console.log(arrNum[key]);   // key 为索引
}

for(let key of arrNum){
    console.log(key);    // key 为值
}

//其他方式参考对象方法中相关方法

数组对象方法

  • concat() ------用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组
let subject = ['java','python'];
let city = ['北京','上海','深圳','广州'];
let flower = ['兰花','梅花','茉莉花'];
let sum = subject.concat(city,flower);
console.log(sum);

  • push() ------将一个或多个元素添加到数组的末尾，并返回该数组的新长度
let fruit = ['apple','orange','strawberry'];
console.log(fruit);     // [ 'apple', 'orange', 'strawberry' ]
let f1 = fruit.push('banana');
let f2 = fruit.push('watermelon ');
console.log(f1);        // 4
console.log(f2);        // 5
console.log(fruit);     // [ 'apple', 'orange', 'strawberry', 'banana', 'watermelon ' ]
  • unshift() ------向数组的开头添加一个或更多元素，并返回新的长度
let fruit_1 = ['apple','orange','strawberry'];
console.log(fruit_1);     // [ 'apple', 'orange', 'strawberry' ]
let f1_1 = fruit_1.unshift('banana');
let f2_1 = fruit_1.unshift('watermelon');
console.log(f1_1);        // 4
console.log(f2_1);        // 5
console.log(fruit_1);     // [ 'watermelon ', 'banana', 'apple', 'orange', 'strawberry' ]
  • pop() ------删除并返回数组的最后一个元素
let fruit_2 = ['apple','orange','strawberry'];
let f1_2 = fruit_2.pop();
console.log(f1_2);      // strawberry     
console.log(fruit_2);        // [ 'apple', 'orange' ]
  • shift()  ------删除并返回数组的第一个元素
let fruit_3 = ['apple','orange','strawberry'];
let f1_3 = fruit_3.shift();
console.log(f1_3);      // apple     
console.log(fruit_3);        // [ 'orange', 'strawberry' ]
  • splice() ------从数组中添加或删除元素
let fruit_4 = ["Banana", "Orange", "Apple", "Mango"];
let f1_4 = fruit_4.splice(2,2);     //删除元素，第一个元素为开始的索引，第二个参数为长度
console.log(f1_4);  // [ 'Apple', 'Mango' ]
console.log(fruit_4);    //[ 'Banana', 'Orange' ]

let fruit_5 = ["Apple", "Orange", "Mango"];
let f2_5 = fruit_5.splice(2,0,"Pear","Peach"); // 添加元素
console.log(fruit_5);    //[ 'Apple', 'Orange', 'Pear', 'Peach', 'Mango' ]
  • join() ------将一个数组的所有元素连接成一个字符串并返回这个字符串
let subject2 = ['java','python','javaScript','C++'];
let joinSub = subject2.join('---');
console.log(joinSub);       // java---python---javaScript---C++
  • indexOf() ------返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回 -1
  • lastIndexOf() ------返回在数组中可以找到一个给定元素的最后一个索引，如果不存在，则返回 -1
let num = [100,99,98,97,99,100,96,99,100];
console.log(num.indexOf(99));   // 1
console.log(num.lastIndexOf(99));   // 7
  • includes() ------判断一个数组是否包含指定的值
let num_1 = [100,99,98,97,99,100,96,99,100];
console.log(num_1.includes(100));   // true
console.log(num_1.includes(90));    // false
  • isArray() ------判断对象是否为数组
let num_2 = [100,99,98,97,99,100,96,99,100];
let str = 'javaScript';
console.log(Array.isArray(num_2));  // true
console.log(Array.isArray(str));    // false
  • slice() ------选取数组的一部分，并返回新的数组
let num_3 = [100,99,98,97,99,100,96,99,100];
let sliceNum = num_3.slice(2,7);
console.log(sliceNum);
  • reverse() ------反转数组的元素顺序
let fruit_6 = ["Apple", "Orange", "Mango"];
console.log(fruit_6.reverse()); // [ 'Mango', 'Orange', 'Apple' ]
  • copyWithin() -------浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度
var subject3 = ["python", "java","javascript","c++"];
var copy1 = subject3.copyWithin(2,0)    // 将索引0的元素拷贝到索引2位置
console.log(copy1);        // [ 'python', 'java', 'python', 'java' ]
  • entries() ------返回数组的可迭代对象，该对象包含数组的键值对
let fruit_7 = ["Banana", "Orange", "Apple", "Mango"];
for (let [key, value] of Object.entries(fruit_7)) {
  console.log([key, value]); 
}
  • every() ------对数组中每一项运行给定函数，如果该数组中每一项都返回true，则返回true，否则返回false
let age = [18,16,23,22,21,19,34,17]
function ageRange(age) {
    return age >= 18;
}
let temp = age.every(ageRange);
console.log(temp);        // false
  • some() ------对数组中每一项运行给定函数，只要该数组中有一项返回true，则返回true，否则返回false
let numList = [23,21,45,22,11,9,34];
function ase(n) {
    return n > 20;
}
console.log(numList.some(ase));     // true
  • fill() ------使用一个固定的值来填充数组
let fruit_8 = ["Banana", "Orange", "Apple", "Mango"];
let fruit_9 = fruit_8.fill("aaa");
console.log(fruit_9);   // [ 'aaa', 'aaa', 'aaa', 'aaa' ]
  • filter() ------检测所有元素，并返回符合条件的所有元素的数组
let age2 = [18,16,23,22,21,19,34,17];
function filterArray(arg) {
    return arg >= 20;
}
let filterAge = age2.filter(filterArray);
console.log(filterAge);        //[ 23, 22, 21, 34 ]
  • find() ------返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined
  • findIndex() ------返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1
let age3 = [18,16,23,22,21,19,34,17];
function filterArray3(arg) {
    return arg >= 20;
}
console.log(age3.find(filterArray3));            //23
console.log(age3.findIndex(filterArray3));      //2
  • forEach() ------数组每个元素都执行一次回调函数
let numEach = [1,2,3,4,5,6];
let calNum;
function cacul(arg){
    calNum = arg*arg;
    console.log(calNum);
}
numEach.forEach(cacul);
  • from() ------通过拥有 length 属性的对象或可迭代的对象来返回一个数组
let setObj = "python";
let objArr = Array.from(setObj);
console.log(objArr);    //[ 'p', 'y', 't', 'h', 'o', 'n' ]
  •  keys() ------返回数组的可迭代对象，包含原始数组的键(key)，对象是数组返回 true，否则返回 false
let arr = ['a', 'b', 'c'];
let iterator = arr.keys();
console.log(iterator.next()); // { value: 0, done: false }

// map() ------通过指定函数处理数组的每个元素，并返回处理后的数组
let numL = [1,2,3,4,5];
function calcu(x){
    return x*x;
}
let res = numL.map(calcu);
console.log(res);   //[ 1, 4, 9, 16, 25 ]
  • reduce() ------将数组元素计算为一个值（从左到右）
  • reduceRight() ------将数组元素计算为一个值（从右到左）
let numL2 = [1,2,3,4,5,6,7,8,9,10,11];
function calcu2(num,total){
    return num + total;
}
let res2 = numL2.reduce(calcu2);
console.log(res2);  //66
  • sort() ------对数组元素进行排序,默认按照字符串UniCode码的顺序进行排序的。sort()可以接收一个比较函数来实现自定义的排序。比较函数应该具有两个参数 a 和 b，返回 a-b 升序，返回 b-a 降序。
let fs = ["Banana", "Orange", "Apple", "Mango"];
fs.sort();      //默认排序顺序为按字母升序
console.log(fs);    //[ 'Apple', 'Banana', 'Mango', 'Orange' ]

let numList2 = [23,21,45,22,11,9,34];
function sortN(a,b){
    return a-b;
}
let res3 = numList2.sort(sortN);
console.log(res3);
  • toString() ------把数组转换为字符串，并返回结果
let arrN = [1,2,3,4,5];
console.log(arrN.toString());   // 1,2,3,4,5
posted @ 2021-11-16 16:41  rissa  阅读(39)  评论(0)    收藏  举报

记录学习笔记，会有很多是参考重复，如有侵权，联系删除