Efter år av att förlita sig på tredjepartsbundlar, kämpa med session lagring och skriva komplicerad controller logik för att hantera "guider", har Symfony 7.4 levererat en av de mest efterfrågade funktionerna i ramens historia: . Native Multi-Step Forms Om du har arbetat med Symfony i ett decennium, som jag har, vet du kampen. Du behöver en registreringsguide, en komplex checkoutprocess eller en flerstegsundersökning. Du hade två val: hackad-tillsammans kontroller logik med manuella valideringsgrupper eller den legendariska Medan Craue tjänade oss väl, var det alltid ett externt beroende som kände sig något avkopplat från kärnformkomponentens filosofi. CraueFormFlowBundle Med utgivningen av Symfony 7.4 i november 2025 har Core Team introducerat Form Flows. Detta är inte bara en hjälpklass, det är ett komplett paradigmskifte som behandlar ett flöde i flera steg som en första klassens medborgare, fullt integrerad med Validator och Form-komponenterna. I den här artikeln kommer vi att bygga en produktionsbered användarens Onboarding Wizard med hjälp av Symfony 7.4.Vi kommer att täcka allt från installation till avancerad statthantering, med hjälp av endast de inbyggda bibliotek som tillhandahålls av ramverket. Utvecklingen av former i Symfoni 7.4 Innan vi skriver kod, låt oss förstå varför denna uppdatering spelar roll. I tidigare versioner var ett formulär en enskild enhet av arbete. Du skickade in det, validerade det och sköljde det. För att bryta upp detta var utvecklarna tvungna att artificiellt skära datamodellen och manuellt hantera tillståndet mellan förfrågningar. och och manuellt spara framsteg till sessionen. step 1 step 2, step 3 Symfony 7.4 introducerar Tänk på detta som en ” Den hanterar hela processens livscykel, hanterar navigering (Nästa, Föregående, Hoppa), valideringsgrupper och datapersistens automatiskt. AbstractFlowType Form of Forms Företagsanvändare onboarding Vi bygger en onboarding-guide för en SaaS-plattform. Den består av tre separata steg: 
 
 
 
 Identitet: Grundläggande användarinformation (Email, lösenord) Profil: Professionell information (Job titel, företag) Plan: Val av prenumeration (Free, Pro, Enterprise) Vi kommer att använda en Detta är en bästa praxis i modern Symfony-utveckling, undviker "Anemic Domain Model" -problemet där enheter är förvirrade med tillfälliga formulärdata. Data Transfer Object (DTO) Dataöverföringsobjektet (DTO) DTO fungerar som ryggraden i vårt flöde. Observera användningen av attribut för validering. I Symfony 7.4 använder formulärflödeskomponenten automatiskt Detta är en spelförändrare; vi behöver inte längre komplexa och stängningar. current step name as the validation group validation_groups //src/Form/Dto/UserOnboarding.php
namespace App\Form\Dto;

use Symfony\Component\Validator\Constraints as Assert;

class UserOnboarding
{
    // We need a property to track the current step.
    // The flow component will read/write to this.
    public string $currentStep = 'identity';

    // -- Step 1: Identity --
    
    #[Assert\NotBlank(groups: ['identity'])]
    #[Assert\Email(groups: ['identity'])]
    public ?string $email = null;

    #[Assert\NotBlank(groups: ['identity'])]
    #[Assert\PasswordStrength(minScore: 2, groups: ['identity'])]
    public ?string $password = null;

    // -- Step 2: Profile --

    #[Assert\NotBlank(groups: ['profile'])]
    #[Assert\Length(min: 2, groups: ['profile'])]
    public ?string $fullName = null;

    #[Assert\NotBlank(groups: ['profile'])]
    public ?string $jobTitle = null;

    #[Assert\IsTrue(message: "You must agree to terms.", groups: ['profile'])]
    public bool $termsAccepted = false;

    // -- Step 3: Plan --

    #[Assert\NotBlank(groups: ['plan'])]
    #[Assert\Choice(choices: ['free', 'pro', 'enterprise'], groups: ['plan'])]
    public string $plan = 'free';
}
 Notera och Dessa motsvarar exakt stegsnamnen som vi kommer att definiera senare. groups: [‘identity’] groups: [‘profile’] Att bygga steg former Vi behöver en standard Dessa är standard Symfoniformulär; det finns inget "speciellt" om dem, vilket gör dem återanvändbara. AbstractType Identity Step //src/Form/Step/IdentityStepType.php
