javascript - 如何使用 RxJS 将我的数据映射为正确的格式

Question

1。发生了什么事

我有一些数据需要映射成正确的格式才能有用我想做的事。我得到的数据的长度也可能有所不同(意味着，它可能是一个对象，或 10 个，或 200 个)。然而——我只关心前 6 个该数组中的元素。当只有例如3个元素，那么我仍然想发出结果。但我不想在以下情况下发出更改:值没有改变(源可以触发更新，但数据可能仍然是一样的)。

我可能得到的数据如下所示:

var data = {
  myData: {
    cats: [             // data I care about!
      {
        name: 'Mr. Cat',
        someReallyLongPropertyNameThatLinksToAnImage: 'http://cat/ur/day.jpg',
        ... // SOME MORE PROPS
      },
      {
        name: 'Supercat',
        someReallyLongPropertyNameThatLinksToAnImage: 'http://cat/ur/day2.jpg',
        ... // SOME MORE PROPS
      },
      ... etc.
    ]  
  },
  foo: {                // data I don't care about...
    bar: [{...}...]     // data I don't care about...
  },
  baz: {
    butz: [{...}...]    // data I don't care about...
  }
}

我想要的结果应该是这样的:

var result = [
  {
    image: 'http://url/to/1',
    title: 'title 1'
  },
  {
    image: 'http://url/to/2',
    title: 'title 2'
  },
  {
    image: 'http://url/to/3',
    title: 'title 3'
  }
]

2。有什么问题吗？

我的问题是，我不知道如何:

• 发出 n 个项目的更改(不发出每个项目)

  看起来 bufferWithCount(6) 是我正在寻找的东西，但当该数组中只有 3 个元素时，这不起作用!

• 仅当结果数组不同时才发出更改

  当结果看起来与之前完全相同时，则不触发更改事件。

3。我做了什么(但显然不起作用)

Rx.Observable.of(data)
  .map((e) => data.myStuff.cats)
  .map((arr) => {
    // this would emit a change for EACH element, right? ugh.
    return Rx.Observable.fromArray(arr)
      // only care about the first 6 elements? if it only
      // has 3, would this still work?
      .take(6)
      // pluck out the props I need. (maybe not neccessary, but anyway)
      .pluck('someReallyLongPropertyNameThatLinksToAnImage', 'name') 
      .map((el) => {
        // map the data into the right format
        return {
          title: el.name
          image: el.someReallyLongPropertyNameThatLinksToAnImage
        }
      })
  })
  .distinctUntilChanged() // yeah... this doesn't work either I guess..
  .subscribe(
    (result) => console.log(result)
  )

Answer 1

我认为使用 Array.prototype.slice 方法而不是尝试使用 Rx 破解解决方案可能是最简单的。

至于使用distinctUntilChanged，您将需要使用比较器函数来告诉它如何比较我想象的两个数组:

Rx.Observable.just(data)
  //Arrays slice will only take up to six items from the array 
  .map((e) => e.myData.cats.slice(0, 6))
  //Only updates if the array values have changed
  .distinctUntilChanged(null, (cur, next) => /*Implement your array value comparison*/)
  //Converts the values into something we can work with
  .map((arr) => arr.map(el => { 
                         return {name : el.name, 
                                 image : el.someBlahBlah}; 
                })
  )
  //Receives a series of arrays only if the values have changed.
  .subscribe();

至于如何进行数组比较，这完全是另一回事，实际上取决于您，但您可以看到这个答案 here .

本质上，最简单的解决方案是迭代数组并检查对象中的字段是否不同，这里稍微修改了链接中的代码:

// attach the .equals method to Array's prototype to call it on any array
Array.prototype.equals = function (array) {
  // if the other array is a falsy value, return
  if (!array)
      return false;

  // compare lengths - can save a lot of time 
  if (this.length != array.length)
      return false;

  for (var i = 0, l=this.length; i < l; i++) {
      //Compare properties here, 
      //just make sure you are comparing value instances not references     
      if (this[i].name != array[i].name) { 
          // Warning - two different object instances will never be equal: {x:20} != {x:20}
          return false;   
      }           
  }       
  return true;
}