Passer un paramètre aux fonctions de filtrage et d'action

Par défaut,celan'estpaspossible. Ilexiste des solutions de contournement si vousprocédez de lamanière POO.
Vouspouvez créer une classepour stocker les valeurs que vous souhaitez utiliserplustard.

Exemple:

 /**
 * Stores a value and calls any existing function with this value.
 */
class WPSE_Filter_Storage
{
    /**
     * Filled by __construct(). Used by __call().
     *
     * @type mixed Any type you need.
     */
    private $values;

    /**
     * Stores the values for later use.
     *
     * @param  mixed $values
     */
    public function __construct( $values )
    {
        $this->values = $values;
    }

    /**
     * Catches all function calls except __construct().
     *
     * Be aware: Even if the function is called with just one string as an
     * argument it will be sent as an array.
     *
     * @param  string $callback Function name
     * @param  array  $arguments
     * @return mixed
     * @throws InvalidArgumentException
     */
    public function __call( $callback, $arguments )
    {
        if ( is_callable( $callback ) )
            return call_user_func( $callback, $arguments, $this->values );

        // Wrong function called.
        throw new InvalidArgumentException(
            sprintf( 'File: %1$s<br>Line %2$d<br>Not callable: %3$s',
                __FILE__, __LINE__, print_r( $callback, TRUE )
            )
        );
    }
}
 

Vouspouvezmaintenant appeler la classe avecn'importe quellefonction de votre choix - si lafonctionexiste quelquepart,elle sera appelée avec vosparamètres stockés.

Créons unefonction de démonstration…

 /**
 * Filter function.
 * @param  array $content
 * @param  array $numbers
 * @return string
 */
function wpse_45901_add_numbers( $args, $numbers )
{
    $content = $args[0];
    return $content . '<p>' . implode( ', ', $numbers ) . '</p>';
}
 

…et l'utiliser unefois…

 add_filter(
    'the_content',
    array (
        new WPSE_Filter_Storage( array ( 1, 3, 5 ) ),
        'wpse_45901_add_numbers'
    )
);
 

…et encore…

 add_filter(
    'the_content',
    array (
        new WPSE_Filter_Storage( array ( 2, 4, 6 ) ),
        'wpse_45901_add_numbers'
    )
);
 

Sortie:

La cléest la réutilisabilité : vouspouvez réutiliser la classe (et dansnosexemples également lafonction).

PHP 5.3+

Si vouspouvez utiliser une version 5.3 de PHP ou une versionplus récente,fermetures fera quebeaucoupplusfacile:

 $param1 = '<p>This works!</p>';
$param2 = 'This works too!';

add_action( 'wp_footer', function() use ( $param1 ) {
        echo $param1;
    }, 11 
);
add_filter( 'the_content', function( $content ) use ( $param2 ) {
        return t5_param_test( $content, $param2 );
    }, 12
);

/**
 * Add a string to post content
 *
 * @param  string $content
 * @param  string $string This is $param2 in our example.
 * @return string
 */
function t5_param_test( $content, $string )
{
    return "$content <p><b>$string</b></p>";
}
 

L'inconvénientest que vousne pouvezpas écrire detests unitairespour lesfermetures.  

By default this is not possible. There are workarounds if you do it the OOP way.
You could create a class to store the values you want to use later.

Example:

/**
 * Stores a value and calls any existing function with this value.
 */
class WPSE_Filter_Storage
{
    /**
     * Filled by __construct(). Used by __call().
     *
     * @type mixed Any type you need.
     */
    private $values;

    /**
     * Stores the values for later use.
     *
     * @param  mixed $values
     */
    public function __construct( $values )
    {
        $this->values = $values;
    }