namespace App\Form\Step;

use App\Form\Dto\UserOnboarding;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\EmailType;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class IdentityStepType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('email', EmailType::class, [
                'label' => 'Work Email',
                'attr' => ['placeholder' => 'you@company.com']
            ])
            ->add('password', PasswordType::class, [
                'label' => 'Choose a Password',
                'always_empty' => false,
            ]);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'data_class' => UserOnboarding::class,
            // We do NOT set validation_groups here. The Flow handles it.
        ]);
    }
}
 Profile Step //src/Form/Step/ProfileStepType.php

namespace App\Form\Step;

use App\Form\Dto\UserOnboarding;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class ProfileStepType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('fullName', TextType::class, ['label' => 'Full Name'])
            ->add('jobTitle', TextType::class, ['label' => 'Job Title'])
            ->add('termsAccepted', CheckboxType::class, [
                'label' => 'I agree to the Terms of Service',
                'required' => false, // Handled by validator
            ]);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'data_class' => UserOnboarding::class,
        ]);
    }
}
 Plan Step //src/Form/Step/PlanStepType.php

namespace App\Form\Step;

use App\Form\Dto\UserOnboarding;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class PlanStepType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('plan', ChoiceType::class, [
                'choices' => [
                    'Free Tier' => 'free',
                    'Pro ($29/mo)' => 'pro',
                    'Enterprise' => 'enterprise',
                ],
                'expanded' => true, // Radio buttons
                'label' => 'Select your plan'
            ]);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'data_class' => UserOnboarding::class,
        ]);
    }
}
 Typ av flöde (The Magic) Det är här Symfony 7.4 lyser. Vi utökar Vi använder också den nya . AbstractType AbstractFlowType FormFlowBuilderInterface //src/Form/Flow/UserOnboardingFlowType.php
namespace App\Form\Flow;

use App\Form\Dto\UserOnboarding;
use App\Form\Step\IdentityStepType;
use App\Form\Step\PlanStepType;
use App\Form\Step\ProfileStepType;
use Symfony\Component\Form\Flow\AbstractFlowType;
use Symfony\Component\Form\Flow\FormFlowBuilderInterface;
use Symfony\Component\Form\Flow\Type\NavigatorFlowType;
use Symfony\Component\OptionsResolver\OptionsResolver;

class UserOnboardingFlowType extends AbstractFlowType
{
    public function buildFormFlow(FormFlowBuilderInterface $builder, array $options): void
    {
        // 1. Add Steps
        // The first argument is the step name (used for validation groups)
        $builder->addStep('identity', IdentityStepType::class);
        $builder->addStep('profile', ProfileStepType::class);
        $builder->addStep('plan', PlanStepType::class);

        // 2. Add Navigation
        // The NavigatorFlowType automatically adds Next, Previous and Finish buttons
        $builder->add('navigator', NavigatorFlowType::class);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'data_class' => UserOnboarding::class,
            // Crucial: Tell Symfony which property holds the current step name
            'step_property_path' => 'currentStep',
        ]);
    }
}
 den är en ny sammansatt typ i Symfony 7.4. Den abstraherar bort knapparna. Som standard återger den: NavigatorFlowType 
 
 
 
  (on all steps except the last) Next Föregående (på alla steg utom den första) Finish (på det sista steget) Du kan anpassa detta! Till exempel om du vill tillåta att hoppa över ett steg: $builder->add('navigator', NavigatorFlowType::class, [
    'buttons' => [
        'next' => ['label' => 'Continue'],
        'finish' => ['label' => 'Complete Setup'],
    ]
]);
 Den kontrollerande Gone är dagarna för manuell kontroll av $step-frågeparametrar eller sessionsknappar. //src/Controller/OnboardingController.php
namespace App\Controller;

