'my_login_logo_url_title' );nfunction my_login_logo_url_title() {n return 'The Arabic Guide to Learning WordPress';n}n ""

WordPress Hooks are considered one of the most important features that help WordPress developers develop their own WordPress themes or plugins, modify the way a template or plugin works, or change the way WordPress itself works. Hooks are essentially functions that contain code that can perform an action, or filter and modify specific data in WordPress. In this article, we will explain the concept of hooks in WordPress and learn about their types and how they work.

It is worth noting that this topic is considered one of the necessary topics that any developer of WordPress templates or plugins must understand well as part of the WordPress development process. Contents of the article What are hooks in WordPress Types of hooks in WordPress How do hooks work in WordPress? Action Hooks in WordPress The most important functions of Action Hooks Filter Hooks in WordPress The most important functions of filter hooks in WordPress A practical application to deal with hooks in WordPress programmatically Explanation of the plugin code: Important sources for learning WordPress hooks professionally Conclusion What are hooks in WordPress Hooks in WordPress On any WordPress site there are three basic elements that work together to form and display the site’s pages in their final form It is the WordPress core, the WordPress template, and the external plugins activated on the site.

The WordPress core runs the basic functionality of a website, while plugins and themes add more features and functionality to the site and control its appearance, both of which make extensive use of hooks. The main task that hooks do in WordPress is to allow WordPress developers to modify or add features to the default WordPress features without compromising the core files of WordPress itself. It allows you to extend WordPress by having it execute your own code, and connect that code at specific points or places to automatically run your custom code.

Core WordPress includes more than 2,200 virtual hooks that allow the developer to specify the exact place where he wants to hook and run his custom code. You can see a list of all these hooks and when they work at the following link Once you associate your code with a hook you will be able to direct your code to do anything custom on your site. For example, you can use hooks to automatically send an email to all your followers after each article is published on the site.

The Plugin API powers hooks functionality in WordPress. You can use hooks by calling specific WordPress functions called Hook Functions that are called in certain situations that occur while running WordPress. Using hook functions, you can compile your code into a function or callback function and link it to any hook.

The callback functions can be used either as regular PHP functions, or as default WordPress functions, or you can write your own custom programming functions depending on what you want to implement on the site. (You can visit the next page in the official WordPress Developer Guide for more instructions on WordPress functions.) Once you associate the hook with this callback function, this callback function will run everywhere the hook occurs, allowing the WordPress developer to add new features to or modify the default WordPress features. Types of hooks in WordPress The WordPress system provides two types of hooks: Action Hooks, which allow the developer to execute a specific task or command at pre-defined points in WordPress runtime. Filter hooks, which allow the ability to modify any data processed by WordPress and return this modified data.

Types of hooks in WordPress In the following paragraphs, we will discuss each of these types and their most important dependencies in more detail. But before you, let us explain how hooks work in WordPress in more detail, knowing that in some cases you can use an action hook or a filter to perform the same task and get the same result. So, as a WordPress developer, you have to know when to use one or the other.

How do hooks work in WordPress? WordPress hooks, as we explained earlier, enable developers to interact with their website or modify it as they want. We have 3 types of programming functions that work in the hook system: the hooks themselves, both types (Action hooks or Filter Hookd), and these hooks are already present in the WordPress code.

By itself, it does not do anything. Rather, it exists only in the code and waits for one of the hook functions to activate it. Hook functions (Action functions and Filter functions) are used to associate or register hooks with callback functions.

Callback functions that include custom code that the developer wants to execute when the associated hook occurs. hooks functions in wordpress Image source: https://kinsta.com/blog/wordpress-hooks/ Note: It does not matter the order in which you use these functions in your code. You can first define the callback function and write custom code within it, then register it and associate it with the required hook. But it is better to place them close to each other within the code for easy understanding of their connection to each other.

These functions provide you with the ability to intervene in the process of building website pages and give you more control over what you build. To better understand how hooks work, you can imagine that your website is a building being built, and the hooks themselves are a lever that moves elements back and forth to and from that building. The items that hooks move or bring into the building are callbacks that contain the custom code you want to execute.

