假设我有一个具有这种状态结构的 redux store:

{
  items: {
    "id1" : {
      foo: "foo1",
      bar: "bar1"
    },
    "id2": {
      foo: "foo2",
      bar: "bar2"
    } 
  }
}

这家商店通过接收元素的全新值(value)而发展:

const reduceItems = function(items = {}, action) {
  if (action.type === 'RECEIVE_ITEM') {
    return {
      ...items,
      [action.payload.id]: action.payload,
    };
  }
  return items;
};

我想显示一个 Root View ，它呈现一个 SubItem View 列表，它只提取部分状态。 例如 SubItem View 只关心 foos，应该得到它:

function SubItem({ id, foo }) {
  return <div key={id}>{foo}</div>
}

因为我只关心状态的“子部分”，所以这就是我想传递给“哑巴” Root View 的内容:

const Root = function({ subitems }) {
  // subitems[0] => { id: 'id1', foo: "foo1" }
  // subitems[1] => { id; 'id2', foo : "foo2" }
  const children = subitems.map(SubItem);
  return <div>{children}</div>;
};

我可以很容易地连接这个组件来订阅状态的变化:

function mapStatesToProps(state) {    
 return {
    subitems: xxxSelectSubItems(state)
 }
}
return connect(mapStatesToProps)(Root)

我的基本问题是当我不关心的状态部分 (bar) 发生变化时会发生什么。 甚至，当我收到一个项目的新值时，foo 和 bar 都没有改变:

setInterval(() => {
    store.dispatch({
      type: 'RECEIVE_ITEM',
      payload: {
        id: 'id1',
        foo: 'foo1',
        bar: 'bar1',
      },
    });
  }, 1000);

如果我使用“朴素”的选择器实现:

// naive version
function toSubItem(id, item) {
  const foo = item.foo;
  return { id, foo };
}

function dumbSelectSubItems(state) {
  const ids = Object.keys(state.items);
  return ids.map(id => {
    const item = state.items[id];
    return toSubItem(id, item);
  });
}

然后列表在每次调用时都是一个全新的对象，我的组件每次都会被渲染，没有任何意义。

当然，如果我使用“常量”选择器，它总是返回相同的列表，因为连接的组件是纯的，它会被重新渲染(但这只是为了说明连接的组件是纯的):

// fully pure implementation
const SUBITEMS = [
  {
    id: 'id0',
    foo: 'foo0',
  },
];
function constSelectSubItems(state) {
  return SUBITEMS;
}

现在，如果我使用列表发生变化但包含相同元素的“almostConst”版本，这会变得有点棘手。

const SUBITEM = {
  id: 'id0',
  foo: 'foo0',
};
function almostConstSelectSubItems(state) {
  return [SUBITEM];
}

现在，可以预见的是，由于列表不同，即使里面的项目相同，组件也会每秒重新渲染一次。

这是我虽然“重新选择”可以提供帮助的地方，但我想知道我是否没有完全忽略这一点。我可以让 reselect 使用此行为:

const reselectSelectIds = (state, props) => Object.keys(state.items);
const reselectSelectItems = (state, props) => state.items;
const reselectSelectSubItems = createSelector([reSelectIds, reSelectItems], (ids, items) => {
  return ids.map(id => toSubItem(id, items));
});

但是它的行为与原始版本完全一样。

所以:

• 尝试内存一个数组是没有意义的吗？
• 可以重新选择处理这个吗？
• 我应该改变国家的组织吗？
• 我是否应该使用“deepEqual”测试在 Root 上实现 shouldComponentUpdate？
• 我是否应该放弃 Root 是连通分量，而让每个 LeafItems 本身都是连通分量？
• immutable.js 有帮助吗？
• 这实际上不是问题吗，因为 React 很聪明，一旦计算出虚拟 dom 就不会重绘任何东西？

我尝试做的事情可能毫无意义，并且在我的 redux 存储中隐藏了一个问题，所以请随意陈述明显的错误。

最佳答案

您关于新数组引用导致重新呈现和排序选择器在正确轨道上的说法绝对是正确的，但您确实需要改变一些方法。

与其让选择器立即返回 Object.keys(state.item)，不如处理对象本身:

const selectItems = state => state.items;

const selectSubItems = createSelector(
    selectItems,
    (items) => {
        const ids = Object.keys(items);
        return ids.map(id => toSubItem(id, items));
    }
);

这样，数组只会在 state.items 对象被替换时重新计算。

除此之外，是的，您可能还想查看连接您的各个列表项组件，以便每个组件都按 ID 查找自己的数据。请参阅我的博文 Practical Redux, Part 6: Connected Lists, Forms, and Performance举些例子。我在Redux Techniques#Selectors and Normalization 也有一堆相关文章。和 Performance#Redux Performance我的 React/Redux links list 的部分.

关于javascript - 你如何使用 `reselect` 来内存一个数组？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44305631/