数组的基本操作,基脾天性及常用操作方法

最初的作品地址:http://www.cnblogs.com/hbzyin/p/7310716.html
数组Array是Javascript语言中那个关键的三种引用类型数据之一,其它一种为对象Object。Array的数据模型可分为二种举办仓库储存:堆栈结构、队列结构。

正文首要介绍js数组成分的有些基本操作,常用的有的方法

关键词:始建数组、新增数组成分、删除数组成分、将数组变成字符串、数组对象常用属性、合并数组、拷贝数组、数组排序等

昨天,确切说是前天了,去和大学同学见面,请了半天假,顺便去参加了一个面试,结果还不知道;先说说面试中的一些Javascript相关的基本知识。虽然平时工作中也经常用到各种数组相关的方法, 但理解不够深刻,总是容易遗忘,今天趁机再整理一下。

1. 开立数组

1.数组的中央性子:①length、②prototype、③constructor

  • Array.length : 设置、重返数组相月素的数目;
  • Array.prototype : 设置、重临数组中原型的本性/方法;
  • Array.constructor: 重回次对象的数组函数的引用

var arr1=new Array();  
arr1.length=3;                                         //// 1.1. 设置数组的长度
console.log(arr1); //[undefined × 3]
var arr2=[1,2,4];                                     //// 1.2.返回数组的长度
console.log(arr2.length);//3

Array.prototype.attrName="new attribute"; //// 2.1 设置数组原型的属性
console.log(Array.attrName);//new attribute; 
Array.prototype.newFn=function(){            //// 2.2设置数组原型的方法
    return "This is a new fn of Array.prptotype.";
}
console.log(Array.newFn()); // This is a new fn of Array.prptotype.  

Array.constructor.newFunction();               ////返回创建次对象的数组函数;     

1.1 使用Array构造函数

var arr1 = new Array(); //创建一个空数组
var arr2 = new Array(20); // 创建一个包含20项的数组
var arr3 = new Array("lily", "lucy", "Tom"); // 创建一个包含3个字符串的数组

2. 数组堆栈FILO模型下方法:①push(el) 、②pop()

那二种艺术都会促成原数组发生变化,重返值为做到操作之后的数目;

var arr3=['a','b','c'];
arr3.push('d');                                      // 2.1 堆栈中从**堆栈顶部**添加一个元素--改变原数组
console.log(arr3);//["a","b","c","d"]

arr3.pop(1)                                         // 2.2 从堆栈顶部删除数组的最后一个元素--改变原数组
consoel.log(arr3);//["a","b","c"]

1.2 使用数组字面量表示

var arr4 = []; //创建一个空数组
var arr5 = [20]; // 创建一个包含1项的数组
var arr6 = ["lily", "lucy", "Tom"]; // 创建一个包含3个字符串的数组

3.数组成代表队列模型FIFO下的章程:①push(el)、②shift()、③unshift(el)

var arr4=["d","e","f"];
arr4.push("g");                                //// 3.1 在队列末尾添加一个元素--改变原数组
console.log(arr4);//["d","e","f","g"]  

arr4.shift(1);                                  //// 3.2 在队列头部删除一个元素--改变原数组
console.log(arr4);//["e","f","g"]

arr4.unshift("dd");                          //// 3.3 在队列头部添加一个元素--改变原数组
console.log(arr4);//["dd","e","f","g"]

2. 数组常用艺术

4. 数组的排序方法:①sort()、②reverse()

此处须求表明几点:

  1. sort方法私下认可根据圣墟对数组实行排序,即 由小到大升序;
    2.
    sort方法会隐式调用每一种数组项的toString()方法,然后比较得到的字符串,最终进行升序排列;如:[0,1,3,10,15].sort();//[0,1,10,15,3];
    3.
    sort方法可传唱1个用于比较函数,实际应用中常自定义相比函数function(a,b){return a-b;},若
    a-b<0 升序排列;若a-b>0降序排列;a-b=0 原数组不变;
  2. reverse方法–其排序方向为 降序排列数组、与sort方向相反;
var arr=[12,13,25,24,27];
arr.sort();                                              //// 4.1 sort() 默认升序排列
console.log(arr);   //[12,13,24,25,27] 
arr.reverse();                                        //// 4.2 reverse() 翻转排序
console.log(arr);  //[27,25,24,13,12]

var arr=[1,5,13,20,25];
arr.sort();                                           ////  4.3 sort() 隐式调用toString() 方法后对元素进行比较排序
console.log(arr);  //[1,13,20,25,5]

arr.sort(function(a,b){                         ////  4.4 sort(function(a,b){return fn})   自定义比较函数
    return a-b;
});
console.log(arr);  //[1,5,13,20,25]

