Symfony2: come ottenere errori di convalida del modulo dopo aver associato la richiesta al modulo


110

Ecco il mio saveActioncodice (a cui il modulo passa i dati)

public function saveAction()
{
    $user = OBUser();

    $form = $this->createForm(new OBUserType(), $user);

    if ($this->request->getMethod() == 'POST')
    {
        $form->bindRequest($this->request);
        if ($form->isValid())
            return $this->redirect($this->generateUrl('success_page'));
        else
            return $this->redirect($this->generateUrl('registration_form'));
    } else
        return new Response();
}

La mia domanda è: come ottengo gli errori in caso di $form->isValid()reso false?

Risposte:


117

Hai due possibili modi per farlo:

  • non reindirizzare l'utente in caso di errore e visualizzarlo {{ form_errors(form) }}all'interno del file modello
  • accedere all'array degli errori come $form->getErrors()

22
Ho fatto la seconda cosa che hai suggerito ma form-> getErrors () restituisce un array vuoto.
putolaruan

2
Ho fatto anche il primo (con modelli php <? Php echo $ view ['form'] -> errors ($ form)?>) Ma è ancora vuoto!
putolaruan

59
@mives È necessario impostare error_bubblingsu true nel tipo di modulo impostando esplicitamente l'opzione per ogni campo.
kgilden

5
Se stai usando validatori personalizzati, Symfony non restituisce gli errori generati da quei validatori in $ form-> getErrors ().
Jay Sheth

13
Puoi anche $form->getErrors(true)includere errori di moduli figlio
Chris

103

Symfony 2.3 / 2.4:

Questa funzione ottiene tutti gli errori. Quelli nel modulo come "Il token CSRF non è valido. Prova a inviare nuovamente il modulo." così come errori aggiuntivi sui figli del modulo che non hanno errori di bubbling.

private function getErrorMessages(\Symfony\Component\Form\Form $form) {
    $errors = array();

    foreach ($form->getErrors() as $key => $error) {
        if ($form->isRoot()) {
            $errors['#'][] = $error->getMessage();
        } else {
            $errors[] = $error->getMessage();
        }
    }

    foreach ($form->all() as $child) {
        if (!$child->isValid()) {
            $errors[$child->getName()] = $this->getErrorMessages($child);
        }
    }

    return $errors;
}

Per ottenere tutti gli errori come stringa:

$string = var_export($this->getErrorMessages($form), true);

Symfony 2.5 / 3.0:

$string = (string) $form->getErrors(true, false);

Documenti:
https://github.com/symfony/symfony/blob/master/UPGRADE-2.5.md#form https://github.com/symfony/symfony/blob/master/UPGRADE-3.0.md#form (all'indirizzo il fondo: The method Form::getErrorsAsString() was removed)


1
Questa sembra la risposta più corretta per Symfony 2.4 corrente.
Slava Fomin II

@Flip funziona perfettamente su 2.5
iarroyo

1
Ottima risposta MA $errors[$child->getName()] = $this->getErrorMessages($child);stava generando un'eccezione, poiché getErrorMessages mancava dal componente Symfony \ Bundle \ FrameworkBundle \ Controller \ Controller . Quindi l'ho sostituito con$form_errors[$child->getName()] = $child->getErrorsAsString();
Ahad Ali

3
@AhadAli è una funzione ricorsiva, quindi quando metti lo snippet di codice nella classe in cui hai bisogno di questa funzionalità sarà in grado di chiamare se stessa. La tua "correzione" ti impedirà di raggiungere le forme annidate. Ha funzionato per altre 37 persone, dovrebbe funzionare anche per te;)
Flip

@Flip Ah mi dispiace, stavo solo guardando $this->getErrorMessages()e ho pensato che fosse chiamato direttamente all'interno di un controller e parte di Symfony api.
Ahad Ali

47

Di seguito è la soluzione che ha funzionato per me. Questa funzione si trova in un controller e restituirà un array strutturato di tutti i messaggi di errore e il campo che li ha causati.

