Message Format Explained in Simple Terms

Message format is a crucial aspect of communication, and understanding it can make all the difference in conveying your message effectively.

A message format typically includes a sender, recipient, and a medium, such as email, text, or social media.

The key to a well-structured message format is clarity and concision, ensuring the recipient quickly understands the purpose and content of the message.

This can be achieved by using a clear subject line, a brief introduction, and a concise main message, as seen in a well-crafted email.

Message format solves a lot of problems that developers and translators face when working with UI texts and translations.

Separating code from text formatting makes it easier to work with, and message format provides the tools to do just that.

You can keep message sources in human-friendly formats and compile them into JavaScript during your build phase.

Message format also gives you an easy-to-use API that's future-proof and won't lock you in.

This means you can avoid the limitations of a hand-rolled system and work with existing workflows without reinventing the wheel.

For example, message format provides a Format Guide with details on available selectors, formatters, and more.

The ICU MessageFormat class uses message "pattern" strings with variable-element placeholders enclosed in curly braces.

These placeholders are called "arguments" in the API docs, and they can include formatting details to customize the output.

A properly formatted ICU Message Format pattern is required to avoid errors.

The ICU MessageFormat class supports a variety of formatting options, including number, date, time, plural, selectordinal, and select formats.

Here are the specific options supported by the ICU MessageFormat class:

The MessageFormat class requires two parameters: locales and pattern. The locales parameter is a string with a BCP 47 language tag or an array of such strings.

The ICU MessageFormat class uses message "pattern" strings with variable-element placeholders enclosed in curly braces. These placeholders, called "arguments" in the API docs, can include formatting details.

The ICU MessageFormat class supports several formats, including number, date, time, plural, selectordinal, and select. You can use these formats to create a variety of messages.

Here are the supported ICU Formats:

In a message format pattern, curly braces are used to enclose variable-element placeholders, known as arguments.

To represent a single quote within a pattern string, you need to use doubled single quotes. For example, the pattern string "'{0}'" represents the string "{0}".

Any unmatched quote is treated as closed at the end of the given pattern. For instance, the pattern string "'{0}" is treated as "'{0}'".

Curly braces within an unquoted pattern must be balanced. For example, "ab {0} de" and "ab '}' de" are valid patterns, but "ab {0'}' de", "ab } de", and "''{''" are not.

The ArgumentIndex value is a non-negative integer written using the digits '0' through '9', and represents an index into the arguments array passed to the format methods or the result array returned by the parse methods.

Here's how FormatType and FormatStyle values map to Format instances:

Argument formatting is a crucial aspect of working with MessageFormat. Arguments are formatted according to their type, using the default ICU formatters for those types, unless otherwise specified.

If the type is unknown, the Java MessageFormat will call toString(). You can control the formatting in several ways, but one recommended approach is to format the parameter as needed before calling MessageFormat.

This offers maximum control and is preferred to using custom format objects. For example, you can use the ICU formats supported by MessageFormat, such as number, date, time, plural, selectordinal, and select.

These formats can be used to format arguments in a specific way, such as percent, currency, short, medium, long, or full. You can also use complex argument types, like plural, select, or the discouraged choice type.

However, it's worth noting that using complex arguments can be tricky for translators, so it's recommended to use them as the outermost structure of a message.

On a similar theme: How to Type Text Messages

Format Details are crucial in creating and interpreting pattern strings. A pair of single quotes can be used to quote any arbitrary characters except single quotes.

For your interest: Single Email Message

To represent a single quote itself, you must use doubled single quotes throughout a String. This is because a single quote must be represented by doubled single quotes, not a single quote itself.

Quoting and escaping rules are essential in pattern strings. An ASCII apostrophe ' (U+0027) only starts quoted text if it immediately precedes a character that requires quoting.

The recommendation is to use the ASCII apostrophe only for escaping syntax characters and the pretty single quote (’ U+2019) for actual apostrophes and single quotes in a message pattern.

To create a Format instance, you need to map FormatType and FormatStyle values to a Format instance. The following table shows how these values map to Format instances:

Any unmatched quote is treated as closed at the end of the given pattern. For example, pattern string "'{0}" is treated as pattern "'{0}'".

A MessageFormat instance is required to format messages. This is especially true if your pattern contains placeholders.

The args object is a crucial part of a MessageFormat instance. It contains the values to replace placeholders with.

Here's a key fact about the args object: it's required if your pattern contains placeholders.

The MessageFormat instance takes the args object as a parameter to replace placeholders with the actual values.

In text-based message formats, the character limit is typically around 160 characters, which can make it difficult to convey complex information.

This limitation can be a challenge when trying to send messages with multiple recipients, as it may require breaking up the message into multiple parts.

The use of symbols, such as the asterisk (*), can help to convey emphasis in text-based messages.

Take a look at this: Demand Assigned Multiple Access

String patterns are discouraged in favor of skeletons, which are more flexible and easier to localize. This is because string patterns are locale-sensitive, requiring translators to localize them as well, which can be error-prone and inconsistent.

You might enjoy: String Format Golang

Using string patterns also means you won't benefit from the curated patterns provided by the Unicode Consortium for many locales. For example, a pattern string "'{0}'" represents the string "{0}", not a FormatElement, and must be used carefully to avoid confusion.

The complexity of localizing string patterns can be overwhelming, especially when dealing with regional variants. For instance, translating a pattern for French might not be suitable for French-Canadian speakers.

In contrast, skeletons are localized according to the MessageFormat locale, which can include regional variants. This ensures that your messages are formatted correctly for the target audience.

Unsupported formats are not supported by Intl.NumberFormat, requiring language-specific code to implement.

Ordinal, duration, and spellout arguments are actually supported by the parser, but they act like numbers and are not fully supported by Intl.NumberFormat.

These formats would make the library too large, so for now, you can pass them into the message pre-formatted and reference them in the message pattern with a simple string placeholder.

You can use a message pre-formatted with ordinal, duration, or spellout arguments, and then reference them in the message pattern with a placeholder like { arg }.

Discover more: Messaging Apps Not Working

Format Options are quite flexible, and you have several choices when it comes to formatting your messages.

You can use ICU formats to format numbers, dates, and times. ICU formats include options like percent, currency, short, medium, long, and full.

The ICU formats for numbers are percent and currency, while for dates and times, you can use short, medium, long, and full formats.

Here are some specific ICU formats you can use:

You can also use predefined styles, which are recommended. These styles include short, medium, long, and full for dates and times, and integer, currency, and percent for number formatting.

Message format is a powerful tool for creating dynamic messages in your program. It allows you to insert variables into a message, making it more flexible and user-friendly.

You can create a MessageFormat instance that can be used repeatedly, which is more efficient than creating a new instance each time. This is done by calling the constructor with a pattern and arguments.

For more complex patterns, you can use a ChoiceFormat to produce correct forms for singular and plural. For example, you can create a ChoiceFormat programmatically to handle different cases.

Escaping is a bit tricky in ICU Message Format. For instance, if you have a message with multiple occurrences of the same argument, the last match will be the final result of the parsing.

To include the value of a variable in a message, surround it with braces. For example, if you have a message like "Hello, {username}!", the username will be replaced with the actual value.

You can also use patterns to create a ChoiceFormat, which is a more elegant way to handle complex cases. However, be careful not to produce a format that recurses on itself, which will cause an infinite loop.