remove_action o remove_filter con classi esterne?

Ogni volta che un plugin crea un new MyClass();, dovrebbe assegnarlo a una variabile con un nome univoco. In questo modo, l'istanza della classe è accessibile.

Quindi, se stava facendo $myclass = new MyClass();, allora potresti fare questo:

global $myclass;
remove_action( 'wp_footer', array( $myclass, 'my_action' ) );

Questo funziona perché i plugin sono inclusi nello spazio dei nomi globale, quindi le dichiarazioni implicite di variabili nel corpo principale di un plugin sono variabili globali.

Se il plugin non salva l'identificatore della nuova classe da qualche parte, allora tecnicamente è un bug. Uno dei principi generali della programmazione orientata agli oggetti è che gli oggetti che non sono referenziati da qualche variabile da qualche parte sono soggetti a pulizia o eliminazione.

Ora, PHP in particolare non fa questo come farebbe Java, perché PHP è un'implementazione OOP un po' approssimativa. Le variabili di istanza sono semplicemente stringhe con nomi di oggetti univoci, più o meno. Funzionano solo grazie al modo in cui l'interazione del nome della variabile funziona con l'operatore ->. Quindi fare semplicemente new class() può effettivamente funzionare perfettamente, anche se in modo stupido. :)

Quindi, in sintesi, non fare mai new class();. Fai $var = new class(); e rendi quella $var accessibile in qualche modo per consentire ad altre parti di riferirsi ad essa.

Modifica: anni dopo

Una cosa che ho visto fare a molti plugin è utilizzare qualcosa simile al pattern "Singleton". Creano un metodo getInstance() per ottenere l'unica istanza della classe. Questa è probabilmente la soluzione migliore che ho visto. Esempio di plugin:

class ExamplePlugin
{
    protected static $instance = NULL;

    public static function getInstance() {
        NULL === self::$instance and self::$instance = new self;
        return self::$instance;
    }
}

La prima volta che getInstance() viene chiamato, istanzia la classe e salva il suo puntatore. Puoi usarlo per agganciare azioni.

Un problema con questo è che non puoi usare getInstance() all'interno del costruttore se usi una cosa del genere. Questo perché il new chiama il costruttore prima di impostare $instance, quindi chiamare getInstance() dal costruttore porta a un ciclo infinito e rompe tutto.

Una soluzione alternativa è non usare il costruttore (o almeno non usare getInstance() al suo interno), ma avere esplicitamente una funzione "init" nella classe per impostare le tue azioni e simili. In questo modo:

public static function init() {
    add_action( 'wp_footer', array( ExamplePlugin::getInstance(), 'my_action' ) );
}

Con qualcosa del genere, alla fine del file, dopo che la classe è stata definita e tutto il resto, istanziare il plugin diventa semplice come questo:

ExamplePlugin::init();

Init inizia ad aggiungere le tue azioni, e così facendo chiama getInstance(), che istanzia la classe e assicura che ne esista solo una. Se non hai una funzione init, faresti questo per istanziare la classe inizialmente:

ExamplePlugin::getInstance();

Per rispondere alla domanda originale, rimuovere quell'hook dell'azione dall'esterno (ovvero, in un altro plugin) può quindi essere fatto così:

remove_action( 'wp_footer', array( ExamplePlugin::getInstance(), 'my_action' ) );

Metti questo in qualcosa agganciato all'hook dell'azione plugins_loaded e annullerà l'azione agganciata dal plugin originale.

La cosa migliore da fare qui è utilizzare una classe statica. Il seguente codice dovrebbe essere istruttivo:

class MyClass {
    function __construct() {
        add_action( 'wp_footer', array( $this, 'my_action' ) );
    }
    function my_action() {
        print '<h1>' . __class__ . ' - ' . __function__ . '</h1>';
    }
}
new MyClass();


class MyStaticClass {
    public static function init() {
        add_action( 'wp_footer', array( __class__, 'my_action' ) );
    }
    public static function my_action() {
        print '<h1>' . __class__ . ' - ' . __function__ . '</h1>';
    }
}
MyStaticClass::init();

function my_wp_footer() {
    print '<h1>my_wp_footer()</h1>';
}
add_action( 'wp_footer', 'my_wp_footer' );

function mfields_test_remove_actions() {
    remove_action( 'wp_footer', 'my_wp_footer' );
    remove_action( 'wp_footer', array( 'MyClass', 'my_action' ), 10 );
    remove_action( 'wp_footer', array( 'MyStaticClass', 'my_action' ), 10 );
}
add_action( 'wp_head', 'mfields_test_remove_actions' );

Se esegui questo codice da un plugin, dovresti notare che il metodo della StaticClass così come la funzione verranno rimossi da wp_footer.

2 piccole funzioni PHP per permettere la rimozione di filtri/azioni con classi "anonime": https://github.com/herewithme/wp-filters-extras/

Le soluzioni precedenti sembrano obsolete, ho dovuto scrivere la mia...

function remove_class_action ($action,$class,$method) {
    global $wp_filter ;
    if (isset($wp_filter[$action])) {
        $len = strlen($method) ;
        foreach ($wp_filter[$action] as $pri => $actions) {
            foreach ($actions as $name => $def) {
                if (substr($name,-$len) == $method) {
                    if (is_array($def['function'])) {
                        if (get_class($def['function'][0]) == $class) {
                            if (is_object($wp_filter[$action]) && isset($wp_filter[$action]->callbacks)) {
                                unset($wp_filter[$action]->callbacks[$pri][$name]) ;
                            } else {
                                unset($wp_filter[$action][$pri][$name]) ;
                            }
                        }
                    }
                }
            }
        }
    }
}

