2. september 2025Norsk

Utforsk Reacts `experimental_useFormStatus`-hook for enklere skjemastatus-håndtering. Lær implementering, fordeler og avansert bruk med eksempler.

Implementering av React experimental_useFormStatus: Forbedret Håndtering av Skjemastatus

Reacts landskap er i stadig utvikling og introduserer kontinuerlig verktøy og teknikker for å forbedre utvikleropplevelsen og applikasjonsytelsen. En slik eksperimentell funksjon er experimental_useFormStatus-hooken, designet for å forenkle håndteringen av skjemastatus, spesielt i scenarioer med server-handlinger og progressiv forbedring. Denne omfattende guiden vil utforske experimental_useFormStatus-hooken i detalj, med praktiske eksempler og innsikt for effektiv bruk.

Hva er `experimental_useFormStatus`?

experimental_useFormStatus-hooken er et eksperimentelt API introdusert av React-teamet for å gi en enklere måte å spore statusen for en skjemainnsending på, spesielt ved bruk av server-handlinger. Før denne hooken krevde håndtering av de ulike tilstandene til et skjema (inaktiv, sender, suksess, feil) ofte kompleks logikk for tilstandshåndtering. experimental_useFormStatus tar sikte på å abstrahere bort mye av denne kompleksiteten, og gir en enkel og effektiv måte å overvåke og reagere på skjemainnsendingstilstander.

Viktige fordeler:

Forenklet tilstandshåndtering: Reduserer standardkoden som trengs for å håndtere tilstander for skjemainnsending.
Forbedret brukeropplevelse: Muliggjør mer responsive UI-oppdateringer basert på skjemaets status.
Forbedret lesbarhet i koden: Gjør skjemarelatert kode enklere å forstå og vedlikeholde.
Sømløs integrasjon med server-handlinger: Designet for å fungere spesielt godt med React Server Components og server-handlinger.

Grunnleggende Implementering

For å illustrere den grunnleggende implementeringen av experimental_useFormStatus, la oss se på et enkelt kontaktskjemaeksempel. Dette skjemaet vil samle inn brukerens navn, e-post og melding, og deretter sende det inn ved hjelp av en server-handling.

Forutsetninger

Før du dykker ned i koden, sørg for at du har et React-prosjekt satt opp med følgende:

React-versjon som støtter de eksperimentelle API-ene (sjekk Reacts dokumentasjon for påkrevd versjon).
React Server Components aktivert (brukes vanligvis i rammeverk som Next.js eller Remix).

Eksempel: Et Enkelt Kontaktskjema

Her er en grunnleggende kontaktskjema-komponent:

```jsx // app/actions.js (Server-handling) 'use server' export async function submitContactForm(formData) { // Simuler et databasekall eller en API-forespørsel 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: 'Alle felt er påkrevd.' }; } try { // Erstatt med et faktisk API-kall eller databaseoperasjon console.log('Skjema sendt:', { name, email, message }); return { success: true, message: 'Skjemaet ble sendt!' }; } catch (error) { console.error('Feil ved innsending av skjema:', error); return { success: false, message: 'Innsending av skjemaet mislyktes.' }; } } // app/components/ContactForm.jsx (Klientkomponent) 'use client' import { experimental_useFormStatus as useFormStatus } from 'react' import { submitContactForm } from '../actions' function SubmitButton() { const { pending } = useFormStatus() return ( ) } export default function ContactForm() { return (

Navn:

E-post:

Melding:

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

<h3>Forklaring</h3>

<ul>
  <li><b>Server-handling (<code>app/actions.js</code>):</b> Denne filen definerer funksjonen <code>submitContactForm</code>, som er en server-handling. Den simulerer en API-forespørsel med 2 sekunders forsinkelse for å demonstrere den asynkrone naturen til skjemainnsending. Den håndterer også grunnleggende validering og feilhåndtering.</li>
  <li><b>Klientkomponent (<code>app/components/ContactForm.jsx</code>):</b> Denne filen definerer <code>ContactForm</code>-komponenten, som er en klientkomponent. Den importerer <code>experimental_useFormStatus</code>-hooken og <code>submitContactForm</code>-handlingen.</li>
  <li><b>Bruk av <code>useFormStatus</code>:</b> Inne i <code>SubmitButton</code>-komponenten kalles <code>useFormStatus</code>. Denne hooken gir informasjon om skjemaets innsendingsstatus.</li>
  <li><b><code>pending</code>-egenskapen:</b> <code>pending</code>-egenskapen som returneres av <code>useFormStatus</code>, indikerer om skjemaet for øyeblikket sendes inn. Den brukes til å deaktivere send-knappen og vise en "Sender..."-melding.</li>
  <li><b>Skjemabinding:</b> <code>form</code>-elementets <code>action</code>-prop er bundet til server-handlingen <code>submitContactForm</code>. Dette forteller React at den skal påkalle server-handlingen når skjemaet sendes inn.</li>
</ul>

<h2>Avansert Bruk og Vurderinger</h2>

<h3>Håndtering av Suksess- og Feiltilstander</h3>

<p>Selv om <code>experimental_useFormStatus</code> forenkler sporing av innsendingsstatus, må du ofte håndtere suksess- og feiltilstander eksplisitt. Server-handlinger kan returnere data som indikerer suksess eller feil, som du deretter kan bruke til å oppdatere brukergrensesnittet tilsvarende.</p>

<p><b>Eksempel:</b></p>

```jsx
// app/components/ContactForm.jsx (Modifisert)
'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 ? 'Sender...' : 'Send inn'}
    </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">Navn:</label>
          <input type="text" id="name" name="name" required />
        </div>
        <div>
          <label htmlFor="email">E-post:</label>
          <input type="email" id="email" name="email" required />
        </div>
        <div>
          <label htmlFor="message">Melding:</label>
          <textarea id="message" name="message" required />
        </div>
        <SubmitButton />
      </form>
      {message && (
        <p className={message.success ? 'success' : 'error'}>
          {message.message}
        </p>
      )}
    </div>
  );
}
```

<p><b>Forklaring:</b></p>

<ul>
  <li><b>Tilstand for meldinger:</b> En <code>message</code>-tilstandsvariabel er introdusert for å lagre resultatet som returneres av server-handlingen.</li>
  <li><b>Håndtering av resultatet:</b> Etter at skjemaet er sendt, oppdaterer <code>handleSubmit</code>-funksjonen <code>message</code>-tilstanden med resultatet fra server-handlingen.</li>
  <li><b>Visning av meldinger:</b> Komponenten viser meldingen basert på <code>success</code>-egenskapen til resultatet, og bruker forskjellige CSS-klasser for suksess- og feiltilstander.</li>
</ul>

<h3>Progressiv Forbedring</h3>

<p><code>experimental_useFormStatus</code> utmerker seg i scenarioer med progressiv forbedring. Ved å progressivt forbedre et standard HTML-skjema med React, kan du gi en bedre brukeropplevelse uten å ofre grunnleggende funksjonalitet hvis JavaScript svikter.</p>

<p><b>Eksempel:</b></p>

<p>Vi starter med et grunnleggende HTML-skjema:</p>

```html

<form action="/submit-contact" method="post">
  <div>
    <label for="name">Navn:</label>
    <input type="text" id="name" name="name" required />
  </div>
  <div>
    <label for="email">E-post:</label>
    <input type="email" id="email" name="email" required />
  </div>
  <div>
    <label for="message">Melding:</label>
    <textarea id="message" name="message" required>