    /**
     * Catches all function calls except __construct().
     *
     * Be aware: Even if the function is called with just one string as an
     * argument it will be sent as an array.
     *
     * @param  string $callback Function name
     * @param  array  $arguments
     * @return mixed
     * @throws InvalidArgumentException
     */
    public function __call( $callback, $arguments )
    {
        if ( is_callable( $callback ) )
            return call_user_func( $callback, $arguments, $this->values );

        // Wrong function called.
        throw new InvalidArgumentException(
            sprintf( 'File: %1$s<br>Line %2$d<br>Not callable: %3$s',
                __FILE__, __LINE__, print_r( $callback, TRUE )
            )
        );
    }
}

Now you can call the class with any function you want – if the function exists somewhere it will be called with your stored parameters.

Let’s create a demo function …

/**
 * Filter function.
 * @param  array $content
 * @param  array $numbers
 * @return string
 */
function wpse_45901_add_numbers( $args, $numbers )
{
    $content = $args[0];
    return $content . '<p>' . implode( ', ', $numbers ) . '</p>';
}

… and use it once …

add_filter(
    'the_content',
    array (
        new WPSE_Filter_Storage( array ( 1, 3, 5 ) ),
        'wpse_45901_add_numbers'
    )
);

… and again …

add_filter(
    'the_content',
    array (
        new WPSE_Filter_Storage( array ( 2, 4, 6 ) ),
        'wpse_45901_add_numbers'
    )
);

Output:

The key is reusability: You can reuse the class (and in our examples also the function).

PHP 5.3+

If you can use a PHP version 5.3 or newer closures will make that much easier:

$param1 = '<p>This works!</p>';
$param2 = 'This works too!';

add_action( 'wp_footer', function() use ( $param1 ) {
        echo $param1;
    }, 11 
);
add_filter( 'the_content', function( $content ) use ( $param2 ) {
        return t5_param_test( $content, $param2 );
    }, 12
);

/**
 * Add a string to post content
 *
 * @param  string $content
 * @param  string $string This is $param2 in our example.
 * @return string
 */
function t5_param_test( $content, $string )
{
    return "$content <p><b>$string</b></p>";
}

The downside is that you cannot write unit tests for closures. 

Créez unefonction avec les argumentsnécessaires qui renvoie unefonction.Passez cettefonction (fonction anonyme,également appeléefermeture) au hook wp.

Montréicipour un avis d'administrateur dans lebackend wordpress.

 public function admin_notice_func( $message = '')
{
$class = 'error';
    $output = sprintf('<div class="%s"><p>%s</p></div>',$class, $message);
    $func = function() use($output) { print $output; };
    return $func;
}
$func = admin_notice_func('Message');
add_action('admin_notices', $func);
 

Create a function with the needed arguments that returns a function. Pass this function (anonymous function, also known as closure) to the wp hook.

Shown here for an admin notice in wordpress backend.

public function admin_notice_func( $message = '')
{
$class = 'error';
    $output = sprintf('<div class="%s"><p>%s</p></div>',$class, $message);
    $func = function() use($output) { print $output; };
    return $func;
}
$func = admin_notice_func('Message');
add_action('admin_notices', $func);

Utilisezphp Fonctions anonymes :

 $my_param = 'my theme name';
add_filter('the_content', function ($content) use ($my_param) {
    //$my_param is available for you now
    if (is_page()) {
        $content = $my_param . ':<br>' . $content;
    }
    return $content;
}, 10, 1);
 

Use php Anonymous functions:

$my_param = 'my theme name';
add_filter('the_content', function ($content) use ($my_param) {
    //$my_param is available for you now
    if (is_page()) {
        $content = $my_param . ':<br>' . $content;
    }
    return $content;
}, 10, 1);

Je sais que letemps apassé,maisj'aieu unproblème avec latransmission demonpropreparamètrejusqu'à ce queje trouve que le 4èmeparamètre dans add_filterest lenombre deparamètrespassés y compris le contenu àmodifier.Donc,si vouspassez 1paramètre supplémentaire,lenombre doit être 2 et non 1 dans votre cas

 add_filter('the_content', 'my_content', 10, 2, $my_param)
 

et en utilisant

 function my_content($content, $my_param) {...}
 

