How To Create A WordPress Plugin

Posted on July 17 by Andy Leverenz in Tips & Tricks | 44 comments

WordPress Plugins allow users to easily modify, customize, and enhance any WordPress
website. Instead of changing the core software WordPress is built on you can rather create a
plugin to extend it. Using plugins allows you to have the most optimized WordPress
installation all while maximizing how you use the software to begin with.
This article will walk you through the steps in creating a WordPress plugin.

What is a WordPress Plugin?

Here is the basic definition found on the WordPress Codex.

WordPress Plugin: A WordPress Plugin is a program, or

a set of one or more functions, written in the PHP scripting
language, that adds a specific set of features or services to
the WordPress weblog, which can be seamlessly integrated
with the weblog using access points and methods provided
by the WordPress Plugin Application Program Interface
(API).

Creating a Plugin
When creating a WordPress plugin there are some standards to uphold to when doing so.
Below Ill outline some key points to remember when creating your own.

Plugin Name

If youre planning on making a plugin that doesnt exist yet you will need to first determine its
name. To be extra sure you will want to do a search in the WordPress Plugin repository.
Some developers choose a name that describes more of what the plugin does so the end
user can establish a quick connection with the name. The name itself can be multiple words.

Plugin Files
Typically a plugin lives within its own folder under wp-content/plugins/ inside your
WordPress installation. There is usually at least one PHP file that is typically named after the
plugin. So if your plugin was named amazing-plug then your PHP file name would most likely
be amazing-plug.php. Using a unique name is crucial so no two plugins use the same
name.
You can also choose to split your plugin into multiple files; similar to the way WordPress is
built. Assets such as images, CSS, and JavaScript are common to see within installed
plugins.

Readme File
Readme files are useful for other developers and users. Usually these files give a quick
description of the plugin as well as sometimes offer change logs which indicate previous
updates and maintenance announcements to users.

Home Page
If you plan to share you plugin with the WordPress community, having a dedicated home
page would be wise. This page can be used as a place to download the plugin, report bugs,
and announce updates to your user community.

Standard Plugin File

A plugin must contain a bit of meta information which tells WordPress what it is and how to
handle it within your website. Plugins can be installed, deleted, activated, and inactivated. A
standard header is introduced below to establish your plugins presence. The parameters
shown will tell WordPress how to optimize it within your website and WordPress admin area.
<?php
/**
* Plugin Name: My Plugin Name
* Plugin URI: http://mypluginuri.com/
* Description: A brief description about your plugin.
* Version: 1.0 or whatever version of the plugin (pretty self explanatory)
* Author: Plugin Author's Name
* Author URI: Author's website
* License: A "Slug" license name e.g. GPL12
*/

The minimum WordPress needs to establish your file as a plugin is the line
Plugin Name: My Plugin Name

The rest of the information will be displayed within the Admin area under the Pluginssection.

Programming the Plugin

Now the time comes to create our own demo plugin. Ill be working on a local copy of
WordPress using the our Divi 2.0 theme. You can follow along whichever method you prefer
but to limit any downtime on your website I suggest you work locally or on a testing server.
Our blog features other posts about installing WordPress locally if you are new to the
concept. Find the links below depending on your platform.
Links:

How To Install WordPress Locally On A Windows Computer

How To Create A Local WordPress Installation On A Mac

For this tutorial I will be creating a plugin that creates a custom post type for our blog as well
as establishes some other custom parameters. This plugin will be useful because we will be
able to use it among any theme rather than just modifying one.

Plugin Scope
Our plugin will start with a simple PHP file. We will call this file custom-musicreviews.php. Within our file we will create a custom post type as well as define some new
categories within that post type. The purpose of this plugin will be to write music reviews
within specific genres without needing to touch code in the future. Each review will have a
feature image, excerpt, rating, and genre type.

Starting Off
Assuming you have a local copy of WordPress ready to use, navigate to your wpcontent folder inside of a code editor of your choice. Inside that folder you should see a
folder called plugins. Inside of that folder create a new folder called custom-musicreviews.
With the folder created create a new file inside it called custom-music-reviews.php.
The path to the file should now be wp-content/plugins/custom-musicreviews/custom-music-reviews.php.
With your new file created we need to add some parameters in comment form like I explained
earlier. For our plugin our parameters will look like this:
<?php
/**
* Plugin Name: Custom Music Reviews
* Plugin URI: http://elegantthemes.com/
* Description: A custom music review plugin built for example.
* Version: 1.0
* Author: Andy Leverenz
* Author URI: http://justalever.com/
**/

