Javascript常用的数组方法,数组的多少个法子

By admin in 4858美高梅 on 2019年4月3日

 数组的 every()
、some()
、filter() 
三者的回调函数都有多个参数:成分、索引和当前数组,用到哪些写哪个(成分一定要有),顺序不可乱

一、JavaScript中数组的概念

  • 数组的正儿8经定义:三个存储成分的线性集合(collection),成分得以通过索引来引用任意存取,索引经常是数字,用来测算成分之间存款和储蓄地方的偏移量。
  • JavaScript数组的概念:是一种很是的靶子,用来表示偏移量的目录是该目的的习性,索引也许是整数。不过,那么些数字索引在里面是被转换来字符串类型的,那是因为JavaScript对象中的属性必须是字符串类型,内部的因素得以使任意档次的。

Javascript有很多数组的诀要,有的人有W3C的API,还足以去MDN上去找,可是自身认为API上说的不全,MDN上又太多。。其实常用的就那个,很多都能够用这贰个法子解出来。

1、数组的判定

arr instance Array;

Array.isArray(arr);

方法:

every()
当数组的每一种成分都满意条件(例如大于三)才会再次回到true

2、数组的操作

有的是措施中有包容性的,在应用的时候,把包容代码复制粘贴即可。

1. push

效益:像数组的最终添加1项或多项因素

参数:要丰硕的项

重回值:新数组的长短

是否改变原数组:改变

var ary = [‘a’,’b’,’c’];

var res = ary.push(‘d’,’e’);

console.log(ary);  // [“a”,”b”,”c”,”d”,”e”]

console.log(res);  // 5

some() 倘使数组里有贰个因素满意条件即再次回到true

一. 开立数组

  • 方式一:

var numbers = [];
  • 方式二:

// 当传入一个数字类型的参数时,表示数组的长度,其他则表示数组的元素。
var numbers = new Array();

那三种办法推荐应用办法一,因为那种措施作用更高。

先贴上来数组和字符串的艺术的相比,我在念书的时候也是会混。所以做了小总括。之后正是数组方法和一部分实例。若是有侧边栏就好了,看得就比较清楚。

2. pop

作用:删除数组的最终一项

参数:无

重返值:被去除的项

是否改变原数组:改变

varary = [‘1′,’2′,’3’];varres = ary.pop();console.log(ary);//
[‘1′,’2’]console.log(res);// 3

filter() 回去满足条件的因素结合的数组

2. 读写数组

貌似采取 [] 操作符

数组 字符串

3. shift

职能:删除数组的首项

参数:无

再次来到值:被剔除的项

是不是变动原数组:改变

varary = [‘a’,’b’,’c’]Javascript常用的数组方法,数组的多少个法子。;varres = ary.shift();console.log(ary);//
[‘b’,’c’]console.log(res);// a

4858美高梅 1

三. 由字符串生成数组

split() 方法:

  • 作用:通过分隔符,将字符串分成几有的,并将每部分作为三个因素保存在2个新的数组中。
  • 参数:分隔符
  • 重回值:新的数组
  • 元字符串不发生变更。

var str = 'hello world javascript css html';
var words = str.split(' '); // words为一个数组

slice | slice substring 截取供给初阶和终结index的

4. unshift

功用:向数组的发端添加1或多项

参数:要增加的项,多项用’,’隔断

再次回到值:新数组的长短

是不是变动原数组:改变

var ary = [‘a’,’b’,’c’];

var res = ary.unshift(‘d’,’e’);

console.log(ary);  // [“d”,”e”,”a”,”b”,”c”]

console.log(res);  // 5

every() 和 some() 皆以回到boolean

四. 对数组的总体操作

splice | substr 截取供给伊始index和截取长度的

5. splice

作用:增删改

参数:ary.splice(index,howmany,item1,…..,itemX)

重临值:删除的项

是还是不是改变原数组:改变

扩大的效益

ary.splice(n,0,x,……,y);

从数组的索引n开端,删除0项,在索引n的眼下扩张新的项,第伍个参数早先都以用来补偿删除的品类地点的

varary = [1,2,3,4,5];varres = ary.splice(1,0,6,7);console.log(ary);//
[1, 6, 7, 2, 3, 4, 5]console.log(res);// [] 删除0项,重回2个空数组

删去的功效

ary.splice(n,m);

从数组的索引n开始,删除m项

varary = [1,2,3,4,5];varres = ary.splice(1,2);console.log(ary);//
[1,4,5]console.log(res);// [2,3]

修改的效果

ary.splice(n,m,x);

从数组的索引n初阶,删除m项,把x添加到索引n前面

varary = [1,2,3,4,5];varres = ary.splice(1,2,6,7);console.log(ary);//
[1, 6, 7, 4, 5]console.log(res);// [2,3]

//模拟push(尾巴部分增进)  和push2者重临值分化

ary.splice(ary.length,0,新的项)
//因为splice是在目录前增加,所以首先个参数为ary.length//模拟pop(尾巴部分删除)

ary.splice(arr.length-1,1);

//模拟shift(首项删除)

ary.splice(0,1)

//模拟unshift(首项添加) 和unshilft二者重返值分化

ary.splice(0,0,新的项)

此外

ary.splice(n)// 表示从索引n起先删除到末尾ary.splice(0)// 删除全部数组
有克隆数组的效应,利用再次来到值

filter() 回去的是数组

4.一 将多少个数组赋值给另三个数组

改操作只是给被赋值的数组增添了1个新的引用,其实八个变量指向的是1个数组,两者的操作是相互影响的。常常被称为“浅复制”。
什么样促成深复制:

// 将arr1深复制给arr2
function copy (arr1,arr2) {
  for (var i = 0; i < arr1.length; i++) {
    arr2[i] = arr1[i]
  }
}

实行:如何兑现1个对象的深复制?

function copyObj (obj1, obj2) {
  var obj2 = obj2 || {};
  for (item in obj1) {
    if (typeof item === 'object') {
      obj2[item] = (obj1[item].constructor === Array):[]?{}; // 判断属性是否为对象或是数组
      copyObj(obj1[item], obj2[item]);
    }else{
      obj2[item] = obj1[item]
    }
  }
  return obj2;
}

concat | concat 都以连续,多个是连接数组,一个是接2连三字符串

6. slice

功能:截取数组(复制数组)

