DEV Community: Martin Kordas

7 modern and practical MySQL/MariaDB features you should know and use

Martin Kordas — Wed, 08 Dec 2021 09:46:14 +0000

When programming we always tend to look up new interesting syntax features of our main programming language. With SQL database systems systems however we are not so eager, although we use use SQL almost every day. MySQL and MariaDB are constantly evolving and some of the newly added features can help you a lot. Unfortunately the most useful things in changelogs are often hidden among other not so important changes, like storage engines optimizations, adding specific new data types or changing the behaviour of certain configuration variables.

This short list include 7 important new functionalities which make your life simpler. For practical examples, please see provided links. Since MySQL and MariaDB have diverted from each other, I will link each of them individually. Some functionalities are available in MariaDB only.

WITH clause (common table expressions) (since MySQL 8.0, MariaDB 10.2.1): By using WITH you can define derived tables at the beginning of your query. This way subqueries are not nested in the main query, which makes the whole query much more readable. Moreover, advanced WITH RECURSIVE clause lets you define recursive algorithms for processing table values (can be used for sequences generation, hierarchical data traversal etc.). See MySQL ref for detailed explanation and examples.
OVER clause and window functions (since MySQL 8.0, MariaDB 10.2): Similarly to GROUP BY, OVER clause enables you to define a groups of rows (window) and work with column values in each group using window functions. In constrast to GROUP BY, the resulting set of rows remains the same, i.e. rows are not grouped in the result. This way you can use classical aggregate functions like SUM() or AVG() on groups of rows (e.g. groups of comments belonging to the same blog post) and display the agregate function's return value in a column (e.g. sum of comment's likes numbers), but without actually grouping the results. Using specialized window functions (MySQL ref, MariaDB ref) you can do even more, like obtain first/last column value in a group, obtain number of row in a group or obtain previous/following value in a group. The latter gives you exceptional ability to compare values of adjacent rows.
INTERSECT/EXCEPT (since MariaDB 10.3 - INTERSECT, EXCEPT): In the past intersect and except (difference) operations needed to be done manually by JOINing tables and filtering rows. Now you can use more readable INTERSECT and EXCEPT operators.
VALUES statement (table values constructor) (since MySQL 8.0, MariaDB 10.3.3): This practical feature lets you create a table on the fly using literal row values, e.g. SELECT * FROM table UNION VALUES (10, 20), (30, 40).
CREATE SEQUENCE statement (since MariaDB 10.3): While being standard for a long time in many other database systems, MariaDB has adopted sequences recently. They allow you to define a custom way of auto incrementing column values (e.g. incrementing it by addition of 2 instead of 1 etc.).
JSON data type (since MySQL 5.7, MariaDB 10.2.7): In an effort to bring SQL databases closer to noSQL world, RDBMS servers are trying to facilitate JSON data handling. This enables you to combine solid relation database schema with schemaless JSON fields, which are similar to document-oriented databases. You can add or remove attributes from your JSON data without any ALTER TABLE query. Columns using JSON data type and can be manipulated as string or using special JSON_*() functions. Database server will check validity of submitted JSON string, will be able to read its content using JSON_*() functions with JSONPath syntax and it is even possible to put indexes on individual JSON attributes. MySQL in addition offers operators -> and ->> to access JSON column content. Implementations of JSON support in MySQL and MariaDB differ. For MySQL see JSON Data Type overview, for MariaDB see JSON With MariaDB platform article.
Temporal tables (since MariaDB 10.3.4/10.4.3): Several functionalities which help you to read and write data within versioned tables (i.e. tables with records storing date and time ranges). You can easily query rows data valid in certain time point or time span. When updating or deleting data for specified date range, rows are automatically split, shrunk or deleted. This part would be very hard to implement on the application side, so why not to use native database server functionality?

In the end, I will mention some older but useful features which are not commonly known:

Null-safe equal operator <=> (MySQL ref, MariaDB ref): Allows to easily compare nullable columns (without the need to test if column IS NULL).
+/- operators for date/datetime manipulation: Simply put, you can use date_column + interval 1 DAY instead of DATE_ADD(date_column, INTERVAL 1 DAY).
Row subqueries (MySQL ref, MariaDB ref): When using subqueries in the WHERE clause, more then 1 value can be returned from the subquery and compared, e.g. WHERE (name,age) IN (SELECT name, age FROM customer).
REPLACE statement (MySQL ref, MariaDB ref): Acts like INSERT except the case when a row with the same primary key value already exists in the database. In such situation REPLACE will delete the existing row before inserting new one.
#/-- comments syntax: Putting a hash or two dashes and a whitespace into SQL will mark as comment everything to the end of the current line. It is more practical than classical pair /* ... */ comments syntax.

I hope these tips will help you to write more readable and powerful SQL queries.

Revealing Module design pattern and when (not) to use it in PHP

Martin Kordas — Thu, 11 Nov 2021 00:10:11 +0000

Originated in Javascript...

One of the most common design patterns used in JavaScript is Revealing Module. Since JavaScript initially didn't have classic Java-like OOP system, Revealing Module concept was used instead to create simple objects and implement private-like object properties. Revealing Module also fits well into functional nature of JavaScript. (You can see example implementation of Revealing Module in JS on GitHub Gist.)

..but can also be used in PHP

Since PHP includes OOP for very long time, it is quite non-idiomatic to replace classical OOP object handling with functional alternatives like Revealing Module. However thanks to great support of anonymous functions in PHP it is very straightforward to implement it. You can do it as an exercise to dig deeper into functional PHP programming or you can use it in your mainly procedural codebase which you don't want to mix with OOP paradigm, but still want to use some object-like approach.

Example: rectangle object

For easier explanation, I will start with practical example - using Revealing Module in PHP to implement simple "rectangle" object. You will easily understand that $rectangle is a constructor function, which returns $rectangle0 - an array representing newly created object instance with public properties and functions on it. Local variables inside $rectangle functions on the other hand act like private members.

<?php
$rectangle = function (int $a, int $b) {
  $name             = "rectangle";
  $is_square        = function () use (&$a, &$b) {
    return $a === $b;
  };

  $rectangle0       = [
    "get_area"      => function () use (&$a, &$b) {
      return $a * $b;
    },
    "get_perimeter" => function () use (&$a, &$b, $is_square) {
      return $is_square() ? (4 * $a) : (2 * ($a + $b));
    },
    "set_a"         => function (int $a1) use (&$a) { $a = $a1; },
    "set_b"         => function (int $b1) use (&$b) { $b = $b1; },
    "get_name"      => fn() => $name,
    "to_string"     => function () use (&$rectangle0, &$a, &$b) {
      return sprintf("%s: %s x %s", $rectangle0["get_name"](), $a, $b);
    },
  ];
  return $rectangle0;
};

$rectangle1 = $rectangle(2, 3);
$rectangle1["get_perimeter"]();   // result: 10
$rectangle1["get_area"]();        // result: 6
$rectangle2 = $rectangle(4, 4);
$rectangle2["get_perimeter"]();   // result: 16
$rectangle2["set_a"](5);
$rectangle2["get_perimeter"]();   // result: 18

General pattern description

More general scheme of Revealing Module pattern with explanation of certain parts in comments looks as follows:

// 1) $obj is function acting as CONSTRUCTOR
//  - passed parameters $param1, $param2 can be later accessed by any private or public properties/functions defined in constructor
$obj = function ($param1, $param2) {
  // 2) PRIVATE properties/functions are implemented as local variables
  $private_prop1 = 10;
  $private_func1 = function () use (&$obj0, &$private_prop1, &$param1, &$private_func1) {
    // private function $private_func1 can access other private properties/functions
    $private_prop1++;
    // private function $private_func1 can access public properties/functions via $obj0 reference (see below)
    $obj0["public_prop1"] += $param1;

    // function $private_func1 is also able to call itself recursively via $private_func1 reference
    if (false) $private_func1();
  };

  // 3) PUBLIC properties/functions are implemented as values in $obj0 array
  //  - $obj0 itself represents newly created object instance and is returned from constructor function
  $obj0 = [
    "public_prop1" => 20,
    "public_func1" => function () use (&$obj0, &$private_func1, &$param2) {
      // public function public_func1 can access other public properties/functions via $obj0 reference
      $obj0["public_prop1"] += $param2;
      // public function public_func1 can access private properties/functions
      $private_func1();
    },
  ];
  return $obj0;
};
// 5) INSTANCE $obj1 will be created by calling constructor function $obj
$obj1 = $obj(10, 20);
$obj1["public_func1"]();

This snippet comprises roughly everything you need to know about Revealing Module.

When using Revealing Module in PHP you should specifically be careful about use (...) construct, which needs to declare all variables from the outer scope that your function needs to use. Especially ensure you declare variables by reference (use (&$private_prop1)) instead of by value (use ($private_prop1)), otherwise the variable value in the inner scope will not match future changes of the variable in outer scope and it also won't be possible to edit the variable from the inner scope.

Conclusion

Finally, it would be very interesting to look at pros and cons of Revealing Module approach in comparison with traditional PHP OOP.

Advantages

Revealing Module fits well into procedural codebase, in case you don't want to mix it with OOP. It also doesn't require any knowledge of OOP programming.
It is suitable for simple ad-hoc objects you create inside of other existing module or script. In such cases you don't necessarily want to create full OOP class in separate file. Revealing Module constructors can be created in the middle of existing code, even inside loops (constructor function redefinition doesn't imply any error).
Object instance is implemented as an array and is quite flexible. You can add/delete public properties and functions, sort them and build nested structures from them (e.g. $obj1["functions_group1"]["function1"]();: member function function1 has been placed into functions_group1, which is just a nested array of functions).
Constructor function is standard variable (Closure object) and can be manipulated easily.
- You can store it in another variable, return it from a function or pass it as a parameter:
```
$foo = fn($rectangle) => $rectangle(4,5);
$foo($rectangle);
```
- Standard OOP class on the other hand is not a variable and you can pass it as a parameter only using its name obtained from ::class constant:
```
$foo = fn($className) => new $className(4,5);
$foo(Rectangle::class);
```

Disadvantages

This list is very extensive, that's why you should use Revealing Module only sparingly.

Inheritance, cloning and serialization of Revealing Module objects are not possible. (Especially lack of inheritance is quite painful, because it is strong mechanism of code reuse.) Determining object type using instanceof or get_class() is not possible.
Type hinting of private or public object properties and functions is not possible.
IDE support is poor. You probably will not get any autocomplete for public object properties and functions, because they are implemented as simple array values. You cannot document member properties and functions with PHPDoc.
Autoloading is not possible. If your constructor function is located in a separate file, you will need to include it manually.
Code structure consisting of private and public members is not as optically clear as with classic OOP. Necessity to put so many variables into use (...) construct is annoying and causes code bloat.
Object instances are simple arrays and, as such, are passed by value by default. It is undesirable, because we are used to objects being passed by reference.
It is not possible to implement static object properties and functions. You always need to create instance first and call instance properties and functions.

I hope this article has inspired you to use functional programming in PHP more frequently, or even try out Revealing Module pattern in PHP or any other functional-ready language. For common work on PHP backend, you should probably stick to traditional OOP approach.

PHP global functions: how they affect code extensibility, testability and modularity

Martin Kordas — Wed, 29 Sep 2021 21:36:23 +0000

We all have been told not to use global variables, as they can be modified and read from whatever part of code, which causes confusion and errors. Using global functions by contrast is quite common, but can be problematic too.

We will discuss issues of global function calls on a simple Notification class, which calls global function logMessage() internally.

