【问题标题】:React / Redux Async not waiting for returned responseReact / Redux Async 不等待返回的响应
【发布时间】:2017-04-21 09:10:27
【问题描述】:

首先我的代码 是 工作(一切都正确导出等),但它不等待数据的异步返回。 我正在为我的异步中间件使用 redux-thunk

我有一个名为 async.js

的操作
export function itemsHasErrored(bool) {
    return {
        type: 'ITEMS_HAS_ERRORED',
        hasErrored: bool
    };
}

export function itemsIsLoading(bool) {
    return {
        type: 'ITEMS_IS_LOADING',
        isLoading: bool
    };
}

export function itemsFetchDataSuccess(items) {
    return {
        type: 'ITEMS_FETCH_DATA_SUCCESS',
        items
    };
}

export function itemsFetchData(url) {
    return (dispatch) => {
        dispatch(itemsIsLoading(true));

        fetch(url)
            .then((response) => {
                if (!response.ok) {
                    throw Error(response.statusText);
                }

                dispatch(itemsIsLoading(false));

                return response;
            })
            .then((response) => response.json())
            .then((items) => dispatch(itemsFetchDataSuccess(items)))
            .catch(() => dispatch(itemsHasErrored(true)));
    };
}

我的减速器

export function itemsHasErrored(state = false, action) {
    switch (action.type) {
        case 'ITEMS_HAS_ERRORED':
            return action.hasErrored;

        default:
            return state;
    }
}

export function itemsIsLoading(state = false, action) {
    switch (action.type) {
        case 'ITEMS_IS_LOADING':
            return action.isLoading;

        default:
            return state;
    }
}

export function items(state = [], action) {
    switch (action.type) {
        case 'ITEMS_FETCH_DATA_SUCCESS':
            return action.items;

        default:
            return state;
    }
}

我有一个容器组件,asyncContainer.js

import React, {Component} from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux'

import {itemsFetchData} from '../../../actions/async';
import AsyncUI from './asyncUI'

class AsyncContainer extends Component {

    componentDidMount() {
        this.props.fetchData('http://5826ed963900d612000138bd.mockapi.io/items');
    }

    render() {

        if (this.props.hasErrored) {
            return <p>Sorry! There was an error loading the items</p>;
        }

        if (this.props.isLoading) {
            return <p>Loading…</p>;
        }
//This fails to wait
        return (
               <AsyncUI />
        );
    }
}

AsyncContainer.propTypes = {
    fetchData: PropTypes.func.isRequired,
    items: PropTypes.array.isRequired,
    hasErrored: PropTypes.bool.isRequired,
    isLoading: PropTypes.bool.isRequired
};

const mapStateToProps = (state) => {
    return {
        items: state.items,
        hasErrored: state.itemsHasErrored,
        isLoading: state.itemsIsLoading
    };
};

const mapDispatchToProps = (dispatch) => {
    return {
        fetchData: (url) => dispatch(itemsFetchData(url))
    };
};

export default connect(mapStateToProps, mapDispatchToProps)(AsyncContainer);

最后我有一个名为 asyncUI.js 的简单 UI 组件,它以函数式的方式编写

import React, {Component} from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux'

const AsyncUI = (items) => {

    return (
        <ul>
            {items.map((item) => (
                <li key={item.id}>
                    {item.label}
                </li>
            ))}
        </ul>
    );
}

const mapStateToProps = (state) => {
    return {
        items: state.items
    };
};

export default connect(mapStateToProps)(AsyncUI);

在 asyncContainer.js 中你可以看到对我的简单 UI 组件的调用

 return (
               <AsyncUI />
        );

但是在 asyncUI.js 中调用 redux 存储 items 的属性是一个空数组,因此 items.map 失败

但是,如果我从 asyncUI.js 中删除代码并将其放在 asyncContainer.js 中,它可以工作

这是在 asyncContainer.js

中工作的代码
  class AsyncContainer extends Component {
        componentDidMount() {
            this.props.fetchData('http://5826ed963900d612000138bd.mockapi.io/items');
        }

        render() {
            if (this.props.hasErrored) {
                return <p>Sorry! There was an error loading the items</p>;
            }

            if (this.props.isLoading) {
                return <p>Loading…</p>;
            }

//THIS IS WHERE I HAD <Async />
            return (
                <ul>
                    {this.props.items.map((item) => (
                        <li key={item.id}>
                            {item.label}
                        </li>
                    ))}
                </ul>
            );
        }
    }

    AsyncContainer.propTypes = {
        fetchData: PropTypes.func.isRequired,
        items: PropTypes.array.isRequired,
        hasErrored: PropTypes.bool.isRequired,
        isLoading: PropTypes.bool.isRequired
    };

    const mapStateToProps = (state) => {
        return {
            items: state.items,
            hasErrored: state.itemsHasErrored,
            isLoading: state.itemsIsLoading
        };
    };

    const mapDispatchToProps = (dispatch) => {
        return {
            fetchData: (url) => dispatch(itemsFetchData(url))
        };
    };

    export default connect(mapStateToProps, mapDispatchToProps)(AsyncContainer);