参数:array.slice(start, end)

再次来到值:再次来到贰个新数组

是还是不是变动原数组:不更改

varary = [1,2,3,4,5];varres = ary.slice(1,3);varres2 =
ary.slice(-3,-1)console.log(ary);// [1,2,3,4,5]console.log(res);//
[2,3]console.log(res2)//[3,4]
slice匡助负参数,从最后一项伊始算起,-一为结尾1项,-2为尾数第一项slice(n)//从索引n开头复制到最终1项slice()、
slice(0)//复制整个数组

叁者都不会变动原数组

伍. 存取操作

indexOf | indexOf 搜索元素在不在里面,重返index值或许-一

7. join

功能:用钦定的相间符将数组每1项拼接为字符串

参数:钦赐的分隔符,假设省略该参数,则利用逗号作为分隔符

再次回到值:拼接好的字符串

是或不是改变原数组:不转移

varary = [1,2,3,4,5];varres = ary.join(‘-‘);console.log(ary);// [1,
2, 3, 4, 5]console.log(res);// 1-2-3-4-5

P.S
:
every()和some()各个检查测试成分是或不是符合条件,不合符时就不会再检查评定剩下的成分,好奇底层代码是怎么样促成的,为啥写个规格就能让每一个成分都去看清是还是不是满意

伍.一 查找匹配成分

join | split 那正是多少个反义词啊,互相转化的利器

8. concat

职能:用于连接多个或八个数组

参数:参数能够是具体的值,也能够是数组对象。能够是轻易四个

重临值:重返连接后的新数组

是或不是变动原数组:不改动

varary = [1,2,3,4,5];varres = ary.concat(6,7);varres2 =
ary.concat(6,[7,8]);varres3 = ary.concat(6,[7,[8,9]]);varres4 =
ary.concat();console.log(ary);// [1, 2, 3, 4, 5]console.log(res);//
[1, 2, 3, 4, 5, 6, 7]console.log(res2);//[1, 2, 3, 4, 5, 6, 7,
8]console.log(res3)// [1, 2, 3, 4, 5, 6, 7, [8,9]]  concat()
倘诺操作的参数是数组,那么足够的是数组中的成分,而不是数组。
如若是二维(或上述)数组,concat只好’拆开’一层数组console.log(res4)// [1,
2, 3, 4, 5] 
尽管concat()未有参数或许参数是空数组也得以达到规定的标准克隆数组的指标


5.1.1 indexOf():
  • 功能:用来寻找传进来的参数在目的函数中是还是不是存在;
  • 参数:要摸索的情节
  • 重临值:如若有,则赶回改成分在指标数组中的索引,倘诺不设有则赶回-一
  • 原数组不发生改变

var names = ['huangjin','qq','jack','hellen'];
var postion = names.indexOf('qq')
console.log(postion); // 1
  • 截取方法中,字符串有两种艺术slice / substring / substr
    ,数组方法有多个slice / splice
    其间字符串的slice 和 substring 是要起来和终结的目录,substr
    是要从头索引和长短
    数组的slice是要从头和了结索引,但是splice是要开端索引和长度
  • 搜索元素方法中,数组和字符串都有indexOf方法,不过字符串多出去三种形式charAt和charCodeAt
    其中indexOf是回去索引,charAt是回去索引对应的值,charCodeAt是回到对应值的ASCII码值。
  • 数组的遍历有四中方法,map,every,foreach,some,filter
    其间foreach早先就停不下来,全体遍历。every遍历1个就判断一下,true就一连遍历下一个,false就跳出。map正是边遍历边运算。some重回的是布尔值,符合正是true,不合乎正是false。filter重返的是顺应成分构成的数组。
  • 追加数组成分,后面unshift,后边push
    移除数组成分,前面shift,前边pop
  • 数组和字符串都有concat方法,各自连接各自的,是数组就连接受数组,字符串就连接成字符串
  • 正如重大的八个正是数组和字符串之间的转化的三个点子
    join是数组转字符串,split是字符串转数组

9. sort

效用:对数组的元素实行排序

参数:可选(函数) 规定排序规则 私下认可排序顺序为按字母升序

重回值:排好序的原数组

是或不是改变原数组:改变

varary = [1,5,7,9,12,24,56,87,92];varary2 =
[1,5,7,9,12,24,56,87,92];varary3 = [1,5,7,9,12,24,56,87,92];varres =
ary.sort();varres2 = ary2.sort(function(a,b){returna-b;

})varres3 = ary3.sort(function(a,b){returnb-a;

})//
sort的参数函数总的形参a,b正是数组排序时候的周边相比较的两项console.log(res);//
[1, 12, 24, 5, 56, 7, 87, 9, 92]console.log(res2);// [1, 5, 7, 9, 12,
24, 56, 87, 92]console.log(res3);// [92, 87, 56, 24, 12, 9, 7, 5, 1]

split()
、slice() 、splice()

5.1.2 slice():
  • 效果:数组的查询
  • 参数:slice(n,m):从索引n初步,查询到目录为m前,不包蕴m
  • 重返值:把找到的以新的数组重临
  • 原来数组不发出变动
  • 新鲜情形:
    • 假诺只写3个参数是,则从钦点索引找到最终
    • slice(0)和slice(),表示数组克隆
    • 支撑负数索引,假若传递了负数,浏览器解析时是按总司长度+负数索引
      来拍卖的

10. reverse

效果:倒序数组

参数:无

重回值:倒序后的原数组

是或不是改变原数组:改变

varary = [1,2,3,4,5];varres = ary.reverse();console.log(ary);// [5,
4, 3, 2, 1]console.log(res);// [5, 4, 3, 2, 1]

split() 将字符串切割再次来到数组

5.2 数组的字符串表示

数组

11. indexOf

作用:查找内定元素的职责

参数:array.indexOf(item,start) item:查找的成分start:字符串中开头探寻的职务

再次来到值:重回第1回查到的目录,未找到再次来到-一

是否改变原数组: 不改变

varary = [1,2,3,4,5]varres = ary.indexOf(3);console.log(ary);//
[1,2,3,4,5]console.log(res);// 2varary =
[‘a’,’b’,’c’,’d’,’c’];varres = ary.indexOf(‘c’,3);console.log(res)// 4

4858美高梅 2 

