js将类数组对象转换成数组对象,javascript框架设计读书笔记之数组的恢宏与修补

大雅的数组降维——Javascript中apply方法的妙用

2016/02/18 · JavaScript
· apply,
数组

初稿出处:
ralph_zhu   

将多维数组(尤其是二维数组)转化为一维数组是工作支付中的常用逻辑,除了行使节能的大循环转换以外,大家还足以接纳Javascript的语言特征完毕越发简单优雅的变换。本文将从节俭的轮回转换开始,逐一介绍三种常用的转换方法,并借此简单回看Array.prototype.concat方法和Function.prototype.apply方法。
以下代码将以把二维数组降维到一维数组为例。

  1. 勤政的变换

JavaScript

function reduceDimension(arr) { var reduced = []; for (var i = 0; i
< arr.length; i++) { for (var j = 0; j < arr[i].length; j++) {
reduced.push(arr[i][j]); } } return reduced; }

1
2
3
4
5
6
7
8
9
function reduceDimension(arr) {
    var reduced = [];
    for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr[i].length; j++) {
            reduced.push(arr[i][j]);
        }
    }
    return reduced;
}

此情势思路简单,利用再一次循环遍历二维数组中的每个元素并置于新数组中。

 

  1. 利用concat转换
    先来回看一下MDN上对于该方法的介绍:
    “concat creates a new array consisting of the elements in the object on
    which it is called, followed in order by, for each argument, the
    elements of that argument (if the argument is an array) or the argument
    itself (if the argument is not an array).”

即如若concat方法的参数是一个因素,该因素会被间接插入到新数组中;若是参数是一个数组,该数组的相继要素将被插入到新数组中;将该特性应用到代码中:

JavaScript

function reduceDimension(arr) { var reduced = []; for (var i = 0; i
< arr.length; i++){ reduced = reduced.concat(arr[i]); } return
reduced; }

1
2
3
4
5
6
7
function reduceDimension(arr) {
    var reduced = [];
    for (var i = 0; i < arr.length; i++){
        reduced = reduced.concat(arr[i]);
    }
    return reduced;
}

arr的每一个因素都是一个数组,作为concat方法的参数,数组中的每一个子元素又都会被单独插入进新数组。
动用concat方法,大家将再也循环简化为了单重循环。

 

  1. 利用apply和concat转换
    依据惯例,先来回想一下MDN上对此apply方法的介绍:
    “The apply() method calls a function with a given this value and
    arguments provided as an array.”

即apply方法会调用一个函数,apply方法的首先个参数会作为被调用函数的this值,apply方法的第三个参数(一个数组,或类数组的靶子)会作为被调用对象的arguments值,也就是说该数组的一一要素将会挨个成为被调用函数的各样参数;将该特性应用到代码中:

function reduceDimension(arr) { return
Array.prototype.concat.apply([], arr); }

1
2
3
function reduceDimension(arr) {
    return Array.prototype.concat.apply([], arr);
}

arr作为apply方法的第四个参数,本身是一个数组,数组中的每一个元素(依然数组,即二维数组的第二维)会被看做参数依次传入到concat中,效果一样[].concat([1,2],
[3,4], [5,6])。
应用apply方法,咱们将单重循环优化为了一行代码,很简短有型有木有啊~

读者也可参考本文思路,自己使用递归达成N维数组降维的逻辑。

3 赞 8 收藏
评论

亚洲必赢官网 1

在正儿八经浏览器中,好像只要对象存在length属性,就能把它转换为数组,但IE就不尽然。

1.indexOf和lastIndexOf方法:

在JavaScript中,可以通过三种办法成立数组,构造函数和数组直接量,
其中后者为首选办法。数组对象继承自Object.prototype,对数组执行typeof操作符重临‘object’而不是‘array’。但是执行[]
instanceof
Array重临true。别的,还有类数组对象是题材更复杂,如字符串对象,arguments对象。arguments对象不是Array的实例,但却有个length属性,并且值能通过索引获取,所以能像数组一样通过轮回操作。

[Ctrl+A 全选
注:如需引入外部Js需刷新才能履行]

因为IE7在数组对象上行使indexOf会报错,所以须要重写一个包容性的。

 

随着大家看看各大类库的处理:

复制代码 代码如下:

在本文中,我将复习一些数组原型的方法,并追究这几个办法的用法。

复制代码 代码如下:

Array.prototype.lastIndexOf(item,index){
  var n = this.length,i = (index==null||index>n-1)?n-1:index;
  if(i < 0) i = n+i;
  for(;i>=0;i–)
    if(this[i] === item)   //全等判定,indexOf,lastIndexOf
      return i;
  return -1;
}

 

//jQuery的makeArray
var makeArray = function( array ) {
var ret = [];
if( array != null ){
var i = array.length;
// The window, strings (and functions) also have ‘length’
if( i == null || typeof array === “string” || jQuery.isFunction(array)
|| array.setInterval )
ret[0] = array;
else
while( i )
ret[–i] = array[i];
}
return ret;
}

2.shuffle方法:对数组进行洗牌。

循环.forEach

jQuery对象是用来囤积与处理dom元素的,它首要依靠于setArray方法来安装与尊敬长度与索引,而setArray的参数必要是一个数组,因而makeArray的身价格外重大。那办法保障即使没有参数也要回去一个空数组。
Prototype.js的$A方法

复制代码 代码如下:

断言.some和.every

复制代码 代码如下:

function shuffle(target){
  var i = target.length, j ,temp;
  for(;i>0;j=parseInt(Math.random() * i), x =
target[–i],target[i] = target[js将类数组对象转换成数组对象,javascript框架设计读书笔记之数组的恢宏与修补。j],target[j]=x){}   
    
//假设length=10,那么Math.random()*10->[0,10),parseInt后,[0,9],随机的接纳一个与数组最终一项沟通。第二次巡回,[0,8],与数组的尾数第二项交流。
  return target;
}

.join和.concat的区别

function $A(iterable) {
if (!iterable) return [];
if (iterable.toArray) return iterable.toArray();
var length = iterable.length || 0, results = new Array(length);
while (length–) results[length] = iterable[length];
return results;
}

3.数组的平坦化处理:flatten,再次回到一个一维数组

栈和队列.pop,.push,.shift和.unshift

mootools的$A方法

复制代码 代码如下:

模型映射.map

复制代码 代码如下:

function flatten(arr){
  var result = [];
  arr.forEach(function(item){
    if(Array.isArray(item))   result.concat(flatten(item));
    else  result.push(item);
  });
  return result;
}

查询.filter

function $A(iterable){
if (iterable.item){
var l = iterable.length, array = new Array(l);
while (l–) array[l] = iterable[l];
return array;
}
return Array.prototype.slice.call(iterable);
};

4.unique措施:对数组去重操作

排序.sort

Ext的toArray方法

此格局,面试官最欣赏问了,因为它有多种兑现形式,最平常的是多少个for循环。一般通晓的最多的是选择一个目的a,然后一个for循环数组arr,每一遍if(a[arr[i]])是不是留存,不设有则push到您新定义的数组result中。存在就注解,重复,由此不要push到result中。那种方案,针对”123″,123,会觉得相同的,其实一个是字符串,一个是数字,不应该认为是如出一辙的。

计算.reduce和.reduceRight

复制代码 代码如下:

就此就出现了以下方法:[1,”1″,”1″]

复制.slice

var toArray = function(){
return isIE ?
function(a, i, j, res){
res = [];
Ext.each(a, function(v) {
res.push(v);
});
return res.slice(i || 0, j || res.length);
} :
function(a, i, j){
return Array.prototype.slice.call(a, i || 0, j || a.length);
}
}()

复制代码 代码如下:

万能的.splice

Ext的规划比较巧妙,作用也正如强硬。它一初始就自行执行自身,将来就绝不判定浏览器了。它还有四个可选参数,对转移的纯数组举办操作。
最后看dojo的_toArray,dojo的落实一连那么怪异的。
和Ext一样,前边八个参数是可选,只可是第四个是偏移量,最终一个是已部分数组,用于把新生的新组元素合并过去。

 if ((typeof obj[array[i]]) != (typeof array[i]) ||
obj[array[i]] != array[i]) {
  a.push(array[亚洲必赢官网 ,i]);
  obj[array[i]] = array[i];
}

查找.indexOf

复制代码 代码如下:

//首先判断项目是还是不是同样,若是一致,就判断他们的值是不是等于,不对等就存进去,相等就印证从前曾经存在这些值了。

in操作符

(function(){
var efficient = function(obj, offset, startWith){
return (startWith||[]).concat(Array.prototype.slice.call(obj,
offset||0));
};
var slow = function(obj, offset, startWith){
var arr = startWith||[];
for(var x = offset || 0; x >obj.length; x++){
arr.push(obj[x]);
}
return arr;
};
dojo._toArray =
dojo.isIE ? function(obj){
return ((obj.item) ? slow : efficient).apply(this, arguments);
} :
efficient;
})();

