javascript中Array相关的属性和方法

欢迎访问我的博客https://qqqww.com/，祝码农同胞们早日走上人生巅峰，迎娶白富美~~~

目录：

1. Array 对象属性
2. Array 对象方法
   1. concat()
   2. join()
   3. pop()
   4. shift()
   5. push()
   6. unshift()
   7. reverse()
   8. slice()
   9. sort()
   10. splice()
   11. toSource()
   12. toString()
   13. toLocaleString()
   14. valueOf()
3. Array 部分方法实现
   1. 数组元素去重
   2. 数组最值
   3. 数组排序
   4. 数组翻转

Array 对象属性

constructor : 返回对创建此对象的数组函数的引用

var test=new Array()
if (test.constructor==Array){
    document.write("This is an Array")
}

length 设置或返回数组中元素的数目。

prototype 可以向构造函数的原型对象添加属性和方法

Array 对象方法

concat()

连接两个或更多的数组，并返回结果

var arr = [1,2,3,4];
var arr2 = [5,6,7,8];
var arr3 = arr.concat(arr2);
console.log(arr3); // 连接之后返回的数组为：[1, 2, 3, 4, 5, 6, 7, 8]

join()

把数组的所有元素放入一个字符串，元素通过指定的分隔符进行分隔

var arr = ['xiao','lin','qiqi','mingtian'];
var arr2 = arr.join(',');
console.log(arr2); // 根据','隔开返回的字符串为："xiao,lin,qiqi,mingtian"

pop()

删除并返回数组的最后一个元素

var arr = [2,3,4,5];
var arr2 = arr.pop();
console.log(arr2); // 删除的数组的最后一个元素为：5
console.log(arr);  // 删除元素之后的数组为：[2, 3, 4]

shift()

删除并返回数组的第一个元素

var arr = [2,3,4,5];
var arr2 = arr.shift();
console.log(arr2); // 删除的数组的第一个元素为：2
console.log(arr);  // 删除元素之后的数组为：[3, 4，5]

push()

向数组的末尾添加一个或更多元素，并返回新的长度

var arr = [2,3,4,5];
var arr2 = arr.push(6);
console.log(arr2);  // 返回的数组长度：5 
console.log(arr);  // [2, 3, 4, 5, 6]

unshift()

向数组的开头添加一个或更多元素，并返回新的长度

var arr = ['xiao','ming','qiqi','aiming'];
var arr1 = arr.unshift('lang');
console.log(arr1);  // 返回的数组的长度：  5
console.log(arr);  //向数组开头添加元素返回的结果：["lang", "xiao", "ming", "qiqi", "aiming"]

reverse()

颠倒数组中元素的顺序

var arr = [2,3,4,5];
arr.reverse();
console.log(arr);   //  [5, 4, 3, 2]

slice()

从某个已有的数组返回选定的元素

var arr = [2,3,4,5];
var arr2 = arr.slice(1,3);
console.log(arr2);  // 截取区间返回的数组为：[3, 4]
console.log(arr);  // [2, 3, 4, 5]

sort()

对数组的元素进行排序

// 借助排序函数，实现数值由小到大排序
function sortNumber(a,b){
    return a - b
}
var arr = [23,30,42,5];
var arr2 = arr.sort(sortNumber);
console.log(arr2);  // [5, 23, 30, 42]
console.log(arr);   // [5, 23, 30, 42]

// 借助排序函数，实现数值由大到小排序
function sortNumber(a,b){
    return b - a
}
var arr = [23,30,42,5];
var arr2 = arr.sort(sortNumber);
console.log(arr2);  // [42, 30, 23, 5]
console.log(arr);  // [42, 30, 23, 5]

splice()

删除元素，并向数组添加新元素。

// 创建一个新数组，并向其添加一个元素
var arr = [1,2,3,4];
arr.splice(2,0,5);
console.log(arr);  // [1, 2, 5, 3, 4]

// 删除位于 index 2 的元素，并添加一个新元素来替代被删除的元素：
var arr = [1,2,3,4];
arr.splice(2,1,5);
console.log(arr);  // [1, 2, 5, 4]

toSource()

返回该对象的源代码

// 浏览器支持
// 只有 Gecko 核心的浏览器（比如 Firefox）支持该方法，也就是说 IE、Safari、Chrome、Opera 等浏览器均不支持该方法。
<script type="text/javascript">
function employee(name,job,born){
    this.name=name;
    this.job=job;
    this.born=born;
}
var bill = new employee("Bill Gates","Engineer",1985);
document.write(bill.toSource());
</script>
// 输出：({name:"Bill Gates", job:"Engineer", born:1985}) 

toString()

把数组转换为字符串，并返回结果

var arr = ['xiao','ming','qiqi','aiming'];
arr.toString();
console.log(arr);  // ["xiao", "ming", "qiqi", "aiming"]

toLocaleString()

把数组转换为本地数组，并返回结果

var arr = ['xiao','ming','qiqi','aiming'];
arr.toLocaleString();
console.log(arr);  // ["xiao", "ming", "qiqi", "aiming"]

valueOf()

返回数组对象的原始值

var arr = ['xiao','ming','qiqi','aiming'];
arr.valueOf('lang');
console.log(arr); // ["xiao", "ming", "qiqi", "aiming"]

array1 array2 array3

Array 部分方法实现

数组元素去重

方法一：