5.2.1 toString():
  • 效果:将数组转换来字符串,各要素用逗号隔开分离
  • 参数:无
  • 再次来到值:各成分以逗号分隔的字符串
  • 原数组不发生转移

var names = ['huangjin','qq','jack','hellen'];
console.log(names.toString()); 

Array.prototype

Array.prototype
属性表示构造函数的原型,并允许你向全部Array对象添加新的性质和办法。

/*
如果JavaScript本身不提供 first() 方法,
添加一个返回数组的第一个元素的新方法。
*/ 

if(!Array.prototype.first) {
    Array.prototype.first = function() {
        return this[0];
    }
}

Array.prototype本人也是贰个 Array

Array.isArray(Array.prototype); 
// true

//属性
Array.prototype.constructor
//所有的数组实例都继承了这个属性,它的值就是 Array,表明了所有的数组都是由 Array 构造出来的。
Array.prototype.length
//上面说了,因为 Array.prototype 也是个数组,所以它也有 length 属性,这个值为 0,因为它是个空数组。

12. lastIndexOf

意义:查找钦赐成分最终出现的职位

参数:array.indexOf(item,start) item:查找的因素
start:字符串中起头探寻的职责

再次回到值:再次来到查到的因素的目录,未找到重返-一

是还是不是改变原数组:不改动

varary = [‘a’,’b’,’c’,’d’,’c’];varres = ary.lastIndexOf(‘c’,3);varres2
= ary.lastIndexOf(‘c’,1);console.log(res);// 2console.log(res2);// -1

4858美高梅 3

5.2.2 join():
  • 功效:将数组转换来字符串,各成分用钦命的相间符分隔
  • 参数:分隔符
  • 重临值:各成分以钦命分隔符链接的字符串
  • 原数组不爆发转移

console.log(names.join('-')); // huangjin-qq-jack-hellen

判定是还是不是数组的法子

13. forEach

意义:循环遍历数组每壹项

参数:函数 ary.forEach(function(item,index,ary){}) item:每壹项
index:索引 ary:当前数组

返回值:无

是或不是变动原数组: 不改变

varary = [‘a’,’b’,’c’]varres =
ary.forEach(function(item,index,ary){console.log(item,index,ary);/*  a
0 [“a”, “b”, “c”]

b 1 [“a”, “b”, “c”]

c 2 [“a”, “b”, “c”]

*/returnitem;

})console.log(res)// undefined  无重临值

 

五.三. 由已有数组成立新的数组

Array.isArray( );

Array.isArray( obj );

  • 静态方法,是数组构造函数的点子

  • obj是内需质量评定的值,假如是数组,重临true,不然再次来到false

    // 下面的函数调用都返回 true
    Array.isArray([]);
    Array.isArray([1]);
    Array.isArray(new Array());
    // 鲜为人知的事实:其实 Array.prototype 也是一个数组。
    Array.isArray(Array.prototype); 
    
    // 下面的函数调用都返回 false
    Array.isArray();
    Array.isArray({});
    Array.isArray(null);
    Array.isArray(undefined);
    Array.isArray(17);
    Array.isArray('Array');
    Array.isArray(true);
    Array.isArray(false);
    Array.isArray({ __proto__: Array.prototype });
    
  • 留存包容难点(IE8及以下不扶助)

    //Polyfill
    //假如不存在 Array.isArray(),则在其他代码之前运行下面的代码将创建该方法。
    if (!Array.isArray) {
      Array.isArray = function(arg) {
        return Object.prototype.toString.call(arg) === '[object Array]';
      };
    }
    

14. map

意义:数组中的成分为原始数组成分调用函数处理后的值

参数:函数 ary.map(function(item,index,ary){})item:每壹项index:索引
ary:当前数组

返回值:新数组

是否改变原数组:不转移

varary = [‘a’,’b’,’c’]varres =
ary.map(function(item,index,ary){returnitem+1;

})console.log(res)// [“a1”, “b1”, “c1”]

slice() 数组或字符串都有 slice()
方法,截取数组则赶回数组,截取的是字符串则赶回字符串

5.3.1 concat():
  • 职能:合并多个数组,方法的调用者为多个数组,作为参数的数组会被链接到调用数组的而背后;
  • 参数:贰个还是八个,可以使数组,或其余类型
  • 再次来到值:合并后的新数组
  • 原数组不发出变动。

console.log(names.concat(['aaa','bbb']));
VM629:1 (6) ["huangjin", "qq", "jack", "hellen", "aaa", "bbb"]

console.log(names.concat(['aaa','bbb'],'ccc'));
VM631:1 (7) ["huangjin", "qq", "jack", "hellen", "aaa", "bbb", "ccc"]

console.log(names.concat(['aaa','bbb'],'ccc',123));
VM633:1 (8) ["huangjin", "qq", "jack", "hellen", "aaa", "bbb", "ccc", 123]

(Object.prototype)toString.call(arr) -> [object Array]

Object.prototype.toString.call([]) -> [ object Array]

  • 转化成字符串是”[object Array]”,能够用作度量圭臬。
  • Object.prototype.toString.call(obj).slice(8,-1); -> ===’Array’
  • ({}).toString.call(function(){}).slice(8,-1); -> ===’Function’
  • slice截取,后面包车型客车是从第四个早先,截取到尾数的第三个。

15. filter

效能:创立二个新的数组,新数组中的元素是经过检查钦定数组中符合条件的全数因素。

参数:函数 ary.filter(function(item,index,ary){})item:每一项index:索引
ary:当前数组

返回值:新数组

是否改变原数组:不改变

varary = [1,2,3,4,5,6]varres =
ary.filter(function(item){returnitem<3;

})console.log(res)// [1,2]

一个参数则截取钦点索引到结尾的成分

5.3.2 splice(n,m):
  • 成效:截取二个数组的子集作为二个新的数组
  • 参数:第1个是截取的始发索引,第二个为告竣索引,如若第一个不传,则直接截取到终极,假使四个参数都不传,则不截取;
  • 再次回到值:截取出来的要素结合的新数组
  • 原数组改变

names = ['a','b','c','d','e'];

console.log(names.splice(1,2));
VM837:1 (2) ["b", "c"]

console.log(names);
VM839:1 (3) ["a", "d", "e"]

console.log(names.splice(1));
VM841:1 (2) ["d", "e"]

console.log(names);
VM843:1 ["a"]

