Sur l’écriture de code intelligent avec des tableaux dans WordPress

Je ne sais pas s’il existe une norme pour ce qui est considéré comme un "code intelligent", mais je pense que si vous deviez montrer divers exemples de code aux programmeurs, ils pourraient le savoir quand ils le verraient.

Et il fut un temps dans ma carrière où j’étais très intéressé par l’écriture de code intelligent. Mais plus je vieillis et plus je travaille à la maintenance des projets, moins je suis préoccupé par l’écriture de code intelligent et plus je suis intéressé par l’écriture de code clair et lisible et donc maintenu.

Le code intelligent est pour les oiseaux. Pardonnez ces jeux de mots stupides.

Lorsque nous travaillons avec WordPress, nous avons probablement beaucoup affaire à des tableaux, d’autant plus qu’une grande partie des éléments internes de WordPress sont construits sur eux (oui, il y a aussi des objets, mais les tableaux sont omniprésents).

À quoi ressemble alors un code intelligent avec des tableaux dans WordPress par rapport à un code moins intelligent? Et de plus, faut-il éviter de viser à écrire du code intelligent ?

Code intelligent avec des tableaux

Les fonctions de tableau sont sans doute l’un des plus grands ensembles de fonctions en PHP.

Naturellement, écrire du code intelligent avec WordPress semble correspondre en partie à l’environnement, n’est-ce pas? Je ne dis pas que c’est mauvais du tout. Je dis simplement que lorsque vous avez des fonctions dans l’espace de noms global qui fonctionnent avec des tableaux qui renvoient des tableaux, il est beaucoup trop facile d’écrire des appels imbriqués qui nécessitent finalement un peu plus de travail mental pour analyser ce que fait le code.

Bien sûr, écrire à ce sujet est une chose, mais il est peut-être logique de regarder un exemple de ce à quoi pourrait ressembler un code intelligent avec WordPress et ensuite comment il peut être refactorisé.

Un exemple

Supposons, par exemple, que nous ayons une publication et que nous mettions à jour l’extrait de publication afin qu’un nom contenu dans l’extrait doive être supprimé. Quand cela se produit n’est pas nécessairement important (bien que delete_user ne soit pas difficile à imaginer, n’est-ce pas ?)

Dès le départ, on nous donne :

• l’identifiant du poste,
• le nom de la personne à supprimer.

Une façon de faire serait d’utiliser une combinaison de array, array_map, exploser, array_diff, implode. Tout ça pour cette raison :

• tableau pour créer un tableau de la personne (car il, en tant que tableau, est requis plus tard),
• array_map pour couper l’espace blanc après avoir explosé l’extrait dans un tableau,
• array_diff pour trouver les chaînes qui restent après la suppression d’un nom,
• et implose pour reconstruire le résultat dans une chaîne pour le post_excerpt.

Bon, cela dit, voici à quoi peut ressembler un exemple de code intelligent dans WordPress :

<?php

// Get the excerpt from the incoming post.
$post    = get_post( $post_id );
$excerpt = $post->post_excerpt;

/**
 * And we update the post content without the information (and we don't need
 * paragraph tags).
 */
$event_post->post_excerpt = 
  apply_filters( 
    'the_excerpt', 
    implode( ', ', 
      array_diff( 
        array_map( 
          'trim', 
          explode( ',', $excerpt) ), 
      array( $name) ),
    ),
  );

Mais il y a beaucoup d’imbrication, et nous devons généralement commencer de l’extérieur vers l’intérieur et savoir ce que fait chaque fonction, n’est-ce pas ?

Pour le nettoyer, nous devons encore gérer les fonctions répertoriées ci-dessus, mais nous pouvons décomposer les choses en étapes plus faciles à lire (avec des commentaires de code) pour faciliter l’analyse par un autre développeur.

Peut-être que cela pourrait ressembler à ceci :

<?php

// Get the excerpt from the incoming post.
$post    = get_post( $post_id );
$excerpt = $post->post_excerpt;

// Remove the name from the array of names in the excerpt.
$to_remove = array( $name );
$names     = array_map( 'trim', explode( ',', $excerpt) );
$result    = array_diff( $names, $to_remove );

// Now creae the new excerpt.
$new_excerpt = implode( ', ', $result );

/**
 * And we update the post content without the information (and we don't need
 * paragraph tags).
 */
$event_post->post_excerpt = apply_filters( 'the_excerpt', $new_excerpt );

Maintenant, est-ce la façon de faire? Je ne sais pas. Mais c’est une façon de faire. Et c’est une de ces situations qui est plus facile à lire et à suivre.

Alors peut-être qu’il ne s’agit pas d’écrire du code intelligent dans WordPress, mais je ne sais pas – ni ne pense – que cela devrait être notre objectif.

Devrions-nous viser à écrire du code intelligent ?

Le manuel WordPress indique ce qui suit :

En général, la lisibilité est plus importante que l’intelligence ou la brièveté.

Et procède ensuite à donner un exemple. À ce stade de ma carrière, j’ai tendance à être d’accord :

• code intelligent n’est pas synonyme de code plus performant,
• le code intelligent prend souvent plus de temps pour sauter à travers plus de cerceaux mentaux que le code verbeux,
• le code intelligent est donc plus difficile à maintenir, en particulier lors du saut dans une base de code plus ancienne.

Enfin, je pense que différentes personnes pourraient considérer certains codes plus intelligents que d’autres, mais il y a aussi du code que beaucoup d’entre nous considéreraient comme une tentative plus intelligente que non.

En fin de compte, essayez d’écrire du code comme vous le souhaitez, mais écrivez en pensant à un autre développeur : si vous vous êtes déjà plaint qu’un morceau de code était difficile à déchiffrer au premier coup d’œil, il y a de fortes chances qu’il ait été mal écrit ou qu’il s’agissait d’un essayer d’être intelligent. Alors ne soyez pas ce gars ou cette fille qui renvoie la responsabilité au prochain développeur.

Au lieu de cela, essayez d’écrire un code clair et utilisez des commentaires si nécessaire.