PHP Callback Functions (Very Simple Examples)

Welcome to a quick tutorial and examples of PHP callback functions. Functions are one of the most basic things that we learn in PHP, then come along with this “callback function” thing… So, just what is a callback?

Yes, that’s all. Callbacks are actually simple, but yet confusing at the same time. Let us walk through some examples in this guide – Read on!

 

 

TABLE OF CONTENTS

 

 

EXAMPLE CODE DOWNLOAD

Source code on GitHub Gist

Just click on “download zip” or do a git clone. I have released it under the MIT license, so feel free to build on top of it or use it in your own project.

 

QUICK NOTES

If you spot a bug, feel free to comment below. I try to answer short questions too, but it is one person versus the entire world… If you need answers urgently, please check out my list of websites to get help with programming.

 

 

 

EXAMPLE 1) CLASSIC CALLBACK FUNCTION

<?php
// (A) FUNCTION TO CALLBACK
function funky () { echo "YO!"; }

// (B) PASS FUNKY() INTO CALL_USER_FUNC()
call_user_func("funky");

First, we have a very simple and classic example here. Remember the two “conditions” of what makes a callback function?

• Pass a function as a parameter into another function – We pass funky() into call_user_func() as a parameter.
• The callback function gets called inside the function itself – call_user_func() calls funky().

For the guys who have not figured out where the name “callback” comes from – We pass funky() into call_user_func(), then call_user_func() calls back to funky(). Get it?

 

EXAMPLE 2) YET ANOTHER SIMPLE ONE

// (A) FUNCTIONS TO CALL BACK
function funkyA () { echo "YO!"; }
function funkyB () { echo "MAN!"; }
 
// (B) THE "MAIN" FUNCTION
function getFunky ($callback) {
  if (is_callable($callback)) { $callback(); }
}
 
// (C) PASS CALLBACK FUNCTIONS INTO "MAIN FUNCTION"
getFunky("funkyA");
getFunky("funkyB");

Let us take “very simple” up a notch to “simple”. This is pretty much how a “common callback” will look like.

• We have a “main” getFunky() function that will call back to $callback if specified.
• So, very straightforward –
  • getFunky("funkyA") will call back to funkyA().
  • getFunky("funkyB") will call back to funkyB().

As to why we do this “dumb” way of passing a function into a function, see the following examples.

 

 

EXAMPLE 3) PASS PARAMETERS TO THE CALLBACK FUNCTION

<?php
// (A) "MAIN FUNCTION"
function repeater ($num, $callback) {
  return $callback($num);
}
 
// (B) CALLBACK FUNCTIONS
function twice ($num) { return $num * 2; }
function thrice ($num) { return $num * 3; }
 
// (C) RUN!
echo repeater(12, "twice"); // 24
echo repeater(12, "thrice"); // 36

Before the angry trolls scream “this is dumb, we can just call twice(12) directly and it will do the same” – Yes, the whole point of this example is to illustrate:

• Callback functions are still functions. We can pass variables into callback functions.
• The idea of using a callback function is to “reuse the main function, but modify the way it acts”. Read the next “practical example” below.

 

EXAMPLE 4) CURL FETCH CALLBACK

<?php
// (A) "MAIN" FUNCTION - CURL FETCH
function fetch ($url, $after) {
  // (A1) FETCH CONTENT FROM URL
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, $url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  $result = curl_exec($ch);
 
  // (A2) CALLBACK AFTER CURL FETCH
  if (is_callable($after)) { $after($result); }
}
 
// (B) CALLBACK FUNCTIONS
function save ($data) { file_put_contents("demo.html", $data); }
function show ($data) { echo $data; }
 
// (C) GO!
fetch("https://en.wikipedia.org/wiki/Rule-based_system", "save");
fetch("https://code-boxx.com", "show");

1. The “main function” fetch() will get content from your specified $url, then passes it into the $after callback function.
2. We have 2 callback functions here.
   • save() will save the given $data into a file.
   • While show() will directly output $data.

As you can see, the main process of fetch() is to get content from a website. But depending on the callback function that is passed in, it will act very differently. That is the smart part about callback functions – Reuse a function in different ways.

 

 

EXAMPLE 5) CALLBACK FUNCTION IN CLASS

<?php
// (A) CLASS - STATIC FUNCTION TO CALLBACK
class MyClass {
  public static function MyFunc () { echo "FOO!"; }
}
 
// (B) THE "MAIN" FUNCTION
function funky ($callback) {
  if (is_callable($callback)) { $callback(); }
}
 
// (C) PASS STATIC FUNCTION MYFUNC() INTO FUNKY()
funky("MyClass::MyFunc");

Yep, it’s that simple – CLASS::FUNCTION if you ever need to callback a function in a class. But take note that the callback function must be static or PHP will throw an error.

 

EXAMPLE 6) CALLBACK FUNCTION IN OBJECT

<?php
// (A) OBJECT - TO CALLBACK MYFUNC()
class MyClass {
  public function MyFunc () { echo "FOO!"; }
}
$myObj = new MyClass();
 
// (B) THE "MAIN" FUNCTION
function funky ($callback) {
  // (B1) FUNCTION IN OBJECT
  if (is_array($callback)) { call_user_func($callback); }
 
  // (B2) "REGULAR" CALLBACK FUNCTIONS
  else if (is_callable($callback)) { $callback(); }
}
 
// (C) PASS OBJECT + FUNCTION TO CALL
// SINCE OBJECTS ARE NOT GLOBAL, WE HAVE TO PASS IN ENTIRE OBJECT
funky([$myObj, "MyFunc"]);

Finally, the complication comes when calling a function in an object. Since objects are not global, we have to pass in the entire object along with the callback function.

 

 

 

LINKS & REFERENCES

• Callback / Callables – PHP
• Call User Function – PHP