In a situation where a plugin has encapsulated its methods within a class and then registered a filter or action against one of those methods, how do you remove the action or the filter if you no longer have access to that class’ instance?
For example, suppose you have a plugin that does this:
class MyClass {
function __construct() {
add_action( "plugins_loaded", array( $this, 'my_action' ) );
}
function my_action() {
// do stuff...
}
}
new MyClass();
Noting that I now have no way of accessing the instance, how do I unregister the class? This: remove_action( "plugins_loaded", array( MyClass, 'my_action' ) ); doesn’t seem to be the right approach – at least, didn’t seem to work in my case.
The best thing to do here is to use a static class. The following code should be instructional:
If you run this code from a plugin you should notice that the method of the StaticClass as well as the function will removed from wp_footer.
Whenever a plugin creates a
new MyClass();, it should assign it to a uniquely named variable. That way, the instance of the class is accessible.So if he was doing
$myclass = new MyClass();, then you could do this:This works because plugins are included in the global namespace, so implicit variable declarations in the main body of a plugin are global variables.
If the plugin doesn’t save the identifier of the new class somewhere, then technically, that’s a bug. One of the general principles of Object Oriented Programming is that objects which are not being referenced by some variable somewhere are subject to cleanup or elimination.
Now, PHP in particular doesn’t do this like Java would, because PHP is sorta a half-arsed OOP implementation. The instance variables are just strings with unique object names in them, sort of thing. They only work because of the way the variable function name interaction works with the
->operator. So just doingnew class()can indeed work perfectly, just stupidly. 🙂So, bottom line, never do
new class();. Do$var = new class();and make that $var accessible in some way for other bits to reference it.Edit: years later
One thing I’ve seen a lot of plugins doing is to use something similar to the “Singleton” pattern. They create a getInstance() method to get the single instance of the class. This is probably the best solution I’ve seen. Example plugin:
The first time getInstance() is called, it instantiates the class and saves its pointer. You can use that to hook in actions.
One problem with this is that you can’t use getInstance() inside the constructor if you use such a thing. This is because the new calls the constructor before setting the $instance, so calling getInstance() from the constructor leads to an infinite loop and breaks everything.
One workaround is to not use the constructor (or, at least, not to use getInstance() within it), but to explicitly have an “init” function in the class to set up your actions and such. Like this:
With something like this, at the end of the file, after the class has been all defined and such, instantiating the plugin becomes as simple as this:
Init starts to add your actions, and in so doing it calls getInstance(), which instantiates the class and makes sure only one of them exists. If you don’t have an init function, you would do this to instantiate the class initially instead:
To address the original question, removing that action hook from the outside (aka, in another plugin) can then be done like so:
Put that in something hooked to the
plugins_loadedaction hook and it’ll undo the action being hooked by the original plugin.2 small PHP functions for allow removing filter/action with “anonymous” class :
https://github.com/herewithme/wp-filters-extras/
Here’s a extensively documented function I created for removing filters when you don’t have access to the class object (works with WordPress 1.2+, including 4.7+):
https://gist.github.com/tripflex/c6518efc1753cf2392559866b4bd1a53
Above solutions look like outdated, had to write my own…
In cases like this the WordPress adds a hash (unique id) to the function name and stores it in the global
$wp_filtervariable. So if you useremove_filterfunction nothing will happen. Even if you add the class name to the function name likeremove_filter('plugins_loaded', ['MyClass', 'my_action']).All you can is to remove all the
my_actionhooks from the global$wp_filtervariable manually.Here is the function to do this:
use it like:
This is not a generic answer, but one specific to Avada theme and WooCommerce, which I think other people may find helpful:
This function based on @Digerkam answer. Added compare if
$def['function'][0]is string and it’s finally worked for me.Also using
$wp_filter[$tag]->remove_filter()should make it more stable.Example usage:
Exact match
Any priority
Any Class and any priority