console.log(names.splice());
VM845:1 []

console.log(names);
VM847:1 ["a"]

拓展:splice能够用于充实和删除数组成分,删除操作跟上边一样,只是那是去除是绝对于原数组,而地点的是相对于重返值。所以删除就不做牵线,那里主要教学一下剧增成分。如下:

  • splice(n,m,x):在原有删除的功底上,用x替换删除的剧情
    • 重返值:被轮换的原有值
    • 原数组暴发改变
  • 追加操作:
    • splice(n,0,x):在改动的基本功上,壹项都不删除,把x插入到索引n的日前

names = ['a','b','c']

console.log(names.splice(1,0,'d'));
VM928:1 []

console.log(names);
VM953:1 (4) ["a", "d", "b", "c"]

instanceof

对象 instanceof 数据类型

  • console.log(obj instanceof Array);

  • (不审慎)多少个页面实行判断,会失常

    //iframe
      /*B页面嵌套到A页面中,每个页面都有一个top属性,top属性一直都指向A页面的window,所以在A页面定义的函数fn,暴露在B页面的全局环境中,在B页面中也可以调用。*/
      top.fn(); //(就是调用页面A的fn函数)
    
    //那么问题来了:
    B页面:  top.fn([]);
    A页面:  function fn(arr){
              console.log(arr instanceof Array);
              }  //此时会成为false
    
    //要直接访问A页面,访问B页面会报错,因为只打开的页面的top指向自己的window,此时调用了没有定义的函数。
    //防止被嵌套:if( top != window){
          top.location.href = ‘inner-B.html’;} //跳转到自己的地址
    

16. every

作用:检查测试数组全体因素是或不是都符合钦命条件

参数:函数 ary.every(function(item,index,ary){})item:每一项index:索引
ary:当前数组

返回值:布尔值

是或不是变动原数组: 不改变

varary = [1,2,3,4,5,6]varres =
ary.every(function(item){returnitem<3;

})varres2 = ary.every(function(item){returnitem<7;

})console.log(res)// false;console.log(res二)// true;一借使数组中检测到有3个要素不满足,则全体表明式重回false,且剩余的成分不会再开始展览检查测试。

贰 若是拥有因素都满意条件,则赶回true。

