User Contributed Notes

1. Skip to note 7 content

   
   Codex
   
   
   11 years ago
   

   You must log in to vote on the helpfulness of this noteVote results for this note: 13You must log in to vote on the helpfulness of this note

   This function is identical to the remove_filter() function.

   remove_action() must be called inside a function and cannot be called directly in your plugin or theme.

   If an action has been added from within a class, for example by a plugin, removing it will require accessing the class through a variable that holds the class instance.

   add_action( 'wp_head', 'remove_my_class_action' );
   function remove_my_class_action() {
   	global $my_class;
   	remove_action( 'wp_footer', array( $my_class, 'class_function_being_removed' ) );
   }

   Unless the function is static in which case you could call the class and function directly.

   add_action( 'wp_head', 'remove_my_class_action' );
   function remove_my_class_action() {
   	remove_action( 'wp_footer', array( 'My_Class', 'class_function_being_removed' ) );
   }

   Notes:

   1. You may need to prioritize the removal of the action to a hook that occurs after the action is added.
   2. You cannot successfully remove the action before it has been added.
   3. You also cannot remove an action after it has been run.
   4. To remove an action, the priority must match the priority with the function that was originally added.

2. Skip to note 8 content

   
   tripflex
   
   
   9 years ago
   

   You must log in to vote on the helpfulness of this noteVote results for this note: 11You must log in to vote on the helpfulness of this note

   If you need to be able to remove an action/filter for a class object you do not have access to, you can do so with this function (which includes support for WordPress 4.7+):

   /**
    * Make sure the function does not exist before defining it
    */
   if( ! function_exists( 'remove_class_filter' ) ){
   	/**
   	 * Remove Class Filter Without Access to Class Object
   	 *
   	 * In order to use the core WordPress remove_filter() on a filter added with the callback
   	 * to a class, you either have to have access to that class object, or it has to be a call
   	 * to a static method.  This method allows you to remove filters with a callback to a class
   	 * you don't have access to.
   	 *
   	 * Works with WordPress 1.2+ (4.7+ support added 9-19-2016)
   	 * Updated 2-27-2017 to use internal WordPress removal for 4.7+ (to prevent PHP warnings output)
   	 *
   	 * @param string $tag         Filter to remove
   	 * @param string $class_name  Class name for the filter's callback
   	 * @param string $method_name Method name for the filter's callback
   	 * @param int    $priority    Priority of the filter (default 10)
   	 *
   	 * @return bool Whether the function is removed.
   	 */
   	function remove_class_filter( $tag, $class_name = '', $method_name = '', $priority = 10 ) {
   		global $wp_filter;
   		// Check that filter actually exists first
   		if ( ! isset( $wp_filter[ $tag ] ) ) {
   			return FALSE;
   		}
   		/**
   		 * If filter config is an object, means we're using WordPress 4.7+ and the config is no longer
   		 * a simple array, rather it is an object that implements the ArrayAccess interface.
   		 *
   		 * To be backwards compatible, we set $callbacks equal to the correct array as a reference (so $wp_filter is updated)
   		 *
   		 * @see <a href="https://make.wordpress.org/core/2016/09/08/wp_hook-next-generation-actions-and-filters/" rel="nofollow ugc">https://make.wordpress.org/core/2016/09/08/wp_hook-next-generation-actions-and-filters/</a>
   		 */
   		if ( is_object( $wp_filter[ $tag ] ) && isset( $wp_filter[ $tag ]->callbacks ) ) {
   			// Create $fob object from filter tag, to use below
   			$fob       = $wp_filter[ $tag ];
   			$callbacks = &$wp_filter[ $tag ]->callbacks;
   		} else {
   			$callbacks = &$wp_filter[ $tag ];
   		}
   		// Exit if there aren't any callbacks for specified priority
   		if ( ! isset( $callbacks[ $priority ] ) || empty( $callbacks[ $priority ] ) ) {
   			return FALSE;
   		}
   		// Loop through each filter for the specified priority, looking for our class & method
   		foreach ( (array) $callbacks[ $priority ] as $filter_id => $filter ) {
   			// Filter should always be an array - array( $this, 'method' ), if not goto next
   			if ( ! isset( $filter['function'] ) || ! is_array( $filter['function'] ) ) {
   				continue;
   			}
   			// If first value in array is not an object, it can't be a class
   			if ( ! is_object( $filter['function'][0] ) ) {
   				continue;
   			}
   			// Method doesn't match the one we're looking for, goto next
   			if ( $filter['function'][1] !== $method_name ) {
   				continue;
   			}
   			// Method matched, now let's check the Class
   			if ( get_class( $filter['function'][0] ) === $class_name ) {
   				// WordPress 4.7+ use core remove_filter() since we found the class object
   				if ( isset( $fob ) ) {
   					// Handles removing filter, reseting callback priority keys mid-iteration, etc.
   					$fob->remove_filter( $tag, $filter['function'], $priority );
   				} else {
   					// Use legacy removal process (pre 4.7)
   					unset( $callbacks[ $priority ][ $filter_id ] );
   					// and if it was the only filter in that priority, unset that priority
   					if ( empty( $callbacks[ $priority ] ) ) {
   						unset( $callbacks[ $priority ] );
   					}
   					// and if the only filter for that tag, set the tag to an empty array
   					if ( empty( $callbacks ) ) {
   						$callbacks = array();
   					}
   					// Remove this filter from merged_filters, which specifies if filters have been sorted
   					unset( $GLOBALS['merged_filters'][ $tag ] );
   				}
   				return TRUE;
   			}
   		}
   		return FALSE;
   	}
   }
   /**
    * Make sure the function does not exist before defining it
    */
   if( ! function_exists( 'remove_class_action') ){
   	/**
   	 * Remove Class Action Without Access to Class Object
   	 *
   	 * In order to use the core WordPress remove_action() on an action added with the callback
   	 * to a class, you either have to have access to that class object, or it has to be a call
   	 * to a static method.  This method allows you to remove actions with a callback to a class
   	 * you don't have access to.
   	 *
   	 * Works with WordPress 1.2+ (4.7+ support added 9-19-2016)
   	 *
   	 * @param string $tag         Action to remove
   	 * @param string $class_name  Class name for the action's callback
   	 * @param string $method_name Method name for the action's callback
   	 * @param int    $priority    Priority of the action (default 10)
   	 *
   	 * @return bool               Whether the function is removed.
   	 */
   	function remove_class_action( $tag, $class_name = '', $method_name = '', $priority = 10 ) {
   		remove_class_filter( $tag, $class_name, $method_name, $priority );
   	}
   }

   https://gist.github.com/tripflex/c6518efc1753cf2392559866b4bd1a53

   • This is a great function and works a charm. Thanks to this.

     ProServ 4 years ago

