2025 m. rugsėjo 2 d.Lietuvių

Ištirkite React experimental_useFormStatus kabliuką (hook) supaprastintam formos būsenos valdymui. Sužinokite apie diegimą, naudą ir pažangų naudojimą su pavyzdžiais.

React experimental_useFormStatus įgyvendinimas: patobulintas formos būsenos valdymas

Nuolat besikeičianti React ekosistema nuolat pristato įrankius ir metodus, skirtus pagerinti programuotojų patirtį ir programų našumą. Viena iš tokių eksperimentinių funkcijų yra experimental_useFormStatus kabliukas (hook), sukurtas supaprastinti formos būsenos valdymą, ypač serverio veiksmų ir laipsniško tobulinimo (progressive enhancement) scenarijuose. Šiame išsamiame vadove išsamiai išnagrinėsime experimental_useFormStatus kabliuką, pateikdami praktinių pavyzdžių ir įžvalgų, kaip jį efektyviai naudoti.

Kas yra `experimental_useFormStatus`?

experimental_useFormStatus kabliukas (hook) yra eksperimentinis API, kurį pristatė React komanda, siekdama suteikti paprastesnį būdą sekti formos pateikimo būseną, ypač naudojant serverio veiksmus. Prieš atsirandant šiam kabliukui, skirtingų formos būsenų (neaktyvi, pateikiama, sėkminga, klaida) valdymas dažnai reikalavo sudėtingos būsenos valdymo logikos. experimental_useFormStatus siekia abstrahuoti didžiąją dalį šio sudėtingumo, suteikdamas paprastą ir efektyvų būdą stebėti formos pateikimo būsenas ir į jas reaguoti.

Pagrindiniai privalumai:

Supaprastintas būsenos valdymas: Sumažina šabloninio kodo, reikalingo formos pateikimo būsenoms valdyti, kiekį.
Pagerinta vartotojo patirtis: Leidžia greičiau atnaujinti vartotojo sąsają, atsižvelgiant į formos būseną.
Geresnis kodo skaitomumas: Su formomis susijęs kodas tampa lengviau suprantamas ir prižiūrimas.
Sklandi integracija su serverio veiksmais: Sukurtas ypač gerai veikti su React serverio komponentais ir serverio veiksmais.

Pagrindinis įgyvendinimas

Norėdami iliustruoti pagrindinį experimental_useFormStatus įgyvendinimą, panagrinėkime paprastos kontaktų formos pavyzdį. Ši forma rinks vartotojo vardą, el. pašto adresą ir žinutę, o tada pateiks ją naudojant serverio veiksmą.

Būtinosios sąlygos

Prieš pradedant analizuoti kodą, įsitikinkite, kad turite React projektą su šiomis sąlygomis:

React versija, palaikanti eksperimentinius API (reikiamą versiją patikrinkite React dokumentacijoje).
Įjungti React serverio komponentai (dažniausiai naudojami karkasuose, tokiuose kaip Next.js ar Remix).

Pavyzdys: paprasta kontaktų forma

Štai pagrindinis kontaktų formos komponentas:

```jsx // app/actions.js (Serverio veiksmas) 'use server' export async function submitContactForm(formData) { // Imituojamas duomenų bazės iškvietimas ar API užklausa await new Promise(resolve => setTimeout(resolve, 2000)); const name = formData.get('name'); const email = formData.get('email'); const message = formData.get('message'); if (!name || !email || !message) { return { success: false, message: 'Visi laukai yra privalomi.' }; } try { // Pakeiskite tikru API iškvietimu ar duomenų bazės operacija console.log('Forma pateikta:', { name, email, message }); return { success: true, message: 'Forma sėkmingai pateikta!' }; } catch (error) { console.error('Klaida pateikiant formą:', error); return { success: false, message: 'Nepavyko pateikti formos.' }; } } // app/components/ContactForm.jsx (Kliento komponentas) 'use client' import { experimental_useFormStatus as useFormStatus } from 'react' import { submitContactForm } from '../actions' function SubmitButton() { const { pending } = useFormStatus() return ( ) } export default function ContactForm() { return (

Vardas:

El. paštas:

Žinutė:

</div>
      <SubmitButton />
    </form>
  );
}
```

