¿remove_action o remove_filter con clases externas?

Cuando un plugin crea un new MyClass();, debería asignarlo a una variable con un nombre único. De esta manera, la instancia de la clase es accesible.

Así que si estaba haciendo $myclass = new MyClass();, entonces podrías hacer esto:

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

Esto funciona porque los plugins se incluyen en el espacio de nombres global, por lo que las declaraciones implícitas de variables en el cuerpo principal de un plugin son variables globales.

Si el plugin no guarda el identificador de la nueva clase en algún lugar, entonces técnicamente, eso es un error. Uno de los principios generales de la Programación Orientada a Objetos es que los objetos que no están siendo referenciados por alguna variable en algún lugar están sujetos a limpieza o eliminación.

Ahora, PHP en particular no hace esto como lo haría Java, porque PHP es una implementación de POO a medias. Las variables de instancia son simplemente cadenas con nombres de objetos únicos, algo así. Solo funcionan debido a la forma en que la interacción del nombre de la función variable funciona con el operador ->. Así que simplemente hacer new class() puede funcionar perfectamente, aunque de manera estúpida. :)

Así que, en resumen, nunca hagas new class();. Haz $var = new class(); y haz que esa $var sea accesible de alguna manera para que otras partes puedan referenciarla.

Edición: años después

Algo que he visto hacer mucho a los plugins es usar algo similar al patrón "Singleton". Crean un método getInstance() para obtener la única instancia de la clase. Esta es probablemente la mejor solución que he visto. Ejemplo de plugin:

class ExamplePlugin
{
    protected static $instance = NULL;

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

La primera vez que se llama a getInstance(), instancia la clase y guarda su puntero. Puedes usar eso para enganchar acciones.

Un problema con esto es que no puedes usar getInstance() dentro del constructor si usas algo así. Esto se debe a que new llama al constructor antes de establecer $instance, por lo que llamar a getInstance() desde el constructor lleva a un bucle infinito y rompe todo.

Una solución es no usar el constructor (o al menos no usar getInstance() dentro de él), sino tener explícitamente una función "init" en la clase para configurar tus acciones y demás. Algo así:

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

Con algo así, al final del archivo, después de que la clase ha sido definida y todo, instanciar el plugin se vuelve tan simple como esto:

ExamplePlugin::init();

Init comienza a añadir tus acciones, y al hacerlo llama a getInstance(), que instancia la clase y se asegura de que solo exista una de ellas. Si no tienes una función init, harías esto para instanciar la clase inicialmente en su lugar:

ExamplePlugin::getInstance();

Para abordar la pregunta original, eliminar ese gancho de acción desde fuera (es decir, en otro plugin) puede hacerse así:

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

Pon eso en algo enganchado al gancho de acción plugins_loaded y deshará la acción enganchada por el plugin original.

Lo mejor que puedes hacer aquí es usar una clase estática. El siguiente código debería ser instructivo:

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

Si ejecutas este código desde un plugin, deberías notar que el método de la StaticClass así como la función serán eliminados de wp_footer.

2 pequeñas funciones PHP para permitir eliminar filtros/acciones con clases "anónimas": https://github.com/herewithme/wp-filters-extras/

Las soluciones anteriores parecen estar desactualizadas, tuve que escribir mi propia función...

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

En casos como este, WordPress añade un hash (identificador único) al nombre de la función y lo almacena en la variable global $wp_filter. Por lo tanto, si utilizas la función remove_filter, no ocurrirá nada. Incluso si añades el nombre de la clase al nombre de la función como remove_filter('plugins_loaded', ['MiClase', 'mi_accion']).

Todo lo que puedes hacer es eliminar manualmente todos los hooks mi_accion de la variable global $wp_filter.

Aquí está la función para hacer esto:

function mi_eliminar_filtro($tag, $nombre_funcion, $prioridad = 10){

    global $wp_filter;

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

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

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

        }, ARRAY_FILTER_USE_BOTH );
    }
}

Úsala así:

mi_eliminar_filtro('plugins_loaded', 'mi_accion');

Esta no es una respuesta genérica, sino específica para el tema Avada y WooCommerce, que creo que otras personas pueden encontrar útil:

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

Encontré este Gist que hacía exactamente lo que necesitaba:

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) {
            /**
             * Permitir solo notación de array y string para los hooks, ya que
             * estamos buscando eliminar un método exacto de una clase. Y el
             * método de la clase se pasa como string de todas formas.
             */
            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;
}

Esta función está basada en la respuesta de @Digerkam. Se añadió una comparación para verificar si $def['function'][0] es una cadena y finalmente funcionó para mí.

También, usar $wp_filter[$tag]->remove_filter() debería hacerla más estable.

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

Ejemplo de uso:

Coincidencia exacta

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

Cualquier prioridad

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

Cualquier clase y cualquier prioridad

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