remove_action( string $tag, callable $function_to_remove, int $priority = 10 )

Removes a function from a specified action hook.


Description Description

This function removes a function attached to a specified action hook. This method can be used to remove default functions attached to a specific filter hook and possibly replace them with a substitute.


Parameters Parameters

$tag

(string) (Required) The action hook to which the function to be removed is hooked.

$function_to_remove

(callable) (Required) The name of the function which should be removed.

$priority

(int) (Optional) The priority of the function.

Default value: 10


Top ↑

Return Return

(bool) Whether the function is removed.


Top ↑

Source Source

File: wp-includes/plugin.php

function remove_action( $tag, $function_to_remove, $priority = 10 ) {
	return remove_filter( $tag, $function_to_remove, $priority );
}

Top ↑

Changelog Changelog

Changelog
Version Description
1.2.0 Introduced.


Top ↑

User Contributed Notes User Contributed Notes

  1. Skip to note 1 content
    Contributed by Codex

    This function is identical to the remove_filter() function.

     <?php remove_action( $tag, $function_to_remove, $priority ); ?> 
    

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

    global $my_class;
    remove_action( 'the_content', array( $my_class, 'class_filter_function' ) );
    

    It is also worth noting that you may need to prioritise the removal of the action to a hook that occurs after the action is added. You cannot successfully remove the action before it has been added.

  2. Skip to note 2 content
    Contributed by tripflex

    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 https://make.wordpress.org/core/2016/09/08/wp_hook-next-generation-actions-and-filters/
    		 */
    		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

  3. Skip to note 4 content
    Contributed by Sushil Adhikari
    /**
    * 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 );
    } 

You must log in before being able to contribute a note or feedback.