<h3>Paaiškinimas</h3>

<ul>
  <li><b>Serverio veiksmas (<code>app/actions.js</code>):</b> Šiame faile apibrėžiama <code>submitContactForm</code> funkcija, kuri yra serverio veiksmas. Ji imituoja API užklausą su 2 sekundžių vėlavimu, kad būtų parodytas asinchroninis formos pateikimo pobūdis. Taip pat tvarkomas pagrindinis validavimas ir klaidų apdorojimas.</li>
  <li><b>Kliento komponentas (<code>app/components/ContactForm.jsx</code>):</b> Šiame faile apibrėžiamas <code>ContactForm</code> komponentas, kuris yra kliento komponentas. Jis importuoja <code>experimental_useFormStatus</code> kabliuką ir <code>submitContactForm</code> veiksmą.</li>
  <li><b><code>useFormStatus</code> naudojimas:</b> <code>SubmitButton</code> komponente iškviečiamas <code>useFormStatus</code>. Šis kabliukas suteikia informaciją apie formos pateikimo būseną.</li>
  <li><b><code>pending</code> savybė:</b> <code>useFormStatus</code> grąžinama <code>pending</code> savybė nurodo, ar forma šiuo metu yra pateikiama. Ji naudojama norint išjungti pateikimo mygtuką ir rodyti pranešimą „Pateikiama...“.</li>
  <li><b>Formos susiejimas:</b> <code>form</code> elemento <code>action</code> atributas yra susietas su <code>submitContactForm</code> serverio veiksmu. Tai nurodo React iškviesti serverio veiksmą, kai forma yra pateikiama.</li>
</ul>

<h2>Pažangus naudojimas ir aspektai</h2>

<h3>Sėkmės ir klaidų būsenų tvarkymas</h3>

<p>Nors <code>experimental_useFormStatus</code> supaprastina pateikimo būsenos sekimą, dažnai reikia aiškiai tvarkyti sėkmės ir klaidų būsenas. Serverio veiksmai gali grąžinti duomenis, kurie nurodo sėkmę ar nesėkmę, kuriuos galite naudoti atitinkamai atnaujindami vartotojo sąsają.</p>

<p><b>Pavyzdys:</b></p>

```jsx
// app/components/ContactForm.jsx (Pakeista)
'use client'

import { experimental_useFormStatus as useFormStatus } from 'react'
import { submitContactForm } from '../actions'
import { useState } from 'react';

function SubmitButton() {
  const { pending } = useFormStatus()

return (
    <button type="submit" disabled={pending}>
      {pending ? 'Pateikiama...' : 'Pateikti'}
    </button>
  )
}

export default function ContactForm() {
  const [message, setMessage] = useState(null);

async function handleSubmit(formData) {
    const result = await submitContactForm(formData);
    setMessage(result);
  }

return (
    <div>
      <form action={handleSubmit}>
        <div>
          <label htmlFor="name">Vardas:</label>
          <input type="text" id="name" name="name" required />
        </div>
        <div>
          <label htmlFor="email">El. paštas:</label>
          <input type="email" id="email" name="email" required />
        </div>
        <div>
          <label htmlFor="message">Žinutė:</label>
          <textarea id="message" name="message" required />
        </div>
        <SubmitButton />
      </form>
      {message && (
        <p className={message.success ? 'success' : 'error'}>
          {message.message}
        </p>
      )}
    </div>
  );
}
```

<p><b>Paaiškinimas:</b></p>

<ul>
  <li><b>Būsena pranešimams:</b> Įvedamas <code>message</code> būsenos kintamasis, skirtas saugoti serverio veiksmo grąžintą rezultatą.</li>
  <li><b>Rezultato tvarkymas:</b> Pateikus formą, <code>handleSubmit</code> funkcija atnaujina <code>message</code> būseną su rezultatu iš serverio veiksmo.</li>
  <li><b>Pranešimų rodymas:</b> Komponentas rodo pranešimą, remdamasis rezultato <code>success</code> savybe, ir taiko skirtingas CSS klases sėkmės ir klaidų būsenoms.</li>