<?php
class Notification {
  private $isRead = false;

  public function markAsRead() {
    $this->isRead = true;
    logMessage('article was marked as read');
  }
}

Issue 1: Extensibility

Function logMessage() probably logs given message into a file. The problem is that the call is hardcoded into the function markAsRead() and cannot be changed externally, which violates the Open-closed principle.

Common solution is to use an object (not function) for the purpose of logging and pass it to the Notification class constructor. This technique is called Dependency-injection.

<?php
class Notification {
  private $isRead = false;
  private $logger;

  public function __construct($logger) {
    $this->logger = $logger;
  }

  public function markAsRead() {
    $this->isRead = true;
    $this->logger->logMessage('article was marked as read');
  }
}

This way is the logging logic separated into a distinct object $logger, which is injected into the Notification class externally. It means we can affect the logging logic from the outside (e.g. we can use logger object which logs messages to a file or use another one which logs to database etc.)

(Alternatively it is possible to use Factory method pattern. In that case, we would pass factory object (not the actual logger object) to the Notification class constructor and the logger object would be created by Notification class itself calling a factory object method.)

Issue 2: Testability

When writing unit tests, we often need to change behaviour of the tested class slightly (e.g. we want to turn off logging completely during tests instead of usual logging into a file).

Again, with global function it is impossible to change logging behaviour from the outside of the class. By contrast, the above mentioned solution with dependency injection provides possibility to pass custom logger object which will silently ignore all log messages, which is the desired behaviour.

Issue 3: Modularity

