రియాక్ట్ experimental_postpone: మెరుగైన వినియోగదారు అనుభవం కోసం ఎగ్జిక్యూషన్ కంట్రోల్‌లో నైపుణ్యం సాధించడం

రియాక్ట్ నిరంతరం అభివృద్ధి చెందుతూనే ఉంది, పనితీరు మరియు ప్రతిస్పందించే వినియోగదారు ఇంటర్‌ఫేస్‌లను రూపొందించడానికి డెవలపర్‌లకు మరింత అధునాతన సాధనాలను అందిస్తోంది. ఇటీవలి మరియు ఆసక్తికరమైన చేర్పులలో ఒకటి, ప్రస్తుతం ప్రయోగాత్మకంగా ఉంది, experimental_postpone. ఈ ఫీచర్ కాంపోనెంట్‌లు ఎప్పుడు మరియు ఎలా రెండర్ చేయబడతాయనే దానిపై పూర్తి నియంత్రణను అందిస్తుంది, ఇది కీలకమైన నవీకరణలకు ప్రాధాన్యత ఇవ్వడానికి మరియు తక్కువ ముఖ్యమైన వాటిని వాయిదా వేయడానికి మిమ్మల్ని అనుమతిస్తుంది, చివరికి మెరుగైన వినియోగదారు అనుభవానికి దారి తీస్తుంది.

ఎగ్జిక్యూషన్ కంట్రోల్ అవసరాన్ని అర్థం చేసుకోవడం

సాంప్రదాయ రియాక్ట్ అప్లికేషన్‌లలో, అప్‌డేట్‌లు వరుసగా రీ-రెండర్‌లను ప్రేరేపిస్తాయి. రియాక్ట్ సాధారణంగా సమర్థవంతంగా ఉన్నప్పటికీ, సంక్లిష్టమైన కాంపోనెంట్‌లు లేదా తరచుగా అప్‌డేట్‌లు పనితీరు సమస్యలకు దారితీయవచ్చు, ఫలితంగా నెమ్మదిగా ఉండే UIలు మరియు నిరాశాజనకమైన వినియోగదారు అనుభవం ఏర్పడుతుంది. పరిమిత ప్రాసెసింగ్ పవర్ లేదా నెమ్మదిగా ఉండే నెట్‌వర్క్ కనెక్షన్‌లు ఉన్న పరికరాలకు ఇది ప్రత్యేకంగా వర్తిస్తుంది.

experimental_postpone ఈ సవాలును అప్‌డేట్‌లను వ్యూహాత్మకంగా ఆలస్యం చేయడానికి మిమ్మల్ని అనుమతించడం ద్వారా పరిష్కరిస్తుంది. అనవసరమైన రెండరింగ్ పనులను గుర్తించి, వాయిదా వేయడం ద్వారా, మీ అప్లికేషన్‌లోని అత్యంత కీలకమైన భాగాలు ప్రతిస్పందించేలా మీరు నిర్ధారించుకోవచ్చు, ఇది వినియోగదారులకు వేగం మరియు నిరంతరాయ అనుభూతిని ఇస్తుంది.

experimental_postpone పరిచయం

experimental_postpone అనేది ఒక ఫంక్షన్, ఇది ఒక కాంపోనెంట్ యొక్క రెండరింగ్‌ను ఆలస్యం చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇది ఒక ప్రామిస్‌ను ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది. ప్రామిస్ రిసాల్వ్ అయినప్పుడు కాంపోనెంట్ రెండర్ అవుతుంది. కాంపోనెంట్ ఇప్పటికే రెండర్ అవుతుంటే, ప్రామిస్ రిసాల్వ్ అయ్యే వరకు అది పాజ్ చేయబడుతుంది.

ముఖ్య గమనిక: ఈ రచన ప్రకారం, experimental_postpone అనేది ఒక ప్రయోగాత్మక API మరియు మార్పులకు లోబడి ఉంటుంది. మీ రియాక్ట్ కాన్ఫిగరేషన్‌లో ప్రయోగాత్మక ఫీచర్లను ఉపయోగించడానికి మీరు ఆప్ట్-ఇన్ చేయాలి. తాజా వివరాలు మరియు సిఫార్సు చేయబడిన ఉపయోగం కోసం అధికారిక రియాక్ట్ డాక్యుమెంటేషన్‌ను తనిఖీ చేయండి.

