Le meilleur moyen de mettre fin à la demande ajax de WordPress et pourquoi?

11

Prendre en compte les requêtes ajax WordPress classiques comme celles-ci:

add_action( 'wp_ajax_merrychristmas_happynewyear', array( $this, 'merrychristmas_happynewyear' ) );
add_action( 'wp_ajax_nopriv_merrychristmas_happynewyear', array( $this, 'merrychristmas_happynewyear' ) );

Sera-t-il préférable de mettre fin à la fonction merrychristmas_happynewyear avec die() , die(0) , wp_die() ou autre chose et pourquoi?

    
posée prosti 24.12.2016 - 13:18

8 réponses

9

Utiliser wp_die() est la meilleure de ces options.

Comme d'autres l'ont déjà noté, il y a de nombreuses raisons de préférer une fonction spécifique à WordPress plutôt que la simple die ou exit :

  • Cela permet aux autres plugins de s’accrocher aux actions appelées par wp_die() .
  • Elle permet à un gestionnaire spécial de sortie d'être utilisé en fonction du contexte (le comportement de wp_die() est personnalisé en fonction du fait que la requête est une requête Ajax ou non).
  • Cela permet de tester votre code.

Le dernier point est plus important, raison pour laquelle j'ai ajouté cette note à le Codex . Si vous souhaitez créer des tests unitaires / d'intégration pour votre code, vous ne pourrez pas tester de fonction qui appelle exit ou die directement. Il mettra fin au script, comme il est supposé. La façon dont les propres tests de WordPress sont configurés pour éviter cela (pour les callbacks Ajax pour lesquels il dispose de tests), consiste à se connecter aux actions déclenchées par wp_die() et à lever une exception. Cela permet de capturer l’exception dans le test et d’analyser la sortie du rappel (le cas échéant).