3. Skip to note 9 content

   
   Bart Kuijper
   
   
   6 years ago
   

   You must log in to vote on the helpfulness of this noteVote results for this note: 4You must log in to vote on the helpfulness of this note

   The old codex contains this very important note that unfortunately didn’t make it into this page:

   Important: To remove a hook, the <em>$function_to_remove</em> and <em>$priority arguments</em> must match when the hook was added. This goes for both filters and actions. No warning will be given on removal failure.

4. Skip to note 10 content

   
   Anthony Hortin
   
   
   9 years ago
   

   You must log in to vote on the helpfulness of this noteVote results for this note: 2You must log in to vote on the helpfulness of this note

   Related:

   do_action()
   add_action()

5. Skip to note 11 content

   
   Sushil Adhikari
   
   
   8 years ago
   

   You must log in to vote on the helpfulness of this noteVote results for this note: 0You must log in to vote on the helpfulness of this note

   /**
   * Different way to remove hooks declare inside class
   */
   
   class MyClass {
   	
   	/**
   	 * The single instance of the class.
   	 * 
   	 */
   	protected static $_instance = null;
   
   	/**
   	 * Main plugins instance
   	 *
   	 * Ensures only one instance of this class
   	 * Its always good practice to user single instance of the class so we can modify hooks initialized on this class
   	 */
   	public static function get_instance() {
   		if ( is_null( self::$_instance ) ) {
   			self::$_instance = new self();
   		}
   		return self::$_instance;
   	}
   
   	/**
   	* Register hoooks
   	*/
   	public function __construct() {
   		/*
   		* @hooked add_custom_body_class 10
   		*/
   		add_filter( 'body_class', array( $this, 'add_custom_body_class' ) );
   		/*
   		* @hooked static static_body_class - 20
   		*/
   		add_filter( 'body_class', array( 'MyClass', 'static_body_class' ),  20 );
   	}
   	/**
   	* @return array of class
   	*/
   	public function add_custom_body_class( $class ) {
   		$class[ 'custom_class' ] = 'customClass';
   		return $class;
   	}
   	/**
   	* @return array of class
   	*/
   	static function static_body_class( $class ) {
   		$class[ 'static_custom_class' ] = 'staticCustomClass';
   		return $class;
   	}
   }
   $my_class = MyClass::get_instance();
   
   /**
   * Remove methods: add_custom_body_class attached to body class
   */
   add_action( 'wp_head', 'themeslug_remove_hooks' );
   function themeslug_remove_hooks() {
   	/**
   	* Always use same class object, this can be achieve by restricting multiple instance of the class
   	*/
   	$is_action_removed = remove_action( 'body_class', array( MyClass::get_instance(), 'add_custom_body_class'  ) );
   	/**
   	* Remove static method class by using class name with same priority 20
   	*/
   	$is_action_removed = remove_action( 'body_class', array( 'MyClass', 'static_body_class'  ), 20 );
   } 

6. Skip to note 12 content

   
   geigel
   
   
   1 year ago
   

   You must log in to vote on the helpfulness of this noteVote results for this note: 0You must log in to vote on the helpfulness of this note

   It seems (for the moment) like there is no easy way to specifically target an action for removal that relies on an anonymous function. A blanket removal will remove it if using the default priority, but it also wipes out other actions that have hooked into it. Additional discussion regarding some solutions people have been able to put together is found here: https://wordpress.stackexchange.com/questions/137688/remove-actions-filters-added-via-anonymous-functions