</ul>

<h3>Laipsniškas tobulinimas</h3>

<p><code>experimental_useFormStatus</code> ypač naudingas laipsniško tobulinimo scenarijuose. Laipsniškai tobulindami standartinę HTML formą su React, galite suteikti geresnę vartotojo patirtį, neprarandant pagrindinio funkcionalumo, jei JavaScript neveikia.</p>

<p><b>Pavyzdys:</b></p>

<p>Pradedant nuo pagrindinės HTML formos:</p>

```html

<form action="/submit-contact" method="post">
  <div>
    <label for="name">Vardas:</label>
    <input type="text" id="name" name="name" required />
  </div>
  <div>
    <label for="email">El. paštas:</label>
    <input type="email" id="email" name="email" required />
  </div>
  <div>
    <label for="message">Žinutė:</label>
    <textarea id="message" name="message" required>

```

Tada galite ją laipsniškai tobulinti su React ir experimental_useFormStatus.

```jsx // app/components/EnhancedContactForm.jsx 'use client' import { experimental_useFormStatus as useFormStatus } from 'react' import { submitContactForm } from '../actions' import { useState } from 'react'; import { useFormState } from 'react-dom'; function SubmitButton() { const { pending } = useFormStatus() return ( ) } export default function EnhancedContactForm() { const [message, setMessage] = useState(null); const [state, formAction] = useFormState(submitContactForm, null); // Naudokite null kaip pradinę būseną, jei ja nesiremiama return (

Vardas:

El. paštas:

Žinutė:

</div>
        <SubmitButton />
		{state?.message && (
        <p className={state.success ? 'success' : 'error'}>
          {state.message}
        </p>
      )}
      </form>
    </div>
  );
}
```

<p><b>Paaiškinimas:</b></p>

<ul>
  <li><b>Pradinė HTML forma:</b> <code>public/contact.html</code> faile yra standartinė HTML forma, kuri veiks net ir be JavaScript.</li>
  <li><b>Laipsniškas tobulinimas:</b> <code>EnhancedContactForm</code> komponentas laipsniškai tobulina HTML formą. Jei JavaScript yra įjungtas, React perima valdymą ir suteikia turtingesnę vartotojo patirtį.</li>
  <li><b><code>useFormState</code> kabliukas:</b> Naudoja <code>useFormState</code> formos būsenai valdyti ir serverio veiksmui susieti su forma.</li>
	<li> <b><code>state</code>:</b> <code>state</code> iš <code>useFormState</code> dabar saugo grąžinamąją vertę iš serverio veiksmo, kurią galima patikrinti dėl sėkmės ar klaidos pranešimų.</li>
</ul>

<h3>Tarptautiniai aspektai</h3>

<p>Įgyvendinant formas pasaulinei auditorijai, atsiranda keletas tarptautinių aspektų:</p>

<ul>
  <li><b>Lokalizacija:</b> Užtikrinkite, kad jūsų formos etiketės, pranešimai ir klaidų pranešimai būtų lokalizuoti į skirtingas kalbas. Įrankiai, tokie kaip i18next, gali padėti valdyti vertimus.</li>
  <li><b>Datos ir skaičių formatai:</b> Tvarkykite datos ir skaičių formatus pagal vartotojo lokalę. Naudokite bibliotekas, tokias kaip <code>Intl</code> ar <code>moment.js</code> (datos formatavimui, nors dabar laikoma pasenusia), kad teisingai formatuotumėte datas ir skaičius.</li>
  <li><b>Adresų formatai:</b> Skirtingos šalys turi skirtingus adresų formatus. Apsvarstykite galimybę naudoti biblioteką, palaikančią kelis adresų formatus, arba sukurti pasirinktinius formos laukus pagal vartotojo vietą.</li>
  <li><b>Telefono numerio tikrinimas:</b> Tikrinkite telefono numerius pagal tarptautinius standartus. Bibliotekos, tokios kaip <code>libphonenumber-js</code>, gali padėti tai padaryti.</li>
  <li><b>Iš dešinės į kairę (RTL) palaikymas:</b> Užtikrinkite, kad jūsų formos išdėstymas palaikytų RTL kalbas, tokias kaip arabų ar hebrajų. Geresniam RTL palaikymui naudokite CSS logines savybes (pvz., <code>margin-inline-start</code> vietoj <code>margin-left</code>).</li>
  <li><b>Prieinamumas:</b> Laikykitės prieinamumo gairių (WCAG), kad užtikrintumėte, jog jūsų formas galėtų naudoti žmonės su negalia, nepriklausomai nuo jų buvimo vietos.</li>
