ரியாக்ட் experimental_LegacyHidden ஐப் புரிந்துகொள்ளுதல்: மரபு அமைப்புகளுடன் உள்ள இடைவெளியைக் குறைத்தல்

ரியாக்ட் (React) என்பது பயனர் இடைமுகங்களை உருவாக்க உதவும் ஒரு சக்திவாய்ந்த ஜாவாஸ்கிரிப்ட் நூலகம் ஆகும். ரியாக்ட் வளர்ச்சியடையும் போது, அது புதிய அம்சங்களையும் API-களையும் அறிமுகப்படுத்தி செயல்திறனையும் டெவலப்பர் அனுபவத்தையும் மேம்படுத்துகிறது. experimental_LegacyHidden என்பது அத்தகைய ஒரு சோதனை API ஆகும், இது சஸ்பென்ஸ் (Suspense) மற்றும் டிரான்சிஷன்ஸ் (Transitions) போன்ற புதிய ரியாக்ட் அம்சங்களுக்கு, மரபுப் பகுதி அமைப்புகளுடன் பணிபுரியும் போது மாற்றத்தை எளிதாக்க வடிவமைக்கப்பட்டுள்ளது. இந்த கட்டுரை experimental_LegacyHidden-ன் நோக்கம், பயன்பாடு, நன்மைகள் மற்றும் வரம்புகள் பற்றிய விரிவான கண்ணோட்டத்தை வழங்குகிறது.

experimental_LegacyHidden என்றால் என்ன?

experimental_LegacyHidden என்பது புதிய ரியாக்ட் அம்சங்களுடன் மரபுப் பகுதி அமைப்புகளை ஒருங்கிணைக்கும் போது ஏற்படும் இணக்கத்தன்மை சிக்கல்களைக் கையாள வடிவமைக்கப்பட்ட ஒரு ரியாக்ட் API ஆகும். குறிப்பாக, சஸ்பென்ஸ் (Suspense) மற்றும் டிரான்சிஷன்ஸ் (Transitions) போன்ற ரியாக்ட்டின் ஒருங்கமைந்த ரெண்டரிங் (concurrent rendering) திறன்களை நம்பகத்தன்மையுடன் ஆதரிக்காத பகுதிகளை நிர்வகிக்க இது உதவுகிறது. இந்த மரபுப் பகுதிகள் ஒருங்கமைவாக ரெண்டர் செய்யப்படும்போது எதிர்பாராத நடத்தைகளை வெளிப்படுத்தலாம் அல்லது பிழைகளை ஏற்படுத்தலாம்.

இதை ஒரு இணக்கத்தன்மை அடுக்காக (compatibility layer) கருதலாம். இது உங்கள் பயன்பாட்டின் சில பகுதிகளை (குறிப்பாக மரபுப் பகுதிகளைக் கொண்டவை) ரெண்டரிங் செய்யும் போது "மரபு" (legacy) எனச் செயல்படுத்தப்பட வேண்டிய பிரிவுகளாகக் குறிக்க அனுமதிக்கிறது. இதன் பொருள், ரியாக்ட், இடைமறிக்கக்கூடிய ரெண்டரிங் (interruptible rendering) போன்ற ஒருங்கமைந்த அம்சங்களை அந்தப் பிரிவுகளுக்குப் பயன்படுத்துவதைத் தவிர்க்கும், இதனால் சாத்தியமான சிக்கல்களைத் தடுக்கும்.

experimental_LegacyHidden ஏன் அவசியம்?

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

இந்த மரபுப் பகுதிகள் ஒருங்கமைந்த அம்சங்களுடன் ரெண்டர் செய்யப்படும்போது, அவை பின்வருவனவற்றிற்கு வழிவகுக்கும்:

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

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

பயன்பாட்டு நிகழ்வுகள் மற்றும் எடுத்துக்காட்டுகள்

experimental_LegacyHidden பயனுள்ளதாக இருக்கும் சில நடைமுறைச் சூழ்நிலைகளை ஆராய்வோம்:

1. மூன்றாம் தரப்பு நூலகங்களுடன் ஒருங்கிணைத்தல்

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

இந்தப் பகுதியைப் பிரித்து வைக்க நீங்கள் experimental_LegacyHidden ஐ எவ்வாறு பயன்படுத்தலாம் என்பது இங்கே:

            import React from 'react';
import { experimental_LegacyHidden as LegacyHidden } from 'react';
import ChartComponent from './ChartComponent'; // Assume this is a legacy charting component

function MyComponent() {
  return (
    

      
My Application
      
        
      
      
Other content...
    
  );
}

export default MyComponent;

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், ChartComponent ஆனது LegacyHidden-க்குள் இணைக்கப்பட்டுள்ளது. இது ரியாக்ட்டிற்கு ChartComponent ஐ ஒரு மரபுப் பகுதியாகக் கருதுமாறு அறிவுறுத்துகிறது மற்றும் அந்த துணைப்பகுதியினுள் (subtree) ஒருங்கமைந்த ரெண்டரிங்கைத் தவிர்க்கிறது.

2. மரபு குறியீட்டை படிப்படியாக மாற்றுதல்

ஒரு பெரிய குறியீட்டுத் தொகுப்பை (codebase) ரியாக்ட் 18 மற்றும் அதற்கு அப்பால் மாற்றும்போது, எல்லாப் பகுதிகளையும் ஒரே நேரத்தில் புதுப்பிப்பது பெரும்பாலும் சாத்தியமற்றது. experimental_LegacyHidden ஆனது பழைய குறியீடுகளுடன் இணக்கத்தன்மையை நிலைநிறுத்திக் கொண்டே புதிய ரியாக்ட் அம்சங்களை படிப்படியாகப் பயன்படுத்த உங்களை அனுமதிக்கிறது.

மரபுப் பகுதிகளைக் கொண்ட உங்கள் பயன்பாட்டின் பிரிவுகளைச் சுற்றிப் போர்த்த experimental_LegacyHidden ஐப் பயன்படுத்தலாம். இந்தப் பகுதிகளை ஒருங்கமைந்த ரெண்டரிங்கிற்கு இணக்கமாகப் புதுப்பிக்கும் போது, நீங்கள் படிப்படியாக LegacyHidden அடுக்குகளை அகற்றலாம்.

3. ஒத்திசைவான பக்க விளைவுகளைக் கொண்ட பகுதிகளைக் கையாளுதல்

சில பகுதிகள் ரெண்டரிங் செய்யும் போது, DOM ஐ நேரடியாகக் கையாளுதல் அல்லது உலகளாவிய மாறிகளை (global variables) அணுகுதல் போன்ற ஒத்திசைவான பக்க விளைவுகளைச் செய்யலாம். இந்த பக்க விளைவுகள் ஒருங்கமைவாக ரெண்டர் செய்யப்படும்போது சிக்கல்களை ஏற்படுத்தலாம், ஏனெனில் ரியாக்ட் ரெண்டரிங் வேலையை இடைமறிக்கலாம் அல்லது மறுவரிசைப்படுத்தலாம்.

componentDidMount ஆயுள் சுழற்சி முறையில் (lifecycle method) document.getElementById ஐப் பயன்படுத்தி DOM ஐ நேரடியாக மாற்றியமைக்கும் ஒரு பகுதியைக் கவனியுங்கள். இத்தகைய நேரடி DOM கையாளுதல் ஒருங்கமைந்த ரெண்டரிங்கில் சிக்கல்களை ஏற்படுத்தலாம்.

            import React, { Component } from 'react';
import { experimental_LegacyHidden as LegacyHidden } from 'react';

class LegacyComponent extends Component {
  componentDidMount() {
    // Direct DOM manipulation (example, avoid in modern React)
    document.getElementById('myElement').textContent = 'Updated by LegacyComponent';
  }

  render() {
    return <div id="myElement">Initial Content</div>;
  }
}