三个参数则截取索引范围 [n, m,邢台不包尾

6. 可变函数

JavaScript的数组的可变函数重即使用来在不引用数组中某些成分的地方下,改变数组内容。

数COO度

  • 数组的length属性总是比数组中定义的终极二个成分的下标大学一年级,表示数组霜月素的个数。

  • 数组的length属性在创立数组的时候开始化,在累加新成分的时候数老董度改变

    //如果函数中没有参数,a为空数组
    var a = new Array();   // a.length 被初始化为 0
    
    //如果函数参数是一个,参数表示函数的长度
    var b = new Array(10); // b.length 被初始化为 10
    
    //如果函数参数是两个及以上,参数表示数组内容
    var c = new Array("one", "two", "three");  // c.length 被初始化为 3
    c[3] = "four";        // c.length 被更新为 4
    c[10] = "blastoff";   // c.length 变为 11 
    
  • 安装属性length的值能够转移数组的大大小小,设置值小则被从后截断,设置值大则剩下的值都为undefined

    var a = new Array("one", "two", "three");
    a.length = 2;  //["one", "two"]
    a.length = 5;  //["one", "two", undefined × 3]
    

17. some

成效:检查测试数组中的成分是不是满足钦定条件

参数:函数 ary.some(function(item,index,ary){})item:每一项index:索引
ary:当前数组

返回值:布尔值

是还是不是变动原数组:不转移

varary = [1,2,3,4,5,6]varres =
ary.some(function(item){returnitem<3;

})console.log(res)// true;一 万壹有2个因素满意条件,则表明式重回true,
剩余的要素不会再实施行检查测。

② 要是未有满意条件的要素,则赶回false。

4858美高梅 4

陆.壹 从数组的前因后果添英镑素

遍历数组

 

6.1.1 push():
  • 功能:将多少个要素添加到数组末尾
  • 参数:要添加的要素内容,能够是五个
  • 重返值:添加新成分后数组的长度
  • 原数组改变

var names = ['a','b','c']

names.push('d')
4
console.log(names)
VM297:1 (4) ["a", "b", "c", "d"]

map

var new_array = array.map (function(value,index,array){ },thisArg);

  • 遍历数组,能够将数组转化为二个新的数组,新数组的值由map方法回调函数的重返值决定。

  • 回调函数的首先个参数是数组的值,第2个参数是索引,第八个参数是被调用的数组。thisArg可选,执行
    callback函数时 使用的this值。

  • 假如 thisArg 参数有值,则每一回 callback
    函数被调用的时候,this都会针对thisArg参数上的这么些目的。借使简单了
    thisArg参数,大概赋值为null或undefined,则 this 指向全局对象 。

  • 重临值是新的数组

 var arrNew = arr.map(function(value,index){
     console.log(‘索引是’+index+”,内容是:”+value+);
   })

 let numbers = [1, 5, 10, 15];
 let roots = numbers.map(function(x) {
      return x * 2;
   });
// roots is now [2, 10, 20, 30]
// numbers is still [1, 5, 10, 15]
  • 求数组中每一个成分的平方根

    var numbers = [1, 4, 9];
    var roots = numbers.map(Math.sqrt);
    /* roots的值为[1, 2, 3], numbers的值仍为[1, 4, 9] */
    

  • 行使 map 重新格式化数组中的对象

    var kvArray = [{key:1, value:10}, 
                   {key:2, value:20}, 
                   {key:3, value: 30}];
    var reformattedArray = kvArray.map(function(obj){ 
      //obj指的是每一个数组元素,是一个对象
       var rObj = {};
       rObj[obj.key] = obj.value;
       return rObj;
    });
    // reformattedArray is now [{1:10}, {2:20}, {3:30}], 
    // kvArray is still [{key:1, value:10}, {key:2, value:20}, {key:3, value: 30}]
    

  • 将数组中的单词转换到对应的复数形式

    var words = ["foot", "goose", "moose", "kangaroo"];
    //定义函数
    function fuzzyPlural(single) {
      //所有的o变成e
      var result = single.replace(/o/g, 'e');  
      if( single === 'kangaroo'){
        result += 'se';
      }
      return result; 
    }
    //遍历每一个元素
    console.log(words.map(fuzzyPlural));
    // ["feet", "geese", "meese", "kangareese"]
    

  • 怎么着让1个string使用map方法获得字符串中每一种字符所对应的ASCII码组成的数组

    var map = Array.prototype.map
    var a = map.call("Hello World", function(x) { 
      return x.charCodeAt(0); 
    })
    // a的值为[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
    

  • 何以遍历querySelectorAll获得动态指标集合

    var elems = document.querySelectorAll('select option:checked');
    var values = Array.prototype.map.call(elems, function(obj) {
      return obj.value;
    });
    
  • 反转字符串

    var str = '12345';
    Array.prototype.map.call(str, function(x) {
      return x;
    }).reverse().join(''); 
    
    // Output: '54321'
    
  • parseInt等有多个参数的函数要专注

    var a = ['1','2','3'];
    var b = a.map(function(x){
      return parseInt(x);
     }); //[1,2,3]
    
     // 下面的语句返回什么呢:
      ["1", "2", "3"].map(parseInt);
      // 你可能觉的会是[1, 2, 3]
      // 但实际的结果是 [1, NaN, NaN]
    
      //parseInt有两个参数,第二个数是进制数
      //所以以上函数主要执行的是
      var a  = ['1','2','3'];
      var b = a.map(function(ele,index,array){
        return parseInt(ele,index);
        //第三个参数parseInt会忽视, 但第二个参数不会
        // parseInt把传过来的索引值当成进制数来使用
        //而第二个参数假如经过 Number 函数转换后为 0 或 NaN,则将会忽略
        //parseInt(1,0);       1
        //parseInt(2,1);       NaN
        //parseInt(3,2);       NaN
      })
    
      //解决如下
      function returnInt(element){
        return parseInt(element,10);
      }
      ["1", "2", "3"].map(returnInt);
      // 返回[1,2,3]
    

  • 包容难点 IE八及以下不帮助

    // 实现 ECMA-262, Edition 5, 15.4.4.19
    // 参考: http://es5.github.com/#x15.4.4.19
    // 兼容代码
    if (!Array.prototype.map) {
      Array.prototype.map = function(callback, thisArg) {
    
        var T, A, k;
        if (this == null) {
          throw new TypeError(" this is null or not defined");
        }
        // 1. 将O赋值为调用map方法的数组.
        var O = Object(this);
        // 2.将len赋值为数组O的长度.
        var len = O.length >>> 0;
        // 3.如果callback不是函数,则抛出TypeError异常.
        if (Object.prototype.toString.call(callback) != "[object Function]") {
          throw new TypeError(callback + " is not a function");
        }
        // 4. 如果参数thisArg有值,则将T赋值为thisArg;否则T为undefined.
        if (thisArg) {
          T = thisArg;
        }
        // 5. 创建新数组A,长度为原数组O长度len
        A = new Array(len);
        // 6. 将k赋值为0
        k = 0;
        // 7. 当 k < len 时,执行循环.
        while(k < len) {
          var kValue, mappedValue;
          //遍历O,k为原数组索引
          if (k in O) {
            //kValue为索引k对应的值.
            kValue = O[ k ];
            // 执行callback,this指向T,参数有三个.分别是kValue:值,k:索引,O:原数组.
            mappedValue = callback.call(T, kValue, k, O);
            // 返回值添加到新数组A中.
            A[ k ] = mappedValue;
          }
          // k自增1
          k++;
        }
        // 8. 返回新数组A
        return A;
      };      
    }
    

splice() 操作数组,再次来到数组。功效强大,可增添、删除、替换元素

6.1.2 unshift():
  • 效果:将一个因素添加到数组的先头
  • 参数:要添加的因素内容,能够是多个
  • 重回值:添加新元素后的数主任度
  • 原数组改变

console.log(names)
VM297:1 (4) ["a", "b", "c", "d"]

console.log(names.unshift(1));
VM351:1 5

console.log(names)
VM353:1 (5) [1, "a", "b", "c", "d"]

forEach

4858美高梅,array.forEach(function(value,index,array){},thisArg);

  • 遍历数组,跑起来就停不下来,调用就会遍历整个数组,无法中断循环

  • 回调函数的率先个参数表示数组中的每三个元素,第二个代表索引号,第捌个代表正在操作的数组,可选

  • 返回值undefined

    //实例
    function logArrayElements(element, index, array) {
        console.log("a[" + index + "] = " + element);
    }
    
    // 注意索引2被跳过了,因为在数组的这个位置没有项
    [2, 5, ,9].forEach(logArrayElements);
    // a[0] = 2
    // a[1] = 5
    // a[3] = 9
    
    [2, 5,"" ,9].forEach(logArrayElements);
    // a[0] = 2
    // a[1] = 5
    // a[2] = 
    // a[3] = 9
    
  • 使用thisArg

    因为thisArg参数(this)传给了forEach(),每趟调用时,它都被传给callback函数,作为它的this值。可是在ES陆的箭头函数表达式传入函数参数,thisArg参数会被忽略,因为箭头函数在词法上绑定了this值。

    function Counter() {
        this.sum = 0;
        this.count = 0;
    }
    
    Counter.prototype.add = function(array) {
        array.forEach(function(entry) {
            this.sum += entry;
            ++this.count;
        }, this);
        //console.log(this);
    };
    
    var obj = new Counter();
    obj.add([1, 3, 5, 7]);
    obj.count; 
    // 4 === (1+1+1+1)
    obj.sum;
    // 16 === (1+3+5+7)
    

  • 包容难题 IE八及以下不支持

    // Production steps of ECMA-262, Edition 5, 15.4.4.18
    // Reference: http://es5.github.io/#x15.4.4.18
    if (!Array.prototype.forEach){
      Array.prototype.forEach = function(callback, thisArg) {
    
        var T, k;
        if (this == null) {
          throw new TypeError(' this is null or not defined');
        }
        // 1. Let O be the result of calling toObject() passing the
        // |this| value as the argument.
        var O = Object(this);
        // 2. Let lenValue be the result of calling the Get() internal
        // method of O with the argument "length".
        // 3. Let len be toUint32(lenValue).
        var len = O.length >>> 0;
        // 4. If isCallable(callback) is false, throw a TypeError exception. 
        // See: http://es5.github.com/#x9.11
        if (typeof callback !== "function") {
          throw new TypeError(callback + ' is not a function');
        }
        // 5. If thisArg was supplied, let T be thisArg; else let
        // T be undefined.
        if (arguments.length > 1) {
          T = thisArg;
        }
        // 6. Let k be 0
        k = 0;
        // 7. Repeat, while k < len
        while (k < len) {
          var kValue;
          // a. Let Pk be ToString(k).
          //    This is implicit for LHS operands of the in operator
          // b. Let kPresent be the result of calling the HasProperty
          //    internal method of O with argument Pk.
          //    This step can be combined with c
          // c. If kPresent is true, then
          if (k in O) {
            // i. Let kValue be the result of calling the Get internal
            // method of O with argument Pk.
            kValue = O[k];
            // ii. Call the Call internal method of callback with T as
            // the this value and argument list containing kValue, k, and O.
            callback.call(T, kValue, k, O);
          }
          // d. Increase k by 1.
          k++;
        }
        // 8. return undefined
      };
    }
    

多个参数时去除从钦命索引到数组末尾的元素

六.二 从数组的首尾删除成分

every

array.every(function(value,index){});

  • 基于近来回调函数的重回值决定是不是开始展览下贰回巡回

    • 设若未有return true,则只是实施2遍
    • 回调函数的再次回到值为true,继续循环
    • 重返值是false,甘休循环
  • 首先个参数是数组中的每二个要素 第三个参数表示索引号

  • 包容难点 IE8及以下不援助

    //兼容问题
    if (!Array.prototype.every){
      Array.prototype.every = function(fun /*, thisArg */){
        'use strict';
    
        if (this === void 0 || this === null)
          throw new TypeError();
    
        var t = Object(this);
        var len = t.length >>> 0;
        if (typeof fun !== 'function')
            throw new TypeError();
    
        var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
        for (var i = 0; i < len; i++){
          if (i in t && !fun.call(thisArg, t[i], i, t))
            return false;
        }
        return true;
      };
    }
    

四个参数时
splice(n,m)
,删除从索引n早先的m个成分,若m为0则不删除成分,所以回来的是空数组,原数组无变化

6.2.1 pop():
  • 功能:删除数组末尾的因素
  • 参数:无
  • 重返值:删除末尾成分后数组的长短
  • 原数组改变

some(再次来到布尔)

array.some(callback[,thisArg])

  • callback 被调用时传出两个参数:成分的值,成分的目录,被遍历的数组

  • thisArg参数,将会把它传给被调用的callback,作为this
    值。不然,在非严俊情势下将会是全局对象,严俊形式下是undefined

  • 数组中一旦有叁个满足条件,重回true,否则再次回到false

    //callback
    function isBigEnough(element, index, array){
      return (element >= 10);
    }
    var passed = [2, 5, 8, 1, 4].some(isBigEnough);
    // passed is false
    passed = [12, 5, 8, 1, 4].some(isBigEnough);
    // passed is true
    
  • some有包容难题,IE捌及以下不帮衬

    //兼容代码
    if (!Array.prototype.some){
      Array.prototype.some = function(fun /*, thisArg */){
        'use strict';
        if (this === void 0 || this === null)
           throw new TypeError();
    
        var t = Object(this);
        var len = t.length >>> 0;
        if (typeof fun !== 'function')
          throw new TypeError();
    
        var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
        for (var i = 0; i < len; i++){
          if (i in t && fun.call(thisArg, t[i], i, t))
            return true;
        }
        return false;
      };
    }
    

4858美高梅 5

6.2.2 shift():
  • 成效:删除数组的率先个要素,数组后边的袁术向前移动一个人
  • 参数:无
  • 再次回到值:删除成分后数组的尺寸
  • 原数组改变

filter

var new_array = arr.filter(callback[, thisArg])

  • 看清数组中的每一项是不是都满足条件,全体满意条件的则赶回新数组

  • callback 用来测试数组的各种成分的函数。调用时接纳参数 (element,
    index, array)
    回来true表示保留该因素(通过测试),false则不保留

  • thisArg 可选,执行callback时的用于this的值

  • 这个概念去看some

    function isBigEnough(element) {
      return element >= 10;
    }
    var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
    // filtered is [12, 130, 44]
    
    //另一种写法
    var arr = [12, 5, 8, 130, 44];
    var filt = arr.filter(function(element){
      return element >= 10;
    })//filt is [12, 130, 44]
    

  • filter有兼容难点,IE8及以下不帮衬

    //兼容代码
    //假定 fn.call 等价于 Function.prototype.call 的初始值,且 Array.prototype.push 拥有它的初始值。
    if (!Array.prototype.filter)
    {
      Array.prototype.filter = function(fun /*, thisArg */)
      {
        "use strict";
    
        if (this === void 0 || this === null)
          throw new TypeError();
    
        var t = Object(this);
        var len = t.length >>> 0;
        if (typeof fun !== "function")
          throw new TypeError();
    
        var res = [];
        var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
        for (var i = 0; i < len; i++)
        {
          if (i in t)
          {
            var val = t[i];
    
            // NOTE: Technically this should Object.defineProperty at
            //       the next index, as push can be affected by
            //       properties on Object.prototype and Array.prototype.
            //       But that method's new, and collisions should be
            //       rare, so use the more-compatible alternative.
            if (fun.call(thisArg, val, i, t))
              res.push(val);
          }
        }
    
        return res;
      };
    }
    

多个或以上参数

6.3 从数组的中游地点添加和删除成分

splice():

  • splice(n,m):从第n到m删除
    • 重返值:被剔除的成分
    • 原数组爆发转移
  • 扩张操作:
    • splice(n,0,x):在改动的底子上,一项都不删除,把x插入到索引n的前边

截取数组

4858美高梅 6

陆.肆 数组排序

slice(索引)

array.slice(start,end)

  • start

    • 正数,数组片段开首截取的下标
    • 负数,从数组尾巴部分开端算起,-壹是终极三个,-2是尾数第1个
    • 截取三个生成新数组,不影响原本数组,参数起首从0开首,从-壹终了
  • end

    • 甘休的后三个因素的数组下标
    • 并未有点名参数,则暗许是到数组甘休
    • 万1是负数,便是从最终初步算起
  • 截取二个生成新数组,不影响原本数组,包涵从start到end(不包含该因素)内定的array元素

    var 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]; 
    //IE 4存在的Bug: 返回[1,2,3]
    