I know time have passed, but I had some problem with passing my own parameter till I found that the the 4th parameter in add_filter is number of passed parameters including the content to change. So if you pass 1 additional parameter, number should be 2 and not 1 in your case

add_filter('the_content', 'my_content', 10, 2, $my_param)

and using

function my_content($content, $my_param) {...}

Lemoyen correct,très courtet leplusefficace detransmettre lenombre d'arguments auxfiltreset actions WPest de @Wesam Alalem ici ,qui utilise lafermeture.

J'ajouterais seulement que vouspourriez le rendreencoreplus clairet beaucoupplusflexibleen séparant laméthode réelle de l'action de lafermeture anonyme. Pour cela,il vous suffit d'appeler laméthode de lafermeture comme suit (exemplemodifié de la réponse @Wesam Alalem).

De cettefaçon,vouspouvez écrire une logique aussi longue ou compliquée que vous le souhaitez lexicalementen dehors de lafermeture que vous utilisezpour appeler l'acteur réel.

 // ... inside some class

private function myMethod() {
    $my_param = 'my theme name';
    add_filter('the_content', function ($content) use ($my_param) {
        // This is the anonymous closure that allows to pass 
        // whatever number of parameters you want via 'use' keyword.
        // This is just oneliner.
        // $my_param is available for you now via 'use' keyword above
        return $this->doThings($content, $my_param);
    }, 10, 2);
}

private function doThings($content, $my_param) {
    // Call here some other method to do some more things
    // however complicated you want.
    $morethings = '';
    if ($content = 'some more things') {
        $morethings = (new MoreClass())->get();
    }
    return $my_param . ':<br>' . $content . $morethings;
}
 

The correct, really short and most efficient way of passing whatever number of arguments to WP filters and actions is from @Wesam Alalem here, that uses the closure.

I would only add that you could make it even clearer and much more flexible by separating the actual doer method from anonymous closure. For this you just call the method from the closure as follows (modified example from @Wesam Alalem answer).

This way you can write as long or complicated logic as you wish lexically outside of the closure you use to call the actual doer.

// ... inside some class

private function myMethod() {
    $my_param = 'my theme name';
    add_filter('the_content', function ($content) use ($my_param) {
        // This is the anonymous closure that allows to pass 
        // whatever number of parameters you want via 'use' keyword.
        // This is just oneliner.
        // $my_param is available for you now via 'use' keyword above
        return $this->doThings($content, $my_param);
    }, 10, 2);
}

private function doThings($content, $my_param) {
    // Call here some other method to do some more things
    // however complicated you want.
    $morethings = '';
    if ($content = 'some more things') {
        $morethings = (new MoreClass())->get();
    }
    return $my_param . ':<br>' . $content . $morethings;
}

Commementionné dans d'autres réponses,passer unparamètre à lafonction de rappeln'estpaspossiblepar défaut. La POOet lafonction anonyme PHP sont des solutions de contournement MAIS :

1. Votre coden'estpeut-êtrepasen POO
2. Vous devrezpeut-être supprimer cefiltre par la suite

Sitelest votre cas,ilexiste une autre solution de contournement à utiliser: utilisez lesfonctions add_filteret apply_filterspour rendre disponible leparamètre que vous vouleztransmettre dans lafonction de rappel:

 // Workaround to "save" parameter to be passed to your callback function.
add_filter( 'pass_param', function() use ( $param ){ return $param; } );

// Hook your function to filter whatever you want to filter.
add_filter( 'actual_filter', 'myCallback' );

// Your callback function that actually filters whatever you want to filter.
function myCallback()
{
   // Get the param that we were not able to pass to this callback function.
   $param = apply_filters( 'pass_param', '' );

   // Do whatever with the workarounded-passed param so it can be used to filter.
   return $param;
}
 

As mentioned on other answers, passing a parameter to the callback function is not possible by default. OOP and PHP anonymous function are workarounds BUT:

1. Your code might not be OOP
2. You might need to remove that filter afterwards

If that is your case, there is another workaround for you to use: make yourself use of the add_filter and apply_filters functions to make that parameter you want to pass available in the callback function:

// Workaround to "save" parameter to be passed to your callback function.
add_filter( 'pass_param', function() use ( $param ){ return $param; } );

// Hook your function to filter whatever you want to filter.
add_filter( 'actual_filter', 'myCallback' );

// Your callback function that actually filters whatever you want to filter.
function myCallback()
{
   // Get the param that we were not able to pass to this callback function.
   $param = apply_filters( 'pass_param', '' );

   // Do whatever with the workarounded-passed param so it can be used to filter.
   return $param;
}

si vous créez votrepropre hook,voici unexemple.

 // lets say we have three parameters  [ https://codex.wordpress.org/Function_Reference/add_filter ]
add_filter( 'filter_name', 'my_func', 10, 3 );
my_func( $first, $second, $third ) {
  // code
}
 

puisimplémentez le hook:

 // [ https://codex.wordpress.org/Function_Reference/apply_filters ]
echo apply_filters( 'filter_name', $first, $second, $third );
 

if you create your own hook, here is example.

// lets say we have three parameters  [ https://codex.wordpress.org/Function_Reference/add_filter ]
add_filter( 'filter_name', 'my_func', 10, 3 );
my_func( $first, $second, $third ) {
  // code
}

then implement hook:

// [ https://codex.wordpress.org/Function_Reference/apply_filters ]
echo apply_filters( 'filter_name', $first, $second, $third );

Vouspouveztoujours utiliserglobal,n'est-cepas?

   global $my_param;
 

You can always use global couldn't you?

  global $my_param;

Bien que vous appeliez directement unefonction,faites-le d'unemanièreplus élégante: passez unefonction anonyme comme rappel.

Parexemple:

J'ai une seulefonctionpourtraduire letitre,le contenuet l'extrait demes articles.Donc,je doispasser à cettefonctionprincipale des argumentsindiquant qui appelle.

 add_filter( 'the_title', function( $text ) { 
    return translate_text( $text, 'title', 'pl' );
});

add_filter( 'the_content', function( $text ) { 
    return translate_text( $text, 'content', 'pl' );
});

add_filter( 'the_excerpt', function( $text ) { 
    return translate_text( $text, 'excerpt', 'pl' );
});
 

Ainsi,lafonctionprincipale translate_text reçoit autant deparamètres queje veux,simplementparce quej'aipassé unefonction anonyme comme rappel.

Despite calling a function directly, do this in a more elegant way: pass an anonymous function as a callback.

For example:

I have a single function to translate the title, content, and excerpt from my posts. So, I need to pass to this main function some arguments saying who is calling.

add_filter( 'the_title', function( $text ) { 
    return translate_text( $text, 'title', 'pl' );
});

add_filter( 'the_content', function( $text ) { 
    return translate_text( $text, 'content', 'pl' );
});

add_filter( 'the_excerpt', function( $text ) { 
    return translate_text( $text, 'excerpt', 'pl' );
});

So, the main function translate_text receives as many parameters as I want, just because I have passed an anonymous function as a callback.

Je suis d'accord que la réponse defuxia ci-dessus donne les approchespréférées. Maispendant quej'essayais de comprendre la solution POO,j'aitrouvé unmoyen de lefaire qui définitpuis désactive à lafois lefiltreet une variableglobale:

 function my_function() {
    
    // Declare the global variable and set it to something
    global $my_global;
    $my_global = 'something';
        
    // Add the filter
    add_filter( 'some_filter', 'my_filter_function' );
    
    // Do whatever it is that you needed the filter for
    echo $filtered_stuff; 
    
    // Remove the filter (So it doesn't mess up something else that executes later)
    remove_filter( 'some_filter', 'my_filter_function' );

    // Unset the global (Because we don't like globals floating around in our code)
    my_unset_function( 'my_global' );
    
}

function my_filter_function( $arg ) {
    
    // Declare the global
    global $my_global

    // Use $my_global to do something with $arg
    $arg = $arg . $my_global;

    return $arg;

}

