api.subscribe calls every subscriber even if state doesn't change about zustand HOT 6 CLOSED

I believe it's the same in Redux, subs will fire for any dispatch?

We probably could just compare the root in order to detect reduced state changes, right?

  const setState = (partialState: PartialState<State>) => {
    const oldState = state
    state = Object.assign(
      {},
      state,
      typeof partialState === 'function' ? partialState(state) : partialState
    )
    if (oldState !== state) listeners.forEach(listener => listener(state))
  }

edit:

On second thought, ... assign creates a new object each time, so that probably wouldn't work. 🤔If root change detection can get expensive i would just accept the current behaviour, and the upcoming selective subscribe will also help.

from zustand.

I have a fix that's basically the same but does a shallow equal check. I just wanted to open this issue to see if you had any more info on what the behavior should be and to reference this for a potential fix. I'll check if redux is the same.

from zustand.

The selective api.subscribe change is how I discovered this. The behavior seemed inconsistent because a selective subscription would not be called unless its state changed but a non-selective one would be called every time even on no change.

from zustand.

just scared that adding a shallow equal check will add overhead (for instance root objects with hundredes/thousands of objects in it, like a central-state hashmap). At work our state is formed like that, there can be thousands of object in state-root. It would run over each on every setState.

One way: subscribe(fn) could expectedly fire on each setState, with docs declaring it so.

Or, maybe, ... is it possible to run the check only over the partialState?

const partial = typeof partialState === 'function' ? partialState(state) : partialState

// This works if "shallowEqual" could disregard that A has less keys than B somehow
if (shallowEqual(partial, state)) {
   state = Object.assign({}, state, partial)

from zustand.

Yeah, we can run the check only on the keys in partialState:

const setState: SetState<TState> = partial => {
  const partialState =
    typeof partial === 'function' ? partial(state) : partial
  if (
    partialState !== state &&
    Object.entries(partialState).some(
      ([key, value]) => !Object.is(state[key], value)
    )
  ) {
    state = Object.assign({}, state, partialState)
    listeners.forEach(listener => listener(state))
  }
}

from zustand.

I kept thinking about this, sadly this doesn't help when the user does set(state => ({ ...state, something: 123 }))

from zustand.