React的useEffect有自己的状态/生命周期。它与状态突变有关，直到效果被破坏才会更新状态。

只要在参数状态中传递一个参数或留下一个黑色数组，它就会完美地工作。

React.useEffect(() => {
    console.log("effect");
    (async () => {
        try {
            let result = await fetch("/query/countries");
            const res = await result.json();
            let result1 = await fetch("/query/projects");
            const res1 = await result1.json();
            let result11 = await fetch("/query/regions");
            const res11 = await result11.json();
            setData({
                countries: res,
                projects: res1,
                regions: res11
            });
        } catch {}
    })(data)
}, [setData])
# or use this
useEffect(() => {
    (async () => {
        try {
            await Promise.all([
                fetch("/query/countries").then((response) => response.json()),
                fetch("/query/projects").then((response) => response.json()),
                fetch("/query/regions").then((response) => response.json())
            ]).then(([country, project, region]) => {
                // console.log(country, project, region);
                setData({
                    countries: country,
                    projects: project,
                    regions: region
                });
            })
        } catch {
            console.log("data fetch error")
        }
    })()
}, [setData]);

或者，您可以尝试React. useref()在React钩子中进行即时更改。

const movies = React.useRef(null);
useEffect(() => {
movies.current='values';
console.log(movies.current)
}, [])

我知道已经有很好的答案了。但我想给另一个想法如何解决同样的问题，并访问最新的'电影'状态，使用我的模块react-useStateRef。

正如你所理解的，通过使用React状态，你可以在每次状态改变时渲染页面。但是通过使用React ref，你总是可以得到最新的值。

模块react-useStateRef让你同时使用状态和ref。它与React向后兼容。useState，所以你可以替换import语句

const { useEffect } = React
import { useState } from 'react-usestateref'

  const [movies, setMovies] = useState(initialValue);

  useEffect(() => {
    (async function() {
      try {

        const result = [
          {
            id: "1546514491119",
          },
        ];
        console.log("result =", result);
        setMovies(result);
        console.log("movies =", movies.current); // will give you the latest results
      } catch (e) {
        console.error(e);
      }
    })();
  }, []);

更多信息:

react-usestsateref

很像扩展React创建的类组件中的. setstate()。组件或React。使用useState钩子提供的更新器的PureComponent状态更新也是异步的，并且不会立即反映出来。

此外，这里的主要问题不仅是异步性质，而且是函数基于当前闭包使用状态值，状态更新将在下一次重新呈现中反映出来，这样现有的闭包不会受到影响，但会创建新的闭包。现在，在当前状态下，钩子中的值是由现有的闭包获得的，当重新呈现发生时，闭包将根据是否再次重新创建函数而更新。

即使您添加了一个setTimeout函数，尽管超时将在重新呈现发生的一段时间后运行，但setTimeout仍将使用前一个闭包的值，而不是更新的值。

setMovies(result);
console.log(movies) // movies here will not be updated

如果你想在状态更新上执行一个动作，你需要使用useEffect钩子，就像在类组件中使用componentDidUpdate一样，因为useState返回的setter没有回调模式

useEffect(() => {
    // action on update of movies
}, [movies]);

就更新状态的语法而言，setMovies(result)将用异步请求中可用的movies值替换状态中先前的movies值。

但是，如果希望将响应与先前存在的值合并，则必须使用状态更新的回调语法以及正确使用扩展语法，如

setMovies(prevMovies => ([...prevMovies, ...result]));

如果我们必须只更新状态，那么更好的方法是使用push方法。

这是我的代码。我想从Firebase状态存储url。

const [imageUrl, setImageUrl] = useState([]);
const [reload, setReload] = useState(0);

useEffect(() => {
    if (reload === 4) {
        downloadUrl1();
    }
}, [reload]);


const downloadUrl = async () => {
    setImages([]);
    try {
        for (let i = 0; i < images.length; i++) {
            let url = await storage().ref(urls[i].path).getDownloadURL();
            imageUrl.push(url);
            setImageUrl([...imageUrl]);

            console.log(url, 'check', urls.length, 'length', imageUrl.length);
        }
    }
    catch (e) {
        console.log(e);
    }
};

const handleSubmit = async () => {
    setReload(4);
    await downloadUrl();
    console.log(imageUrl);
    console.log('post submitted');
};

这段代码将url置于数组状态。这可能对你也有用。

我发现这很好。不将状态(方法1)定义为，例如，

const initialValue = 1;

const [state,setState] = useState(initialValue)

试试这个方法(方法2)，

const [state = initialValue,setState] = useState()

这在没有使用useEffect的情况下解决了渲染问题，因为在这种情况下我们不关心它的内部闭包方法。

附注:如果你关心在任何用例中使用旧状态，那么useState和useEffect需要使用，因为它需要那种状态，所以在这种情况下接近1应使用。

使用后台定时器库。它解决了我的问题。

const timeoutId = BackgroundTimer.setTimeout(() => {
    // This will be executed once after 1 seconds
    // even when the application is the background
    console.log('tac');
}, 1000);