In casi come questo WordPress aggiunge un hash (ID univoco) al nome della funzione e lo memorizza nella variabile globale $wp_filter. Quindi, se usi la funzione remove_filter non accadrà nulla. Anche se aggiungi il nome della classe al nome della funzione come remove_filter('plugins_loaded', ['MyClass', 'my_action']).
Tutto ciò che puoi fare è rimuovere manualmente tutti gli hook my_action dalla variabile globale $wp_filter.

Ecco la funzione per farlo:

function my_remove_filter($tag, $function_name, $priority = 10){

    global $wp_filter;

    if( isset($wp_filter[$tag]->callbacks[$priority]) and !empty($wp_filter[$tag]->callbacks[$priority]) ){

        $wp_filter[$tag]->callbacks[$priority] = array_filter($wp_filter[$tag]->callbacks[$priority], function($v, $k) use ($function_name){

            return ( stripos($k, $function_name) === false );

        }, ARRAY_FILTER_USE_BOTH );
    }
}

Usala così:

my_remove_filter('plugins_loaded', 'my_action');

Questa non è una risposta generica, ma specifica per il tema Avada e WooCommerce, che penso possa essere utile ad altre persone:

function remove_woo_commerce_hooks() {
    global $avada_woocommerce;
    remove_action( 'woocommerce_single_product_summary', array( $avada_woocommerce, 'add_product_border' ), 19 );
}
add_action( 'after_setup_theme', 'remove_woo_commerce_hooks' );

Ho trovato questa Gist che faceva esattamente quello che volevo:

function remove_class_hook( $tag, $class_name = '', $method_name = '', $priority = 10 ) {
    global $wp_filter;
    $is_hook_removed = false;
    if ( ! empty( $wp_filter[ $tag ]->callbacks[ $priority ] ) ) {
        $methods = array_filter(wp_list_pluck(
            $wp_filter[ $tag ]->callbacks[ $priority ],
            'function'
        ), function ($method) {
            /**
             * Consenti solo la notazione array e stringa per gli hook, visto che
             * stiamo cercando di rimuovere un metodo specifico di una classe comunque. E il
             * metodo della classe viene passato come stringa in ogni caso.
             */
            return is_string($method) || is_array($method);
        });
        $found_hooks = ! empty( $methods ) ? wp_list_filter( $methods, array( 1 => $method_name ) ) : array();
        foreach( $found_hooks as $hook_key => $hook ) {
            if ( ! empty( $hook[0] ) && is_object( $hook[0] ) && get_class( $hook[0] ) === $class_name ) {
                $wp_filter[ $tag ]->remove_filter( $tag, $hook, $priority );
                $is_hook_removed = true;
            }
        }
    }
    return $is_hook_removed;
}

Questa funzione si basa sulla risposta di @Digerkam. Ho aggiunto un controllo per verificare se $def['function'][0] è una stringa e alla fine ha funzionato per me.

Inoltre, utilizzare $wp_filter[$tag]->remove_filter() dovrebbe renderla più stabile.

function remove_class_action($tag, $class = '', $method, $priority = null) : bool {
    global $wp_filter;
    if (isset($wp_filter[$tag])) {
        $len = strlen($method);

        foreach($wp_filter[$tag] as $_priority => $actions) {

            if ($actions) {
                foreach($actions as $function_key => $data) {

                    if ($data) {
                        if (substr($function_key, -$len) == $method) {

                            if ($class !== '') {
                                $_class = '';
                                if (is_string($data['function'][0])) {
                                    $_class = $data['function'][0];
                                }
                                elseif (is_object($data['function'][0])) {
                                    $_class = get_class($data['function'][0]);
                                }
                                else {
                                    return false;
                                }

                                if ($_class !== '' && $_class == $class) {
                                    if (is_numeric($priority)) {
                                        if ($_priority == $priority) {
                                            //if (isset( $wp_filter->callbacks[$_priority][$function_key])) {}
                                            return $wp_filter[$tag]->remove_filter($tag, $function_key, $_priority);
                                        }
                                    }
                                    else {
                                        return $wp_filter[$tag]->remove_filter($tag, $function_key, $_priority);
                                    }
                                }
                            }
                            else {
                                if (is_numeric($priority)) {
                                    if ($_priority == $priority) {
                                        return $wp_filter[$tag]->remove_filter($tag, $function_key, $_priority);
                                    }
                                }
                                else {
                                    return $wp_filter[$tag]->remove_filter($tag, $function_key, $_priority);
                                }
                            }

                        }
                    }
                }
            }
        }

    }

    return false;
}

Esempio di utilizzo:

Corrispondenza esatta

add_action('plugins_loaded', function() {
    remove_class_action('plugins_loaded', 'MyClass', 'my_action', 0);
});

Qualsiasi priorità

add_action('plugins_loaded', function() {
    remove_class_action('plugins_loaded', 'MyClass', 'my_action');
});

Qualsiasi classe e qualsiasi priorità

add_action('plugins_loaded', function() {
    remove_class_action('plugins_loaded', '', 'my_action');
});