TypeError：this.props.setLoginDisabled不是函数

Question

有一个名为Login的屏幕，它从loginActions传入一个动作创建者， loginActions所示：

https://gist.github.com/ldco2016/e2feedc5460e64e9b740af73cec5fe89

当我启动应用程序并单击“登录”按钮时，出现以下错误：

在该应用程序的旧版中，所有这些均正常运行，没有此类错误，但是现在在升级的0.60.4版本中单击“登录”按钮时，出现此错误。

当我查看loginActions文件时，我想知道是否应该在其中存在export default connect()()和mapDispatchToProps ，以将道具注入“ Login屏幕。 所以我的问题之一是，我确实需要这个吗？

以前是如何运作的？ 是从父母那里传下来的吗？ 这是loginActions.js文件：

import {Alert} from 'react-native';
import logger from 'logger';
import * as types from 'auth/constants';
import * as endpoints from 'endpoints';
import * as cache from 'utils/cache';
import {AUTH_STATUS} from 'enums/authStatus';
import * as requester from 'services/Requester';
import {clearSurveys} from 'surveys-ballots/actions';
import {clearEvents} from 'events/actions';
import * as repsActions from 'representatives/actions';
import {clearRegistration} from 'auth/registrationActions';
import {clearFeed} from 'activity-feed/actions';
import {clearActionAlerts} from 'action-alerts/actions';
import * as dataHelpers from 'auth/helpers/data-helpers';
import * as helpers from 'auth/helpers/actions-helpers';
import {verificationEmailChanged} from 'auth/registrationActions';
import {clearMembershipFields} from 'membership/actions';
import {
  setRelevantStates,
  clearPreferences,
} from 'account-settings/preferencesActions';
import {fetchPrefences, fetchTopics} from 'account-settings/preferencesActions';
import * as appcenter from 'utils/appcenterLogger';

export function setAuthStatus(authStatus) {
  return async (dispatch, getState) => {
    try {
      const {auth: {user}} = getState();
      dispatch({
        type: types.SET_AUTH_STATUS,
        payload: {
          ...user,
          authStatus,
        },
      });
      logger(types.SET_AUTH_STATUS);
    } catch (error) {
      logger('error in setAuthStatus');
      return false;
    }
  };
}

export function handleLogin({email, password, rememberEmail}) {
  return async dispatch => {
    try {
      dispatch({type: types.LOGIN_STARTED});
      logger(types.LOGIN_STARTED);

      const response = await requester.sendPost(endpoints.USER_LOGIN, {
        Username: email,
        Password: password,
      });

      const needsSetup = dataHelpers.needsSetup(response);

      if (needsSetup) {
        dispatch({
          type: types.EMAIL_VERIFICATION_SUBMIT_ENDED_SUCCESS,
          payload: response,
        });
        dispatch(verificationEmailChanged(email));
        return Promise.resolve({
          needsSetup: true,
        });
      }
      const user = {
        ...response,
        authStatus: AUTH_STATUS.LOGGED_IN,
      };

      cache.saveUserRef(user);
      cache.handleEmailCache(email, rememberEmail);

      helpers.sendOneSignalTags(user, true);
      appcenter.trackUser('UserLogin', user, true);

      dispatch({
        type: types.LOGIN_SUCCESS,
        payload: user,
      });

      const deepLinkedEvent = await cache.getDeepLinkedElement('event');
      const deepLinkedBallot = await cache.getDeepLinkedElement('survey');

      dispatchAfterLoginActions(dispatch, user);

      logger(types.LOGIN_SUCCESS);

      return Promise.resolve({
        needsSetup: false,
        deepLinkedEvent,
        deepLinkedBallot,
      });
    } catch (e) {
      logger(types.LOGIN_ERROR, e);
      const error = e && e.Message;
      dispatch({type: types.LOGIN_ERROR, payload: error});
    }
  };
}

export function checkSession(responseError) {
  return (dispatch, getState) => {
    const {auth: {user}} = getState();
    if (
      user.authStatus === AUTH_STATUS.LOGGED_IN &&
      responseError &&
      responseError.Message &&
      (responseError.Message.lastIndexOf('TokenExpired') >= 0 ||
        responseError.Message === 'Individual not found')
    ) {
      dispatch(handleLogout());
      return Alert.alert(
        'Session Timeout',
        'For your security, your NFIB session has timed out due to inactivity.',
        [{text: 'Ok', onPress: () => false}]
      );
    }
  };
}