思路：
1. 定义一个 json 对象
2. 遍历数组，将 arr[i] 作为 json 的键
3. 若 不重复，则给对应 arr[i] 的键值为 1 作为后面判断的标识，并 push 到新数组 arr1 中，若重复，则删除

var arr = [1, 2, 3, 2, 1, 5, 6, 3, 3, 2, 1, 7, 9, 8,6]
   var arr1 = []
   var json = {}
   for (var i = 0; i < arr.length; i++) {
     if (!json[arr[i]]) {
        json[arr[i]] = 1
        arr1.push(arr[i])
     }
   }

方法二：

思路：

1. 定义一个新数组 arr1
2. 如果这个新数组中没有这个元素，则 push

var arr = [1, 2, 3, 2, 1, 5, 6, 3, 3, 2, 1, 7, 9, 8,6]
   var arr1 = []
   for (var i = 0; i < arr.length; i++) {
     if (arr1.indexOf(arr[i]) < 0) {
        arr1.push(arr[i])
     }
   }

方法三：filter

1. filter的接收回调，可以有多个参数回调可以接收三个参数，第一个是数组中的元素，第二个是位置，第三个是数组本身
2. 利用filter过滤器，总是返回元素第一个位置
3. 去除重复元素依靠的是indexOf总是返回第一个元素的位置，后续的重复元素位置与indexOf返回的位置不相等，因此被filter滤掉了

var arr = [1, 2, 3, 2, 1, 5, 6, 3, 3, 2, 1, 7, 9, 8,6]
    var arr1 = arr.filter(function(ele, index, self) {
        return self.indexOf(ele) === index
    })
    console.log(arr1)

数组最值

方法一：Math.max.apply And Math.min.apply

方法一：Math.max.apply
    var iMax = 0
    var iMin = 0
    var arr = [1, 268, 5, 4, 9, 0, 68]
    iMax = Math.max.apply(null, arr)
    iMin = Math.min.apply(null, arr)
    console.log(iMax, iMin)

方法二：：Math.max.call And Math.min.call

    var iMax = 0
    var iMin = 0
    var arr = [1, 268, 5, 4, 9, 0, 68]
    iMax = Math.max.call(null, 1, 268, 5, 4, 9, 0, 68)
    iMin = Math.min.call(null, 1, 268, 5, 4, 9, 0, 68)
    console.log(iMax, iMin)

方法三：循环比较

    var iMax = 0
    var iMin = 0
    var arr = [1, 268, 5, 4, 9, 0, 68]
    for (var i = 0; i < arr.length; i++) {
        if (iMax < arr[i]) {
            iMax = arr[i]
        }
        if (iMin > arr[i]) {
            iMin = arr[i]
        }
    }
    console.log(iMax, iMin)

数组排序

sort

原理：在不带参数的情况下sort()方法默认会将数组元素当作string类型来升序排序,根据它们的unicode码从小到大依次排列，如果想按照自己的条件进行排序，需要传一个比较函数

    var arr = [1, 268, 5, 4, 9, 0, 68]
    // 从小到大
    arr.sort(function (a, b) {
        return a - b
    })
    console.log(arr)
    // 从大到小
    arr.sort(function (a, b) {
        return b - a
    })
    console.log(arr)

冒泡排序

思路：每次比较相邻的两个数，如果后一个比前一个小，换位置。如果要实现由大到小排序，使用reverse()即可；

var a = [1, 268, 5, 4, 9, 0, 68, 67, 69, 96, 14, 78, 100, 25, 42, 23, 32, 68, 89, 98, 1]
    var temp = 0
    for (var i = 0; i < a.length; i++) {
        for (var j = 0; j < a.length - i; j++) {
            if (a[j] > a[j + 1]) {
                temp = a[j]
                a[j] = a[j + 1]
                a[j + 1] = temp
            }
        }
        
    }
    var b = a.reverse()
    console.log(a)

快速排序

思路：采用二分法，取出中间数，数组每次和中间数比较，小的放到左边，大的放到右边。

    var arr = [1, 268, 5, 4, 9, 0, 68, 67, 69, 96, 14, 78, 100, 25, 42, 23, 32, 68, 89, 98, 1]
    function quickSort(arr) {
        if(arr.length == 0) {
            return [];  // 返回空数组
        }
        var arrL = []
        var arrR = []
        var index = Math.floor(arr.length / 2)
        var arrM = arr.splice(index, 1) // 返回被删除的数
        for (var i = 0; i < arr.length; i++) {  
            if (arrM > arr[i]) {
                arrL.push(arr[i])
            } else {
                arrR.push(arr[i])
            }
        }
        // console.log(arrL.concat(arrR))
        return quickSort(arrL).concat(arrM, quickSort(arrR))
    }
    console.log(quickSort(arr))

数组翻转(非reverse)

方法一：

删除数组最后一个元素并返回被删除的元素

var arr = [1,2,3,4];
var arr2 = [];
while(arr.length) {
    var num = arr.pop(); //删除数组最后一个元素并返回被删除的元素
    arr2.push(num);
}
console.log(arr2);
// [4, 3, 2, 1]

方法二：

删除数组第一个元素并返回被删除的元素

var arr = [1,2,3,4];
var arr2 = [];
while(arr.length){
    var num = arr.shift(); //删除数组第一个元素并返回被删除的元素
    arr2.unshift(num);
}
console.log(arr2);