ES5学习——数组和数组的方法

目录

数组

如何创建数组

访问和使用数组

数组的检测：

数组类型的转换、

内存

栈与队列方法

排序方法

截取方法

索引方法

迭代方法

总结

---

数组

  数组：ECMAScript数组是有序列表，是存放多个值的集合。在堆中开辟连续的内存空间
  有以下特性：
    1.每一项都可以保存任何类型的数据。
    2.数组的大小可以动态调整。
    3.数组的length属性：可读可写，可以通过设置length的值从数组的末尾移除项或向数组中添加新项

如何创建数组

1. 数组字面量
   var arr=[12,“eg”,true,{}]
2. 构造函数
   var arr = new Array();
   var arr = new Array(20); // 预先指定数组的大小
   var arr = new Array(“terry”,“larry”,“boss”); //传入参数

访问和使用数组

1.访问数组：数组变量名[索引]
	例： arr[1]
	如果索引小于数组的长度，返回对应项的值
    var arr = ["terry","larry","boss"];
    arr[0] ;  			//访问数组中第一个元素,返回值为terry
	如果索引大于数组的长度，数组自动增加到该索引值加1的长度
    var arr = ["terry","larry","boss"];
    arr[3] ="jacky";    //添加元素,数组程度变为4
2.使用
    var arr=[100,200,300,400];
    arr[0];
    arr[1];
    arr.length = max(index)+1;
    max(index)=arr.length-1；

数组的检测

判断当前变量的数据类型

  var arr = [];
  console.log(typeof arr);//object

判断当前变量是否在某个构造函数对应的原型链上，如果在返回true。

console.log( arr instanceof Array);//true arr是Array的实例吗
console.log( arr instanceof String );//false
console.log( arr instanceof Object);//true

当前变量是我的子孙后代吗

console.log( Array.prototype.isPrototypeOf(arr)); 
//Array.prorotype是arr的原型吗

Array.isArray()

数组中常用的，封装好的静态函数
Array.isArray(arr) 如果arr是数组返回true，不是返回false。

数组类型的转换

目录

数组

如何创建数组

访问和使用数组

数组的检测

数组类型的转换

内存

栈与队列方法

排序方法

截取方法

索引方法

迭代方法

总结

---

数组——>string类型

1.Array.prorotype.toString()
对数组的每个成员使用了toString()进行循环遍历输出

var arr=['100','200',{name:'zs'}]
console.log(arr.toString() ); //调用的是Array的toString方法,结果为100,200,[object Object]
console.log(['hello','world'].toString() ); //hello,world
var arr2 = [100,true,{name:'zs',},[123,123],function (){}];
console.log(arr2.toString());//100,true,[object Object],123,123,function (){}

  2.String()    +‘’     其实就是toString()方法、

console.log(String(arr2));
//100,true,[object Object],123,123,function (){}
console.log(arr2+'');
//100,true,[object Object],123,123,function (){}

 3.使用Array.prototype 中的实例方法join() 

用指定的字符串用来分隔数组字符串

var str1 = arr2.join();
var str2=arr2.join('$');
var str3 = arr2.join('a');
console.log(str1);//100,true,[object Object],123,123,function (){}
console.log(str2);//100$true$[object Object]$123,123$function (){}
console.log(str3);//100atruea[object Object]a123,123afunction (){}

4.JSON.stringify()

JSON不处理函数，只处理数据

var str4 =JSON.stringify(arr2);//JSON不处理函数，只处理数据
console.log(str4);//[100,true,{"name":"zs"},[123,123],null]

数组——>   boolean类型
1. Boolean()
 2.!!

console.log(!!null);//false
console.log(Boolean([]));//true
console.log(Boolean(["qqq","www"]));//true
console.log(!!['eee','rrr']);//true

内存

数组也是引用类型，在堆空间中开辟空间，但是这个空间是连续的。

栈与队列方法