设若类型不均等,这里存在二种情况,

走进.reverse

你或许感兴趣的小说:

  • JavaScript中的类数组对象介绍
  • JavaScript 里的类数组对象
  • js
    用于检测类数组对象的函数方法
  • JQuery
    $.each遍历JavaScript数组对象实例
  • js使用Array.prototype.sort()对数组对象排序的法子
  • js接收并转发Java中的数组对象的点子
  • JS从非数组对象转数组的法门小结
  • javascript
    Array数组对象的恢弘函数代码
  • JavaScript类数组对象转换为数组对象的方式实例分析

首先种处境,obj从前曾经存了此数据了,比如:obj[123] =
123,现在array[i] = “123”,这时,typeof
obj[array[i]])是数字,而typeof array[i]是字符串,因而存入数组中。

 

第三种境况是obj还没存此数据,比如:array[i] = “123”,obj[“123”] =
undefind,这时typeof obj[array[i]])就是typeof undefined =
undefined,不等于typeof array[i],存入数组中。

 

此种方法,可以解决字符串和数字同样的场馆,不过力不从心缓解对象相同的动静。比如:a
= {1:2}, b ={2:1};

万一您想测试上边的例子,您可以复制并粘贴到你的浏览器的控制斯科普里。

先是次巡回时,typeof obj[a] = undefined,typeof a =
Object。存入obj[a] =a.其实就是obj[Object] = a;

 

第二次巡回时,typeof obj[b] 等于typeof obj[Object]实质上就是typeof a =
object,typeof b = object.因而进来到obj[array[i]] !=
array[i]|,也就是obj[b]->obj[Object]->a != b,因而存入

循环.forEach

obj[b] = b;也就是obj[Object] = b;覆盖了事先的obj[Object] = a;

 

那种情景下,就会见世所有的目的,都只会存最后一个对象值。

那是JavaScript原生数组方法中最简便的不二法门。不用思疑,IE7和IE8不协助此格局。

当考虑对象时,我就会采取以下这种艺术:

 

复制代码 代码如下:

forEach方法需求一个回调函数,数组内的每个元素都会调用两回此办法,此措施须要多少个参数如下:

for(var i = 0; i < temp.length; i++){
                for(var j = i + 1; j < temp.length; j++){
                        if(temp[i] === temp[j]){
                                temp.splice( j, 1 );
                                j–;
                        }
                }
        }
 return temp;

 

5.数组排序:sort方法,若是要排序的是目的,可以协调写一个compare(a,b){if(a.age>b.age)
return 1;else return -1;},A.sort(compare).

value 当前操作的数组元素

6.min回去数组最小值:return Math.min.apply(0,array);

index 当前操作元素的数组索引

7.unshift在ie6,7下不回去数主管度。

array 当前数组的引用

复制代码 代码如下:

别的,可以传递可选的第二个参数,作为每个调用函数的上下文(this)。

if([].unshift(1)!==1)  
//往空数组中以前方添加一项,其余浏览器会回去1,而IE6,7不会回到数首席营业官度。那时就实施if语句
{
  var _unshift = Array.prototype.unshift;      //函数威吓。
  Array.prototype.unshift = function(){
    _unshift.apply(this,arguments);
    return this.length;
  }
}

 

8.splice在一个参数的状态下,IE8以及以下版本默认第三个参数为0,而任何浏览器是数首席执行官度。

[‘_’, ‘t’, ‘a’, ‘n’, ‘i’, ‘f’, ‘]’].forEach(function (value, index,
array) {

复制代码 代码如下:

    this.push(String.fromCharCode(value.charCodeAt() + index + 2))

if([1,2,3].splice(1).length == 0)  
//IE8以及以下版本会等于0,其余版本会等于3,进入if里面
{
  var _splice = Array.prototype.splice;
  Array.prototype.splice = function(a){
    if(arguments.length == 1)   //假设只有一个参数时
    {
      return _splice.call(this,a,this.length);
    }else{
      return _splice.apply(this,arguments);
    }
  }
}

}, out = [])

其一方法会改变数组的选项,因而数组的push,pop,shift,unshift(那多少个点子也会修改数组的拔取)都会调用那几个方法来促成。

 

这边有一个地点要求注意:

out.join(”)

复制代码 代码如下:

// <- ‘awesome’

var color = new Array(‘red’,’blue’,’yellow’,’black’);
var color2 = color.splice(2,0,’brown’,’pink’);
alert(color); //
red,blue,brown,pink,yellow,black,在yellow选项上,初步操作,若是剔除为0,则增进的选项是在yellow以前插入。切记。

.join函数我将在下文提及,上边例子中,它将数组中的差距因素拼接在联合,类似于如下的功用:out[0]

 
那里请大家去看下splice和slice的界别,再次来到值,以及对原数组的影响。

  • ” + out[1] + ” + out[2] + ” + out[n]。

如上就是本节的情节的精简版了,即使简单,但重点都在,希望对我们阅读本节的时候能有所辅助

 

你或许感兴趣的篇章:

  • 十大热点的JavaScript框架和库
  • 长远解析JavaScript框架Backbone.js中的事件机制
  • JavaScript框架是什么样?怎样才能叫做框架?
  • 超赞的出手创设JavaScript框架的事无巨细教程
  • javascript框架设计等等工厂
  • javascript框架规划之浏览器的嗅探和特点侦测
  • javascript框架企划之种子模块
  • javascript框架统筹之框架分类及至关首要作用
  • 2014
    年最热点的21款JavaScript框架推荐
  • javascript框架企划读书笔记之字符串的壮大和修补
  • javascript框架统筹读书笔记之模块加载系统
  • javascript框架企划读书笔记之种子模块
  • JavaScript框架(iframe)操作计算
  • 怎么取舍Javascript框架(Javascript
    Framework)
  • 详细介绍8款超实用JavaScript框架
  • brook javascript框架介绍
  • 16个最风靡的JavaScript框架[推荐]
  • 怎么选用适合你的JavaScript框架

大家不可以用break中断forEach循环,抛出尤其是不明智的法子。幸运的是,大家有任何的办法中断操作。

 

断言.some和.every

 

比方你已经用过.NET的枚举,这个艺术的名字和.Any(x => x.IsAwesome) 和
.All(x => x.IsAwesome)极度相像。

 

那个措施和.forEach类似,须要一个分包value,index,和array多少个参数的回调函数,并且也有一个可选的第四个上下文参数。MDN对.some的描述如下:

 

some将会给数组里的每一个因素执行五次回调函数,直到有一个回调函数再次回到true位置。假设找到对象元素,some立刻重返true,否则some再次来到false。回调函数只对曾经指定值的数组索引执行;它不会对已删除的或未指定值的元素执行。

 

复制代码

max = -Infinity

satisfied = [10, 12, 10, 8, 5, 23].some(function (value, index, array)
{

    if (value > max) max = value

    return value < 10

})

 

console.log(max)

// <- 12

 

satisfied

// <- true

复制代码

在意,当回调函数的value < 10
条件满意时,中断函数循环。.every的行事表现看似,但回调函数要赶回false而不是true。

 

.join和.concat的区别

 

.join方法常常和.concat混淆。.join(分隔符)方法创造一个字符串,会将数组里面每个元素用分隔符连接。假使没有提供分隔符,默许的相间符为“,”。.concat方法创制一个新数组,其是对原数组的浅拷贝(注意是浅拷贝哦)。

 

.concat 的申明用法:array.concat(val, val2, val3, valn)

.concat 再次回到一个新书组

array.concat()没有参数的景况下,会重临原数组的浅拷贝

浅拷贝意味着新数组和原数组保持同一的靶子引用,那日常是好事。例如:

 

复制代码

var a = { foo: ‘bar’ }

var b = [1, 2, 3, a]

var c = b.concat()

 

console.log(b === c)

// <- false

 

b[3] === a && c[3] === a

// <- true

复制代码

栈和队列.pop,.push,.shift和.unshift

 

每个人都精晓向数组添泰铢素用.push。但你领悟五回可以加上多少个要素呢?如下[].push(‘a’,
‘b’, ‘c’, ‘d’, ‘z’)。

 

.pop方法和.push成对利用,它回到数组的最后元素并将元素从数组移除。即使数组为空,重返void
0(undefined)。使用.push和.pop大家能随意模拟出LIFO(后进先出或先进后出)栈。

 

复制代码

function Stack () {

    this._stack = []

}

 

Stack.prototype.next = function () {

    return this._stack.pop()

}

 

Stack.prototype.add = function () {

    return this._stack.push.apply(this._stack, arguments)

}

 

stack = new Stack()

stack.add(1,2,3)

 

stack.next()

// <- 3

复制代码

反而,大家得以用.unshift 和 .shift模拟FIFO(先进先出)队列。

 

复制代码

function Queue () {

    this._queue = []

}

 

Queue.prototype.next = function () {

    return this._queue.shift()

}

 

Queue.prototype.add = function () {

    return this._queue.unshift.apply(this._queue, arguments)

}

 

queue = new Queue()

queue.add(1,2,3)

 

queue.next()

// <- 1

复制代码

用.shift或.pop能很简单遍历数组元素,并做一些操作。

 

复制代码

list = [1,2,3,4,5,6,7,8,9,10]

 

while (item = list.shift()) {

    console.log(item)

}

 

list

// <- []

复制代码

模型映射.map

 

map 方法会给原数组中的每个元素(必须有值)都调用三次 callback
函数.callback 每回执行后的重临值组合起来形成一个新数组.
callback函数只会在有值的目录上被调用;
那么些向来没被赋过值或者使用delete删除的目录则不会被调用。——MDN

 

Array.prototype.map方法和方面大家提到的.forEach,.some和.every有同等的参数:.map(fn(value,
index, array), thisArgument)。

 

复制代码

values = [void 0, null, false, ”]

values[7] = void 0

result = values.map(function(value, index, array){

    console.log(value)

    return value

})

 

// <- [undefined, null, false, ”, undefined × 3, undefined]

复制代码

undefined × 3
值解释.map不会在没被赋过值或者采纳delete删除的目录上调用,但他俩如故被含有在结果数组中。map在遍历或改变数组方面至极有用,如下所示:

 

复制代码

// 遍历

[1, ‘2’, ’30’, ‘9’].map(function (value) {

    return parseInt(value, 10)

})

// 1, 2, 30, 9

 

[97, 119, 101, 115, 111, 109, 101].map(String.fromCharCode).join(”)

// <- ‘awesome’

 

// 一个映射新对象的通用方式

items.map(function (item) {

    return {

        id: item.id,

        name: computeName(item)

    }

})

复制代码

查询.filter

 

filter对种种数组元素执行三遍回调函数,并回到一个由回调函数再次来到true的因素
组成的新数组。回调函数只会对曾经指定值的数组项调用。

 

用法例子:.filter(fn(value, index, array),
thisArgument)。把它想象成.Where(x => x.IsAwesome) LINQ
expression(假诺你熟知C#),或者SQL语句里面的WHERE。考虑到.filter仅重临callback函数重回真值的值,下边是一些幽默的事例。没有传递给回调函数测试的要素被概括的跳过,不会含有进重回的新书组里。

 

复制代码

[void 0, null, false, ”, 1].filter(function (value) {

    return value

})

// <- [1]

 

[void 0, null, false, ”, 1].filter(function (value) {

    return !value

})

// <- [void 0, null, false, ”]

复制代码

排序.sort(比较函数)

 

若是未提供比较函数,元素会更换为字符串,并按字典许排列。例如,在字典序里,“80”排在“9”以前,但实在大家希望的是80在9过后(数字排序)。

 

像一大半排序函数一样,Array.prototype.sort(fn(a,b))要求一个包涵八个测试参数的回调函数,并且要发生一下二种重返值之一:

 

借使a在b前,则重回值小于零

设若a和b是等价的,则重临值等于零

假使a在b后,则重返值大于零

复制代码

[9,80,3,10,5,6].sort()

// <- [10, 3, 5, 6, 80, 9]

 

[9,80,3,10,5,6].sort(function (a, b) {

    return a – b

})

// <- [3, 5, 6, 9, 10, 80]

复制代码

计算.reduce和.reduceRight

 

第一reduce函数不是很好了解,.reduce从左到右而.reduceRight从右到左循环遍历数组,每一次调用接收方今为止的部分结实和当前遍历的值。

 

两种形式都有如下典型用法:.reduce(callback(previousValue, currentValue,
index, array), initialValue)。

 

previousValue是最终被调用的回调函数的再次回到值,initialValue是早先时previousValue被发轫化的值。currentValue
是当下被遍历的元素值,index是时下元素在数组中的索引值。array是对调用.reduce数组的简便引用。

 

一个头名的用例,使用.reduce的求和函数。

 

复制代码

Array.prototype.sum = function () {

    return this.reduce(function (partial, value) {

        return partial + value

    }, 0)

};

 

[3,4,5,6,10].sum()

// <- 28

复制代码

地点提到假使想把数组连成一个字符串,能够动用.join。当数组的值是目标的情事下,除非对象有能重返其合理值的valueof或toString方法,否则.join的表现和您期望的不雷同。不过,我们能够使用.reduce作为对象的字符串生成器。

 

复制代码

function concat (input) {

    return input.reduce(function (partial, value) {

        if (partial) {

            partial += ‘, ‘

        }

        return partial + value

    }, ”)

}

 

concat([

    { name: ‘George’ },

    { name: ‘Sam’ },

    { name: ‘Pear’ }

])

// <- ‘George, Sam, Pear’

复制代码

复制.slice

 

和.concat类似,调用.slice缺省参数时,再次回到原数组的浅拷贝。slice函数须求七个参数,一个是伊始地点和一个收尾地点。

 

Array.prototype.slice能被用来将类数组对象转换为真正的数组。

 

Array.prototype.slice.call({ 0: ‘a’, 1: ‘b’, length: 2 })

// <- [‘a’, ‘b’]

除却,另一个宽广用途是从参数列表中移除最初的多少个因素,并将类数组对象转换为确实的数组。

 

复制代码

function format (text, bold) {

    if (bold) {

        text = ‘<b>’ + text + ‘</b>’

    }

    var values = Array.prototype.slice.call(arguments, 2)

 

    values.forEach(function (value) {

        text = text.replace(‘%s’, value)

    })

 

    return text

}

 

format(‘some%sthing%s %s’, true, ‘some’, ‘other’, ‘things’)

// <- <b>somesomethingother things</b>

复制代码

万能的.splice

 

.splice是自己最欢娱的原生数组函数之一。它同意你剔除元素,插入新因素,或在相同职位同时拓展上述操作,而只利用一个函数调用。注意和.concat和.slice分歧的是.splice函数修改原数组。

 

复制代码

var source = [1,2,3,8,8,8,8,8,9,10,11,12,13]

var spliced = source.splice(3, 4, 4, 5, 6, 7)

 

console.log(source)

// <- [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ,13]

 

spliced

// <- [8, 8, 8, 8]

复制代码

你可能早已注意到,它也回到被删去的因素。假使您想遍历已经删除的数组时那恐怕会派上用场。

 

复制代码

var source = [1,2,3,8,8,8,8,8,9,10,11,12,13]

var spliced = source.splice(9)

 

spliced.forEach(function (value) {

    console.log(‘removed’, value)

})

// <- removed 10

// <- removed 11

// <- removed 12

// <- removed 13

 

console.log(source)

// <- [1, 2, 3, 8, 8, 8, 8, 8, 9]

复制代码

查找.indexOf

 

通过.indexOf,我们得以查找数组元素的职位。若是没有匹配元素则赶回-1。我发现自家用的很多的一个格局是连连相比较,例如a
=== ‘a’ || a === ‘b’ || a ===
‘c’,或者即便唯有七个结果的比较。在这种情状下,你也足以使用.indexOf,像这么:[‘a’,
‘b’, ‘c’].indexOf(a) !== -1。

 

留神那对针对同一个引用的对象同样适用。第三个参数是始于询问的序幕地方。

 

复制代码

var a = { foo: ‘bar’ }

var b = [a, 2]

 

console.log(b.indexOf(1))

// <- -1

 

console.log(b.indexOf({ foo: ‘bar’ }))

// <- -1

 

console.log(b.indexOf(a))

// <- 0

 

console.log(b.indexOf(a, 1))

// <- -1

 

b.indexOf(2, 1)

// <- 1

复制代码

比方您想从后迈入搜索,.lastIndexOf能派上用场。

 

in操作符

 

在面试中新手简单犯的荒唐是混淆.indexOf和in操作符,如下:

 

复制代码

var a = [1, 2, 5]

 

1 in a

// <- true, 但因为 2!

 

5 in a

// <- false

复制代码

问题的首假如in操作符检索对象的键而非值。当然,这在性质上比.indexOf快得多。

 

var a = [3, 7, 6]

 

1 in a === !!a[1]

// <- true

in操作符类似于将键值转换为布尔值。!!表明式平日被开发者用来重新取非一个值(转化为布尔值)。实际上相当于强制转换为布尔值,任何为真正值被转为true,任何为假的值被转换为false。

 

走进.reverse

 

那办法将数组中的元素翻转并替换原来的要素。

 

var a = [1, 1, 7, 8]

 

a.reverse()

// [8, 7, 1, 1]

和复制不一致的是,数组本身被改变。在其后的稿子中本身将开展对这个概念的明亮,去探视如何创立一个库,如Underscore或Lo-Dash。

其中后者为首选办法。数组对象继承自Object.prototype,对数组执行type…

网站地图xml地图