JavaScript数组的属性及方法

已经连续更新了第四天了，希望各位大佬们，可以给出宝贵的意见，顺便给小弟点一赞?。今天和大家唠一下数组(Array)和字符串(String)的一些方法和属性：

来吧既然走到了这里，就歇歇脚吧

Array 数组

说实话看到数组这么多的方法我就脑瓜子疼，唉没办法硬着头皮上吧

1. length 属性：动态获取数组的长度；

let a = [1,2,3]
console.log(a.length) // 3

2. jion() 将一个数组转成字符串，返回一个字符串；

let a = [1,2,3]
console.log(a.join()) // 1,2,3

3. reverse() 将数组中各元素颠倒顺序；

 let a = [1,2,3]
 console.log(a.reverse()) // [3, 2, 1]
 

4. delete() 运算符 只能删除数组元素的值，而所占空间还在，总长度没变(arr.length)

let a = [1,2,3];
delete a[1]; // a在索引1的位置不再有元素
1 in a  // false 数组索引1并未在数组中定义
a.length //  3  delete操作并不影响数组长度

5. shift() 删除数组中的第一个元素，返回删除的那个值，并将长度减一；

let a = [1,2,3]
a.shift()  //a变成了[2,3]  返回：1
let b = [[1,2],3,4] 
b.shift()  //b 变成了[3,4]  返回：[1,2]

6. pop() 删除数组中的最后一个元素，返回删除的那个值，并将长度减一；

// 其实push和pop就是允许将数组当做栈来使用
let stack = [1,2,3]
stack.pop()  //  stack:[1,2] stack.length = 2 返回： 3
let stack1 = [1,2,[3,4]]
stack1.pop()  //stack1:[1,2]  stack1.length = 2 返回：[3,4]

7. unshift() 往数组前面添加一个或多个数组元素，长度要改变，最后返回数组新的长度；

let a = [ ];
a.unshift(1);  //a:[1]  返回：1
a.unshift(2);  //a:[2,1]  返回：2

8. push() 在数组的结尾添加一个或多个元素，长度要改变；

let stack = [ ]
stack.push(1,2)   // stack:[1,2]  返回：2
stack.push([4,5])  //stack:[1,2,[4,5]] 返回：3

9. concat() 连接数组；

// Array.concat()方法创建并返回一个新数组 ,但是concat()不会扁平化数组
let a = [1,2,3];
a.concat(4.5)   // 返回 [1,2,3,4,5]
a.concat([4,5])  // 返回 [1,2,3,4,5]
a.concat([4,5],[6,7])  //返回[1,2,3,4,5,6,7]
a.concat(4,[5,[6,7]])  //返回[1,2,3,4,5,[6,7]]

10. slice() 返回数组的一部分；

let a = [1,2,3,4,5]
a.slice(0,3)  // 返回：[1,2,3]
a.slice(3)  //返回[4,5]
a.slice(1.-1) //返回[2,3,4]   参数中的负数，表示相对于数组中最后一个元素的位置
a.slice(-3,-2) //返回 [3]

11. sort() 对数组进行排序；Array.sort()方法将数组中的元素排序并返回排序后的数组。当不带参数调用sort()时，数组元素以字母表排序（有必要的时候将临时转化为字符创进行比较）

let a = new Array('sunday','apple','jiujiu')
a.sort()  //返回值['apple','jiujiu','sunday']<br>
//如果数组包含undefined元素，他们会被排到数组的尾部
let b = [33,4,111,222]
b.sort()  //[111,222,33,4]  得出的事字母表排序
b.sort( function (a,b) {  //数值顺序：4,33,111,222
    return a-b;  //根据顺序，返回负数，0，正数
})

其余建议大家看一下《JavaScript权威指南》

12. splice() 插入、删除或者替换数组的元素,splice()返回一个由删除元素组成的数组，或者如果没有删除元素就返回一个空数组。

// 第一个参数指定了插入或删除的起始位置，第二个参数指定了应该从数组删除的元素个数，<br>
//如果省略第二个参数，从起点开始到数组结尾的所有元素都将被删除。
let a = [1,2,3,4,5,6,7,8]
a.splice(4)   //返回[5,6,7,8]  a:[1,2,3,4]
a.splice(1,2)  //返回[2,3]  a:[1,4]
a.splice(1,1)  //返回[4] a:[4]
// splice()的前两个参数指定了需要删除的数组元素，紧随其后的任意个数的参数指定了，需要插入到数组中的元素，从第一个参数指定的位置插入
let a = [1,2,3]
a.splice(2,2,'a','b')   //返回[]  a:[1,2,'a','b',3]

13. toString() 将数组转换成一个字符串；

[1,2,3].toString()   //  '1,2,3'
['a','b','c'].toString()   // 'a,b,c'
['a',[2,'c']].toString()   // 'a,2,c'

---

14. forEach()，对数组每一项进行给定函数，和for循环类似

