Dynamically Set Custom Post Titles And Slugs With Custom Fields

Jul 17, 2025 by ADMIN 64 views

How to Dynamically Set Custom Post Titles and Slugs Using Custom Fields in WordPress

In WordPress development, creating custom post types (CPTs) and leveraging custom fields allows for highly tailored content management. A common requirement is to dynamically set the post title and slug based on the value of a custom field. This approach enhances user experience and SEO by creating more descriptive and user-friendly URLs. This article will guide you through the process of automatically setting a custom post title and slug using a custom field, specifically within the context of using the Advanced Custom Fields (ACF) plugin.

Understanding the Need for Dynamic Titles and Slugs

Dynamic titles and slugs are crucial for several reasons. Firstly, they improve the organization and presentation of your content. Instead of generic titles, you can use specific and relevant information from your custom fields. For instance, if you have a custom post type for recipes, you might want the recipe title to be automatically set based on the recipe name entered in a custom field. Secondly, dynamic slugs—the URL-friendly version of your title—enhance SEO. A clear and descriptive slug helps search engines understand the content of the page, improving its ranking. Finally, a well-structured URL makes it easier for users to understand and share your content.

Prerequisites

Before diving into the implementation, ensure you have the following:

WordPress Installation: A working WordPress site.
Custom Post Type: A registered custom post type. For example, a ‘recipe’ custom post type.
Advanced Custom Fields (ACF) Plugin: Installed and activated. This plugin simplifies the process of creating and managing custom fields.
Custom Field: A custom field created using ACF. For example, a ‘recipe_name’ text field.

Step-by-Step Implementation

The process involves writing a function that hooks into WordPress’s save post action. This function will retrieve the value from the custom field and use it to update the post title and slug.

1. Create a Function to Update the Post Title and Slug

First, you need to create a function that will be triggered when a post is saved. This function will:

Retrieve the value of the custom field.
Update the post title with this value.
Generate a new slug based on the new title.

Here’s an example function:

function set_custom_post_title_and_slug( $post_id ) {
    // Prevent infinite loop
    if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE )
        return;

    // Unhook this function to prevent infinite looping
    remove_action( 'save_post', 'set_custom_post_title_and_slug' );

    // Get the post type
    $post_type = get_post_type( $post_id );

    // Check if it's the correct post type (e.g., 'recipe')
    if ( 'recipe' !== $post_type ) {
        return;
    }

    // Get the custom field value (e.g., 'recipe_name')
    $recipe_name = get_field( 'recipe_name', $post_id );

    // If the custom field has a value
    if ( ! empty( $recipe_name ) ) {
        // Create the new title
        $new_title = sanitize_text_field( $recipe_name );

        // Update the post
        $post = array(
            'ID'         => $post_id,
            'post_title' => $new_title,
            'post_name'  => sanitize_title( $new_title ) // Create the slug
        );

        // Update the post without triggering 'save_post' again
        wp_update_post( $post );
    }

    // Re-hook this function
    add_action( 'save_post', 'set_custom_post_title_and_slug' );
}

2. Hook the Function into the `save_post` Action

Next, you need to hook this function into the save_post action. This action is triggered whenever a post is saved or updated in WordPress. Add the following line to your theme’s functions.php file or a custom plugin:

add_action( 'save_post', 'set_custom_post_title_and_slug' );

3. Detailed Explanation of the Code

Let’s break down the code snippet to understand each part:

Prevent Infinite Loop:
```
if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE )
    return;
```
This condition checks if the current save action is an autosave. If it is, the function returns to prevent unnecessary processing during autosaves. This is an optimization to avoid potential issues with autosaving.
Unhook and Re-hook the Function:
```
remove_action( 'save_post', 'set_custom_post_title_and_slug' );
// ... code to update the post ...
add_action( 'save_post', 'set_custom_post_title_and_slug' );
```
Before updating the post, the function is unhooked from the save_post action to prevent an infinite loop. After the update, it is re-hooked. This ensures that the function is only called once per save action.
Get the Post Type:
```
$post_type = get_post_type( $post_id );
```
This retrieves the post type of the post being saved. It’s essential to check the post type to ensure the function only runs for the intended custom post type (e.g., ‘recipe’).
Check the Post Type:
```
if ( 'recipe' !== $post_type ) {
    return;
}
```
This conditional statement verifies that the post type is ‘recipe’. If it’s not, the function returns, preventing it from running on other post types.
Get the Custom Field Value:
```
$recipe_name = get_field( 'recipe_name', $post_id );
```
This uses ACF’s get_field() function to retrieve the value of the ‘recipe_name’ custom field for the current post. The second parameter, $post_id, specifies the post to retrieve the field from.
Check if the Custom Field Has a Value:
```
if ( ! empty( $recipe_name ) ) {
    // ... code to update the post ...
}
```
This checks if the custom field has a value. The code inside the if block will only execute if the ‘recipe_name’ field is not empty.
Create the New Title:
```
$new_title = sanitize_text_field( $recipe_name );
```
The value from the custom field is sanitized using sanitize_text_field() to ensure it contains only safe text. This prevents potential security issues.
Update the Post:
```
$post = array(
    'ID'         => $post_id,
    'post_title' => $new_title,
    'post_name'  => sanitize_title( $new_title ) // Create the slug
);
wp_update_post( $post );
```
This creates an array with the post’s ID, the new title, and the new slug. The slug is generated using sanitize_title(), which creates a URL-friendly version of the title. The wp_update_post() function is then used to update the post with the new title and slug.
Re-hook This Function:
```
add_action( 'save_post', 'set_custom_post_title_and_slug' );
```
After updating the post, the function is re-hooked to the save_post action, ensuring it runs the next time a post is saved.

4. Add the Code to Your WordPress Site

You can add the code to your theme’s functions.php file or create a custom plugin. Adding it to a custom plugin is generally recommended to keep your functionality separate from your theme, making it easier to switch themes without losing your custom code.

To create a custom plugin:

Create a new folder in the wp-content/plugins/ directory. Name it something descriptive, like dynamic-recipe-title.
Inside the folder, create a PHP file (e.g., dynamic-recipe-title.php).

Add the plugin header to the PHP file:

<?php
/**
 * Plugin Name: Dynamic Recipe Title
 * Description: Sets the post title and slug based on the recipe_name custom field.
 * Version: 1.0.0
 * Author: Your Name
 */

Paste the PHP code (the function and the add_action line) below the plugin header.
Save the file and activate the plugin through your WordPress admin panel.

Testing the Implementation

To test the implementation, follow these steps:

Go to your WordPress admin panel.
Create a new post of the custom post type (e.g., Recipe).
Fill in the custom field (e.g., ‘recipe_name’) with a value.
Save the post.
Check if the post title and slug have been updated automatically based on the custom field value.

Advanced Considerations

Handling Empty Custom Field Values

The code includes a check for empty custom field values. If the custom field is empty, the post title and slug will not be updated. You might want to add additional logic to handle this scenario, such as setting a default title or displaying an error message.

Updating Existing Posts

The code will automatically update the title and slug for new posts and updated posts. However, if you have existing posts, you may need to update them manually. You can do this by editing each post and saving it, which will trigger the save_post action. Alternatively, you can write a script to update all posts in bulk.

SEO Best Practices

While this method helps in creating SEO-friendly URLs, remember to follow other SEO best practices. Use relevant keywords in your custom field values, and ensure your content is high-quality and user-friendly.

Performance Optimization

The save_post action is triggered frequently, so it’s essential to ensure your code is optimized for performance. Avoid running complex or time-consuming operations within the function. The provided code includes measures to prevent infinite loops and unnecessary processing during autosaves.

Troubleshooting Common Issues

Title and Slug Not Updating

Check Post Type: Ensure the post type check in the function matches your custom post type.
Custom Field Name: Verify the custom field name in the get_field() function is correct.
Infinite Loop: If you encounter issues, double-check the unhooking and re-hooking of the save_post action.
ACF Plugin: Ensure ACF is installed and activated.

Infinite Loop Errors

The most common cause of infinite loops is not properly unhooking and re-hooking the save_post action. Review the code to ensure these steps are correctly implemented.

Performance Issues

If you notice performance issues, consider optimizing the code further. Avoid running complex queries or operations within the save_post action.

Conclusion

Dynamically setting custom post titles and slugs based on custom fields is a powerful technique for enhancing the organization, user experience, and SEO of your WordPress site. By leveraging the Advanced Custom Fields plugin and the save_post action, you can automate this process and create more descriptive and user-friendly URLs. This guide has provided a detailed walkthrough of the implementation, along with explanations, advanced considerations, and troubleshooting tips. By following these steps, you can effectively manage your custom post types and provide a better experience for your users.