web-dev-qa-db-fra.com

Les shortcodes sont-ils sensibles à la casse?

Si j'écris un plugin et enregistre un shortcode en utilisant ce code:

add_shortcode('footag', 'footag_func');

et un utilisateur l'utilise dans son message:

[FOOTAG]

Est-ce censé fonctionner?

plugin-developmentshortcode
4
Ben Miller

Réponse courte

Oui, les codes courts sont sensibles à la casse

Réponse plus longue

Il est très facile de construire un cas de test pour cela et de voir.

<?php
add_shortcode('sOme_ShOrTcOdE', 'wpse102375_shortcode');
function wpse102375_shortcode($args, $content=null)
{
    return 'yep';
}

Réponse la plus longue

Lire la source.

La "magie" avec les codes courts se produit dans do_shortcode , regardons donc cela.

<?php
// wp-includes/shortcode.php
function do_shortcode($content) {
    global $shortcode_tags;

    if (empty($shortcode_tags) || !is_array($shortcode_tags))
        return $content;

    $pattern = get_shortcode_regex();
    return preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $content );
}

Hmmm, $shortcode_tags - probablement mis en place dans add_shortcode:

<?php
// wp-includes/shortcodes.php
function add_shortcode($tag, $func) {
    global $shortcode_tags;

    if ( is_callable($func) )
        $shortcode_tags[$tag] = $func;
}

Il ne s’agit donc que d’une partie clé de la valeur de $shortcode_name => $a_callablle. Logique.

On dirait que l'essentiel de la magie de do_shortcode se produit lors de la construction de l'expression régulière pour faire correspondre les codes courts eux-mêmes. Tout ce qui se passe dans get_shortcode_regex, regardons donc ceci:

<?php
// wp-includes/shortcode.php
function get_shortcode_regex() {
    global $shortcode_tags;
    $tagnames = array_keys($shortcode_tags);
    $tagregexp = join( '|', array_map('preg_quote', $tagnames) );

    // WARNING! Do not change this regex without changing do_shortcode_tag() and strip_shortcode_tag()
    // Also, see shortcode_unautop() and shortcode.js.
    return
          '\\['                              // Opening bracket
        . '(\\[?)'                           // 1: Optional second opening bracket for escaping shortcodes: [[tag]]
        . "($tagregexp)"                     // 2: Shortcode name
        . '(?![\\w-])'                       // Not followed by Word character or hyphen
        . '('                                // 3: Unroll the loop: Inside the opening shortcode tag
        .     '[^\\]\\/]*'                   // Not a closing bracket or forward slash
        .     '(?:'
        .         '\\/(?!\\])'               // A forward slash not followed by a closing bracket
        .         '[^\\]\\/]*'               // Not a closing bracket or forward slash
        .     ')*?'
        . ')'
        . '(?:'
        .     '(\\/)'                        // 4: Self closing tag ...
        .     '\\]'                          // ... and closing bracket
        . '|'
        .     '\\]'                          // Closing bracket
        .     '(?:'
        .         '('                        // 5: Unroll the loop: Optionally, anything between the opening and closing shortcode tags
        .             '[^\\[]*+'             // Not an opening bracket
        .             '(?:'
        .                 '\\[(?!\\/\\2\\])' // An opening bracket not followed by the closing shortcode tag
        .                 '[^\\[]*+'         // Not an opening bracket
        .             ')*+'
        .         ')'
        .         '\\[\\/\\2\\]'             // Closing shortcode tag
        .     ')?'
        . ')'
        . '(\\]?)';                          // 6: Optional second closing brocket for escaping shortcodes: [[tag]]
}

Très bien commenté dans le noyau, donc pas grand chose à expliquer ici. La partie clé est ici:

global $shortcode_tags;
$tagnames = array_keys($shortcode_tags);
$tagregexp = join( '|', array_map('preg_quote', $tagnames) );

Ce qui sera essentiellement utilisé plus tard pour faire explicitement correspondre l'un des noms de shortcode enregistrés. Notez qu'aucun traitement de texte n'est effectué à l'exception de preg_quote, donc WP tentera uniquement de faire correspondre les valeurs explicites transmises à add_shortcode en tant que nom de code abrégé. Il semble que les shortcodes sont sensibles à la casse jusqu'à présent.

Nous devons ensuite examiner les indicateurs dans lesquels l'expression régulière construite dans get_shortcode_regex est utilisée. Le bit pertinent de do_shortcode.

"/$pattern/s"

Les barres obliques délimitent l'expression régulière, les lettres qui suivent la barre oblique sont des indicateurs PRCE ou des modificateurs .

Si nous voyions un i, il serait insensible à la casse. Nous avons seulement une s (ce qui signifie qu'un . correspond à tous les caractères, y compris la nouvelle ligne).

Donc, oui, les codes courts sont sensibles à la casse .

9
chrisguitarguy