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.


Top ↑

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 ↑

More Information More Information

  • This function is an alias to remove_filter().
  • See also add_action() and add_filter().
  • To remove a hook, the $function_to_remove and $priority arguments must match when the hook was added. This goes for both filters and actions. No warning will be given on removal failure.

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

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

    <?php
    add_action( 'wp_head', 'remove_my_action' );
    function remove_my_action() {
    	remove_action( 'wp_footer', 'function_being_removed' );
    }
    ?>
    

    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 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 Bart Kuijper

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

    Important: To remove a hook, the $function_to_remove and $priority arguments 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 5 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.