push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。

        语法：  array.push(item1, item2, ..., itemX)

        参数：要添加到数组末尾的元素。（必需）

        返回值：数组新的长度，number类型

        注意： 1.新元素将添加在数组的末尾

                    2. 此方法改变数组的长度。

        var arr=["hello","world"];
        console.log(arr.push("!"));//结果为3
        console.log(arr);//["hello","world","!"]
        console.log(arr.length);//3

pop() 方法用于删除数组的最后一个元素并返回删除的元素。

        语法：  array.pop()

        参数：无

        返回值：删除的元素

        注意： 此方法改变数组的长度。

        var arr=["moon","star1","star2","star3"];
         var star=arr.pop();
        console.log(star);//star3
        console.log(arr);//Array(3) [ "moon", "star1", "star2" ]
        console.log(arr.length);3

unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。

        语法：  array.unshift(item1,item2, ..., itemX)

        参数：要添加的元素（可选）

        返回值：数组的新长度 number类型

        注意： 此方法改变数组的长度，将新项添加到数组起始位置

var arr=["moon","star1","star2","star3"];
var star=arr.unshift("hello","world");
console.log(star);//6
console.log(arr);//[ "hello", "world", "moon", "star1", "star2", "star3" ]
console.log(arr.length);//6

 shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。

        语法：  array.shift()

        参数：无

        返回值：数组第一个元素（移出的那个元素）

        注意： 此方法改变数组的长度。

        var arr=["moon","star1","star2","star3"];
        var star=arr.shift();
        console.log(star);//moon
        console.log(arr);//[ "star1", "star2", "star3" ]
        console.log(arr.length);//3

排序方法

reverse() 方法用于颠倒数组中元素的顺序。

语法：  array.reverse()

返回值：反转排序后的数组

参数：无

注意：改变原始的数据，会影响执行环境对象

        var arr=["moon","star1","star2","star3"];
        arr.reverse();
        console.log(arr);//[ "star3", "star2", "star1", "moon" ]

sort() 方法用于对数组的元素进行排序。如果调用该方法时没有使用参数，将按字母顺序（Ascall编码）对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。

语法：  array.sort(sortfunction)

参数：可以写也可以不写，不写就是按默认排序方式，参数sortfunction规定排序顺序。必须是函数

注意：  排序顺序可以是字母或数字，并按升序或降序。

             默认排序顺序为按字母升序。

        var arr=[1,12,100,2,24,6,2,30];
        arr.sort();
        console.log(arr);//[ 1, 100, 12, 2, 2, 24, 30, 6 ]

如果要实现按数字大小排序，应该传入一个函数。

        var arr=[1,12,100,2,24,6,2,30];
        arr.sort(function(a,b){
            return a-b
        });
        console.log(arr);//[ 1, 2, 2, 6, 12, 24, 30, 100 ]

关于升序和降序的条件

当 a>b 时，
  a - b > 0  ，排序结果 ===> b，a （升序）
  b - a < 0  ，排序结果 ===> a，b （降序）
 
  当 b>a 时，
  a - b < 0  ，排序结果 ===> a，b （升序）
  b - a > 0  ，排序结果 ===> b，a （降序）
 
  当 a=b 时，
  a - b = b - a =0 , 排序结果 ===> 保持不变

无论a>b还是b>a，return a-b 总能得到升序的结果，而 return b-a 总能得到降序的结果。

截取方法

concat() 方法用于连接两个或多个数组。

该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

语法：array1.concat(array2,array3,...,arrayX)

参数： 必需，该参数可以是具体的值，也可以是数组对象。可以是任意多个。

返回值：Array 对象 ，返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。

如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。

合并三个数组的值：

var arr1=[100,101];
var arr2=[102,103,104];
var arr3=[105];
var arr4=arr1.concat(arr2,arr3);
console.log(arr1);//[ 100, 101 ]
console.log(arr4);//[ 100, 101, 102, 103, 104, 105 ]

