Day 58: WordPress Curie and Global Variables

WordPress Curie (Custom URI Embeds) is a feature introduced in WordPress 4.5 that allows embedding of third-party content using custom URIs. The term “Curie” stands for “Compact URI” and is a way to compactly represent a URI.

Before the Curie feature, embedding external content in WordPress posts or pages usually required using oEmbed or specific embed handlers implemented by WordPress for popular services like YouTube, Twitter, etc. However, these embeds were limited to predefined services and providers.

With WordPress Curie, developers can define custom URIs for embedding content from any service or provider. This feature enables WordPress to recognize and embed content from these custom URIs just like it does for regular oEmbed providers.

Here’s how it works:

  1. Defining Curie Links: Developers define custom URIs (Curie links). These Curie links map to specific providers or services.
function my_plugin_prefix_register_curie( $curies ) {

    $curies[] = array(
        'name'      => 'my_plugin',
        'href'      => '{rel}',
        'templated' => true,

    return $curies;
  1. Using Curie Links in Content: In WordPress content, authors can use these custom URIs to embed content from the registered providers.
  1. Handling Curie Requests: Developers also need to implement callback functions to handle requests for Curie links. This allows WordPress to retrieve the embed content from the registered providers.
   function mytheme_handle_curie_request( $matches ) {
       // Retrieve and return embed HTML for the provided identifier
   add_filter( 'pre_oembed_result', 'mytheme_handle_curie_request', 10, 2 );

WordPress Curie provides developers with more flexibility and control over embedding external content in WordPress sites. It allows for the integration of custom services and providers seamlessly into the WordPress content embedding system, expanding the possibilities for content creation and consumption within the WordPress ecosystem.

Global Variables

In WordPress, global variables like $wp_actions, $wp_filter, and others play a crucial role in managing the execution of actions and filters throughout the WordPress lifecycle.

  1. $wp_actions: This global variable stores the actions registered in WordPress. Actions are events triggered at specific points during the execution of WordPress, allowing developers to hook into these events and execute custom code. The $wp_actions variable is an associative array where keys represent the action names, and values represent the number of times the action has been executed.
  2. $wp_filter: This global variable stores the filters registered in WordPress. Filters allow developers to modify data as it passes through various WordPress functions. The $wp_filter variable is also an associative array where keys represent filter names, and values represent arrays of callback functions attached to those filters. Both $wp_actions and $wp_filter are essential components of WordPress’s event-driven architecture, facilitating extensibility and customization through actions and filters.
  3. $wpdb: This global variable is an instance of the WordPress database class (wpdb), which provides methods for interacting with the WordPress database. It allows developers to perform database queries, insert, update, delete data, and more.
  4. $wp_rewrite: This global variable contains an instance of the WordPress rewrite class (WP_Rewrite), which manages URL rewriting and allows developers to define custom URL structures, rewrite rules, and permalink formats.
  5. $wp_query: This global variable holds the main WordPress query object (WP_Query), which represents the current query being executed. It contains information about the requested posts, taxonomies, pagination settings, and more.

These global variables are stored in the global scope of the WordPress environment and are accessible from any part of the WordPress codebase. They are typically initialized during the WordPress bootstrap process and remain available throughout the execution of WordPress requests. However, it’s important to use them carefully and avoid modifying them directly unless necessary, as they are critical components of the WordPress core functionality.

Walker Class

In WordPress, a Walker class is a utility class used to generate HTML output for hierarchical data structures, such as navigation menus, category lists, and comment threads. The primary purpose of a Walker class is to traverse the hierarchical data and generate HTML markup for each element, allowing developers to customize the output structure and styling.

The Walker class is an abstract class, meaning that it provides a template for implementing specific walkers for different types of hierarchical data. Each Walker subclass typically overrides methods to customize the behavior and output of the walker for a specific use case.

Here are some key components and functions of the Walker class and its subclasses:

  1. Walker Class: The base Walker class defines the basic structure and methods for traversing hierarchical data. It contains methods for starting and ending the walker, handling the start and end of elements, and traversing child elements.
  2. start_el() and end_el(): These methods are called to generate HTML output for each individual element in the hierarchy. Developers override these methods in subclass implementations to customize the output for specific elements. For example, in a menu walker, start_el() might generate the HTML for a menu item, while end_el() would close the menu item markup.
  3. start_lvl() and end_lvl(): These methods are called to generate HTML output for the start and end of each level (depth) of the hierarchy. Developers can override these methods to add container elements or additional markup around groups of child elements.
  4. walk(): This method initiates the traversal of the hierarchical data structure. It typically calls other methods to generate HTML output for each element and its children.
  5. display_element(): This method is responsible for processing an individual element and generating its HTML output. It is called by the walker’s traversal methods (walk() or display_element()) for each element in the hierarchy.

By subclassing the Walker class and implementing custom walkers, developers can customize the HTML output and behavior of hierarchical data structures in WordPress. For example, WordPress includes built-in walkers for menus (Walker_Nav_Menu), categories (Walker_Category), and comments (Walker_Comment), each tailored to their respective use cases. Custom walkers can be created for other hierarchical data structures as needed.

Leave a Reply

Your email address will not be published. Required fields are marked *