These elements (or functions) can help you in the process of building or modifying a home. We can only carry certain things on specific vectors connected to certain hooks, so action hooks can only be linked to Action Functions like add_action() and remove_action() and Filter hooks can only be hooked to Filter Functions like add_filter() and remove_filter() (we'll explain what each of these functions do in detail later) Actions do not pass any value to their callbacks and can perform any task, including changing the way the core functions. WordPress. While filter functions need to pass an argument to their callback function, they are only able to modify the data passed to them by filters and must return the modified values ​​as usable output.

For example, you can modify the text in a post by hooking the callback function to the publish_post action hook and change the content of the post when it is saved in the database as follows: // define the callback function to change the text function change_text_callback() { // add the code to change text here } // hook in to the 'publish_post' action with the add_action() function add_action( 'publish_post', 'change_text_callback' ); Alternatively, you can register another callback function, this time using the the_content filter hook, in order to modify the content of the article before displaying it in the browser, as follows: // define the callback function to modify the text function change_text_callback( $content ) { // add the code to change text here and then return it return $filtered_content; } // hook in to 'the_content' filter with the add_filter() function add_filter( 'the_content', 'change_text_callback'); Do things seem confusing and complicated to you? Don't worry, in the following paragraphs we will explain more about hooks and attach practical examples to explain it better. Action Hooks in WordPress ACTION HOOKS Action Hooks in WordPress are defined through the do_action function, which takes the following form: do_action( 'action_name', ); Whereas: action_name is a text string that represents the name of the event or action that will occur on the site, and it is usually an expressive name that explains the meaning of this event.

[optional_arguments] is a field for optional variables or arguments that can be passed to the callback function. If no value is specified for this field, its default value will be empty. For example, the following action hook: do_action( 'wp_head' ) is a function that represents an action hook through which you can run custom code every time WordPress displays the header of your site. This hook does not have any arguments or parameters. The following action hook do_action( 'wp_footer' ) is a function that represents an action hook through which custom code can be run every time WordPress displays a footer on your site. This hook also does not have any additional arguments or parameters.

The most important action hook functions. In this paragraph, we explain the most important programming functions that are used with action hooks in WordPress. The add_action function. The add_action() function is considered the most widely used action hook function, and it is mainly used to connect your callback function to a specific action hook. This way we tell WordPress to execute the callback function code when this action occurs. Therefore, this function accepts two arguments: the name of the action that you want the code to execute when it occurs, and the callback function that contains this code.

add_action( 'hook_action_name', 'callback_function'); For example, to execute the wporg_callback() function when the init hook occurs, we write the following code: add_action( 'init', 'wporg_callback' ); function wporg_callback() { // Write here the code you want to execute } The add_action() function can also accept two optional additional parameters or arguments, namely priority and number of parameters. 1- Priority: It is a positive integer whose default value is 10. This parameter determines the priority of executing the callback function associated with the hook. The lower the priority value, the earlier the function will be run. The priority parameter is important when a developer wants to bind multiple callback functions to a hook and wants to avoid getting incorrect results from the order in which these functions are executed. For example, if we associate 3 callback functions with a hook, as follows: foo1() has a priority value of 11 foo2() has a priority value of 10 foo3() has a priority value of 9, this means that when the hook occurs, the foo3() function will be run first, then the foo2() function, then the foo1() function.

If their priorities are the same, the functions will be run in the order in which they are linked within the code. 2- Number of parameters Accepted args: By default, any callback function associated with the hook through the add_action() function receives only one argument. But sometimes you may need to pass additional arguments to the callback function.

That's why the add_action() function can accept additional optional arguments with which you can set the number of arguments you need. For example, the comment_post hook is executed immediately after WordPress adds a comment to an article in the site's database. If you do not set the number of arguments parameter for this hook, only one value will be passed to its associated callback function, in this case the comment_ID.

If you want to set an additional parameter that represents a boolean comment_approved that takes 1 if the comment is approved and 0 if the comment is rejected because it is marked as spam, pass the value 2 to the number of hook parameters as follows: add_action( 'comment_post', 'show_message_function', 10, 2 ); If you set the number of parameters to 2, this means that you can now pass two values to the response function: comment_ID and comment_approved, so that you can execute a specific code in this function only when you verify that the comment is approved and not an annoying comment, as follows: function show_message_function( $comment_ID, $comment_approved) { // check whether a comment is approved with the second parameter if( 1 === $comment_approved ){ // Write the code you want here. Implement it only if the comment is acceptable} } You can, of course, pass as many parameters or arguments as you need and your code, but make sure that both the add_action() function and the callback function have the same number of arguments. The do_action function, as we explained previously, is used by the WordPress system itself to define all default action hooks in the system in order to allow other functions to bind and register with these hooks. As a WordPress developer, you can use this function to create your own new custom action hook by specifying the name of this hook as the function's argument, and you can optionally pass any additional parameters to it in case you want to use your own callback functions as follows: do_action( 'action_name', , ); The do_action_ref_array function: This function is similar to the do_action() function in the way it works, but the arguments are passed to it through an array.

They are useful when your brokers are already in a matrix. Or when you need to pass a lot of arguments to a function. $arguments_array = array( 'arg_1', 'foo', true, 'arg_4' ); do_action_ref_array( 'example_action', $arguments_array ); has_action function: This action function checks whether a particular hook has been attached to a function.

It receives two arguments, the first is the name of the action hook, action_name, and the second is an optional argument that represents the name of the callback function to be checked, function_to_check. If you pass both parameters to this function, it will return false if the callback function specified with the specified action hook is not registered. If you pass only the first argument, it returns true if any callback function is linked to the first argument, which represents the hook name, and false otherwise.

has_action( 'action_name', 'function_to_check' ); Did_action function: This function is used to find out the number of times any action hook occurred during the operation of a site. It returns to you an integer that represents the number of times the hook occurred on your site. For example, if there is a hook that occurs or occurs several times on the site and you want to run the callback function only the first time this hook is run and not the following times, you can write the following code: add_action('example_action', 'example_callback_function' function example_callback_function() { if( did_action( 'example_action' ) === 1 ) { // Here write the code you want to execute when the 'example_action' hook occurs for the first time only } } function remove_action This hook function removes or unlinks the callback function associated with the specified action hook. For example, you can use this function to remove the default WordPress functions associated with built-in actions hooks and replace them with your own. remove_action( 'action_name', 'function_to_be_removed', ); In order to use this function, both the function_to_be_removed arguments representing the callback function you want to unbind and the priority argument must be the same as the arguments to the function through which add_action() is binding.

It should be noted that you cannot call this function directly within the code. Rather, you must need to call it from within another function. Likewise, you cannot remove the callback function through this function before you link it to the original or after it is run in the code. For example, the WooCommerce plugin uses this function to remove the default thumbnail of the product from the store's home page through the following code: remove_action( 'woocommerce_before_shop_loop_item_title', 'woocommerce_template_loop_product_thumbnail', 10 ); Function remove_all_action This function is used to remove all callback functions associated with a given action hook. All we have to do to do this is pass it an argument that represents the name of the required hook.

You can also optionally pass a priority parameter as follows. remove_all_actions( 'action_name', ); Be careful that this function cannot be called from within the same code as the action hook that you want to unlink from the callback function, otherwise you will end up with code that contains an infinite loop. Function doing_action This function returns a boolean value (true or false) that specifies whether the action hook passed as its argument is currently running.

All you have to do is pass it an argument that represents the hook name as follows: if ( doing_action( 'action_name' ) ) { // execute your code here } This function can also be used without arguments, in which case it will return true if any hook occurs during the site's operation, as follows. if ( doing_action() ) { // the code here is run when any action is fired } Filter Hooks in WordPress FILTER HOOKS Filter Hooks are defined in WordPress through the apply_filters function, which has the following form: apply_filters( 'filter_name', 'value_to_be_filtered', ); Where: filter_name is a text string representing the name of the filter. value_to_be_filtered is a variable representing the value to be modified or filtered and returned are arguments that can optionally be passed to the filter.

Core WordPress uses a lot of built-in filters to modify the data used by its various functions. For example, the following filter hook: apply_filters( 'admin_footer_text' , string $text) is a filter through which the text string (Thank you for using WordPress) can be modified, which is usually displayed in the footer of the site admin control panel, as shown in the following image: admin_footer_text The most important functions of filter hooks in WordPress In this paragraph we explain the most important programming functions that are used with filter hooks in WordPress The function add_filter The add_filter() function is considered one of the most widely used and famous filter hook functions. It is used to connect the callback function to a specific filter hook. Therefore, we pass to this function two arguments, which are the name of the filter and the callback function to be associated with this filter, as follows: add_filter( 'hook_filter_name', ;'callbak_function'). Similar to the add_action() function, this function can also be optionally taken Two additional arguments are: priority is an integer that represents the execution priority so that each associated callback function is run according to its own priority order and the number of arguments accepted args which is an integer that you can pass to the function if you need to pass a number of additional arguments to the callback function associated with the filter (the callback function accepts one argument by default). We mention here that the callback function that connects with filter hooks must return a value after executing its code as follows: add_filter( 'hook_filter_name', 'example_callback' ); function example_callback( $example ) { // Maybe modify $example in some way.

return $example; } Function has_filter This function verifies whether the specified filter is associated with any callback function. It receives two arguments, the first is the name of the filter and the second is an optional argument that returns the name of the callback function as follows: has_filter( 'filter_name', 'function_to_check' ); If you pass only the first argument to the has_filter function, it will return True if filter_name is associated with any function whatsoever. If you pass two arguments to it, it will return an integer representing the priority value assigned to this function over this filter if the mentioned callback function is associated with the specified filter, and it will return a logical value of False otherwise. The application_filters function is similar to the do_action() function in action hooks. It runs any callback functions associated with this filter wherever this function exists within the WordPress code.

You can also use this function to create a new custom filter by specifying the filter name and filter value as arguments as apply_filters( 'filter_name', 'value_to_filter', , ); Application_filters_ref_array function This function is similar to the application_filters function that we explained in the previous paragraph, but the difference here is that all the arguments passed to this function are grouped in the form of an array. Therefore, this function is useful if there are multiple arguments that need to be passed or if the arguments already exist within an array. // an example array $arguments_array = array( 'some_value', 'foo', false, 'another_value' ); apply_filters_ref_array( 'example_filter', $arguments_array ); The current_filter function, although its name is related to filters, returns the name of the current hook being run in WordPress, whether it is a filter hook or an action hook.

It does not need to pass any arguments to it because it works within the code of the callback function and is used as follows: function example_callback() { echo current_filter(); // 'the_title' will be echoed return } add_filter( 'the_title', 'example_callback' ); remove_filter function This function deletes the callback function bound to the filter hook specified as an argument. It works similarly to the remove_action function for action hooks. This function can be used to delete registered default WordPress functions associated or registered with a specific filter hook, and link your own callback functions when needed. remove_filter( 'filter_name', 'function_to_be_removed', ); To unbind a callback function bound to a particular filter, both the function_to_be_removed and priority arguments must be identical to the arguments used when binding the callback function to that filter.

If the filter was added from within a class, which is what usually happens when adding it through a custom WordPress plugin, then you need to access the class variable to be able to remove the filter as follows. // access the class variable first, and then remove the filter through it global $some_class; remove_filter( 'the_content', array($some_class, 'class_filter_callback') ); For example, the WooCommerce plugin uses a callback function called wc_lostpassword_url() associated with the lostpassword_url filter hook in order to redirect users who click on the “Forgot your password” link? When any user clicks on this link, they will be taken to a custom page with a custom URL of www.domain/my-account/lost-password instead of being taken to the regular URL used to log in to WordPress. www.domain/wp-login.php Suppose you want to reset this function and send users to the default password recovery page or send them to any other custom page you want, you can unbind the wc_lostpassword_url callback function from the filter as follows: remove_filter( 'lostpassword_url', 'wc_lostpassword_url', 10 ); function remove_all_filter This filter function removes all the callback functions that were created Hook them into a defined filter hook similar to the remove_all_actions function for action filters.

remove_all_filters( 'filter_name', ); For example, Advanced Excerpt removes all default functions associated with the _excerpt filter and get_the_excerpt filter. It then associates its own callback functions with these filters.

if ( !

has_filter( 'get_the_excerpt', array( $advanced_excerpt, 'filter_excerpt' ) ) ) { remove_all_filters( 'get_the_excerpt' ); remove_all_filters( 'the_excerpt' ); add_filter( 'get_the_excerpt', array( $advanced_excerpt, 'filter_excerpt' ) ); } function do_filter This filter function checks whether the specified filter is currently running, returning True if the hook is running and False otherwise. if ( doing_filter( 'save_post' ) ) { // run your code here } A practical application for dealing with hooks in WordPress programmatically. After having formed a comprehensive theoretical idea about the mechanism of how hooks work in WordPress, their types, and their most important programming dependencies, let us now apply all of this through an integrated practical example that shows you the use of hooks. Before that, I remind you that working programmatically with hooks within WordPress requires that you have basic knowledge of developing custom WordPress plugins, developing WordPress templates from scratch, and how to create a child template from an existing template.

Hook functions in WordPress plugins are usually registered in dedicated PHP files within plugins, or within WordPress templates (in the main theme’s functions file, functions.php, or within a child template of the primary template activated on your site). Please note that you can also edit the WordPress kernel files directly to register hooks, but this method is not preferable because you will lose any modifications you make if you update WordPress. For the same reason, it is not preferable to add your hooks inside the main template, but rather within a child template of the template itself. For example, to illustrate how hooks work in WordPress, we will create a new plugin called tryhooks that will customize the logo and link displayed on the WordPress login page located at http://example.com/wp-login.php using hooks. Instead of displaying the WordPress logo in the interface shown above, clicking on which leads to the official WordPress website, we will display the WordPress logo in Arabic, and clicking on it will take us to the main page of the site as follows: To do this, we will create the beginning of a folder for the custom plugin named tryhooks in the /wp-content/plugins/ directory.

Inside this folder, we create a file called tryhooks.php, edit it, and add the following code to it: #login h1 a, .login h1 a { background-image: url(/plugins/tryhooks/images/wparlogo.png); height:300px; width:300px; padding-bottom: 5px; background-size: 300px 300px; background-repeat: no-repeat; }