slice() 方法可从已有的数组中返回选定的元素。

slice()方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。

语法：array.slice(start, end)
参数值：start(可选)。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
              end(可选)。规定从何处结束选取。该参数是数组结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素。

返回值：Array 返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。

var arr1=[100,101,102,103,104,105];
var arr2=arr1.slice(-2,-1);
var arr3=arr1.slice(1)
var arr4=arr1.slice(2,5);
console.log(arr2);//[ 104 ]
console.log(arr3);//[ 101, 102, 103, 104, 105 ]
console.log(arr4);//[ 102, 103, 104 ]
console.log(arr1);//[ 100, 101, 102, 103, 104, 105 ]

splice() 方法用于删除、新增插入、替换数组中的元素。

注意：这种方法会改变原始数组。

语法：array.splice(起始位置，要删除的项个数，要插入的任意数量的项))

参数：至少是两个参数(起始位置，要删除的项，要插入的任意数量的项)
参数：起始位置 （必需），规定从何处添加/删除元素。 该参数是开始插入和（或）删除的数组元素的下标，必须是数字。
          要删除的项的个数（可选）。规定应该删除多少元素。必须是数字，但可以是 "0"。 如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
          插入的项（可选）要添加到数组的新元素        

返回值：被删除的元素的数组。
 

// 数组中添加新元素：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
//从数组索引位置 2 开始，不删除元素，添加两个新的元素"Lemon","Kiwi"
var r1=fruits.splice(2,0,"Lemon","Kiwi");
console.log(r1);//[]  因为第二个参数为0 ，没有删除元素，返回空数组
console.log(fruits);//[ "Banana", "Orange", "Lemon", "Kiwi", "Apple", "Mango" ]


//移除数组的第三个元素，并在数组第三个位置添加新元素:
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var r2=fruits.splice(2,1,"Lemon","Kiwi");
console.log(r2);//[ "Apple" ] 返沪删除的下标为2的元素
console.log(fruits);//fruits输出结果：[ "Banana", "Orange", "Lemon", "Kiwi", "Mango" ]

//从第三个位置开始删除数组后的两个元素：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var r3=fruits.splice(2,2);
console.log(r3);//[ "Apple", "Mango" ]
console.log(fruits);//fruits输出结果：[ "Banana", "Orange" ]

索引方法

 indexOf() 方法可返回数组中某个指定的元素位置。

该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。

如果在数组中没找到指定元素则返回 -1。

语法：array.indexOf(item,start)

参数：item（必须）查找的元素。

           start（可选）整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

返回值：number类型，元素在数组中的位置，如果没有搜索到则返回 -1。

查找数组中的 "Apple" 元素：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple");
console.log(a); //a结果输出：2
  //以上输出结果意味着 "Apple" 元素位于数组中的第 3 个位置。

lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。

如果要检索的元素没有出现，则该方法返回 -1。

  该方法将从尾到头地检索数组中指定元素 item。开始检索的位置在数组的 start 处或数组的结尾（没有指定 start 参数时）。如果找到一个 item，则返回 item 从尾向前检索第一个次出现在数组的位置。数组的索引开始位置是从 0 开始的。

  如果在数组中没找到指定元素则返回 -1。

语法：array.lastIndexOf(item,start)
参数：item（必需）规定需检索的字符串值。
           start（可选）整数参数。规定在字符串中开始检索的位置。最大取值stringObject.length-1。如省略该参数，则将从字符串的最后一个字符处开始检索。

返回值：number类型，如果存在返回下标，不存在返回-1，是从后往前查找的。

//查找数组元素 "Apple"出现的位置：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");
console.log(a);
//a输出结果：2
//以上实例输出结果意味着 "Apple" 位于数组中的第 2 个位置.

迭代方法

 every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。

  every() 方法使用指定函数检测数组中的所有元素：

  - 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
  - 如果所有元素都满足条件，则返回 true。