With this information added, save your file and navigate to your WordPress admin area. Click
on Plugins on the left side navigation and you should now see our plugin available. Wasnt
that easy?

With our parameters in place our plugin becomes available to activate under Installed Plugins.

Even though our file is empty we can go ahead and activate the plugin. Go ahead and do that
now. Youll hopefully notice nothing different about your site with the plugin activate. If you do
you probably typed the content above wrong or failed to close the comment.

Adding Our Plugin Code

With our file all set up and plugin active we can now add the inner workings of the plugin
which we will be using for this tutorial.
Add the code below:
// Register the Custom Music Review Post Type

function register_cpt_music_review() {

$labels = array(
'name' => _x( 'Music Reviews', 'music_review' ),
'singular_name' => _x( 'Music Review', 'music_review' ),
'add_new' => _x( 'Add New', 'music_review' ),
'add_new_item' => _x( 'Add New Music Review', 'music_review'),
'edit_item' => _x( 'Edit Music Review', 'music_review' ),
'new_item' => _x( 'New Music Review', 'music_review' ),
'view_item' => _x( 'View Music Review', 'music_review' ),
'search_items' => _x( 'Search Music Reviews', 'music_review'),
'not_found' => _x( 'No music reviews found', 'music_review'),
'not_found_in_trash' => _x( 'No music reviews found in
Trash', 'music_review' ),
'parent_item_colon' => _x( 'Parent Music Review:','music_review' ),
'menu_name' => _x( 'Music Reviews', 'music_review' ),
);

$args = array(
'labels' => $labels,
'hierarchical' => true,
'description' => 'Music reviews filterable by genre',
'supports' => array( 'title', 'editor', 'author','thumbnail', 'trackbacks'
, 'custom-fields', 'comments', 'revisions','page-attributes' ),
'taxonomies' => array( 'genres' ),
'public' => true,
'show_ui' => true,
'show_in_menu' => true,
'menu_position' => 5,
'menu_icon' => 'dashicons-format-audio',
'show_in_nav_menus' => true,
'publicly_queryable' => true,
'exclude_from_search' => false,
'has_archive' => true,
'query_var' => true,
'can_export' => true,
'rewrite' => true,
'capability_type' => 'post'
);

register_post_type( 'music_review', $args );

}

add_action( 'init', 'register_cpt_music_review' );

This code above may look like a lot and almost seem like an unknown language to you if
youre new to WordPress but if not youll recognize this code as a Custom Post Type. In this
case our custom post type is called music_review. The code is essentially telling WordPress
to establish a new type of post within your theme. The post type has parameters that go
along with it such as labels, arguments, and more. I wont go into a ton of detail on how
Custom Post Types work because Ive already covered it within another article on Elegant
Themes. Be sure to read it to gain a full understanding.
With our post type set up you can already see it active within the WordPress admin area.
Our custom post type is successfully implemented.
Lets take things one set further and include a custom Taxonomy called Genre inside our
plugin. Think of a Taxonomy as a type of categorizing feature that is completely custom.
WordPress already includes Categories and Tag support by default but developers can
create custom taxonomies to extend their themes or plugins even further.
Read more about WordPress Taxonomies here.

Add the code below under the custom post type function we just added.
function genres_taxonomy() {
register_taxonomy(
'genres',
'music_review',
array(
'hierarchical' => true,
'label' => 'Genres',
'query_var' => true,
'rewrite' => array(
'slug' => 'genre',
'with_front' => false
)
)
);
}
add_action( 'init', 'genres_taxonomy');

Registering a new Taxonomy is relatively easy. We have made the connection to our custom
post type by using the
register_taxonomy() function which creates a new taxonomy called genres and assigns
it to our post type music_review.
We need to add one more line to our custom post type to make everything sync up. Add this
code just below the supports argument within the custom post type.
Heres all our plugin code up until this point. For better legibility Ive stripped our code of any
comments we had prior to this.
function register_cpt_music_review() {

$labels = array(
'name' => _x( 'Music Reviews', 'music_review' ),
'singular_name' => _x( 'Music Review', 'music_review' ),
'add_new' => _x( 'Add New', 'music_review' ),
'add_new_item' => _x( 'Add New Music Review', 'music_review'),
'edit_item' => _x( 'Edit Music Review', 'music_review' ),
'new_item' => _x( 'New Music Review', 'music_review' ),
'view_item' => _x( 'View Music Review', 'music_review' ),
'search_items' => _x( 'Search Music Reviews', 'music_review'),
'not_found' => _x( 'No music reviews found', 'music_review'),
'not_found_in_trash' => _x( 'No music reviews found in
Trash', 'music_review' ),
'parent_item_colon' => _x( 'Parent Music Review:','music_review' ),
'menu_name' => _x( 'Music Reviews', 'music_review' ),
);

$args = array(
'labels' => $labels,
'hierarchical' => true,
'description' => 'Music reviews filterable by genre',
'supports' => array( 'title', 'editor', 'author','thumbnail', 'trackbacks'
, 'custom-fields', 'comments', 'revisions','page-attributes' ),
'taxonomies' => array( 'genres' ),
'public' => true,
'show_ui' => true,
'show_in_menu' => true,
'menu_position' => 5,
'menu_icon' => 'dashicons-format-audio',
'show_in_nav_menus' => true,
'publicly_queryable' => true,
'exclude_from_search' => false,
'has_archive' => true,
'query_var' => true,
'can_export' => true,
'rewrite' => true,
'capability_type' => 'post'
);

register_post_type( 'music_review', $args );

}

add_action( 'init', 'register_cpt_music_review' );

function genres_taxonomy() {
register_taxonomy(
'genres',
'music_review',
array(
'hierarchical' => true,
'label' => 'Genres',
'query_var' => true,
'rewrite' => array(
'slug' => 'genre',
'with_front' => false
)
)
);
}
add_action( 'init', 'genres_taxonomy');

The only line that changed was the 'taxonomies' => array('genre') line within our
custom post type. I added this line to tell our custom post type to connect to our new
taxonomy and use it instead of the default category or tag structure WordPress comes
installed with.
If youve made it this far you can now visit your WordPress admin area and see your new
custom post type and taxonomy(Genres) present. Congrats!

Our custom post type and taxonomy are successfully implemented. Here we can add a new Music Review
which contains various types of genres decided upon by the user.

Getting Our Code To Output

Below Ill try adding a new music review. You should see the new Genres section that we set
up with our custom Taxonomy. With some data entered Ill publish the post.

Create a new music review as an example.

At this point we have our functionality set up within our plugin.

In order to make things effortless we will rely on the plugin to create a new page calledMusic
Reviews. The page will be referenced by our plugin and output any new music reviews the
user posts. We are doing this so the user doesnt have to edit a single line of code.

Tying it All Together

Our code now works but we should create a page that will use
// Function used to automatically create Music Reviews page.
function create_music_review_pages()
{
//post status and options
$post = array(
'comment_status' => 'open',
'ping_status' =>

'closed' ,

'post_date' => date('Y-m-d H:i:s'),

'post_name' => 'music_review',
'post_status' => 'publish' ,
'post_title' => 'Music Reviews',
'post_type' => 'page',
);
//insert page and save the id

$newvalue = wp_insert_post( $post, false );

//save the id in the database
update_option( 'mrpage', $newvalue );
}

And finally we need to create our Music Reviews page once the plugin is activated. Adding
the code below initiates the function we just wrote above ( function
create_music_review_pages(){}).
// // Activates function if plugin is activated
register_activation_hook( __FILE__, 'create_music_review_pages');

Testing
Our plugin should be ready to test at this point. Lets create an example music review and see
what outputs.

Create another music review to verify our plugin is working correctly.

If you click View Music Review once the post is published you should be taken to a screen
which looks similar to the image below. Your theme and styles may vary

The single page music review template

You may notice that I modified the menu to include our new Music Reviews page. Doing this
gives us easy access.

Adjusting primary navigation to include Music Reviews page

With your menu in place and saved click on Music Reviews to see all the posts we have
made so far.
Based on the page template supplied by your theme the Music Review should output all
together and be clickable through to the single review template. You will probably notice that
the music review I posted earlier has output as well as the one we just created.

Our music reviews on the Music Review page

Our feature image, title, genre, and review all have posted successfully. Our plugin works!
To verify, you can deactivate the plugin and reinstall it or activate it. Upon doing so a new
Page called Music Reviews should be created. You can delete or reuse the one from before
if there are duplicates but there should be only one Music Reviews page. We could have
added a function to delete and restore this page within our plugin but I wanted to keep things
as simple as possible.

Finish
Our plugin is a relatively simple one. You can extend it so much further by including its own
predefined templates, custom widgets, more taxonomies and so much more. Creating a
plugin is no easy feat. You will want to plan your plugin before even moving to development.
Knowing what you can an cant do with WordPress before coding your own plugin is a crucial
step to developing a quality one. The plugin create in this tutorial is meant to teach by
example. There are better standards to follow and more useful practices to endure. Be sure
to read the WordPress Codex and get familiar with the WordPress Plugin API. If a plugin isnt
out there and you need custom functionality for your website then I stronger encourage trying
to create your own!

Plugin API
Languages: English Espaol Franais Portugus do Brasil () (Add your
language)

Contents

1 Introduction

2 Hooks, Actions and Filters

3 Function Reference

4 Actions

4.1 Create an Action Function

4.1.1 Avoiding Function Name Collisions

4.2 Hook to WordPress

4.3 Install and Activate

4.4 Current Hooks For Actions

5 Filters

5.1 Create a Filter Function

5.2 Hook in your Filter

5.3 Install and Activate

5.4 Current Hooks for Filters

5.5 Example

6 Removing Actions and Filters

7 Pluggable Functions

8 Activation/Deactivation/Uninstall

9 Related

10 External Resources

Introduction
This page documents the API (Application Programming Interface) hooks available to WordPress plugin
developers, and how to use them.
This article assumes you have already read Writing a Plugin, which gives an overview (and many details) of
how to develop a plugin. This article is specifically about the API of "Hooks", also known as "Filters" and
"Actions", that WordPress uses to set your plugin in motion.
These hooks may also be used in themes, as described here.

Hooks, Actions and Filters

Hooks are provided by WordPress to allow your plugin to 'hook into' the rest of WordPress; that is, to call
functions in your plugin at specific times, and thereby set your plugin in motion. There are two kinds of hooks:
1. Actions (Codex Action Reference)

2. Filters (Codex Filter Reference)

You can sometimes accomplish the same goal with either an action or a filter. For example, if you want your
plugin to change the text of a post, you might add an action function to publish_post (so the post is modified
as it is saved to the database), or a filter function to the_content (so the post is modified as it is displayed in
the browser screen).
For a thorough listing of all action and filter hooks in WP see Adam Brown's WordPress Hooks Database.

Function Reference
Filter Functions

has_filter()
add_filter()
apply_filters()
apply_filters_ref_array()
current_filter()
remove_filter()
remove_all_filters()
doing_filter()

Actions Functions

has_action()
add_action()
do_action()
do_action_ref_array()
did_action()
remove_action()
remove_all_actions()
doing_action()

Activation/Deactivation/Uninstall Functions

register_activation_hook()
register_uninstall_hook()

register_deactivation_hook()

Actions
Actions are triggered by specific events that take place in WordPress, such as publishing a post, changing
themes, or displaying anadministration screen. An Action is a custom PHP function defined in your plugin (or
theme) and hooked, i.e. set to respond, to some of these events. Actions usually do one or more of the
following:

Modify database data.

Send an email message.

Modify the generated administration screen or front-end page sent to a user browser.
The basic steps to make this happen (described in more detail below) are:

1. Create a PHP function that should execute when a specific WordPress event occurs, in your plugin file.
2. Hook this function to the event by using the add_action() function.
3. Put your PHP function in a plugin file, and activate it.

Create an Action Function

The first step in creating an action in your plugin is to create a PHP function with the action functionality of your
plugin, and put it in your plugin file (your plugin file must go into the wp-content/plugins directory). For example,

if you want your friends to get an email message whenever you create a new post, you might define the
following function:

function email_friends($post_ID)

$friends = 'bob@example.org,susie@example.org';

mail($friends, "sally's blog updated",

'I just put something on my blog: http://blog.example.com');

return $post_ID;

For most actions, your function should accept a single parameter (usually the post or comment ID, depending
on the action). Some actions take more than one parameter -- check the documentation for the action (if
available) or the WordPress source code for more information. Besides the one parameter, you can also access
the global variables of WordPress, and call other WordPress functions (or functions in your plugin file).
Any text output by the function (e.g. with print) will appear in the page source at the location where the action
was invoked.
NOTE: Keep in mind that other plugins or the WordPress core may already be using the function name you
have thought of. See the next section, Avoiding Function Name Collisions for more information.

Avoiding Function Name Collisions

It is possible that someone has created a plugin with a function named the same as one in your plugin!
This is a problem because PHP does not allow multiple functions with the same name. If two plugins provide
function with the same name, or a plugin provides a function with a name the same as a WordPress function,
the blog could cease to function. There are two ways to avoid this problem.
The first solution is to prefix every function in your plugin with a unique set of characters. If your name is John
Q. Public, you might declare your functions as function jqp_output() {...}. The likelihood that someone with
the same initials does the same thing with their plugin is possible, but low.
The second - and possibly easier - solution is to enclose your plugin functions in a class and call the class
methods statically. This sounds more complicated than it is.
Consider this class, which expands on the examples provided above:

class emailer {

static function send($post_ID)

$friends = 'bob@example.org,susie@example.org';

mail($friends,"sally's blog updated",'I just put something on my blog:

http://blog.example.com');

return $post_ID;

add_action('publish_post', array('emailer', 'send'));

This class, called emailer has a method send that implements the plugin functionality.
The add_action() function outside of the class adds the action to WordPress that tells it to call the send method
when a post is published. The array used in the second parameter tells the plugin system to call the static
method of the class 'emailer' named 'send'.
The function send is protected from the global namespace by the class declaration. It is not possible to call
send() directly, and so any other function named send will not collide with this one. If you did want to call send(),
you would need to use a scope resolution operator, like this: emailer::send()
The above example is for static methods. If you have an instance of a class then that won't work. To call a
method of an instance you need to pass the instance as a variable. Consider the above example modified to
take this into account:
class emailer {

function send($post_ID)

$friends = 'bob@example.org,susie@example.org';

mail($friends,"sally's blog updated",'I just put something on my blog:

http://blog.example.com');

return $post_ID;

$myEmailClass = new emailer();

add_action('publish_post', array($myEmailClass, 'send'));

Classes are a complicated subject. Read more about them in the PHP documentation on classes.

Hook to WordPress
After your function is defined, the next step is to "hook" or register it with WordPress. To do this,
call add_action() in the global execution space of your plugin file:

add_action ( 'hook_name', 'your_function_name', [priority], [accepted_args] );

where:
hook_name
The name of an action hook provided by WordPress, that tells what event your function should be
associated with.
your_function_name
The name of the function that you want to be executed following the event specified by hook_name.
This can be a standard php function, a function present in the WordPress core, or a function defined by
you in the plugin file (such as 'email_friends'defined above).
priority
An optional integer argument used to specify the order in which the functions associated with a
particular action are executed (default: 10). Lower numbers correspond with earlier execution, and
functions with the same priority are executed in the order added to the action.
accepted_args
An optional integer argument defining how many arguments your function can accept (default 1), useful
because some hooks can pass more than one argument to your function. This parameter is new in
release 1.5.1.
Return Value
The (optionally modified) value of the first argument passed to the filter function.
In the example above, we would put the following line in the plugin file:

add_action ( 'publish_post', 'email_friends' );

Likewise, you can also Remove Actions from action hooks. See that section for details.

Install and Activate

The last step in getting your action hook to work is to install the file and activate the plugin. The PHP function
you wrote and theadd_action call must go into a PHP file together, and the PHP file must be installed in

the wp-content/plugins directory. Once it is installed, you will need to visit the admin section of WordPress and
activate your plugin; see Managing Plugins for more details.

Current Hooks For Actions

See Plugin API/Action Reference for a current list of action hooks in WordPress, and links to previous versions
of WordPress.

Filters
Filters are functions that WordPress passes data through, at certain points in execution, just before taking
some action with the data (such as adding it to the database or sending it to the browser screen). Filters sit
between the database and the browser (when WordPress is generating pages), and between the browser and
the database (when WordPress is adding new posts and comments to the database); most input and output in
WordPress passes through at least one filter. WordPress does some filtering by default, and your plugin can
add its own filtering.
The basic steps to adding your own filters to WordPress (described in more detail below) are:
1. Create the PHP function that filters the data.
2. Hook to the filter in WordPress, by calling add_filter().
3. Put your PHP function in a plugin file, and activate it.

Create a Filter Function

A filter function takes as input the unmodified data, and returns modified data (or in some cases, a null value to
indicate the data should be deleted or disregarded). If the data is not modified by your filter, then the original
data must be returned so that subsequent plugins can continue to modify the value if necessary.
So, the first step in creating a filter in your plugin is to create a PHP function to do the filtering, and put it in your
plugin file (your plugin file must go into the wp-content/plugins directory). For example, if you want to make sure
that your posts and comments contain no profanity, you might define a variable with a list of forbidden words,
and then create the following PHP function:

function filter_profanity( $content ) {

$profanities = array('badword','alsobad','...');

$content = str_ireplace( $profanities, '{censored}', $content );

return $content;

Why does this work without a loop? Because $profanities is an array, and str_ireplace loops through the array
for you. Thestr_ireplace function is used instead of str_replace because str_ireplace is case insensitive.

NOTE: Keep in mind that other plugins or the WordPress core may already be using the function name you
have thought of. See thePlugin Development Suggestions for more information.

Hook in your Filter

After your function is defined, the next step is to "hook" or register it with WordPress. To do this,
call add_filter() in the global execution space of your plugin file:

add_filter ( 'hook_name', 'your_filter', [priority], [accepted_args] );

where:
hook_name
The name of a filter hook provided by WordPress, which defines when your filter should be applied.
your_filter
The name of the function that you want to use for filtering. This can be a standard PHP function, a
function present in the WordPress core, or a function defined by you in the plugin file.
priority
An optional integer argument that can be used to specify the order in which the functions associated
with a particular filter are executed (default: 10). Lower numbers correspond with earlier execution, and
functions with the same priority are executed in the order in which they were added to the filter.
accepted_args
An optional integer argument defining how many arguments your function can accept (default 1), useful
because some hooks can pass more than one argument to your function.
In the example above, we would put the following in the main executing section of the plugin file, to tell
WordPress to filter comments for profanity:

add_filter( 'comment_text', 'filter_profanity' );

You can also remove filters from filter hooks using the remove_filter() function. See Removing Actions and
Filters.

Install and Activate

The last step in getting your filter hook to work is to install the file and activate the plugin. The PHP function you
wrote and theadd_filter() call must go into a PHP file together, and the PHP file must be installed in
the wp-content/plugins directory. Once it is installed, you will need to visit the admin section of WordPress and
activate your plugin; see Managing Plugins for more details.

Current Hooks for Filters

See Plugin API/Filter Reference for a current list of filter hooks in WordPress, and links to previous versions of
WordPress.

Example
This is an example, as described by Ozh on the wp-hackers email list, for a plugin to modify (or overwrite) the
default bloginfo()function. This will require modifying a core function behavior.
add_filter( 'bloginfo', 'mybloginfo', 1, 2 );

add_filter( 'bloginfo_url', 'mybloginfo', 1, 2 );

function mybloginfo( $result='', $show='' ) {

switch ( $show ) {

case 'wpurl':

$result = SITE_URL;

break;

case 'template_directory':

$result = TEMPL_DIR;

break;

default:

return $result;

Removing Actions and Filters

In some cases, you may find that you want your plugin to disable one of the actions or filters built into
WordPress, or added by another plugin. You can do that by
calling remove_filter('filter_hook','filter_function') orremove_action('action_hook','
action_function').
For example, remove_action('publish_post','generic_ping'); would prevent your weblog from
sending pings whenever a new post is created.

Note that if a hook was registered using a priority other than the default of 10, then you must also specify the
priority in the call toremove_action(). Also note that in general, you shouldn't remove anything unless you
know what it does and why it does it -- check the WordPress or other plugin source code to be sure.

Pluggable Functions
Besides the hooks (actions and filters) described above, another way for a plugin to modify WordPress's
behavior is to override WordPress functions. In fact, there is a small set of functions WordPress intends for
plugins to redefine. These are called Pluggable Functions and they are defined in wp-includes/pluggable.php.
WordPress loads these functions only if they are still undefined after all plugins have been loaded. For more
details examine wp-settings.php file.

Activation/Deactivation/Uninstall
If your plugin has tasks to complete only at activation or deactivation time, it can
use register_activation_hook andregister_deactivation_hook. Many plugins do not need to use
these, as the plugins only modify current behavior. However, if your plugin (for example) needs to change a
default option on activation, it can use these functions.
Creating Tables with Plugins has an example using the register_activation_hook function to make the
database compatible with the current version of the plugin.
The register_uninstall_hook gives your plugin the option of cleaning up after itself when it is deleted
from the WordPress installation. Users have reasons to temporarily deactivate plugins, so do not do anything
from the deactivation hook that would lose any user settings. This is what the uninstall hook is for.