_wp_filter_build_unique_id

The timeline below displays how wordpress function _wp_filter_build_unique_id has changed across different WordPress versions. If a version is not listed, refer to the next available version below.

WordPress Version: 6.3

/**
 * Builds a unique string ID for a hook callback function.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @since 5.3.0 Removed workarounds for spl_object_hash().
 *              `$hook_name` and `$priority` are no longer used,
 *              and the function always returns a string.
 *
 * @access private
 *
 * @param string                $hook_name Unused. The name of the filter to build ID for.
 * @param callable|string|array $callback  The callback to generate ID for. The callback may
 *                                         or may not exist.
 * @param int                   $priority  Unused. The order in which the functions
 *                                         associated with a particular action are executed.
 * @return string Unique function ID for usage as array key.
 */
function _wp_filter_build_unique_id($hook_name, $callback, $priority)
{
    if (is_string($callback)) {
        return $callback;
    }
    if (is_object($callback)) {
        // Closures are currently implemented as objects.
        $callback = array($callback, '');
    } else {
        $callback = (array) $callback;
    }
    if (is_object($callback[0])) {
        // Object class calling.
        return spl_object_hash($callback[0]) . $callback[1];
    } elseif (is_string($callback[0])) {
        // Static calling.
        return $callback[0] . '::' . $callback[1];
    }
}

WordPress Version: 5.9

/**
 * Builds Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @since 5.3.0 Removed workarounds for spl_object_hash().
 *              `$hook_name` and `$priority` are no longer used,
 *              and the function always returns a string.
 *
 * @access private
 *
 * @param string                $hook_name Unused. The name of the filter to build ID for.
 * @param callable|string|array $callback  The callback to generate ID for. The callback may
 *                                         or may not exist.
 * @param int                   $priority  Unused. The order in which the functions
 *                                         associated with a particular action are executed.
 * @return string Unique function ID for usage as array key.
 */
function _wp_filter_build_unique_id($hook_name, $callback, $priority)
{
    if (is_string($callback)) {
        return $callback;
    }
    if (is_object($callback)) {
        // Closures are currently implemented as objects.
        $callback = array($callback, '');
    } else {
        $callback = (array) $callback;
    }
    if (is_object($callback[0])) {
        // Object class calling.
        return spl_object_hash($callback[0]) . $callback[1];
    } elseif (is_string($callback[0])) {
        // Static calling.
        return $callback[0] . '::' . $callback[1];
    }
}

WordPress Version: 5.8

/**
 * Builds Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @since 5.3.0 Removed workarounds for spl_object_hash().
 *              `$hook_name` and `$priority` are no longer used,
 *              and the function always returns a string.
 * @access private
 *
 * @param string   $hook_name Unused. The name of the filter to build ID for.
 * @param callable $callback  The function to generate ID for.
 * @param int      $priority  Unused. The order in which the functions
 *                            associated with a particular action are executed.
 * @return string Unique function ID for usage as array key.
 */
function _wp_filter_build_unique_id($hook_name, $callback, $priority)
{
    if (is_string($callback)) {
        return $callback;
    }
    if (is_object($callback)) {
        // Closures are currently implemented as objects.
        $callback = array($callback, '');
    } else {
        $callback = (array) $callback;
    }
    if (is_object($callback[0])) {
        // Object class calling.
        return spl_object_hash($callback[0]) . $callback[1];
    } elseif (is_string($callback[0])) {
        // Static calling.
        return $callback[0] . '::' . $callback[1];
    }
}

WordPress Version: 5.4

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @since 5.3.0 Removed workarounds for spl_object_hash().
 *              `$tag` and `$priority` are no longer used,
 *              and the function always returns a string.
 * @access private
 *
 * @param string   $tag      Unused. The name of the filter to build ID for.
 * @param callable $function The function to generate ID for.
 * @param int      $priority Unused. The order in which the functions
 *                           associated with a particular action are executed.
 * @return string Unique function ID for usage as array key.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects.
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object class calling.
        return spl_object_hash($function[0]) . $function[1];
    } elseif (is_string($function[0])) {
        // Static calling.
        return $function[0] . '::' . $function[1];
    }
}