```

Du kan deretter progressivt forbedre det med React og 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); // Bruk null som initiell tilstand hvis du ikke er avhengig av den return (

Navn:

E-post:

Melding:

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

<p><b>Forklaring:</b></p>

<ul>
  <li><b>Initiell HTML-skjema:</b> Filen <code>public/contact.html</code> inneholder et standard HTML-skjema som vil fungere selv uten JavaScript.</li>
  <li><b>Progressiv forbedring:</b> Komponenten <code>EnhancedContactForm</code> forbedrer HTML-skjemaet progressivt. Hvis JavaScript er aktivert, tar React over og gir en rikere brukeropplevelse.</li>
  <li><b><code>useFormState</code>-hooken:</b> Bruker <code>useFormState</code> for å håndtere skjematilstand og binde server-handlingen til skjemaet.</li>
  <li><b><code>state</code>:</b> <code>state</code> fra <code>useFormState</code> inneholder nå returverdien fra server-handlingen, som kan sjekkes for suksess- eller feilmeldinger.</li>
</ul>

<h3>Internasjonale Hensyn</h3>

<p>Når du implementerer skjemaer for et globalt publikum, er det flere internasjonale hensyn å ta:</p>

<ul>
  <li><b>Lokalisering:</b> Sørg for at skjemaetiketter, meldinger og feilmeldinger er lokalisert til forskjellige språk. Verktøy som i18next kan hjelpe med å håndtere oversettelser.</li>
  <li><b>Dato- og tallformater:</b> Håndter dato- og tallformater i henhold til brukerens locale. Bruk biblioteker som <code>Intl</code> eller <code>moment.js</code> (for datoformatering, selv om det nå anses som utdatert) for å formatere datoer og tall korrekt.</li>
  <li><b>Adresseformater:</b> Forskjellige land har forskjellige adresseformater. Vurder å bruke et bibliotek som støtter flere adresseformater eller å lage tilpassede skjemafelt basert på brukerens plassering.</li>
  <li><b>Validering av telefonnummer:</b> Valider telefonnumre i henhold til internasjonale standarder. Biblioteker som <code>libphonenumber-js</code> kan hjelpe med dette.</li>
  <li><b>Støtte for høyre-til-venstre (RTL):</b> Sørg for at skjemaoppsettet ditt støtter RTL-språk som arabisk eller hebraisk. Bruk logiske CSS-egenskaper (f.eks. <code>margin-inline-start</code> i stedet for <code>margin-left</code>) for bedre RTL-støtte.</li>
  <li><b>Tilgjengelighet:</b> Følg retningslinjer for tilgjengelighet (WCAG) for å sikre at skjemaene dine er brukbare for personer med nedsatt funksjonsevne, uavhengig av deres plassering.</li>
</ul>

<p><b>Eksempel: Lokaliserte Skjemaetiketter</b></p>

```jsx
// i18n/locales/en.json
{
  "contactForm": {
    "nameLabel": "Navn",
    "emailLabel": "E-post",
    "messageLabel": "Melding",
    "submitButton": "Send inn",
    "successMessage": "Skjemaet ble sendt!",
    "errorMessage": "Innsending av skjemaet mislyktes."
  }
}

// i18n/locales/fr.json
{
  "contactForm": {
    "nameLabel": "Navn",
    "emailLabel": "E-post",
    "messageLabel": "Melding",
    "submitButton": "Send inn",
    "successMessage": "Skjemaet ble sendt!",
    "errorMessage": "Innsending av skjemaet mislyktes."
  }
}

// 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>Forklaring:</b></p>

<ul>
  <li><b>Oversettelsesfiler:</b> Eksemplet bruker <code>react-i18next</code> for å håndtere oversettelser. Separate JSON-filer inneholder oversettelser for forskjellige språk.</li>
  <li><b><code>useTranslation</code>-hooken:</b> <code>useTranslation</code>-hooken gir tilgang til oversettelsesfunksjonen (<code>t</code>), som brukes til å hente lokaliserte strenger.</li>
  <li><b>Lokaliserte etiketter:</b> Skjemaetikettene og knappeteksten hentes ved hjelp av <code>t</code>-funksjonen, noe som sikrer at de vises på brukerens foretrukne språk.</li>
</ul>

<h3>Tilgjengelighetshensyn</h3>

<p>Det er avgjørende å sikre at skjemaene dine er tilgjengelige for alle brukere, inkludert de med nedsatt funksjonsevne. Her er noen sentrale tilgjengelighetshensyn:</p>

<ul>
  <li><b>Semantisk HTML:</b> Bruk semantiske HTML-elementer som <code><label></code>, <code><input></code>, <code><textarea></code> og <code><button></code> korrekt.</li>
  <li><b>Etiketter:</b> Knytt etiketter til skjemakontroller ved å bruke <code>for</code>-attributtet på <code><label></code> og <code>id</code>-attributtet på skjemakontrollen.</li>
  <li><b>ARIA-attributter:</b> Bruk ARIA-attributter for å gi tilleggsinformasjon til hjelpeteknologier. Bruk for eksempel <code>aria-describedby</code> for å koble en skjemakontroll til en beskrivelse.</li>
  <li><b>Feilhåndtering:</b> Indiker feil tydelig og gi nyttige feilmeldinger. Bruk ARIA-attributter som <code>aria-invalid</code> for å indikere ugyldige skjemakontroller.</li>
  <li><b>Tastaturnavigasjon:</b> Sørg for at brukere kan navigere i skjemaet ved hjelp av tastaturet. Bruk <code>tabindex</code>-attributtet for å kontrollere fokusrekkefølgen om nødvendig.</li>
  <li><b>Fargekontrast:</b> Sørg for tilstrekkelig fargekontrast mellom tekst og bakgrunnsfarger.</li>
  <li><b>Skjemastruktur:</b> Bruk en klar og konsekvent skjemastruktur. Grupper relaterte skjemakontroller ved hjelp av <code><fieldset></code>- og <code><legend></code>-elementer.</li>
