import React, { experimental_useCache, Suspense } from 'react';

// ஒரு API அழைப்பைப் போலியாக உருவாக்குங்கள் (உங்கள் உண்மையான API எண்ட்பாயிண்டுடன் மாற்றவும்)
const fetchUserData = async (userId) => {
  console.log(`பயனர் ஐடிக்கு பயனர் தரவைப் பெறுகிறது: ${userId}`);
  await new Promise(resolve => setTimeout(resolve, 1000)); // நெட்வொர்க் தாமதத்தைப் போலியாக உருவாக்குங்கள்
  const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
  if (!response.ok) {
    throw new Error(`பயனர் தரவைப் பெற முடியவில்லை: ${response.status}`);
  }
  return response.json();
};

// fetchUserData செயல்பாட்டின் கேச் செய்யப்பட்ட பதிப்பை உருவாக்கவும்
const getCachedUserData = experimental_useCache(fetchUserData);

function UserProfile({ userId }) {
  const userData = getCachedUserData(userId);

  return (
    

      
பயனர் சுயவிவரம்
      
பெயர்: {userData.name}
      
மின்னஞ்சல்: {userData.email}
    
  );
}

function App() {
  return (
    பயனர் தரவு ஏற்றப்படுகிறது...

விளக்கம்:

1. experimental_useCache-ஐ இறக்குமதி செய்யவும்: நாங்கள் ரியாக்ட்டிலிருந்து தேவையான ஹூக்கை இறக்குமதி செய்கிறோம்.
2. fetchUserData-ஐ வரையறுக்கவும்: இந்த செயல்பாடு ஒரு API-இலிருந்து பயனர் தரவைப் பெறுவதைப் போலியாக உருவாக்குகிறது. போலி API அழைப்பை உங்கள் உண்மையான தரவுப் பெறுதல் தர்க்கத்துடன் மாற்றவும். await new Promise நெட்வொர்க் தாமதத்தைப் போலியாக உருவாக்குகிறது, இது கேச்சிங்கின் விளைவை மேலும் வெளிப்படையாக்கும். உற்பத்திக்குத் தயாராக பிழை கையாளுதல் சேர்க்கப்பட்டுள்ளது.
3. getCachedUserData-ஐ உருவாக்கவும்: fetchUserData செயல்பாட்டின் கேச் செய்யப்பட்ட பதிப்பை உருவாக்க நாங்கள் experimental_useCache-ஐப் பயன்படுத்துகிறோம். இதுவே நாங்கள் எங்கள் கூறில் உண்மையில் பயன்படுத்தும் செயல்பாடு.
4. UserProfile-இல் getCachedUserData-ஐப் பயன்படுத்தவும்: UserProfile கூறு பயனர் தரவைப் பெற getCachedUserData-ஐ அழைக்கிறது. நாங்கள் experimental_useCache-ஐப் பயன்படுத்துவதால், தரவு ஏற்கனவே கிடைத்தால் கேச்சிலிருந்து பெறப்படும்.
5. Suspense-உடன் மூடவும்: தரவு பெறப்படும்போது ஏற்றுதல் நிலையை கையாள UserProfile கூறு Suspense-உடன் மூடப்பட்டுள்ளது. தரவு ஏற்ற சிறிது நேரம் எடுத்தாலும் இது ஒரு மென்மையான பயனர் அனுபவத்தை உறுதி செய்கிறது.
6. பல அழைப்புகள்: App கூறு இரண்டு UserProfile கூறுகளை ஒரே userId (1) உடன் ரெண்டர் செய்கிறது. இரண்டாவது UserProfile கூறு கேச் செய்யப்பட்ட தரவைப் பயன்படுத்தும், இது இரண்டாவது API அழைப்பைத் தவிர்க்கும். கேச் செய்யப்படாத தரவைப் பெறுவதைக் காட்ட இது வேறு ID உடன் மற்றொரு பயனர் சுயவிவரத்தையும் கொண்டுள்ளது.

இந்த எடுத்துக்காட்டில், முதல் UserProfile கூறு API-இலிருந்து பயனர் தரவைப் பெறும். இருப்பினும், இரண்டாவது UserProfile கூறு கேச் செய்யப்பட்ட தரவைப் பயன்படுத்தும், இது இரண்டாவது API அழைப்பைத் தவிர்க்கும். இது செயல்திறனை கணிசமாக மேம்படுத்தலாம், குறிப்பாக API அழைப்பு அதிக செலவுமிக்கதாக இருந்தால் அல்லது தரவு பல கூறுகளால் அணுகப்பட்டால்.

சஸ்பென்ஸுடன் ஒருங்கிணைத்தல்

experimental_useCache ரியாக்ட்டின் சஸ்பென்ஸ் அம்சத்துடன் தடையின்றி செயல்பட வடிவமைக்கப்பட்டுள்ளது. தரவு ஏற்றத்திற்காகக் காத்திருக்கும் கூறுகளின் ஏற்றுதல் நிலையை அறிவிப்பு ரீதியாக கையாள சஸ்பென்ஸ் உங்களை அனுமதிக்கிறது. நீங்கள் experimental_useCache-ஐ சஸ்பென்ஸுடன் இணைந்து பயன்படுத்தும்போது, தரவு கேச்சில் கிடைக்கும் வரை அல்லது தரவு மூலத்திலிருந்து பெறப்படும் வரை ரியாக்ட் தானாகவே கூறின் ரெண்டரிங்கை இடைநிறுத்தும். தரவு ஏற்றப்படும்போது ஒரு பின்னடைவு UI-ஐ (எ.கா., ஒரு ஏற்றுதல் ஸ்பின்னர்) காண்பிப்பதன் மூலம் சிறந்த பயனர் அனுபவத்தை வழங்க இது உங்களை அனுமதிக்கிறது.

மேலே உள்ள எடுத்துக்காட்டில், Suspense கூறு UserProfile கூறினைச் சுற்றி ஒரு fallback ப்ராப்பை வழங்குகிறது. பயனர் தரவு பெறப்படும்போது இந்த பின்னடைவு UI காட்டப்படும். தரவு கிடைத்தவுடன், UserProfile கூறு பெறப்பட்ட தரவுடன் ரெண்டர் செய்யப்படும்.

ரியாக்ட் சர்வர் கூறுகள் (RSCs) மற்றும் experimental_useCache

ரியாக்ட் சர்வர் கூறுகளுடன் பயன்படுத்தும்போது experimental_useCache பிரகாசிக்கிறது. RSC-களில், தரவுப் பெறுதல் சர்வரில் நடக்கிறது, மற்றும் முடிவுகள் கிளையண்டிற்கு அனுப்பப்படுகின்றன. பல கூறுகளுக்கு ஒரே தரவு தேவைப்பட்டாலும், ஒரு கோரிக்கைக்கு ஒரு முறை மட்டுமே தரவு பெறப்படுவதை உறுதி செய்வதன் மூலம் experimental_useCache சர்வர் பக்க தரவுப் பெறுதலை கணிசமாக மேம்படுத்தலாம்.

பயனர் தரவைப் பெற்று அதை UI-இன் பல பகுதிகளில் காண்பிக்க வேண்டிய ஒரு சர்வர் கூறு உங்களிடம் இருப்பதாகக் கருதுங்கள். experimental_useCache இல்லாமல், நீங்கள் பயனர் தரவை பலமுறை பெற நேரிடலாம், இது திறமையற்றதாக இருக்கலாம். experimental_useCache-உடன், பயனர் தரவு ஒரு முறை மட்டுமே பெறப்பட்டு, அதே சர்வர் கோரிக்கைக்குள் அடுத்தடுத்த பயன்பாடுகளுக்கு கேச் செய்யப்படுவதை நீங்கள் உறுதிசெய்யலாம்.

உதாரணம் (கருத்தியல் RSC உதாரணம்):

// சர்வர் கூறு
import { experimental_useCache } from 'react';

async function fetchUserData(userId) {
  // ஒரு தரவுத்தளத்திலிருந்து பயனர் தரவைப் பெறுவதைப் போலியாக உருவாக்குங்கள்
  await new Promise(resolve => setTimeout(resolve, 500)); // தரவுத்தள வினவல் தாமதத்தைப் போலியாக உருவாக்குங்கள்
  return { id: userId, name: `பயனர் ${userId}`, email: `user${userId}@example.com` };
}

const getCachedUserData = experimental_useCache(fetchUserData);

export default async function UserDashboard({ userId }) {
  const userData = await getCachedUserData(userId);

  return (
    

      
வரவேற்கிறோம், {userData.name}!
      
      
    
  );
}

async function UserInfo({ userId }) {
  const userData = await getCachedUserData(userId);
  return (
    

      
பயனர் தகவல்
      
மின்னஞ்சல்: {userData.email}
    
  );
}

async function UserActivity({ userId }) {
  const userData = await getCachedUserData(userId);
  return (
    

      
சமீபத்திய செயல்பாடு
      
{userData.name} முகப்புப் பக்கத்தைப் பார்த்தார்.
    
  );
}

இந்த எளிமைப்படுத்தப்பட்ட எடுத்துக்காட்டில், UserDashboard, UserInfo, மற்றும் UserActivity அனைத்தும் சர்வர் கூறுகள். அவை அனைத்திற்கும் பயனர் தரவிற்கான அணுகல் தேவை. experimental_useCache-ஐப் பயன்படுத்துவது fetchUserData செயல்பாடு பல கூறுகளில் பயன்படுத்தப்பட்டாலும், ஒரு சர்வர் கோரிக்கைக்கு ஒரு முறை மட்டுமே அழைக்கப்படுவதை உறுதி செய்கிறது.

கருத்தில் கொள்ள வேண்டியவை மற்றும் சாத்தியமான குறைபாடுகள்

experimental_useCache குறிப்பிடத்தக்க நன்மைகளை வழங்கினாலும், அதன் வரம்புகள் மற்றும் சாத்தியமான குறைபாடுகளைப் பற்றி அறிந்திருப்பது முக்கியம்:

• சோதனை நிலை: ஒரு சோதனை API ஆக, experimental_useCache எதிர்கால ரியாக்ட் வெளியீடுகளில் மாற்றப்படலாம் அல்லது அகற்றப்படலாம். உற்பத்திச் சூழல்களில் இதை எச்சரிக்கையுடன் பயன்படுத்தவும், தேவைப்பட்டால் உங்கள் குறியீட்டை மாற்றியமைக்கத் தயாராக இருங்கள். புதுப்பிப்புகளுக்கு ரியாக்ட்டின் அதிகாரப்பூர்வ ஆவணங்கள் மற்றும் வெளியீட்டுக் குறிப்புகளைக் கண்காணிக்கவும்.
• கேச் செல்லுபடியாகாதது: experimental_useCache கேச் செல்லுபடியாகாததற்கான உள்ளமைக்கப்பட்ட வழிமுறைகளை வழங்கவில்லை. அடிப்படை தரவு மாறும்போது கேச்சை செல்லுபடியாகாததாக்க உங்கள் சொந்த உத்திகளை நீங்கள் செயல்படுத்த வேண்டும். இது கேச் ஆயுட்காலத்தை நிர்வகிக்க தனிப்பயன் ஹூக்குகள் அல்லது சூழல் வழங்குநர்களைப் பயன்படுத்துவதை உள்ளடக்கலாம்.
• நினைவகப் பயன்பாடு: தரவை கேச் செய்வது நினைவகப் பயன்பாட்டை அதிகரிக்கலாம். நீங்கள் கேச் செய்யும் தரவின் அளவைக் கவனத்தில் கொள்ளுங்கள் மற்றும் நினைவக நுகர்வைக் கட்டுப்படுத்த கேச் வெளியேற்றம் அல்லது காலாவதி போன்ற நுட்பங்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள். உங்கள் பயன்பாட்டில், குறிப்பாக சர்வர் பக்க சூழல்களில் நினைவகப் பயன்பாட்டைக் கண்காணிக்கவும்.
• வாத வரிசைப்படுத்தல்: கேச் செய்யப்பட்ட செயல்பாட்டிற்கு அனுப்பப்படும் வாதங்கள் வரிசைப்படுத்தக்கூடியதாக இருக்க வேண்டும். ஏனெனில் experimental_useCache வாதங்களைப் பயன்படுத்தி ஒரு கேச் விசையை உருவாக்குகிறது. வாதங்கள் வரிசைப்படுத்தப்படாவிட்டால், கேச் சரியாக வேலை செய்யாமல் போகலாம்.
• பிழைத்திருத்தம்: கேச்சிங் சிக்கல்களைப் பிழைத்திருத்துவது சவாலானது. கேச்சை ஆய்வு செய்து அது எதிர்பார்த்தபடி செயல்படுகிறதா என்பதைச் சரிபார்க்க பதிவிடுதல் மற்றும் பிழைத்திருத்தக் கருவிகளைப் பயன்படுத்தவும். தரவு எப்போது பெறப்படுகிறது மற்றும் எப்போது கேச்சிலிருந்து மீட்டெடுக்கப்படுகிறது என்பதைக் கண்காணிக்க உங்கள் fetchUserData செயல்பாட்டில் தனிப்பயன் பிழைத்திருத்தப் பதிவைச் சேர்ப்பதைக் கருத்தில் கொள்ளுங்கள்.
• உலகளாவிய நிலை: கேச் செய்யப்பட்ட செயல்பாட்டிற்குள் உலகளாவிய மாற்றக்கூடிய நிலையைப் பயன்படுத்துவதைத் தவிர்க்கவும். இது எதிர்பாராத நடத்தைக்கு வழிவகுக்கும் மற்றும் கேச் பற்றி तर्कரீதியாக சிந்திப்பதை கடினமாக்கும். ஒரு நிலையான நிலையை பராமரிக்க செயல்பாட்டு வாதங்கள் மற்றும் கேச் செய்யப்பட்ட முடிவை நம்பியிருங்கள்.
• சிக்கலான தரவுக் கட்டமைப்புகள்: சிக்கலான தரவுக் கட்டமைப்புகளை கேச் செய்யும்போது எச்சரிக்கையாக இருங்கள், குறிப்பாக அவை வட்டக் குறிப்புகளைக் கொண்டிருந்தால். வட்டக் குறிப்புகள் வரிசைப்படுத்தலின் போது முடிவற்ற சுழற்சிகள் அல்லது ஸ்டேக் ஓவர்ஃப்ளோ பிழைகளுக்கு வழிவகுக்கும்.

கேச் செல்லுபடியாகாததற்கான உத்திகள்

experimental_useCache செல்லுபடியாகாததைக் கையாளாததால், நீங்கள் பயன்படுத்தக்கூடிய சில உத்திகள் இங்கே:

• கைமுறை செல்லுபடியாகாதது: தரவு மாற்றங்களைக் கண்காணிக்க ஒரு தனிப்பயன் ஹூக் அல்லது சூழல் வழங்குநரைச் செயல்படுத்தவும். ஒரு மாற்றம் ஏற்படும்போது, கேச் செய்யப்பட்ட செயல்பாட்டை மீட்டமைப்பதன் மூலம் கேச்சை செல்லுபடியாகாததாக்குங்கள். இது மாற்றத்தின் போது மாறும் ஒரு பதிப்பு அல்லது நேரமுத்திரையை சேமித்து, `fetch` செயல்பாட்டிற்குள் இதைச் சரிபார்ப்பதை உள்ளடக்கியது.

       
       import React, { createContext, useContext, useState, experimental_useCache } from 'react';
  
       const DataVersionContext = createContext(null);
  
       export function DataVersionProvider({ children }) {
         const [version, setVersion] = useState(0);
         const invalidate = () => setVersion(v => v + 1);
  
         return (
           
             {children}
           
         );
       }
  
       async function fetchData(version) {
          console.log("பதிப்புடன் தரவைப் பெறுகிறது:", version)
          await new Promise(resolve => setTimeout(resolve, 500));
          return { data: `பதிப்பு ${version}-க்கான தரவு` };
       }
  
       const useCachedData = () => {
         const { version } = useContext(DataVersionContext);
         return experimental_useCache(() => fetchData(version))(); // கேச்சை அழைக்கவும்
       };
  
       export function useInvalidateData() {
         return useContext(DataVersionContext).invalidate;
       }
  
       export default useCachedData;
  
       // எடுத்துக்காட்டு பயன்பாடு:
       function ComponentUsingData() {
         const data = useCachedData();
         return 
  {data?.data}
  ;
       }
  
       function ComponentThatInvalidates() {
          const invalidate = useInvalidateData();
          return கேச்சை செல்லுபடியாகாததாக்கு
       }
  
       // உங்கள் App-ஐ DataVersionProvider உடன் மூடவும்
       // 
       //   
       //   
       // 
       
       

• நேரம் சார்ந்த காலாவதி: ஒரு குறிப்பிட்ட காலத்திற்குப் பிறகு தானாகவே கேச்சை செல்லுபடியாகாததாக்கும் ஒரு கேச் காலாவதி பொறிமுறையைச் செயல்படுத்தவும். இது ஒப்பீட்டளவில் நிலையான ஆனால் எப்போதாவது மாறக்கூடிய தரவுகளுக்கு பயனுள்ளதாக இருக்கும்.
• குறிச்சொல் அடிப்படையிலான செல்லுபடியாகாதது: கேச் செய்யப்பட்ட தரவுகளுடன் குறிச்சொற்களை இணைத்து, இந்த குறிச்சொற்களின் அடிப்படையில் கேச்சை செல்லுபடியாகாததாக்குங்கள். ஒரு குறிப்பிட்ட தரவு மாறும்போது தொடர்புடைய தரவை செல்லுபடியாகாததாக்க இது பயனுள்ளதாக இருக்கும்.
• வெப்சாக்கெட்டுகள் மற்றும் நிகழ்நேர புதுப்பிப்புகள்: உங்கள் பயன்பாடு வெப்சாக்கெட்டுகள் அல்லது பிற நிகழ்நேர புதுப்பிப்பு வழிமுறைகளைப் பயன்படுத்தினால், கேச் செல்லுபடியாகாததைத் தூண்டுவதற்கு இந்த புதுப்பிப்புகளைப் பயன்படுத்தலாம். ஒரு நிகழ்நேர புதுப்பிப்பு பெறப்படும்போது, பாதிக்கப்பட்ட தரவிற்கான கேச்சை செல்லுபடியாகாததாக்குங்கள்.

experimental_useCache-ஐ பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

experimental_useCache-ஐ திறம்படப் பயன்படுத்தவும், சாத்தியமான ஆபத்துகளைத் தவிர்க்கவும், இந்த சிறந்த நடைமுறைகளைப் பின்பற்றவும்:

• அதிக செலவுமிக்க செயல்பாடுகளுக்கு இதைப் பயன்படுத்தவும்: தரவுப் பெறுதல் அல்லது சிக்கலான கணக்கீடுகள் போன்ற உண்மையிலேயே அதிக செலவுமிக்க செயல்பாடுகளுக்கு மட்டுமே experimental_useCache-ஐப் பயன்படுத்தவும். மலிவான செயல்பாடுகளை கேச் செய்வது உண்மையில் கேச் நிர்வாகத்தின் மேல்செலவு காரணமாக செயல்திறனைக் குறைக்கலாம்.
• தெளிவான கேச் விசைகளை வரையறுக்கவும்: கேச் செய்யப்பட்ட செயல்பாட்டிற்கு அனுப்பப்படும் வாதங்கள் கேச் செய்யப்படும் தரவை தனித்துவமாக அடையாளம் காண்பதை உறுதிசெய்யவும். கேச் சரியாக வேலை செய்வதையும், தரவு தற்செயலாக மீண்டும் பயன்படுத்தப்படாமல் இருப்பதையும் உறுதிசெய்ய இது முக்கியமானது. பொருள் வாதங்களுக்கு, ஒரு நிலையான விசையை உருவாக்க அவற்றை வரிசைப்படுத்தி ஹாஷ் செய்வதைக் கருத்தில் கொள்ளுங்கள்.
• கேச் செல்லுபடியாகாத உத்திகளைச் செயல்படுத்தவும்: முன்னர் குறிப்பிட்டபடி, அடிப்படை தரவு மாறும்போது கேச்சை செல்லுபடியாகாததாக்க உங்கள் சொந்த உத்திகளை நீங்கள் செயல்படுத்த வேண்டும். உங்கள் பயன்பாடு மற்றும் தரவுகளுக்கு பொருத்தமான ஒரு உத்தியைத் தேர்வுசெய்க.
• கேச் செயல்திறனைக் கண்காணிக்கவும்: உங்கள் கேச்சின் செயல்திறனைக் கண்காணித்து அது எதிர்பார்த்தபடி செயல்படுகிறதா என்பதை உறுதிசெய்யவும். கேச் வெற்றிகள் மற்றும் தவறுகளைக் கண்காணிக்கவும், சாத்தியமான இடையூறுகளை அடையாளம் காணவும் பதிவிடுதல் மற்றும் பிழைத்திருத்தக் கருவிகளைப் பயன்படுத்தவும்.
• மாற்றுகளைக் கருத்தில் கொள்ளுங்கள்: experimental_useCache-ஐப் பயன்படுத்துவதற்கு முன்பு, பிற கேச்சிங் தீர்வுகள் உங்கள் தேவைகளுக்கு மிகவும் பொருத்தமானதாக இருக்குமா என்பதைக் கருத்தில் கொள்ளுங்கள். எடுத்துக்காட்டாக, கேச் செல்லுபடியாகாதது மற்றும் வெளியேற்றம் போன்ற உள்ளமைக்கப்பட்ட அம்சங்களுடன் கூடிய வலுவான கேச்சிங் தீர்வு உங்களுக்குத் தேவைப்பட்டால், ஒரு பிரத்யேக கேச்சிங் நூலகத்தைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளலாம். `react-query`, `SWR` போன்ற நூலகங்கள், அல்லது `localStorage`-ஐப் பயன்படுத்துவது கூட சில நேரங்களில் மிகவும் பொருத்தமானதாக இருக்கும்.
• சிறியதாகத் தொடங்குங்கள்: உங்கள் பயன்பாட்டில் experimental_useCache-ஐ படிப்படியாக அறிமுகப்படுத்துங்கள். சில முக்கிய தரவுப் பெறுதல் செயல்பாடுகளை கேச் செய்வதன் மூலம் தொடங்கி, நீங்கள் அதிக அனுபவம் பெறும்போது அதன் பயன்பாட்டை படிப்படியாக விரிவாக்குங்கள்.
• உங்கள் கேச்சிங் உத்தியை ஆவணப்படுத்தவும்: எந்த தரவு கேச் செய்யப்படுகிறது, கேச் எவ்வாறு செல்லுபடியாகாததாக்கப்படுகிறது, மற்றும் ஏதேனும் சாத்தியமான வரம்புகள் உட்பட உங்கள் கேச்சிங் உத்தியை தெளிவாக ஆவணப்படுத்தவும். இது மற்ற டெவலப்பர்கள் உங்கள் குறியீட்டைப் புரிந்துகொள்வதற்கும் பராமரிப்பதற்கும் எளிதாக்கும்.
• முழுமையாகச் சோதிக்கவும்: உங்கள் கேச்சிங் செயலாக்கம் சரியாகச் செயல்படுகிறதா என்பதையும், அது எந்த எதிர்பாராத பிழைகளையும் அறிமுகப்படுத்தவில்லை என்பதையும் உறுதிப்படுத்த முழுமையாகச் சோதிக்கவும். கேச் எதிர்பார்த்தபடி நிரப்பப்பட்டு செல்லுபடியாகாததாக்கப்படுகிறது என்பதைச் சரிபார்க்க யூனிட் சோதனைகளை எழுதுங்கள்.

experimental_useCache-க்கு மாற்றுகள்

experimental_useCache ரியாக்ட்டுக்குள் கேச்சிங்கை நிர்வகிக்க ஒரு வசதியான வழியை வழங்கினாலும், இது மட்டுமே கிடைக்கும் விருப்பமல்ல. ரியாக்ட் பயன்பாடுகளில் பல பிற கேச்சிங் தீர்வுகள் பயன்படுத்தப்படலாம், ஒவ்வொன்றும் அதன் சொந்த நன்மைகள் மற்றும் தீமைகளைக் கொண்டுள்ளன.

• useMemo: useMemo ஹூக் அதிக செலவுமிக்க கணக்கீடுகளின் முடிவுகளை மெமோயிஸ் செய்யப் பயன்படுத்தப்படலாம். இது ரெண்டர்கள் முழுவதும் உண்மையான கேச்சிங்கை வழங்கவில்லை என்றாலும், ஒரு கூறுக்குள் செயல்திறனை மேம்படுத்துவதற்கு இது பயனுள்ளதாக இருக்கும். தரவுப் பெறுதல் அல்லது கூறுகள் முழுவதும் தரவைப் பகிர வேண்டிய சூழ்நிலைகளுக்கு இது குறைவாகப் பொருத்தமானது.
• React.memo: React.memo என்பது ஒரு உயர்-வரிசைக் கூறு ஆகும், இது செயல்பாட்டுக் கூறுகளை மெமோயிஸ் செய்யப் பயன்படுத்தப்படலாம். அதன் ப்ராப்ஸ் மாறவில்லை என்றால் அது கூறின் மறு-ரெண்டர்களைத் தடுக்கிறது. இது சில சமயங்களில் செயல்திறனை மேம்படுத்தலாம், ஆனால் இது தரவின் கேச்சிங்கை வழங்காது.
• வெளிப்புற கேச்சிங் நூலகங்கள் (react-query, SWR): react-query மற்றும் SWR போன்ற நூலகங்கள் ரியாக்ட் பயன்பாடுகளுக்கு விரிவான தரவுப் பெறுதல் மற்றும் கேச்சிங் தீர்வுகளை வழங்குகின்றன. இந்த நூலகங்கள் தானியங்கி கேச் செல்லுபடியாகாதது, பின்னணி தரவுப் பெறுதல் மற்றும் ஆப்டிமிஸ்டிக் புதுப்பிப்புகள் போன்ற அம்சங்களை வழங்குகின்றன. உங்களுக்கு மேம்பட்ட அம்சங்களுடன் கூடிய வலுவான கேச்சிங் தீர்வு தேவைப்பட்டால் அவை ஒரு நல்ல தேர்வாக இருக்கும்.
• உள்ளூர் சேமிப்பு / அமர்வு சேமிப்பு: எளிமையான பயன்பாட்டு நிகழ்வுகளுக்கு அல்லது அமர்வுகள் முழுவதும் தரவைத் தக்கவைக்க, `localStorage` அல்லது `sessionStorage` பயன்படுத்தப்படலாம். இருப்பினும், வரிசைப்படுத்தல், செல்லுபடியாகாதது மற்றும் சேமிப்பக வரம்புகளை கைமுறையாக நிர்வகிக்க வேண்டும்.
• தனிப்பயன் கேச்சிங் தீர்வுகள்: ரியாக்ட்டின் சூழல் API அல்லது பிற நிலை மேலாண்மை நுட்பங்களைப் பயன்படுத்தி உங்கள் சொந்த தனிப்பயன் கேச்சிங் தீர்வுகளையும் நீங்கள் உருவாக்கலாம். இது கேச்சிங் செயலாக்கத்தில் உங்களுக்கு முழுமையான கட்டுப்பாட்டை வழங்குகிறது, ஆனால் இது அதிக முயற்சி மற்றும் நிபுணத்துவத்தையும் richiede.

முடிவுரை

ரியாக்ட்டின் experimental_useCache ஹூக் ரியாக்ட் பயன்பாடுகளுக்குள் கேச்சிங்கை நிர்வகிக்க ஒரு சக்திவாய்ந்த மற்றும் வசதியான வழியை வழங்குகிறது. அதிக செலவுமிக்க செயல்பாடுகளின் முடிவுகளை கேச் செய்வதன் மூலம், நீங்கள் செயல்திறனை கணிசமாக மேம்படுத்தலாம், நெட்வொர்க் கோரிக்கைகளைக் குறைக்கலாம், மற்றும் உங்கள் தரவுப் பெறுதல் தர்க்கத்தை எளிமைப்படுத்தலாம். சஸ்பென்ஸ் மற்றும் ரியாக்ட் சர்வர் கூறுகளுடன் இணைந்து பயன்படுத்தும்போது, experimental_useCache பயனர் அனுபவத்தை மேலும் மேம்படுத்தலாம் மற்றும் சர்வர் ரெண்டரிங் செயல்திறனை மேம்படுத்தலாம்.

இருப்பினும், உள்ளமைக்கப்பட்ட கேச் செல்லுபடியாகாதது இல்லாதது மற்றும் அதிகரித்த நினைவகப் பயன்பாட்டிற்கான சாத்தியம் போன்ற experimental_useCache-இன் வரம்புகள் மற்றும் சாத்தியமான குறைபாடுகளைப் பற்றி அறிந்திருப்பது முக்கியம். இந்த வழிகாட்டியில் கோடிட்டுக் காட்டப்பட்டுள்ள சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலமும், உங்கள் பயன்பாட்டின் குறிப்பிட்ட தேவைகளை கவனமாகக் கருத்தில் கொள்வதன் மூலமும், குறிப்பிடத்தக்க செயல்திறன் ஆதாயங்களைத் திறக்கவும், சிறந்த பயனர் அனுபவத்தை வழங்கவும் நீங்கள் experimental_useCache-ஐ திறம்படப் பயன்படுத்தலாம்.

ரியாக்ட்டின் சோதனை API-களுக்கான சமீபத்திய புதுப்பிப்புகள் குறித்து தொடர்ந்து அறிந்திருக்கவும், தேவைக்கேற்ப உங்கள் குறியீட்டை மாற்றியமைக்கத் தயாராக இருக்கவும் நினைவில் கொள்ளுங்கள். ரியாக்ட் தொடர்ந்து வளர்ச்சியடைந்து வருவதால், experimental_useCache போன்ற கேச்சிங் நுட்பங்கள் உயர் செயல்திறன் மற்றும் அளவிடக்கூடிய வலைப் பயன்பாடுகளை உருவாக்குவதில் பெருகிய முறையில் முக்கிய பங்கு வகிக்கும்.