4858美高梅 7

6.4.1 reverse():
  • 功效:颠尾数组
  • 参数: 无
  • 重回值:颠倒后的数组
  • 原数组改变

splice(长度,可替换)

array.splice(start, deleteCount, value, …)

  • 参数有start,deleteCount,options(替换)

    • start初步插入和(或)删除的数组成分的下标
    • deleteCount
      从start起头(包涵start)要删减的成分个数。参数可选,要是未有点名,就暗中认可到结尾的拥有因素
    • value,… 要插入的数组值,从start所指的下标处早先插入
  • 重回值是截取到的数组

    //定义一个数组
    var arr = [10,20,30,40,50,60,70,80,90];
    //三个参数的情况  从索引为三的地方数三个,替换这三个数
    var result = arr.splice(3,3,100,200,300);
    //arr = [10,20,30,100,200,300,70,80,90];
    //result = [40,50,60];
    //两个参数的情况  从索引为三的地方截取三个
    var result1 = arr.splice(3,3);
    //arr = [10,20,30,70,80,90];
    //result = [100,200,300];
    //一个参数的情况,是从索引为三的地方一直到最后截取
    var result2 = arr.splice(3);
    //arr = [70,80,90]
    //result2 = [10,20,30]
    

4858美高梅 8

6.4.2 sort():
  • 功用:按规则排列数组
  • 参数:无或然回调函数,当无参数时,依照Unicode排序
  • 再次回到值:排序后的数组
  • 原数组改变