export function handleLogout() {
  return async (dispatch, getState) => {
    const {auth: {user}} = getState();

    dispatch(clearSurveys());
    dispatch(clearEvents());
    dispatch(clearRegistration());
    dispatch(repsActions.clearRepresentatives());
    dispatch(clearFeed());
    dispatch(clearActionAlerts());
    dispatch(clearMembershipFields());
    dispatch(clearPreferences());
    dispatch({type: types.RESET_LOGIN_STATE});

    cache.clearCache();
    helpers.sendOneSignalTags(user, false);
    appcenter.trackUser('UserLogout', user, false);
    requester.resetTokenExpired();
  };
}

export function setCurrentUser({Key}) {
  return async dispatch => {
    try {
      dispatch({type: types.FETCH_USER_DETAILS_STARTED});
      const user = await helpers.fetchCurrentUserDetails(Key);
      dispatch({
        type: types.SET_CURRENT_USER,
        payload: {
          ...user,
          authStatus: AUTH_STATUS.LOGGED_IN,
        },
      });

      dispatchAfterLoginActions(dispatch, user);

      logger(types.SET_CURRENT_USER);
    } catch (error) {
      dispatch({
        type: types.FETCH_USER_DETAILS_FINISHED_ERROR,
        payload: error,
      });
      dispatch(checkSession(error));
      logger(types.FETCH_USER_DETAILS_FINISHED_ERROR);
    }
  };
}

function dispatchAfterLoginActions(dispatch, user) {
  dispatch(fetchUserOrganizationDetails(user));
  dispatch(validateUserInformationForVoterVoice());
  dispatch(setRelevantStates());
  dispatch(fetchPrefences(user));
  dispatch(fetchTopics());
}

export function setUserMembership(user) {
  const isMember = Boolean(user.Organization && user.Organization.Key);
  return {
    type: types.SET_USER_MEMBERSHIP,
    payload: isMember,
  };
}

export function fetchUserOrganizationDetails(user) {
  return async dispatch => {
    try {
      if (user.Organization && user.Organization.Key) {
        const {Key} = user.Organization;
        const payload = await helpers.fetchOrganizationDetails(Key);
        dispatch({
          type: types.GET_USER_ORGANIZATION_FINISHED_SUCCESS,
          payload,
        });
        dispatch(setUserMembership(user));
        logger(types.GET_USER_ORGANIZATION_FINISHED_SUCCESS);
        helpers.sendOneSignalOrganizationTags(payload);
        cache.saveOrganizationData(payload);
      }
    } catch (error) {
      logger(types.GET_USER_ORGANIZATION_FINISHED_ERROR);
      dispatch({
        type: types.GET_USER_ORGANIZATION_FINISHED_ERROR,
        payload: error,
      });
      dispatch(checkSession(error));
    }
  };
}

export function setUserPosition(coords) {
  return {
    type: types.SET_USER_POSITION,
    payload: coords,
  };
}

export function setEmailField(email) {
  return {
    type: types.SET_EMAIL_FIELD,
    payload: email,
  };
}

export function setPasswordField(password) {
  return {
    type: types.SET_PASSWORD_FIELD,
    payload: password,
  };
}

export function setSecurityTextEntry(current) {
  return {
    type: types.SET_SECURITY_TEXT_ENTRY,
    payload: current,
  };
}

export function setLoginDisabled(status) {
  return {
    type: types.SET_LOGIN_DISABLED,
    payload: status,
  };
}

export function validateUserAddress() {
  return async (dispatch, getState) => {
    try {
      logger(types.VALIDATE_USER_ADDRESS_STARTED);
      dispatch({type: types.VALIDATE_USER_ADDRESS_STARTED});
      const {auth: {user: {PersonalAddress}}} = getState();
      const payload = await helpers.validateAddress({
        homeAddress: PersonalAddress.AddressLine1,
        city: PersonalAddress.City,
        state: PersonalAddress.StateCode,
        zipCode: PersonalAddress.PostalCode,
      });
      dispatch({type: types.VALIDATE_USER_ADDRESS_SUCCESS, payload});
      logger(types.VALIDATE_USER_ADDRESS_SUCCESS);
    } catch (error) {
      logger(types.VALIDATE_USER_ADDRESS_ERROR);
      dispatch({
        type: types.VALIDATE_USER_ADDRESS_ERROR,
        payload: error,
      });
      dispatch(checkSession(error));
    }
  };
}

