Obtenir la langue actuelle de l'appareil dans iOS?

Je voudrais montrer la langue actuelle que l'interface utilisateur de l'appareil utilise. Quel code devrais-je utiliser?

Je veux que ce soit dans un NSStringformat entièrement expliqué. (Pas @ "en_US")

EDIT: Pour ceux qui passent, il y a une tonne de commentaires utiles ici, car la réponse a évolué avec les nouvelles versions d'iOS.

Les solutions fournies renverront en fait la région actuelle de l'appareil - pas la langue actuellement sélectionnée. Ce sont souvent les mêmes. Cependant, si je suis en Amérique du Nord et que je mets ma langue au japonais, ma région sera toujours l'anglais (États-Unis). Pour récupérer la langue actuellement sélectionnée, vous pouvez:

NSString * language = [[NSLocale preferredLanguages] firstObject];

Cela renverra un code à deux lettres pour la langue actuellement sélectionnée. "en" pour l'anglais, "es" pour l'espagnol, "de" pour l'allemand, etc. Pour plus d'exemples, veuillez consulter cette entrée Wikipedia (en particulier, la colonne 639-1):

Liste des codes ISO 639-1

Il suffit ensuite de convertir les codes à deux lettres en la chaîne que vous souhaitez afficher. Donc, si c'est "en", affichez "Anglais".

J'espère que cela aidera quelqu'un qui cherche à faire la différence entre la région et la langue actuellement sélectionnée.

ÉDITER

Vaut la peine de citer les informations d'en-tête de NSLocale.h:

+ (NSArray *)preferredLanguages NS_AVAILABLE(10_5, 2_0); // note that this list does not indicate what language the app is actually running in; the [NSBundle mainBundle] object determines that at launch and knows that information

Les personnes intéressées par le langage de l'application regardent la réponse de @ mindvision

La réponse sélectionnée renvoie la langue actuelle de l'appareil, mais pas la langue réelle utilisée dans l'application. Si vous ne fournissez pas de localisation dans votre application pour la langue préférée de l'utilisateur, la première localisation disponible, commandée par la commande préférée de l'utilisateur, est utilisée.

Pour découvrir la langue actuellement sélectionnée dans vos localisations, utilisez

[[NSBundle mainBundle] preferredLocalizations];

Exemple:

NSString *language = [[[NSBundle mainBundle] preferredLocalizations] objectAtIndex:0];

Rapide:

let language = NSBundle.mainBundle().preferredLocalizations.first as NSString

Solution pour iOS 9:

NSString *language = [[NSLocale preferredLanguages] objectAtIndex:0];

langue = "en-US"

NSDictionary *languageDic = [NSLocale componentsFromLocaleIdentifier:language];

languageDic aura les composants nécessaires

NSString *countryCode = [languageDic objectForKey:@"kCFLocaleCountryCodeKey"];

countryCode = "US"

NSString *languageCode = [languageDic objectForKey:@"kCFLocaleLanguageCodeKey"];

languageCode = "en"

Cela vous donnera probablement ce que vous voulez:

NSLocale *locale = [NSLocale currentLocale];

NSString *language = [locale displayNameForKey:NSLocaleIdentifier 
                                         value:[locale localeIdentifier]];

Il affichera le nom de la langue, dans la langue elle-même. Par exemple:

Français (France)
English (United States)

Les réponses acceptées et les autres ne tiennent pas compte du fait que la langue préférée peut être une autre langue que la langue de l'appareil .

La langue de l'appareil est la langue dans laquelle les éléments du système d'exploitation et les applications Apple sont présentés.

La langue préférée est la langue dans laquelle l'utilisateur souhaite que les applications soient localisées. Apple ne fournit qu'un ensemble limité de traductions. Si la langue préférée est une langue vers laquelle Apple a traduit ses applications, ce sera également la langue de l'appareil. Cependant, si l'utilisateur préfère une langue pour laquelle Apple ne fournit pas de traductions, l' appareil et les langues préférées ne correspondent pas . La langue de l'appareil ne sera pas en première position dans la liste des langues préférées.

La fonction suivante va parcourir la liste des langues préférées et vérifier s'il y a une traduction dans les frameworks Apple. La première langue à traduire est la langue de l'appareil. La fonction renverra son code de langue.