2.1 数组成分的丰盛

  • push将三个或多少个新因素添加到数组结尾,并赶回数组新长度
  • unshift将一个或多少个新因素添加到数组开头,数组中的成分自动后移,再次来到数组新长度
  • splice(2, 0,
    arr6)将2个或八个新因素插入到数组的钦命地点,插入地方的元素自动后移,重临””

var arr7 = [1, 2];
arr7.push(8);
arr7.push(9, 10, 11);
arr7.unshift("00", "01");
arr7.splice(2, 0, arr6);
console.log(arr7); // ["00", "01", Array(3), 1, 2, 8, 9, 10, 11] 数组长度为9

5. 数组地点方法: ①indexOf(el)、②lastIndexOf(el)

**说明:**此处说明一点,数组位置查找时,采用全等(===)比较进行查找

var arr=["jack","lily","lucy","lily","brown","json"];
var index1=arr.indexOf("lily");                    //// 5.1 从头(序号0)开始查找元素 
var index2=arr.lastIndexOf("lily");              //// 5.2 从尾部(序号1)开始查找元素
var index3=arr.indexOf("xiaoming");          
console.log(index1);     // 1
console.log(index2);    // 3
console.log(index3);   // -1

2.2 数组元素的去除

  • pop移除最终3个因素并重回该成分值
  • shift移除最前二个因素并重回该成分值,数组中元素自动前移
  • splice(2,
    1)删除从内定地点(2,从0起始)开首的钦点数量(1)的因素,数组方式重回所移除的因素

var arr8 = [1, 2, 5, 8, 10, "123lili", "9087tt", 20];
arr8.pop();
arr8.shift();
arr8.splice(2, 1);
console.log(arr8); // [2, 5, 10, "123lili", "9087tt"]

6. 数组操作方法:

  • 数组合并:①concat()、②join()

var arr5=["a","b","c"];
var arr6=[1,2,3];
var res=arr5.concat(arr6);              //// 6.1.1 concat 合并两个数组
console.log(arr5);//["a","b","c"]
console.log(arr6);//[1,2,3]
console.log(res);//["a","b","c",1,2,3]

var res6=[...arr5,...arr6];               //// ES6解构方法合并数组

var res2=arr5.join("-");               //// 6.1.2 join 连接数组元素为字符串
console.log(arr5);//["a","b","c"]
console.log(res2);//a-b-c
  • 数组复制(切分):①slice(st[,end])

    至于arr.slice(start,end)方法此处表达几点:

    1. arr.slice(start,end) : 可传唱3个依然三个参数,start
      复制数组的前奏地点,end数组复制甘休的岗位;
    2. arr.slice(start,end) :
      若传入参数start>end,表示数组不进行理并答复制,再次回到空数组;
    3. arr.slice(start,end) :
      若传入参数start、end任意1个为负值,则实在复制时改参数值为
      argValue=arr.length+该传入值,再进行复制

var arr=[0,1,2,3,4,5,6];
var arr1=arr.slice(1);                    // 6.2.1 从指定开始位置复制数组
var arr2=arr.slice(1,3);                 // 6.2.2 从指定的开始、结束位置复制数组
var arr3=arr.slice(-2,2);              // 6.2.3 从指定位置(start+arr.length)和结束位置复制数组
  • 全能方法:splice()

    至于arr.splice()说澳优(Ausnutria Hyproca)(Karicare)下几点:

    1. arr.splice(arguments)–展开操作时会对原数组造成影响
    2. 可用作数组的删除插入替换三类操作;其传播参数有
      1个、1个、八个
    3. arr.splice(start,num)–从钦命地点(start)初始,删除钦定个数(num)数组成分;
    4. arr.splice(start,DeleteNum,newEl1)–从钦赐地方(start),删除钦点个数元素,并在钦定地点(start)插入新因素;
    5. arr.splice(start,DeleteNum,newEl1)–在钦定地点(start+DeletenNum)用新因素(newEl)替换旧成分;

var names=["lily","lucy","jhon","schwts"];
var name1=names.splice(1,1);                                 //// 6.3.1 从指定位置(start),去删除(num)个数组元素
console.log(name1);     // ["lucy"];
console.log(names);     // ["lily","jhon","schwts"]    // splice()方法会对原数组造成影响


var name2=names.splice(1,1,...["xiaoming"]);       //// 6.3.3 从指定位置插入元素
console.log(name1);     // ["lucy"];
console.log(names);     // ["lily","jhon","schwts"]  

var names=[1,2,3,4,5,6];
var name=names.splice(2,2,5);
console.log(name);     // 1,2,5,5,6;
console.log(names);     

