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?

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()

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)

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;
}

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:

• ConstraintViolationList
• ConstraintViolation

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.

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

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

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;
}

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:

• Symfony2 - Ottenere gli errori di convalida tradotti nel controller
• Come usare il componente validatore di Symfony2 senza form (entità e array di dati) .
• Symfony2 - Ottenere tutti gli errori da un form in un controller

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."
}

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

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

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();
        }
    }

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));

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.
        }
    }

}

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.

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);
                }
            }
        }
    }

}

$ form-> getErrors () funziona per me.

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.

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

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.

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;
}