前言

• 现在有很多人抛弃redux转向valtio，包括Umi最新版也开始使用它。
• react状态管理门派一般分为以下几类：
  没有状态管理工具：直接用 props 或者 context
  单项数据流：redux、zustand
  双向绑定：mobx、valtio
  状态原子化：jotai、recoil
  有限状态机：xstate
• 我觉得一个好的状态管理器要有超低的学习成本、能产生符合预期的效果、并且性能不会很差。
• valtio和jotai 是同一个作者，今天主角valtio是以proxy为核心的状态管理库。
• valtio由于以proxy为核心，所以可以脱离react使用。
• 这里摘抄云谦大佬对umi加入valtio的原话：
  1、数据与视图分离的心智模型。不再需要在 React 组件或 hooks 里用 useState 和 useReducer 定义数据，或者在 useEffect 里发送初始化请求，或者考虑用 context 还是 props 传递数据。如果熟悉 dva，你会在此方案中找到一丝熟悉的感觉，概念上就是 reducer 和 effects 换成了 actions，subscriptions 则换了种形式存在。
  2、更现代的 dva？「现代」主要出于这些点，1）基于 proxy，mutable，所以更新更简单，同时读取更高效，无需 selector，tracking with usage，2）没有中心化的 actions，以及基于组合式的扩展机制，这些都是对 TypeScript 更友好的方式，3）更少脚手架代码。
  再看缺点。
  1、兼容性。由于基于 proxy，所以不支持 IE 11、Chrome 48、Safari 9.1、Firefox 17 和 Opera 35 等。如果你的项目目前或未来有兼容需求，不要用。
  2、非 Hooks 数据流。这不一定算缺点，看从什么角度看。但如果你是从 useModel、hox 这类 Hooks 数据流切过来，会发现有些事情不能做了。不能在 state 里组合其他的 hooks 数据，也不能在 actions 调用其他的 hooks 方法。我就想用 hooks 的方式组织，怎么办？解法是把 valtio 的 store 作为一个原子，和其他 hook 结合使用，而不是在 store 里调用其他 hook。

使用

安装

npm i valtio

proxy与useSnapshot

• 使用proxy包装需要代理的对象。
• 在任意的地方去进行更改。
• 在需要刷新显示的地方使用useSnapshot监听该对象变化

import React, { useEffect, useState } from "react";
import { proxy, useSnapshot } from "valtio";const state = proxy({ count: 0, text: "hello" });setInterval(() => {++state.count;
}, 1000);export default function App() {const snap = useSnapshot(state);console.log("refresh");return (
{ height: 500, padding: 20 }}>{snap.count}
);
}

• 可以发现深度的检测也是可以的：

import React, { useEffect, useState } from "react";
import { proxy, useSnapshot } from "valtio";const state = proxy({ count: 0, text: "hello", aaa: { bbb: 1 } });
setInterval(() => {state.aaa.bbb++;
}, 1000);function Child1() {console.log("child1 refresh");return 
child1
;
}
function Child2() {console.log("child2 refresh");return 
child2
;
}
export default function App() {const snap = useSnapshot(state);console.log("refresh");return (
{ height: 500, padding: 20 }}>{snap.aaa.bbb}
);
}

• 其余行为符合react规律，如果不依赖变化的属性，该组件也不会刷新。

subscribe与subscribeKey

• 订阅顾名思义，任何地方使用后改变其然后执行函数。

import React, { useEffect, useState } from "react";
import { proxy, useSnapshot, subscribe } from "valtio";const state = proxy({ count: 0, text: "hello", aaa: { bbb: 1 } });
setInterval(() => {state.aaa.bbb++;
}, 1000);function Child1() {console.log("child1 refresh");return 
child1
;
}
function Child2() {console.log("child2 refresh");return 
child2
;
}
export default function App() {console.log("refresh");useEffect(() => {const unsubscribe = subscribe(state, () => {console.log("jjjjjjjjj", state.aaa.bbb);});return () => unsubscribe();}, []);return (
{ height: 500, padding: 20 }}>
);
}

• 调试发现第一个只能接对象。如果state内部的对象没更新他也可以不更新。
• 如果想要subscribe对象外的可以使用subscribeKey解决。

import React, { useEffect, useState } from "react";
import { proxy, useSnapshot, subscribe } from "valtio";
import { subscribeKey } from "valtio/utils";
const state = proxy({count: 0,text: "hello",aaa: { bbb: 1 },ccc: { dd: 1 },
});
setInterval(() => {state.count++;
}, 1000);function Child1() {console.log("child1 refresh");return 
child1
;
}
function Child2() {console.log("child2 refresh");return 
child2
;
}
export default function App() {console.log("refresh");useEffect(() => {const unsubscribe = subscribeKey(state, "count", (v) => {console.log("jjjjjjjjj", v);});return () => unsubscribe();}, []);return (
{ height: 500, padding: 20 }}>
);
}