Vous ne pouvez utiliser die ou exit que si vous souhaitez ignorer toute gestion spéciale de wp_die() et interrompre immédiatement l'exécution. Il y a des endroits où WordPress fait cela (et d'autres endroits où il peut utiliser die directement parce que le traitement de wp_die() n'est pas important, ou que personne n'a encore essayé de créer des tests pour un morceau de code, il a donc été négligé. ). Souvenez-vous que cela rend également votre code plus difficile à tester, il ne serait donc généralement utilisé que dans du code qui ne fait de toute façon pas partie du corps d'une fonction (comme WordPress le fait dans admin-ajax.php ). Donc, si le traitement de wp_die() n'est pas spécifiquement souhaité, ou si vous supprimez le script à un moment donné par précaution (comme admin-ajax.php , attendez-vous à ce qu'un rappel Ajax soit déjà correctement terminé), alors vous pourriez envisager en utilisant die directement.

En termes de wp_die() vs wp_die( 0 ) , vous devez utiliser dépend du traitement de la réponse de cette demande Ajax au niveau du serveur frontal. S'il attend un corps de réponse particulier, vous devez alors transmettre ce message (ou un entier, dans ce cas) à wp_die() . Si tout ce qu'il écoute, c'est que la réponse aboutisse (code de réponse 200 ou autre), il n'est pas nécessaire de transmettre quoi que ce soit à wp_die() . Je ferais remarquer, cependant, que terminer avec wp_die( 0 ) rendrait la réponse impossible à distinguer de la réponse par défaut admin-ajax.php . Terminer par 0 ne vous dit donc pas si votre rappel a été correctement raccordé et effectivement exécuté. Un message différent serait mieux.

Comme indiqué dans d'autres réponses, vous trouverez souvent wp_send_json() et al. pour vous aider si vous envoyez une réponse JSON, ce qui est généralement une bonne idée. Cela est également préférable à simplement appeler wp_die() avec un code, car vous pouvez transmettre beaucoup plus d'informations dans un objet JSON, si nécessaire. L'utilisation de wp_send_json_success() et wp_send_json_error() renverra également le message de réussite / d'erreur dans un format standard que toutes les fonctions d'assistance JS Ajax fournies par WordPress pourront comprendre (comme wp.ajax ).

TL; DR: vous devriez probablement toujours utiliser wp_die() , que ce soit dans un rappel Ajax ou non. Encore mieux, renvoyez les informations avec wp_send_json() et vos amis.

    
réponse donnée J.D. 04.02.2017 - 22:51
11

Extrait du codex AJAX dans les plugins

add_action( 'wp_ajax_my_action', 'my_action_callback' );

function my_action_callback() {
    global $wpdb; // this is how you get access to the database

    $whatever = intval( $_POST['whatever'] );

    $whatever += 10;

        echo $whatever;

    wp_die(); // this is required to terminate immediately and return a proper response
}
  

Notez l'utilisation de wp_die() au lieu de die() ou exit() . La plupart   temps que vous devriez utiliser wp_die() dans votre fonction de rappel Ajax. Ce   offre une meilleure intégration avec WordPress et facilite les tests   votre code.

    
réponse donnée Tunji 24.12.2016 - 13:23
5

Vous pouvez également utiliser wp_send_json() décrit dans le codex sous le nom de send a JSON response back to an AJAX request, and die().

Donc, si vous devez retourner un tableau, vous ne terminerez votre fonction qu'avec wp_send_json($array_with_values); . Pas besoin de echo ou die .

Vous disposez également de deux fonctions d'assistance: wp_send_json_success() et wp_send_json_error() qui ajoute une clé nommée success qui sera respectivement true ou false .

Par exemple:

$array_val = range( 1,10 );
var_dump( wp_send_json_error( $array_val ) ); # Output: {"success":false,"data":[1,2,3,4,5,6,7,8,9,10]}
echo 'Hey there'; # Not executed because already died.
    
réponse donnée RRikesh 25.12.2016 - 14:31
2

Ceci vient juste s'ajouter à ce que d'autres ont dit. La raison pour préférer wp_die est que le noyau peut déclencher des actions là-bas et que les plugins peuvent effectuer correctement des tâches telles que le traçage, la surveillance ou la mise en cache.

En général, vous devriez toujours préférer un appel API principal à un autre, car il est probable qu'il ajoute une valeur (mise en cache, intégration de plug-in ou autre) que vous ne recevez pas de l'appel PHP direct.

    
réponse donnée Mark Kaplun 03.02.2017 - 18:24
2

Pour utiliser wordpress ajax / woo commerce, la syntaxe générale ajax est la suivante:

add_action( 'wp_ajax_my_action', 'my_action_callback' );
add_action( 'wp_ajax_nopriv_my_action', 'my_action_callback' );
function my_action_callback()
{
// your code goes here

wp_die();

}

Vous devez utiliser wp_die () à la fin de la fonction. Parce que wordpress utilise en interne un filtre au cours de la fonction wp_die (). Ainsi, tout plug-in fonctionnant à l'aide de ce filtre risque de ne pas fonctionner si nous ne le faisons pas. inclure le wp_die (). Die () et d’autres fonctions tuent immédiatement l’exécution de PHP sans tenir compte des fonctions wordpress à prendre en compte lors de la fin de l’exécution.

Si vous utilisez wp_send_json () à l'intérieur de votre système, vous fonctionnerez comme ceci

       function my_action_callback()
    {
    // your code goes here

      wp_send_json();

    //wp_die(); not necessary to use wp_die();

    }

Il n'est pas nécessaire d'utiliser wp_die () à la fin si vous incluez wp_send_json () dans la fonction de rappel . parce que wordpress utilise lui-même la fonction wp_die () en toute sécurité dans la fonction wp_send_json ().

    
réponse donnée Saran 06.02.2017 - 08:29
2

Je n'accepterai pas cette réponse, cela ne serait pas juste. Je voulais juste créer un aperçu et des indices possibles sur les éléments que je trouve importants:

La définition principale de wp-die ()

File: wp-includes/functions.php
2607: /**
2608:  * Kill WordPress execution and display HTML message with error message.
2609:  *
2610:  * This function complements the 'die()' PHP function. The difference is that
2611:  * HTML will be displayed to the user. It is recommended to use this function
2612:  * only when the execution should not continue any further. It is not recommended
2613:  * to call this function very often, and try to handle as many errors as possible
2614:  * silently or more gracefully.
2615:  *
2616:  * As a shorthand, the desired HTTP response code may be passed as an integer to
2617:  * the '$title' parameter (the default title would apply) or the '$args' parameter.
2618:  *
2619:  * @since 2.0.4
2620:  * @since 4.1.0 The '$title' and '$args' parameters were changed to optionally accept
2621:  *              an integer to be used as the response code.
2622:  *
2623:  * @param string|WP_Error  $message Optional. Error message. If this is a WP_Error object,
2624:  *                                  and not an Ajax or XML-RPC request, the error's messages are used.
2625:  *                                  Default empty.
2626:  * @param string|int       $title   Optional. Error title. If '$message' is a 'WP_Error' object,
2627:  *                                  error data with the key 'title' may be used to specify the title.
2628:  *                                  If '$title' is an integer, then it is treated as the response
2629:  *                                  code. Default empty.
2630:  * @param string|array|int $args {
2631:  *     Optional. Arguments to control behavior. If '$args' is an integer, then it is treated
2632:  *     as the response code. Default empty array.
2633:  *
2634:  *     @type int    $response       The HTTP response code. Default 200 for Ajax requests, 500 otherwise.
2635:  *     @type bool   $back_link      Whether to include a link to go back. Default false.
2636:  *     @type string $text_direction The text direction. This is only useful internally, when WordPress
2637:  *                                  is still loading and the site's locale is not set up yet. Accepts 'rtl'.
2638:  *                                  Default is the value of is_rtl().
2639:  * }
2640:  */
2641: function wp_die( $message = '', $title = '', $args = array() ) {
2642: 
2643:   if ( is_int( $args ) ) {
2644:       $args = array( 'response' => $args );
2645:   } elseif ( is_int( $title ) ) {
2646:       $args  = array( 'response' => $title );
2647:       $title = '';
2648:   }
2649: 
2650:   if ( wp_doing_ajax() ) {
2651:       /**
2652:        * Filters the callback for killing WordPress execution for Ajax requests.
2653:        *
2654:        * @since 3.4.0
2655:        *
2656:        * @param callable $function Callback function name.
2657:        */
2658:       $function = apply_filters( 'wp_die_ajax_handler', '_ajax_wp_die_handler' );
2659:   } elseif ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST ) {
2660:       /**
2661:        * Filters the callback for killing WordPress execution for XML-RPC requests.
2662:        *
2663:        * @since 3.4.0
2664:        *
2665:        * @param callable $function Callback function name.
2666:        */
2667:       $function = apply_filters( 'wp_die_xmlrpc_handler', '_xmlrpc_wp_die_handler' );
2668:   } else {
2669:       /**
2670:        * Filters the callback for killing WordPress execution for all non-Ajax, non-XML-RPC requests.
2671:        *
2672:        * @since 3.0.0
2673:        *
2674:        * @param callable $function Callback function name.
2675:        */
2676:       $function = apply_filters( 'wp_die_handler', '_default_wp_die_handler' );
2677:   }
2678: 
2679:   call_user_func( $function, $message, $title, $args );
2680: }