</ul>

<p><b>Pavyzdys: lokalizuotos formos etiketės</b></p>

```jsx
// i18n/locales/lt.json
{
  "contactForm": {
    "nameLabel": "Vardas",
    "emailLabel": "El. paštas",
    "messageLabel": "Žinutė",
    "submitButton": "Pateikti",
    "successMessage": "Forma sėkmingai pateikta!",
    "errorMessage": "Nepavyko pateikti formos."
  }
}

// i18n/locales/de.json
{
  "contactForm": {
    "nameLabel": "Name",
    "emailLabel": "E-Mail",
    "messageLabel": "Nachricht",
    "submitButton": "Senden",
    "successMessage": "Formular erfolgreich gesendet!",
    "errorMessage": "Fehler beim Senden des Formulars."
  }
}

// app/components/LocalizedContactForm.jsx
'use client'

import { useTranslation } from 'react-i18next';
import { experimental_useFormStatus as useFormStatus } from 'react'
import { submitContactForm } from '../actions'
import { useState } from 'react';

function SubmitButton() {
  const { pending } = useFormStatus()
  const { t } = useTranslation();

return (
    <button type="submit" disabled={pending}>
      {pending ? t('contactForm.submitButton', {ns: 'contactForm'}) : t('contactForm.submitButton', {ns: 'contactForm'})}
    </button>
  )
}

export default function LocalizedContactForm() {
  const { t } = useTranslation();
  const [message, setMessage] = useState(null);

async function handleSubmit(formData) {
    const result = await submitContactForm(formData);
    setMessage(result);
  }

return (
    <div>
      <form action={handleSubmit}>
        <div>
          <label htmlFor="name">{t('contactForm.nameLabel', {ns: 'contactForm'})}:</label>
          <input type="text" id="name" name="name" required />
        </div>
        <div>
          <label htmlFor="email">{t('contactForm.emailLabel', {ns: 'contactForm'})}:</label>
          <input type="email" id="email" name="email" required />
        </div>
        <div>
          <label htmlFor="message">{t('contactForm.messageLabel', {ns: 'contactForm'})}:</label>
          <textarea id="message" name="message" required />
        </div>
        <SubmitButton />
      </form>
      {message && (
        <p className={message.success ? 'success' : 'error'}>
          {message.message}
        </p>
      )}
    </div>
  );
}
```

<p><b>Paaiškinimas:</b></p>

<ul>
  <li><b>Vertimų failai:</b> Pavyzdyje naudojamas <code>react-i18next</code> vertimams valdyti. Atskiri JSON failai turi vertimus skirtingoms kalboms.</li>
  <li><b><code>useTranslation</code> kabliukas:</b> <code>useTranslation</code> kabliukas suteikia prieigą prie vertimo funkcijos (<code>t</code>), kuri naudojama lokalizuotoms eilutėms gauti.</li>
  <li><b>Lokalizuotos etiketės:</b> Formos etiketės ir mygtuko tekstas gaunami naudojant <code>t</code> funkciją, užtikrinant, kad jie būtų rodomi vartotojo pageidaujama kalba.</li>
</ul>

<h3>Prieinamumo aspektai</h3>

<p>Labai svarbu užtikrinti, kad jūsų formos būtų prieinamos visiems vartotojams, įskaitant tuos, kurie turi negalią. Štai keletas pagrindinių prieinamumo aspektų:</p>

