Javascript 确定Redux中单个项的本地缓存是否过时

在本例中，有一个名为

shouldFetch

的函数，它接受

（state，subreddit）

，并返回是否应获取给定

subreddit

中的项

除了单个项目，您如何可靠地完成相同的工作？表示一个函数，它接受

shouldFetch（state，subreddit，id）

并返回

布尔值

真正的问题是如何保存提取每个项目时的
元数据
？我们存储的是在
lastdupdated
中获取列表的时间，而不是每个项目上次更新的时间

您需要：
1.确定项目是否在缓存（存储）中为偶数
2.确定当前项目当前是否正在获取（通过列表获取或通过单个获取）
3.确定项目是否过时

除了为lastUpdated/isFetching构建客户端数据库之外，还有什么好方法可以实现这一点吗

除了单个项目，您如何可靠地完成相同的工作？表示接受shouldFetch（state、subreddit、id）并返回布尔值的函数

作为链接中的shouldFetchPosts函数，您必须创建自己的函数来检查某些元数据是否有内容。这一部分不是关于redux的，而是关于您的元数据、您如何在redux存储中形成数据，或者您需要的元数据是否可以在服务器响应中保存

因此，您必须创建一个函数，该函数获取一些数据，并检查给定数据中您在函数体中编写的逻辑

真正的问题是如何保存提取每个项目时的元数据？我们存储的是在lastUpdated中获取列表的时间，而不是每个项目上次更新的时间

您的意思是您正在更新列表项，并且没有向服务器请求更新的列表吗？如果不是，如果您只是发送一个更新项目的请求，并且可能也在您的redux状态下更新项目，那么这应该是可以的。由于您的应用程序是SPA，如果您确定服务器上的数据已更改，则可以轻松更改redux状态，并且可能不会发出服务器请求

你需要：1。确定项目是否在缓存（存储）2中。确定当前项目是否正在获取（通过列表获取或通过单个获取）3。确定项目是否过时

现在我的想法是，您实际上应该检查组件中的某些数据是否过时，如果正在获取某些数据，您不应该允许用户触发重新蚀刻，同样，如果某些数据不过时，您可以在组件中轻松创建一个函数，决定是否需要用户触发操作

将所有这些逻辑移到redux操作会使redux文件变得丑陋。不过，您可以塑造您的redux状态，边做边改进，并检查来自该状态的一些元数据以做出决定

除了单个项目，您如何可靠地完成相同的工作？表示接受shouldFetch（state、subreddit、id）并返回布尔值的函数

作为链接中的shouldFetchPosts函数，您必须创建自己的函数来检查某些元数据是否有内容。这一部分不是关于redux的，而是关于您的元数据、您如何在redux存储中形成数据，或者您需要的元数据是否可以在服务器响应中保存

因此，您必须创建一个函数，该函数获取一些数据，并检查给定数据中您在函数体中编写的逻辑

真正的问题是如何保存提取每个项目时的元数据？我们存储的是在lastUpdated中获取列表的时间，而不是每个项目上次更新的时间

您的意思是您正在更新列表项，并且没有向服务器请求更新的列表吗？如果不是，如果您只是发送一个更新项目的请求，并且可能也在您的redux状态下更新项目，那么这应该是可以的。由于您的应用程序是SPA，如果您确定服务器上的数据已更改，则可以轻松更改redux状态，并且可能不会发出服务器请求

你需要：1。确定项目是否在缓存（存储）2中。确定当前项目是否正在获取（通过列表获取或通过单个获取）3。确定项目是否过时

现在我的想法是，您实际上应该检查组件中的某些数据是否过时，如果正在获取某些数据，您不应该允许用户触发重新蚀刻，同样，如果某些数据不过时，您可以在组件中轻松创建一个函数，决定是否需要用户触发操作

将所有这些逻辑移到redux操作会使redux文件变得丑陋。不过，您可以塑造您的redux状态，边做边改进，并检查来自该状态的一些元数据以做出决定
 我实际上构建了一个包，可以帮助以缓存方式与API交互。它保留提取完成时间戳，该时间戳有助于确定缓存是否过时。例如：