export function validateUserInformationForVoterVoice(userKey = null) {
  return async (dispatch, getState) => {
    try {
      logger(types.VALIDATE_USER_INFORMATION_FOR_VOTER_VOICE_STARTED);
      dispatch({
        type: types.VALIDATE_USER_INFORMATION_FOR_VOTER_VOICE_STARTED,
      });

      const {auth: {user: {Key}}} = getState();
      const payload = await helpers.validateUserInformationForVoterVoice(
        userKey || Key
      );

      logger(types.VALIDATE_USER_INFORMATION_FOR_VOTER_VOICE_SUCCESS);
      dispatch({
        type: types.VALIDATE_USER_INFORMATION_FOR_VOTER_VOICE_SUCCESS,
        payload,
      });
    } catch (error) {
      dispatch({
        type: types.VALIDATE_USER_INFORMATION_FOR_VOTER_VOICE_ERROR,
        payload: error,
      });
    }
  };
}

export function sendVerificationEmail() {
  return async (dispatch, getState) => {
    try {
      logger(types.SEND_EMAIL_CONFIRMATION_STARTED);
      dispatch({type: types.SEND_EMAIL_CONFIRMATION_STARTED});

      const {auth: {user: {Key}}} = getState();
      const payload = await helpers.sendVerificationEmail(Key);

      logger(types.SEND_EMAIL_CONFIRMATION_SUCCESS);
      dispatch({
        type: types.SEND_EMAIL_CONFIRMATION_SUCCESS,
        payload,
      });
    } catch (error) {
      dispatch({
        type: types.SEND_EMAIL_CONFIRMATION_ERROR,
        payload: error,
      });
    }
  };
}

export function toggleRememberEmail() {
  return {type: types.TOGGLE_REMEMBER_EMAIL};
}

这是减速器：

import {AUTH_STATUS} from 'enums/authStatus';
import * as types from 'auth/constants';

export const INITIAL_STATE = {
  user: {
    authStatus: AUTH_STATUS.LOGGED_OUT,
  },
  error: null,
  loading: false,
  isMember: false,
  userOrganization: null,
  primaryIndividual: null,
  userPosition: null,
  email: '',
  password: '',
  useSecureTextEntry: true,
  isDisabled: false,
  validatingUserAddress: true,
  validatingUserAddressForVV: true,
  userAddressValid: true,
  userAddressIsValidForVoterVoice: false,
  userEmailIsValidForVoterVoice: false,
  rememberEmail: true,
};

