我的js学习(数组及相关方法)

学习js第四天

引用类型与值类型的区别

1.存储位置
引用类型存在堆内存中
值类型存在栈内存中
变量存储在栈内存中
var a = 10; // 声明了一个变量 存储了10这个值
var b = a; // 又声明了一个变量 把a的值复制了一份 交给b存起来
a = 11; // 把a修改为11时 不会影响到b 依然是10
console.log(b)

2 比较
var arr = [1, 2, 3, 4, 5, 6];
var arr1 = [1, 2, 3, 4, 5, 6];
console.log(arr === arr1) //false
引用类型比较的时候比的是地址

3 复制
var a = [1,2,3,4,5,6,7,7,8]
var b = a;
仅仅是把数组的地址复制了一份交给了b
console.log(a === b); //true
数组 不是数字的组 而是数据组

数组的定义

数组是JS中的引用类型之一
它是一个数据容器。 可以装：字符串、布尔值、数字、undefined、null、函数、数组、对象等.

定义数组

1 构造函数
var arr = Array(1, 2, 3, 4, 5, 6, 7); // new 关键字 可以省略
var arr = new Array(1, 2, 3, 4, 5, 6, 7);

2 为了简化数组的定义 于是JS允许使用简化写法 我们叫做字面量写法 也有叫直接量的
var arr = [5];
console.log(arr);

小bug 当Array的参数只有一个且是数字时，会被当作长度来处理
var arr = new Array(4);
console.log(arr);

数组的数据获取方式

数组的存储方式是以 下标 对应 成员 的结构去存储的
有序排列
下标也叫做索引、序号。 下标从0开始。
比如
var arr = [“a”, “b”];
console.log(arr[0]) //a
console.log(arr[1]) //b

数组的数据存储方式

var arr = [444];
arr[1] = 555;
把555存储到数组的下标1的位置
console.log(arr); // [444, 555]

数组的属性

数组有一个length属性 非常重要
它表示数组的成员的个数 也表示数组的长度
var arr = [“a”, “b”, “c”];
console.log(arr.length); //3
该属性可读可写
arr.length = 0; // 它可以实际改变数组的成员个数
arr.length = 3;
console.log(arr);//[ , , ]

数组的遍历

循环数组 可以使用for循环
var arr = [1, 44, 55, 3, 2, 77, 198, 44];
// 循环数组的时候要注意一点： 数组的最大有效成员下标 是数组的长度 - 1 不能循环到数组的长度
var allScore = 0;
for (var i = 0; i < arr.length; i++) {
console.log(arr[i])
allScore += arr[i]
}
console.log(allScore);
// 总分 / 人数
var avg = allScore / arr.length;
console.log(avg)

// 求任意个数的和
function sum() {
console.log(arguments); // 函数内部有一个内置的东西 它叫做arguments 它是一个类数组对象
var count = 0;
for (var i = 0; i < arguments.length; i++) {
count += arguments[i];
}
return count;
}
sum(1, 2, 777, 999, 888, 3333);
// sum(1, 2, 3)
// sum(1, 2, 3, 5)

数组的方法

数组是一个容器 我们把内容放入容器之后 要对容器内的内容做一些操作
有时也会对数组本身做一些操作
为了方便进行这些操作 JS提供了一些方法 能够让我们简便的达成目的

• push(item) 该方法用于向数组的末尾增加一项
  • item 参数是数组的新成员
  • 返回值是数组的长度

    var arr = [1, 2, 3];
    arr.push(123);
    // arr => [1, 2, 3, 123]

• pop() 该方法用于从数组的末尾移除一项
  • 返回值是被移除的成员

    var arr = [1, 2, 3, 4];
    var item = arr.pop(); 
    // item => 4
    // arr => [1, 2, 3]

• unshift(item) 该方法用于往数组的头部增加一项
  • item 参数是数组的新成员
  • 返回值是数组的长度

    var arr = [1, 2, 3, 4];
    arr.unshift(0); 
    // arr => [0, 1, 2, 3, 4]

• shift() 该方法用于从数组的头部移除一项
  • 返回值是被移除的成员

    var arr = [1, 2, 3, 4];
    var item = arr.shift();
    // item => 1
    // arr => [2, 3, 4]

• concat(arg1, arg2, arg3, …) 拼接
  • 参数个数不定 如果参数中有数组 会把数组拆开
  • 返回值是新数组
  • 不会改变原数组

    var arr = [1, 2];
    var arr1 = arr.concat(3, 4, 5, [6, 7, 8]);
    // arr => [1, 2, 3, 4, 5, 6, 7, 8]

• reverse() 将数组中的每一个成员逆序
  • 返回值是原数组
  • 会把原数组改变

    var arr = [1, 2, 3, 4, 5, 6];
    var arr1 = arr.reverse();
    // arr1 => [6, 5, 4, 3, 2, 1]
    // arr => [6, 5, 4, 3, 2, 1]

• sort 排序方法 通常用于数字 参数是函数 函数中有a b
  • 如果返回a -b 升序排列
  • 如果返回 b - a 降序排列
  • 如果不传递函数 则按照首位数字进行排序

    var arr = [10, 23, 44, 6, 88, 22];
    // 升序
    var arr1 = arr.sort(function(a, b) {
        return a - b;
    }); 
    // arr => [6, 10, 22, 23, 44, 88]
    // arr1 = > [6, 10, 22, 23, 44, 88]


    // 降序
    var arr2 = arr.sort(function(a, b) {
        return b - a;
    });
    // arr => [88, 44, 23, 22, 10, 6]

• slice 用于截取数组中的一段
  • 第一个参数是开始截取的位置
  • 第二个参数是结束截取的位置(不包含该位置的成员)
  • 如果参数是负数 则从后往前数
  • 如果不传递第二个参数 则从第一个参数截取到最后
  • 如果没有参数 就截取全部

    var arr = [11, 22, 33, 44];
    // 两个参数
    var arr1 = arr.slice(0, 3);
    // arr1 => [11, 22, 33]

    // 一个参数
    var arr2 = arr.slice(2);
    // arr2 => [33, 44]

    // 参数是负数
    var arr3 = arr.slice(-1);
    // arr3 => [44]

    // 没有参数
    var arr4 = arr.slice();
    // arr4 => [11, 22, 33, 44]

• splice 用于数组的增、删、改
  • 第一个参数表示开始操作的位置
  • 第二个参数表示删除的个数
  • 之后的每一个参数都表示数组的新成员(如果是数组 不拆)
  • 如果没有第二个参数 则默认从第一个参数截取到末尾
  • 返回值是被删除的元素组成的数组

    // 增
    var arr = [1, 5];
    var arr1 = arr.splice(1, 0, 2, 3, 4);
    // arr => [1, 2, 3, 4, 5]
    // arr1 => []

    // 删
    var arr = [1, 2, 3, 4, 5];
    var arr1 = arr.splice(1, 3);
    // arr => [1, 5]
    // arr1 => [2, 3, 4]

• join 用于将数组转为字符串
  • 参数是拼接符号 默认为逗号 ,
  • 返回值是拼接完毕的字符串

    var arr = ["a", "b", "c", "d"];
    var str = arr.join();
    // str => "a,b,c,d"
    var str1 = arr.join("&");
    // str1 => a&b&c&d

• indexOf 用于搜索数组中的成员所在位置
  • 参数是成员
  • 返回值是下标位置
    • 如果找得到就是下标位置
    • 如果找不到就是 -1

    var arr = ["a", "b", "c"];
    var idx = arr.indexOf("a");
    // idx => 0