wp_send_json

File: wp-includes/functions.php
3144: /**
3145:  * Send a JSON response back to an Ajax request.
3146:  *
3147:  * @since 3.5.0
3148:  * @since 4.7.0 The '$status_code' parameter was added.
3149:  *
3150:  * @param mixed $response    Variable (usually an array or object) to encode as JSON,
3151:  *                           then print and die.
3152:  * @param int   $status_code The HTTP status code to output.
3153:  */
3154: function wp_send_json( $response, $status_code = null ) {
3155:   @header( 'Content-Type: application/json; charset=' . get_option( 'blog_charset' ) );
3156:   if ( null !== $status_code ) {
3157:       status_header( $status_code );
3158:   }
3159:   echo wp_json_encode( $response );
3160: 
3161:   if ( wp_doing_ajax() ) {
3162:       wp_die( '', '', array(
3163:           'response' => null,
3164:       ) );
3165:   } else {
3166:       die;
3167:   }
3168: }

wp_doing_ajax

File: wp-includes/load.php
1044: /**
1045:  * Determines whether the current request is a WordPress Ajax request.
1046:  *
1047:  * @since 4.7.0
1048:  *
1049:  * @return bool True if it's a WordPress Ajax request, false otherwise.
1050:  */
1051: function wp_doing_ajax() {
1052:   /**
1053:    * Filters whether the current request is a WordPress Ajax request.
1054:    *
1055:    * @since 4.7.0
1056:    *
1057:    * @param bool $wp_doing_ajax Whether the current request is a WordPress Ajax request.
1058:    */
1059:   return apply_filters( 'wp_doing_ajax', defined( 'DOING_AJAX' ) && DOING_AJAX );
1060: }