Symfony 2.0:

private function getErrorMessages(\Symfony\Component\Form\Form $form) {
    $errors = array();
    foreach ($form->getErrors() as $key => $error) {
        $template = $error->getMessageTemplate();
        $parameters = $error->getMessageParameters();

        foreach($parameters as $var => $value){
            $template = str_replace($var, $value, $template);
        }

        $errors[$key] = $template;
    }
    if ($form->hasChildren()) {
        foreach ($form->getChildren() as $child) {
            if (!$child->isValid()) {
                $errors[$child->getName()] = $this->getErrorMessages($child);
            }
        }
    }

    return $errors;
}

Symfony 2.1 e versioni successive:

private function getErrorMessages(\Symfony\Component\Form\Form $form) {      
    $errors = array();

    if ($form->hasChildren()) {
        foreach ($form->getChildren() as $child) {
            if (!$child->isValid()) {
                $errors[$child->getName()] = $this->getErrorMessages($child);
            }
        }
    } else {
        foreach ($form->getErrors() as $key => $error) {
            $errors[] = $error->getMessage();
        }   
    }

    return $errors;
}

5
Gist.github.com/2011671 migliorato ma non è ancora quello che voglio. Voglio che le chiavi di matrice siano nomi di campo, ma non lo sono.
umpirsky

9
@SalmanPK Twig non è referenziato da nessuna parte nel codice precedente. Non credo di aver capito il tuo commento.
Icode4food

1
Ecco una correzione per l'essenza precedente, funziona con Symfony 2.1.7. gist.github.com/WishCow/5101428
K. Norbert

Sembra che ci sia un errore di battitura $this->getFormErrorsdovrebbe essere $this->getErrorMessagesnel tuo esempio in Symfony2.1
Mick

@umpirsky Per ottenere il nome del campo, ho ricevuto questo: $ child-> getConfig () -> getOptions () ['label'] Mi ci è
voluta

35

Utilizza il Validator per ottenere gli errori per un'entità specifica

if( $form->isValid() )
{
    // ...
}
else
{
    // get a ConstraintViolationList
    $errors = $this->get('validator')->validate( $user );

    $result = '';

    // iterate on it
    foreach( $errors as $error )
    {
        // Do stuff with:
        //   $error->getPropertyPath() : the field that caused the error
        //   $error->getMessage() : the error message
    }
}

Riferimento API:


Grazie, quello che mi serviva +1
Phill Pafford

4
Non sono sicuro che sia un buon approccio per convalidare ciascuna entità separatamente. E se hai una forma gerarchica complessa? Il secondo problema è che la convalida avviene due volte.
Slava Fomin II

3
@SlavaFominII - "Il secondo problema è che la convalida avviene due volte" - Buon punto, nulla viene aggiornato! Stessa lista di errori dopo!
BentCoder

20

Per ottenere messaggi corretti (traducibili), attualmente utilizzando SF 2.6.3, ecco la mia funzione finale (poiché nessuno dei precedenti sembra funzionare più):

 private function getErrorMessages(\Symfony\Component\Form\Form $form) {      
    $errors = array();
    foreach ($form->getErrors(true, false) as $error) {
        // My personnal need was to get translatable messages
        // $errors[] = $this->trans($error->current()->getMessage());
        $errors[] = $error->current()->getMessage();
    }

    return $errors;
}

poiché il metodo Form :: getErrors () ora restituisce un'istanza di FormErrorIterator , a meno che non si cambi il secondo argomento ($ flatten) su true . (Restituirà quindi un'istanza di FormError e dovrai chiamare direttamente il metodo getMessage (), senza il metodo current ():

 private function getErrorMessages(\Symfony\Component\Form\Form $form) {      
    $errors = array();
    foreach ($form->getErrors(true, true) as $error) {
        // My personnal need was to get translatable messages
        // $errors[] = $this->trans($error->getMessage());
        $errors[] = $error->getMessage();
    }

    return $errors;
}

)