Modularity is closely related to testability. We need to test separate code parts which ideally do not interact with each other (see also Single-responsibility principle. This way only are we able to find errors in the tested module itself without mixing them with errors from other interacting modules.

Solution with dependency injection described above gives us opportunity to choose custom logger object. With the help of testing framework such as PHPUnit we can create stub object instead of regular logger object, which allows us to freely redefine or suppress object functionality for purposes of the test and also watch which methods on the logger object has been called from inside of tested module (mocking). Neither of these features can be achieved when implementing logging with a global function.

Last but not least, modularity gives you knowledge about what other modules your current module uses (E.g. with dependency injection, you can just look on class constructor's parameters. They represent injected objects and this objects in turn represent injected functionality from other modules.) With this knowledge of module dependencies you can more easily extract your code and use it in another project, as you know which other modules it depends on and which of them you therefore have to extract as well.

There is one alternative solution of modularity using namespaced global functions.

<?php
use \utils\logging\filesystem\logMessage;

class Notification {
  private $isRead = false;

  public function markAsRead() {
    $this->isRead = true;
    logMessage('article was marked as read');
  }
}

Enclosing functions in namespaces gives you some modularity per se. Moreover, each called namespaced function is usually mentioned with use operator statement in the beginning of the file. Thus you can more easily overview which functions from other modules are called from inside your class. You can also change the namespace (for example to \utils\logging\database\logMessage) and thus change logging behaviour as well, but this change cannot be made on runtime, because doing the change requires you to modify the source code. (In contrast, with dependency injection the change can be done on runtime, because the changed behaviour is represented by runtime injected object.)

Conclusion

Given the limitations of global function calls, you should generally avoid them when possible (at least if you work on OOP project) or use them only in several cases when they become handy, e.g.:

very frequently used functions (calling global functions is much shorter in code than instancing a class and calling a class method)
functions with unimportant functionality (debugging functions, shorthand functions which probably only call some object method)
very widely used functions (used almost in every project module)
functions whose logic is not meant to be modified or mocked (e.g. during unit tests, see above)
platform functions - built-in PHP functionality is mostly implemented as global functions (array_push(), strlen() etc.) - we usually don't use objects and dependency injection for basic built-in functionality like string or array manipulation

See also Laravel Miscellaneous functions list as an example of what type of functions the framework defines globally (as opposed to object methods which make up the majority in Laravel).

Speed up switching between opened windows using Autohotkey shortcuts

Martin Kordas — Tue, 21 Sep 2021 15:51:33 +0000

Usually our OS runs quite many application at one time and it could be quite hard not to get lost in so many opened windows. If you are using Windows, you usually have several built-in possibilities how to switch between open apps.

Select an app from taskbar.
Use Alt+Tab or Win+Tab shortcut to switch the app. (Least recently used apps are displayed first, which helps your orientation. You can also use arrow keys to navigate between suggested apps and Delete to close an app.)
Use Win+<n> shortcut to open an app, whose icon is the nth icon on the taskbar. (You usually have several apps pinned to the taskbar, so their position is unchanging and therefore you remember their hotkey. For example, if you have web browser pinned as a first app on your taskbar, you regularly use Win+1 shortcut to open browser window. If the app doesn't run at all, OS will run it.)

Using Win+<n> shortcut saves me much time as I don't have to search between opened windows, I just use one exact hotkey instead and the window gets displayed. The problem is that it is possible to use this hotkey only for 10 apps (corresponding to 0-9 keys on your keyboard).

For this reason I installed Autohotkey program and created a simple script which shows an app based on its window title text. I always use Win+Shift+? shortcut (# means Win, + means Shift in Autohotkey scripts). With the script running, Visual Studio window shows up upon pressing Win+Shift+V, Postman shows up upon pressing Win+Shift+P and so on.

SetTitleMatchMode, Regex
SetTitleMatchMode, Slow

#+v::
WinActivate, .*Visual Studio
return 

#+p::
WinActivate, Postman
return

#+o::
WinActivate, .*LibreOffice
return

#+c::
WinActivate, .*Calc
return

If you save the script with .ahk extension you can run it manually by double clicking it. Alternatively you can place it into your startup folder (%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup) so as it will run automatically every time you use your computer.

Now you can switch to almost every running app so fast with just one keyboard shortcut.

You can do many other useful things with Autohotkey, like remapping keys you lack on your current physical keyboard or creating shortcuts for multimedia features (start/resume playing, volume up/down...), all of this achieved with standard keyboard layout without the need to buy specialized keyboard with additional keys.

How to properly store and print plaintext strings

Martin Kordas — Sun, 14 Mar 2021 23:19:04 +0000

Most of the time, users of web applications fill in dynamic textual data in the form of plaintext. These texts are usually stored in a database and then get printed in different ways. Apart from dynamic user data, applications also use static plaintexts for user interface texts and for static items lists. (Static plaintexts could be stored in a database or directly in program data.)

I decided to share some common tips on how to deal with these plain strings appropriately. For brevity, the article only lists what should be done with plaintext strings, it does not focus on how to implement it. In most programming languages, an existing library function could be found to accomplish each of described tasks.

Storing plaintext

Before storing a string received as an user input, you should perform these operations.

Normalize whitespace: Normalization provides uniform format for your strings and strip unnecessary or unintended characters. You will probably implement this feature using regular expressions.
1. Strip any whitespace from beginning and end of the string.
2. Convert whitespace characters other than space character (e. g. tabulator) into a space character (do not convert line break characters).
3. Merge any adjacent whitespace characters into a single space character.
4. Normalize line breaks: line breaks are represented by carriage return (CR) or line feed (LF) character. Replace CR or CRLF sequence with LF character (Unix convention) or CRLF sequence (Windows convention).
Strip non-printable characters: Today's most common Unicode encoding has also adopted many non-printable characters from the original ASCII character set (e. g. BELL, EOT...). Strip those characters to avoid confusion caused by debugging "invisible" strings. To filter the non-printable characters out, you would usually use a regular expression with specific character value range.
Strip unsupported Unicode characters: Although UTF-8 encoding is de-facto standard these days, some unusual Unicode characters may not be supported by your systems. For example, MySQL's utf8 charset is capable of storing character of Unicode Basic Multilingual Plane only. Other characters (e.g. emojis) will not work and you should ideally strip them before processing a storing.

Printing plaintext

Printing plaintext into plaintext

Web applications usually use HTML as its output format, but occasionally you would use plaintext instead. This includes exporting into text files or sending plaintext e-mails. Printing plaintext into plaintext is naturally easier then printing it into HTML.

Normalize line breaks: Thanks to line break normalization before storing, you already have line breaks in an uniform format. You should now however convert it depending on the system where the text will be used. Ideally you would use LF line break style for Unix systems and CRLF sequence for Windows systems. You just have to discover what type the target system is.
- When sending a file to a client, you could determine client's operating system from the User-Agent header.
- Alternatively, you could simply always use CRLF sequence, which will work on both Unix and Windows systems most of the time.
- If you are printing into a file stored locally on your server, you should always use line break style specific to your server's operating system.
Wrap lines: It could be very annoying for user to read lines with excessive length. Check that each line in your text does not exceed suitable limit of characters (e. g. 80 chars) and insert a line break where needed.
Convert encoding: Although we usually use UTF-8 on the web and in database storage, when doing exports some legacy character sets may be preferred by your clients (e.g. ISO-8859-1).

Printing plaintext into HTML

Although it cannot express any formatting, storing plaintext in the database has several advantages over storing HTML itself:

plaintext is smaller in size
plaintext can be easily read by database admin or by developer when debugging an app
plaintext is suitable for querying (searching based on user input including fulltext search)
plaintext represents "neutral", generic form of textual data (whereas text stored as HTML can be used only inside HTML document)

If you need to print a plaintext string into HTML, you should try to programatically add all formatting features that plaintext was not able to store. I list some of these below. (Only points marked with '!' are necessary for proper and secure printing of texts into HTML, others are optional.)

Convert URLs into <a> tags: Do this only if the text is supposed to contain URLs.
Apply formatting expressed in given markup language: Simple markup languages like Markdown make it possible for users to specify formatting directly in the plaintext. Before printing, plaintext is transformed into HTML using a library function. Your users however need to be trained to use specific markup language.
(!) Convert HTML special characters into corresponding entities: This is an absolute necessity for security reasons, as it protects your website against HTML injection. For example, special character < would be encoded as entity > and special character " as entity ".
Convert all applicable HTML characters into corresponding HTML entities: This makes some unusual Unicode characters easier to identify in the source code. For example, © character would be encoded as entity ©.
Transform characters based on your language's grammar rules: Users of your application typically only use basic characters when filling in input fields and do not care much about typography. Hence, your program should intelligently deduce transformations needed for the text to be typographically and grammatically correct. Typically you would replace a character located at appropriate position with an HTML entity.
-  : Put non-breaking space instead of simple space wherever a line break is inappropriate. In English for example, you would put non breaking space between number and unit indication ( e. g. 10 kg).
- – or —: Basic dash character (-) should be replaced with wider dash characters in many cases. In English for example, you would put ndash character (–) between numerical ranges (e. g. 1939–1945).
- …: Horizontal ellipsis character (…) should replace three dots at the end of a sentence.
- &bdquo; and “: Users usually use basic double quote character (") when filling forms. Some languages may however require different stylization for opening and closing quotes (for example „ for opening and “ for closing quotes).
(!) Convert line break characters to <br /> tags: Otherwise you will see no actual line breaks on the website.
Wrap lines: See above section Printing as plaintext. Wrapping long HTML lines becomes useful when you read raw HTML source code as a developer, but does not have any impact on user experience.

You should ideally incorporate several of these operations into one function call which you will use as a standard way for printing plaintext into HTML.

As an alternative approach, you could store plaintext and HTML version of the text simultaneously. This solution saves you from dynamically transforming plaintext every time you need to print it into HTML, but reduces maintainability and increases storage needs.

Conclusion

I consider the above mentioned thoughts to be a structured summary on how to deal with plaintext as a programmer. It is not easy for a beginner to think through all possible eventualities, so I hope this could be helpful.

If anything is not clear, please write to comments. I can also provide example implementation of some of the described string handling operations.

Practical use of callback functions in PHP

Martin Kordas — Tue, 02 Mar 2021 15:21:38 +0000

Ability to use function callbacks comes very handy in many everyday programming situations. With anonymous functions it is possible to inject your own code into another function's execution, which greatly improves code reuse.

These are some simple, but highly practical examples of using callbacks for various programming tasks. In each example, we are going to define a helper function that accepts another callback function as an argument and does some processing with it. The helper function can then be reused by calling it repeatedly with custom callback arguments.

Example1: Time measurement

You have probably already used microtime() function for benchmarking your program. Now you can define runWithTimer() helper function, which performs microtime() calls and time subtractions automatically for you. Code intended for time measurement is passed in a callback parameter $cb and called from inside of the helper function.

Helper function

function runWithTimer(callable $cb, &$seconds) {
  $t0 = microtime(true);
  try { 
    $res = $cb();
    return $res;
  }
  finally {
    $t1 = microtime(true);
    $seconds = $t1 - $t0;
  }
}

The helper function uses &$seconds parameter passed by reference to store the resulting number of seconds. Helper function itself returns the return value of the callback function $cb. It could also be implemented the other way round (helper function returning number of seconds and storing callback function return value in an parameter passed by reference).

Usage

$seconds = 0;
$res = runWithTimer(function () {
  sleep(3);
  return true;
}, $seconds);
var_dump($seconds, $res);
// Outputs: float(3.022805929184) bool(true)

Number of seconds the callback function was executing was stored into $seconds variable. Callback function itself returned TRUE, which was stored into the $res variable.

Note that doing the final time subtraction in finally block ensures that we get the resulting number of seconds even if the callback function throws an exception.

$seconds = 0;
try {
  $res = runWithTimer(function () {
    sleep(3);
    throw new Exception();
  }, $seconds);
}
catch (Throwable $ex) { };
var_dump($seconds, $res);
// Outputs: float(3.0143301486969) NULL

Example 2: Output buffering

Some of your existing functions may be echoing output instead of returning it as a string. Ideally, you should rewrite those functions to return strings, but as a fast workaround, you can use output buffering. runWithOutputBuffer() helper function encapsulates necessary output buffering calls for you.

Helper function

function runWithOutputBuffer($callback, &$output) {
  ob_start();
  try { 
    $res = $callback();
    return $res;
  }
  finally {
    $output = ob_get_contents();
    ob_end_clean();
  }
}

Usage

$output = "";
$res = runWithOutputBuffer(function () {
  echo "Hello world!";
  return true;
}, $output);
var_dump($output, $res);
// Outputs: string(12) "Hello world!" bool(true)

Here, output of callback function was stored as string into $output variable. Callback function itself returned TRUE, which was stored into the $res variable.

You could also use string-based callback to easily store output of existing echoing function.

$output = "";
runWithOutputBuffer("phpinfo", $output);
var_dump($output);

Example 3: Database transactions

runInTransaction() function stores repetitive code for committing and rolling back database transactions.

Helper function

function runInTransaction(mysqli $mysqli, callable $cb) {
  $mysqli->begin_transaction();
  try {
    $res = $cb();
    $mysqli->commit();
    return $res;
  }
  catch (Throwable $ex) {
    $mysqli->rollback();
    throw $ex;
  }
}

The helper function executes callback $cb and invokes transaction rollback if the callback throws an exception. Otherwise, it commits the transaction. (Callback $cb should contain database data manipulation logic, otherwise it does not make sense to pass it to the runInTransaction() function.)

NOTE: In a real project code you would probably implement the helper function as a method of your database connection provider class, so that the $mysqli object could be stored in a class variable instead of being repeatedly passed through function parameter.

Usage

try {
  $persons = [
    ["id" => 1, "name" => "John"],
    ["id" => 2, "name" => "Monica"],
  ];
  $countInserted = runInTransaction($mysqli, function () use ($persons) {
    $count = 0;

    $res = insertIntoTable("persons1", $persons);
    if ($res === false) throw new Exception;
    else $count += $res;

    $res = insertIntoTable("persons2", $persons);
    if ($res === false) throw new Exception;
    else $count += $res;

    return $count;
  });
  echo "Transaction commited ($countInserted rows inserted).";
}
catch (Throwable $ex) {
  echo "Transaction rolled back.";
}

In this example, callback represented by anonymous function inserts data into two different database tables. Database manipulation logic is black-boxed in the insertIntoTable() function. When a database error is signaled by a FALSE return value, callback function throws an exception, and thus causes transaction rollback. Otherwise, it returns number of inserted rows, which is finally stored in $coutInserted variable.

Since $persons data intended for database insertion were defined outside the scope of the anonymous function, we have applied use construct in anonymous function definition to bring $perons variable into the inner scope (function () use ($persons)).

NOTE: You could use similar helper functions even for other database-related tasks, like executing callback functions against certain default database (you would probably use $mysqli->select_db(...) in the helper function code).

Example 4: Caching

Our final example deals with caching of function return values. Usually you would want to cache resource-consuming calculations, database querying functions or other I/O related calls.

Similar to previously mentioned helper functions, createCache() accepts callback function in $cb parameter. This callback function represents a computation for which we want to cache return values. Helper function finally returns a completely new anonymous function, which can then be used by outer code as a caching function.

Helper function

function createCache(callable $cb, bool $multiArgs = false) {
  $cache = [];
  if (!$multiArgs) {
    return function ($argument) use (&$cache, $cb) {
      if (array_key_exists($argument, $cache)) return $cache[$argument];
      else {
        $cache[$argument] = $cb($argument);
        return $cache[$argument];
      }
    };
  }
  else {
    return function (...$args) use (&$cache, $cb) {
      $valFound = false;
      foreach ($cache as list($args1, $val1)) {
        if ($args1 === $args) {
          $val = $val1;
          $valFound = true;
          break;
        }
      }
      if ($valFound) return $val;
      else {
        $val = $cb(...$args);
        $cache[] = [$args, $val];
        return $val;
      }
    };
  }
};

Helper function first creates $cache array, which will serve as a storage for cached return values. Then it returns an anonymous function which executes a given callback $cb and caches its return value, but only if it does not find its return value already stored in the cache. Returned anonymous function could have been created in two branches, which is only a performance tweak - return values of callback functions accepting only one argument can be cached more efficiently, which is what the first branch is for.

Usage

We will define getPerson() function querying person's data from the database and then we create caching function $getPersonCached() from it.

function getPerson ($id, $nameOnly = false) {
  echo "called widh id $id<br />";
  $person = selectFromTable("persons", $id);
  return $nameOnly ? $person["name"] : $person;
}
$getPersonCached = createCache("getPerson", true);
$person1 = $getPersonCached("1");
$person2 = $getPersonCached("2");
$person1 = $getPersonCached("1");
// Outputs:
// called with id 1
// called with id 2

As you see, repeated call to $getPersonCached() with argument "1" hasn't invoked getPerson() function, because the return value has been obtained from the cache.

If you wanted to make calls to getPerson() with the optional parameter $nameOnly changing, you would have to call createCache() with parameter $multiArgs set to TRUE.

$getPersonCache = createCache("getPerson", true);
$person1 = $getPersonCache("1");
$personName1 = $getPersonCache("1", true);

NOTE: We have used string-based callback "getPerson" as an argument for createCache() function in this examples, but you could naturally use anonymous function callbacks as well.

Conclusion

I hope this examples helped you to understand how to build better code. They also serve as an introduction to functional programming in PHP.

For advanced techniques, see following sections of PHP Manual:

Image credit: https://commons.wikimedia.org/wiki/File:Php_elephant_logo.svg