Title: WP_Object_Cache Published: April 25, 2014 Last modified: May 20, 2026 --- # class WP_Object_Cache {} ## In this article * [Description](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#description) * [More Information](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#more-information) * [Role of the WordPress Object Cache](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#role-of-the-wordpress-object-cache) * [wp_cache_* functions](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#wp_cache_-functions) * [Persistent Caching](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#persistent-caching) * [Persistent Cache Plugins](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#persistent-cache-plugins) * [Related](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#related) * [Resources](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#resources) * [Methods](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#methods) * [Source](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#source) * [Changelog](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#changelog) * [User Contributed Notes](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#user-contributed-notes) [ Back to top](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#wp--skip-link--target) Core class that implements an object cache. ## 󠀁[Description](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#description)󠁿 The WordPress Object Cache is used to save on trips to the database. The Object Cache stores all of the cache data to memory and makes the cache contents available by using a key, which is used to name and later retrieve the cache contents. The Object Cache can be replaced by other caching mechanisms by placing files in the wp-content folder which is looked at in wp-settings. If that file exists, then this file will not be included. ## 󠀁[More Information](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#more-information)󠁿 ## 󠀁[Role of the WordPress Object Cache](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#role-of-the-wordpress-object-cache)󠁿 [WP_Object_Cache](https://developer.wordpress.org/reference/classes/wp_object_cache/) is WordPress’ class for caching data which may be computationally expensive to regenerate, such as the result of complex database queries. The object cache is defined in ` [wp-includes/cache.php](https://core.trac.wordpress.org/browser/tags/5.5.1/src/wp-includes/cache.php#L0)`. Do not use the class directly in your code when writing plugins, but use the `wp_cache_*` functions listed below. By default, the object cache is non-persistent. This means that data stored in the cache resides in memory only and only for the duration of the request. Cached data will not be stored persistently across page loads unless you install a [persistent caching](https://developer.wordpress.org/reference/classes/wp_object_cache/#persistent-caching) plugin. Use the [Transients API](https://developer.wordpress.org/apis/handbook/transients/) instead of these functions if you need to guarantee that your data will be cached. If persistent caching is configured, then the transients functions will use the wp_cache_* functions described in this document. However if persistent caching has not been enabled, then the data will instead be cached to the options table. Additionally, some object cache groups are designated as “non-persistent” and won’t be cached in persistent storage. This is useful when adding items to the cache that should only be available for the duration of a script session, and not between script invocations (or HTTP requests). ## 󠀁[wp_cache_* functions](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#wp_cache_-functions)󠁿 The most commonly used functions to interact with object cache are: * [wp_cache_get()](https://developer.wordpress.org/reference/functions/wp_cache_get/) * [wp_cache_set()](https://developer.wordpress.org/reference/functions/wp_cache_set/) * [wp_cache_delete()](https://developer.wordpress.org/reference/functions/wp_cache_delete/) * [wp_cache_flush()](https://developer.wordpress.org/reference/functions/wp_cache_flush/) * [wp_cache_add()](https://developer.wordpress.org/reference/functions/wp_cache_add/) * [wp_cache_replace()](https://developer.wordpress.org/reference/functions/wp_cache_replace/) * [wp_cache_add_global_groups()](https://developer.wordpress.org/reference/functions/wp_cache_add_global_groups/) * [wp_cache_add_non_persistent_groups()](https://developer.wordpress.org/reference/functions/wp_cache_add_non_persistent_groups/) In recent version WordPress introduced object cache functions that can help using the cache more efficiently. * [wp_cache_get_multiple()](https://developer.wordpress.org/reference/functions/wp_cache_get_multiple/) * [wp_cache_set_multiple()](https://developer.wordpress.org/reference/functions/wp_cache_set_multiple/) * [wp_cache_delete_multiple()](https://developer.wordpress.org/reference/functions/wp_cache_delete_multiple/) * [wp_cache_add_multiple()](https://developer.wordpress.org/reference/functions/wp_cache_add_multiple/) * [wp_cache_flush_group()](https://developer.wordpress.org/reference/functions/wp_cache_flush_group/) * [wp_cache_flush_runtime()](https://developer.wordpress.org/reference/functions/wp_cache_flush_runtime/) Testing whether newer functions are available cannot be done using `function_exists()`, but must be checked using `wp_cache_supports()` because WordPress will polyfill them. This means if an [object caching plugin](https://developer.wordpress.org/reference/classes/wp_object_cache/#persistent-cache-plugins) does not support flushing cache groups, calling `wp_cache_flush_group()` blindly may cause the entire cache to be flushed. ```wp-block-code if ( wp_cache_supports( 'flush_group' ) ) { wp_cache_flush_group( 'posts' ) } else { wp_cache_flush_cache(); } ``` ## 󠀁[Persistent Caching](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#persistent-caching)󠁿 Prior to [WordPress 2.5](https://wordpress.org/support/wordpress-version/version-2-5/), data stored using the wp_cache functions was stored persistently if you added define(' WP_CACHE', true) to your wp-config.php file. This is no longer the case, **and adding the define will have no effect** unless you install a persistent cache plugin (see examples below). ## 󠀁[Persistent Cache Plugins](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#persistent-cache-plugins)󠁿 * [Redis Object Cache](https://wordpress.org/plugins/redis-cache/) provides a persistent backend for the WordPress object cache. A [Redis](http://redis.io/) server is required. * [Memcached Object Cache](https://wordpress.org/plugins/memcached/) & [Memcached Redux Object Cache](https://wordpress.org/plugins/memcached-redux/) provides a persistent backend for the WordPress object cache. A [memcached](https://memcached.org) server and the [memcache extension](https://pecl.php.net/package/memcache) (or [Memcache**d** extension](https://pecl.php.net/package/memcached) for Redux) for PHP are required. * [Docket Cache](https://wordpress.org/plugins/docket-cache/) uses php’s built- in opcode cache mechanism to provide a persistent object cache. * [SQLite Object Cache](https://wordpress.org/plugins/sqlite-object-cache/) provides a persistent backend using the SQLite database engine. The [SQLite3 extension](https://www.php.net/sqlite3) for PHP is required. Some caching plugins like [W3 Total Cache](https://wordpress.org/extend/plugins/w3-total-cache/) and [LiteSpeed Cache](https://wordpress.org/plugins/litespeed-cache/) provide object caches as well, but are not the easiest way to get object caching in WordPress, because they additionally offer browser, page, asset and CDN caching. ## 󠀁[Related](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#related)󠁿 The [Transients_API](https://developer.wordpress.org/apis/handbook/transients/) provides persistent but temporary data caching by giving it a custom name and a timeframe after which it will be expired and regenerated. _Note: Transients only get deleted when a request is made. So, until someone visits your page and calls up the Transient, it will stay in the DB. In short: It’s not a real persistent cache and not equal to stuff running on cron jobs._ ## 󠀁[Resources](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#resources)󠁿 * The [Debug Bar](https://wordpress.org/plugins/debug-bar/) and [Query Monitor](https://wordpress.org/plugins/query-monitor/) plugins help you analyze the object cache. * Scott Taylor’s article [WordPress + Memcached](http://scotty-t.com/2012/01/20/wordpress-memcached/) explains various cache plugins and concepts. ## 󠀁[Methods](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#methods)󠁿 | Name | Description | | [WP_Object_Cache::__construct](https://developer.wordpress.org/reference/classes/wp_object_cache/__construct/) | Sets up object properties. | | [WP_Object_Cache::__get](https://developer.wordpress.org/reference/classes/wp_object_cache/__get/) | Makes private properties readable for backward compatibility. | | [WP_Object_Cache::__isset](https://developer.wordpress.org/reference/classes/wp_object_cache/__isset/) | Makes private properties checkable for backward compatibility. | | [WP_Object_Cache::__set](https://developer.wordpress.org/reference/classes/wp_object_cache/__set/) | Makes private properties settable for backward compatibility. | | [WP_Object_Cache::__unset](https://developer.wordpress.org/reference/classes/wp_object_cache/__unset/) | Makes private properties un-settable for backward compatibility. | | [WP_Object_Cache::_exists](https://developer.wordpress.org/reference/classes/wp_object_cache/_exists/) | Serves as a utility function to determine whether a key exists in the cache. | | [WP_Object_Cache::add](https://developer.wordpress.org/reference/classes/wp_object_cache/add/) | Adds data to the cache if it doesn’t already exist. | | [WP_Object_Cache::add_global_groups](https://developer.wordpress.org/reference/classes/wp_object_cache/add_global_groups/) | Sets the list of global cache groups. | | [WP_Object_Cache::add_multiple](https://developer.wordpress.org/reference/classes/wp_object_cache/add_multiple/) | Adds multiple values to the cache in one call. | | [WP_Object_Cache::decr](https://developer.wordpress.org/reference/classes/wp_object_cache/decr/) | Decrements numeric cache item’s value. | | [WP_Object_Cache::delete](https://developer.wordpress.org/reference/classes/wp_object_cache/delete/) | Removes the contents of the cache key in the group. | | [WP_Object_Cache::delete_multiple](https://developer.wordpress.org/reference/classes/wp_object_cache/delete_multiple/) | Deletes multiple values from the cache in one call. | | [WP_Object_Cache::flush](https://developer.wordpress.org/reference/classes/wp_object_cache/flush/) | Clears the object cache of all data. | | [WP_Object_Cache::flush_group](https://developer.wordpress.org/reference/classes/wp_object_cache/flush_group/) | Removes all cache items in a group. | | [WP_Object_Cache::get](https://developer.wordpress.org/reference/classes/wp_object_cache/get/) | Retrieves the cache contents, if it exists. | | [WP_Object_Cache::get_multiple](https://developer.wordpress.org/reference/classes/wp_object_cache/get_multiple/) | Retrieves multiple values from the cache in one call. | | [WP_Object_Cache::incr](https://developer.wordpress.org/reference/classes/wp_object_cache/incr/) | Increments numeric cache item’s value. | | [WP_Object_Cache::is_valid_key](https://developer.wordpress.org/reference/classes/wp_object_cache/is_valid_key/) | Serves as a utility function to determine whether a key is valid. | | [WP_Object_Cache::replace](https://developer.wordpress.org/reference/classes/wp_object_cache/replace/) | Replaces the contents in the cache, if contents already exist. | | [WP_Object_Cache::reset](https://developer.wordpress.org/reference/classes/wp_object_cache/reset/) | Resets cache keys. — deprecated | | [WP_Object_Cache::set](https://developer.wordpress.org/reference/classes/wp_object_cache/set/) | Sets the data contents into the cache. | | [WP_Object_Cache::set_multiple](https://developer.wordpress.org/reference/classes/wp_object_cache/set_multiple/) | Sets multiple values to the cache in one call. | | [WP_Object_Cache::stats](https://developer.wordpress.org/reference/classes/wp_object_cache/stats/) | Echoes the stats of the caching. | | [WP_Object_Cache::switch_to_blog](https://developer.wordpress.org/reference/classes/wp_object_cache/switch_to_blog/) | Switches the internal blog ID. | ## 󠀁[Source](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#source)󠁿 ```php #[AllowDynamicProperties] class WP_Object_Cache { /** * Holds the cached objects. * * @since 2.0.0 * @var array */ private $cache = array(); /** * The amount of times the cache data was already stored in the cache. * * @since 2.5.0 * @var int */ public $cache_hits = 0; /** * Amount of times the cache did not have the request in cache. * * @since 2.0.0 * @var int */ public $cache_misses = 0; /** * List of global cache groups. * * @since 3.0.0 * @var string[] */ protected $global_groups = array(); /** * The blog prefix to prepend to keys in non-global groups. * * @since 3.5.0 * @var string */ private $blog_prefix; /** * Holds the value of is_multisite(). * * @since 3.5.0 * @var bool */ private $multisite; /** * Sets up object properties. * * @since 2.0.8 */ public function __construct() { $this->multisite = is_multisite(); $this->blog_prefix = $this->multisite ? get_current_blog_id() . ':' : ''; } /** * Makes private properties readable for backward compatibility. * * @since 4.0.0 * * @param string $name Property to get. * @return mixed Property. */ public function __get( $name ) { return $this->$name; } /** * Makes private properties settable for backward compatibility. * * @since 4.0.0 * * @param string $name Property to set. * @param mixed $value Property value. */ public function __set( $name, $value ) { $this->$name = $value; } /** * Makes private properties checkable for backward compatibility. * * @since 4.0.0 * * @param string $name Property to check if set. * @return bool Whether the property is set. */ public function __isset( $name ) { return isset( $this->$name ); } /** * Makes private properties un-settable for backward compatibility. * * @since 4.0.0 * * @param string $name Property to unset. */ public function __unset( $name ) { unset( $this->$name ); } /** * Serves as a utility function to determine whether a key is valid. * * @since 6.1.0 * * @param int|string $key Cache key to check for validity. * @return bool Whether the key is valid. */ protected function is_valid_key( $key ) { if ( is_int( $key ) ) { return true; } if ( is_string( $key ) && trim( $key ) !== '' ) { return true; } $type = gettype( $key ); if ( ! function_exists( '__' ) ) { wp_load_translations_early(); } $message = is_string( $key ) ? __( 'Cache key must not be an empty string.' ) /* translators: %s: The type of the given cache key. */ : sprintf( __( 'Cache key must be an integer or a non-empty string, %s given.' ), $type ); _doing_it_wrong( sprintf( '%s::%s', __CLASS__, debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS, 2 )[1]['function'] ), $message, '6.1.0' ); return false; } /** * Serves as a utility function to determine whether a key exists in the cache. * * @since 3.4.0 * * @param int|string $key Cache key to check for existence. * @param string $group Cache group for the key existence check. * @return bool Whether the key exists in the cache for the given group. */ protected function _exists( $key, $group ) { return isset( $this->cache[ $group ] ) && ( isset( $this->cache[ $group ][ $key ] ) || array_key_exists( $key, $this->cache[ $group ] ) ); } /** * Adds data to the cache if it doesn't already exist. * * @since 2.0.0 * * @uses WP_Object_Cache::_exists() Checks to see if the cache already has data. * @uses WP_Object_Cache::set() Sets the data after the checking the cache * contents existence. * * @param int|string $key What to call the contents in the cache. * @param mixed $data The contents to store in the cache. * @param string $group Optional. Where to group the cache contents. Default 'default'. * @param int $expire Optional. When to expire the cache contents, in seconds. * Default 0 (no expiration). * @return bool True on success, false if cache key and group already exist. */ public function add( $key, $data, $group = 'default', $expire = 0 ) { if ( wp_suspend_cache_addition() ) { return false; } if ( ! $this->is_valid_key( $key ) ) { return false; } if ( empty( $group ) ) { $group = 'default'; } $id = $key; if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) { $id = $this->blog_prefix . $key; } if ( $this->_exists( $id, $group ) ) { return false; } return $this->set( $key, $data, $group, (int) $expire ); } /** * Adds multiple values to the cache in one call. * * @since 6.0.0 * * @param array $data Array of keys and values to be added. * @param string $group Optional. Where the cache contents are grouped. Default empty. * @param int $expire Optional. When to expire the cache contents, in seconds. * Default 0 (no expiration). * @return bool[] Array of return values, grouped by key. Each value is either * true on success, or false if cache key and group already exist. */ public function add_multiple( array $data, $group = '', $expire = 0 ) { $values = array(); foreach ( $data as $key => $value ) { $values[ $key ] = $this->add( $key, $value, $group, $expire ); } return $values; } /** * Replaces the contents in the cache, if contents already exist. * * @since 2.0.0 * * @see WP_Object_Cache::set() * * @param int|string $key What to call the contents in the cache. * @param mixed $data The contents to store in the cache. * @param string $group Optional. Where to group the cache contents. Default 'default'. * @param int $expire Optional. When to expire the cache contents, in seconds. * Default 0 (no expiration). * @return bool True if contents were replaced, false if original value does not exist. */ public function replace( $key, $data, $group = 'default', $expire = 0 ) { if ( ! $this->is_valid_key( $key ) ) { return false; } if ( empty( $group ) ) { $group = 'default'; } $id = $key; if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) { $id = $this->blog_prefix . $key; } if ( ! $this->_exists( $id, $group ) ) { return false; } return $this->set( $key, $data, $group, (int) $expire ); } /** * Sets the data contents into the cache. * * The cache contents are grouped by the $group parameter followed by the * $key. This allows for duplicate IDs in unique groups. Therefore, naming of * the group should be used with care and should follow normal function * naming guidelines outside of core WordPress usage. * * The $expire parameter is not used, because the cache will automatically * expire for each time a page is accessed and PHP finishes. The method is * more for cache plugins which use files. * * @since 2.0.0 * @since 6.1.0 Returns false if cache key is invalid. * * @param int|string $key What to call the contents in the cache. * @param mixed $data The contents to store in the cache. * @param string $group Optional. Where to group the cache contents. Default 'default'. * @param int $expire Optional. Not used. * @return bool True if contents were set, false if key is invalid. */ public function set( $key, $data, $group = 'default', $expire = 0 ) { if ( ! $this->is_valid_key( $key ) ) { return false; } if ( empty( $group ) ) { $group = 'default'; } if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) { $key = $this->blog_prefix . $key; } if ( is_object( $data ) ) { $data = clone $data; } $this->cache[ $group ][ $key ] = $data; return true; } /** * Sets multiple values to the cache in one call. * * @since 6.0.0 * * @param array $data Array of key and value to be set. * @param string $group Optional. Where the cache contents are grouped. Default empty. * @param int $expire Optional. When to expire the cache contents, in seconds. * Default 0 (no expiration). * @return bool[] Array of return values, grouped by key. Each value is always true. */ public function set_multiple( array $data, $group = '', $expire = 0 ) { $values = array(); foreach ( $data as $key => $value ) { $values[ $key ] = $this->set( $key, $value, $group, $expire ); } return $values; } /** * Retrieves the cache contents, if it exists. * * The contents will be first attempted to be retrieved by searching by the * key in the cache group. If the cache is hit (success) then the contents * are returned. * * On failure, the number of cache misses will be incremented. * * @since 2.0.0 * * @param int|string $key The key under which the cache contents are stored. * @param string $group Optional. Where the cache contents are grouped. Default 'default'. * @param bool $force Optional. Unused. Whether to force an update of the local cache * from the persistent cache. Default false. * @param bool|null $found Optional. Whether the key was found in the cache (passed by reference). * Disambiguates a return of false, a storable value. Default null. * @return mixed|false The cache contents on success, false on failure to retrieve contents. */ public function get( $key, $group = 'default', $force = false, &$found = null ) { if ( ! $this->is_valid_key( $key ) ) { return false; } if ( empty( $group ) ) { $group = 'default'; } if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) { $key = $this->blog_prefix . $key; } if ( $this->_exists( $key, $group ) ) { $found = true; $this->cache_hits += 1; if ( is_object( $this->cache[ $group ][ $key ] ) ) { return clone $this->cache[ $group ][ $key ]; } else { return $this->cache[ $group ][ $key ]; } } $found = false; $this->cache_misses += 1; return false; } /** * Retrieves multiple values from the cache in one call. * * @since 5.5.0 * * @param array $keys Array of keys under which the cache contents are stored. * @param string $group Optional. Where the cache contents are grouped. Default 'default'. * @param bool $force Optional. Whether to force an update of the local cache * from the persistent cache. Default false. * @return array Array of return values, grouped by key. Each value is either * the cache contents on success, or false on failure. */ public function get_multiple( $keys, $group = 'default', $force = false ) { $values = array(); foreach ( $keys as $key ) { $values[ $key ] = $this->get( $key, $group, $force ); } return $values; } /** * Removes the contents of the cache key in the group. * * If the cache key does not exist in the group, then nothing will happen. * * @since 2.0.0 * * @param int|string $key What the contents in the cache are called. * @param string $group Optional. Where the cache contents are grouped. Default 'default'. * @param bool $deprecated Optional. Unused. Default false. * @return bool True on success, false if the contents were not deleted. */ public function delete( $key, $group = 'default', $deprecated = false ) { if ( ! $this->is_valid_key( $key ) ) { return false; } if ( empty( $group ) ) { $group = 'default'; } if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) { $key = $this->blog_prefix . $key; } if ( ! $this->_exists( $key, $group ) ) { return false; } unset( $this->cache[ $group ][ $key ] ); return true; } /** * Deletes multiple values from the cache in one call. * * @since 6.0.0 * * @param array $keys Array of keys to be deleted. * @param string $group Optional. Where the cache contents are grouped. Default empty. * @return bool[] Array of return values, grouped by key. Each value is either * true on success, or false if the contents were not deleted. */ public function delete_multiple( array $keys, $group = '' ) { $values = array(); foreach ( $keys as $key ) { $values[ $key ] = $this->delete( $key, $group ); } return $values; } /** * Increments numeric cache item's value. * * @since 3.3.0 * * @param int|string $key The cache key to increment. * @param int $offset Optional. The amount by which to increment the item's value. * Default 1. * @param string $group Optional. The group the key is in. Default 'default'. * @return int|false The item's new value on success, false on failure. */ public function incr( $key, $offset = 1, $group = 'default' ) { if ( ! $this->is_valid_key( $key ) ) { return false; } if ( empty( $group ) ) { $group = 'default'; } if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) { $key = $this->blog_prefix . $key; } if ( ! $this->_exists( $key, $group ) ) { return false; } if ( ! is_numeric( $this->cache[ $group ][ $key ] ) ) { $this->cache[ $group ][ $key ] = 0; } $offset = (int) $offset; $this->cache[ $group ][ $key ] += $offset; if ( $this->cache[ $group ][ $key ] < 0 ) { $this->cache[ $group ][ $key ] = 0; } return $this->cache[ $group ][ $key ]; } /** * Decrements numeric cache item's value. * * @since 3.3.0 * * @param int|string $key The cache key to decrement. * @param int $offset Optional. The amount by which to decrement the item's value. * Default 1. * @param string $group Optional. The group the key is in. Default 'default'. * @return int|false The item's new value on success, false on failure. */ public function decr( $key, $offset = 1, $group = 'default' ) { if ( ! $this->is_valid_key( $key ) ) { return false; } if ( empty( $group ) ) { $group = 'default'; } if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) { $key = $this->blog_prefix . $key; } if ( ! $this->_exists( $key, $group ) ) { return false; } if ( ! is_numeric( $this->cache[ $group ][ $key ] ) ) { $this->cache[ $group ][ $key ] = 0; } $offset = (int) $offset; $this->cache[ $group ][ $key ] -= $offset; if ( $this->cache[ $group ][ $key ] < 0 ) { $this->cache[ $group ][ $key ] = 0; } return $this->cache[ $group ][ $key ]; } /** * Clears the object cache of all data. * * @since 2.0.0 * * @return true Always returns true. */ public function flush() { $this->cache = array(); return true; } /** * Removes all cache items in a group. * * @since 6.1.0 * * @param string $group Name of group to remove from cache. * @return true Always returns true. */ public function flush_group( $group ) { unset( $this->cache[ $group ] ); return true; } /** * Sets the list of global cache groups. * * @since 3.0.0 * * @param string|string[] $groups List of groups that are global. */ public function add_global_groups( $groups ) { $groups = (array) $groups; $groups = array_fill_keys( $groups, true ); $this->global_groups = array_merge( $this->global_groups, $groups ); } /** * Switches the internal blog ID. * * This changes the blog ID used to create keys in blog specific groups. * * @since 3.5.0 * * @param int $blog_id Blog ID. */ public function switch_to_blog( $blog_id ) { $blog_id = (int) $blog_id; $this->blog_prefix = $this->multisite ? $blog_id . ':' : ''; } /** * Resets cache keys. * * @since 3.0.0 * * @deprecated 3.5.0 Use WP_Object_Cache::switch_to_blog() * @see switch_to_blog() */ public function reset() { _deprecated_function( __FUNCTION__, '3.5.0', 'WP_Object_Cache::switch_to_blog()' ); // Clear out non-global caches since the blog ID has changed. foreach ( array_keys( $this->cache ) as $group ) { if ( ! isset( $this->global_groups[ $group ] ) ) { unset( $this->cache[ $group ] ); } } } /** * Echoes the stats of the caching. * * Gives the cache hits, and cache misses. Also prints every cached group, * key and the data. * * @since 2.0.0 */ public function stats() { echo '