La cosa più importante è effettivamente impostare il primo argomento su true per ottenere gli errori. Lasciando il secondo argomento ($ flatten) al suo valore predefinito ( true ) restituirà istanze di FormError , mentre restituirà istanze di FormErrorIterator se impostato su false.


Bello, usando la stessa roba.
Organico danneggiato

non è vero? :) @KidBinary
Cedo

Assolutamente stupendo, amico
:)

L'opzione migliore è: $ errors = array_map (function ($ item) {return $ item-> current () -> getMessage ();}, $ campaignForm-> getErrors (true, false));
Enrique Quero

Buona soluzione per Symfony 2.7
Yann Chabot

16

Per i miei messaggi flash ero soddisfatto $form->getErrorsAsString()

Modifica (da Benji_X80): per uso SF3 $form->getErrors(true, false);


3
So che è una vecchia risposta ma per riferimento futuro: This method should only be used to help debug a form.( fonte )
cheesemacfly

getErrorsAsString () è deprecato nella 3.0, usa: $ form-> getErrors (true, false);
Benji_X80

15

La funzione per symfony 2.1 e successive, senza alcuna funzione deprecata:

/**
 * @param \Symfony\Component\Form\Form $form
 *
 * @return array
 */
private function getErrorMessages(\Symfony\Component\Form\Form $form)
{
    $errors = array();

    if ($form->count() > 0) {
        foreach ($form->all() as $child) {
            /**
             * @var \Symfony\Component\Form\Form $child
             */
            if (!$child->isValid()) {
                $errors[$child->getName()] = $this->getErrorMessages($child);
            }
        }
    } else {
        /**
         * @var \Symfony\Component\Form\FormError $error
         */
        foreach ($form->getErrors() as $key => $error) {
            $errors[] = $error->getMessage();
        }
    }

    return $errors;
}

Stavo per pubblicare una nuova risposta a questo post ma mi sembrava che mi avessi battuto sul tempo. Ho dovuto esaminare il codice sorgente per capire perché le chiamate al metodo non sono state trovate.
Dottor Knowitall

Ho notato che questo non inserisce errori da elementi che hanno il bubbling impostato su true. SF2.4
kinghfb

@stwe qual è lo scopo della prima IFaffermazione? Perché si escludono a vicenda? Per quanto posso vedere: il modulo può avere i suoi errori così come i bambini.
Slava Fomin II

4

Messaggi di errore del modulo tradotto (Symfony2.1)

Ho lottato molto per trovare queste informazioni, quindi penso che valga sicuramente la pena aggiungere una nota sulla traduzione degli errori di modulo.

@Icode4foodla risposta restituirà tutti gli errori di un modulo. Tuttavia, l'array restituito non prende in considerazione né la pluralizzazione né la traduzione del messaggio .

Puoi modificare il ciclo foreach di @Icode4foodrisposta per avere una combo:

  • Ottieni tutti gli errori di una forma particolare
  • Restituisce un errore tradotto
  • Prendi in considerazione la pluralizzazione, se necessario

Ecco qui:

foreach ($form->getErrors() as $key => $error) {

   //If the message requires pluralization
    if($error->getMessagePluralization() !== null) {
        $errors[] = $this->container->get('translator')->transChoice(
            $error->getMessage(), 
            $error->getMessagePluralization(), 
            $error->getMessageParameters(), 
            'validators'
            );
    } 
    //Otherwise, we do a classic translation
    else {
        $errors[] = $this->container->get('translator')->trans(
            $error->getMessage(), 
            array(), 
            'validators'
            );
    }
}

Questa risposta è stata composta da 3 post diversi:


Ho appena provato la tua versione ed è andata Fatal Error: Call to undefined method Symfony\Component\Form\FormError::getMessagePluralization(). Sospetto che sia solo per Symfony 2.1?
Zar Pino

