了解 React Native 如何渲染组件对于构建高效且高性能的应用程序至关重要。当组件的状态或属性发生变化时，React 会自动更新用户界面（UI）以反映这些变化。结果，React 再次调用组件的 render 方法来生成更新的 UI 表示。
在本文中，我们将探讨三个 React Hook 以及它们如何防止 React 中不必要的渲染
这些工具使我们能够通过避免不必要的重新渲染、提高性能和有效存储值来优化代码。
在本文结束时，我们将更好地了解如何使用这些方便的 React hook 使我们的 React 应用程序更快、响应更快。
在 React 中，useMemo 可以防止不必要的重新渲染并优化性能。
让我们探索一下 useMemo 钩子如何防止 React 组件中不必要的重新渲染。
通过记住函数的结果并跟踪其依赖关系，useMemo 确保仅在必要时重新计算该过程。
考虑以下示例：
import { useMemo, useState } from 'react';
function Page() {
const [count, setCount] = useState(0);
const [items] = useState(generateItems(300));
const selectedItem = useMemo(() => items.find((item) => item.id === count), [
count,
items,
]);
function generateItems(count) {
const items = [];
for (let i = 0; i < count; i++) {
items.push({
id: i,
isSelected: i === count - 1,
});
}
return items;
}
return (
<div className="tutorial">
<h1>Count: {count}</h1>
<h1>Selected Item: {selectedItem?.id}</h1>
<button onClick={() => setCount(count + 1)}>Increment</button>
</div>
);
}
export default Page;
上面的代码是一个名为Page的React组件，它使用useMemo来优化selectedItem计算。
解释如下：
使用 useMemo 通过记住 items.find 操作的结果来优化性能。它确保仅在依赖项（计数或项目）发生变化时才执行 selectedItem 的计算，从而防止后续渲染时不必要的重新计算。
应有选择地对计算密集型操作采用记忆化，因为它会给渲染过程带来额外的开销。
React 中的 useCallback 钩子允许记忆函数，防止在每个组件渲染期间重新创建它们。通过利用 useCallback。只要其依赖项保持不变，部件仅创建一次并在后续渲染中重复使用。
考虑以下示例：
import React, { useState, useCallback, memo } from 'react';
const allColors = ['red', 'green', 'blue', 'yellow', 'orange'];
const shuffle = (array) => {
const shuffledArray = [...array];
for (let i = shuffledArray.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[shuffledArray[i], shuffledArray[j]] = [shuffledArray[j], shuffledArray[i]];
}
return shuffledArray;
};
const Filter = memo(({ onChange }) => {
console.log('Filter rendered!');
return (
<input
type='text'
placeholder='Filter colors...'
onChange={(e) => onChange(e.target.value)}
/>
);
});
function Page() {
const [colors, setColors] = useState(allColors);
console.log(colors[0])
const handleFilter = useCallback((text) => {
const filteredColors = allColors.filter((color) =>
color.includes(text.toLowerCase())
);
setColors(filteredColors);
}, [colors]);
return (
<div className='tutorial'>
<div className='align-center mb-2 flex'>
<button onClick={() => setColors(shuffle(allColors))}>
Shuffle
</button>
<Filter onChange={handleFilter} />
</div>
<ul>
{colors.map((color) => (
<li key={color}>{color}</li>
))}
</ul>
</div>
);
}
export default Page;
上面的代码演示了 React 组件中的简单颜色过滤和洗牌功能。让我们一步一步来：
useCallback 钩子用于记忆handleFilter 函数，这意味着该函数仅创建一次，并且如果依赖项（在本例中为颜色状态）保持不变，则在后续渲染中重用。
This optimization prevents unnecessary re-renders of child components that receive the handleFilter function as a prop, such as the Filter component.
It ensures that the Filter component is not re-rendered if the colors state hasn't changed, improving performance.
Another approach to enhance performance in React applications and avoid unnecessary re-renders is using the useRef hook. Using useRef, we can store a mutable value that persists across renders, effectively preventing unnecessary re-renders.
This technique allows us to maintain a reference to a value without triggering component updates when that value changes. By leveraging the mutability of the reference, we can optimize performance in specific scenarios.
Consider the following example:
import React, { useRef, useState } from 'react';
function App() {
const [name, setName] = useState('');
const inputRef = useRef(null);
function handleClick() {
inputRef.current.focus();
}
return (
<div>
<input
type="text"
value={name}
onChange={(e) => setName(e.target.value)}
ref={inputRef}
/>
<button onClick={handleClick}>Focus</button>
</div>
);
}
The example above has a simple input field and a button. The useRef hook creates a ref called inputRef. As soon as the button is clicked, the handleClick function is called, which focuses on the input element by accessing the current property of the inputRef ref object. As such, it prevents unnecessary rerendering of the component when the input value changes.
To ensure optimal use of useRef, reserve it solely for mutable values that do not impact the component's rendering. If a mutable value influences the component's rendering, it should be stored within its state instead.
Throughout this tutorial, we explored the concept of React re-rendering and its potential impact on the performance of our applications. We delved into the optimization techniques that can help mitigate unnecessary re-renders. React offers a variety of hooks that enable us to enhance the performance of our applications. We can effectively store values and functions between renders by leveraging these hooks, significantly boosting React application performance.
以上是如何防止不必要的 React 组件重新渲染的详细内容。更多信息请关注PHP中文网其他相关文章！
