ரியாக்ட்டின் experimental_useMemoCacheInvalidation உத்தி: கேச் மேலாண்மையின் ஒரு ஆழமான பார்வை

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

ரியாக்ட்டில் மெமோயைசேஷன் மற்றும் கேச்சிங்கை புரிந்துகொள்ளுதல்

experimental_useMemoCacheInvalidation இன் பிரத்யேக அம்சங்களைப் பற்றி ஆராய்வதற்கு முன், ரியாக்ட்டில் உள்ள மெமோயைசேஷன் மற்றும் கேச்சிங்கின் அடிப்படைக் கருத்துக்களைப் புரிந்துகொள்வது முக்கியம். மெமோயைசேஷன் என்பது ஒரு நுட்பமாகும், இதில் அதிக செலவாகும் செயல்பாடுகளின் முடிவுகள் சேமிக்கப்பட்டு (கேச் செய்யப்பட்டு) அதே உள்ளீடுகள் மீண்டும் வரும்போது மீண்டும் பயன்படுத்தப்படுகின்றன. ரியாக்ட்டின் உள்ளமைக்கப்பட்ட useMemo மற்றும் useCallback ஹூக்குகள் தேவையற்ற மறு-ரெண்டர்கள் மற்றும் மறு-கணக்கீடுகளைத் தடுக்க மெமோயைசேஷனைப் பயன்படுத்துகின்றன.

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

தரமான useMemo-வின் வரம்புகள்

useMemo ஒரு மதிப்புமிக்க கருவியாக இருந்தாலும், அதற்கு சில வரம்புகள் உள்ளன:

• மேலோட்டமான சார்பு ஒப்பீடு: useMemo அதன் சார்பு வரிசையின் மேலோட்டமான சமத்துவ சோதனைகளை நம்பியுள்ளது. கட்டமைப்பில் சமமாக ஆனால் ரெபரன்ஸில் சமமாக இல்லாத சிக்கலான பொருள்கள் அல்லது வரிசைகள் இன்னும் ஒரு மறு-கணக்கீட்டைத் தூண்டும்.
• நுட்பமான செல்லாததாக்குதல் இல்லாமை: மெமோ செய்யப்பட்ட மதிப்பைச் செல்லாததாக்க சார்பு வரிசையில் உள்ள சார்புகளில் ஒன்றில் மாற்றம் தேவை. மற்ற பயன்பாட்டு தர்க்கத்தின் அடிப்படையில் கேச்சைத் தேர்ந்தெடுத்து செல்லாததாக்க நேரடி வழி இல்லை.
• காம்பொனென்ட்-குறித்தது: மெமோ செய்யப்பட்ட மதிப்பின் வரம்பு useMemo பயன்படுத்தப்படும் காம்பொனென்ட்டுடன் περιορισμένο. காம்பொனென்ட்டுகளுக்கு இடையில் மெமோ செய்யப்பட்ட மதிப்புகளைப் பகிர்வதற்கு கூடுதல் வழிமுறைகள் தேவை.

experimental_useMemoCacheInvalidation-ஐ அறிமுகப்படுத்துதல்

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

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

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

experimental_useMemoCacheInvalidation எவ்வாறு செயல்படுகிறது

experimental_useMemoCacheInvalidation API சில முக்கிய கருத்துக்களைச் சுற்றி வருகிறது:

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

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

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

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

எடுத்துக்காட்டு 1: பிரத்யேக செல்லாததாக்குதலுடன் API பதில்களை கேச்சிங் செய்தல்

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

இதோ ஒரு எளிமைப்படுத்தப்பட்ட கருத்தியல் விளக்கம்:

// கருத்தியல் எடுத்துக்காட்டு - உண்மையான API மற்றும் // எதிர்கால சோதனை API மாற்றங்களின் அடிப்படையில் மாற்றியமைக்கவும். import React, { useState, useEffect } from 'react'; // ஒரு கற்பனையான சோதனை API-ஐக் கருதி // import { unstable_useMemoCache as useMemoCache, unstable_useCacheKey as useCacheKey } from 'react'; function useCachedData(url, dataVersion) { const [data, setData] = useState(null); const [loading, setLoading] = useState(true); const [error, setError] = useState(null); useEffect(() => { async function fetchData() { setLoading(true); try { // தரவைப் பெறுவதை சிமுலேட் செய்யவும் const response = await fetch(url); if (!response.ok) { throw new Error(`HTTP error! Status: ${response.status}`); } const jsonData = await response.json(); setData(jsonData); } catch (error) { setError(error); } finally { setLoading(false); } } fetchData(); }, [url, dataVersion]); // dataVersion ஒரு எளிய செல்லாததாக்கும் தூண்டுதலாக செயல்படுகிறது return { data, loading, error }; } function MyComponent() { const [version, setVersion] = useState(0); // தரவு பதிப்பிற்கான எடுத்துக்காட்டு ஸ்டேட் const { data, loading, error } = useCachedData('/api/data', version); const handleUpdateData = () => { // சர்வரில் தரவைப் புதுப்பிப்பதை சிமுலேட் செய்யவும் // பின்னர், கேச்சை செல்லாததாக்க பதிப்பை அதிகரிக்கவும் setVersion(prevVersion => prevVersion + 1); }; if (loading) return

ஏற்றுகிறது...

; if (error) return

பிழை: {error.message}

; return (

தரவு: {JSON.stringify(data)}

தரவைப் புதுப்பிக்கவும்

); } export default MyComponent;

விளக்கம்:

1. useCachedData ஹூக் ஒரு API-யிலிருந்து தரவைப் பெற்று அதை ஸ்டேட்டில் சேமிக்கிறது.
2. dataVersion prop ஒரு செல்லாததாக்குதல் விசையாக செயல்படுகிறது. பதிப்பு மாறும்போதெல்லாம், useEffect ஹூக் தரவை மீண்டும் பெறுகிறது.
3. handleUpdateData செயல்பாடு சர்வரில் தரவைப் புதுப்பிப்பதை சிமுலேட் செய்து பின்னர் பதிப்பை அதிகரிக்கிறது, இது கேச்சை திறம்பட செல்லாததாக்குகிறது.

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

எடுத்துக்காட்டு 2: பயனர் உள்ளீட்டின் அடிப்படையில் சிக்கலான கணக்கீடுகளை கேச்சிங் செய்தல்

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

// கருத்தியல் எடுத்துக்காட்டு - உண்மையான API மற்றும் // எதிர்கால சோதனை API மாற்றங்களின் அடிப்படையில் மாற்றியமைக்கவும். import React, { useState } from 'react'; function ExpensiveCalculation({ input }) { // ஒரு செலவுமிக்க கணக்கீட்டை சிமுலேட் செய்யவும் const result = useMemo(() => { console.log('கணக்கிடுகிறது...'); let sum = 0; for (let i = 0; i < input * 100000; i++) { sum += i; } return sum; }, [input]); return

முடிவு: {result}

; } function MyComponent() { const [inputValue, setInputValue] = useState(1); const handleChange = (event) => { setInputValue(parseInt(event.target.value, 10) || 1); }; return (

உள்ளீட்டை உள்ளிடவும்:

); } export default MyComponent;

விளக்கம்:

1. ExpensiveCalculation காம்பொனென்ட் input prop-ஐ அடிப்படையாகக் கொண்டு கணக்கீட்டு ரீதியாக தீவிரமான ஒரு கணக்கீட்டைச் செய்கிறது.
2. useMemo ஹூக் input சார்பின் அடிப்படையில் கணக்கீட்டின் முடிவை மெமோ செய்கிறது.
3. inputValue மாறும்போதெல்லாம், ExpensiveCalculation காம்பொனென்ட் மீண்டும் ரெண்டர் செய்யப்படுகிறது, மற்றும் useMemo முடிவை மீண்டும் கணக்கிடுகிறது.

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

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

experimental_useMemoCacheInvalidation பயன்படுத்துவது பல நன்மைகளை வழங்க முடியும்:

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

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

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

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

experimental_useMemoCacheInvalidation-ஐ எப்போது பயன்படுத்துவது

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

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

முடிவுரை

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

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