4

SYMFONY 3.X

Altri metodi SF 3.X forniti qui non hanno funzionato per me perché potevo inviare dati vuoti al modulo (ma ho vincoli NotNull / NotBlanck). In questo caso la stringa di errore sarebbe simile a questa:

string(282) "ERROR: This value should not be blank.
ERROR: This value should not be blank.
ERROR: This value should not be blank.
ERROR: This value should not be blank.
ERROR: This value should not be blank.
ERROR: This value should not be null.
name:
    ERROR: This value should not be blank.
"

Che non è molto utile. Quindi ho fatto questo:

public function buildErrorArray(FormInterface $form)
{
    $errors = [];

    foreach ($form->all() as $child) {
        $errors = array_merge(
            $errors,
            $this->buildErrorArray($child)
        );
    }

    foreach ($form->getErrors() as $error) {
        $errors[$error->getCause()->getPropertyPath()] = $error->getMessage();
    }

    return $errors;
}

Il che restituirebbe che:

array(7) {
  ["data.name"]=>
  string(31) "This value should not be blank."
  ["data.street"]=>
  string(31) "This value should not be blank."
  ["data.zipCode"]=>
  string(31) "This value should not be blank."
  ["data.city"]=>
  string(31) "This value should not be blank."
  ["data.state"]=>
  string(31) "This value should not be blank."
  ["data.countryCode"]=>
  string(31) "This value should not be blank."
  ["data.organization"]=>
  string(30) "This value should not be null."
}

3

Puoi anche utilizzare il servizio di convalida per ottenere violazioni dei vincoli:

$errors = $this->get('validator')->validate($user);

6
Ciò convaliderà l'oggetto ma non il modulo. Se, ad esempio, il token CRSF fosse la causa dell'errore, il messaggio non verrebbe incluso.
Icode4food

3

Messaggi di errore del modulo tradotto (Symfony2.3)

La mia versione per risolvere il problema:

/src/Acme/MyBundle/Resources/config/services.yml

services:
    form_errors:
        class: Acme\MyBundle\Form\FormErrors

/src/Acme/MyBundle/Form/FormErrors.php

<?php
namespace Acme\MyBundle\Form;

class FormErrors
{
    public function getArray(\Symfony\Component\Form\Form $form)
    {
        return $this->getErrors($form);
    }

    private function getErrors($form)
    {
        $errors = array();

        if ($form instanceof \Symfony\Component\Form\Form) {

            // соберем ошибки элемента
            foreach ($form->getErrors() as $error) {

                $errors[] = $error->getMessage();
            }

            // пробежимся под дочерним элементам
            foreach ($form->all() as $key => $child) {
                /** @var $child \Symfony\Component\Form\Form */
                if ($err = $this->getErrors($child)) {
                    $errors[$key] = $err;
                }
            }
        }

        return $errors;
    }
}

/src/Acme/MyBundle/Controller/DefaultController.php

$form = $this->createFormBuilder($entity)->getForm();
$form_errors = $this->get('form_errors')->getArray($form);
return new JsonResponse($form_errors);

In Symfony 2.5 puoi ottenere tutti gli errori dei campi molto facilmente:

    $errors = array();
    foreach ($form as $fieldName => $formField) {
        foreach ($formField->getErrors(true) as $error) {
            $errors[$fieldName] = $error->getMessage();
        }
    }

3

Per Symfony 3.2 e versioni successive usa questo,

public function buildErrorArray(FormInterface $form)
{
    $errors = array();

    foreach ($form->getErrors() as $key => $error) {
        if ($form->isRoot()) {
            $errors['#'][] = $error->getMessage();
        } else {
            $errors[] = $error->getMessage();
        }
    }

    foreach ($form->all() as $child) {
        if (!$child->isValid()) {
            $errors[$child->getName()] = (string) $child->getErrors(true, false);
        }
    }
    return $errors;
}