<ul>
  <li><b>Semantinis HTML:</b> Teisingai naudokite semantinius HTML elementus, tokius kaip <code><label></code>, <code><input></code>, <code><textarea></code> ir <code><button></code>.</li>
  <li><b>Etiketės:</b> Susiekite etiketes su formos valdikliais naudodami <code>for</code> atributą <code><label></code> elemente ir <code>id</code> atributą formos valdiklyje.</li>
  <li><b>ARIA atributai:</b> Naudokite ARIA atributus, kad suteiktumėte papildomos informacijos pagalbinėms technologijoms. Pavyzdžiui, naudokite <code>aria-describedby</code>, kad susietumėte formos valdiklį su aprašymu.</li>
  <li><b>Klaidų tvarkymas:</b> Aiškiai nurodykite klaidas ir pateikite naudingus klaidų pranešimus. Naudokite ARIA atributus, tokius kaip <code>aria-invalid</code>, kad nurodytumėte neteisingus formos valdiklius.</li>
  <li><b>Navigacija klaviatūra:</b> Užtikrinkite, kad vartotojai galėtų naršyti formą naudodami klaviatūrą. Prireikus naudokite <code>tabindex</code> atributą, kad valdytumėte fokuso tvarką.</li>
  <li><b>Spalvų kontrastas:</b> Užtikrinkite pakankamą spalvų kontrastą tarp teksto ir fono spalvų.</li>
  <li><b>Formos struktūra:</b> Naudokite aiškią ir nuoseklią formos struktūrą. Grupuokite susijusius formos valdiklius naudodami <code><fieldset></code> ir <code><legend></code> elementus.</li>
</ul>

<p><b>Pavyzdys: prieinamas klaidų tvarkymas</b></p>

```jsx
// app/components/AccessibleContactForm.jsx
'use client'

import { experimental_useFormStatus as useFormStatus } from 'react'
import { submitContactForm } from '../actions'
import { useState } from 'react';

function SubmitButton() {
  const { pending } = useFormStatus()

return (
    <button type="submit" disabled={pending}>
      {pending ? 'Pateikiama...' : 'Pateikti'}
    </button>
  )
}

export default function AccessibleContactForm() {
  const [message, setMessage] = useState(null);
  const [errors, setErrors] = useState({});

async function handleSubmit(formData) {
    // Paprastas kliento pusės validavimas
    const newErrors = {};
    if (!formData.get('name')) {
      newErrors.name = 'Vardas yra privalomas.';
    }
    if (!formData.get('email')) {
      newErrors.email = 'El. paštas yra privalomas.';
    }
    if (!formData.get('message')) {
      newErrors.message = 'Žinutė yra privaloma.';
    }

if (Object.keys(newErrors).length > 0) {
      setErrors(newErrors);
      return;
    }

setErrors({}); // Išvalyti ankstesnes klaidas
    const result = await submitContactForm(formData);
    setMessage(result);
  }

return (
    <div>
      <form action={handleSubmit}>
        <div>
          <label htmlFor="name">Vardas:</label>
          <input
            type="text"
            id="name"
            name="name"
            aria-invalid={!!errors.name}
            aria-describedby="name-error"
            required
          />
          {errors.name && (
            <p id="name-error" className="error">
              {errors.name}
            </p>
          )}
        </div>
        <div>
          <label htmlFor="email">El. paštas:</label>
          <input
            type="email"
            id="email"
            name="email"
            aria-invalid={!!errors.email}
            aria-describedby="email-error"
            required
          />
          {errors.email && (
            <p id="email-error" className="error">
              {errors.email}
            </p>
          )}
        </div>
        <div>
          <label htmlFor="message">Žinutė:</label>
          <textarea
            id="message"
            name="message"
            aria-invalid={!!errors.message}
            aria-describedby="message-error"
            required
          />
          {errors.message && (
            <p id="message-error" className="error">
              {errors.message}
            </p>
          )}
        </div>
        <SubmitButton />
      </form>
      {message && (
        <p className={message.success ? 'success' : 'error'}>
          {message.message}
        </p>
      )}
    </div>
  );
}
```