WordPress Version: 5.3

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @access private
 *
 * @global array $wp_filter Storage for all of the filters and actions.
 * @staticvar int $filter_id_count
 *
 * @param string   $tag      Used in counting how many hooks were applied
 * @param callable $function Used for creating unique id
 * @param int|bool $priority Used in counting how many hooks were applied. If === false
 *                           and $function is an object reference, we return the unique
 *                           id only if it already has one, false otherwise.
 * @return string|false Unique ID for usage as array key or false if $priority === false
 *                      and $function is an object reference, and it does not already have
 *                      a unique id.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    global $wp_filter;
    static $filter_id_count = 0;
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object Class Calling
        return spl_object_hash($function[0]) . $function[1];
    } elseif (is_string($function[0])) {
        // Static Calling
        return $function[0] . '::' . $function[1];
    }
}

WordPress Version: 4.4

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @access private
 *
 * @global array $wp_filter Storage for all of the filters and actions.
 * @staticvar int $filter_id_count
 *
 * @param string   $tag      Used in counting how many hooks were applied
 * @param callable $function Used for creating unique id
 * @param int|bool $priority Used in counting how many hooks were applied. If === false
 *                           and $function is an object reference, we return the unique
 *                           id only if it already has one, false otherwise.
 * @return string|false Unique ID for usage as array key or false if $priority === false
 *                      and $function is an object reference, and it does not already have
 *                      a unique id.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    global $wp_filter;
    static $filter_id_count = 0;
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object Class Calling
        if (function_exists('spl_object_hash')) {
            return spl_object_hash($function[0]) . $function[1];
        } else {
            $obj_idx = get_class($function[0]) . $function[1];
            if (!isset($function[0]->wp_filter_id)) {
                if (false === $priority) {
                    return false;
                }
                $obj_idx .= isset($wp_filter[$tag][$priority]) ? count((array) $wp_filter[$tag][$priority]) : $filter_id_count;
                $function[0]->wp_filter_id = $filter_id_count;
                ++$filter_id_count;
            } else {
                $obj_idx .= $function[0]->wp_filter_id;
            }
            return $obj_idx;
        }
    } elseif (is_string($function[0])) {
        // Static Calling
        return $function[0] . '::' . $function[1];
    }
}

WordPress Version: 4.3

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @access private
 *
 * @global array $wp_filter Storage for all of the filters and actions.
 * @staticvar int $filter_id_count
 *
 * @param string   $tag      Used in counting how many hooks were applied
 * @param callback $function Used for creating unique id
 * @param int|bool $priority Used in counting how many hooks were applied. If === false
 *                           and $function is an object reference, we return the unique
 *                           id only if it already has one, false otherwise.
 * @return string|false Unique ID for usage as array key or false if $priority === false
 *                      and $function is an object reference, and it does not already have
 *                      a unique id.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    global $wp_filter;
    static $filter_id_count = 0;
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object Class Calling
        if (function_exists('spl_object_hash')) {
            return spl_object_hash($function[0]) . $function[1];
        } else {
            $obj_idx = get_class($function[0]) . $function[1];
            if (!isset($function[0]->wp_filter_id)) {
                if (false === $priority) {
                    return false;
                }
                $obj_idx .= isset($wp_filter[$tag][$priority]) ? count((array) $wp_filter[$tag][$priority]) : $filter_id_count;
                $function[0]->wp_filter_id = $filter_id_count;
                ++$filter_id_count;
            } else {
                $obj_idx .= $function[0]->wp_filter_id;
            }
            return $obj_idx;
        }
    } elseif (is_string($function[0])) {
        // Static Calling
        return $function[0] . '::' . $function[1];
    }
}

