js 数组练习

认识数组是引用类型

var arr1 = [3, 5, 7, 8, 2]; // arr1 中存放的是地址
var arr2 = arr1; // arr2 中存放的是地址
arr2[0] = 5;
arr1 === arr2; // => true
arr1[0], arr2[0]; // => 5 5

由于数组本质上就是一个对象，数组的变量名存放的是该引用类型的地址，在赋值时，赋的也就是地址，即：在这个案例中 arr1、arr2 指向的是同一块内存空间。

使用 slice 克隆一个数组（产生一个全新的对象）

var arr1 = [3, 5, 7, 8, 2];
var arr2 = arr1.slice();
arr2[0] = 5;
console.log(arr1 === arr2); // false
console.log(arr1[0], arr2[0]); // 3 5

在这个案例中，arr2 是一个由 arr1 克隆而来的全新的数组，arr1、arr2 指向的内存空间不再是同一块了。

数组求和

var arr = [3, 7, 6, 4, 5];
var sum = 0;
for (var i = 0; i < arr.length; i++) {
  sum += arr[i];
}
sum; // => 25

逻辑很简单，就是遍历数组的每一项，然后将每一项累加到一个变量中。

二维数组

// 3*3的二维数组
var arr = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];
// 输出二维数组的每一项
for (var i = 0; i < arr.length; i++) {
  for (var j = 0; j < arr[i].length; j++) {
    console.log(arr[i][j]);
  }
}
// 对二维数组求和
var sum = 0;
for (var i = 0; i < arr.length; i++) {
  for (var j = 0; j < arr[i].length; j++) {
    sum += arr[i][j];
  }
}
console.log(sum); // 45

二维数组：数组中的每一项是一个数组。

需要知道如何遍历一个二位数组。

将数组的每一项进行字符串拼接

var arr = [3, 4, 6, 1, 3];
// 输出：3, 4, 6, 1, 3
var str = "";
for (var i = 0; i < arr.length; i++) {
  str += arr[i];
  if (i < arr.length ### 1) {
    str += ", ";
  }
}
str; // => "3, 4, 6, 1, 3"

使用 join 这个数组 api，可以更轻易地实现相同的效果。

数组.join(拼接的分隔符)

var arr = [3, 4, 6, 1, 3];
var str = arr.join(", ");
str; // => "3, 4, 6, 1, 3"

join() 该函数返回一个字符串，按照我们指定的分隔符，对数组的每一项进行拼接。

数组1.concat(数组2)

var arr1 = [34, 5, 2, 1];
var arr2 = ["abc", "bcd"];
var arr3 = arr1.concat(arr2);
arr1; // => (4) [34, 5, 2, 1]
arr2; // => (2) ["abc", "bcd"]
arr3; // => (6) [34, 5, 2, 1, "abc", "bcd"]

数组1.concat(数组2)，将 数组2 的所有元素拼接到数组1的末尾，产生一个新数组返回，该表达式不会对原数组造成任何影响。

提示用户输入数组的长度，以及数组每一项的值，然后输出该数组

var len = +prompt("请输入数组的长度");
if (isNaN(len) || len < 0) {
  console.log("输入有误");
} else {
  //输入正确
  var arr = []; // var arr = new Array(len);
  for (var i = 0; i < len; i++) {
    // 提示用户输入数组的这一项的值
    arr[i] = prompt("请输入数组第" + (i + 1) + "项的值"); // 若 i + 1 不加括号 那么会先拼接 i 再拼接 1
  }
  console.log(arr);
}

我们需要知道，大多数情况下，数组中的值不是我们自己写死的，而是用户输入的某些值。

初始化一个数字数组，然后求该数组所有项之和

var arr = [1, 2, 3, 3, 3, 2, 1],
  sum = 0;
for (var i = 0; i < arr.length; i++) {
  sum += arr[i];
}
console.log(sum); // 15

初始化一个数字数组，然后输出数组中所有的奇数

var arr = [234, 6, 23, 211, 23];
for (var index in arr) {
  if (arr[index] % 2 !== 0) {
    console.log(arr[index]);
  }
}

初始化一个数字数组，然后输出数组中所有的素数

var arr = [234, 2, 6, 23, 211, 23];
for (var index in arr) {
  // 判断arr[index]是不是素数
  var isFind = false;
  for (var i = 2; i < arr[index] - 1; i++) {
    if (arr[index] % i === 0) {
      isFind = true;
      break;
    }
  }
  if (!isFind && arr[index] >= 2) {
    console.log(arr[index]);
  }
}

让用户输入斐波拉契数列的长度，在控制台中打印该长度的斐波拉契数列

斐波拉契数列是这样一种数列：1 1 2 3 5 8 13 ……

数列前两位为1，第n位=第n-1位+第n-2位

var len = +prompt("请输入斐波拉契数列的长度");
if (isNaN(len) || len < 0) {
  console.log("输入有误");
} else {
  //输入正确
  var arr = [];
  for (var i = 0; i < len; i++) {
    if (i === 0 || i === 1) {
      arr[i] = 1;
    } else {
      arr[i] = arr[i - 1] + arr[i - 2];
    }
  }
  console.log(arr);
}

定义一个用户数组，数组的每一项是一个用户对象，用户对象中包含账号和密码，随意初始化一些对象放入数组中。然后提示用户输入账号和密码，判断是否登录成功

var users = [{
    loginId: "abc",
    loginPwd: "123"
  },
  {
    loginId: "abc1",
    loginPwd: "1234"
  },
  {
    loginId: "abc2",
    loginPwd: "1235"
  },
  {
    loginId: "abc3",
    loginPwd: "1236"
  }
];
var loginId = prompt("请输入账号");
var loginPwd = prompt("请输入密码");
// 查找问题
var isFind = false;
for (var i = 0; i < users.length; i++) {
  var u = users[i];
  if (u.loginId === loginId && u.loginPwd === loginPwd) {
    isFind = true;
    break;
  }
}
if (isFind) {
  console.log("登录成功");
} else {
  console.log("登录失败");
}

注意：不能使用 indexOf() 来查找。

var index = user.indexOf({ // 返回值永远都是 -1
  loginId,
  loginPwd
})

indexOf() 比较时用的是严格相等，而对象之间的比较比较的是地址，它们之间的地址是不可能相等的。

即：查找对象时，不能使用 indexOf()。但是，若查找基本类型，是可以使用 indexOf() 的，比如：数字、字符串、…

初始化一个5*5的二维数组，数组每一项是一个数字，计算对角线（两条）之和

var arr = [
  [5, 2, 3, 1, 7],
  [8, 0, 6, 7, 8],
  [4, 0, 6, 2, 0],
  [3, 0, 6, 8, 1],
  [2, 0, 4, 5, 9]
];
// 对角线之和
var sum = 0;
for (var i = 0; i < arr.length; i++) {
  // arr[i] 是一个数组
  for (var j = 0; j < arr[i].length; j++) {
    // arr[i][j]
    if (i === j || i + j === arr.length - 1) {
      sum += arr[i][j];
    }
  }
}
console.log(sum); // 44

难点：如何判断当前成员处于二维数组的对角线上？

• i === j 主对角线
• i + j === arr.length - 1 副对角线