function my_unset_function( $var_name ) {

    // Declare the global
    $GLOBALS[$var_name];

    // Unset the global
    unset($GLOBALS[$var_name];

}
 

Je suis un développeurnonforméet jetravaille strictement surmespropres sites,veuillez doncprendre cetteesquisse avec ungrain de sel. Celafonctionnepourmoi,mais s'il y a quelque chose quine vapas dans ce queje faisici,je serais reconnaissant à quelqu'un deplus compétent de le signaler.

I agree that fuxia's answer above gives the preferred approaches. But while I was trying to wrap my head around the OOP solution I hit upon a way of doing it that sets and then unsets both the filter and a global variable:

function my_function() {
    
    // Declare the global variable and set it to something
    global $my_global;
    $my_global = 'something';
        
    // Add the filter
    add_filter( 'some_filter', 'my_filter_function' );
    
    // Do whatever it is that you needed the filter for
    echo $filtered_stuff; 
    
    // Remove the filter (So it doesn't mess up something else that executes later)
    remove_filter( 'some_filter', 'my_filter_function' );

    // Unset the global (Because we don't like globals floating around in our code)
    my_unset_function( 'my_global' );
    
}

function my_filter_function( $arg ) {
    
    // Declare the global
    global $my_global

    // Use $my_global to do something with $arg
    $arg = $arg . $my_global;

    return $arg;

}

function my_unset_function( $var_name ) {

    // Declare the global
    $GLOBALS[$var_name];

    // Unset the global
    unset($GLOBALS[$var_name];

}

I'm an untrained developer and I work strictly on my own sites, so please take this sketch with a grain of salt. It works for me, but if there's something wrong with what I'm doing here I'd be grateful if someone more knowledgeable would point it out.

Dansma solution POO,j'ai simplement utilisé une variable demembre de classe quiest appelée dans lafonction de rappel. Dans cetexemple,lepost_titleestfiltrépar unterme de recherche:

 class MyClass
{
  protected $searchterm = '';

  protected function myFunction()
  {
    query = [
      'numberposts' => -1,
      'post_type' => 'my_custom_posttype',
      'post_status' => 'publish'
    ];

    $this->searchterm = 'xyz';
    add_filter('posts_where', [$this, 'searchtermPostsWhere']);
    $myPosts = get_posts($query);
    remove_filter('posts_where', [$this, 'searchtermPostsWhere']);
  }

  public function searchtermPostsWhere($where)
  {
    $where .= ' AND ' . $GLOBALS['wpdb']->posts . '.post_title LIKE \'%' . esc_sql(like_escape($this->searchterm)) . '%\'';
    return $where;
  }
}
 

In my OOP solution I simply used a class member variable which is called in the callback function. In this example the post_title is filtered by a searchterm:

class MyClass
{
  protected $searchterm = '';

  protected function myFunction()
  {
    query = [
      'numberposts' => -1,
      'post_type' => 'my_custom_posttype',
      'post_status' => 'publish'
    ];

    $this->searchterm = 'xyz';
    add_filter('posts_where', [$this, 'searchtermPostsWhere']);
    $myPosts = get_posts($query);
    remove_filter('posts_where', [$this, 'searchtermPostsWhere']);
  }

  public function searchtermPostsWhere($where)
  {
    $where .= ' AND ' . $GLOBALS['wpdb']->posts . '.post_title LIKE \'%' . esc_sql(like_escape($this->searchterm)) . '%\'';
    return $where;
  }
}

J'espéraisfaire lamême chosemais comme cen'estpaspossible,je suppose qu'une solution simple consiste à appeler unefonction différente add_filter('the_content', 'my_content_filter', 10, 1);

alorsmy_content_filter ()peut simplement appelermy_content ()en passant l'argument de son choix.

I was hoping to do the same but since its not possible I guess a simple workaround is to call a different function like add_filter('the_content', 'my_content_filter', 10, 1);

then my_content_filter() can just call my_content() passing any argument it wants.