Usa str_replace se vuoi eliminare il fastidioso testo " Errore: " in ogni testo di descrizione dell'errore.

$errors[$child->getName()] = str_replace('ERROR:', '', (string) $child->getErrors(true, false));

2

Se stai usando validatori personalizzati, Symfony non restituisce gli errori generati da quei validatori in $form->getErrors(). $form->getErrorsAsString()restituirà tutti gli errori di cui hai bisogno, ma il suo output è sfortunatamente formattato come una stringa, non come un array.

Il metodo che usi per ottenere tutti gli errori (indipendentemente da dove provengano), dipende dalla versione di Symfony che stai usando.

La maggior parte delle soluzioni suggerite comporta la creazione di una funzione ricorsiva che analizza tutti i form figlio ed estrae gli errori rilevanti in un array. Symfony 2.3 non ha la $form->hasChildren()funzione, ma ce l'ha $form->all().

Ecco una classe di supporto per Symfony 2.3, che puoi usare per estrarre tutti gli errori da qualsiasi forma. (È basato sul codice di un commento di yapro su una relativa segnalazione di bug nell'account github di Symfony.)

namespace MyApp\FormBundle\Helpers;

use Symfony\Component\Form\Form;

class FormErrorHelper
{
    /**
     * Work-around for bug where Symfony (2.3) does not return errors from custom validaters,
     * when you call $form->getErrors().
     * Based on code submitted in a comment here by yapro:
     * https://github.com/symfony/symfony/issues/7205
     *
     * @param Form $form
     * @return array Associative array of all errors
     */
    public function getFormErrors($form)
    {
        $errors = array();

        if ($form instanceof Form) {
            foreach ($form->getErrors() as $error) {
                $errors[] = $error->getMessage();
            }

            foreach ($form->all() as $key => $child) {
                /** @var $child Form */
                if ($err = $this->getFormErrors($child)) {
                    $errors[$key] = $err;
                }
            }
        }

        return $errors;
    }
}

Codice di chiamata:

namespace MyApp\ABCBundle\Controller;

use MyApp\FormBundle\Helpers;

class MyController extends Controller
{
    public function XYZAction()
    {
        // Create form.

        if (!$form->isValid()) {
            $formErrorHelper = new FormErrorHelper();
            $formErrors = $formErrorHelper->getFormErrors($form);

            // Set error array into twig template here.
        }
    }

}

2

Sulla base della risposta di @Jay Seth, ho creato una versione della classe FormErrors appositamente per Ajax Forms:

// src/AppBundle/Form/FormErrors.php
namespace AppBundle\Form;

class FormErrors
{

    /**
     * @param \Symfony\Component\Form\Form $form
     *
     * @return array $errors
     */
    public function getArray(\Symfony\Component\Form\Form $form)
    {
        return $this->getErrors($form, $form->getName());
    }

    /**
     * @param \Symfony\Component\Form\Form $baseForm
     * @param \Symfony\Component\Form\Form $baseFormName
     *
     * @return array $errors
     */
    private function getErrors($baseForm, $baseFormName) {
        $errors = array();
        if ($baseForm instanceof \Symfony\Component\Form\Form) {
            foreach($baseForm->getErrors() as $error) {
                $errors[] = array(
                    "mess"      => $error->getMessage(),
                    "key"       => $baseFormName
                );
            }

            foreach ($baseForm->all() as $key => $child) {
                if(($child instanceof \Symfony\Component\Form\Form)) {
                    $cErrors = $this->getErrors($child, $baseFormName . "_" . $child->getName());
                    $errors = array_merge($errors, $cErrors);
                }
            }
        }
        return $errors;
    }
}

Utilizzo (ad es. Nella tua azione):

$errors = $this->get('form_errors')->getArray($form);

Versione di Symfony: 2.8.4

Esempio di risposta JSON:

{
    "success": false,
    "errors": [{
        "mess": "error_message",
        "key": "RegistrationForm_user_firstname"
    }, {
        "mess": "error_message",
        "key": "RegistrationForm_user_lastname"
    }, {
        "mess": "error_message",
        "key": "RegistrationForm_user_email"
    }, {
        "mess": "error_message",
        "key": "RegistrationForm_user_zipCode"
    }, {
        "mess": "error_message",
        "key": "RegistrationForm_user_password_password"
    }, {
        "mess": "error_message",
        "key": "RegistrationForm_terms"
    }, {
        "mess": "error_message2",
        "key": "RegistrationForm_terms"
    }, {
        "mess": "error_message",
        "key": "RegistrationForm_marketing"
    }, {
        "mess": "error_message2",
        "key": "RegistrationForm_marketing"
    }]
}

L'oggetto errore contiene il campo "chiave", che è l'id dell'elemento DOM di input, in modo da poter popolare facilmente i messaggi di errore.

Se hai form figlio all'interno del form genitore, non dimenticare di aggiungere l' cascade_validationopzione all'interno del form genitore setDefaults.


1

Per Symfony 2.1 in poi per l'uso con la visualizzazione degli errori Twig ho modificato la funzione per aggiungere un FormError invece di recuperarli semplicemente, in questo modo hai più controllo sugli errori e non devi usare error_bubbling su ogni singolo input. Se non lo imposti nel modo seguente, {{form_errors (form)}} rimarrà vuoto:

/**
 * @param \Symfony\Component\Form\Form $form
 *
 * @return void
 */
private function setErrorMessages(\Symfony\Component\Form\Form $form) {      

    if ($form->count() > 0) {
        foreach ($form->all() as $child) {
            if (!$child->isValid()) {
                if( isset($this->getErrorMessages($child)[0]) ) {
                    $error = new FormError( $this->getErrorMessages($child)[0] );
                    $form->addError($error);
                }
            }
        }
    }

}


1

Ho trovato questa soluzione. Funziona bene con l'ultima versione di Symfony 2.4 .

Cercherò di dare alcune spiegazioni.

Utilizzando un validatore separato

Penso che sia una cattiva idea usare la convalida separata per convalidare le entità e restituire i messaggi di violazione dei vincoli, come suggerito da altri autori.

  1. Dovrai convalidare manualmente tutte le entità, specificare gruppi di convalida, ecc., Ecc. Con forme gerarchiche complesse non è affatto pratico e sfuggirà rapidamente di mano.

  2. In questo modo convaliderai il modulo due volte: una volta con il modulo e una volta con un validatore separato. Questa è una cattiva idea dal punto di vista delle prestazioni.

Suggerisco di iterare ricorsivamente il tipo di modulo con i suoi figli per raccogliere i messaggi di errore.

Utilizzo di alcuni metodi suggeriti con l'istruzione IF esclusiva

Alcune risposte suggerite da altri autori contengono affermazioni IF mutuamente esclusive come questa: if ($form->count() > 0)o if ($form->hasChildren()).

Per quanto posso vedere, ogni modulo può avere errori così come i bambini. Non sono esperto con il componente Symfony Forms , ma in pratica non otterrai alcuni errori del modulo stesso, come errore di protezione CSRF o errore di campi extra . Suggerisco di rimuovere questa separazione.

Utilizzo della struttura dei risultati denormalizzata

Alcuni autori suggeriscono di inserire tutti gli errori all'interno di un semplice array. Quindi tutti i messaggi di errore del modulo stesso e dei suoi figli verranno aggiunti allo stesso array con diverse strategie di indicizzazione: basata sui numeri per gli errori del tipo e basata sul nome per gli errori figli. Suggerisco di utilizzare la struttura dati normalizzata del modulo:

errors:
    - "Self error"
    - "Another self error"

children
    - "some_child":
        errors:
            - "Children error"
            - "Another children error"

        children
            - "deeper_child":
                errors:
                    - "Children error"
                    - "Another children error"

    - "another_child":
        errors:
            - "Children error"
            - "Another children error"

In questo modo il risultato può essere facilmente ripetuto in seguito.

La mia soluzione

Quindi ecco la mia soluzione a questo problema:

use Symfony\Component\Form\Form;

/**
 * @param Form $form
 * @return array
 */
protected function getFormErrors(Form $form)
{
    $result = [];

    // No need for further processing if form is valid.
    if ($form->isValid()) {
        return $result;
    }

    // Looking for own errors.
    $errors = $form->getErrors();
    if (count($errors)) {
        $result['errors'] = [];
        foreach ($errors as $error) {
            $result['errors'][] = $error->getMessage();
        }
    }

    // Looking for invalid children and collecting errors recursively.
    if ($form->count()) {
        $childErrors = [];
        foreach ($form->all() as $child) {
            if (!$child->isValid()) {
                $childErrors[$child->getName()] = $this->getFormErrors($child);
            }
        }
        if (count($childErrors)) {
            $result['children'] = $childErrors;
        }
    }

    return $result;
}

Spero che possa aiutare qualcuno.


@weaverryan puoi dare un'occhiata alla mia soluzione per favore? È valido o ci sono svantaggi o idee sbagliate? Grazie!
Slava Fomin II

1

SYMFONY 3.1

Ho semplicemente implementato un metodo statico per gestire la visualizzazione degli errori

static function serializeFormErrors(Form\Form $form)
{
    $errors = array();
    /**
     * @var  $key
     * @var Form\Form $child
     */
    foreach ($form->all() as $key => $child) {
        if (!$child->isValid()) {
            foreach ($child->getErrors() as $error) {
                $errors[$key] = $error->getMessage();
            }
        }
    }

    return $errors;
}

Sperando di aiutare


1

Symfony 3 e versioni successive

Recentemente ho creato una funzione che crea un albero di errori di modulo. Ciò sarà utile per restituire l'elenco degli errori al front-end. Questo si basa sui tipi di modulo che hanno:

'error_bubbling' => false

Codice:

public static function getFormErrorsTree(FormInterface $form): array
{
    $errors = [];

    if (count($form->getErrors()) > 0) {
        foreach ($form->getErrors() as $error) {
            $errors[] = $error->getMessage();
        }
    } else {
        foreach ($form->all() as $child) {
            $childTree = self::getFormErrorsTree($child);

            if (count($childTree) > 0) {
                $errors[$child->getName()] = $childTree;
            }
        }
    }

    return $errors;
}

Produzione:

Array
(
    [name] => Array
        (
            [0] => This value is not valid.
        )

    [emails] => Array
        (
            [0] => Array
                (
                    [0] => Given e-mail is not valid.
                    [1] => Given e-mail is not valid #2.
                )
            [1] => Array
                (
                    [0] => Given e-mail is not valid.
                    [1] => Given e-mail is not valid #2.
                )

        )

)

Avviso : so che gli errori dei campi di livello più profondo possono essere sovrascritti se il livello superiore contiene errori, ma questo è apposta per il mio utilizzo.


Perfetto per var_dump, grazie
ReaperSoon il

0

Per Symfony 2.1:

Questa è la mia soluzione finale che mette insieme molte altre soluzioni:

protected function getAllFormErrorMessages($form)
{
    $retval = array();
    foreach ($form->getErrors() as $key => $error) {
        if($error->getMessagePluralization() !== null) {
            $retval['message'] = $this->get('translator')->transChoice(
                $error->getMessage(), 
                $error->getMessagePluralization(), 
                $error->getMessageParameters(), 
                'validators'
            );
        } else {
            $retval['message'] = $this->get('translator')->trans($error->getMessage(), array(), 'validators');
        }
    }
    foreach ($form->all() as $name => $child) {
        $errors = $this->getAllFormErrorMessages($child);
        if (!empty($errors)) {
           $retval[$name] = $errors; 
        }
    }
    return $retval;
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.