Understanding iOS internationalization

Standard locale data

Software applications can face differences above and beyond straightforward translation of phrases and words, because laptop programs can generate content dynamically. These differences may prefer to be taken into account by the internationalization process in preparation intended for translation. Many of these differences are so regular a conversion among languages can be easily automatic. The Common Locale Data Database by Unicode provides a number of such variations. Its info is used by simply major systems, including Microsoft Windows, macOS and Debian, and by key Internet corporations or tasks such as Yahoo and the Wikimedia Foundation. Samples of such distinctions include:

  • Different scripts in different publishing systems make use of different characters another type of set of letters, syllograms, logograms, or icons. Modern systems use the Unicode standard to symbolize many different dialects with a solitary character development.
  • Writing direction is usually left to right in many European dialects, right-to-left in Hebrew and Arabic, or perhaps both in boustrophedon scripts, and optionally up and down in some Cookware languages.
  • Sophisticated text design, for languages where characters change shape depending on circumstance
  • Capitalization exists in some scripts rather than in other folks
  • Several languages and writing software has different textual content sorting guidelines
  • Different languages have different numeral systems, which might should be supported in the event that Western Persia numerals are not used
  • Different ‘languages’ have different pluralization rules, which can complicate courses that dynamically display statistical content. Other sentence structure rules may additionally vary, at the. g. genitive.
  • Several languages make use of different punctuation (e. g. quoting textual content using double-quotes ( ) as in British, or guillemets (« ») as in French)
  • Key pad shortcuts can simply make use of switches actually within the keyboard design which is staying localized pertaining to. If a shortcut corresponds to anything in a particular language (e. g. Ctrl-s stands for save in English), it may need to be changed.

Donreuse strings

Or even more accurately, donreuse strings just because they are really similar if the string itself has a distinct purpose or perhaps meaning.

By way of example: imagine you have an on/off switch in the app and the switch control needs the written text for and to be localized. You also display the value of that setting elsewhere in the iphone app in a text label. You should use different strings for the switch screen versus the switchstatus (even if they are precisely the same string within your default language) by way of example:

  • On displayed on the swap itself
  • Off displayed around the switch on its own
  • On exhibited in a packaging
  • Off viewed in a labeled

This provides optimum flexibility intended for the übersetzungsprogramm:

  • Pertaining to design reasons, perhaps the change itself uses lowercase on and off but the screen label uses upper circumstance On and Off.
  • Some dialects might need the switch benefit to be close to fit inside the user interface control, while the finish (translated) phrase can are available in the label.
  • Alternatively, for a few languages the rendering of the switch may be use I and O for cultural familiarity, however you might want the label to read On or perhaps Off.

Basic internationalization

It’s a fancy name for distancing your storyboards/nibs UI coming from text, so , instead of helping million copies of storyboard/nib you just take care of million types of. strings files and single storyboard/nib. I nonetheless don’t still find it much valuable as I don’t store very much user facing strings in storyboards/nibs, but it really worth it. Localization native creation region or perhaps CFBundleDevelopmentRegion explains to which localization is the Base place.

Forcing NSLocalizedString to use particular locale’s plural rules

While I was searching CoreFoundation with Hopper I came across that there is a mention of the additional NSStringFormatLocaleKey key around NSStringFormatSpecTypeKey and NSStringFormatValueTypeKey. From your decompiled code it looked like if this key was present, it absolutely was used as being a locale to get plural rules intended for. Unfortunately the worthiness behind this key has to be an area object, not string locale-ID, so you can’t just put it along with a. stringsdict. Meaning that there’s only a hacky way to push locale by code:

Which only works in iOS8-. My spouse and i strongly suppress anybody from using this in production.


If we want to ensure we are using the correct keys, we have to cover localization with our unit tests. If we try to check our UI elements, all of us will quickly discover, that we can only test if the correct chain was set on the UI element. All of us can’t evaluation if the right localization important was used, because the key is not saved anywhere. We can fix that by extending the UI aspect. In this case, let’s extend the UILabel. We will include a new homelocalizationKeytowards the UILabel. We will also put in a new functionset(with crucial: LocalizationKey). This kind of function will save the key and place the text. We need to create this functionality for a lot of UI elements we want to test out.

This could be quite tedious mainly because we have to override all the elements and also identify the correct overridden class if we build the user interface. I would still use this option on a larger job because you get a lot of benefit from the power of having all of the UI elements extended.

We are able to try to use exts to save the localization essential. The main issue here is that extensions don’t allow employing stored homes. We can get around this by using connected objects.

This removes the need for extending USER INTERFACE elements and remains totally testable. In some cases, associated things would be the prefered way to do this if we are too lazy to bother working with all the extended classes.

I presented a couple of options means handle localization keys inside your project. The tests look the same for almost any option we choose. We will simply use XCAssertEqual to check if we could using the right keys.

If you opt to use enums with raw string values, you don’t have to do any additional setup.

If we want to test with structs, we must upgrade each of our struct a little and preserve the localization key:

All of us also have to update our prolonged UILabel, and save the localization important from the struct:

Testing gets most complicated whenever using enums with associated ideals. Here, the equal way for enum should be implemented. We must cover almost all possible situations and also take those associated benefit into consideration. The following is an article that describes tips on how to achieve this https://medium.com/@jegnux/on-swift-enums-with-associated-value-equality-e815a768d9b0

i18n and L10n

Internationalizationis the technique of making your code in a position of displaying different languages and establishing its display for different venues (such while number and date formatting). This is also termed asglobalization.

Localizationis the stage that follows creating solutions (such because strings and images) for every single language and bundling associated with the internationalize app.

Internationalization it is often shortened to i18n short for 18 letters between i and n. Localization is likewise shortened to L10n for twelve letters among L and n.

Stand 2 . 6 Examples of Surrogate Pairs


Code Point

Surrogate Pair

The following code snippet demonstrates how to get a printout of a surrogate pair if you are given the code level:

Note that this is certainly taking advantage of theCFStringGetSurrogatePairForLongCharacterfunction, which roadmaps a UTF-32 character into a pair of UTF-16 surrogate heroes. We need a variety to select the producing UTF-16 set intothat’s the actualcharacterArrayis definitely forand then theinitWithCharacters: span:method ofNSStringdoes the rest.

In speaking to many other developers, I’ve found that one of the gotchas they’ve were required to debug and fix was from the consequence of copying and pasting surrogate pairs. They’ve also had issues whenever using Greek/mathematical icons. The result of the paste action was munged and lacking characters. Perform thorough screening with a selection of characters, individuals with high Unicode code stage values, surrogate pairs, and Emoji heroes, especially if your app helps text entrance.

Rewording textual content

The other way, wording and terminology text pertaining to brevity, may be used to try to shorten the chain to fit inside the allotted space. Perhaps the layout features two keys side-by-side with no additional vertical space to expand in to. In that case, it is especially useful. For situations where all of us determined that the was the best solution, we proclaimed our strings files having a custom characteristic denoting the fact that length of the text message should be because brief as is feasible and attemptedto be match the existing character count with the English phrase.

Some Lessons I Learned

  1. Localization is a wonderful idea. So far, I was regretting my decision of localizing my software in twelve languages. I’d written several Quora answers on how it was the most labor intensive thing Used to do for my own app and I’d not really advise any kind of indie designer without the price range to outsource to localize. But now my opinion has changed. Localizing your iphone app in 1012 languages applying Google Convert and having friends proofread it is a great method to reach a larger audience for your app. Apple also loves localized programs more. You can’t always get every thing right and every possible chain localized. However you can get 80 percent of the benefits (i. at the., text translated) with the 20% of the work.
  2. Individuals are much more happy to help you you think. We am extremely grateful to possess a number of close friends and teachers who helped me a lot in this journey. Yet I was simply astonished how so many other people responded to me personally when I reached out to them and helped me. Very in the beginning in my journey, when I merely had a tiny prototype from the main user interface of my own app, I reached out to Carla White colored after I experienced read her amazing publication. She mentored me and helped me with her advice for the app. As I was localizing my application, I needed proofreaders for each vocabulary to make sure the translations (done using Yahoo Translate) are excellent and circumstance specific. Pascal commented in the story about Medium offering his assistance with German translations. I reached out to him and on a really short recognize, he really did modify my The german language translations! And many more complete other people offered their help. A single important essential takeaway using this would be: People are willing to help you. Reach out to all of them, be honest, and they will assist you in any way they will!: D
  3. User reviews early on can be super important. Not only do the kind words out of your fans or perhaps believers encourage you, yet a lot of your early users will give you delete word features, for design advancements, and much more beneficial feedback. One of many mistakes My spouse and i made was testing very late. My spouse and i uploaded my build pertaining to TestFlight testing only

1 week ahead of planned release when the iphone app was virtually ready and i also couldn’t make major changes. If I acquired asked my own users to start testing weeks ago after i just acquired the main interface, I’d have gotten lots of feedback and would have increased it. And iterated that for every key feature, my own app is a whole lot better. Quite a few testers have described things that could have been fixed in 23 days easily had sent the build for assessment earlier. Thus my guidance to everybody would be: Get your app inside the hands of the users and also have them test that asap and get opinions!


According toSoftware without frontiers, the design aspects to cons

Translation is typically the most time-consuming component of language localization. This may involve:

  • For film, v
  • Different translation length and differences in character sizes (e.g. between Latin alphabet letters and Chinese characters) can cause layouts that work well in one language to work poorly in others
  • Cons
  • Writing conventions like:
    • Formatting of figures (especially decimal separator and digit grouping)
    • Particular date and period format, quite possibly including usage of different calendars

How -[NSString initWithFormat: locale: quarrels: ] converts amounts to thread representation?

Take this lines of code:

My spouse and i wondered about how does it enhance from NSInteger to NSString and inserts it instead of the format specifier, so I digged in with Hopper and got which it uses CFNumberFormatter. It uses primary foundation’s CFNumberFormatter in __CFStringFormatLocalizedNumber called via ___CFStringAppendFormatCore. Therefore you can’t change formatter or change it somehow (only via format specifier configuration just like %. 6f ). You actually can cheat and structure number yourself, but it gets tricky with pluralization, observe corresponding section below intended for details. Intended for objects with %@ specifier it sends -descriptionWithLocale:.