__END

2.3 数组的截取和合并

  • 截取:slice(start,
    [end])截取钦命地方的数组成分,以数组的款型重返数组的一部分,不包含end 对应的成分,要是简单 end 将复制 start 之后的拥有因素
  • 合并:concat([item1[, item2[, …
    [,itemN]]]]);将四个数组(也足以是字符串,只怕是数组和字符串的以次充好)连接为1个数组,再次来到连接好的新的数组

var arr9 = ["12yu", "i", "am", "ada", "~"];
console.log(arr9.slice(1, 4)); //  ["i", "am", "ada"]
console.log(arr9.slice(1)); // ["i", "am", "ada", "~"]

console.log(arr9.concat("啦啦啦", 666)); // ["12yu", "i", "am", "ada", "~", "啦啦啦", 666]
console.log(arr9.concat("啦啦啦", ["啦啦啦", 999])); // ["12yu", "i", "am", "ada", "~", "啦啦啦", "啦啦啦", 999]

2.4 数组的正片

  • 回到数组的拷贝数组,注意是三个新的数组,不是指向。能够用concat()、.slice()、splice()来兑现

var arr10 = arr9.slice(0); // ["12yu", "i", "am", "ada", "~"]
arr9[0] = "hello";
console.log(arr10); // ["12yu", "i", "am", "ada", "~"]
console.log(arr9.concat()); // ["hello", "i", "am", "ada", "~"]
console.log(arr9.splice(0, arr9.length)); // ["hello", "i", "am", "ada", "~"]

2.5 数组成分的排序

  • reverse()反转元素(最前的排到最终、最终的排到最前),再次回到数组地址
  • sort():按升序排列数组项——即最小的值位于最前方,最大的值排在最后边。重临数组地址。
    • 在排序时,sort()方法会调用每个数组项的
      toString()转型措施,然后比较得到的字符串,以鲜明哪些排序。固然数组中的每一项都以数值,
      sort()方法比较的也是字符串,
    • sort()方法还不错多个相比较函数作为参数,以便大家钦点哪个值位于哪个值的前边。比较函数接收七个参数,假诺第三个参数应该放在第①个从前则赶回三个负数,即便三个参数相等则赶回
      0,要是第③个参数应该放在第①个之后则赶回三个正数。

var arr11 = ["you", "and", "me"];
console.log(arr11.reverse()); // ["me", "and", "you"] 
console.log(arr11.sort()); // ["and", "me", "you"]
arr11.sort(function (a, b) {

    return a - b;
});

2.6 数组转为字符串

var arr12 = [1, 2, 3, 4];
// join(separator)返回字符串,这个字符串将数组的每一个元素值用separator连接在一起
console.log(arr12.join("--")); // 1--2--3--4
console.log(arr12.toLocaleString()); // 1,2,3,4
console.log(arr12.toString()); // 1,2,3,4
// 注:数组使用arr12.valueOf()方法依旧是数组

2.7 数组中是不是存在钦赐成分

  • indexOf():接收五个参数:要物色的项和(可选的)表示查找源点地方的目录。当中,从数组的始发(位置0)起先向后搜索。
  • lastIndexOf:接收多个参数:要物色的项和(可选的)表示查找源点地方的目录。当中,从数组的末尾开首向前查找。
    那八个办法都回到要物色的项在数组中的地方,可能在没找到的情状下再次回到1。在比较第二个参数与数组中的每一项时,会动用全等操作符。

console.log(arr12.indexOf(2)); // 1
console.log(arr12.lastIndexOf(2)); // 1
console.log(arr12.indexOf(2, 2)); // -1
console.log(arr12.lastIndexOf(2, 2)); // 1

3. 数组的为主品质

3.1 length

length属性表示数组的尺寸,即内部成分的个数。数组的目录总是由0开端,所以一个数组的上下限分别是:0和length-1。javascript数组的length属性是可变的。当length属性被装置得更大时,整个数组的处境其实不会爆发变化,仅仅是length属性别变化大;当length属性被安装得比原来时辰,则原先数组中索引大于或等于length的要素的值全部被遗失。

var arr13 = [1, 90, 22, "111"];
console.log(arr13.length); // 4;
arr13.length = 6;
console.log(arr13[5]); // [1, 90, 22, "111", undefined, undefined]
arr13.length = 3;
console.log(arr13); // [1, 90, 22]

3.1 Array.prototype

宣示原型属性后拥有数组对象共有

Array.prototype.max = function () {

    this.sort(function (a, b) {

        return a - b;
    });
    return this[this.length - 1];
};
var arr14 = [5, 78, 48, 19, 8];
console.log(arr14.max()); // 78

4. 相关作品