Ajax in WordPress is one of those APIs that’s easy to work with (assuming you understand the fundamentals).

Ajax in WordPress: Protocols

A highly technical illustration of Ajax.

For the most part, it’s as simple as:

  1. Defining a function on the server-side and hooking it to the proper WordPress hook,
  2. Setting up JavaScript to make a POST or a GET request to the particular function,
  3. Handling the response on the client-side once the function as returned it.

Sure, there are things like localization and security that matter but they aren’t as difficult to implement as you might think. These topics are outside the focus of this post, though.

Instead, one of the things that I usually implement is a simple protocol of sorts to help when handling response information from the server.

In short, I’m talking about the idea of using a protocol, of sorts, when using Ajax in WordPress. And it sounds like a more complicated concept than it is.

Simple Protocols for Ajax in WordPress

In computer science, computer engineering, or programming, the idea of using “a protocol” usually evokes something more complicated. We usually think of something like TCP/IP, HTTP, FTP, or UDP (along with the obligatory “did you get it?” joke).

But a protocol doesn’t have to be that complicated. The definition in and of itself is easy enough:

These are the rules or standard that defines the syntax, semantics and synchronization of communication and possible error recovery methods.

Or, in other words, the rules by which a communications protocol follow require three things:

  1. the syntax the protocol uses (which should be consistent),
  2. how the communication is synchronized (in our case, this would be asynchronous),
  3. and ways to recover from errors (which can often be a function we define to handle an unexpected response gracefully).

For the sake of writing of a lengthy, boring article, I won’t be going into too much information about Ajax in WordPress. I’ve covered in other articles, and it’s well-documented.

Instead, the main point that I’m trying to illustrate is how to implement a simple protocol when working with Ajax in WordPress in hopes that it makes your asynchronous programming just a little bit easier.

However, as I began working through all of the details of each of the above three points, this post began to get to a point where not even I’d want to read it (even as the one who is writing it).

Whenever that happens, I split up the articles. So over the next three posts (at least, that’s what’s I’m planning for now), I’m going to walk through how to set up a simple protocol for working with Ajax in WordPress.

Ultimately, it’s going to cover:

  1. defining a simple protocol,
  2. implementing the protocol on the server-side,
  3. and handling the response on the server-side.

I may add one final article because that are inevitably going to be things that I forget to mention in this post or in what I’m planning, but I’d rather be forthcoming about it now than later.

With that said, I know this isn’t much of a post. If nothing else, it serves as a landing page for the posts to come.

If this sounds like a topic interesting to you, bookmark this page or follow me, or do whatever you do on the web to stalk people, and I’ll be sure to make sure I’m sharing each article as I publish them.

And if there are specific questions you have about this topic, don’t hesitate to leave them in the comments.

Series Posts

  1. Protocol Syntax

Leave a Reply