Troubleshooting

This is a place to share common problems and solutions to them.
The examples use React, but you should still find them useful if you use something else.

Nothing happens when I dispatch an action

Sometimes, you are trying to dispatch an action, but your view does not update. Why does this happen? There may be several reasons for this.

Never mutate reducer arguments

It is tempting to modify the state or action passed to you by Redux. Don’t do this!

Redux assumes that you never mutate the objects it gives to you in the reducer. Every single time, you must return the new state object. Even if you don’t use a library like Immutable, you need to completely avoid mutation.

Immutability is what lets react-redux efficiently subscribe to fine-grained updates of your state. It also enables great developer experience features such as time travel with redux-devtools.

For example, a reducer like this is wrong because it mutates the state:

function todos(state = [], action) {
  switch (action.type) {
  case 'ADD_TODO':
    // Wrong! This mutates state.actions.
    state.actions.push({
      text: action.text,
      completed: false
    });
  case 'COMPLETE_TODO':
    // Wrong! This mutates state.actions[action.index].
    state.actions[action.index].completed = true;
  }

  return state
}

It needs to be rewritten like this:

function todos(state = [], action) {
  switch (action.type) {
  case 'ADD_TODO':
    // Return a new array
    return [...state, {
      text: action.text,
      completed: false
    }];
  case 'COMPLETE_TODO':
    // Return a new array
    return [
      ...state.slice(0, action.index),
      // Copy the object before mutating
      Object.assign({}, state[action.index], {
        completed: true
      }),
      ...state.slice(action.index + 1)
    ];
  default:
    return state;
  }
}

It’s more code, but it’s exactly what makes Redux predictable and efficient. If you want to have less code, you can use a helper like React.addons.update to write immutable transformations with a terse syntax:

// Before:
return [
  ...state.slice(0, action.index),
  Object.assign({}, state[action.index], {
    completed: true
  }),
  ...state.slice(action.index + 1)
]

// After
return update(state, {
  [action.index]: {
    completed: {
      $set: true
    }
  }
});

Finally, to update objects, you’ll need something like _.extend from Underscore, or better, an Object.assign polyfill.

Make sure that you use Object.assign correctly. For example, instead of returning something like Object.assign(state, newData) from your reducers, return Object.assign({}, state, newData). This way you don’t override the previous state.

You can also enable ES7 object spread proposal with Babel stage 1:

// Before:
return [
  ...state.slice(0, action.index),
  Object.assign({}, state[action.index], {
    completed: true
  }),
  ...state.slice(action.index + 1)
]

// After:
return [
  ...state.slice(0, action.index),
  { ...state[action.index], completed: true },
  ...state.slice(action.index + 1)
]

Note that experimental language features are subject to change, and it’s unwise to rely on them in large codebases.

Don’t forget to call dispatch(action)

If you define an action creator, calling it will not automatically dispatch the action. For example, this code will do nothing:

TodoActions.js

export function addTodo(text) {
  return { type: 'ADD_TODO', text };
}

AddTodo.js

import { Component } from 'react';
import { addTodo } from './TodoActions';

class AddTodo extends Component {
  handleClick() {
    // Won't work!
    addTodo('Fix the issue');
  }

  render() {
    return (
      <button onClick={() => this.handleClick()}>
        Add
      </button>
    );
  }
}

It doesn’t work because your action creator is just a function that returns an action. It is up to you to actually dispatch it. We can’t bind your action creators to a particular Store instance during the definition because apps that render on the server need a separate Redux store for every request.

The fix is to call dispatch() method on the store instance:

handleClick() {
  // Works! (but you need to grab store somehow)
  store.dispatch(addTodo('Fix the issue'));
}

If you’re somewhere deep in the component hierarchy, it is cumbersome to pass the store down manually. This is why react-redux lets you use a connect higher-order component that will, apart from subscribing you to a Redux store, inject dispatch into your component’s props.

The fixed code looks like this:

AddTodo.js

import { Component } from 'react';
import { connect } from 'react-redux';
import { addTodo } from './TodoActions';

class AddTodo extends Component {
  handleClick() {
    // Works!
    this.props.dispatch(addTodo('Fix the issue'));
  }

  render() {
    return (
      <button onClick={() => this.handleClick()}>
        Add
      </button>
    );
  }
}

// In addition to the state, `connect` puts `dispatch` in our props.
export default connect(AddTodo, state => ({}))

You can then pass dispatch down to other components manually, if you want to.

Something else doesn’t work

Ask around on the #redux Reactiflux Slack channel, or create an issue.
If you figure it out, edit this document as a courtesy to the next person having the same problem.