//eslint-disable-next-line
export default (state = INITIAL_STATE, {type, payload}) => {
  switch (type) {
    case types.LOGIN_STARTED:
      return {...state, loading: true, error: null};
    case types.LOGIN_SUCCESS:
      return {...state, user: payload, loading: false};
    case types.LOGIN_ERROR:
      return {
        ...state,
        loading: false,
        error: payload,
      };
    case types.EMAIL_VERIFICATION_SUBMIT_ENDED_SUCCESS:
      return {...state, loading: false};
    case types.SET_CURRENT_USER:
      return {...state, loading: false, user: payload};
    case types.SET_AUTH_STATUS:
      return {...state, user: payload};
    case types.SET_USER_MEMBERSHIP:
      return {...state, isMember: payload};
    case types.GET_USER_ORGANIZATION_STARTED:
      return {...state, loading: true, error: null};
    case types.GET_USER_ORGANIZATION_FINISHED_SUCCESS:
      return {...state, loading: false, ...payload};
    case types.GET_USER_ORGANIZATION_FINISHED_ERROR:
      return {...state, loading: false, error: payload};
    case types.RESET_LOGIN_STATE:
      return INITIAL_STATE;
    case types.SET_USER_POSITION:
      return {...state, userPosition: payload};
    case types.FETCH_USER_DETAILS_STARTED:
      return {...state, loading: true, error: null};
    case types.FETCH_USER_DETAILS_FINISHED_ERROR:
      return {...state, loading: false, error: payload};
    case types.SET_EMAIL_FIELD:
      return {...state, email: payload};
    case types.SET_PASSWORD_FIELD:
      return {...state, password: payload};
    case types.SET_SECURITY_TEXT_ENTRY:
      return {...state, useSecureTextEntry: payload};
    case types.SEND_EMAIL_CONFIRMATION_STARTED:
      return {...state, loading: true};
    case types.SEND_EMAIL_CONFIRMATION_SUCCESS:
      return {...state, loading: false};
    case types.SEND_EMAIL_CONFIRMATION_ERROR:
      return {...state, loading: false};
    case types.SET_LOGIN_DISABLED:
      return {...state, isDisabled: payload};
    case types.UPDATE_PERSONAL_DETAILS:
      return {
        ...state,
        user: {
          ...state.user,
          PersonalDetails: payload,
        },
      };
    case types.UPDATE_CONTACT_DETAILS:
      return {
        ...state,
        user: {
          ...state.user,
          ContactDetails: payload,
        },
      };
    case types.UPDATE_PERSONAL_ADDRESS:
      return {
        ...state,
        user: {
          ...state.user,
          PersonalAddress: payload,
        },
      };
    case types.VALIDATE_USER_ADDRESS_STARTED:
      return {...state, validatingUserAddress: true};
    case types.VALIDATE_USER_ADDRESS_SUCCESS:
      return {
        ...state,
        validatingUserAddress: false,
        userAddressValid: payload,
      };
    case types.VALIDATE_USER_ADDRESS_ERROR:
      return {...state, validatingUserAddress: false};
    case types.VALIDATE_USER_INFORMATION_FOR_VOTER_VOICE_STARTED:
      return {...state, validatingUserAddressForVV: true};
    case types.VALIDATE_USER_INFORMATION_FOR_VOTER_VOICE_SUCCESS: {
      const {
        userAddressIsValidForVoterVoice,
        userEmailIsValidForVoterVoice,
      } = payload;
      return {
        ...state,
        userAddressIsValidForVoterVoice,
        userEmailIsValidForVoterVoice,
        validatingUserAddressForVV: false,
      };
    }
    case types.VALIDATE_USER_INFORMATION_FOR_VOTER_VOICE_ERROR:
      return {
        ...state,
        userAddressIsValidForVoterVoice: false,
        userEmailIsValidForVoterVoice: false,
        validatingUserAddressForVV: false,
      };
    case types.TOGGLE_REMEMBER_EMAIL:
      return {...state, rememberEmail: !state.rememberEmail};
    default:
      return state;
  }
};

这些都在src/auth 。

正在src/navigation/auth/stack.js内部使用Login屏幕：

import React from "react";
import { StackNavigator, NavigationActions } from "react-navigation";
import { Intro } from "auth/screens/Intro";
import { Login } from "auth/screens/Login";
import { PasswordReset } from "auth/screens/PasswordReset";
import { RegisterNoEmail } from "auth/screens/RegisterNoEmail";
import AskForMembership from "auth/screens/AskForMembership";
import { CompleteAccount } from "auth/screens/CompleteAccount";
import { ConfirmMemberAccount } from "auth/screens/ConfirmMemberAccount";
import { Register } from "auth/screens/Register";
import { SetNewPassword } from "auth/screens/SetNewPassword";
import { RegisterEmailPassword } from "auth/screens/RegisterEmailPassword";
import { ResetLinkConfirmationAlert } from "auth/screens/ResetLinkConfirmationAlert";
import { DetailsConfirmation } from "auth/screens/DetailsConfirmation";
import { AccountCreated } from "auth/screens/AccountCreated";

import BackButton from "navigation-components/BackButton";
import CustomHeader from "navigation-components/CustomHeader";
import HeaderTitle from "navigation-components/HeaderTitle";
import { v2Colors } from "theme";
import { defaultStackConfig, defaultHeaderStyles } from "../config";

const leftRegiterNavOptions = {
  title: "Register",
  headerStyle: defaultStackConfig.authHeaderStyle
};

