Next.js 15 Fullstack Web Apps · Aula

Componentes Controlados e Estado

Gerencie valores de entrada de formulários usando o padrão de componentes controlados do React para obter um comportamento previsível.

Aula 1 de 411 etapas

Componentes Controlados e Estado é uma aula grátis de Next.js 15 Fullstack Web Apps no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Next.js 15 Fullstack Web Apps, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Next.js 15 Fullstack Web Apps inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Forms: User Interaction Hub

Forms are essential for almost any web application! They allow users to input information, make choices, and interact with your app.

Think about login screens, search bars, feedback forms, or even shopping cart quantity selectors – all rely on forms.

Uncontrolled Inputs: A Quick Look

In plain HTML, input elements manage their own state. When you type into an <input>, its value updates internally.

In React, these are called uncontrolled components. While simple for static forms, they can be tricky to integrate with React's dynamic UI updates and state management.

Meet Controlled Components

Controlled components are input elements whose values are controlled by React state. Instead of the DOM managing the input's value, your React component's state becomes the 'single source of truth'.

This gives you full control over the form data, making it predictable and easier to manage.

The Core: `value` & `onChange`

Two props are key to controlled components:

value: Sets the current displayed value of the input. It should always come from your component's state.
onChange: A function that gets called whenever the input's value changes (e.g., user types). This function updates your component's state.

Controlled Text Input in Action

Let's see a basic controlled text input. We use useState to hold the input's value and update it with onChange.

Try typing in the input below:

import React, { useState } from 'react';

function App() {
  const [name, setName] = useState('');

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

  return (
    <div>
      <label>Your Name:</label>
      <input
        type="text"
        value={name}
        onChange={handleChange}
      />
      <p>Hello, {name || 'stranger'}!</p>
    </div>
  );
}

State is the Single Source of Truth

Here's the flow for a controlled input:

The input's value prop is set by React state (e.g., name).
User types a character.
The onChange event fires, calling handleChange.
handleChange updates the state (setName).
React re-renders the component.
The input's value prop is now updated with the new state, displaying the typed character.

Other Controlled Elements

The same value and onChange pattern applies to other form elements like <textarea> and <select>.

For <select>, the value prop is set on the <select> tag itself, not on individual <option> tags.

import React, { useState } from 'react';

function App() {
  const [feedback, setFeedback] = useState('');
  const [fruit, setFruit] = useState('apple');

  return (
    <div>
      <label>Your Feedback:</label>
      <textarea
        value={feedback}
        onChange={(e) => setFeedback(e.target.value)}
        rows="3"
      />
      <p>Feedback: {feedback}</p>

      <label>Favorite Fruit:</label>
      <select
        value={fruit}
        onChange={(e) => setFruit(e.target.value)}
      >
        <option value="apple">Apple</option>
        <option value="banana">Banana</option>
        <option value="orange">Orange</option>
      </select>
      <p>Selected: {fruit}</p>
    </div>
  );
}

Why Control Matters

Controlling your form inputs provides many benefits:

Instant Validation: Validate input as the user types.
Conditional Logic: Enable/disable buttons based on input state.
Formatted Input: Automatically format phone numbers or currencies.
Easy State Access: Always know the current value of any input.
Predictable Behavior: Your UI always reflects your application's state.

Managing Many Inputs

For forms with multiple inputs, you can use a single state object and a generic onChange handler. The name attribute of the input helps identify which state property to update.

import React, { useState } from 'react';

function App() {
  const [formData, setFormData] = useState({
    username: '',
    email: ''
  });

  const handleChange = (event) => {
    const { name, value } = event.target;
    setFormData(prevData => ({ ...prevData, [name]: value }));
  };

  return (
    <form>
      <label>Username:</label>
      <input
        type="text"
        name="username"
        value={formData.username}
        onChange={handleChange}
      />
      <label>Email:</label>
      <input
        type="email"
        name="email"
        value={formData.email}
        onChange={handleChange}
      />
      <p>User: {formData.username}, Email: {formData.email}</p>
    </form>
  );
}

Controlled Input Challenge

Which of the following are key characteristics of a controlled component in React?

Responda na aula interativa

Recap: Controlled & Predictable

You've learned about controlled components!

They link input values directly to React state.
They use the value prop for display and an onChange handler to update state.
This pattern provides full control, enabling features like instant validation and predictable behavior.
It applies to <input>, <textarea>, and <select> elements.

Mastering controlled components is a crucial step for building robust forms in Next.js applications!

Grátis para começar

Aprenda TypeScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 12
Aulas: 48

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Componentes Controlados e Estado” é grátis?

Sim — o texto completo de “Componentes Controlados e Estado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Next.js 15 Fullstack Web Apps, atualize para CoddyKit PRO. O curso de Next.js 15 Fullstack Web Apps inclui 4 aulas no total.

O que vou aprender em “Componentes Controlados e Estado”?

Gerencie valores de entrada de formulários usando o padrão de componentes controlados do React para obter um comportamento previsível. Você pratica Next.js 15 Fullstack Web Apps com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Next.js 15 Fullstack Web Apps?

Nenhuma experiência prévia é necessária. Next.js 15 Fullstack Web Apps no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Componentes Controlados e Estado”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Next.js 15 Fullstack Web Apps?

Sim. Cada aula de Next.js 15 Fullstack Web Apps inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Componentes Controlados e Estado
Validação de Formulários com React Hook Form
Formulários Fullstack com Ações de Servidor
Envio de arquivos e tratamento de formulários multipart

← Voltar para Next.js 15 Fullstack Web Apps