绝对如此，

Question

这是我的代码：

var myArr = [1,2,3,4,5];
function queue(arr, item) {
  return arr.push(item).shift();
}

我试图创建一个带有＆＃34;数组的函数队列＆＃34;和＆＃34;项目＆＃34;作为参数。我需要

将项目添加到数组的末尾
删除数组的第一个元素
返回已删除的元素。

我的代码无效。你能帮我搞清楚吗？

Answer 1

只是不要链接方法调用：

function queue(arr, item) {
  arr.push(item);
  return arr.shift();
}

或者，如果您想要一个声明，

function queue(arr, item) {
  return arr.push(item), arr.shift();
}

或者，如果你够疯狂，你可以继承Array并添加一个可链接的推送：

class MyArray extends Array {
  chainablePush(item) {
    this.push(item);
    return this;
  }
}
var myArr = new MyArray(1,2,3);
myArr.chainablePush(4).shift(); // 1
myArr; // MyArray [2,3,4];

Answer 2

因为arr.push返回数组的长度，你不能像那样链接移位

只需这样做

function queue(arr, item) {
  arr.push(item);
  return arr.shift();
}

Answer 3

使用concat代替推送

function queue(arr, item) {
  return arr.concat([item]).shift();
}

应该为您带来所需的结果。

Answer 4

实际上，所有答案都是正确的，我只想在ES6中添加另一种方式：

const Queue = (array, item) => { array.push(item); return array.splice(0,1); }

或

const Queue = (array, item) => { array.push(item); return array.shift(); }

您不应该使用concat而不是push，因为在这种情况下，您应该更改myArr数组，因为它是一个队列。

Answer 5

绝对如此，

推动

[1, 2].concat([3])
// [1,2,3]

班次

[1,2,3].filter((e, i, a) => i != 0)
// [2,3]

流行

[1,2,3].filter((e, i, a) => i != a.length - 1)
// [1,2]

取消变速

[1,2,3].concat([0]).map((e, i, a) => i == 0 ? a[a.length - 1] : a[i-1])
// [0,1,2,3]

在map和filter内部使用第二参数索引和第三参数数组使事情变得非常灵活。您可以使用该方法尝试更多。

另一种（更轻松的）方式，但略为鲁ck且并非一成不变

推动

Array.prototype.pushChain = function(item) {
  this.push(item)
  return this
}
[1,2,3].pushChain(4)
//[1,2,3,4]

这意味着您可以使用数组的原型，并使用要链接的更简单的方法，但是只需返回this，就可以了，但是缺点是您可能会弄乱依赖于Array的其他代码是或可能会覆盖您不打算使用的其他方法。

OR

另一种方法是使JavaScript ES6 +类型的类像这样

class ImmutableChainedArray {
  constructor(arr) {
    this._arr = Array.isArray(arr) ? arr : []
  }
  push(item) {
    this._arr = this._arr.concat([item])
    return this
  }
  pop() {
    this._arr = this._arr
      .filter((e, i, a) => i != a.length - 1)
     return this
  }
  shift() {
    this._arr = this._arr
      .filter((e, i, a) => i != 0)
    return this
  }
  unshift(item) {
    this._arr = this._arr
      .concat([item])
      .map((e, i, a) => i == 0 ? a[a.length - 1] : a[i-1])
    return this
  }
  // the rest of them are easy...

  val() {
    return this._arr
  }
}

然后使用

const ica = new ImmutableChainedArray([1])
ica.unshift(0).push(2).shift().pop().val()
// ends up with [1]

是否有方法链接.push和.shift数组方法？

5 个答案:

绝对如此，