<p><b>Paaiškinimas:</b></p>

<ul>
  <li><b>Klaidų būsena:</b> Komponentas palaiko <code>errors</code> būseną, kad sektų validavimo klaidas.</li>
  <li><b>Kliento pusės validavimas:</b> <code>handleSubmit</code> funkcija atlieka pagrindinį kliento pusės validavimą prieš pateikiant formą.</li>
  <li><b>ARIA atributai:</b> <code>aria-invalid</code> atributas nustatomas į <code>true</code>, jei yra klaida konkrečiam formos valdikliui. <code>aria-describedby</code> atributas susieja formos valdiklį su klaidos pranešimu.</li>
  <li><b>Klaidų pranešimai:</b> Klaidų pranešimai rodomi šalia atitinkamų formos valdiklių.</li>
</ul>

<h2>Galimi iššūkiai ir apribojimai</h2>

<ul>
  <li><b>Eksperimentinis statusas:</b> Kadangi <code>experimental_useFormStatus</code> yra eksperimentinis API, jis gali būti pakeistas ar pašalintas būsimose React versijose. Būtina sekti React dokumentaciją ir būti pasirengus prireikus pritaikyti savo kodą.</li>
  <li><b>Ribota apimtis:</b> Kabliukas pirmiausia skirtas pateikimo būsenai sekti ir nesuteikia išsamių formos valdymo funkcijų, tokių kaip validavimas ar duomenų tvarkymas. Jums vis tiek gali tekti įgyvendinti papildomą logiką šiems aspektams.</li>
  <li><b>Priklausomybė nuo serverio veiksmų:</b> Kabliukas sukurtas veikti su serverio veiksmais, kurie gali netikti visiems naudojimo atvejams. Jei nenaudojate serverio veiksmų, gali tekti ieškoti alternatyvių sprendimų formos būsenai valdyti.</li>
</ul>

<h2>Išvada</h2>

<p><code>experimental_useFormStatus</code> kabliukas siūlo reikšmingą pagerinimą valdant formos pateikimo būsenas React aplinkoje, ypač dirbant su serverio veiksmais ir laipsnišku tobulinimu. Supaprastindamas būsenos valdymą ir pateikdamas aiškų bei glaustą API, jis pagerina tiek programuotojų, tiek vartotojų patirtį. Tačiau, atsižvelgiant į jo eksperimentinį pobūdį, svarbu būti informuotam apie atnaujinimus ir galimus pakeitimus būsimose React versijose. Suprasdami jo privalumus, apribojimus ir geriausias praktikas, galite efektyviai panaudoti <code>experimental_useFormStatus</code>, kad sukurtumėte tvirtesnes ir patogesnes formas savo React programose. Nepamirškite atsižvelgti į internacionalizacijos ir prieinamumo geriausias praktikas, kad sukurtumėte įtraukias formas pasaulinei auditorijai.</p></div><template id="P:4"></template></article></div><script>$RS=function(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("S:2","P:2")</script><div hidden id="S:4"><footer class="mt-12 pt-8 border-t border-gray-200"><h3 class="text-sm font-semibold text-gray-900 mb-3 dark:text-white/90">Tags:</h3><div class="flex flex-wrap gap-2"><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">React</span><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">useFormStatus</span><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">formos būsena</span><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">React formos</span><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">eksperimentinis API</span><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">React kabliukai</span><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">formos pateikimas</span><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">asinchroninės formos</span><span class="inline-block bg-gray-100 text-gray-800 px-3 py-1 rounded-full text-sm hover:bg-gray-200 transition-colors dark:bg-neutral-800 dark:text-white dark:hover:bg-neutral-700">laipsniškas tobulinimas</span></div></footer></div><script>$RS("S:4","P:4")</script><script>$RC("B:1","S:1")</script></body></html>

React experimental_useFormStatus įgyvendinimas: patobulintas formos būsenos valdymas

Kas yra experimental_useFormStatus?

Pagrindinis įgyvendinimas

Būtinosios sąlygos

Pavyzdys: paprasta kontaktų forma

Kas yra `experimental_useFormStatus`?