remove_action sau remove_filter cu clase externe?

Ori de câte ori un plugin creează un new MyClass();, ar trebui să îl atribuie unei variabile cu un nume unic. În acest fel, instanța clasei este accesibilă.

Deci, dacă ar fi făcut $myclass = new MyClass();, atunci ai putea face asta:

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

Aceasta funcționează pentru că pluginurile sunt incluse în namespace-ul global, așadar declarațiile implicite de variabile în corpul principal al unui plugin sunt variabile globale.

Dacă pluginul nu salvează identificatorul noii clase undeva, atunci, tehnic vorbind, este un bug. Unul dintre principiile generale ale Programării Orientate pe Obiecte este că obiectele care nu sunt referențiate de o variabilă undeva sunt supuse curățării sau eliminării.

Acum, PHP în special nu face asta așa cum ar face Java, deoarece PHP este o implementare cam pe jumătate a OOP. Variabilele de instanță sunt doar șiruri de caractere cu nume unice de obiecte în ele, cam așa. Ele funcționează doar datorită modului în care interacțiunea numelui variabilei funcționează cu operatorul ->. Deci, doar făcând new class() poate funcționa perfect, dar stupid. :)

Așadar, concluzia este să nu faci niciodată new class();. Fă $var = new class(); și asigură-te că acea variabilă $var este accesibilă într-un fel pentru alte părți să o poată referenția.

Editare: ani mai târziu

Un lucru pe care l-am văzut la multe pluginuri este utilizarea unui model similar cu "Singleton". Ele creează o metodă getInstance() pentru a obține singura instanță a clasei. Aceasta este probabil cea mai bună soluție pe care am văzut-o. Exemplu de plugin:

class ExamplePlugin
{
    protected static $instance = NULL;

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

Prima dată când getInstance() este apelată, instantiază clasa și salvează pointerul acesteia. Poți folosi asta pentru a lega acțiuni.

O problemă cu aceasta este că nu poți folosi getInstance() în interiorul constructorului dacă folosești așa ceva. Acest lucru se întâmplă pentru că "new" apelează constructorul înainte de a seta $instance, așadar apelarea getInstance() din constructor duce la o buclă infinită și strică totul.

O soluție este să nu folosești constructorul (sau, cel puțin, să nu folosești getInstance() în el), ci să ai în mod explicit o funcție "init" în clasă pentru a configura acțiunile tale și altele. Ca aceasta:

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

Cu ceva de genul acesta, la sfârșitul fișierului, după ce clasa a fost definită complet, instantierea pluginului devine la fel de simplă ca aceasta:

ExamplePlugin::init();

Funcția init începe să adauge acțiunile tale, iar în acest proces apelează getInstance(), care instantiază clasa și se asigură că există doar una singură. Dacă nu ai o funcție init, ai face asta pentru a instantia clasa inițial:

ExamplePlugin::getInstance();

Pentru a răspunde la întrebarea inițială, eliminarea acelui action hook din exterior (adică, din alt plugin) poate fi făcută astfel:

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

Pune asta în ceva legat de action hook-ul plugins_loaded și va anula acțiunea legată de pluginul original.

Cel mai bun lucru de făcut aici este să folosești o clasă statică. Următorul cod ar trebui să fie instructiv:

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' );

Dacă rulezi acest cod dintr-un plugin, ar trebui să observi că metoda StaticClass, precum și funcția, vor fi eliminate din wp_footer.

2 funcții PHP mici pentru a permite eliminarea filtrelor/acțiunilor cu clase "anonime": https://github.com/herewithme/wp-filters-extras/

Soluțiile de mai sus par învechite, a trebuit să scriu propria mea soluție...

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]) ;
                            }
                        }
                    }
                }
            }
        }
    }
}

În astfel de cazuri, WordPress adaugă un hash (ID unic) numelui funcției și îl stochează în variabila globală $wp_filter. Așadar, dacă folosești funcția remove_filter, nu se va întâmpla nimic. Chiar dacă adaugi numele clasei înaintea numelui funcției, ca în remove_filter('plugins_loaded', ['MyClass', 'my_action']). Tot ce poți face este să elimini manual toate hook-urile my_action din variabila globală $wp_filter.

Iată funcția care face asta:

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 );
    }
}

Folosește-o astfel:

my_remove_filter('plugins_loaded', 'my_action');

Acesta nu este un răspuns generic, ci unul specific pentru tema Avada și WooCommerce, despre care cred că și alți oameni ar putea să-l găsească util:

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' );

Am găsit acest Gist care făcea exact ce doream:

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) {
            /**
             * Permite doar notația de tip array și string pentru hook-uri, deoarece
             * căutăm să eliminăm o metodă exactă a unei clase. În plus,
             * metoda clasei este transmisă ca string.
             */
            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;
}

Această funcție este bazată pe răspunsul lui @Digerkam. Am adăugat o verificare suplimentară pentru a compara dacă $def['function'][0] este un șir de caractere și în final a funcționat pentru mine.

De asemenea, utilizarea $wp_filter[$tag]->remove_filter() ar trebui să o facă mai stabilă.

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;
}

Exemplu de utilizare:

Potrivire exactă

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

Orice prioritate

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

Orice clasă și orice prioritate

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