Généralement, ce que nous obtenons d'un appel ajax est une sorte de réponse. La réponse peut être codée en json ou peut ne pas l'être en json.

Dans le cas où nous aurions besoin de json outupt wp_send_json ou de deux satellites, c'est une excellente idée.

Cependant, nous pouvons renvoyer x-www-form-urlencoded ou multipart/form-data ou text/xml ou tout autre type de codage. Dans ce cas, nous n'utilisons pas wp_send_json .

Nous pouvons renvoyer le code HTML complet et dans ce cas, il est judicieux d'utiliser wp_die() premier et deuxième paramètre, sinon ces paramètres doivent être vides.

 wp_die( '', '', array(
      'response' => null,
 ) );

Mais quel est l'avantage d'appeler wp_die() sans paramètres?

Enfin, si vous vérifiez le bon noyau WP, vous trouverez peut-être

File: wp-includes/class-wp-ajax-response.php
139:    /**
140:     * Display XML formatted responses.
141:     *
142:     * Sets the content type header to text/xml.
143:     *
144:     * @since 2.1.0
145:     */
146:    public function send() {
147:        header( 'Content-Type: text/xml; charset=' . get_option( 'blog_charset' ) );
148:        echo "<?xml version='1.0' encoding='" . get_option( 'blog_charset' ) . "' standalone='yes'?><wp_ajax>";
149:        foreach ( (array) $this->responses as $response )
150:            echo $response;
151:        echo '</wp_ajax>';
152:        if ( wp_doing_ajax() )
153:            wp_die();
154:        else
155:            die();

Les deux formats sont utilisés die() et wp_die() . Pouvez-vous expliquer pourquoi?

Enfin, voici ce que admin-ajax.php renvoie die( '0' );

Pourquoi pas wp_die(...) ?

    
réponse donnée prosti 07.02.2017 - 14:07
1

Utilisez wp_die() . Il est préférable d’utiliser autant que possible les fonctions de WordPress.

    
réponse donnée Greeso 04.02.2017 - 23:05
1

Si vous utilisez echo , cela vous obligera à utiliser die() ou die(0) ou wp_die() .

Si vous n'utilisez pas echo , JavaScript peut gérer cela.

Vous devriez alors utiliser un meilleur moyen de renvoyer des données: wp_send_json() .

Pour envoyer des données dans votre rappel (au format json ), vous pouvez utiliser les éléments suivants:

wp_send_json()

wp_send_json_success()

wp_send_json_error()

Tous mourront pour vous. Pas besoin de sortir ou de mourir après.

MISE À JOUR

Et si vous n'avez pas besoin de json comme format de sortie, vous devez utiliser:

wp_die($response)

Votre réponse sera renvoyée avant sa mort. Selon le codex:

  

La fonction wp_die() est conçue pour donner une sortie juste avant de mourir   pour éviter des réponses vides ou qui dépassent le délai imparti.

Veuillez lire l'article complet du codex ici .

    
réponse donnée Faisal Alvi 09.02.2017 - 15:26

Lire d'autres questions sur les étiquettes