有没有一种方法可以实现chain.push和.shift数组方法

Is there a way to method chain .push and .shift array methods?

本文关键字：方法 chain 实现 push 数组 shift 一种 有没有      更新时间：2023-09-26

这是我的代码：

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

我正在尝试创建一个函数队列，它以"数组"answers"项"作为参数。我需要

  1. 将项添加到数组的末尾
  2. 删除数组的第一个元素
  3. 返回已删除的元素

我的代码不起作用。你能帮我弄清楚吗？

只是不要链接方法调用：

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

因为arr.push返回数组的长度，所以不能像那样连锁移位

只需进行

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

绝对不变

推送

[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中使用第二个param索引和第三个param数组使事情变得非常灵活。使用这种方法可以尝试更多。

另一种（更简单）方式，但有点鲁莽，并非一成不变

推送

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

这意味着你可以使用数组的原型，使用你想要链接的更简单的方法，但只需返回this，你就很好了，但缺点是你可能会把依赖数组的其他代码搞砸，或者可能会覆盖你不想要的其他方法。

或

另一种方法是制作一个类似于so 的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]

有一种使用concat而不是推送的黑客攻击

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

应该会得到你想要的结果。

实际上，所有的答案都是正确的，我只想在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数组，因为它是一个队列。

相关文章：