experimental_postpone ఎలా పనిచేస్తుంది

ప్రధానంగా, experimental_postpone రియాక్ట్ యొక్క కాంకరెంట్ మోడ్ సామర్థ్యాలను ఉపయోగిస్తుంది. కాంకరెంట్ మోడ్ రియాక్ట్‌కు రెండరింగ్ పనులను ఆపడానికి, పాజ్ చేయడానికి లేదా తిరిగి ప్రారంభించడానికి అనుమతిస్తుంది, అసమకాలిక రెండరింగ్‌ను మరియు వాటి ప్రాముఖ్యత ఆధారంగా అప్‌డేట్‌లకు ప్రాధాన్యత ఇవ్వడాన్ని సాధ్యం చేస్తుంది. experimental_postpone కొన్ని అప్‌డేట్‌లను తక్కువ ప్రాధాన్యతగా గుర్తించడం ద్వారా దీనిని సద్వినియోగం చేసుకుంటుంది, రియాక్ట్ మొదట అత్యవసర పనులపై దృష్టి పెట్టడానికి వీలు కల్పిస్తుంది.

దీనిని మీ రియాక్ట్ అప్లికేషన్ కోసం ఒక ట్రాఫిక్ కంట్రోలర్‌గా భావించండి. అన్ని అప్‌డేట్‌లు ఒకేసారి రాకుండా, experimental_postpone మీకు ట్రాఫిక్‌ను నిర్దేశించడానికి అనుమతిస్తుంది, అత్యంత ముఖ్యమైన వాహనాలకు (కీలకమైన అప్‌డేట్‌లు) ప్రాధాన్యత ఇస్తూ, తక్కువ కీలకమైన వాటిని (అనవసరమైన అప్‌డేట్‌లు) తాత్కాలికంగా ఆపుతుంది.

experimental_postpone ఉపయోగించడానికి ఆచరణాత్మక ఉదాహరణలు

experimental_postpone ప్రత్యేకంగా ప్రయోజనకరంగా ఉండే కొన్ని దృశ్యాలను అన్వేషిద్దాం:

1. తక్కువ ప్రాధాన్యత గల UI ఎలిమెంట్లను వాయిదా వేయడం

వివిధ డేటా విజువలైజేషన్‌లు మరియు చార్ట్‌లను ప్రదర్శించే ఒక డాష్‌బోర్డ్‌ను ఊహించుకోండి. ఈ విజువలైజేషన్‌లలో కొన్ని ఇతరుల కంటే తక్కువ కీలకమైనవి కావచ్చు. ఉదాహరణకు, అనుబంధ సమాచారాన్ని అందించే ఒక ద్వితీయ చార్ట్‌ను వినియోగదారు యొక్క ప్రాథమిక వర్క్‌ఫ్లోపై ప్రభావం చూపకుండా సురక్షితంగా ఆలస్యం చేయవచ్చు.

            import React, { useState, useEffect } from 'react';
import { experimental_postpone } from 'react';

function ImportantComponent() {
  return <div>This is the most important content!</div>;
}

function LessImportantComponent() {
  const [data, setData] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      // Simulate a slow data fetch
      await new Promise(resolve => setTimeout(resolve, 1000));
      setData('Data loaded after 1 second');
    };

    // Postpone rendering until the data is fetched
    experimental_postpone(fetchData());
  }, []);

  if (!data) {
    return <div>Loading less important data...</div>;
  }

  return <div>{data}</div>;
}

function MyDashboard() {
  return (
    <div>
      <ImportantComponent />
      <LessImportantComponent />
    </div>
  );
}

export default MyDashboard;

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, LessImportantComponent దాని రెండరింగ్‌ను ఒక ప్రామిస్ (డేటా ఫెచ్‌ను అనుకరించడం) రిసాల్వ్ అయిన తర్వాత ఆలస్యం చేయడానికి experimental_postponeను ఉపయోగిస్తుంది. ఇది ImportantComponent మొదట రెండర్ అవ్వడాన్ని నిర్ధారిస్తుంది, వేగవంతమైన ప్రారంభ లోడింగ్ అనుభవాన్ని అందిస్తుంది.