function compare(a,b) {
  return a-b; // 如果为正,按升序,为0位置不变,为负则按降序
}
var nums = [1,2,5,3,55,43,4];
nums.sort(compare);

老是数组

 

七. 迭代器方法

join(字符串)

var string = array.join()

  • 一旦未有参数,暗中同意用逗号作为分割符

  • 只要有参数,则参数是用于分隔数组成分的字符或字符串

  • 回去字符串,通过把array每种成分转换来字符串,用参数连接起来

  • 能够用String对象的split()方法实行相反的操作,把字符串依照参数分隔成数组

    var a = new Array(1, 2, 3, "testing");
    //a = [1,2,3,testing]
    var s = a.join("+");  // s 是字符串"1+2+3+testing"
    

如上为百度同时本身实施后做的读书笔记,心累,前路漫漫
+﹏+

7.一 不生成新数组的迭代器方法

即,不发出任何新的数组,要么对于数组中的各种成分执行某种操作,要么重返四个值。

concat

var new_array = array1.concat(‘array2′,’array3’)

  • 参数至少是多个

  • 回来三个新数组

  • 假定操作的参数是三个数组,那么丰裕的是数组中的成分,而不是数组

    var 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]]
    

 

7.1.1 forEach():
  • 职能:对数组中的每一种成分进行规定的操作
  • 参数:函数,即对每一个成分执行的操作函数
  • 返回值:无
  • 原数组不更改

console.log(names)
VM586:1 (5) [1, "a", "b", "c", "d"]

console.log(names.forEach(function(a){console.log('f'+a)}));
VM624:1 f1
VM624:1 fa
VM624:1 fb
VM624:1 fc
VM624:1 fd
VM624:1 undefined

console.log(names)
VM626:1 (5) [1, "a", "b", "c", "d"]

添法郎素


7.1.2 every():
  • 作用:匹配全部因素都复合某些规则
  • 参数:重回值为布尔类型的函数
  • 再次来到值:假若数组中的各样成分经过该函数再次回到为true,则赶回为true,不然为false
  • 原数组不爆发变更

var nums = [1,2,3,4,5]

nums.every(function(i){if(i>0){return true}});
true
nums.every(function(i){if(i>1){return true}});
false

push

array.push(value,…)

  • 要添加到array的尾声,能够是七个也能够是三个

  • 重返值是添加后的数组的长短

  • pop()方法和push()方法能够提供先进后出的栈的效果

  • 在目的中添法郎素

    var obj = {
        length: 0,
        addElem: function addElem(elem){
            [].push.call(this, elem);
        }
    };
    obj.addElem({});
    obj.addElem({});
    console.log(obj.length);
    // → 2
    

 

7.1.3 some():
  • 功能:匹配数组中是不是有成分都复合某些规则
  • 参数:重返值为布尔类型的函数
  • 重返值:如若数组中的只要有八个因素经过该函数重返为true,则赶回为true,不然为false
  • 原数组不爆发变动

unshift

array.unshift(value, …)

  • 参数是要添加到底部的1个或三个值
  • 回去数组的新长度

不定时记下境遇的新点子

7.1.4 reduce():
  • 职能:接收三个函数作为累加器,数组中的每一种值(从左到右)开端减小,最终总计为一个值。
  • 参数:用于实践各样数组成分的函数
  • 重返值:再次回到总括结果
  • 原数组不改变

var numbers = [65, 44, 12, 4];

function getSum(total, num) {
    return total + num;
}
function myFunction(item) {
    console.log(numbers.reduce(getSum));
}

移除成分

ES六 的数组方法

7.2 生成新数组的迭代器方法

pop

array.pop()

  • 删去的是数组中的最终三个要素,数首席营业官度-壹
  • 再次回到值是删除的要素
  • 万一数组为空,则数首席营业官度不变,重临undefined
  • pop()方法和push()方法可以提供先进后出的栈的功力

find()
接收二个办法作为参数,方法内部再次回到3个标准化,遍历全数因素,执行给定的含有条件重回值的函数,符合该原则的要素会被重回,若未有符合条件的成分,重临undefined

7.2.1 map():
  • 效益:类似于forEach(),差距在于map()会回到二个新数组
  • 参数:用于实践各样数组成分的函数
  • 重返值:再次来到3个新数组,数组中的成分为原始数组成分调用函数处理后的值
  • 原数组不更改

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

function myFunction() {
    console.log(numbers.map(Math.sqrt));
}

shift

array.shift()

  • 移除的是数组中的第壹个要素,别的的向前移

  • 归来的是移除成分的值

  • 假如是空数组,则不实行其余操作,重返undefined

findIndex() 遍历全部因素,再次回到第一个符合条件成分的目录