use App\Form\Dto\UserOnboarding;
use App\Form\Flow\UserOnboardingFlowType;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class OnboardingController extends AbstractController
{
    #[Route('/onboarding', name: 'app_onboarding')]
    public function __invoke(Request $request): Response
    {
        // 1. Initialize your DTO
        $dto = new UserOnboarding();
        
        // 2. Create the Flow Form
        // This inspects the Request and automatically determines the current step
        $flow = $this->createForm(UserOnboardingFlowType::class, $dto);
        
        $flow->handleRequest($request);

        // 3. Check for completion
        // isFinished() checks if the 'finish' button was clicked AND the final step is valid
        if ($flow->isSubmitted() && $flow->isValid() && $flow->isFinished()) {
            
            // At this point, $dto is fully populated and validated across ALL steps
            $this->saveUser($dto);

            return $this->redirectToRoute('app_dashboard');
        }

        // 4. Render the specific step
        // do NOT use createView(). Use getStepForm() to get the view for the current step.
        return $this->render('onboarding/flow.html.twig', [
            'form' => $flow->getStepForm(),
        ]);
    }

    private function saveUser(UserOnboarding $dto): void
    {
        // Logic to persist User entity, create Stripe customer, etc.
        // dd($dto);
    }
}
 Som standard, den är statlös i den meningen att den är beroende av de data som Men för ett bättre liv, . Wait, where is the Session? AbstractFlowType POSTed back and forth Symfony 7.4 automatically integrates with the standard HTTP Session if your DTO is serializable Om du har att göra med enheter som inte lätt kan serialiseras kanske du vill använda en datatransformator eller förlita dig på För att hålla poängen giltig. step_property_path Templet är Det här är där gummit möter vägen.Vi behöver återge formuläret. Den variabla formen som överförs till mallen är den aktuella stegens formulärvy. {% extends 'base.html.twig' %}

{% block title %}Onboarding Step: {{ form.vars.name|capitalize }}{% endblock %}