</ul>

<p><b>Eksempel: Tilgjengelig Feilhåndtering</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 ? 'Sender...' : 'Send inn'}
    </button>
  )
}

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

async function handleSubmit(formData) {
    // Grunnleggende klient-side-validering
    const newErrors = {};
    if (!formData.get('name')) {
      newErrors.name = 'Navn er påkrevd.';
    }
    if (!formData.get('email')) {
      newErrors.email = 'E-post er påkrevd.';
    }
    if (!formData.get('message')) {
      newErrors.message = 'Melding er påkrevd.';
    }

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

setErrors({}); // Fjern tidligere feil
    const result = await submitContactForm(formData);
    setMessage(result);
  }

return (
    <div>
      <form action={handleSubmit}>
        <div>
          <label htmlFor="name">Navn:</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">E-post:</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">Melding:</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>Forklaring:</b></p>

<ul>
  <li><b>Feiltilstand:</b> Komponenten opprettholder en <code>errors</code>-tilstand for å spore valideringsfeil.</li>
  <li><b>Klient-side-validering:</b> <code>handleSubmit</code>-funksjonen utfører grunnleggende klient-side-validering før skjemaet sendes inn.</li>
  <li><b>ARIA-attributter:</b> <code>aria-invalid</code>-attributtet settes til <code>true</code> hvis det er en feil for en spesifikk skjemakontroll. <code>aria-describedby</code>-attributtet kobler skjemakontrollen til feilmeldingen.</li>
  <li><b>Feilmeldinger:</b> Feilmeldinger vises ved siden av de tilsvarende skjemakontrollene.</li>
</ul>

<h2>Potensielle Utfordringer og Begrensninger</h2>

<ul>
  <li><b>Eksperimentell status:</b> Siden det er et eksperimentelt API, kan <code>experimental_useFormStatus</code> endres eller fjernes i fremtidige React-versjoner. Det er viktig å holde seg oppdatert med Reacts dokumentasjon og være forberedt på å tilpasse koden din om nødvendig.</li>
  <li><b>Begrenset omfang:</b> Hooken fokuserer primært på å spore innsendingsstatus og gir ikke omfattende funksjoner for skjemahåndtering som validering eller datahåndtering. Du må kanskje fortsatt implementere ekstra logikk for disse aspektene.</li>
  <li><b>Avhengighet av server-handlinger:</b> Hooken er designet for å fungere med server-handlinger, noe som kanskje ikke passer for alle bruksområder. Hvis du ikke bruker server-handlinger, må du kanskje finne alternative løsninger for å håndtere skjemastatus.</li>
</ul>

<h2>Konklusjon</h2>

<p><code>experimental_useFormStatus</code>-hooken tilbyr en betydelig forbedring i håndteringen av skjemainnsendingstilstander i React, spesielt når man jobber med server-handlinger og progressiv forbedring. Ved å forenkle tilstandshåndtering og tilby et klart og konsist API, forbedrer den både utvikler- og brukeropplevelsen. Gitt dens eksperimentelle natur er det imidlertid avgjørende å holde seg informert om oppdateringer og potensielle endringer i fremtidige React-versjoner. Ved å forstå dens fordeler, begrensninger og beste praksis, kan du effektivt utnytte <code>experimental_useFormStatus</code> til å bygge mer robuste og brukervennlige skjemaer i dine React-applikasjoner. Husk å vurdere internasjonalisering og beste praksis for tilgjengelighet for å skape inkluderende skjemaer for et globalt publikum.</p></div><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">skjemastatus</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-skjemaer</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">eksperimentelt 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 hooks</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">skjemainnsending</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">asynkrone skjemaer</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">progressiv forbedring</span></div></footer></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><script>$RC("B:1","S:1")</script></body></html>

Implementering av React experimental_useFormStatus: Forbedret Håndtering av Skjemastatus

Hva er experimental_useFormStatus?

Grunnleggende Implementering

Forutsetninger

Eksempel: Et Enkelt Kontaktskjema

Hva er `experimental_useFormStatus`?