const stack = StackNavigator(
  {
    Intro: {
      screen: Intro,
      navigationOptions: {
        header: null
      }
    },
    Register: {
      screen: Register,
      navigationOptions: ({ navigation }) => ({
        header: <CustomHeader onPress={() => navigation.goBack(null)} />,
        headerStyle: defaultStackConfig.authHeaderStyle
      })
    },
    RegisterNoEmail: {
      screen: RegisterNoEmail,
      navigationOptions: leftRegiterNavOptions
    },
    RegisterEmailPassword: {
      screen: RegisterEmailPassword,
      navigationOptions: leftRegiterNavOptions
    },
    AskForMembership: {
      screen: AskForMembership,
      navigationOptions: {
        header: <HeaderTitle />,
        headerStyle: defaultStackConfig.authHeaderStyle
      }
    },
    ConfirmMemberAccount: {
      screen: ConfirmMemberAccount,
      navigationOptions: ({ navigation }) => ({
        header: (
          <HeaderTitle
            headerLeft={() => (
              <BackButton onPress={() => navigation.goBack(null)} />
            )}
          />
        ),
        headerStyle: defaultStackConfig.authHeaderStyle
      })
    },
    CompleteAccount: {
      screen: CompleteAccount,
      navigationOptions: {
        header: <HeaderTitle />,
        headerStyle: defaultStackConfig.authHeaderStyle
      }
    },
    Login: {
      screen: Login,
      navigationOptions: ({ navigation }) => ({
        title: "Log In",
        headerLeft: <BackButton onPress={() => navigation.goBack(null)} />,
        headerStyle: defaultStackConfig.authHeaderStyle
      })
    },

似乎loginActions内部的所有动作创建者都未定义回来，例如setAuthStatus ，它正在auth/screens/Intro.js内部使用：

/* eslint react/forbid-prop-types: "off"*/
import React from "react";
import {
  View,
  Image,
  Keyboard,
  TouchableWithoutFeedback,
  Text
} from "react-native";
import PropTypes from "prop-types";
import { connect } from "react-redux";
import { TextButton } from "react-native-material-buttons";
import { colors, v2ButtonStyles, v2Colors } from "theme";
import { Loading } from "common-components";
import { setAuthStatus } from "auth/loginActions";
import styles from "auth/styles";

const logo = require("icons/NFIB_white.png");

const propTypes = {
  loading: PropTypes.bool,
  navigation: PropTypes.object.isRequired,
  setAuthStatus: PropTypes.func.isRequired
};

export class Intro extends React.Component {
  _dismiss = () => {
    Keyboard.dismiss();
  };

  render() {
    return (
      <View style={styles.container}>
        <TouchableWithoutFeedback onPress={this._dismiss}>
          <View style={{ flex: 1 }} accessible={true}>
            <Image
              source={logo}
              style={styles.v2Logo}
              accessible={true}
              accessibilityLabel={"imgLogo"}
            />
            {this.props.loading && <Loading />}
            {!this.props.loading && (
              <View style={styles.footerWrapper}>
                <View style={styles.authButtonsWrapper} accessible={true}>
                  <TextButton
                    color={v2Colors.green}
                    title={"LOG IN"}
                    titleColor={colors.white}
                    onPress={() => this.props.navigation.navigate("Login")}
                    style={styles.authButton}
                    titleStyle={v2ButtonStyles.titleStyle}
                    accessibilityLabel={"btnLogin"}
                    accessibilityTraits={"button"}
                    accessibilityComponentType={"button"}
                  />
                  <Text style={styles.textSeparatorNewLine} />
                  <Text style={styles.textSeparatorNewLine}>
                    {" "}
                    {"First time here?"}
                  </Text>
                  <TextButton
                    color={v2Colors.green}
                    title={"REGISTER"}
                    titleColor={colors.white}
                    onPress={() => this.props.navigation.navigate("Register")}
                    style={styles.authButton}
                    titleStyle={v2ButtonStyles.titleStyle}
                    accessibilityLabel={"btnRegister"}
                    accessibilityTraits={"button"}
                    accessibilityComponentType={"button"}
                  />
                </View>
              </View>
            )}
          </View>
        </TouchableWithoutFeedback>
      </View>
    );
  }
}

Intro.propTypes = propTypes;
const mapState2Props = ({ auth }) => {
  const { loading } = auth;
  return { loading };
};

export default connect(
  mapState2Props,
  {
    setAuthStatus
  }
)(Intro);

setLoginDisabled没有被调度：

export function setLoginDisabled(status) {
  return {
    type: types.SET_LOGIN_DISABLED,
    payload: status
  };
}

所以我试图像这样dispatch它：

export const setLoginDisabled = status => async (dispatch, getState) => {
  dispatch({ type: types.SET_LOGIN_DISABLED, payload: status });
};

仍然出现与上述相同的错误。 我认为这没有任何区别。

因此，我决定在其import语句之后立即console.log(setLoginDisabled)并得到：

ƒ setLoginDisabled(status) {
    return {
      type: types.SET_LOGIN_DISABLED,
      payload: status
    };
  }

因此，在导入时一定要对其进行定义。 然后我尝试了：

// all this logic below will need to be consolidated into one `componentDidMount()`
  UNSAFE_componentWillMount() {
    console.log(this.props.setLoginDisabled);
    this.props.setLoginDisabled();
    this.keyboardDidShowListener = Keyboard.addListener(
      "keyboardDidShow",
      this._keyboardDidShow
    );
    this.keyboardDidHideListener = Keyboard.addListener(
      "keyboardDidHide",
      this._keyboardDidHide
    );
  }

而且我还没有得到任何回报。

我开始认为问题可能与require cycles有关，因为我收到很多警告，说很多loginActions中的操作创建者未定义，并且我也收到这些警告：

我认为这是一个需要周期的问题。 因此，就像文件A想要文件B的某些东西->文件B想要文件C的某些东西->文件C想要文件A的某些东西。正在创建一个圆，它导致我的loginActions.js文件中的值未初始化。如果是这种情况，则不确定如何解决。

按登录按钮后，我在android方面也遇到了相同的错误：

Android更加清晰，因为实际上该动作创建者是未定义的。

Answer 1

这是react-redux是吗？

您是否将登录组件包装在“连接”包装器中。

{connect}来自'react-redux';

connect（mapStateToProps，mapDispatchToProps）（登录）;

我不确定您的Login组件是否知道要使用哪个操作'setLoginDisabled（）'，从而不会触发精简程序'SET_LOGIN_DISABLED'。 我只是用react-native设置了react-redux，然后使用了“连接”包装器，效果很好。

可能想尝试一下， https：//github.com/reduxjs/react-redux/blob/master/docs/api/connect.md

Answer 2

您应该将派遣用于地图派发到道具。 尝试这样：

const mapDispatchToProps = dispatch => {
     return {
        setLoginDisabled: (status) => dispatch({ type: types.SET_LOGIN_DISABLED , payload: status })
     }
}
//OR
export function setLoginDisabled(dispatch, status) {
  return dispatch({
    type: types.SET_LOGIN_DISABLED,
    payload: status,
  })
}

然后，如果您创建了mapDispatchToProps常量， mapDispatchToProps mapDispatchToProps传递给第二个参数：

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

除此以外：

export default connect(
     mapStateToProps,
     dispatch => {
         setLoginDisabled(dispatch, status)
     }
)(Login);

Answer 3

似乎您没有将setLoginDisabled传递给connect函数。

这就是为什么当您console.log(setLoginDisabled)时setLoginDisabled是一个函数，但是在this.props上“不可用”（尝试console.log(this.props.setLoginDisabled) ，它将返回未定义）。

您需要像这样将setAuthStatus与setLoginDisabled一起传递

connect(
    mapState2Props, {
        setAuthStatus,
        "setLoginDisabled"
    }
)(Intro);

这将使setLoginDisabled在this.props上this.props

希望对您有用。

Answer 4

如果您查看src/navigation/auth/stack.js ，很多import语句是不正确的，它们不应该使用大括号。 我像这样重构文件：

import React from "react";
import { StackNavigator, NavigationActions } from "react-navigation";
import Intro from "auth/screens/Intro";
import Login from "auth/screens/Login";
import PasswordReset from "auth/screens/PasswordReset";
import RegisterNoEmail from "auth/screens/RegisterNoEmail";
import AskForMembership from "auth/screens/AskForMembership";
import CompleteAccount from "auth/screens/CompleteAccount";
import ConfirmMemberAccount from "auth/screens/ConfirmMemberAccount";
import Register from "auth/screens/Register";
import SetNewPassword from "auth/screens/SetNewPassword";
import RegisterEmailPassword from "auth/screens/RegisterEmailPassword";
import ResetLinkConfirmationAlert from "auth/screens/ResetLinkConfirmationAlert";
import DetailsConfirmation from "auth/screens/DetailsConfirmation";
import AccountCreated from "auth/screens/AccountCreated";

import BackButton from "navigation-components/BackButton";
import CustomHeader from "navigation-components/CustomHeader";
import HeaderTitle from "navigation-components/HeaderTitle";
import { v2Colors } from "theme";
import { defaultStackConfig, defaultHeaderStyles } from "../config";

const leftRegiterNavOptions = {
  title: "Register",
  headerStyle: defaultStackConfig.authHeaderStyle
};

当我更正此错误时，错误又改回了：

出现上述错误的原因是由于react-navigation无法识别我从其他帖子中注意到的从react-redux版本7返回的对象：

路线“ ActivityFeed”的组件必须是React组件