So in my last post about Internationalization, I covered some non-obvious things that you should consider when adding translation capabilities to your code.
Today, let’s add to that by covering some non-obvious translation functions. You’re probably not using these, since they don’t get talked about as much. But there’s probably places where you should be using them, so knowing about them is the first step. And knowing is half the battle.
Basic functions, again
Last time I talked about these functions:
Let’s cover the ones I didn’t talk about.
In practice, you tend to use these mostly when outputting things onto the main page or in the admin. But, one thing you also use a lot when outputting text is the standard escaping functions. These are things like
esc_html(), which outputs text in a way that makes it “safe” to go onto a webpage, without being interpreted as HTML. If the text comes from user input, then this is a good idea.
Now, if you think about it, then the text you have may be translated in some other file, which you don’t control either. So escaping that text might be a good idea too. If somebody snuck bad code into a translation file, a user might get bad things displayed without being able to easily find it.
So you could write something like
echo esc_html(__('text','text-domain')), but that’s a bit wordy. Let’s talk about some shortcuts.
esc_html__() function is the equivalent of
esc_html(__(...)). It does the escaped html and the double-underscore translation all in one go. Similarly, the
esc_html_e() function does the same thing, but it echoes the result, just like the
_e() function would. And there’s also
esc_html_x(), which is the equivalent of combining
Along with those three are the three identical equivalents for attributes:
esc_attr_x(). As the name implies, these combine the translation functions with
esc_attr(), which is the escape function specifically intended when you’re outputting text into html attributes.
Also note there’s no shortcut for the equivalent of
_ex(). It’s just not used that much, or at least not enough to need something special for it. Use an
echo esc_html_x() instead.
There are no shortcuts for the other escaping functions as yet, but these can save a few keystrokes and make your code that much more readable.
The Numerical No-op
So we’ve got some shortcuts for escaping with those three functions, but where’s the love for
One of the problems with
_n() is that it tends to require the strings to be in the same place that the PHP variable is. For all the other functions, you could have a big file of strings in an array, and then reference those strings by name or something elsewhere because they don’t require any PHP variables. Nothing about them is computed at the time of the output.
But not so with
_n(), that $number to decide which string to use means that the strings have to be right there, they can’t be translated separately and referenced.
This is where
_n_noop() comes in. The
_n_noop() function basically takes the singular and plural strings for something, along with the text domain, and stores them in an array so that they can be referenced later by a function named
Perhaps an example is in order. Let’s go back to the tacos:
$string = sprintf( _n('You have %d taco.', 'You have %d tacos.', $number, 'plugin-domain'), $number );
What if we wanted those strings somewhere else? Like in a big file with all of our strings. Here’s a way to separate the strings from the _n() call:
$taco_plural = _n_noop('You have %d taco.', 'You have %d tacos.', 'plugin-domain'); $string = sprintf( translate_nooped_plural( $taco_plural, $number) , $number );
Now, that $taco_plural can be defined anywhere. Note that it contains no references to PHP variables. It’s basically static and unchanging. This allows us to separate it, then reference it elsewhere for the actual translation. The
translate_nooped_plural() function performs the same job as
_n() does, choosing which string to use based on the $number of tacos. The sprintf then pushes the $number into the chosen string, replacing the %d with the number.
Thus, that lets us extract the translatable strings out and put them anywhere we choose.
Also of note: The
_nx_noop() function is a cross between
_x(). It takes a context for the translators as the third argument, and the domain becomes the fourth argument. Useful if you need to explain to the translators the context surrounding the pluralization choice.
Numbers and Dates
number_format_i18n() function is functionally equivalent to the PHP number_format function. It lets you format numbers with commas at the thousands mark and so forth, except that it also takes localization into account. Not everybody uses commas for thousands and periods for decimals. This function will do the translation appropriately for that aspect.
date_i18n() function is functionally equivalent to the PHP date function. It will handle all the same string formatting parameters as date() will, but it will cause output to be translated for month names, day-of-week names, and so forth. Of note is that it doesn’t change the format requested. If some places put days before months, for example, it won’t handle that. But it will output the month name in the native language (if the translation pack has the right month name in it). So you may want to run the date formatting string through
__() as well, to let translators adjust the date format accordingly.
And that’s pretty much all the rest of the translation functions that I didn’t cover before. I may have forgotten a few useful ones here or there. Feel free to comment about anything I missed, or what you see most often, especially if you’re doing translations yourself.