WordPress Version: 4.2

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @access private
 *
 * @global array $wp_filter Storage for all of the filters and actions.
 *
 * @param string   $tag      Used in counting how many hooks were applied
 * @param callback $function Used for creating unique id
 * @param int|bool $priority Used in counting how many hooks were applied. If === false
 *                           and $function is an object reference, we return the unique
 *                           id only if it already has one, false otherwise.
 * @return string|bool Unique ID for usage as array key or false if $priority === false
 *                     and $function is an object reference, and it does not already have
 *                     a unique id.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    global $wp_filter;
    static $filter_id_count = 0;
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object Class Calling
        if (function_exists('spl_object_hash')) {
            return spl_object_hash($function[0]) . $function[1];
        } else {
            $obj_idx = get_class($function[0]) . $function[1];
            if (!isset($function[0]->wp_filter_id)) {
                if (false === $priority) {
                    return false;
                }
                $obj_idx .= isset($wp_filter[$tag][$priority]) ? count((array) $wp_filter[$tag][$priority]) : $filter_id_count;
                $function[0]->wp_filter_id = $filter_id_count;
                ++$filter_id_count;
            } else {
                $obj_idx .= $function[0]->wp_filter_id;
            }
            return $obj_idx;
        }
    } elseif (is_string($function[0])) {
        // Static Calling
        return $function[0] . '::' . $function[1];
    }
}

WordPress Version: 4.1

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating an a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link https://core.trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @access private
 *
 * @global array $wp_filter Storage for all of the filters and actions.
 *
 * @param string   $tag      Used in counting how many hooks were applied
 * @param callback $function Used for creating unique id
 * @param int|bool $priority Used in counting how many hooks were applied. If === false
 *                           and $function is an object reference, we return the unique
 *                           id only if it already has one, false otherwise.
 * @return string|bool Unique ID for usage as array key or false if $priority === false
 *                     and $function is an object reference, and it does not already have
 *                     a unique id.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    global $wp_filter;
    static $filter_id_count = 0;
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object Class Calling
        if (function_exists('spl_object_hash')) {
            return spl_object_hash($function[0]) . $function[1];
        } else {
            $obj_idx = get_class($function[0]) . $function[1];
            if (!isset($function[0]->wp_filter_id)) {
                if (false === $priority) {
                    return false;
                }
                $obj_idx .= isset($wp_filter[$tag][$priority]) ? count((array) $wp_filter[$tag][$priority]) : $filter_id_count;
                $function[0]->wp_filter_id = $filter_id_count;
                ++$filter_id_count;
            } else {
                $obj_idx .= $function[0]->wp_filter_id;
            }
            return $obj_idx;
        }
    } else if (is_string($function[0])) {
        // Static Calling
        return $function[0] . '::' . $function[1];
    }
}

WordPress Version: 4.0

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating an a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @link http://trac.wordpress.org/ticket/3875
 *
 * @since 2.2.3
 * @access private
 *
 * @global array $wp_filter Storage for all of the filters and actions.
 *
 * @param string   $tag      Used in counting how many hooks were applied
 * @param callback $function Used for creating unique id
 * @param int|bool $priority Used in counting how many hooks were applied. If === false
 *                           and $function is an object reference, we return the unique
 *                           id only if it already has one, false otherwise.
 * @return string|bool Unique ID for usage as array key or false if $priority === false
 *                     and $function is an object reference, and it does not already have
 *                     a unique id.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    global $wp_filter;
    static $filter_id_count = 0;
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object Class Calling
        if (function_exists('spl_object_hash')) {
            return spl_object_hash($function[0]) . $function[1];
        } else {
            $obj_idx = get_class($function[0]) . $function[1];
            if (!isset($function[0]->wp_filter_id)) {
                if (false === $priority) {
                    return false;
                }
                $obj_idx .= isset($wp_filter[$tag][$priority]) ? count((array) $wp_filter[$tag][$priority]) : $filter_id_count;
                $function[0]->wp_filter_id = $filter_id_count;
                ++$filter_id_count;
            } else {
                $obj_idx .= $function[0]->wp_filter_id;
            }
            return $obj_idx;
        }
    } else if (is_string($function[0])) {
        // Static Calling
        return $function[0] . '::' . $function[1];
    }
}

