This is a code from a React Application, that receive a large amount of data and…
- User
This is a code from a React Application, that receive a large amount of data and displays in diverse ways, that can be in different internal tabs. But it's slow. I need an improvement for fix code mistakes and a better run:
import { Icon } from '@components/Atoms'; import { BadgeStatus } from '@components/Molecules'; import { Skeleton, Tabs } from '@mantine/core'; import { Bloco, Card, Content } from '@src/components/Atoms/Library'; import { CardCountDays } from '@src/components/Organisms/CardCountDays'; import { MainProgressBar } from '@src/components/Organisms/MainProgressBar'; import { getObra, medicoesByObraID, medicoesItemsByMedicaoID, planilhaItemsByPlanilhaID, planilhasByObraID, } from '@src/graphql/queries'; import { Medicao, MedicaoItem, Obra, PlanilhaData, PlanilhaItemData } from '@src/utils/interfaces'; import { bgStatus } from '@src/utils/interfaces/status.enum'; import { generateClient } from 'aws-amplify/api'; import dayjs from 'dayjs'; import { useCallback, useEffect, useMemo, useState } from 'react'; import { useParams } from 'react-router-dom'; import { CardAddDesconto } from './obras.add-desconto'; import { AddMedicao, MergedData } from './obras.add-medicao'; import { CardSetStart } from './obras.set-start'; import { ViewConsolidado } from './obras.view-consolidado'; import { ViewMedicao } from './obras.view-medicao'; import { ViewPlanilhaOrcamentaria } from './obras.view-planilha'; const client = generateClient(); type Tabs = 'consolidado' | 'planilha' | 'add_medicao'; const ObrasView = () => { const { id } = useParams<{ id: string }>(); const [errorID, setErrorID] = useState<boolean>(false); const [responseObraData, setResponseObraData] = useState<Obra | null>(null); const [planilhaData, setPlanilhaData] = useState<PlanilhaData | null>(null); const [planilhaItemData, setPlanilhaItemData] = useState<PlanilhaItemData[]>([]); const [medicoesInfo, setMedicoesInfo] = useState<Medicao[]>([]); const [lastMedicaoItem, setLastMedicaoItem] = useState<MedicaoItem[]>([]); const [nextMedicaoNum, setNextMedicaoNum] = useState<number>(1); const [currentMedicaoData, setCurrentMedicaoData] = useState<MedicaoItem[]>([]); const [acumuladoPercent, setAcumuladoPercent] = useState<string>(''); const { tabValue } = useParams<{ tabValue: string }>(); const [activeTab, setActiveTab] = useState<string | null>(tabValue || 'consolidado'); const [fetchedMedicaoData, setFetchedMedicaoData] = useState<{ [key: string]: MedicaoItem[] }>( {} ); // Para nova medição, dados já mergeados const [processedData, setProcessedData] = useState<MergedData[]>([]); const handleUpdateProcessedData = useCallback((newProcessedData: MergedData[]) => { setProcessedData(newProcessedData); }, []); // Busca por dados da Obra const fetchObra = useCallback(async () => { if (!id) return null; const response = (await client.graphql({ query: getObra, variables: { id: id }, })) as unknown as { data: { getObra: Obra } }; if (!response.data.getObra) setErrorID(true); return response.data.getObra as Obra; }, [id]); useEffect(() => { const fetchData = async () => { const data = await fetchObra(); if (!data) return; setResponseObraData(data); setAcumuladoPercent(((data.valorAcumulado / data.valorTotal) * 100).toFixed(2)); if ((data.status ?? 0) > 1) { fetchMedicoes(data.id); } fetchPlanilha(data.id); }; fetchData(); }, [fetchObra]); const obraData = useMemo(() => responseObraData, [responseObraData]); // Busca por dados da Planilha const fetchPlanilha = async (obraID: string) => { const planilhasResponse = await client.graphql({ query: planilhasByObraID, variables: { obraID: obraID }, }); const planilhasData = planilhasResponse.data.planilhasByObraID.items; setPlanilhaData(planilhasData[0]); const itemsResponse = (await client.graphql({ query: planilhaItemsByPlanilhaID, variables: { planilhaID: planilhasData[0].id, limit: 1500 }, })) as unknown as { data: { planilhaItemsByPlanilhaID: { items: PlanilhaItemData[] } } }; const itemsData = itemsResponse.data.planilhaItemsByPlanilhaID.items; const itemsDataSorted = itemsData.sort( (a, b) => new Date(a.createdAt ?? '').getTime() - new Date(b.createdAt ?? '').getTime() ); setPlanilhaItemData(itemsDataSorted); }; // Busca por Medições desta Obra const fetchMedicoes = async (obraID: string) => { const medicaoResponse = await client.graphql({ query: medicoesByObraID, variables: { obraID: obraID }, }); const medicaoData = medicaoResponse.data.medicoesByObraID.items; // Se encontrou medições, salva resultados e busca dados da última medição if (medicaoData.length > 0) { setNextMedicaoNum(medicaoData.length + 1); medicaoData.sort((a, b) => a.medicaoNum - b.medicaoNum); const medicoesInfoConverted: Medicao[] = medicaoData.map((item) => ({ id: item.id ?? '', medicaoNum: item.medicaoNum ?? 0, dataMedicao: item.dataMedicao ?? '', userCreatedAt: item.userCreatedAt ?? '', valorTotal: item.valorTotal ?? 0, valorTotalMaodeObra: item.valorTotalMaodeObra ?? 0, valorTotalMaterial: item.valorTotalMaterial ?? 0, valorAcumulado: item.valorAcumulado ?? 0, valorSaldo: item.valorSaldo ?? 0, })); setMedicoesInfo(medicoesInfoConverted); const lastMedicao = medicaoData[medicaoData.length - 1]; const lastMedicaoResponse = await client.graphql({ query: medicoesItemsByMedicaoID, variables: { medicaoID: lastMedicao.id, limit: 500 }, }); const lastMedicaoData = lastMedicaoResponse.data.medicoesItemsByMedicaoID.items; const lastMedicaoDataItems: MedicaoItem[] = lastMedicaoData.map((item) => ({ item: item.item ?? '', qtdMedicao: Number(item.qtdMedicao), valorTotal: item.valorTotal ?? null, valorTotalPerc: item.valorTotalPerc ?? null, acumulado: item.acumulado ?? null, acumuladoPerc: item.acumuladoPerc ?? null, saldoQtd: item.saldoQtd ?? null, saldoValor: item.saldoValor ?? null, saldoValorPerc: item.saldoValorPerc ?? null, })); setLastMedicaoItem(lastMedicaoDataItems); } }; const handleMedicaoChange = async (medicaoID: string) => { // Verifica se os dados para o medicaoID atual já foram buscados if (fetchedMedicaoData[medicaoID]) { // Se os dados já existirem, use-os diretamente setCurrentMedicaoData(fetchedMedicaoData[medicaoID]); } else { // Se os dados não existirem, faça a consulta ao banco de dados const response = await client.graphql({ query: medicoesItemsByMedicaoID, variables: { medicaoID: medicaoID, limit: 500 }, }); const currentMedicaoData = response.data.medicoesItemsByMedicaoID.items; window.log('currentMedicaoData', currentMedicaoData); const medicaoDataConverted: MedicaoItem[] = currentMedicaoData.map((item) => ({ item: item.item ?? '', qtdMedicao: item.qtdMedicao ?? null, valorTotal: item.valorTotal ?? null, valorTotalPerc: item.valorTotalPerc ?? null, acumulado: item.acumulado ?? null, acumuladoPerc: item.acumuladoPerc ?? null, saldoQtd: item.saldoQtd ?? null, saldoValor: item.saldoValor ?? null, saldoValorPerc: item.saldoValorPerc ?? null, })); // Armazena os dados buscados no estado fetchedMedicaoData setFetchedMedicaoData((prevState) => ({ ...prevState, [medicaoID]: medicaoDataConverted, })); setCurrentMedicaoData(medicaoDataConverted); } }; const showTabMedicao = useCallback((medicaoNum: number, medicaoID: string) => { setCurrentMedicaoData([]); setActiveTab(`medicao_${medicaoNum}`); handleMedicaoChange(medicaoID); }, []); if (!id || errorID) return ( <Card p="5" shadow> <h4 className="text-center">Obra não encontrada!</h4> </Card> ); const statusBackground = bgStatus[obraData?.status ?? 5]; const classes = { titleBlock: 'p-5 border-b border-white-light min-h-[110px]', progressBlock: `gap-5 p-5 ${statusBackground}`, acumuladoPercent: 'font-display font-bold text-white lg:text-5xl text-4xl', tab: `relative text-base mx-0.5 border border-gray-200 z-10`, toActiveTab: `mt-1 border-b-2 hover:bg-gray-100 bg-white`, activeTab: 'bg-blue-500 border-blue-500 text-white hover:bg-blue-600', }; if (!obraData) return ( <> <Skeleton visible={true} height={288} radius="md"></Skeleton> </> ); return ( <> <Card p="0" shadow> <Bloco horizontal alignVertical="middle" justify="between" className={classes.titleBlock}> <Bloco vertical> <h2 className="text-sky-900">{obraData?.nomeObra}</h2> {obraData?.contrato && ( <p className="text-sm text-slate-600">Contrato: {obraData?.contrato}</p> )} </Bloco> <Bloco vertical alignVertical="middle" alignHorizontal="center" className="gap-2"> <BadgeStatus status={Number(obraData?.status)} icon size="lg" /> <h4 className="text-blue-900">{obraData?.Campus?.nomeCampus}</h4> </Bloco> </Bloco> {/* Bloco de progresso */} <Bloco horizontal justify="between" className={classes.progressBlock}> {/* Cards de Datas */} {obraData?.dataInicio && obraData?.dataFim && ( <Card p="4" className="basis-3/6 max-lg:basis-4/6 justify-between"> <CardCountDays obraData={obraData} /> </Card> )} {medicoesInfo.length > 0 && ( <Card shadow withBorder className="basis-2/6"> <small>Última Medição</small> <span className="lead mt-2"> {dayjs(medicoesInfo[medicoesInfo.length - 1]?.dataMedicao).format('DD.MM.YY')} </span> <p>{medicoesInfo[medicoesInfo.length - 1]?.userCreatedAt}</p> </Card> )} {obraData?.status === 0 && ( <Card shadow withBorder p="3" className="basis-2/6"> <CardAddDesconto tableData={planilhaItemData} obraID={id} /> </Card> )} {obraData?.status === 1 && ( <Card shadow withBorder p="3" className="basis-3/6"> <CardSetStart dataPrevista={obraData.dataInicio} obraID={id} duracao={obraData.duracao} /> </Card> )} {acumuladoPercent !== '0.00' && ( <Bloco vertical alignHorizontal="right" alignVertical="middle" className="max-lg:basis-1/6 basis-3/6" > <span className={classes.acumuladoPercent}>{acumuladoPercent}%</span> <small className="text-white">Completo</small> </Bloco> )} </Bloco> <MainProgressBar acumuladoPercent={acumuladoPercent} valorTotalObra={obraData?.valorTotal ?? 100} medicoesInfo={medicoesInfo} /> </Card> <Content className="px-3 mt-[86px]"> <Tabs className="w-full -mt-[76px]" radius="md" value={activeTab} onChange={setActiveTab}> {/* Tabs */} <Tabs.List className="z-20"> <Tabs.Tab value="consolidado" className={`${classes.tab} ${ activeTab === 'consolidado' ? classes.activeTab : classes.toActiveTab } ml-0`} onClick={() => setActiveTab('consolidado')} > Consolidado </Tabs.Tab> <Tabs.Tab value="planilha" className={`${classes.tab} ${ activeTab === 'planilha' ? classes.activeTab : classes.toActiveTab }`} onClick={() => setActiveTab('planilha')} > Planilha Orçamentária </Tabs.Tab> {medicoesInfo.map((medicao) => ( <Tabs.Tab key={medicao.medicaoNum} value={`medicao_${medicao.medicaoNum}`} className={`${classes.tab} ${ activeTab === `medicao_${medicao.medicaoNum}` ? classes.activeTab : classes.toActiveTab }`} onClick={() => showTabMedicao(medicao.medicaoNum, medicao.id)} > Medição {medicao.medicaoNum} </Tabs.Tab> ))} {Number(obraData?.status) > 1 && acumuladoPercent !== '100.00' && ( <Tabs.Tab value="add_medicao" className={`${classes.tab} ${ activeTab === 'add_medicao' ? classes.activeTab : classes.toActiveTab } text-lg font-bold mr-0`} onClick={() => setActiveTab('add_medicao')} ml="auto" leftSection={<Icon name="BiSolidAddToQueue" propsIcon={{ size: 24 }} />} > Nova Medição </Tabs.Tab> )} </Tabs.List> {/* Conteúdo Tabs */} <Tabs.Panel value="consolidado"> <h3 className="text-blue-900 py-6 px-2">Resumo da Obra com Medições</h3> <ViewConsolidado planilhaItemData={planilhaItemData} medicoesInfo={medicoesInfo} medicoesItemData={lastMedicaoItem} showTabMedicao={showTabMedicao} /> </Tabs.Panel> <Tabs.Panel value="planilha"> <h3 className="text-blue-900 py-5 px-2">Planilha Orçamentária Original</h3> {activeTab === 'planilha' && obraData && planilhaData && ( <ViewPlanilhaOrcamentaria planilhaData={planilhaData!} planilhaItemData={planilhaItemData} obraData={obraData} /> )} </Tabs.Panel> {medicoesInfo.map((medicao) => ( <Tabs.Panel value={`medicao_${medicao.medicaoNum}`} key={medicao.medicaoNum}> <h3 className="text-blue-900 py-5 px-2">Dados da Medição {medicao.medicaoNum}</h3> <ViewMedicao medicaoData={currentMedicaoData} medicaoInfo={medicao} planilhaItemData={planilhaItemData} /> </Tabs.Panel> ))} {activeTab === 'add_medicao' && ( <Tabs.Panel value="add_medicao"> <h3 className="text-blue-900 py-5 px-2">Nova Medição</h3> <AddMedicao tableData={planilhaItemData} medicoesData={lastMedicaoItem} obraID={id} dataInicio={obraData?.dataInicio || Date.now().toString()} nextMedicaoNum={nextMedicaoNum} processedData={processedData} onUpdateProcessedData={handleUpdateProcessedData} /> </Tabs.Panel> )} </Tabs> </Content> </> ); }; export default ObrasView; - Assistant
Optimizing and Improving the Performance of Your React Application
After reviewing your code, I understand that you're experiencing performance issues due to handling a large amount of data and rendering it in different internal tabs. Below are detailed suggestions to fix mistakes and improve the performance of your React application.
1. Lazy Loading of Tab Content
Issue: All
<Tabs.Panel>components are rendered simultaneously, regardless of the active tab. This means that even the content of inactive tabs is being processed and rendered, which can significantly slow down your application when dealing with large data sets.Solution: Only render the content of the active tab. You can achieve this by checking if the tab is active before rendering its content.
Implementation:
Modify your
<Tabs.Panel>components to conditionally render content based on the active tab. For example:<Tabs.Panel value="consolidado"> {activeTab === 'consolidado' && ( <> <h3 className="text-blue-900 py-6 px-2">Resumo da Obra com Medições</h3> <ViewConsolidado planilhaItemData={planilhaItemData} medicoesInfo={medicoesInfo} medicoesItemData={lastMedicaoItem} showTabMedicao={showTabMedicao} /> </> )} </Tabs.Panel>Repeat this pattern for all your
<Tabs.Panel>components. This ensures that only the content of the active tab is rendered, reducing unnecessary processing and improving performance.
2. Optimize Data Fetching
a. Avoid Unnecessary Re-fetching
Issue: Your
useEffecthook depends onfetchObra, which is memoized withuseCallback. However, iffetchObrachanges (e.g., ifidchanges), it will triggeruseEffectagain, causing unnecessary re-fetching.Solution: Use the
iddirectly in theuseEffectdependency array and avoid wrappingfetchObrawithuseCallbackunless necessary.Implementation:
useEffect(() => { const fetchData = async () => { const data = await fetchObra(id); if (!data) return; setResponseObraData(data); setAcumuladoPercent(((data.valorAcumulado / data.valorTotal) * 100).toFixed(2)); await Promise.all([ data.status > 1 ? fetchMedicoes(data.id) : null, fetchPlanilha(data.id), ]); }; fetchData(); }, [id]);b. Fetch Data in Parallel
Issue:
fetchMedicoesandfetchPlanilhaare called sequentially, which can slow down the data loading process.Solution: Use
Promise.allto fetchmedicoesandplanilhadata in parallel.c. Limit Data Fetching
Issue: Fetching large datasets (e.g., limits of 1500 and 500) can be heavy and slow.
Solution: Implement data virtualization or pagination to load data as needed.
Implementation:
- For pagination, modify your GraphQL queries to support
limitandnextToken. - Use a library like
react-windoworreact-virtualizedfor virtualization.
3. Memoization with
useMemoandReact.memoa. Memoize Expensive Calculations
Issue: Sorting and mapping over large datasets every render can be expensive.
Solution: Use
useMemoto memoize the sorted data.Implementation:
const sortedPlanilhaItemData = useMemo(() => { return [...planilhaItemData].sort( (a, b) => new Date(a.createdAt ?? '').getTime() - new Date(b.createdAt ?? '').getTime() ); }, [planilhaItemData]);b. Optimize Components with
React.memoIssue: Components re-render when their parent component renders, even if their props haven't changed.
Solution: Wrap components like
ViewConsolidado,ViewMedicao, andViewPlanilhaOrcamentariawithReact.memoto prevent unnecessary re-renders.Implementation:
const ViewConsolidado = React.memo(({ ...props }) => { // Component code });
4. Optimize State Management
Issue: Some state values are derived from other state values or props, leading to redundant state and potential synchronization issues.
Solution: Compute derived state values using
useMemoinstead of storing them in state.Implementation:
const acumuladoPercent = useMemo(() => { if (obraData && obraData.valorTotal !== 0) { return ((obraData.valorAcumulado / obraData.valorTotal) * 100).toFixed(2); } return '0.00'; }, [obraData]);
5. Avoid Inline Function Definitions
Issue: Defining functions inline, especially in render methods, can cause unnecessary re-renders because new function instances are created on each render.
Solution: Define functions outside of the render method or use
useCallbackto memoize them.Implementation:
const showTabMedicao = useCallback((medicaoNum: number, medicaoID: string) => { setCurrentMedicaoData([]); setActiveTab(`medicao_${medicaoNum}`); handleMedicaoChange(medicaoID); }, [handleMedicaoChange]);
6. Implement Code Splitting and Lazy Loading
Issue: All components are loaded upfront, increasing the initial load time.
Solution: Use
React.lazyandSuspenseto lazy-load components as needed.Implementation:
import { Suspense, lazy } from 'react'; const ViewConsolidado = lazy(() => import('./obras.view-consolidado')); const ViewMedicao = lazy(() => import('./obras.view-medicao')); const ViewPlanilhaOrcamentaria = lazy(() => import('./obras.view-planilha')); const CardSetStart = lazy(() => import('./obras.set-start')); const CardAddDesconto = lazy(() => import('./obras.add-desconto')); const AddMedicao = lazy(() => import('./obras.add-medicao'));Wrap the components in
Suspensewith a fallback:<Suspense fallback={<div>Loading...</div>}> {activeTab === 'consolidado' && ( <ViewConsolidado planilhaItemData={planilhaItemData} medicoesInfo={medicoesInfo} medicoesItemData={lastMedicaoItem} showTabMedicao={showTabMedicao} /> )} </Suspense>
7. Use Loading States and Skeletons
Issue: Rendering components before data is fully loaded can cause errors or empty displays.
Solution: Implement loading states or skeleton screens to enhance user experience while data is loading.
Implementation:
if (!obraData) { return <Skeleton visible={true} height={288} radius="md" />; }You can also add loading states for individual tabs or sections.
8. Optimize Rendering of Medicao Tabs
Issue: Rendering all medicao tabs and their contents can be heavy, especially if there are many medicaos.
Solution:
- Only create tabs for medicaos when necessary.
- Use virtualization for lists within medicao components.
- Avoid rendering tab contents until the tab is active.
Implementation:
Modify the mapping over
medicoesInfoto:<Tabs.Tab key={medicao.medicaoNum} value={`medicao_${medicao.medicaoNum}`} className={`${classes.tab} ${ activeTab === `medicao_${medicao.medicaoNum}` ? classes.activeTab : classes.toActiveTab }`} onClick={() => { showTabMedicao(medicao.medicaoNum, medicao.id); }} > Medição {medicao.medicaoNum} </Tabs.Tab>And the corresponding
<Tabs.Panel>:<Tabs.Panel value={`medicao_${medicao.medicaoNum}`} key={medicao.medicaoNum}> {activeTab === `medicao_${medicao.medicaoNum}` && ( <> <h3 className="text-blue-900 py-5 px-2">Dados da Medição {medicao.medicaoNum}</h3> <ViewMedicao medicaoData={currentMedicaoData} medicaoInfo={medicao} planilhaItemData={planilhaItemData} /> </> )} </Tabs.Panel>
9. Correct Missing Dependencies in Hooks
Issue: Functions like
fetchObraandshowTabMedicaolack dependencies in their dependency arrays, which can lead to stale closures.Solution: Ensure all dependencies are included in dependency arrays.
Implementation:
const fetchObra = useCallback(async () => { if (!id) return null; // function body... }, [id, client]); // Include all dependencies const showTabMedicao = useCallback( (medicaoNum: number, medicaoID: string) => { setCurrentMedicaoData([]); setActiveTab(`medicao_${medicaoNum}`); handleMedicaoChange(medicaoID); }, [handleMedicaoChange] );
10. Optimize Data Structures
Issue: Storing large datasets in state can consume memory and slow down your application.
Solution:
- Only store data in state that triggers UI updates.
- Use references or context for data that doesn't need to trigger re-renders.
11. Use Error Boundaries
Issue: If any component throws an error during rendering, it can unmount the entire component tree, causing a poor user experience.
Solution: Implement error boundaries to catch errors in rendering.
Implementation:
class ErrorBoundary extends React.Component { state = { hasError: false }; static getDerivedStateFromError(error) { return { hasError: true }; } render() { if (this.state.hasError) { return <div>Something went wrong.</div>; } return this.props.children; } } // Usage <ErrorBoundary> <Suspense fallback={<div>Loading...</div>}> {/* Your components */} </Suspense> </ErrorBoundary>
12. Profile and Monitor Performance
Issue: It's challenging to know where the bottlenecks are without profiling.
Solution: Use React's Profiler to identify slow components or unnecessary re-renders.
Implementation:
Enable profiling in your application and analyze the results to optimize further.
13. Debounce or Throttle Expensive Operations
Issue: Functions that run on events like scrolling or resizing can fire multiple times and cause performance issues.
Solution: Implement debouncing or throttling to limit how often these functions execute.
Implementation:
const handleResize = useCallback( debounce(() => { // Your resize logic }, 500), [] ); useEffect(() => { window.addEventListener('resize', handleResize); return () => window.removeEventListener('resize', handleResize); }, [handleResize]);
14. Use Web Workers for Heavy Computations
Issue: Heavy computations on the main thread can freeze the UI.
Solution: Offload heavy computations to Web Workers.
15. Ensure Efficient Rendering of Lists
Issue: Rendering large lists can be slow.
Solution: Use virtualization libraries like
react-windoworreact-virtualizedto efficiently render only the visible items.Implementation:
import { FixedSizeList as List } from 'react-window'; <List height={500} itemCount={items.length} itemSize={35} width="100%" > {({ index, style }) => ( <div style={style}> {items[index]} </div> )} </List>
16. Verify Correct Use of Keys in Lists
Issue: Using incorrect or unstable keys in list rendering can cause React to misidentify elements, leading to performance issues.
Solution: Ensure that you use unique and consistent keys when rendering lists.
17. Clean Up Unused State and Variables
Issue: Unused state variables and code can consume memory and lead to confusion.
Solution: Regularly clean up your codebase to remove any unused code.
18. Optimize CSS and Styling
Issue: Complex or inefficient CSS can slow down rendering.
Solution:
- Minimize the use of complex selectors.
- Avoid inline styles where possible.
- Use CSS modules or styled-components for better performance.
19. Stay Updated
Issue: Older versions of dependencies might lack performance improvements.
Solution: Ensure that all your dependencies (e.g., React, Mantine) are up to date.
By implementing these strategies, you should notice a significant improvement in your application's performance. Begin by focusing on the areas that will have the most impact, such as lazy loading of tab content, optimizing data fetching, and avoiding unnecessary re-renders.
If you need further assistance with any of these steps or have additional questions, feel free to ask!
- For pagination, modify your GraphQL queries to support