Using synchronous state in react.
npm install react-sync-state-hook
npm i react-sync-state-hook
`
或者
`
yarn add react-sync-state-hook
`
快速上手
`
import { useEffect } from 'react'
import { useSyncState, useSyncMemo } from 'react-sync-state-hook'
export default MyComponent = () => {
const [ state, setState, curState ] = useSyncState(0) // 也支持函数式
const [ memo, curMemo ] = useSyncMemo(() => {
return curState.current + 100
}, [curState])
useEffect(() =>{
setState(1) // 也支持函数式更新，参数为不可变数据代理，值为curState.current（不需用.current调用）
console.log(state) // 0
console.log(curState.current) // 1
console.log(memo) // 100
console.log(curMemo.current) // 101
}, [])
return (
<>
{ state }
{ memo }
)
}
`
Hook介绍
* ### useSyncState(value)
函数形式：
`
const [ state, setState, current ] = useSyncState(初始值 | 函数表达式)
`
该hook类似于useState()，接收一个任意类型的参数，但useSyncState多返回一个实时的状态值副本，即返回值的第三个（后文以curState指代），前两个在用法上则与useState的返回值并无二致。其中state表示状态值，用于刷新视图；setState用于同步state和curState的值，也支持函数式更新，参数为不可变数据代理；而curState则表示实时的状态值，即在执行setState()操作之后，能够立刻更新为最新状态值，可用于同步操作，不能用于刷新视图，需以curState.current去调用，参照例子。
注意：由于curState是状态值的一个不可变数据类型代理，因此对其所做的任何修改都不会影响到state，本着状态值的不可变性原则，我们可以这样修改状态：
`
const [ state, setState, curState ] = useSyncState([
{ x: 0, y: 1 }
])
curState.current[0].x = 100
setState(curState.current) // setState内部会自动将不可变对象转换为正常对象
`
同时，setState的函数式更新所带参数也是一个不可变对象，并且不需要通过current调用，用法与useImmer一样， 如下：
`
const [ state, setState, curState ] = useSyncState([
{ x: 0, y: 1 }
])
setState(prev => {
prev[0].x = 100
return prev
})
`
useSyncState又是如何消除副作用的呢？我们看以下例子：
`
import { useState, useEffect } from 'react'
export default MyComponent = () => {
const [ A, setA ] = useState(0)
const [ B, setB ] = useState(0)
let request = () => {
return new Promise((resolve, reject) => {
setTimeout(() => {
setA(1)
resolve()
}, 500)
})
}
useEffect(() =>{
request()
}, [])
useEffect(() =>{
// 每次A更新都会执行
setB(A + 10)
}, [A])
return (
{ B }
)
}
`
这个例子表示有一个状态A需要异步获取，获取之后再根据A计算得到状态B的值，这里我们先不讨论用useMemo优化的问题，现在我们用useSyncState来改写看看：
`
import { useEffect } from 'react'
import { useSyncState, useSyncMemo } from 'react-sync-state-hook'
export default MyComponent = () => {
const [ A, setA, curA ] = useSyncState(0)
const [ B, setB, curB ] = useSyncState(0)
let request = () => {
return new Promise((resolve, reject) => {
setTimeout(() => {
setA(1)
resolve()
}, 500)
})
}
useEffect(() =>{
request().then(() => {
setB(curA.current + 10)
})
}, [])
return (
{ B }
)
}
`
这种写法让副作用变得可控了，不会每次setA都会去更新B，我们后续setA想执行什么副作用就执行什么副作用，不会有额外的心里负担，我们不需要再去考虑数据是怎么流动的，我们把seState当作一个更新视图的函数即可，这样更符合我们的直觉思维。
* ### useSyncMemo(fn[, deps])
函数形式：
`
const [ memo, current ] = useSyncMemo(function(){ 计算函数，最好用状态的current值进行计算 }, [依赖项数组，可传可不传，传的话必须用状态的current值])
`
该hook类似于useMemo()，接收一个计算函数和依赖项数组（也可不传依赖），不同的是返回值中包含memo以及current两个值。注意：如果要显式传依赖项的话，依赖项需为useSyncState()返回的current值，如果想要立刻获取到最新的计算值，计算函数中还需用current值进行计算。如下：
`
import { useEffect } from 'react'
import { useSyncState, useSyncMemo } from 'react-sync-state-hook'
export default MyComponent = () => {
const [ state, setState, curState ] = useSyncState(0)
const [ memo, curMemo ] = useSyncMemo(() => {
return curState.current + 1
}, [curState])
useEffect(() =>{
for(let i = 0; i < 5; i++){
setState(i)
console.log(memo) // 0 0 0 0 0
console.log(curMemo.current) // 1 2 3 4 5
}
}, [])
return (
<>
{ memo }
)
}
`
不传依赖项的话，计算函数必须用状态值的current进行计算，因为useSyncState内部是通过current的getter去判断依赖的，如下所示：
`
import { useEffect } from 'react'
import { useSyncState, useSyncMemo } from 'react-sync-state-hook'
export default MyComponent = () => {
const [ state, setState, curState ] = useSyncState(0)
const [ memo, curMemo ] = useSyncMemo(() => {
return curState.current + 1
})
useEffect(() =>{
for(let i = 0; i < 5; i++){
setState(i)
console.log(memo) // 0 0 0 0 0
console.log(curMemo.current) // 1 2 3 4 5
}
}, [])
return (
<>
{ memo }
)
}
`
* ### \_getImmutableCopy\_(value)
不可变对象代理的解包函数，在极少数情况下，我们可能需要手动解包，保险起见还是预留了该函数。
`
import { _getImmutableCopy_ } from 'react-sync-state-hook'
const [ state, setState, curState ] = useSyncState({a: 0})
const copy = _getImmutableCopy_(curState)
``