import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import api from 'redux-cached-api-middleware';
import Items from './Items';
import Error from './Error';

class ExampleApp extends React.Component {
  componentDidMount() {
    this.props.fetchData();
  }

  render() {
    const { result } = this.props;
    if (!result) return null;
    if (result.fetching) return <div>Loading...</div>;
    if (result.error) return <Error data={result.errorPayload} />;
    if (result.successPayload) return <Items data={result.successPayload} />;
    return <div>No items</div>;
  }
}

ExampleApp.propTypes = {
  fetchData: PropTypes.func.isRequired,
  result: PropTypes.shape({}),
};

const CACHE_KEY = 'GET/items';

const enhance = connect(
  state => ({
    result: api.selectors.getResult(state, CACHE_KEY),
  }),
  dispatch => ({
    fetchData() {
      return dispatch(
        api.actions.invoke({
          method: 'GET',
          headers: { Accept: 'application/json' },
          endpoint: 'https://my-api.com/items/',
          cache: {
            key: CACHE_KEY,
            strategy: api.cache
              .get(api.constants.CACHE_TYPES.TTL_SUCCESS)
              .buildStrategy({ ttl: 10 * 60 * 1000 }), // 10 minutes
          },
        })
      );
    },
  })
);

export default enhance(ExampleApp);

*
CachedApiState
对象由以下字段组成：

{
  fetching: boolean, // is fetching in progress
  fetched: boolean, // was any fetch completed
  error: boolean, // was last response an error
  timestamp: ?number, // last response timestamp
  successPayload: ?any, // last success response payload
  errorPayload: ?any, // last error response payload
}

实际上，我构建了一个包，可以帮助以缓存方式与API交互。它保留提取完成时间戳，该时间戳有助于确定缓存是否过时。例如：

import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import api from 'redux-cached-api-middleware';
import Items from './Items';
import Error from './Error';

class ExampleApp extends React.Component {
  componentDidMount() {
    this.props.fetchData();
  }

  render() {
    const { result } = this.props;
    if (!result) return null;
    if (result.fetching) return <div>Loading...</div>;
    if (result.error) return <Error data={result.errorPayload} />;
    if (result.successPayload) return <Items data={result.successPayload} />;
    return <div>No items</div>;
  }
}

ExampleApp.propTypes = {
  fetchData: PropTypes.func.isRequired,
  result: PropTypes.shape({}),
};

const CACHE_KEY = 'GET/items';

const enhance = connect(
  state => ({
    result: api.selectors.getResult(state, CACHE_KEY),
  }),
  dispatch => ({
    fetchData() {
      return dispatch(
        api.actions.invoke({
          method: 'GET',
          headers: { Accept: 'application/json' },
          endpoint: 'https://my-api.com/items/',
          cache: {
            key: CACHE_KEY,
            strategy: api.cache
              .get(api.constants.CACHE_TYPES.TTL_SUCCESS)
              .buildStrategy({ ttl: 10 * 60 * 1000 }), // 10 minutes
          },
        })
      );
    },
  })
);

export default enhance(ExampleApp);

*
CachedApiState
对象由以下字段组成：

{
  fetching: boolean, // is fetching in progress
  fetched: boolean, // was any fetch completed
  error: boolean, // was last response an error
  timestamp: ?number, // last response timestamp
  successPayload: ?any, // last success response payload
  errorPayload: ?any, // last error response payload
}

你没有发表任何关于如何真正做到这一点的建议，而是概述了我在问题中已经提到的要点。我正在寻找一个可能的真正的解决方案，以确定应用程序是否应该从服务器获取单个项目（而不是项目数组）。对不起，伙计，我感谢你的帮助，但你的帖子对我没有帮助。我正在寻找一个现实生活中的解决方案，或者是用一种特定的方式来构建物品集合的
redux
存储，或者是用一些技术