Object-oriented code, among other equipment, can help systematize and add
reusability to your code. In this lesson, I will instruct you the basics of inscription
a WordPress plugin using object oriented techniques. We’ll be using Dribbble’s
API as an instance for this lesson. Prepared?
What We’re Going to Learn:
- Advantages of using OOP for
WordPress plugins.
- How to install a shortcode.
- How to install a template
tag.
- How to allow shortcode in
WordPress widgets.
- Real-world instance by using
Dribbble’s API.
Why Use OOP?
Before touching onward with this lesson, you should have at least an simple accepting
of writing a WordPress plugin. Give it a study.
Building WordPress plugins with object oriented code is fairly well-organized
and orderly, when compared to using procedural code. It’s easier to control the
code base, and make bigger it using inheritance techniques, which can be chiefly
helpful when writing a bulky plugins.
Dribbble
To inscribe a WordPress plugin, we first require a sense of way. We’re going
to inscribe a plugin that will show the newest shots from(
Take care This)
Dribbble, using their REST API. We’ll
then add short code maintain for posts and widgets, and template tag for
themes.
Step 1 - Setting up the Plugin Class
Object oriented code is supported on classes and methods (functions). Let’s build
our core class, which will cooperate with WordPress’ hooks and filters.
PHP classes contain a constructor function,
__construct, which is effected as soon as a new example
of a class is instantiated. All WordPress hooks and filters will be registered
under the constructor of our plugin class. Lets thrust in advance and schedule
a shortcode for our plugin. The
add_shortcode()
function/hook will go beneath the constructor function.
The new example of a class/object is registered using the
new keyword. Refer to the final line in
the code underneath.
Perceive how we’re using an
array
in the recall function parameter? To register recall functions within an
object, we have to apply an
array.
The initial thing of the array mention the object, via
$this. The next thing in the
array is the method name inside the
class. All hooks and filters have to be mentioned like this when surrounded by
a class.
Step 2 - Dribbble API Class
Ever since we at present do not need any imagine API functions, we’re going
to build a rather straightforward API wrapper for Dribbble. There is by now a
library obtainable for Dribbble, but, for the sake of this lecture, we’re going
away to write our own possess. It’ll help you appreciate the concepts behind
this lesson.
We’re available to write a DribbbleAPI
object,
and register a
method called
getPlayerShots() to interact
with Dribbble’s API and return an
array
of the latest shots.
Let’s create a novel file for this class, called
DribbbleAPI.php
Above, we’re surroundings up two class variables.
- $apiUrl –
The linkage to the Dribbble API, where the calls will be sent.
- $user – The
username or user id of a Dribbble user. This charge will be place from surrounded
by the constructor (
__construct)
method.
The constructor is approved a
$user
variable, which is then approved on by the constructor to the class property, identified
user.
We prefix the property, or variable name with
public to identify that the value of this property can be
repossess from external of the
class.
If we as an alternative wish to perimeter access to the property to only this
class, and possibly any
classes that inherit from it, we’d employ
the
protected prefix. This perform
is passed on to as encapsulation.
We have the pedestal prepared for our Dribbble API wrapper. At the present,
We’re going to inscribe a new
method,
called
getPlayerShots(). The
reason of this
method will
be to query the API and change the effect into an
array for tradition surrounded by our plugin.
The
getPlayerShots
function retrieves’ the user from the class variable. It exploits WordPress’
wp_remote_get function to query the
Dribbble API. The API then responds to our query with a JSON string, which is
then parsed into an
array
and sent reverse to the function by means of the
return keyword.
This is all that we need from the API at the instant – merely an
array of player shots. If we happen to need
more functionality in the upcoming, we can moreover add more
methods to the current
class, or create a new
class that
extends this one. Once
more, this is referred to as inheritance.
Step 3 – Integrating the DribbbleAPI
Class
This is the amusing part; the recently parched
DribbbleAPI class
will approach into use. We’re available to loop through the shots regained from
the API, and produce an
html
list of shots, which will be approved on to the shortcode and the template tag.
At some stage in the loop, the full-sized Dribbble images will be cached and
saved in the plugin folder, and the thumbnails will be generated using
TimThumb.
To agree on if the full images are by now stored locally, the
plugin path is obligatory. Also, to produce
the thumbnails with
timthumb,
the
plugin url is obligatory.
For this reason, we’ll create two class variables called
pluginPath and
pluginURL in our
WPDribbble class, and then place their morals
from inside the constructor
method.
Setting PluginPath and PluginUrl
getImages() Method
Build a novel
method
within the
WPDribbble class, called
getImages.
Surrounded by a
class,
you can utilize generic names for functions. They will not disagreement with
other plugins or WordPress’ built-in functions, since they are beneath the
class namespace.
- user –
Username or User ID of Dribbble.
$user
will be employed when registering a novel occurrence of the DribbbleAPI class.
- $images –
Number of images to render.
$images
will be used when querying the API through the getPlayerShots method.
- $width and $height
– Timthumb will be employed to produce thumbnails.
- $caption – Opportunity to turn into heading of an image.
After that, we’re available to embrace the
DribbbleAPI class in the
getImages() function, and create a novel occurrence of it
to clutch the images.
The
$shots variable in
the code is inhabited with an
array
of three current Dribbbles from the
$user.
As mentioned in advance, we’re available to loop through the
$shots array, and save the chock-full size images close by for
caching motivations. The cached images will be empoyed with TimThumb to provide
the thumbnails. For amassing full-images and thumbnails produced by TimThumb, make
two folders. We’ll utilize
full-images/
for amassing the full size images, and
cache/
for the thumbnails, since that is the default folder name for TimThumb.
The HTML for the list will be generated within the
$shots ring.
Adding Classes
It’s always a good idea to add classes to each element of your plugin. This
provides the advanced users of your plugin with the freedom to customize it.
Avoid using inline CSS for content that is generated through your plugin.
Step 4 – Setting up the Shortcode
Shortcodes, as the name advocates, allows users to simply attach intricate
content into blog posts.
We before now have the
add_shortcode
hook prepared in our plugin class constructor. Now, we’re going away to inscribe
the shortcode
method within
our
class, which will take
out the shortcode attributes and come again the Dribbble images by using the
getImages() method.
We’ll be calling our shortcode
[Dribbble].
As declared previously, the name of the shortcode is strong-minded by the initial
parameter in the
add_shortcode
function. It will be used with the attributes mandatory for the
getImages() method. For example:
[Dribbble user=haris images=5 width=100 height=100
caption=true].
Add Shortcode support for WordPress Widgets
By evade, WordPress widgets don’t sustain shortcodes, however, by using the
widget_text filter, we can oblige
shortcode support in WordPress widgets.
We can add the filter in our
WPDribbble
object constructor.
Step 5 Setting up the Template Tag
The template tag can be employed directly in WordPress themes. The essential
purpose of the template tag will be to generate a novel example of our
WPDribbble class, and call the
getImages() method. The template tag
will be a easy PHP function and it has to be registered outer surface the
plugin
class. It needs to contain
a unique name; otherwise, it will difference with functions / plugins with
similiar name. Since our plugin is entitled
WP-Dribbble,
we’ll entitle the template tag,
wp_Dribbble().
Voila!
Congratulations! You have effectively written a WordPress plugin with OOP. If
you fall in any problem, let me know, I’ll try to do my best to help you.