{% block body %}
<div class="container mx-auto max-w-lg mt-10">
    <h1 class="text-2xl font-bold mb-5">Welcome Aboard</h1>
    
    {# Progress Indicator (Optional) #}
    <div class="mb-6 flex justify-between text-sm text-gray-500">
        <span class="{{ form.vars.name == 'identity' ? 'font-bold text-blue-600' : '' }}">Identity</span>
        <span>&rarr;</span>
        <span class="{{ form.vars.name == 'profile' ? 'font-bold text-blue-600' : '' }}">Profile</span>
        <span>&rarr;</span>
        <span class="{{ form.vars.name == 'plan' ? 'font-bold text-blue-600' : '' }}">Plan</span>
    </div>

    {{ form_start(form) }}
        
        {# Render errors for the whole form #}
        {{ form_errors(form) }}

        {# Render the fields for the CURRENT step #}
        {# The 'navigator' field is technically a nested form containing buttons #}
        
        <div class="bg-white shadow-md rounded px-8 pt-6 pb-8 mb-4">
            {% for child in form %}
                {% if child.vars.name != 'navigator' %}
                    {{ form_row(child, {'attr': {'class': 'mb-4'}}) }}
                {% endif %}
            {% endfor %}
        </div>

        {# Render Navigation Buttons #}
        <div class="flex justify-between items-center">
            {# The navigator contains 'previous', 'next', 'finish' depending on the step #}
            {{ form_widget(form.navigator) }}
        </div>

    {{ form_end(form) }}
</div>
{% endblock %}
 den fältet återges vanligtvis som en grupp knappar. Du kanske vill anpassa Skapa ett anpassat formulärtema om du vill ha specifika klasser (till exempel Tailwind-verktygsklasser) på knapparna Föregående vs Nästa. navigator NavigatorFlowType För att styla knapparna specifikt utan ett tema kan du komma åt dem direkt om du vet att de finns: <div class="flex justify-between">
    {% if form.navigator.previous is defined %}
        {{ form_widget(form.navigator.previous, {'attr': {'class': 'btn-secondary'}}) }}
    {% endif %}
    
    {% if form.navigator.next is defined %}
        {{ form_widget(form.navigator.next, {'attr': {'class': 'btn-primary'}}) }}
    {% endif %}
    
    {% if form.navigator.finish is defined %}
        {{ form_widget(form.navigator.finish, {'attr': {'class': 'btn-success'}}) }}
    {% endif %}
</div>
 Avancerad: Villkorliga steg Tänk om vi vill steg om användaren anger en företags e-postadress? skip the “Profile” i Vi kan använda den alternativ på stegdefinitionen. dock, i Symfony 7.4 är robust. UserOnboardingFlowType include_if addStep Ett gemensamt mönster är att kontrollera data i ? Nej, buildFormFlow byggs en gång. Istället kan vi använda   , eller helt enkelt logik inom handkontrollen. Men det renaste sättet i 7.4 är att använda i addStep-metoden, som accepterar en stängning. buildFormFlow EventListeners inside the Flow skip option Från och med den första 7.4-utgåvan hanteras den dynamiska hopplogiken ofta bäst av logiskt eller genom att lyssna på ändra egenskapen currentStep manuellt om det behövs. Metoden stöder a kan användas i vissa implementeringar. NavigatorFlowType FormEvents::POST_SUBMIT addStep condition Låt oss kontrollera standardmetoden för villkorlig logik. Den vanliga implementeringen av Symfony 7.4 rekommenderar att du använder övergångslogiken. Om du behöver mycket dynamiska flöden (som en "Välj ditt eget äventyr"), kan du överrätta logik, men för enkel hoppa över, kan vi helt enkelt standardfält för att återställas och dölja dem. getStepForm Men ett mer robust sätt som den nya komponenten ger är att använda . Transition System den beräknar nästa steg baserat på arrayordningen. Om du behöver hoppa kan du ändra dataobjektets i a lyssnare av den . NavigatorFlowType currentStep POST_SUBMIT IdentityStepType // In IdentityStepType
$builder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) {
    $data = $event->getData();
    $form = $event->getForm();
    
    if (str_ends_with($data->email, '@corp.com')) {
        // This requires the parent flow to recognize the jump, 
        // usually handled by the navigator looking at the set step.
        // For simple implementations, just ensure your validation groups 
        // don't block empty fields in the skipped step.
    }
});
 Det enklaste sättet i 7.4 är att helt enkelt tillåta användaren att klicka på "Nästa" och se till att de bakre valideringsgrupperna för det hoppade steget inte utlöses. Varför detta är bättre än CraueFormFlowBundle. 
 
 
 
 
 Native Integration: Inga fler strider med buntens session lagringsdrivrutin. Den använder standardformulärdata mappers. Attribut för validering: Mappning av stegnamn -> valideringsgrupp minskar boilerplate-konfigurationen med 50%. Typ Säkerhet: Allt är starkt skrivit. AbstractFlowType säkerställer att du följer avtalet. Twig Simplicity: Ingen mer flow.currentStepNumber logik i Twig. Du bara återge den form du ges. Fungerar det då? För att säkerställa att din implementering är robust följer du dessa verifieringssteg: 
 
 
 
 
 Steg Isoleringstest: Fyll i Steg 1, klicka på Nästa. Ladda sidan. Du bör fortfarande vara på Steg 2 (om session persistens är aktiv) eller kunna hantera den statlösa naturen. Validation Gate: Försök att klicka på "Nästa" på steg 1 med en tom e-post. Gruppisolering: Lägg till ett krav i steg 2. Försök att skicka steg 1. Slutförande: Avsluta flödet. Kontrollera din databas eller dump DTO i handkontrollen. Se till att data från steg 1 (E-post) kvarstår tills den slutliga inlämningen. slutsatser Symfony 7.4-funktionen Multi-Step Forms är ett stort steg framåt för Developer Experience (DX). Den tar ett komplext, återkommande problem och löser det med den elegans vi har kommit att förvänta oss av Symfony Core Team. Genom att utnyttja Den naturliga synergin med Komponent, kan du ta bort hundratals rader spagetti kod från dina kontroller. AbstractFlowType Validator Att bygga komplexa trollkarlar är inte längre en uppgift – det är en standard, njutbar del av Symfony-ekosystemet. Planerar du att återskapa dina legacy wizards till Symfony 7.4? Låt oss komma i kontakt på LinkedIn: . https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Read My Stories

Det här ljudet är producerat på berättelsens originalspråk!

Symfony 7.4: Hur man behärskar flerstegsformulär

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps