Your cart is empty.
Keep shopping
Teach on Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn MoreComplete WordPress Theme & Plugin Development Course
Rating: 4.5 out of 54.5(4,045 ratings)
22,598 students
Complete WordPress Theme & Plugin Development Course
Everything you need to become a hirable WordPress Developer building custom themes and plugins
Created byZac Gordon
Last updated 6/2022
English
English [Auto],
What you'll learn
- PHP for WordPress - The Loop, Conditionals, Hooks and More!
- How to Work with Child and Starter Themes Like Pro
- The Ins and Outs of the Template Hierarchy - Always Know What File to Customize
- How To Enqueue and Work with JavaScript and CSS in Themes
- The Complete List of Template Tags To Use When Customizing and Extending Themes
- A Deep Understanding of How to Use Action and Filter Hooks to Programmatically Control WordPress
- A Solid Starter Template For Building Your Own WordPress Plugins
- Common Practices and Techniques for Building Custom WordPress Plugins
Explore related topics
Course content
7 sections • 176 lectures • 16h 9m total length
- Course Introduction1:59
Welcome! In this first lesson we go over what we will learn in this course.
This course does not teach, but does use HTML and CSS, so we recommend you learn that first.
Overall the course covers the following topics:
- How to setup your local environment
- How to setup you hosting environment
- PHP for WordPress (The Loop, Conditionals, Tags, Hooks, etc)
- How to work with Child Themes and Starter Themes
- The Template Hierarchy and Template Tags
- Action and Filter Hooks
- How to Start Building Plugins
- Internal WordPress REST APIs
Throughout the course you will follow along with me as I build a theme and plugin and have the opportunity to build your own theme and plugin as well :)
Next up we'll look at how to setup our local WordPress environment so we can run WordPress on our computer.
- Downloading and Using the Course Example Files0:30
- Setting Up WordPress Locally1:00
Local WordPress Development refers to running WordPress on your computer and editing the files locally, on your computer, rather than using a hosted version of WordPress to develop with.
We look at a few different options for locally running WordPress on our computers:
- DesktopServer from ServerPress
- Local from Flywheel
- Setting Up Locally
- DesktopServer from ServerPress5:16
In this lesson we look at how to run WordPress locally using DesktopServer from ServerPress.
- Local from Flywheel5:53
In this lesson we look at how to run WordPress locally using Local from Flywheel.
- Editing WordPress Files Locally4:16
In this lesson we look at how to find the WordPress files that you will need to edit when you work with Desktop and Local.
- Setting Up Locally
- Introduction to Staging10:34
- Pulling from Production to Staging to Local10:18
Learn to pull a live WordPress site from production to staging and to local development using a staging setup, the all-in-one migration plugin, and URL adjustments.
- Pushing from Local to Staging to Production9:14
- PHP for WordPress Introduction0:50
In this lesson we introduce this section on PHP for WordPress and go over what we will learn in the coming lessons:
- Explain what PHP is and how it works
- Write some PHP and learning the basics of the language
- Introduce important WordPress specific PHP things that are important to know about, like the Loop, Template Tags, and Hooks
Next up we answer the question, "What is PHP?"
- What is PHP?1:38
In this lesson we learn the PHP stands for "PHP: Hypertext Preprocessor" and runs before the HTML for a web page is generated. PHP runs a lot in WordPress and can be used outside of WordPress as well to build sites and applications.
PHP Review:
- PHP is a programming language
- It runs on the server before HTML is sent to the browser
- PHP is used quite a lot in WordPress itself and in WordPress Development
- PHP can also be used outside of WordPress in other applications and web sites
Next up we practice writing some PHP.
- What is PHP?
- Writing Some Basic PHP4:59
In this lesson we start to write some basic PHP.
Covered in this lesson:
- Opening an index.php file
- Writing a variable
- Echoing a variable
- Echoing a string of text
- Concatenating or combining variables and strings
Next up we learn some more PHP Programming Basics.
- PHP Programming Basics4:00
In text lesson we outline some of the basics of working with PHP that are important for us to know going forward. Read through and absorb what you can and in the next lesson we will look at putting some of this into practice.
- PRACTICE - PHP Basics6:44
In this lesson we work on the following practice exercise:
- Activate theme 1.4 PHP Basics (Starter)
- Create an array of post titles
- Loop through the array of posts
- Inside of the Loop, call a display_title() function and pass it the title as a parameter
- Have the display_title() function echo the title in an <h3> tag
Try practicing this on your own before checking out the completed solution and the walk through in the video.
- WordPress PHP Coding Standards5:56
In this lesson we learn about the WordPress Coding Standards.
These are guidelines and suggestions for how to write and format your PHP when working with WordPress.
You can access the WordPress PHP Coding Standards here: https://make.wordpress.org/core/handbook/best-practices/coding-standards/php/
The WordPress Coding Standards contain information around the following topics:
- Single and Double Quotes
- Indentation
- Brace Style
- Use elseif, not else if
- Regular Expressions
- No Shorthand PHP Tags
- Remove Trailing Spaces
- Space Usage
- Formatting SQL statements
- Database Queries
- Naming Conventions
- Self-Explanatory Flag Values for Function Arguments
- Interpolation for Naming Dynamic Hooks
- Ternary Operator
- Yoda Conditions
- Clever Code
- Error Control Operator @
- Don’t extract()
Not all of these may make sense to you at this point so try taking a read through these now and check back on them again at different points in the course.
- Different Types of PHP Files in WordPress8:23
In general you will find three general types of PHP files in WordPress:
- WordPress Core Files - These control how WordPress works, not edited, but interesting and possibly helpful to read through or study.
- WordPress Theme Files - These control how themes work and display content. When you are building or customizing a child theme you will definitely edit these files.
- WordPress Plugin Files - These are used when building plugins. If you are writing your own plugin or extending another plugin you will edit these files, but you would not generally directly edit the code of another plugin.
- Include Files - Small PHP files that are included in larger files appear in Core, Theme and Plugin files. You will likely come across and write them yourself.
- The Loop4:23
The Loop is a combination of a conditional statement and loop that intelligently gathers and prepares post or page content to display.
It consists of the following:
- A PHP If Statement
- A PHP While Loop
- A special WordPress function call to get the correct post or page (or custom post etc)
A basic loop looks like this:
```
<?php if ( have_posts() ) : while ( have_posts() ) : the_post(); ?>
<h2><?php the_title(); ?></h2>
<?php the_content(); ?><?php endwhile; else: ?>
<h2><?php esc_html_e( '404 Error', 'phpforwp' ); ?></h2>
<p><?php esc_html_e( 'Sorry, content not found.', 'phpforwp' ); ?></p><?php endif; ?>
```
Notice that since the PHP code is inside various self contained PHP blocks, it is also possible to use HTML inside of the Loop.
It is also possible though to have a pure PHP loop without any HTML being included between PHP blocks:
```
<?php if ( have_posts() ) : while ( have_posts() ) : the_post();
the_title( ’<h1>', ’</h1>' );
the_content();
endwhile; else:
_e( 'Sorry, no pages matched your criteria.', 'textdomain' );
endif; ?>
```
It is also possible to customize the Loop, which we will look at late in the course.
- What is the Loop?
- PRACTICE - The Loop7:30
Now it's time to practice using PHP Loop on your own:
- Activate theme 1.8 – The Loop (Starter)
- Open index.php
- Code out The Loop
- Use the_title and the_content to display the content
- Display a 404 message using _e() if no content available
- Open a page or post from WP Admin to test
Try tackling this on your own then follow along with me as I show you the approach I took.
- Template Tags2:52
Template tags are special functions that allow us to easily get information and content from WordPress.
Some popular template tags include:
- get_header()
- get_footer()
- get_sidebar()
- get_template_part()
- wp_login_form()
- bloginfo()
- the_title()
- get_the_title()
- the_content()
- the_author()
- the_category()
- the_tags()
- comment_author()
- the_post_thumbnail()
- the_permalink()
- edit_post_link()
- site_url()
- wp_nav_menu()
- PRACTICE - Template Tags11:46
Now that we've learned about template tags, it's time for you to tackle some practice on your own:
- Activate theme 1.10 – Template Tags (Starter)
- Open index.php
- Add template tags inside The Loop
- Add template tags outside The Loop
- See how many different template tags you can get working!
After you take a stab on your own, you can follow along with my solution :)
- WordPress Conditionals1:42
Conditional Tags are WordPress functions that return true when certain conditions are met.
Some common conditional tags include:
- is_front_page()
- is_home()
- is_admin()
- is_single()
- is_single( 'slug' )
- is_single( [ 'slug-1', 'slug-2', 'slug-3' ] )
- is_singular()
- get_post_type()
- has_excerpt()
- is_page()
- is_page( 'slug' )
- is_page( [ 'slug-1', 'slug-2', 'slug-3' ] )
- is_page_template( 'custom.php' )
- comments_open()
- is_category()
- is_tag()
- is_archive()
- in_the_loop()
- PRACTICE - Conditional Tags12:27
Now that you've learned about Conditional Tags, let's try practicing writing some:
- Activate theme 1.12 – Conditional Tags (Starter)
- Open index.php
- Try adding conditional tags
- Open page from admin or visit site.dev/category site.dev/tag url directly
- Might need && || !
- WordPress Hooks6:28
Hooks allow you to add custom code into existing software.
Two types of hooks exist in WordPress:
- Action Hooks let you run your own code when certain events take place in the WordPress run cycle.
- Filter Hooks let you modify how content is displayed on a page or saved to the database.
Here is an example of an Action Hook in use:
```
<?php
function my_theme_styles() {
wp_enqueue_style( 'main-css', get_stylesheet_uri() );
}
add_action( 'wp_enqueue_scripts', 'my_theme_styles' );
?>
```
Here is an example of a Filter Hook in use:
```
<?php
function my_read_more_link( $excerpt ) {
return $excerpt . '<a href="' . get_permalink() . '">Read more</a>';
}
add_filter( 'get_the_excerpt', 'my_read_more_link', 10 );
?>
```
- Intro to Hooks Quiz
- PRACTICE - WordPress Hooks11:35
Now it's time to practice writing some hooks on your own.
Try the following:
- Activate 1.14 – WordPress Hooks (Starter)
- Open the functions.php
- Try enqueueing the theme CSS via an Action Hook
- Try adding a Read More link to the_excerpt() with a filter
- PHP for WordPress Review0:36
Some important points for review:
- PHP is a server side programming language.
- Many Core, Plugin and Theme
files in WordPress are PHP. - Some basic PHP is required for WordPress Development.
- WordPress provides The Loop, Template Tags and Conditionals to make writing PHP easier.
- Action and Filter Hooks let us run our own code and modify data in WordPress programmatically.
- Chlid Themes v Starter Themes1:58
A Child Theme allows you to override another theme (parent theme) without making direct changes that are lost during updates.
A Starter Theme includes helpful files and functions for building themes from scratch. You usually edit starter themes directly, not using child themes.
Here is when to use each:
- Child Theme - Customizing an existing theme
- Starter Theme - Building sites from scratch
- Child and Starter Theme Quiz
- Child Theme Basics3:42
Child Theme
- Reference to parent theme in style.css file
- Include parent style in functions.php file
- Copies of any templates from Parent Theme you want to modify
Parent Theme
- Keeps all original files unedited
- Before loading a file, WordPress looks to see if exists in Child Theme
- Can be updated without affecting code in Child Theme
- DEMO - Child Theme5:26
In this lesson we take a look at a child theme in action.
- PRACTICE - Child Themes2:44
Now it is time for you to practice making a child theme:
- Pick a WordPress theme
- Create a Child Theme for it
- Modify the CSS and one of the templates
- You don’t need to make it look better, just get it working!
- Demo and Practice Child Theme files
- Starter Theme Basics9:59
Starter Theme Basics:
- Include common theme template files
- No CSS styles (but some include Bootstrap / Foundation)
- Extra functionality in functions.php
- Extra hooks in template files
- Follow modular file architecture
- Some include workflow tools
- Usually edited directly, not via child themes
- DEMO - Underscore Starter Theme6:53
- PRACTICE - Starter Themes4:15
In this lesson I encourage you to go practice working with a starter theme on your own:
- Choose a starter theme (I recommend JointsWP)
- Install and Activate it
- Make a CSS change
- Make a change to one of the templates
- WARNING: Not all starter themes are created equal
- Child and Starter Themes Review2:13
Child Theme Review:
- When customizing a theme use a Child Theme
- When starting from scratch use a Starter Theme
- Also possible to start with no child theme or starter theme!
- Child and Starter Theme Quiz
- An Introduction to the Template Hierarchy3:03
Explore the WordPress template hierarchy and how templates like page.php, single.php, category.php, and tag.php control content display, with fallback to index.php when templates are missing.
- Setting up the Theme Content and Files9:15
- Working with the style.css file6:11
Configure the WordPress style.css header with theme metadata to display details in the appearance themes dashboard, using WP Hierarchy as the example.
- Working with the functions.php file17:19
Discover how to configure a WordPress theme via the functions.php file by enabling theme support for post formats, post thumbnails, HTML5 features, the title tag, and enqueueing styles.
- Working with the index.php template2:29
Explore index.php as the fallback template in WordPress theme development, illustrating the WP hierarchy, combining HTML and PHP, using hard-coded data, and preparing shared header and footer templates.
- Working with Headers in WordPress6:57
Create and load header.php in WordPress, implement custom headers (such as header-splash), use get_header to switch headers, and ensure wp_head loads styles, scripts, and title tags.
- Working with Footers in WordPress3:31
- Adding Menus and body_class12:34
- Adding Markup to a Theme - Part 18:48
- Adding Markup to a Theme - Part 25:39
- Adding Markup to a Theme - Part 30:49
Add footer markup with a link to WordPress.org and a translatable 'powered by WordPress' label, ensuring splash pages function and final downloads reflect the updates.
- Working with Sidebars in WordPress3:15
- Adding Widget Areas in WordPress12:53
- Working with the Loop7:43
Explore dynamic templating with the WordPress loop, building index.php around have_posts and while have_posts to display posts, handle 404s, and streamline with template parts.
- Creating Content Includes5:15
Break up the theme's loop into modular, reusable pieces using template parts, content.php and content-none.php, organized in a template-parts folder and loaded with get template part.
- Working with the singular.php template5:25
Explore how the singular.php template fits WordPress hierarchy, with fallbacks from page, single, and attachment to singular, then to index. Decide when to use or omit singular.php to avoid redundancy.
- Working with the single.php template6:07
- Adding a single-post.php template1:58
Explore the WordPress template hierarchy by using single post templates, explain when to use single.php versus single-post.php, and how custom post types like portfolio affect fallback behavior.
- Working with the comments.php template7:41
Learn to integrate a comments.php template into your WordPress theme, load and style post comments, and conditionally display them when comments are open or closed on single posts.
- Working with Post Formats in WordPress13:21
Learn how to implement WordPress post formats, use get post format and get template part to create format-specific templates like gallery, video, and quote, with practical testing and dashicons cues.
- The home.php for the Blog Homepage12:39
Learn to implement home.php as the blog homepage, toggle latest posts or a static page, and convert the loop into linkable excerpts with permalinks, pagination, and template variations.
- Working with archive.php and Archives in WordPress3:36
Learn how archive.php powers WordPress category, tag, and author archives by copying home.php, creating a generic archive template, and implementing fallbacks to index.
- Working with the author.php template6:08
Explore the author.php template to display an author bio and their posts on the author archive page, using the author posts link and author meta.
- Working with author-id.php and author-nicename.php templates1:36
Explore author-id.php and author-nicename.php templates as author-specific fallbacks, showing how to apply per-author templates, considerations about id versus nice name, and using body class for targeted styling.
- Working with Category Archive Templates8:36
Learn how to build WordPress category archive templates with category.php, including category-id and category-slug variants. Add category descriptions and CSS-driven styling to tailor category pages.
- Working with Date Archive Templates4:57
- Working with Media Attachment Templates7:34
Explore how WordPress attachment templates route by mime type, using mime-specific templates (image.php, video.php, pdf.php) with fallbacks, and inspect post data and metadata to build flexible media templates.
- Mime Type Templates Further Explained8:26
Explore mime type templates in WordPress by building generic attachment pages for image, video, and text using attachment dot PHP, template parts, and get post mime type.
- Working with Page Templates8:08
Explore page templates in WordPress, extending page.php and using page id and slug. Customize sidebars for pages with page-specific widgets and understand fallbacks to singular.php and front-page.php.
- Working with the front-page.php Template8:33
Create a front-page.php template and set a home page to enable a front-page widget area. Move the sidebar into the primary div and register the front-page widget area in functions.php.
- Working with Custom Templates8:05
- Adding a 404.php template5:34
Design a robust 404.php template that gracefully handles not found content with an index fallback and optional search or page lists to guide visitors.
- Working with Search Templates9:56
Explore when to use site search and how to implement a flexible WordPress search template, including search.php, template parts, and displaying post types, excerpts, and the search query.
- Working with Custom Post Type Archives10:40
- Working with Custom Post Type Single Pages - Part 15:56
Explore how to build and load single pages for custom post types in WordPress, using single-portfolio.php, fallback to single.php and singular.php, and integrate custom fields with Advanced Custom Fields.
- Working with Custom Post Type Single Pages - Part 23:57
Learn to append the custom post type slug as a hyphen suffix to a portfolio template, use template parts to avoid duplication, and style with body classes or post IDs.
- Working with Custom Taxonomy Archives - Part 14:16
Set up custom taxonomies in WordPress, then build a generic archive template with taxonomy.php to display taxonomy terms on portfolio items and link to taxonomy pages.
- Working with Custom Taxonomy Archives - Part 28:02
Learn to implement custom taxonomy archives in WordPress using taxonomy.php and taxonomy-{taxonomy}.php. Customize the skills taxonomy with a portfolio-style archive and targeted term templates, including PHP, with CSS adjustments.
- Working with Multiple CSS Files6:27
Master how to load multiple CSS files in a WordPress theme by enqueuing styles, managing dependencies with the main CSS, and optionally including external fonts.
- Including JavaScript in Your Themes10:16
- Working with JavaScript Dependencies (like jQuery)7:20
- Template Hierarchy Review3:44
Master the WordPress template hierarchy, including index.php as the fallback, and learn to implement headers, footers, sidebars, widget areas, custom templates, archives, 404 and search pages, and front page behavior.
- An Introduction to Template Tags4:45
Discover the basics of WordPress template tags, including the underscore version and get underscore version, parameter use, and examples with titles and permalinks, plus hooks and filters for output control.
- General Template Tags - Introduction1:26
Explore general template tags in WordPress, including include, login, blog info, archive, calendar, and miscellaneous tags, and preview how we’ll examine their functions in upcoming lessons.
- General Tags - Include Tags6:12
Learn general WordPress template tags, including get header, get footer, get sidebar, and get template part, with parameters and defaults, plus how to read their documentation.
- General Tags - Login Tags13:08
Explore WordPress login tags, including login out and log in out, login url, log out url, and login form, and learn to display them dynamically with is_user_logged_in and optional redirects.
- General Tags - bloginfo5:06
Explore the blog info template tag and get blog info; learn parameters like name, description, and URL, and note deprecated items with alternatives like home URL or blog info URL.
- General Tags - Archive Tags - Part 17:59
Discover WordPress archive tags like single post title, post type archive title, and single term title, plus date archives and archive links, including Get Archives Link and WP Get Archives.
- General Tags - Archive Tags - Part 27:45
Explore wp get archives and get archives link to display archive lists with yearly, weekly, monthly, or alpha formats, post counts, and order, and compare sidebar code with dynamic widgets.
- General Tags - Calendar Tags3:34
Learn how the get calendar tag in WordPress displays a calendar that links dates to category archives, with optional initial and echo settings, and how to use widgets.
- General Tags - Misc Tags3:08
- PRACTICE - General Template Tags - Part 13:15
Practice building a WordPress theme from scratch using header, footer, and sidebar include tags. Load functions.php and style.css, display blog info, and add a sidebar with login/logout, calendar, and archives.
- PRACTICE - General Template Tags - Part 210:25
Practice building a WordPress theme by including header, sidebar, and footer, using bloginfo for site details, login/logout options, a calendar and archives in the sidebar, and archive titles.
- Navigation Tags8:33
Master WP nav menu and register nav menus in functions.php to set up custom menus. Learn key arguments, wrappers, depth, and fallback options for flexible navigation.
- Navigation Tags - CSS Classes4:19
Explore how WordPress assigns default CSS classes to navigation menus, such as current menu item and current page, and learn to inspect and style them for theme customization.
- Navigation Tags - Walker Class5:20
Leverage the Walker class to customize WordPress navigation output for bootstrap-style menus, wiring bootstrap CSS and WP Bootstrap Walker nav PHP via functions.php for a tailored menu.
- PRACTICE - Navigation Tags - Part 11:11
Practice building header and footer navigation menus with WordPress navigation tags, experiment with different parameters, and add custom menus to two themes including header, footer, and sidebar placements.
- PRACTICE - Navigation Tags - Part 23:59
Practice implementing navigation tags by configuring header and footer menus, defining main and footer theme locations, and adjusting depth and callback settings in functions.php for two distinct menus.
- Post Tags4:08
Explore how post tags in WordPress provide CSS classes, date data, pagination links, attachments, and get_ tags that return data across posts, pages, and custom post types.
- Post Tags - Class Tags3:48
Learn how body class and post class template tags add CSS classes to your WordPress theme for custom styling and semantic information.
- Post Tags - Common Tags - Part 111:21
Explore the most common WordPress post tags, including ID, title, content, excerpt, category, and tags, and learn how to use their parameters and wrappers in themes and queries.
- Post Tags - Common Tags - Part 27:26
Learn how WordPress excerpts work—auto, custom, and more tag behavior—and how to display categories and tags with separators and before/after options.
- Post Tags - Date Tags4:36
Learn to use WordPress date and time tags, apply PHP date formats, and handle listing behavior when dates repeat to display accurate post metadata.
- Post Tags - Attachment Tags5:05
- Post Tags - Misc Tags14:40
Learn about the less common post tags, including permalink, title attribute, short link, and post meta with get_post_meta, plus displaying custom fields like location and lodging.
- Post Tags - get_ Tags3:33
Explore the difference between get_ and the_ prefixed WordPress template tags, learn when to echo versus return values, and how to use get_the_title and related functions in themes and plugins.
- PRACTICE - Post Tags - Part 13:00
Practice implementing WordPress tags by adding body and post classes and rendering title, content, and date or time. Set up previous and next post links on listing and single views.
- PRACTICE - Post Tags - Part 22:37
- Thumbnail Tags8:51
Master enabling and displaying post thumbnails for posts, pages, and custom post types via functions.php, using theme support and template tags like the_post_thumbnail and has_post_thumbnail.
- PRACTICE - Thumbnail Tags - Part 11:36
- PRACTICE - Thumbnail Tags - Part 23:33
Enable post thumbnails in your WordPress theme and display them on listing and single pages using thumbnail tags with proper size and alignment, while choosing echo or get appropriately.
- Link Tags6:18
Explore WordPress link tags in depth, from permalinks and get permalink alternatives to editing and deleting post links, and to home, site, search, and RSS links.
- PRACTICE - Link Tags - Part 11:34
Practice implementing permalink or get permalink in your WordPress theme, add edit post and edit pages links for front-end editing, and use home URL or site URL where appropriate.
- PRACTICE - Link Tags - Part 22:24
Master WordPress template tags by using permalink and get_permalink, home url, and site url across header, index, and sidebar, with edit post and logout links.
- Introduction to Comment Tags13:59
- Common Comment Tags8:41
Explore how WordPress handles common comment tags, including author, avatar, date, time, text, and IDs, plus nested threaded comments, replies, pagination, and open/closed settings.
- PRACTICE - Comment Tags - Part 12:22
Practice wiring WordPress comment templates with a custom function and a WP list comments callback to load templates, enable reply scripts, and explore styling, nesting, and pagination.
- PRACTICE - Comment Tags - Part 22:28
- Author Tags7:24
Master author tags and get author meta to display display name, user login, email, nickname, first and last name, avatar, and author archive links in WordPress themes.
- PRACTICE - Author Tags - Part 12:09
Practice adding author name and a link to the author archive in post bylines, and display a featured author bio with gravatar. Create an author.php template and style author metadata.
- PRACTICE - Author Tags - Part 23:25
- Conditional Tags5:09
Explore WordPress conditional tags to tailor displays by context, such as home pages, single posts, and post types, and use current_user_can for capabilities while avoiding slowdowns with templates.
- Sanitization, Escaping & Localization3:51
Master sanitization, escaping, and localization in WordPress to secure data and enable translations with template tags. Sanitize input before storage, escape output for safety, and localize with translation hooks.
- DEMO - Sanitization Tags3:36
Learn to apply WordPress sanitization tags, including sanitize text, sanitize title, sanitize email, sanitize HTML classes, and escape URL raw, to securely handle input and prevent injection.
- DEMO - Escaping Tags5:13
Master escaping tags in WordPress development by comparing escaping with sanitizing, and learn to safely render html, urls, js, attributes, and text areas as late as possible to protect users.
- DEMO - Localization Tags5:08
- A Review of Template Tags1:01
Review the WordPress template tags and the template hierarchy, practice using them in a site or a child theme to customize templates, then prepare to study WordPress hooks.
- An Introduction to Hooks in WordPress3:38
Explore hooks in WordPress to customize default behavior with action hooks and filter hooks. Understand the WordPress lifecycle and how to retrieve, modify, and return data for display.
- do_action add_action remove_action6:04
- Action Hooks in WordPress Core8:37
Discover how do_action and add_action hooks work in WordPress core, and learn to locate and hook into actions like admin head and delete post.
- The WordPress Action Runtime Lifecycle6:28
- Exploring Action Hooks with wp_actions and wp_filter6:48
Drill down into WordPress hooks by inspecting WP actions and WP filters to see which functions attach to each hook and how priorities shape callbacks.
- Exploring Action Hooks with R Debug2:55
- Exploring Action Hooks with Debug Bar Plugins3:41
Explore WordPress action hooks using the debug bar and debug bar actions and filters plugins, viewing core and plugin hooks and the admin bar and footer renders.
- Exploring Action Hooks with Simply Show Hooks Plugin1:21
- Exploring Action Hook DEMOs1:20
Explore how WordPress action hooks work, and learn to create custom hooks with do action, then connect to core hooks and practice with widgets, loop, template redirect, and save post.
- DEMO - WordPress Action Hook - do_action4:25
Learn to create and hook into WordPress action hooks with do_action, attach footer functions, and load templates using locate_template for cleaner, extensible themes, child themes, and plugins.
- DEMO - WordPress Action Hook - enqueue_scripts3:11
Explore the WordPress enqueue_scripts action hook to load CSS and JavaScript with dependencies, and observe default priority and conditional loading for performance on specific pages.
- DEMO - WordPress Action Hook - widget_init4:40
- DEMO - WordPress Action Hook - loop_end()4:59
- DEMO - WordPress Action Hook - template_redirect()4:34
- DEMO - WordPress Action Hook - save_post()6:00
- PRACTICE - WordPress Action Hooks - Part 11:24
- PRACTICE - WordPress Action Hooks - Part 210:58
Explore advanced WordPress action hooks, loading admin and editor styles, using pre get comments and caldera forms hooks, and debugging with a var dump to tailor admin behavior.
- Filter Hooks in WordPress0:52
Explore filter hooks in WordPress by retrieving data that would normally be displayed, customizing it within your function, and returning the customized data to WordPress.
- apply_filters(), add_filter(), remove_filter()6:22
- apply_filter() in WordPress Core8:54
- Exploring Filter Hooks with $wp_filter2:31
Learn to discover functions hooked into WordPress filters using $wp_filter, exploring content and excerpts as they pass through filter chains, with priorities and practical hook creation.
- Exploring Filter Hooks with R Debug2:46
Explore how to reveal WordPress filter and action hooks with the R Debug Library, drill into priorities, and view live hooks on header and content for development.
- Exploring Filter Hooks with Debug Bar Plugin0:57
- Exploring Filter Hooks with Simply Show Hooks Plugin2:06
Explore how the Simply Show Hooks plugin reveals which functions are hooked into filter hooks on both the front end and back end of WordPress, with search and toggle options.
- Exploring Filter Hook DEMOs2:22
Explore practical demos of WordPress filter hooks, starting with applying filters to roll our own hook, then extending title, content, excerpt, body class, and admin columns with custom filters.
- DEMO - WordPress Filter Hook - apply_filters4:23
- DEMO - WordPress Filter Hook - the_title5:41
Learn to hook into the WordPress the_title filter, format titles in the loop with a WP Tags Title Markup function, and return adjusted titles as h1 or h2 with links.
- DEMO - WordPress Filter Hook - the_content6:13
Explore the content filter in WordPress by hooking into the_content to insert an ad after the middle paragraph, using PHP, preg_match_all, and a loop check.
- DEMO - WordPress Filter Hook - excerpt_more4:14
Explore how the excerpt_more filter customizes the end of WordPress excerpts by creating a custom read more link with the post permalink, while safely escaping HTML.
- DEMO - WordPress Filter Hook - body_class2:43
Explore how to customize WordPress page classes using the body_class filter by hooking into functions.php, inspecting the body class array, and conditionally adding classes for CSS styling.
- DEMO - WordPress Filter Hook - manage_posts_columns3:02
Learn to customize WordPress admin lists using the manage_post_columns filter to modify back-end columns. Unset unwanted columns and optionally add a post ID column, with hooks for certain users.
- PRACTICE - WordPress Filter Hooks - Part 10:47
Practice selecting three WordPress filter hooks from documentation or WordPress core, implement custom functions, and customize examples to fit your goals, preparing for the next lesson.
- PRACTICE - WordPress Filter Hooks - Part 27:01
- Hooks in WordPress Review1:13
- Introduction to Plugin Development1:42
Explore the shift from theme development to plugin development in WordPress, comparing functions.php versus plugins and showing when to extract functionality into a standalone plugin.
- Setting Up the Files2:44
Explore how to set up WordPress plugins from a single php file to a matching directory, ensuring unique names, security checks, includes, and basic activation.
- Plugin Header6:53
Learn how to craft a WordPress plugin header: a PHP comment with name, URI, description, version, author, license, text domain, and domain path, visible in admin and repositories.
- Settings Pages6:43
Learn to build plugin settings pages in WordPress by hooking into the admin menu, using add_menu_page, defining slugs and capabilities, and creating a callback to render secure, translatable admin markup.
- Settings Sub Pages6:44
Explore building plugin settings sub pages in WordPress, adding sub menus to the main plugin page or existing admin menus. Create pages with callbacks and slugs.
- Link to Settings3:03
Learn how to add a direct settings link from the plugin listing using the plugin action links filter, improving access to WordPress admin settings.
- Plugin File Paths5:58
Master plugin file paths using plugin base name, plugin directory path, and plugins URL to link files within plugin. Place path setup in the main plugin folder to ensure consistency.
- Enqueuing CSS3:26
- Enqueuing JS3:16
Learn to enqueue JavaScript in a WordPress plugin for admin and front end, using the plugin URL, admin enqueue scripts, and wp_enqueue_scripts, with jQuery as a dependency.
- Enqueuing Conditionally4:32
- PRACTICE - Setup - Part 12:47
Create a WordPress plugin with a basic settings page, enqueue JavaScript and CSS, and test the setup. Extend with hooks, front-end styles, and optional submenu organization.
- PRACTICE - Setup - Part 22:43
Master a WordPress plugin setup with a comment header, admin settings, and a footer; load scripts and styles only on plugin page and prepare for saving options to the database.
- The Options API9:56
Explore saving data in the WordPress options table, understand the database architecture, and learn add, update, delete, and get option operations for plugins.
- Saving Array Options7:52
Explore saving complex data in WordPress by storing arrays in the options table. Learn how to use named arrays, update and get options, and understand serialized arrays in the database.
- PRACTICE Options - Part 11:04
Create a basic WordPress plugin, save a string or an array of options to the options table, and display it on the plugin settings page.
- PRACTICE Options - Part 23:40
- Settings API3:30
Learn how to use the Settings API to build admin forms that edit options in WordPress, including creating sections and fields, adding pages, and saving data to the options table.
- Settings Sections6:32
Learn how to add setting sections via the Settings API in WordPress, activate our settings section plugin, and configure titles, descriptions, and page associations.
- Settings Fields14:17
Create and configure settings fields on a WordPress plugin page, register settings, and store custom text in the options table using the Settings API for seamless front-end and database integration.
- More Settings Fields12:01
Explore creating multiple settings fields, including text input, text area, checkbox, radio, and select, with unique callbacks using the WordPress settings API. Save and recall these values in the database.
- Adding Fields to Existing Sections3:45
- An Introduction to Plugins Review1:12
Develop a solid foundation in WordPress plugin development by reviewing concepts, examining others' plugins, and applying best practices to keep plugin code modular. Prepare to explore WordPress APIs.
Requirements
- Basic HTML - Know how to build a simple HTML page and work with HTML forms.
- Basic CSS - Know how to responsively style HTML pages with CSS.
- Know how to work with Posts, Pages and Custom Content in the WordPress admin area
Description
WordPress is the leading Content Management System on the market, powering a large percentage of the Web. The need for WordPress Developers who can build and customize themes and plugins is ever growing. Learn from one of the most recognized educators in the WordPress world, Zac Gordon, who has taught thousands of people now employed as WordPress Developers.
If you want to learn everything from customizing existing themes, building custom themes or starting to build plugins, this course is for you. You will learn in depth how WordPress works under the hood, from template files and tags to hooks and internal APIs. If you are looking to build bigger and more custom projects with WordPress or just get a good job with a great company building WordPress projects, then this course is for you. Make sure though you can already build and style a basic web page with HTML and CSS as we assume you already know this and focus more on learning PHP.
When you learn the skills this course contains you will feel incredibly empowered to build almost anything you can imagine with WordPress. You should also feel confident working professionally in the field as a WordPress Developer. You will have built a theme and plugin along with the course as well as a theme and plugin of your own. Follow in the path of thousands of others of Zac's students who learned WordPress Development and went on to do great work in the field.
Who this course is for:
- Anyone who wants to learn how to build WordPress Themes
- Anyone who wants to learn how to build WordPress Plugins
- Anyone with basic HTML and CSS skills who wants to start customizing WordPress Themes
- Developers who want to learn WordPress Development in more depth
- Anyone looking to get a job or career in WordPress Development