7.2.2 filter():
  • 成效:和every() 类似,差距在于every()重返的是布尔值,而filter()
    再次来到的是新数组,该数组包罗应用回调函数后值为true的因素
  • 参数:用于实践种种数组成分的函数
  • 重返值:再次来到三个含有应用回调函数后值为true的因素的数组
  • 原数组不更改

数组排序

三、总结

  • JavaScript中的数组其实是2个非同一般的靶子
  • 创办数组的方法根本有两种,但常用的是 [] 的形式
  • 数组转字符串:toString()、 join()
  • 字符串转数组:split()
  • 数组的增加和删除改查:
    • 增加:push()、 unshift()、 splice(n,0,x)、 concat()
    • 删除:pop()、shift()、splice(n,m)
    • 更改:splice(n,m,x)
    • 查询:indexOf()、slice(n,m)
  • 数组排序: reverse()、sort()
  • 数组遍历: forEach()、map()、every()、some()、filter()等

sort

arr.sort(compareFunction)

  • compareFunction 可选。是用来钦点按什么顺序实行排序的函数,可选

  • 回去排序后的数组

  • 假如不传参数,将遵守字母(字符编码)顺序最数组开始展览排序,所以要把数组中的成分转化为字符串以便实行相比较

  • 如过依照别的顺序实行排序,就要提供相比较函数(参数a,b)

    • a < b 排序后a在b以前,就回来二个小于0的值
    • a = b 返回0
    • a > b 排序后a在b之后,重回叁个大于0的值

    // 按照数字顺序排序的排序函数
    //a-b 表示升序排列
    function  sortAscending(a, b) { return a - b; }
    //b-a 表示降序排列
    function  sortDescending(a,b) { return b - a; }
    
    var a = new Array(33, 4, 1111, 222);
    // 按照字母顺序的排序
    a.sort();             // 结果为: 1111, 222, 33, 4
    // 按照数字顺序的排序
    a.sort(sortAscending);  //结果为: 4, 33, 222, 1111
    a.sort(sortDescending); //结果为:1111,222,33,4
    

reverse

array.reverse( )

  • 颠倒数组相月素的相继,不创造新数组

    var a = new Array(1, 2, 3); 
    // a = [1,2,3]    a[0] == 1, a[2] == 3;
    a.reverse(  );             
    //Now  a = [3,2,1]  a[0] == 3, a[2] == 1;
    

搜索数组

indexOf(重返索引)

arr.indexOf(searchElement)

arr.indexOf(searchElement[, fromIndex = 0])

  • searchElement 要物色的因素

  • fromIndex 开首查找的岗位

    • fromIndex >= length,意味着不会在数组里摸索,重临-壹
    • 负值,-壹从最后3个开端查找,-二从尾数第三个起来找
  • 重回值假设找到了成分就回去成分在数组中的索引地点,若未有找到则赶回-壹

    var array = [2, 5, 9];
    array.indexOf(2);     // 0
    array.indexOf(7);     // -1
    array.indexOf(9, 2);  // 2
    array.indexOf(2, -1); // -1
    array.indexOf(2, -3); // 0
    
  • 找出内定成分出现的兼具位置

    var indices = [];
    var array = ['a', 'b', 'a', 'c', 'a', 'd'];
    var element = 'a';
    //判断元素在不在数组里面
    var idx = array.indexOf(element);
    //如果元素在数组里面,就循环
    while (idx != -1) {
      //把索引推入新数组中
      indices.push(idx);
      //从找到元素的下一个索引开始继续查找
      idx = array.indexOf(element, idx + 1);
    }
    console.log(indices);
    // [0, 2, 4]
    
  • 判定三个要素是还是不是在数组里,不在则更新数组

    //定义一个函数
    function update(vegs, veg) {
      //如果数组中不存在
        if (vegs.indexOf(veg) === -1) {
          //在数组中添加元素
            vegs.push(veg);
          console.log('New vegs is :' + vegs);
          //如果在数组中存在
        } else if (vegs.indexOf(veg) > -1) {
          //这个元素已经存在在数组中
            console.log(veg + ' already exists in the vegs.');
        }
    }
    
    var vegs = ['potato', 'tomato', 'chillies', 'green-pepper'];
     update(vegs, 'spinach'); 
      // New vegs is : potato,tomato,chillies,green-papper,spinach
     update(vegs, 'spinach');
      // spinach already exists in the vegs.
    
  • 包容难点 IE八及以下不般配

      //兼容代码
      // Production steps of ECMA-262, Edition 5, 15.4.4.14
      // Reference: http://es5.github.io/#x15.4.4.14
      if (!Array.prototype.indexOf) {
        Array.prototype.indexOf = function(searchElement, fromIndex) {
    
          var k;
          // 1. Let O be the result of calling ToObject passing
          //    the this value as the argument.
          if (this == null) {
            throw new TypeError('"this" is null or not defined');
          }
          var O = Object(this);
          // 2. Let lenValue be the result of calling the Get
          //    internal method of O with the argument "length".
          // 3. Let len be ToUint32(lenValue).
          var len = O.length >>> 0;
          // 4. If len is 0, return -1.
          if (len === 0) {
            return -1;
          }
          // 5. If argument fromIndex was passed let n be
          //    ToInteger(fromIndex); else let n be 0.
          var n = +fromIndex || 0;
          if (Math.abs(n) === Infinity) {
            n = 0;
          }
          // 6. If n >= len, return -1.
          if (n >= len) {
            return -1;
          }
          // 7. If n >= 0, then Let k be n.
          // 8. Else, n<0, Let k be len - abs(n).
          //    If k is less than 0, then let k be 0.
          k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
          // 9. Repeat, while k < len
          while (k < len) {
            // a. Let Pk be ToString(k).
            //   This is implicit for LHS operands of the in operator
            // b. Let kPresent be the result of calling the
            //    HasProperty internal method of O with argument Pk.
            //   This step can be combined with c
            // c. If kPresent is true, then
            //    i.  Let elementK be the result of calling the Get
            //        internal method of O with the argument ToString(k).
            //   ii.  Let same be the result of applying the
            //        Strict Equality Comparison Algorithm to
            //        searchElement and elementK.
            //  iii.  If same is true, return k.
            if (k in O && O[k] === searchElement) {
              return k;
            }
            k++;
          }
          return -1;
        };
      }
    

©copyright burning.

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有