WordPress Version: 3.9

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating an a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @access private
 * @since 2.2.3
 * @link http://trac.wordpress.org/ticket/3875
 *
 * @global array $wp_filter Storage for all of the filters and actions
 * @param string $tag Used in counting how many hooks were applied
 * @param callback $function Used for creating unique id
 * @param int|bool $priority Used in counting how many hooks were applied. If === false and $function is an object reference, we return the unique id only if it already has one, false otherwise.
 * @return string|bool Unique ID for usage as array key or false if $priority === false and $function is an object reference, and it does not already have a unique id.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    global $wp_filter;
    static $filter_id_count = 0;
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object Class Calling
        if (function_exists('spl_object_hash')) {
            return spl_object_hash($function[0]) . $function[1];
        } else {
            $obj_idx = get_class($function[0]) . $function[1];
            if (!isset($function[0]->wp_filter_id)) {
                if (false === $priority) {
                    return false;
                }
                $obj_idx .= isset($wp_filter[$tag][$priority]) ? count((array) $wp_filter[$tag][$priority]) : $filter_id_count;
                $function[0]->wp_filter_id = $filter_id_count;
                ++$filter_id_count;
            } else {
                $obj_idx .= $function[0]->wp_filter_id;
            }
            return $obj_idx;
        }
    } else if (is_string($function[0])) {
        // Static Calling
        return $function[0] . '::' . $function[1];
    }
}

WordPress Version: 3.7

/**
 * Build Unique ID for storage and retrieval.
 *
 * The old way to serialize the callback caused issues and this function is the
 * solution. It works by checking for objects and creating an a new property in
 * the class to keep track of the object and new objects of the same class that
 * need to be added.
 *
 * It also allows for the removal of actions and filters for objects after they
 * change class properties. It is possible to include the property $wp_filter_id
 * in your class and set it to "null" or a number to bypass the workaround.
 * However this will prevent you from adding new classes and any new classes
 * will overwrite the previous hook by the same class.
 *
 * Functions and static method callbacks are just returned as strings and
 * shouldn't have any speed penalty.
 *
 * @package WordPress
 * @subpackage Plugin
 * @access private
 * @since 2.2.3
 * @link http://trac.wordpress.org/ticket/3875
 *
 * @global array $wp_filter Storage for all of the filters and actions
 * @param string $tag Used in counting how many hooks were applied
 * @param callback $function Used for creating unique id
 * @param int|bool $priority Used in counting how many hooks were applied. If === false and $function is an object reference, we return the unique id only if it already has one, false otherwise.
 * @return string|bool Unique ID for usage as array key or false if $priority === false and $function is an object reference, and it does not already have a unique id.
 */
function _wp_filter_build_unique_id($tag, $function, $priority)
{
    global $wp_filter;
    static $filter_id_count = 0;
    if (is_string($function)) {
        return $function;
    }
    if (is_object($function)) {
        // Closures are currently implemented as objects
        $function = array($function, '');
    } else {
        $function = (array) $function;
    }
    if (is_object($function[0])) {
        // Object Class Calling
        if (function_exists('spl_object_hash')) {
            return spl_object_hash($function[0]) . $function[1];
        } else {
            $obj_idx = get_class($function[0]) . $function[1];
            if (!isset($function[0]->wp_filter_id)) {
                if (false === $priority) {
                    return false;
                }
                $obj_idx .= isset($wp_filter[$tag][$priority]) ? count((array) $wp_filter[$tag][$priority]) : $filter_id_count;
                $function[0]->wp_filter_id = $filter_id_count;
                ++$filter_id_count;
            } else {
                $obj_idx .= $function[0]->wp_filter_id;
            }
            return $obj_idx;
        }
    } else if (is_string($function[0])) {
        // Static Calling
        return $function[0] . '::' . $function[1];
    }
}