2. ఇన్ఫినిట్ స్క్రోల్‌తో జాబితా రెండరింగ్‌ను ఆప్టిమైజ్ చేయడం

ఇన్ఫినిట్ స్క్రోలింగ్‌తో పొడవైన జాబితాలను రెండర్ చేస్తున్నప్పుడు, వినియోగదారు స్క్రోల్ చేస్తున్నప్పుడు జాబితాను అప్‌డేట్ చేయడం గణనపరంగా ఖరీదైనది. experimental_postponeను ఉపయోగించడం ద్వారా, వినియోగదారు స్క్రోలింగ్ ఆపిన తర్వాత కొత్త అంశాల రెండరింగ్‌ను మీరు ఆలస్యం చేయవచ్చు, గ్రహించిన పనితీరును మెరుగుపరచవచ్చు మరియు UI లాగ్‌ను నివారించవచ్చు.

ఒక పెద్ద ఉత్పత్తి కేటలాగ్‌ను ప్రదర్శించే ఒక ఇ-కామర్స్ వెబ్‌సైట్‌ను పరిగణించండి. వినియోగదారు క్రిందికి స్క్రోల్ చేస్తున్నప్పుడు, మరిన్ని ఉత్పత్తులు లోడ్ చేయబడి రెండర్ చేయబడతాయి. సరైన ఆప్టిమైజేషన్ లేకుండా, ఇది ముఖ్యంగా మొబైల్ పరికరాలలో, ఒక జంకీ స్క్రోలింగ్ అనుభవానికి దారితీయవచ్చు.

            import React, { useState, useEffect } from 'react';
import { experimental_postpone } from 'react';

function ProductList() {
  const [products, setProducts] = useState([]);
  const [isLoading, setIsLoading] = useState(false);
  const [page, setPage] = useState(1);

  useEffect(() => {
    const loadMoreProducts = async () => {
      setIsLoading(true);
      // Simulate fetching products from an API
      await new Promise(resolve => setTimeout(resolve, 500));
      const newProducts = Array.from({ length: 10 }, (_, i) => ({
        id: (page - 1) * 10 + i + 1,
        name: `Product ${ (page - 1) * 10 + i + 1 }`,
      }));
      setIsLoading(false);
      return newProducts;
    };

    if (isLoading) return;

    // Postpone rendering new products
    experimental_postpone(loadMoreProducts()).then(newProducts => {
      setProducts(prevProducts => [...prevProducts, ...newProducts]);
    });

  }, [page, isLoading]);

  const handleScroll = () => {
    if (
      window.innerHeight + document.documentElement.scrollTop ===
      document.documentElement.offsetHeight
    ) {
      // Load more products when the user reaches the bottom of the page
      setPage(prevPage => prevPage + 1);
    }
  };

  useEffect(() => {
    window.addEventListener('scroll', handleScroll);
    return () => window.removeEventListener('scroll', handleScroll);
  }, []);

  return (
    <div>
      <ul>
        {products.map(product => (
          <li key={product.id}>{product.name}</li>
        ))}
      </ul>
      {isLoading && <div>Loading...</div>}
    <div>
  );
}

export default ProductList;

            

              
                Copy
              
            
          

ఇక్కడ, మరిన్ని ఉత్పత్తులను లోడ్ చేసే useEffect హుక్‌లో experimental_postpone ఉపయోగించబడింది. loadMoreProducts ద్వారా తిరిగి ఇవ్వబడిన ప్రామిస్ experimental_postponeకు పంపబడుతుంది, ఇది ప్రామిస్ రిసాల్వ్ అయ్యే వరకు products స్టేట్‌కు అసలు అప్‌డేట్‌ను ఆలస్యం చేస్తుంది. ఇది స్క్రోలింగ్ పనితీరును గణనీయంగా మెరుగుపరచగలదు.

3. వినియోగదారు పరస్పర చర్యలకు ప్రాధాన్యత ఇవ్వడం