注意：every() 不会对空数组进行检测，every() 不会改变原始数组。

语法：array.every(function(v,i,arr), thisValue)

参数:   function(v,i,arr){}函数（必需）数组中的每个元素都会执行这个函数

        v   必须。当前元素的值     
        i    可选。当前元素的索引值  
        arr可选。当前元素属于的数组对象
           thisValue（可选）。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值为 "undefined"

返回值:  布尔值。如果所有元素都通过检测返回 true，否则返回 false。

检测数组 ages的所有元素是否都大于等于 18 :

  var ages = [32, 33, 16, 40];
 
  var result = ages.every(function (age) {
    return age >= 18
  })
  console.log(result);//输出结果为:false

some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。

  some() 方法会依次执行数组的每个元素：

  - 如果有一个元素满足条件，则表达式返回true, 剩余的元素不会再执行检测。
  - 如果没有满足条件的元素，则返回false。

注意：some() 不会对空数组进行检测, some() 不会改变原始数组。

语法:  array.some(function(currentValue,index,arr),thisValue)

参数:   function(v,i,arr){}函数（必需），数组中的每个元素都会执行这个函数

       currentValue  必须。当前元素的值     
        index            可选。当前元素的索引值  
        arr                可选。当前元素属于的数组对象    

thisValue： 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值为 "undefined" |

返回值：  布尔值。如果数组中有元素满足条件返回 true，否则返回 false。

//检测数组中是否有元素大于 18:


  var ages = [32, 33, 16, 40];
 
  var result = ages.some(function (age) {
    return age >= 18
  })
  console.log(result);//输出结果为:true

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

注意 filter() 不会对空数组进行检测，filter() 不会改变原始数组。

语法： array.filter(function(currentValue,index,arr), thisValue)

参数和every()，some()方法一样

返回值:  返回数组，包含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。

// 返回数组 *ages* 中所有元素都大于 18 的元素:


var ages = [32, 33, 16, 40];

var result = ages.filter(function (age) {
  return age >= 18
})
console.log(result);//输出结果为:[ 32, 33, 40 ]

  map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

  map() 方法按照原始数组元素顺序依次处理元素。

注意：map() 不会对空数组进行检测,map() 不会改变原始数组。

语法:  array.map(function(currentValue,index,arr), thisValue)
参数：和filter()参数一样，不重复写了

返回值：  返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

// 返回一个数组，数组中元素为原始数组的平方根:

var numbers = [4, 9, 16, 25];

var result = numbers.map(function (number) {
  return Math.sqrt(number)
})
console.log(result);//输出结果为:[ 2, 3, 4, 5 ]

  forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。

注意:forEach() 对于空数组是不会执行回调函数的。

语法:  array.forEach(function(currentValue, index, arr), thisValue)

参数:与map参数一样。

返回值：没有返回值

var numbers = [4, 9, 16, 25];

numbers.forEach(function (number, index) {
  console.log(index + ' -- ' + number);
})
// 0 -- 4
// 1 -- 9
// 2 -- 16
// 3 -- 25

---

总结

数组的方法有些会影响自身有些又不影响自身，在这里总结一个表格便于记忆。

Array.prototype.push	会影响原数组
Array.prototype.pop	会影响原数组
Array.prototype.unshift	会影响原数组
Array.prototype.reverse	会影响原数组
Array.prototype.splice	会影响原数组
Array.prototype.slice	不会影响原数组
Array.prototype.concat	不会影响原数组
Array.prototype.every	不会影响原数组
Array.prototype.some	不会影响原数组
Array.prototype.filter	不会影响原数组
Array.prototype.map	不会影响原数组
Array.prototype.forEach	不会影响原数组
Array.prototype.indexOf	不会影响原数组
Array.prototype.lasrIndexOf	不会影响原数组
Array.isArray	不会影响原数组