func deviceLanguage() -> String? {
    let systemBundle: NSBundle = NSBundle(forClass: UIView.self)
    let englishLocale: NSLocale = NSLocale(localeIdentifier: "en")

    let preferredLanguages: [String] = NSLocale.preferredLanguages()

    for language: String in preferredLanguages {
        let languageComponents: [String : String] = NSLocale.componentsFromLocaleIdentifier(language)

        guard let languageCode: String = languageComponents[NSLocaleLanguageCode] else {
            continue
        }

        // ex: es_MX.lproj, zh_CN.lproj
        if let countryCode: String = languageComponents[NSLocaleCountryCode] {
            if systemBundle.pathForResource("\(languageCode)_\(countryCode)", ofType: "lproj") != nil {
                // returns language and country code because it appears that the actual language is coded within the country code aswell
                // for example: zh_CN probably mandarin, zh_HK probably cantonese
                return language
            }
        }

        // ex: English.lproj, German.lproj
        if let languageName: String = englishLocale.displayNameForKey(NSLocaleIdentifier, value: languageCode) {
            if systemBundle.pathForResource(languageName, ofType: "lproj") != nil {
                return languageCode
            }
        }

        // ex: pt.lproj, hu.lproj
        if systemBundle.pathForResource(languageCode, ofType: "lproj") != nil {
            return languageCode
        }
    }

    return nil
}

Cela fonctionne si la liste des langues préférées est:

1. Afrikaans (iOS n'est pas traduit en afrikaans)
2. Espagnol (langue de l'appareil)

La liste des langues préférées peut être modifiée dans : Settings.app -> General -> Language & Region -> Preferred Language Order

Vous pouvez alors utiliser le code de langue de l'appareil et le traduire en nom de langue. Les lignes suivantes imprimeront la langue de l'appareil dans la langue de l'appareil. Par exemple, "Español" si l'appareil est réglé sur l'espagnol.

if let deviceLanguageCode: String = deviceLanguage() {
    let printOutputLanguageCode: String = deviceLanguageCode
    let printOutputLocale: NSLocale = NSLocale(localeIdentifier: printOutputLanguageCode)

    if let deviceLanguageName: String = printOutputLocale.displayNameForKey(NSLocaleIdentifier, value: deviceLanguageCode) {
        // keep in mind that for some localizations this will print a language and a country
        // see deviceLanguage() implementation above
        print(deviceLanguageName)
    }
} 

j'utilise ceci

    NSArray *arr = [NSLocale preferredLanguages];
for (NSString *lan in arr) {
    NSLog(@"%@: %@ %@",lan, [NSLocale canonicalLanguageIdentifierFromString:lan], [[[NSLocale alloc] initWithLocaleIdentifier:lan] displayNameForKey:NSLocaleIdentifier value:lan]);
}

ignorer la fuite de mémoire ..

et le résultat est

2013-03-02 20:01:57.457 xx[12334:907] zh-Hans: zh-Hans 中文（简体中文）
2013-03-02 20:01:57.460 xx[12334:907] en: en English
2013-03-02 20:01:57.462 xx[12334:907] ja: ja 日本語
2013-03-02 20:01:57.465 xx[12334:907] fr: fr français
2013-03-02 20:01:57.468 xx[12334:907] de: de Deutsch
2013-03-02 20:01:57.472 xx[12334:907] nl: nl Nederlands
2013-03-02 20:01:57.477 xx[12334:907] it: it italiano
2013-03-02 20:01:57.481 xx[12334:907] es: es español

La traduction de codes de langue tels que en_US en anglais (États-Unis) est une fonction intégrée de NSLocaleet NSLocalene se soucie pas d'où vous obtenez les codes de langue. Il n'y a donc vraiment aucune raison d'implémenter votre propre traduction comme le suggère la réponse acceptée.

// Example code - try changing the language codes and see what happens
NSLocale *locale = [[NSLocale alloc] initWithLocaleIdentifier:@"en"];
NSString *l1 = [locale displayNameForKey:NSLocaleIdentifier value:@"en"];
NSString *l2 = [locale displayNameForKey:NSLocaleIdentifier value:@"de"];
NSString *l3 = [locale displayNameForKey:NSLocaleIdentifier value:@"sv"];
NSLog(@"%@, %@, %@", l1, l2, l3);

Impressions: anglais, allemand, suédois

Même il existe un meilleur moyen d'obtenir la langue actuelle de l'appareil. Essayons par le code ci-dessous -

NSLog(@"Current Language - %@", [[NSLocale preferredLanguages] firstObject]);

Proposé par Abizern sur ici

Vous pouvez utiliser la displayNameForKey:value:méthode de NSLocale:

// get a French locale instance
NSLocale *frLocale = [[[NSLocale alloc] initWithLocaleIdentifier:@"fr_FR"] autorelease];

// use it to get translated display names of fr_FR and en_US
NSLog(@"%@", [frLocale displayNameForKey:NSLocaleIdentifier value:@"fr_FR"]);
NSLog(@"%@", [frLocale displayNameForKey:NSLocaleIdentifier value:@"en_US"]);

Cela imprimera:

français (France)
anglais (États-Unis)

Si vous spécifiez le même identificateur de paramètres régionaux pour la méthode initWithLocaleIdentifier:et également displayNameForKey:value:, il vous donnera le nom natif de la langue. J'ai découvert que si vous supprimez le code de pays et utilisez simplement fret en, cela supprimera également le pays du nom d'affichage (sur Mac OS X au moins, je ne suis pas sûr d'iOS).

Rapide

Pour obtenir la langue actuelle de l'appareil

NSLocale.preferredLanguages()[0] as String

Pour obtenir la langue de l'application

NSBundle.mainBundle().preferredLocalizations[0] as NSString

Remarque:

Il récupère le langage que vous avez donné dans CFBundleDevelopmentRegion of info.plist

si CFBundleAllowMixedLocalizations est vrai dans info.plist, le premier élément de CFBundleLocalizations dans info.plist est renvoyé

J'ai essayé de trouver la bonne solution pour moi. Lorsque j'utilise a Locale.preferredLanguages.firstété retourné la langue préférée de vos paramètres d'application.

Si vous souhaitez connaître la langue à partir des paramètres de la machine utilisateur, vous devez utiliser la chaîne ci-dessous:

Swift 3

let currentDeviceLanguage = Locale.current.languageCode
// Will return the optional String

Pour déballer et utiliser, regardez la ligne ci-dessous:

if let currentDeviceLanguage = Locale.current.languageCode {
    print("currentLanguage", currentDeviceLanguage)

    // For example
    if currentDeviceLanguage == "he" {
        UIView.appearance().semanticContentAttribute = .forceRightToLeft
    } else {
        UIView.appearance().semanticContentAttribute = .forceLeftToRight
    }
}

Pour obtenir la langue actuelle de la machine utilisateur, utilisez le code informatique suivant, cela a fonctionné pour moi.

NSString * myString = [[NSLocale preferredlanguage]objectAtIndex:0];

iOS13, Swift 5+, WWDC2019 https://developer.apple.com/videos/play/wwdc2019/403/

Les utilisateurs peuvent sélectionner la langue préférée d'une application indépendamment de la langue du système d'exploitation.

Vous pouvez les utiliser:

    // Returns a list of the user's preferred languages.
    // Maybe more than (or none of) your app supports!
    Locale.preferredLanguages

    // a subset of this bundle's localizations, re-ordered into the preferred order
    // for this process's current execution environment; the main bundle's preferred localizations
    // indicate the language (of text) the user is most likely seeing in the UI
    Bundle.main.preferredLocalizations



    // The current running app language
    Bundle.main.preferredLocalizations.first

    // list of language names this bundle appears to be localized to
    Bundle.main.localizations

Pour les développeurs MonoTouch C #, utilisez:

NSLocale.PreferredLanguages.FirstOrDefault() ?? "en"

Remarque: je sais que c'était une question iOS, mais comme je suis développeur MonoTouch, la réponse sur cette page m'a conduit dans la bonne direction et j'ai pensé partager les résultats.

Dans Swift:

let languageCode = NSLocale.currentLocale().objectForKey(NSLocaleLanguageCode) as? String

Swift 3

let locale = Locale.current
let code = (locale as NSLocale).object(forKey: NSLocale.Key.countryCode) as! String?
print(code!)

Fonction Swift 3 simple:

  @discardableResult
  func getLanguageISO() -> String {
    let locale = Locale.current
    guard let languageCode = locale.languageCode,
          let regionCode = locale.regionCode else {
        return "de_DE"
    }
    return languageCode + "_" + regionCode
  }

Si vous recherchez le code de langue préféré ("en", "de", "es" ...) et le nom de langue préféré localisé (pour les paramètres régionaux actuels), voici une extension simple dans Swift:

extension Locale {
static var preferredLanguageIdentifier: String {
    let id = Locale.preferredLanguages.first!
    let comps = Locale.components(fromIdentifier: id)
    return comps.values.first!
}

static var preferredLanguageLocalizedString: String {
    let id = Locale.preferredLanguages.first!
    return Locale.current.localizedString(forLanguageCode: id)!
}

}

-(NSString *)returnPreferredLanguage { //as written text

NSUserDefaults * defaults = [NSUserDefaults standardUserDefaults];
NSArray *preferredLanguages = [defaults objectForKey:@"AppleLanguages"];
NSString *preferredLanguageCode = [preferredLanguages objectAtIndex:0]; //preferred device language code
NSLocale *enLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en"]; //language name will be in English (or whatever)
NSString *languageName = [enLocale displayNameForKey:NSLocaleIdentifier value:preferredLanguageCode]; //name of language, eg. "French"
return languageName;

}

Si vous souhaitez obtenir uniquement la langue, voici ma réponse suggérée:

NSString *langplusreg = [[NSLocale preferredLanguages] objectAtIndex:0];
NSString * langonly = [[langplusreg componentsSeparatedByString:@"-"] 
objectAtIndex:0];

Dans mon cas, je voulais seulement la langue locale et non la région locale.

Sortie: Si votre langue locale est le japonais et que la région locale est le Japon, alors:

langplusreg = ja-JP

langonly = ja

Réponse de @amir dans Swift:

// Get language prefered by user
    let langageRegion = NSLocale.preferredLanguages().first!
    let languageDic = NSLocale.componentsFromLocaleIdentifier(langageRegion)
    let language = languageDic[NSLocaleLanguageCode]

De toute évidence, les solutions reposant, par exemple, sur

[[NSLocale preferredLanguages] objectAtIndex:0]

fonctionnent généralement bien et renvoient la langue actuelle de l'appareil.

Mais cela pourrait être trompeur dans certains cas:

Si l'application dans laquelle vous souhaitez obtenir cette valeur a déjà changé la langue, par exemple avec ce type de code:

NSString *lg = @"en"; // or anything like @"en", @"fr", etc.
[[NSUserDefaults standardUserDefaults] 
    setObject:[NSArray arrayWithObjects:lg, nil]  
    forKey:@"AppleLanguages"]

Dans ce cas, [NSLocale PreferredLanguages] renvoie en fait le jeu de langues préféré (et utilisé) dans cette application particulière, pas la langue actuelle de l'appareil!

Et ... dans ce cas, le seul moyen d'obtenir correctement la langue actuelle de l'appareil actuel (et non celle précédemment définie dans l'application) est d'abord de supprimer la clé @ "appleLanguages" dans NSUserDefaults, comme ceci:

[[NSUserDefaults standardUserDefaults]removeObjectForKey:@"AppleLanguages"];

Ensuite, [NSLocale PreferredLanguages] renvoie maintenant la valeur correcte.

J'espère que cette aide.

Réponse mise à jour pour Swift 4

let language = Bundle.main.preferredLocalizations.first

Pour Swift 3.0, le code ci-dessous peut être utilisé pour répondre à votre question:

 let language = Bundle.main.preferredLocalizations.first! as NSString

Dans Swift 4.2 et Xcode 10.1

let language = NSLocale.preferredLanguages[0]
print(language)//en

Selon la documentation Apple

NSUserDefaults* defs = [NSUserDefaults standardUserDefaults];
NSArray* languages = [defs objectForKey:@"AppleLanguages"];
NSString* preferredLang = [languages objectAtIndex:0];

Format à deux lettres. Apple utilise la norme ISO ISO-3166 .

NSString *localeCountryCode = [[NSLocale autoupdatingCurrentLocale] objectForKey:NSLocaleCountryCode];

Pour Swift 3:

NSLocale.preferredLanguages ​​[0] en tant que chaîne

À partir d'iOS 9, si vous voulez simplement le code de langue sans code de pays, vous aurez besoin de ce type de fonction d'aide - car la langue contiendra le code de pays.

// gets the language code without country code in uppercase format, i.e. EN or DE
NSString* GetLanguageCode()
{
    static dispatch_once_t onceToken;
    static NSString* lang;
    dispatch_once(&onceToken, ^
    {
        lang = [[[NSLocale preferredLanguages] objectAtIndex:0] uppercaseString];
        NSRegularExpression* regex = [NSRegularExpression regularExpressionWithPattern:@"^[A-Za-z]+" options:0 error:nil];
        NSTextCheckingResult* match = [regex firstMatchInString:lang options:0 range:NSMakeRange(0, lang.length)];
        if (match.range.location != NSNotFound)
        {
            lang = [lang substringToIndex:match.range.length];
        }
    });
    return lang;
}

SWIFT-4

 // To get device default selected language. It will print like short name of zone. For english, en or spain, es.



let language = Bundle.main.preferredLocalizations.first! as NSString
    print("device language",language)