创建和初始化数组

方法一:使用new关键字创建数组(用new创建数组并不是好的方式)
let daysOfWeek = new Array(); //使用new关键字声明并初始化数组
daysOfWeek = new Array(7); //创建一个指定长度的数组
daysOfWeek = new Array('Sunday','Monday','Tuesday'); //直接将数组元素作为参数传递给他的构造器
方法二: 在JavaScript中只用中括号形式创建数组就行[ ]
let daysOfWeek = []; //创建一个空数组
let daysOfWeek = ['Sunday','Monday','Tuesday']; //创建并初始化数组

访问元素和迭代数组

//求斐波那契数列的前20个数,已知斐波那契数列中的前两项是1,从第三项开始,每一项都等于前两项之和
    const fibonacci = [];//创建一个空数组
    fibonacci[1] = 1; // 从数组第二个开始放斐波那契数列
    fibonacci[2] = 1;
    for(let i = 3; i < 20; i++){  //循环得到第三到第二十的数
        fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
    } 
    for (let i = 1; i < fibonacci.length; i++){// 最后循环迭代数组各个元素
        console.log(fibonacci[i]);
    }

添加元素

在JavaScript中的数组是可以修改的对象 想要添加元素就可以动态增长

在数组末尾插入元素

1.如果想在数组末尾插入元素,只要把值赋给最后一个空位上的元素
let number = [0,1,2,3,4,5,6,7,8,9];number[number.length] = 10; //number的最后一个赋值为10

2.可以使用push方法 ,能把元素添加到数组的末尾能添加任意个元素
number.push(11);number.push(12,13); //输出number,返回的是数组长度Array(14)

在数组开头插入元素

  • 想要在数组开头插入一个新元素-1。
  • 为了实现这个需求,我们首先将数组中的第一个位置腾出,把所有元素向右移一个位置。我们可以循环数组中的元素,从最后一个位开始,将对应的前一个元素(i -1)的值赋给它(i),依次处理,最后把我们想要的值赋值给索引 0 的位置。
  • 我们将这段逻辑写成函数,将该方法直接添加到Array放入原型上。
Array.prototype.insertFirstPosition = function (value) {
            for (let i = this.length; i >= 0; i--) {
                this[i] = this[i - 1];
            }
            this[0] = value;
        }
        number.insertFirstPosition(-1);
        console.log(number);

Java中实现结构体数组_javascript


使用unshift方法:

unshift方法可以直接把数值插入数组开头

number.unshift(-2);//在数组头部插入-2 number.unshift(-2,-3);//按照顺序插入

删除元素

在数组末尾删除元素

  • 要删除数组里最靠后的元素,可以用pop方法
    number.pop();

在数组开头删除元素
使用shift方法:

  • 要删除数组的第一个元素,可以使用shift方法实现
    number.shift();

在任意位置添加或删除元素

  • 使用splice方法,简单地通过指定位置、索引,就可以删除相应位置上指定数量的元素
    number.splice(0,1); 这行代码删除了从数组索引0开始的2个元素(number[0],number[1]两个)
  • 对于JavaScript数组和对象,我们还可以使用delete运算符删除数组中的元素。delete number[0]。数组位置0的值会变成undefined。所以我们还是应该使用splice、pop、或者shift方法来删除数组
  • 想把数0,1插入到数组里,放在之前删除元素的位置上,可以再次使用splice
    number.splice(0,0,0,1) 第一个参数表示:想要删除或插入的元素的索引值。第二个参数是删除元素的个数(这个例子里我们目的不是删除元素,所以传入0)。第三个参数往后就是要添加到数组里的值(0,1)

二维和多维数组

JavaScript只支持一维数组,并不支持矩阵
let averageTemp = [];averageTemp[0] = [1,2,3];averageTemp[1] = [1,2,3];

迭代二维数组的元素如果想看矩阵输出,创建一个通用函数,专门输出其中的值

  • 使用一个嵌套的for循环来处理,其中变量i为行,变量j为列
let averageTemp = [];
        averageTemp[0] = [1,2,3];
        averageTemp[1] = [1,2,3];
        function printMatrix(myMatrix){
            for(let i = 0; i < myMatrix.length; i++){
                for(let j = 0; j < myMatrix[i].length; j++){
                    console.log(myMatrix[i][j]);
                }
            }
        }
        console.table(averageTemp);

多维数组:

  • 我们也可以用这种方式处理多维数组假设我们要创建一个3x3x3的矩阵,每一格里包含矩阵的i(行)、j(列)及z(深度)之和