సెర్చ్ బార్‌లో టైప్ చేయడం వంటి వినియోగదారు పరస్పర చర్యల సమయంలో, UI ప్రతిస్పందించేలా ఉండటం ముఖ్యం. అనలిటిక్స్ ట్రాకింగ్ లేదా బ్యాక్‌గ్రౌండ్ టాస్క్‌ల వంటి తక్కువ ముఖ్యమైన అప్‌డేట్‌లను వాయిదా వేయడానికి మీరు experimental_postponeను ఉపయోగించవచ్చు, ఇది బ్రౌజర్‌కు సెర్చ్ ఇన్‌పుట్ ఫీల్డ్ యొక్క రెండరింగ్‌కు ప్రాధాన్యత ఇవ్వడానికి అనుమతిస్తుంది.

ఉదాహరణకు, వినియోగదారు టైప్ చేస్తున్నప్పుడు శోధన ఫలితాలను ప్రదర్శించే లైవ్ సెర్చ్ ఫీచర్‌తో కూడిన వెబ్‌సైట్‌ను పరిగణించండి. ప్రతి కీస్ట్రోక్‌తో శోధన ఫలితాల జాబితాను నవీకరించడం గణనపరంగా తీవ్రంగా ఉంటుంది. సూచించిన శోధనలు లేదా కేటగిరీ ఫిల్టర్‌ల వంటి సంబంధిత మూలకాల నవీకరణను వాయిదా వేయడం ద్వారా, శోధన ఇన్‌పుట్ ఫీల్డ్ మరింత ప్రతిస్పందించే విధంగా ఉంటుంది.

            import React, { useState, useEffect, useRef } from 'react';
import { experimental_postpone } from 'react';

function SearchBar() {
  const [searchTerm, setSearchTerm] = useState('');
  const [searchResults, setSearchResults] = useState([]);
  const inputRef = useRef(null);

  useEffect(() => {
    const fetchSearchResults = async () => {
      // Simulate fetching search results from an API
      await new Promise(resolve => setTimeout(resolve, 300));
      const results = Array.from({ length: 5 }, (_, i) => ({
        id: i + 1,
        title: `Result for "${searchTerm}" ${i + 1}`,
      }));
      return results;
    };

    if (searchTerm) {
      // Postpone updating search results until after the user pauses typing
      experimental_postpone(fetchSearchResults()).then(results => {
        setSearchResults(results);
      });
    } else {
      setSearchResults([]);
    }

  }, [searchTerm]);

  const handleChange = (event) => {
    setSearchTerm(event.target.value);
  };

  return (
    <div>
      <input
        type="text"
        placeholder="Search..."
        value={searchTerm}
        onChange={handleChange}
        ref={inputRef}
      />
      <ul>
        {searchResults.map(result => (
          <li key={result.id}>{result.title}</li>
        ))}
      </ul>
    </div>
  );
}

export default SearchBar;

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, ప్రస్తుత searchTerm ఆధారంగా శోధన ఫలితాలను నవీకరించడాన్ని ఆలస్యం చేయడానికి useEffect హుక్ లోపల experimental_postpone ఫంక్షన్ ఉపయోగించబడింది. అధిక API కాల్‌లను నివారించడానికి మరియు ఇన్‌పుట్ ఫీల్డ్ యొక్క ప్రతిస్పందనకు ప్రాధాన్యత ఇవ్వడానికి ఒక చిన్న ఆలస్యం (setTimeoutతో అనుకరించబడింది) ప్రవేశపెట్టబడింది.

experimental_postpone ఉపయోగించడానికి ఉత్తమ పద్ధతులు

experimental_postponeను సమర్థవంతంగా ఉపయోగించుకోవడానికి, ఈ ఉత్తమ పద్ధతులను పరిగణించండి:

• కీలకం కాని అప్‌డేట్‌లను గుర్తించండి: వినియోగదారు అనుభవాన్ని ప్రతికూలంగా ప్రభావితం చేయకుండా సురక్షితంగా ఆలస్యం చేయగల UI అంశాలు లేదా అప్‌డేట్‌లను గుర్తించడానికి మీ అప్లికేషన్‌ను జాగ్రత్తగా విశ్లేషించండి.
• పనితీరును కొలవండి: experimental_postponeను అమలు చేయడానికి ముందు మరియు తర్వాత, రెండరింగ్ పనితీరు మరియు ప్రతిస్పందనపై ప్రభావాన్ని కొలవడానికి ప్రొఫైలింగ్ సాధనాలను (రియాక్ట్ డెవ్‌టూల్స్ లేదా బ్రౌజర్ పనితీరు సాధనాలు వంటివి) ఉపయోగించండి.
• జాగ్రత్తగా వాడండి: experimental_postpone ఒక ప్రయోగాత్మక API కాబట్టి, భవిష్యత్ రియాక్ట్ వెర్షన్లలో సంభావ్య మార్పులు లేదా అప్‌డేట్‌లకు సిద్ధంగా ఉండండి. రియాక్ట్‌ను అప్‌గ్రేడ్ చేసిన తర్వాత మీ అప్లికేషన్‌ను క్షుణ్ణంగా పరీక్షించండి.
• ప్రత్యామ్నాయాలను పరిగణించండి: experimental_postponeను ఆశ్రయించే ముందు మెమోయిజేషన్ (React.memo), కోడ్ స్ప్లిటింగ్ మరియు వర్చువలైజేషన్ వంటి ఇతర ఆప్టిమైజేషన్ పద్ధతులను అన్వేషించండి. ఈ పద్ధతులు మరింత స్థిరమైన పనితీరు మెరుగుదలలను అందించవచ్చు.
• దృశ్యమాన ఫీడ్‌బ్యాక్ అందించండి: అప్‌డేట్‌లను ఆలస్యం చేస్తున్నప్పుడు, కంటెంట్ నేపథ్యంలో లోడ్ అవుతోందని లేదా అప్‌డేట్ అవుతోందని సూచించడానికి లోడింగ్ ఇండికేటర్ లేదా ఒక సూక్ష్మ యానిమేషన్ వంటి దృశ్యమాన ఫీడ్‌బ్యాక్‌ను వినియోగదారుకు అందించడాన్ని పరిగణించండి.
• సహేతుకమైన ఆలస్యాలను సెట్ చేయండి: అప్‌డేట్‌లను అధికంగా ఎక్కువ కాలం వాయిదా వేయవద్దు, ఎందుకంటే ఇది ప్రతిస్పందించని భావనకు దారితీస్తుంది. పనితీరు మరియు గ్రహించిన వేగం మధ్య సరైన సమతుల్యతను కనుగొనడానికి వివిధ ఆలస్య వ్యవధులతో ప్రయోగాలు చేయండి.

సంభావ్య సవాళ్లు మరియు పరిగణనలు

experimental_postpone పనితీరు ఆప్టిమైజేషన్ కోసం గణనీయమైన సామర్థ్యాన్ని అందిస్తున్నప్పటికీ, సంభావ్య సవాళ్ల గురించి తెలుసుకోవడం అవసరం:

• సంక్లిష్టత: experimental_postponeను ప్రవేశపెట్టడం మీ కోడ్‌బేస్‌కు సంక్లిష్టతను జోడించవచ్చు, దీనికి జాగ్రత్తగా ప్రణాళిక మరియు అమలు అవసరం.
• అనుకోని దుష్ప్రభావాలు: అప్‌డేట్‌లను ఆలస్యం చేయడం కొన్నిసార్లు అనుకోని దుష్ప్రభావాలకు దారితీయవచ్చు, ముఖ్యంగా సంక్లిష్టమైన స్టేట్ మేనేజ్‌మెంట్ లేదా కాంపోనెంట్‌ల మధ్య పరస్పర చర్యలతో వ్యవహరించేటప్పుడు. క్షుణ్ణమైన పరీక్ష చాలా ముఖ్యం.
• నిర్వహణ ఓవర్‌హెడ్: ఒక ప్రయోగాత్మక APIగా, experimental_postpone భవిష్యత్ రియాక్ట్ వెర్షన్లలో మార్పులకు లేదా తొలగింపుకు లోబడి ఉండవచ్చు, ఇది కోడ్ రీఫ్యాక్టరింగ్ మరియు నిర్వహణను అవసరం చేస్తుంది.

experimental_postponeకు ప్రత్యామ్నాయాలు

experimental_postponeను అమలు చేయడానికి ముందు, ప్రత్యామ్నాయ ఆప్టిమైజేషన్ పద్ధతులను అన్వేషించడాన్ని పరిగణించండి, ఇవి మరింత స్థిరమైన పరిష్కారాలను అందించవచ్చు:

• మెమోయిజేషన్: కాంపోనెంట్‌ల ప్రాప్స్ మారనప్పుడు అనవసరమైన రీ-రెండర్‌లను నివారించడానికి React.memo లేదా useMemoను ఉపయోగించండి.
• కోడ్ స్ప్లిటింగ్: మీ అప్లికేషన్‌ను చిన్న చిన్న భాగాలుగా విభజించండి, వీటిని డిమాండ్‌పై లోడ్ చేయవచ్చు, ఇది ప్రారంభ లోడ్ సమయాన్ని తగ్గిస్తుంది మరియు ప్రతిస్పందనను మెరుగుపరుస్తుంది.
• వర్చువలైజేషన్: పెద్ద జాబితాలను రెండర్ చేయడానికి, కేవలం కనిపించే అంశాలను మాత్రమే రెండర్ చేయడానికి వర్చువలైజేషన్ పద్ధతులను ఉపయోగించండి, ఇది పనితీరును మెరుగుపరుస్తుంది మరియు మెమరీ వినియోగాన్ని తగ్గిస్తుంది.
• డిబౌన్సింగ్ మరియు థ్రాట్లింగ్: టైప్ చేయడం లేదా స్క్రోలింగ్ వంటి వినియోగదారు పరస్పర చర్యల ద్వారా ప్రేరేపించబడిన అప్‌డేట్‌ల ఫ్రీక్వెన్సీని పరిమితం చేయడానికి డిబౌన్సింగ్ లేదా థ్రాట్లింగ్ ఉపయోగించండి.
• డేటా ఫెచింగ్‌ను ఆప్టిమైజ్ చేయడం: బదిలీ చేయబడిన డేటా మొత్తాన్ని తగ్గించడానికి మరియు ప్రతిస్పందన సమయాలను మెరుగుపరచడానికి మీ డేటా ఫెచింగ్ వ్యూహాలను ఆప్టిమైజ్ చేయండి. కాషింగ్ మెకానిజమ్స్ లేదా ప్రీ-ఫెచింగ్ డేటాను ఉపయోగించడాన్ని పరిగణించండి.

ముగింపు

experimental_postpone అనేది రియాక్ట్ అప్లికేషన్‌ల రెండరింగ్ ప్రవర్తనను చక్కగా ట్యూన్ చేయడానికి ఒక శక్తివంతమైన, ప్రయోగాత్మక సాధనం. అనవసరమైన అప్‌డేట్‌లను వ్యూహాత్మకంగా ఆలస్యం చేయడం ద్వారా, మీరు కీలకమైన అప్‌డేట్‌లకు ప్రాధాన్యత ఇవ్వవచ్చు మరియు మొత్తం వినియోగదారు అనుభవాన్ని మెరుగుపరచవచ్చు. అయితే, experimental_postponeను వివేకంతో ఉపయోగించడం చాలా ముఖ్యం, సంక్లిష్టత, నిర్వహణ మరియు దుష్ప్రభావాలపై దాని సంభావ్య ప్రభావాన్ని జాగ్రత్తగా పరిగణించండి. experimental_postponeను ఆశ్రయించే ముందు ఎల్లప్పుడూ ప్రత్యామ్నాయ ఆప్టిమైజేషన్ పద్ధతులను అన్వేషించండి. ఈ ఫీచర్ అభివృద్ధి చెందుతున్నప్పుడు తాజా సమాచారం మరియు సిఫార్సు చేయబడిన వినియోగ నమూనాల కోసం అధికారిక రియాక్ట్ డాక్యుమెంటేషన్‌తో అప్‌డేట్ అవ్వడం గుర్తుంచుకోండి.

అంతిమంగా, experimental_postpone వంటి ఫీచర్లతో ఎగ్జిక్యూషన్ కంట్రోల్‌లో నైపుణ్యం సాధించడం మిమ్మల్ని మరింత ప్రతిస్పందించే, పనితీరు గల మరియు వినియోగదారు-స్నేహపూర్వక రియాక్ట్ అప్లికేషన్‌లను రూపొందించడానికి శక్తివంతం చేస్తుంది, ప్రపంచవ్యాప్తంగా ఉన్న వినియోగదారులకు ఉన్నతమైన అనుభవాన్ని అందిస్తుంది.