Paul Schuhmacher
Durée : 28h
Novembre 2025
Pour bien s’installer et commencer à se familiariser avec le framework.
Pour adapter au mieux le reste de la formation :
{domain}/wp-json/wp
{domain}/wp-json/wp/v2/postsNombre de commits par entreprise
Nombre de contributeur·ices par pays
Pas grand chose de nouveau sur les autres API… (Settings, REST, etc..)
Projet open-source, protégé par la WordPress Foundation (protège la marque WordPress).
WordPress (wordpress.org) != Wordpress.com (Automattic) != WP Engine !
À l’heure de la formation
Attention : il est de la responsabilité de chaque vendor (thème, plugin) de maintenir la compatibilité de ses modules avec WordPress !
Voir la compatibilité entre WordPress et PHP selon leurs versions.
À l’heure de la formation
utf8mb4, attribut AUTO_INCREMENT, etc.) ;Possible d’utiliser d’autres systèmes (PostgreSQL, SQLite) mais demande une couche logicielle supplémentaire (plugins), peu d’intérêt si le choix ;
Télécharger le kit de développement
(dossier kit-dev) préparé pour la formation.
Nous utiliserons Docker pour servir le projet en local.
#A la racine du kit de développement, après installation
cd web
ls -C1 --group-directories-firstwp-admin/
wp-content/
wp-includes/
index.php
license.txt
readme.html
wp-activate.php
wp-blog-header.php
wp-comments-post.php
wp-config-docker.php
wp-config.php
wp-config-sample.php
wp-cron.php
wp-links-opml.php
wp-load.php
wp-login.php
wp-mail.php
wp-settings.php
wp-signup.php
wp-trackback.php
xmlrpc.phpTrois répertoires :
wp-admin + wp-includes + plupart des
fichiers à la racine : fichiers core (moteur WordPress).
Ne jamais les modifier, “Don’t hack the core!” (ces
fichiers sont réécrits à chaque mise à jour de WordPress !) ;wp-content : nos fichiers (themes,
plugins, media), user space ;Les contenus HTML (pages, posts, users, etc.) et leurs métadonnées sont stockés dans la base de données.
wp-admin/
wp-content/
wp-includes/
index.php
license.txt
readme.html
wp-activate.php
wp-blog-header.php
wp-comments-post.php
wp-config-docker.php
........................... => wp-config.php
wp-config-sample.php
wp-cron.php
wp-links-opml.php
wp-load.php
wp-login.php
wp-mail.php
wp-settings.php
wp-signup.php
wp-trackback.php
xmlrpc.phpwp-config.php est le fichier de
configuration le plus important !Le fichier
wp-config-sample.phpsert de base à la création du fichierwp-config.phplors de l’installation.
wordpress_[hash] : authentifie l’utilisateur·ice pour
l’administration (wp-admin);wordpress_logged_in_[hash] : authentifie
l’utilisateur·ice sur la partie publique (frontend).Le hash est calculé avec les clés et sels définis dans
wp-config.php (cf slide suivante).
Il est également possible de s’authentifier auprès de la REST API via plusieurs méthodes (JWT, Basic Auth, etc. )
Les clefs et sels sont générés à l’installation et sont utilisés pour signer les cookies d’authentification et les nonces (tokens anti-CSRF pour les formulaires) :
//Clefs secrètes pour signer :
//- les cookies d'authentification admin
define( 'AUTH_KEY', 'put your unique phrase here' );
//- les cookies d'authentification admin en HTTPS
define( 'SECURE_AUTH_KEY', 'put your unique phrase here' );
//- les cookies d'authentification d'un utilisateur connecté à l'interface publique, sans accès à l’administration.
define( 'LOGGED_IN_KEY', 'put your unique phrase here' );
//- les nonces WordPress (tokens CSRF) utilisés pour valider les formulaires d'un user authentifié
define( 'NONCE_KEY', 'put your unique phrase here' );
//Sels (salts) associés à leurs clés respectives
define( 'AUTH_SALT', 'put your unique phrase here' );
define( 'SECURE_AUTH_SALT', 'put your unique phrase here' );
define( 'LOGGED_IN_SALT', 'put your unique phrase here' );
define( 'NONCE_SALT', 'put your unique phrase here' );WordPress utilise HMAC pour
signer les cookies et les nonces
(wp-includes/pluggable.php) :
//Génération d'un cookie dans la fonction wp_generate_auth_cookie() basé sur un $token (valeur aléatoire) conservé en base
//clé
$key = wp_hash( $user->user_login . '|' . $pass_frag . '|' . $expiration . '|' . $token, $scheme );
//valeur
$hash = hash_hmac( 'sha256', $user->user_login . '|' . $expiration . '|' . $token, $key );Dans le fichier wp-config.php, configurer le mode debug
pour avoir accès à toutes les informations d’erreur et diagnostics:
define( 'WP_ENVIRONMENT_TYPE', 'development' ); // Permet de définir le mode d'execution dans le code.
//Disposer de toutes les informations de debug
define( 'WP_DISABLE_FATAL_ERROR_HANDLER', true ); // Désactiver le gestionnaire d'erreur global > 5.2
define( 'WP_DEBUG', true ); // Active le mode debug global
define( 'WP_DEBUG_DISPLAY', true ); // Affiche les erreurs à l'écran (activé si WP_DEBUG activé)
define( 'WP_DEBUG_LOG', true ); // Log dans wp-content/debug.log
define( 'SAVEQUERIES', true ); // Log SQL dans $wpdb->queries (debug DB)
define( 'SCRIPT_DEBUG', true ); // Charge assets JS/CSS non minifiés du core
//Afficher la valeur des constantes
//print_r( get_defined_constants() );On reviendra sur la configuration en mode production plus tard dans la formation.
Quelques configurations :
define('WP_DEBUG', true); //erreurs sur la sortie (à l'écran)
define('WP_DEBUG_LOG', true); //erreurs dans le fichier de log wp-content/debug.logdefine('WP_DEBUG', true);
define('WP_DEBUG_LOG', true);
define('WP_DEBUG_DISPLAY', false); // pour éviter l'affichage sur la sortie (à l'écran)WP_ENVIRONMENT_TYPE est une constante introduite depuis
WordPress 5.5 pour identifier le contexte d’exécution du site web.
Permet aux thèmes et aux plugins d’adapter leur comportement :
if ( wp_get_environment_type() === 'development' ) {
//Faire quelque chose de spécifique en environnement de dev
}Pour débuger les requêtes SQL :
// Log toutes les requêtes vers la base dans un tableau PHP
define( 'SAVEQUERIES', true );
// Pour afficher le tableau de la requête
global $wpdb;
print_r( $wpdb->queries );Toujours log (erreurs PHP, logs manuels
via la fonction error_log) en environnement de
développement et de production.
Mesure de sécurité (auditability) : conserver une trace de toutes les erreurs et événements critiques pour garantir l’auditabilité, définir les causes et responsabilités.
On peut (et devrait) écrire un log lors d’évènements importants ou le déclenchement de procédures nécessitant des privilèges: authentification d’un admin, installation d’un plugin, etc. Pour cela, on peut utiliser la fonction PHP native error_log :
error_log("Utilisateur X a installé plugin Y");
//Envoi d'un email
error_log('Message critique pour notifier l\'administrateur', 1, "admin@email.com");Par défaut, si WP_DEBUG est définie à true,
WordPress crée un fichier wp-content/debug.log et y écrit
les logs.
Ce fichier est placé dans wp-content qui est par
définition public !
Essayer : http://localhost:8080/wp-content/debug.log
Embrassant !
Il ne doit évidemment pas être accessible aux clients.
Sur Apache, on peut restreindre son accès via un fichier
.htaccess placé dans le dossier wp-content
:
<Files "debug.log">
Require all denied
</Files>Essayer : http://localhost:8080/wp-content/debug.log
Mieux !
Les erreurs PHP peuvent être logés à différents endroits en fonction de l’emplacement de l’erreur :
wp-settings.php,
WordPress n’a pas mis en place sa redirection des logs vers
wp-content/debug.log. Le fichier où est consigné l’erreur
est défini par la configuration de PHP.wp-settings.php,
WordPress a mis en place sa redirection des logs vers
wp-content/debug.log.//Dans wp-settings.php
// Check if WP_DEBUG mode is enabled.
wp_debug_mode(); // enregistre un gestionnaire d'erreur qui redirige les logs vers wp-content/debug.lohwp_debug_mode() est implémentée dans
wp-includes/load.php. Définit le fichier de redirection des logs et le niveau des erreurs consignées (ini_set( ‘error_log’, $log_path ); et error_reporting())
Pour avoir une couverture complète des erreurs, il faut donc :
Il y a trois deux possibilités :
wp-config.php;php.ini;.htaccess, propre à l’ancien module CGI d’Apache
mod_phpQuelle méthode choisir ? Cela dépend de votre environnement de production et de votre liberté d’action sur le serveur. Mon conseil : Privilégier via
php.inisi possible !
Il faut utiliser trois directives PHP :
display_errors
: afficher les erreurs sur la sortie ou non. Valeurs possibles (string)
: On, Off, stdout,
stderr;log_errors
: utiliser le système de logs du serveur. Valeurs possibles (bool) :
1(oui) ou 0(non)error_log
: path de destination des logs (nom complet du
fichier). Ce fichier doit être inscriptible par le serveur (Apache,
Nginx, Caddy, etc.). Valeur (string) : chemin du fichier.Voir toutes les directives et options pour le système de logging de PHP
//wp-config.php
@ini_set('display_errors', 0); // désactive l'affichage
@ini_set('log_errors', 1); // active le logging PHP
@ini_set('error_log', '/var/log/wordpress.log'); // log PHP globalphp.ini #; Désactiver l'affichage des erreurs aux utilisateurs
display_errors = Off
; Activer le logging des erreurs PHP
log_errors = On
; Fichier de log PHP global
error_log = /var/log/wordpress.log
; Niveau d'erreur à loger. Important pour pas polluer ses logs
error_reporting = E_ALL & ~E_NOTICE & ~E_DEPRECATED & ~E_STRICTÀ propos de cette instruction :
error_reporting = E_ALL & ~E_NOTICE & ~E_DEPRECATED & ~E_STRICT. Le & est un ET binaire sur les flags. Le ~ est un NOT binaire qui inverse le flag. On prend tous les types d’erreurs (E_ALL), puis on retire ceux qu’on ne veut pas (E_NOTICE,E_DEPRECATED,E_STRICT).
À privilégier !
Avec Apache
PHP-FPM, placer le fichier ini dans le répertoire
/etc/php/8.x/fpm/pool.d/www.conf. Voir
comment configurer PHP-FPM
Ne plus utiliser l’ancien module CGI PHP d’Apache (
mod_php). Il est déprécié.
En production, on veut toujours log les erreurs, mais on ne souhaite pas les afficher sur la sortie (et finissent chez le client) :
// Mode production
define('WP_ENVIRONMENT_TYPE', 'production');
// Désactive l'affichage
define('WP_DEBUG', true); // Activé pour que les erreurs soient loguées
define('WP_DEBUG_LOG', true); // Consigne les erreurs dans wp-content/debug.log
define('WP_DEBUG_DISPLAY', false); // RIEN AFFICHER SUR LA SORTIE (ECRAN)
define('SAVEQUERIES', false); // Surtout pas !
define('SCRIPT_DEBUG', false); // Désactive le chargement de assets du core non minifiéesUn exemple complet de fichier de configuration sera fourni dans la section consacrée à la mise en production.
Dans le fichier wp-config.php, un emplacement vous est
indiqué pour ajouter vos propres configurations.
/* Add any custom values between this line and the "stop editing" line. */
// => AJOUTER VOS CONFIGS ICI (ou inclure un fichier de config custom) <=
if ( ! defined( 'MACONFIG' ) ){
define( 'MACONFIG', 'MACONFIG_VALUE' );
}
/* That's all, stop editing! Happy publishing. */
/** Absolute path to the WordPress directory. */
if ( ! defined( 'ABSPATH' ) ) {
define( 'ABSPATH', __DIR__ . '/' );
}
...Depuis WordPress 3.7, on peut activer une politique de mise à jour du cœur en arrière-plan. Il y a quatre types de mises à jour automatiques que l’ont peut configurer :
Trois types de mises à jour du cœur :
//désactiver complètement TOUS les types de mises à jour automatiques (core, theme, plugins, traductions)
define( 'AUTOMATIC_UPDATER_DISABLED', true );
//mises à jour du core
//aucune mises à jour auto
define( 'WP_AUTO_UPDATE_CORE', false );
//toutes les mises à jour activées ;
define( 'WP_AUTO_UPDATE_CORE', true );
//Recommandé : mises à jour auto pour versions mineures seulement (sécurité, bug fix)
//Valeur par défaut depuis WordPress 5.6
define( 'WP_AUTO_UPDATE_CORE', 'minor' );wp-admin/ : "gestion de l'administration du site "[x]
wp-content/ : "notre application embarquée par wordpress" [x]
................................................................................. => wp-includes/
index.php : "point d'entrée de l'application WordPress" [x]
license.txt
readme.html
wp-activate.php
wp-blog-header.php
wp-comments-post.php
wp-config-docker.php
wp-config.php [x]
wp-config-sample.php [x]
wp-cron.php : "configure un gestionnaire de tâches automatisées (cron job) (déclenché à chaque visite)" [x]
wp-links-opml.php
wp-load.php
wp-login.php : "gestion du login" [x]
wp-mail.php
wp-settings.php : "définit variables globales, gère includes (core)" [x]
wp-signup.php : "gestion de la création de compte" [x]
wp-trackback.php
xmlrpc.phpCommencer à se sentir chez soi…
(Quelques) fichiers du core, qui implémentent toutes les API
de WordPress, dans /wp-includes :
class-*.php : tous un tas de services sous forme de
classes (hashing, json format, requêtes HTTP, etc.);functions.php : fonctions principales de l’API de
WordPress. Utilisées par le core, les plugins, themes;option.php : fonctions de l’API Options (ex
add_option());formatting.php : fonctions de formatage, d’échappement,
sanitization. Très utiles et importantes;pluggable.php : fonctions pour surcharger des fonctions
du core (ex wp_mail);plugin.php : fonctions de l’API Plugins, pour
développer ses propres plugins !user.php : fonctions de l’API User;post.php : fonctions de traitement des posts;taxonomy.php : fonctions de l’API des taxonomies.Nous allons apprendre à nous servir de nombreuses API (fonctions, classes, variables globales) pour développer notre site sur mesure (theme, plugins).
Pour interagir avec le core, WordPress expose de nombreuses API. Voici les principales :
Les API mises en avant sont celles que nous allons aborder au cours de cette formation !
Il est utile d’avoir une vision d’ensemble du schéma de la base de données de WordPress pour :
WP_Query) ;wp_ (Recommandé : modifier ce préfixe dans
wp-config.php via la variable globale
$table_prefix pour des raisons de sécurité);Points techniques :
Des versions majeures de WordPress peuvent changer (très) légèrement la structure des tables (label, champ). Mais la rétrocompatibilité chez WordPress est un objectif principal (pas de craintes).
Trois grandes régions :
La table
wp_links(gestion de liens vers d’autres sites) a été déprécié en WordPress 3.5 (présente pour rétrocompatibilité, toujours utilisable si besoin !) On l’ignorera ici.
posts : tous les posts (défaut et custom),
pages, media records, revisions. Table la plus grosse
d’un site WordPress ;postmeta : toutes les métadonnées des posts
(custom fields).terms : tous les termes (valeurs) des
différentes taxonomies ;termmeta : métadonnées des termes ;term_taxonomy : association terme-taxonomie ;term_relationships : table de jointure term et
posts.
users : login, password, email, etc. ;usersmeta : roles (user level) ;comments : commentaires ;commentmeta : métadonnées des commentaires.options : toutes les options de la page Settings et
Settings API, roles et capabilities existant dans le système.Données primitives de WordPress : pages, posts, taxonomies, utilisateurs, rôles
post_type = ‘page’), logique spécifique (hiérarchie
parent/enfant, contenu statique)Presque tout est un post en WordPress !
Taxonomie : Terme CMS (Architecture de l’information).
Définition : (syn taxinomie) Science des classifications. Classification, suite d’éléments formant des listes qui concernent un domaine, une science. Arbre hiérarchique de catégorisation thématique (répertoire). Permet de regrouper, organiser et filtrer les objets (dans WordPress des posts, pages, CPTs, Users). ;
Deux types de taxonomies :
Termes (terms) : éléments d’une taxonomie .
Football et Tennis sont des
termes de la taxonomie Sport,Football en salle peut avoir
Football pour parent,terms et relié à
sa taxonomie et à sa hiérarchie via term_taxonomy
Terminologie :
Un exemple :
Terminologie :
Exemple :
category), hiérarchiquepost_tag), non hiérarchiqueUncategorized de la
taxonomie category.
Un vaste sujet (passionnant) !
Pose des questions sur la navigabilité et les possibilités de recherche offertes par le système, et donc sa structure et son design.
Feuilletage recommandé : Information Architecture for the World Wide Web 3rd Edition, de Peter Morville et Louis Rosenfeld, publié chez O’Reilly Media, 2006. Consulter notamment le chapitres 1 et 2.
Les tables pour la gestion des taxonomies et leurs associations (formalisme MERISE).
Exemple :
A (id 4) et B (id
5) de la taxonomie category;6) dans la catégorie A;En base :
term_taxonomy : contient association terme-taxonomie.
(1, 4, category),
(2, 5, category)terms : valeurs des termes. (4, 'A'),
(5, 'B')term_relationships: association post-termes .
(6, 1)users (login, email, password
hashé (bcrypt + salt))usermeta (préférences,
informations supplémentaires).capabilities.
options dans l’attribut
wp_user_roles.administrator,
editor, author, contributor,
subscriber.capabilities (ex:
edit_posts, publish_posts,
manage_options).usermeta)user_can()Les rôles et capacités sont stockés sous forme d’un tableau PHP sérialisé en base.
Extrait de la valeur par défaut (à l’installation) de
wp_options.wp_user_roles :
a:5:
{
s:13:"administrator";
a:2:{
s:4:"name";s:13:"Administrator";s:12:"capabilities";
a:61:{
s:13:"switch_themes";b:1;
s:11:"edit_themes";b:1;
s:16:"activate_plugins";b:1;
s:12:"edit_plugins";b:1;
...Se familiariser avec la base permet :
Pour cela, utilisez au choix :
mysql présent sur le conteneur
db. Pour ouvrir une session :docker compose exec -it db mysql -uroot -prootformation,Formation dans la base de données;formation. Afficher le titre du poste, le
nom de la taxonomie et le nom du
terme;-- Question 1
SELECT ID, post_title, post_status, post_parent FROM wp_posts WHERE post_title = "Hello World!";
-- Question 4.1
SELECT slug FROM wp_terms WHERE name="Formation";
-- Question 4.2
SELECT p.post_title, tt.taxonomy, t.name
FROM wp_term_relationships tr
JOIN wp_posts p ON tr.object_id = p.ID
JOIN wp_term_taxonomy tt ON tt.term_taxonomy_id = tr.term_taxonomy_id
JOIN wp_terms t ON t.term_id = tt.term_id
WHERE t.name = "Formation";
-- Question 4.3
UPDATE wp_users
SET user_pass = MD5('nouveau_mot_de_passe')
WHERE user_id = 1;Attention, ici on hash le mot de passe avec l’algorithme MD5 (déprécié !). À la première connexion, WordPress va re hasher le mot de passe en utilisant bcrypt et son salt. Se reconnecter immédiatement !
En cas de besoin (plus d’accès à /login), utiliser
plutôt WP-CLI :
docker compose run --rm wpcli user update 1 --user_pass="new_pass"Observations :
wp_posts augmente rapidement avec
le nombre de posts !
()Essayer de créer plusieurs révisions en modifiant le contenu du post “Hello World” et en enregistrant.
Conséquences et problèmes :
WP_Query deviennent moins
performantes.Pour inspecter le nombre de révisions en base :
SELECT COUNT(ID) as "Nombre de revisions :" FROM wp_posts WHERE post_type = 'revision';Solution :
Limiter le nombre de révisions via la constante
WP_POST_REVISIONS (2-3 suffisent généralement), à placer
dans le fichier wp-config.php :
//Dans le fichier wp-config.php :
//Limité à 3 révisions
define( 'WP_POST_REVISIONS', 3 );
//Désactiver les révisions, si pas besoin d'historique
define( 'WP_POST_REVISIONS', false );Supprimer toutes les révisions de chaque post sauf la dernière :
DELETE FROM wp_posts
WHERE post_type = 'revision'
AND ID NOT IN (
-- Sélectionne la dernière révision de chaque post
SELECT id FROM (
SELECT MAX(ID) AS id
FROM wp_posts
WHERE post_type = 'revision'
GROUP BY post_parent
) AS latest
);wp-content : user space #Dans le répertoire wp-content :
themes : liste des thèmes (templates et assets) ;uploads : fichiers téléversés via la Médiathèque
(images, vidéos, documents, etc.). Organisé par année/mois par défaut
;plugins : plugins classiques, activables via l’admin
WordPress. Étendre les fonctionnalités du core ;mu-plugins : Must-use plugins :
upgrades : utilisé temporairement pour stocker les
fichiers lors de mises à jour automatiques de WordPress, plugins ou
thèmes,La configuration de WordPress se partage entre les sources et les données en base.
Se connecter en tant qu’administrateur·ice.
Guide Tour :
Par défaut les URLs de WordPress sont de la forme
/?key=value. Par exemple : /?p=1,
/?cat=2, etc. Elles sont basées sur des paramètres d’url
(query part).
Activer les permaliens (réécriture d’URL)
Avantages :
/category/music indique que
/category est aussi une ressource valide;Dans la section Settings/General :
d/m/Y ;H:i ;Paris).À adapter en fonction de la langue du site et de ses règles d’usage.
Installer les plugins suivants :
À utiliser uniquement en environnement de développement !
Fichiers requis :
style.css ;index.php.On développera ce thème (et ses plugins) tout au long de la formation. On a ajouté
screenshot.png(optionnel) pour que le thème ait un thumbnail.
style.css #/*
Theme Name: Mon Thème
Author: Prénom Nom
Description: Une description du thème
Version: 0.1.0
License: Infos sur la licence
Text Domain:
Tags:
*/index.php (test) #<?php
/**
* Point d'entrée du thème
*/
//Modifier l'expéditeur de l'email par défaut via un filtre
add_filter('wp_mail_from', function ($email) {
return 'test@mailhog.local';
});
//Envoi d'un email de test
if (wp_mail("test@example.com", "MailHog test", "Hello from WordPress")) {
echo "email sent";
} else {
echo "Error: email not sent.";
}
//Ecrire un log
error_log('some log');
//Afficher les informations sur la configuration de php utilisée par WordPress
phpinfo();/) et vérifier que
l’email est bien présent dans le mailcatcher;wp-content/debug.log existe et
contient le log.Le service gulp défini dans le fichier
compose.yaml (basé sur gulpjs) :
Lancer le service :
#ne pas le détacher pour debug (voir des erreurs)
docker compose exec gulp gulpOn s’en servira plus tard !
À adapter/étendre à vos usages (intégrer vos frameworks CSS, comme Bootstrap, ou JavaScript favoris). On n’utilisera pas de framework CSS/JS dans cette formation pour ne pas introduire de complexité inutile.
WP-CLI est un outil puissant (programmable !). Il permet de :
#check la configuration de wp-cli
docker compose run --rm wpcli wp config list
docker compose run --rm wpcli cli info
docker compose run --rm wpcli db tablesWP-CLI utilise les informations de connexion présents dans
wp-config.phppour se connecter à la base de données.
#Lister les conteneurs actifs
docker compose ps
#Afficher en temps réel les logs du conteneur WordPress (log d'Apache ici)
docker compose logs -f wordpressCycle de vie de l’application WordPress : de la requête à la réponse HTTP.
/wp-login.php, /wp-content/style.css), le
serveur sert directement le fichier,index.php* de
WordPress (via .htaccess avec Apache ou la configuration
Nginx).wp-settings.php est chargé :
*Que la réécriture des permaliens soit activée ou non (voir slide suivante)
$wp_query : objets $post,
collections, flags (is_single(), is_page(),
etc.) etc.pre_get_posts, etc.).Par défaut, on l’a vu, les URL de WordPress concernent toujours la
ressource racine (/) et en produit des variations avec des
query parameters (ex /?p=1). Le fichier
index.php est donc toujours le point d’entrée.
Réécrire les permaliens génère (avec Apache) le fichier
.htaccess suivant :
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
RewriteBase /
RewriteRule ^index\.php$ - [L]
# Si le fichier ou dossier existe physiquement, il est servi directement.
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
# Sinon, redirige toute requête vers index.php, le point d’entrée WordPress.
RewriteRule . /index.php [L]
</IfModule>Cette configuration dit :
index.php sinon.La réécriture des permaliens ne modifie donc pas le fonctionnement du cycle de vie de l’application.
La template Hierarchy est un mécanisme central du fonctionnement des thèmes à comprendre.
Elle détermine le choix de la vue et donc du script PHP de votre thème qui va être utilisé en fonction du contexte, et donc de l’URL.
On y reviendra plus en détail par la suite.
//Dans un template (page, post, archive, etc.)
//have_posts() interroge le contexte
<?php if ( have_posts() ) : while ( have_posts() ) : the_post(); ?>
<div class="entry">
<?php the_content(); ?>
</div>
<?php endwhile;?>Source de l’image, p 83.
have_posts() : vérifie si le $wp_query
courant (contexte) contient encore des posts;while ( have_posts() ) : itère sur tous les posts
(posts au sens large, “contenu”) du contexte;the_post() (Effets de bords !) :
$wp_query->posts (fait avancer un pointeur),$post + ses métadonnées,the_title(),
the_content(), get_the_ID()) pour accéder au
$post courant et à ses données.//Dans un template (page, post, archive, etc.)
<?php if ( have_posts() ) : while ( have_posts() ) : the_post(); ?>
<div class="entry">
<?php the_content(); ?>
</div>
<?php endwhile;?>On verra dans la suite de la formation comment créer nos propres loops customs.
WP::main() : point d’entrée du
traitement de la requête
parse_request : interprète
l’URL en requête logiqueWP_Query (phase résolution) : construit le
contexte et récupère les donnéesWP_Query (côté lecture), WP_Post, WP_User,
WP_Term, Meta API, Options APIIdéalement, on devrait pouvoir changer de thème tout en maintenant le bon fonctionnement du site !
Un programme écrit en PHP basé sur une base de données relationnelle (MySQL).
Pour migrer ou installer un site WordPress il faut donc :
wp-config.php);wp-content : themes, plugins, mu-plugins, media;On reviendra sur les workflows de déploiement plus tard dans la formation
Pour monter en compétences sur WordPress on peut utiliser les différents niveaux de documentation suivants :
Par exemple, dans le fichier wp-includes/functions.php
:
/**
* Converts given MySQL date string into a different format.
*
* - `$format` should be a PHP date format string.
* - 'U' and 'G' formats will return an integer sum of timestamp with timezone offset.
* - `$date` is expected to be local time in MySQL format (`Y-m-d H:i:s`).
*
* Historically UTC time could be passed to the function to produce Unix timestamp.
*
* If `$translate` is true then the given date and format string will
* be passed to `wp_date()` for translation.
*
* @since 0.71
*
* @param string $format Format of the date to return.
* @param string $date Date string to convert.
* @param bool $translate Whether the return date should be translated. Default true.
* @return string|int|false Integer if `$format` is 'U' or 'G', string otherwise.
* False on failure.
*/
function mysql2date( $format, $date, $translate = true ) {
if ( empty( $date ) ) {
return false;
}
...Recommandé !
Par exemple, dans VS Code, utiliser l’extension Hooks IntelliSense for WordPress, en plus de l’extension PHP Intelephense
wp-cli);posts, postmeta,
terms, term_relationships, users,
usermeta pour la majorité des besoins. Par
exemple :
post +
meta ;Le schéma de base de WordPress (posts, metas, terms, users) est stabilisé, éprouvé sur des millions d’installations, et intégré au système de cache du coeur (objet cache, page cache, query caching). Ses tables ont des index connus, et l’API
WP_Querysait les exploiter efficacement. Beaucoup de plugins se basent dessus, ce qui garantit compatibilité et prévisibilité du comportement. Créer ses tables = une dette à assumer !
Dans cette première séquence nous avons :
wp-config.php ;