function App() {
  return (
    <div>
      <h1>My Application</h1>
      <LegacyHidden>
        <LegacyComponent />
      </LegacyHidden>
    </div>
  );
}

export default App;

            

              
                Copy
              
            
          

LegacyComponent ஐ LegacyHidden உடன் இணைப்பது அதன் componentDidMount முறை ஒருங்கமைவற்ற சூழலில் செயல்படுத்தப்படுவதை உறுதி செய்கிறது, இது ரியாக்ட்டின் ரெண்டரிங் செயல்முறையுடன் சாத்தியமான முரண்பாடுகளைத் தடுக்கிறது.

experimental_LegacyHidden ஐ எவ்வாறு பயன்படுத்துவது?

experimental_LegacyHidden ஐப் பயன்படுத்துவது ஒப்பீட்டளவில் எளிதானது:

1. API ஐ இறக்குமதி செய்யவும்: experimental_LegacyHidden ஐ react தொகுப்பிலிருந்து இறக்குமதி செய்யவும். சிறந்த வாசிப்புத்தன்மைக்காக இதை LegacyHidden எனப் பெயரிட பரிந்துரைக்கப்படுகிறது.
2. மரபுப் பகுதிகளைச் சுற்றிப் போர்த்தவும்: மரபுப் பகுதி அல்லது துணைப்பகுதியை LegacyHidden பகுதியால் சுற்றிப் போர்த்தவும்.

            import React from 'react';
import { experimental_LegacyHidden as LegacyHidden } from 'react';

function MyComponent() {
  return (
    <div>
      <h1>My Application</h1>
      <LegacyHidden>
        {/* Legacy component here */}
      </LegacyHidden>
      <p>Other content...</p>
    </div>
  );
}

export default MyComponent;

            

              
                Copy
              
            
          

experimental_LegacyHidden ஐப் பயன்படுத்துவதன் நன்மைகள்

• இணக்கத்தன்மை: ஒருங்கமைந்த ரெண்டரிங்கிற்காக வடிவமைக்கப்படாத மரபுப் பகுதிகளுடன் இணக்கத்தன்மையை உறுதி செய்கிறது.
• படிப்படியான தத்தெடுப்பு: பகுதிகளை படிப்படியாக புதுப்பிக்க அனுமதிப்பதன் மூலம் ரியாக்ட் 18 மற்றும் அதற்கு அப்பால் படிப்படியாக மாற உதவுகிறது.
• மேம்பட்ட நிலைத்தன்மை: மரபுப் பகுதிகளில் ஒருங்கமைந்த ரெண்டரிங் சிக்கல்களால் ஏற்படும் எதிர்பாராத நடத்தைகள் மற்றும் இயக்க நேரப் பிழைகளைத் தடுக்கிறது.
• புதிய அம்சங்களைப் பயன்படுத்துதல்: உங்கள் பயன்பாட்டின் பிற பகுதிகளில் சஸ்பென்ஸ் (Suspense) மற்றும் டிரான்சிஷன்ஸ் (Transitions) போன்ற ரியாக்ட்டின் புதிய அம்சங்களைப் பயன்படுத்த உங்களை அனுமதிக்கிறது, அதே நேரத்தில் மரபுப் பகுதிகளின் நிலைத்தன்மையை பாதிக்காமல்.

வரம்புகள் மற்றும் பரிசீலனைகள்

experimental_LegacyHidden மரபுப் பகுதிகளை ஒருங்கிணைப்பதற்கான ஒரு மதிப்புமிக்க கருவியாக இருந்தாலும், அதன் வரம்புகளைப் பற்றி அறிந்திருப்பது அவசியம்:

• செயல்திறன் சுமை: LegacyHidden உடன் பகுதிகளைச் சுற்றிப் போர்த்துவது சற்று செயல்திறன் சுமையை அறிமுகப்படுத்தலாம், ஏனெனில் அது அந்த துணைப்பகுதிகளுக்கு (subtrees) ஒருங்கமைந்த ரெண்டரிங் மேம்படுத்தல்களைப் பயன்படுத்துவதைத் தடுக்கிறது.
• இது சோதனைக்குரியது: பெயரில் குறிப்பிடுவது போல, experimental_LegacyHidden ஒரு சோதனைக்குரிய API ஆகும். இதன் பொருள் எதிர்கால ரியாக்ட் வெளியீடுகளில் இது மாறலாம் அல்லது அகற்றப்படலாம். இதை எச்சரிக்கையுடன் பயன்படுத்தவும் மற்றும் தேவைப்பட்டால் உங்கள் குறியீட்டைப் புதுப்பிக்கத் தயாராக இருக்கவும்.
• நீண்ட கால தீர்வு அல்ல: experimental_LegacyHidden இடம்பெயர்வுக்கு வசதியாக ஒரு தற்காலிக தீர்வாக நோக்கம் கொண்டது. இறுதி நோக்கம் உங்கள் மரபுப் பகுதிகளை ரியாக்ட்டின் ஒருங்கமைந்த அம்சங்களுடன் முழுமையாக இணக்கமாகப் புதுப்பிப்பதாக இருக்க வேண்டும். இதை ஒரு படிக்கல்லாகக் கருதுங்கள், உங்கள் குறியீட்டுத் தொகுப்பில் ஒரு நிரந்தர அம்சமாக அல்ல.
• தடுக்கும் சாத்தியம்: மறைக்கப்பட்ட பகுதி ஒரு மரபுப் பகுதியாகக் கருதப்படுவதால், அது UI ஐப் புதுப்பிப்பதைத் தடுக்கலாம். ஏனெனில், UI இன் மீதமுள்ள பகுதிகளைப் புதுப்பிக்கும் முன், மரபுப் பகுதி ரெண்டரிங்கை முடிக்கும் வரை ரியாக்ட் காத்திருக்கும்.

experimental_LegacyHidden க்கு மாற்றுகள்

experimental_LegacyHidden ஐப் பயன்படுத்துவதற்கு முன், இந்த மாற்றுகளைக் கருத்தில் கொள்ளுங்கள்:

1. மரபுப் பகுதிகளைப் புதுப்பித்தல்

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

2. React.memo ஐப் பயன்படுத்துதல்

React.memo பகுதிகளைத் தேவையற்ற முறையில் மீண்டும் ரெண்டர் செய்வதைத் தடுக்கப் பயன்படுத்தப்படலாம், இது செயல்திறனை மேம்படுத்தி ஒருங்கமைந்த ரெண்டரிங் சிக்கல்களின் நிகழ்தகவைக் குறைக்கும். இருப்பினும், React.memo பண்புக்கூறு மாற்றங்களின் (prop changes) அடிப்படையில் மட்டுமே மீண்டும் ரெண்டர் செய்வதைத் தடுக்கும், எனவே இது எல்லா மரபுப் பகுதிகளுக்கும் பயனுள்ளதாக இருக்காது.

3. Debouncing அல்லது Throttling புதுப்பிப்புகள்

சில சந்தர்ப்பங்களில், மரபுப் பகுதிகளுக்கான புதுப்பிப்புகளின் அதிர்வெண்ணைக் கட்டுப்படுத்த நீங்கள் debouncing அல்லது throttling ஐப் பயன்படுத்தலாம். இது விரைவான அல்லது ஒத்திசைவற்ற ரெண்டரிங்கால் ஏற்படும் சிக்கல்களைத் தடுக்க உதவும்.

சிறந்த நடைமுறைகள்

experimental_LegacyHidden ஐப் பயன்படுத்தும் போது, இந்த சிறந்த நடைமுறைகளைப் பின்பற்றவும்:

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

மரபுப் பகுதி ஒருங்கிணைப்பின் எதிர்காலம்

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

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

முடிவுரை

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

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

கூடுதல் ஆதாரங்கள்

• ரியாக்ட் அதிகாரப்பூர்வ ஆவணங்கள்
• ரியாக்ட் 18 பணிக்குழு விவாதங்கள்