watch

• watch可以拿到索要的state，只要它进行了变化：

import React, { useEffect, useState } from "react";
import { proxy, useSnapshot, subscribe } from "valtio";
import { subscribeKey, watch } from "valtio/utils";
const state = proxy({count: 0,text: "hello",aaa: { bbb: 1 },ccc: { dd: 1 },
});
const state2 = proxy({count: 0,text: "hello",
});
setInterval(() => {state.count++;
}, 1000);function Child1() {console.log("child1 refresh");return 
child1
;
}
function Child2() {console.log("child2 refresh");return 
child2
;
}
export default function App() {console.log("refresh");useEffect(() => {const stop = watch((get) => {console.log("state has changed to", get(state2),); // auto-subscribe on use});return () => stop();}, []);return (
{ height: 500, padding: 20 }}>
);

ref

• 如果这个东西你不想被proxy代理又想取值，那么可以使用ref进行包裹：

import { proxy, ref } from 'valtio'const state = proxy({count: 0,dom: ref(document.body),
})

取消批量更新

• 默认情况是开启的，但是如果是输入框这种情况，当你键入一些值后，光标移动到之前地方输入，光标还会跳转到最末尾。使用sync则可以解决这个问题。

function TextBox() {const snap = useSnapshot(state, { sync: true });console.log("mmmm");return (snap.text}onChange={(e) => (state.text = e.target.value)}/>);
}

derive

• 派生类似于computed可以从一个被proxy的值里进行变化。
• 配合snapshot可以进行react组件刷新

import React, { useEffect, useState } from "react";
import { proxy, useSnapshot, subscribe } from "valtio";
import { subscribeKey, watch, derive } from "valtio/utils";
// create a base proxy
const state = proxy({count: 1,
});// create a derived proxy
const derived = derive({doubled: (get) => get(state).count * 2,
});// alternatively, attach derived properties to an existing proxy
const three = derive({tripled: (get) => get(state).count * 3,},{proxy: state,}
);setInterval(() => {++state.count;
}, 1000);export default function App() {const snap = useSnapshot(state);return (
{ height: 500, padding: 20 }}>{derived.doubled}============{three.tripled}=============={three.count}{snap.count}
);
}

proxyWithComputed

• 类似于computed，与上面相比多了缓存。
• 作者建议尽量不要使用，因为和usesnapshot做了相同的事，而且有可能会导致内存泄漏

import memoize from 'proxy-memoize'
import { proxyWithComputed } from 'valtio/utils'const state = proxyWithComputed({count: 1,},{doubled: memoize((snap) => snap.count * 2),}
)// Computed values accept custom setters too:
const state2 = proxyWithComputed({firstName: 'Alec',lastName: 'Baldwin',},{fullName: {get: memoize((snap) => snap.firstName + ' ' + snap.lastName),set: (state, newValue) => {;[state.firstName, state.lastName] = newValue.split(' ')},},}
)// if you want a computed value to derive from another computed, you must declare the dependency first:
const state = proxyWithComputed({count: 1,},{doubled: memoize((snap) => snap.count * 2),quadrupled: memoize((snap) => snap.doubled * 2),}
)

proxyWithHistory

• proxyWithHistory 自带提供了redo和undo命令。

import { proxyWithHistory } from 'valtio/utils'const state = proxyWithHistory({ count: 0 })
console.log(state.value) // ---> { count: 0 }
state.value.count += 1
console.log(state.value) // ---> { count: 1 }
state.undo()
console.log(state.value) // ---> { count: 0 }
state.redo()
console.log(state.value) // ---> { count: 1 }

proxySet与proxyMap

• 这2都是提供创建proxy对象能力

import { proxySet } from 'valtio/utils'const state = proxySet([1, 2, 3])
//can be used inside a proxy as well
//const state = proxy({
//    count: 1,
//    set: proxySet()
//})state.add(4)
state.delete(1)
state.forEach((v) => console.log(v)) // 2,3,4

import { proxyMap } from 'valtio/utils'const state = proxyMap([['key', 'value'],['key2', 'value2'],
])
state.set('key', 'value')
state.delete('key')
state.get('key') // ---> value
state.forEach((value, key) => console.log(key, value)) // ---> "key", "value", "key2", "value2"

总结

• valtio提供了proxy封装的各种用法，使用上较为简单，也容易满足需求。对于状态库要求不是特别高，以及对浏览器支持要求不高时，该状态库比较适合使用。