我认为问题在于组件 在项目数据准备好之前渲染。这是正常的反应行为。那么我如何“推迟”渲染。如您所见,我正在尝试使用容器/组件样式的架构。我总是可以使用上述工作的解决方案,但我想坚持使用这个容器/组件。 我是否必须深入研究 Promises 等? 我不应该为 asyncUI.js 使用功能性的写作方式吗? 我有点困惑。

【问题讨论】:

    标签: reactjs redux react-redux


    【解决方案1】:

    试试:

    const AsyncUI = ({items}) => {
                  /* ^ see ^ */
        return (
            <ul>
                {items.map((item) => (
                    <li key={item.id}>
                        {item.label}
                    </li>
                ))}
            </ul>
        ); }
    

    这会将items 值从您在mapStateToProps 函数中做出反应的道具中提取出来,这是一个对象,而不是一个数组(因此没有map 函数)。

    注意:这应该可以解决您的问题,但它仍然在技术上尝试在项目准备好之前在 2 个实例中呈现:

    1. 组件第一次渲染。 itemsIsLoading 的初始状态是 false,因此第一次渲染将无法通过所有安全检查。 items 的默认值是 [],所以它应该只渲染 &lt;ul&gt;&lt;/ul&gt; 很短的时间,直到 itemsIsLoading(true) 动作被调度。您可以将初始状态设置为true 以停止此操作,或者将加载检查更改为

      if (this.props.isLoading || this.props.items.length != 0) {
          return <p>Loading…</p>;
      }
      

      可以就这两种解决方案的实际必要性提出论据。

    2. 在fetch 返回调度动作的顺序之后,将导致另一个简短的&lt;ul&gt;&lt;/ul&gt; 渲染,因为在设置项目之前加载状态设置为false。请参阅dgrijuela's answer 了解解决此问题的一种方法。另一种方法是不分派单独的操作,并让ITEMS_FETCH_DATA_SUCCESS 和ITEMS_HAS_ERRORED 操作也将itemsIsLoading 值更改回false(多个reducer 可以作用于同一操作类型)。

    【讨论】:

    • 嗨,谢谢,是的,这是可行的,我犯了一个如此简单的错误。我提高了你的答案,干杯
    • 哎呀,我忘了:-)
    【解决方案2】:

    你在dispatch(itemsFetchDataSuccess(items))之前调用dispatch(itemsIsLoading(false))

    试试这样:

    // async.js
    ...
    
    export function itemsFetchData(url) {
      return (dispatch) => {
        dispatch(itemsIsLoading(true));
    
        fetch(url)
            .then((response) => {
                if (!response.ok) {
                    throw Error(response.statusText);
                }
    
                return response;
            })
            .then((response) => response.json())
            .then((items) => {
              dispatch(itemsFetchDataSuccess(items));
              dispatch(itemsIsLoading(false));
            })
            .catch(() => dispatch(itemsHasErrored(true)));
        };
    }
    

    【讨论】:

    • 不工作,完全一样。 asyncUI 在数据(项目)准备好之前渲染
    • 你的答案在一定程度上是正确的,但我也需要 Micheal Peyper 的答案
    【解决方案3】:

    请参阅 Michael Peyper 以获得好的答案

    原来问题出在我的 asyncUI 组件的功能编码风格上。我将它转换回“标准”有状态组件并且它工作正常。

    asyncContainer.js

    class AsyncContainer extends Component {
    
        componentDidMount() {
            this.props.fetchData('http://5826ed963900d612000138bd.mockapi.io/items');
        }
    
        render() {
    
              if (this.props.hasErrored) {
                      return <p>Sorry! There was an error loading the items</p>;
                  }
    
                  if (this.props.isLoading) {
                      return <p>Loading…</p>;
                  }
                  return (
                      <AsyncUI />     
            )
    
        }
    }
    

    asyncUI.js

    import React, {Component} from 'react';
    import PropTypes from 'prop-types';
    import { connect } from 'react-redux'
    
        class AsyncUI extends Component {
    
            render() {
                    return (
                    <ul>
                    {this.props.items.map((item) => (
                        <li key={item.id}>
                            {item.label}
                        </li>
                    ))}
                </ul>   
                )
            }
        }
    
        const mapStateToProps = (state) => {
            return {
                items: state.items,
            };
        };
    
    export default connect(mapStateToProps)(AsyncUI);
    

    希望这对任何人都有帮助:-)

    【讨论】:

      猜你喜欢
      • 2017-01-28
      • 1970-01-01
      • 2021-06-13
      • 2022-12-20
      • 1970-01-01
      • 2019-04-17
      • 2018-05-16
      • 1970-01-01
      • 2021-07-26
      相关资源
      最近更新 更多