// 传递的函数为forEach()的第一个参数，然后forEach()使用<br>//三个参数调用该函数：数组元素，元素索引和数组本身

let arr = [1,2,3,4,5,6] 
//计算数组元素的和值
let sum = 0;
arr.forEach(function(value) {
    sum += value
})
// sum的返回值为21

// 为每个数组元素的值加1
arr.forEach(function(v,i,a) {
    a[i] = v+1
})
//数组返回值  [2,3,4,5,6,7]

/**
注意一下，forEach无法在所有元素都传递给调用的函数之前终止遍历,
其实就是说，forEach中没有break语句,如果要提前终止，就在forEach()方法放在try块中，并能抛出一个异常，抛出异常，循环会提前终止
 */
 function foreach(a,f,t) {
     try{
         a.forEach(f,t);
     }catch (e) {
         if(e === foreach.break) return;
         else throw e
     }
 }
 foreach.break = new Error('StopIterration');

15. map() 对数组中每一项进行给定函数，返回每次函数调用的结果组成新的数组。

// callback:必须的参数，对数组每一项要执行的函数
// thisArg:可选，规定callback回调函数this所指向的对象。
let arr = [1,2,3,4,5,6]
let mapArr = arr.map(function(item,index,array) {
    return item*2
})
// 返回值为[2,4,6,8,10,12]

let arr = [1,2,3,4,5,6]
let obj = {num:2}
let mapArr = arr.map(function(item,index,array) {
    return item*this.num
},obj)
// 返回值为[2,4,6,8,10,12]

16. filter()方法返回的数组元素是调用的数组的一个子集。传递的函数是用来逻辑判定的：该函数返回true和false，其实就是数组的过滤

let arr = [1,2,3,4,5,6,,7]
let newArr = arr.filter(function(x) { return x < 3 })  // [1,2]

17. indexOf()和lastIndexOf()搜索整个数组中具有给定值得元素，返回找到的第一个元素的索引或者如果没有找到就返回-1.indexOf()从头至尾搜索，而lastIndexOf()则反方向搜索。

let a = [1,2,3,1]
a.indexOf(1)  //返回索引 0   a[0]是1
a.lastIndexOf(1)  //返回索引 3   a[3]是1
a.indexOf(4)  //返回-1，没有值为4的元素

18. 如何判断数组

Array.isArray([])   //true
Array.isArray({})   //false

[] instanceof Array   // true

19. ES6中的数组新方法find(),findIndex()

/**数组实例的`find`方法，用于找出第一个符合条件的数组
成员。它的参数是一个回调函数，所有数组成员依次执行该
回调函数，直到找出第一个返回值为`true`的成员，
然后返回该成员。如果没有符合条件的成员，则返回`undefined`。*/
[1, 4, -5, 10].find((n) => n < 0)   // -5
// findIndex()返回下标
[1,4,-5,10].findIndex(n) => n < 0)  // 下标为2

20. includes() 判断数组中是否存在该元素，可以替换 ES5 时代的 indexOf 判断方式。

includes(value,start)

• value：必需，要检测的元素。
• start：可选，规定填充开始位置，默认从索引0处开始。

let arr = ['a', 'b','c', 'd', NaN]
arr.includes('a') //true
arr.includes(NaN) //true
arr.indexOf(NaN) //-1

21. fill() 用新元素替换掉数组内的元素，可以指定替换下标范围。

fill(value,start,end)

• value：必需，用来进行填充的值。
• start：可选，规定填充开始位置，默认从索引0处开始。
• end：可选，规定填充结束位置，默认填充到数组结尾。

const arr = ['a', 'b', 'c', 'd']
console.log(arr.fill('ss', 1, 3))  // ["a", "ss", "ss", "d"]

const arr2 = ['a', 'b', 'c', 'd']
console.log(arr.fill('ss'))  // ["ss", "ss", "ss", "ss"]

来个算法摧残一下自己吧

 /* 
        在一个神话故事中，有一只小兔住在一个周长为一千米的圆形神湖旁，A.B两点把这个神湖分成两部分，已知小兔从B点出发，沿逆时针方向绕神湖做跳跃运动，它每跳8分之3千米休息一次，如果跳到A点正好休息，那么就会经过特别通道AB滑倒B点，从B点继续跳。它每经过一次特别通道，神湖半径就扩大一倍，现知小兔共休息1000次，这时神湖周长是多少千米？（AB为圆的直径）*/
        //神湖周长
        var c = 1000;
        // 跳跃一次的距离
        var jump = 375;
        // 到A点休息时跳跃的次数
        var j = 0;
        // 跳跃1000次
        for (var i = 1; i <= 1000; i++) {
            // 跳跃到c/2
            if(jump * (i-j) % c == c/2) {
                // 周长加倍
                j = i;
                c *= 2;
            }
        }
        // 在控制台打印周长
        console.log(c)   //128000