const matrix3x3x3 = [];
       for(let i = 0; i < 3; i++){
           matrix3x3x3[i] = []; // 初始化每个数组
           for(let j = 0; j < 3; j++){
               matrix3x3x3[i][j] = [];
               for(let z = 0; z < 3; z++){
                   matrix3x3x3[i][j][z] = i + j + z;
               }
           }
       }
    //    用以下代码输出这个矩阵的内容
    for(let i = 0; i < matrix3x3x3.length; i++){
        for(let j = 0; j < matrix3x3x3[i].length; j++){
            for(let z = 0; z < matrix3x3x3[i][j].length; z++){
               console.log(matrix3x3x3[i][j][z]); 
            }
        }
    }

Java中实现结构体数组_javascript_02

JavaScript的数组方法参考

Java中实现结构体数组_数据结构_03

数组合并

  • concat方法:有多个数组需要合并为一个数组。我们可以迭代各个数组,然后把每个元素加入最终的数组
  • concat方法可以向一个数组传递数组,元素或是对象。数组会按照指定参数顺序链接指定数组
    下面例子中顺序是:arr2、zero、arr1
const zero = 0;
      const arr1 = [1,2,3];
      const arr2 = [4,5];
      let number = arr2.concat(zero,arr1);
      console.log(number); //[4,5,0,1,2,3]

迭代器函数

  • JavaScript内置了许多数组可用的迭代方法
  • 假设数组中的值是从1到5;如果数组里的元素可以被2整除,函数就返回true。否则返回false
let number = [1,2,3,4,5];
    function isEven(x){
        console.log(x); //1
        return x % 2 === 0 ? true : false;//也可以写成return (x % 2 === 0 );
    }
    // ES6语法:=>箭头函数
      const isEven = x => x % 2 === 0;
  • 1.用every方法迭代(every方法会迭代数组中的每一个元素,直到返回false)
  • 在这个例子中1不是2的倍数所以返回false 执行结束
number.every(isEven);
  • 2.用some方法迭代(与every相反 会迭代数组的每个元素 直到函数返回true)
  • 在这个例子中 数组第一个偶数是2 打一个被迭代元素是1, 第二个被迭代元素是2,isEven返回true结束
number.some(isEven);//1 2 true
  • 3.用forEach方法迭代:迭代整个数组,它和使用for循环结果相同
let number = [1,2,3,4,5];
    number.forEach(x => console.log(x % 2=== 0));//false true false true false
  • 4.使用map方法
let number = [1,2,3,4,5];
    number.map(x => console.log(x % 2=== 0));//false true false true false
  • 5.使用filter方法(返回的新数组由使函数返回true的元素组成)
let number = [1,2,3,4,5];
   const isEven = x => x % 2 === 0;
   const number2  = number.filter(isEven);
   console.log(number2); //只输出了[2,4]
  • 6.使用reduse方法:(对数组中所有元素求和)
let number = [1,2,3,4,5];
    reducer = (previous,current) => previous + current;
    console.log(number.reduce(reducer));//15
  • reduce() 第二参数为可选参数,会影响 reduce() 最后返回值的格式
console.log(number.reduce(reducer,5));//5+1+2+3+4+5  输出20

ES5和ES6新增的数组方法

Java中实现结构体数组_开发语言_04

  • 1.使用for…of循环迭代
let number = [1,2,3,4,5];
       for (const n of number){
           console.log(n);
       }

for…of遍历循环number中的每一项,迭代项将赋值给变量n

  • 类数组迭代

for…of可以用来迭代类数组对象。arguments是函数体内的特殊变量,包含函数的所有参数

// 写一个求和函数sum{num1,num2,.....numn}
        function sum() {
            let sum = 0;
            for (const n of arguments) {
                sum += n;
            }
            return sum;
        }
        console.log(sum(1, 2, 3, 4));//10

在每次迭代中,for…of循环遍历类数组arguments中的每一个数,并计算总和

// 数组去重
        const s = new Set([1, 2, 3, 4, 5, 4, 3, 1]);
        for (let n of s) {
            console.log(n);
        }

Set对象是值的集合,你可以按照插入的顺序迭代它的元素。 Set中的元素只会出现一次,即 Set 中的元素是唯一的。

  • 2.使用@@iterator对象
  • iterator对象工作原理:创建一个指针对象,指向当前数据结构的起始位置,第一次调用next方法时,指针指向数据结构的第一个成员。接下来调用next方法,指针后移,直到指向最后一个成员

ES5为Array类增加了@@iterator属性,需要通过Symbol.iterator来访问

let number = [1,2,3,4,41,3];
        iterator = number[Symbol.iterator]();
        for(const n of iterator){
            console.log(n);//输出number数组中的每一项
        }
  • 3.entries方法返回键值对