'; echo "Cache Hits: {$this->cache_hits}
"; echo "Cache Misses: {$this->cache_misses}
"; echo '

'; echo ''; } } ``` [View all references](https://developer.wordpress.org/reference/files/wp-includes/class-wp-object-cache.php/) [View on Trac](https://core.trac.wordpress.org/browser/tags/7.0/src/wp-includes/class-wp-object-cache.php#L24) [View on GitHub](https://github.com/WordPress/wordpress-develop/blob/7.0/src/wp-includes/class-wp-object-cache.php#L24-L644) ## 󠀁[Changelog](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#changelog)󠁿 | Version | Description | | [2.0.0](https://developer.wordpress.org/reference/since/2.0.0/) | Introduced. | ## 󠀁[User Contributed Notes](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#user-contributed-notes)󠁿 1. [Skip to note 6 content](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#comment-content-5746) 2. [Philipp Stracker](https://profiles.wordpress.org/strackerphil-1/) [ 4 years ago ](https://developer.wordpress.org/reference/classes/wp_object_cache/#comment-5746) 3. [You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-5746) Vote results for this note: 5[You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-5746) 4. It’s important to note that objects are not referenced, but **a clone of the object is stored in the cache**! 5. If you update an object, after it was added to the cache, **the item in the cache will not change**, unless you update the cache with the new object 6. ```php class SomeItem { private $value = 0; function add() { $this->value++; } function show() { echo "{$this->value}n"; } } $item = new SomeItem; $item->show(); // Prints "0" wp_cache_set( 'test-1', $item ); // Modify item after it was written to object cache. // This call updates the local object, but not the item in the cache! $item->add(); $item->show(); // Prints "1" // Get the item from cache. $item = wp_cache_get( 'test-1' ); $item->show(); // Prints "0" possibly an unexpected result. ``` 7. Reference: Here’s the [relevant part of the core function](https://core.trac.wordpress.org/browser/tags/5.9/src/wp-includes/class-wp-object-cache.php?marks=442-444#L413). 8. **Solution:** Since WordPress only clones objects (using the `clone` keyword), there are several ways to bypass the limitation, with minimal extra code, such as this here: 9. ```php class SomeItem { private $value = 0; function add() { $this->value++; } function show() { echo "{$this->value}n"; } } $item = new SomeItem; $item->show(); // "0" // Assign our instance to an array. Arrays are not cloned and references will stay intact: $cacheData = [ 'ref' => $item ]; // Cache the wrapped instance: wp_cache_set( 'test-1', $cacheData ); // Modify item after it was written to object cache. $item->add(); $item->show(); // "1" // Get the wrapped instance from cache. $cacheData = wp_cache_get('test-1'); $item = $cacheData['ref']; // Retrieve the actual instance from our array $item->show(); // Prints "1", as expected! ``` 10. **Helper functions:** 11. ```php // Setter function wp_cache_set_ref( $key, $data, $group = '', $expire = 0 ) { return wp_cache_set( $key, [ 'ref' => $data ], $group, $expire ); } ``` 12. ```php // Getter function wp_cache_get_ref( $key, $group = '', $force = false, &$found = null ) { $wrapper = wp_cache_get( $key, $group, $force, $found ); if ( is_array( $wrapper ) && array_key_exists( 'ref', $wrapper ) ) { return $wrapper['ref']; } return $wrapper; } ``` 13. ```php // Usage class SomeItem { private $value = 0; function add() { $this->value++; } function show() { echo "{$this->value}n"; } } $item = new SomeItem; $item->show(); // "0" wp_cache_set_ref( 'test-1', $item ); $item->add(); $item->show(); // "1" $item = wp_cache_get_ref( 'test-1' ); $item->show(); // "1" ``` 14. * I think this workaround needs a huge warning, and should generally be avoided. It gives the impression that cached objects can be made modifiable _after_ being stored, whereas all this does is pass around a copied object reference for one request. Changes can be made to such an object but they will only apply to the in-memory copy, not the one written to persistent cache. This may be acceptable if you’re not using persistent cache but that typically defeats the purpose of caching. With persistent cache, subsequent requests will restore the object to the state it had at the time of last save, without any of the modifications made after that point. * [Roy Orbitson](https://profiles.wordpress.org/lev0/) [3 years ago](https://developer.wordpress.org/reference/classes/wp_object_cache/#comment-6620) 15. [Log in to add feedback](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%3Freplytocom%3D5746%23feedback-editor-5746) 16. [Skip to note 7 content](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#comment-content-5412) 17. [xnau webdesign](https://profiles.wordpress.org/xnau/) [ 5 years ago ](https://developer.wordpress.org/reference/classes/wp_object_cache/#comment-5412) 18. [You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-5412) Vote results for this note: 4[You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-5412) 19. It’s easy to miss this, but it’s important to remember that the actual expiration time for the cache depends on whether a persistent cache is set up on the user’s site or not. 20. If there is no persistent cache set up, the cache does not persist across page loads, so it doesn’t matter much what the expiration time is. 21. However, if is persistent cache is installed, and no expiration time is set, the cache can end up being “sticky” and more persistent than intended. This can lead to problems that may not show up in tests. 22. It’s probably a good practice to set an expiration time to avoid this. 23. [Log in to add feedback](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%3Freplytocom%3D5412%23feedback-editor-5412) 24. [Skip to note 8 content](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#comment-content-1976) 25. [Priyanka Behera](https://profiles.wordpress.org/priyankabehera155/) [ 9 years ago ](https://developer.wordpress.org/reference/classes/wp_object_cache/#comment-1976) 26. [You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-1976) Vote results for this note: 3[You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-1976) 27. **The object cache is used for caching the results of expensive SQL queries. So they’re not performed multiple times within a page load. In the below example, imagine the $query variable is an expensive SQL query.** 28. ```php $result = wp_cache_get( 'my_result' ); if ( false === $result ) { $result = $wpdb->get_results( $query ); wp_cache_set( 'my_result', $result ); } // Do something with $result; ``` 29. [Log in to add feedback](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%3Freplytocom%3D1976%23feedback-editor-1976) 30. [Skip to note 9 content](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#comment-content-6285) 31. [OllieJones](https://profiles.wordpress.org/olliejones/) [ 3 years ago ](https://developer.wordpress.org/reference/classes/wp_object_cache/#comment-6285) 32. [You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-6285) Vote results for this note: 2[You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-6285) 33. Many hosts do not provide redis or memcached servers, but do provide the [SQLite3](https://www.php.net/manual/en/book.sqlite3.php) extension to php. 34. Sites running on those hosts can use the [SQLite Object Cache](https://wordpress.org/plugins/sqlite-object-cache/) plugin to provide persistent object caching and get the performance benefits. 35. [Log in to add feedback](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%3Freplytocom%3D6285%23feedback-editor-6285) 36. [Skip to note 10 content](https://developer.wordpress.org/reference/classes/wp_object_cache/?output_format=md#comment-content-6437) 37. [OllieJones](https://profiles.wordpress.org/olliejones/) [ 3 years ago ](https://developer.wordpress.org/reference/classes/wp_object_cache/#comment-6437) 38. [You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-6437) Vote results for this note: 0[You must log in to vote on the helpfulness of this note](https://login.wordpress.org?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%23comment-6437) 39. Notes to implementers of the *_multiple() functions: 40. * Most, if not all, the `$keys` are numeric. * They’re not always in order. * Sometimes the keys arrays passed to calls to `[wp_cache_get_multiple()](https://developer.wordpress.org/reference/functions/wp_cache_get_multiple/)` contain duplicates. 41. This is as of version 6.2. 42. [Log in to add feedback](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F%3Freplytocom%3D6437%23feedback-editor-6437) You must [log in](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fdeveloper.wordpress.org%2Freference%2Fclasses%2Fwp_object_cache%2F) before being able to contribute a note or feedback.