entries方法返回包含键值对的iterator

let number = [1, 2, 3, 4, 41, 3];
        let e = number.entries();
        console.log(e.next().value);//[0,1] 位置0的值1
        console.log(e.next().value);
        console.log(e.next().value);
  • 4.Keys方法返回数组的索引

keys方法会返回number数组的索引。一旦没有可迭代的值,a.next( )就会返回一个value属性为undefined、done属性为true的对象。如果返回done属性的值为false,就意味着还有可迭代的值

let number = [1, 2, 3, 4, 41, 3];
        const a = number.keys();
        console.log(a.next());//{value: 0, done: false}

value是保存在数组索引的值;done:false表示还有可迭代的值

  • 5.value方法返回数组的值
let number = [1, 2, 3, 4, 41, 3];
        const a = number.values();
        console.log(a.next());//{value: 1, done: false}
  • 6.Array.from方法根据已有数组创建一个新数组
let number = [1, 2, 3, 4, 41, 3];
        let number2 = Array.from(number);
        console.log(number2);//[1, 2, 3, 4, 41, 3]
  • 传入一个用来过滤值的函数
let number = [1, 2, 3, 4, 41, 3];
        let number2 = Array.from(number, x => (x % 2 == 0));
        console.log(number2);//[false, true, false, true, false, false]
  • 7.使用Array.of方法根据传入的参数创建一个新数组
let number = [1, 2, 3, 4, 41, 3];
        let number3 = Array.of(1);
        // 等价于
        let number3 = [1];
        console.log(number3);//[1]
  • 用该方法复制数组
let number = [1, 2, 3, 4, 41, 3];
        let number3 = Array.of(...number);
        console.log(number3);//[1, 2, 3, 4, 41, 3]

该方法和from效果是一样的。展开运算符(…)会把number数组里的值都展开成参数

  • 8.使用fill方法用静态值填充数组
  • 填充数组
let number = [1, 2, 3, 4, 41, 3];
        let number3 = Array.of(...number);
        // 所有位置上的值都变成1
        number3.fill(1);
        console.log(number3);//[1, 1, 1, 1, 1, 1]
  • 指定开始索引填充
// 指定开始填充索引
        number3.fill(3,1)//数组中从1开始所有位置上的值都是3
        console.log(number3);// [1, 3, 3, 3, 3, 3]
  • 指定开始结束位置
// 指定结束填充的索引
        number3.fill(1,3,5)//数组中3-5(不包括3)的位置都是1
        console.log(number3);//[1, 3, 3, 1, 1, 3]
  • 创建数组并初始化
// 创建数组并初始化
        let num = Array(7).fill(1);
        console.log(num);//[1, 1, 1, 1, 1, 1, 1]
  • 9.使用copyWithin方法
    copyWithin方法复制数组中的一系列元素到同一指定的起始位置
let number = [1, 2, 3, 4, 41, 3];
        //我们把4,41,3三个值复制到数组前三个位置
        number.copyWithin(0, 3);//把3开始不包括3 的元素复制到 0位置
        console.log(number);//[4, 41, 3, 4, 41, 3]
let number2 = [1, 2, 3, 4, 5, 6, 7];
        number2.copyWithin(1, 2, 5);//将2-5不包括2 的数复制到位置1
        console.log(number2);//[1, 3, 4, 5, 5, 6, 7]

排序元素

  • 1.reverse方法数组元素反转
let number = [1, 2, 3, 4, 41, 3];
        number.reverse();
        console.log(number);//[3, 41, 4, 3, 2, 1]
  • 2.sort方法对数组排序,把元素默认成字符串相互比较
let number = [1, 2, 3,11,12,13];
        number.sort((a,b) => b - a);//降序排序
        number.sort((a,b) => a - b);//升序排序

搜索

搜索有两个方法:
indexof方法返回与参数匹配的第一个元素的索引;
lastIndexof与参数匹配的最后一个元素的索引

let number = [1, 2, 3,11,12,13];
        console.log(number.indexOf(12));//输出4
        console.log(number.indexOf(10));//输出-1 因为没有10
        let number2 = [1,2,3,4,5,3,4,5];
        console.log(number2.lastIndexOf(3));//输出5 输出与之匹配的最后一个元素

输出数组为字符串

  • 1.toString方法把数组所有元素输出为一个字符串
let number = [1, 2, 3,11,12,13];
        console.log(number.toString());//1,2,3,11,12,13
  • 2.join方法可以用一个不同的分隔符(比如-)把元素隔开
let number = [1, 2, 3,11,12,13];
       console.log(number.join('-'));//1-2-3-11-12-13