Otrzymujesz aktualny język urządzenia w iOS?

Chciałbym pokazać bieżący język, którego używa interfejs użytkownika urządzenia. Jakiego kodu użyłbym?

Chcę to jako NSStringw pełni pisanym formacie. (Nie @ „en_US”)

EDYCJA: Dla tych, którzy przejeżdżają, jest tu mnóstwo przydatnych komentarzy, ponieważ odpowiedź ewoluowała wraz z nowymi wersjami iOS.

Dostarczone rozwiązania w rzeczywistości zwrócą bieżący region urządzenia - nie aktualnie wybrany język. Często są one takie same. Jeśli jednak jestem w Ameryce Północnej i ustawię język na japoński, moim regionem nadal będzie angielski (Stany Zjednoczone). Aby odzyskać aktualnie wybrany język, możesz:

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

Zwróci dwuliterowy kod dla aktualnie wybranego języka. „en” dla języka angielskiego, „es” dla języka hiszpańskiego, „de” dla języka niemieckiego itp. Więcej przykładów można znaleźć w tym wpisie w Wikipedii (w szczególności w kolumnie 639-1):

Lista kodów ISO 639-1

Wówczas wystarczy prosta konwersja dwuliterowych kodów na ciąg znaków, który chcesz wyświetlić. Więc jeśli jest to „en”, wyświetl „English”.

Mam nadzieję, że pomoże to komuś, kto chce odróżnić region od aktualnie wybranego języka.

EDYTOWAĆ

Warto zacytować informacje nagłówka z 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

Osoby zainteresowane językiem aplikacji przyglądają się odpowiedzi @ mindvision

Wybrana odpowiedź zwraca bieżący język urządzenia, ale nie rzeczywisty język używany w aplikacji. Jeśli nie podasz lokalizacji w aplikacji dla preferowanego języka użytkownika, zostanie użyta pierwsza dostępna lokalizacja, uporządkowana według preferowanej kolejności użytkownika.

Aby odkryć aktualny język wybrany w twoich lokalizacjach użyj

[[NSBundle mainBundle] preferredLocalizations];

Przykład:

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

Szybki:

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

Rozwiązanie dla iOS 9:

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

language = "en-US"

NSDictionary *languageDic = [NSLocale componentsFromLocaleIdentifier:language];

languageDic będzie miał potrzebne komponenty

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

countryCode = "US"

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

languageCode = "en"

Zapewni to prawdopodobnie to, czego chcesz:

NSLocale *locale = [NSLocale currentLocale];

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

Wyświetli nazwę języka w samym języku. Na przykład:

Français (France)
English (United States)

Wszystkie zaakceptowane i pozostałe odpowiedzi nie biorą pod uwagę, że preferowanym językiem może być inny język niż język urządzenia .

Język urządzenia to język, w którym prezentowane są elementy systemu operacyjnego i aplikacje Apple.

Preferowany język jest językiem użytkownik chciałby mieć aplikacje zlokalizowane w. Jabłko zapewnia tylko ograniczoną liczbę tłumaczeń. Jeśli preferowanym językiem jest jeden język, na który Apple przetłumaczyło swoje aplikacje, będzie to również język urządzenia. Jeśli jednak użytkownik preferuje język, dla którego Apple nie zapewnia tłumaczeń, urządzenie i preferowane języki nie będą pasować . Język urządzenia nie będzie na pierwszym miejscu na liście preferowanych języków.

Poniższa funkcja przejdzie przez listę preferowanych języków i sprawdzi, czy jest dostępne tłumaczenie w środowisku Apple. Pierwszym językiem do tłumaczenia jest język urządzenia. Funkcja zwróci kod języka.

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
}

Działa to, jeśli lista preferowanych języków to:

1. Afrikaans (iOS nie jest tłumaczony na afrikaans)
2. Hiszpański (język urządzenia)

Lista język korzystne mogą być edytowane w : Settings.app -> Ogólne -> Język i region -> Preferowany język Zamówienie

Możesz następnie użyć kodu języka urządzenia i przetłumaczyć go na nazwę języka. Poniższe wiersze wydrukują język urządzenia w języku urządzenia. Na przykład „Español”, jeśli urządzenie jest ustawione na hiszpański.

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)
    }
} 

używam tego

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

zignoruj ​​wyciek pamięci

i wynik jest

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

Tłumaczenie kodów językowych, takich jak en_US na angielski (Stany Zjednoczone), jest wbudowaną funkcją NSLocalei NSLocalenie ma znaczenia, skąd masz kody językowe. Tak naprawdę nie ma powodu, aby wdrażać własne tłumaczenie, jak sugeruje zaakceptowana odpowiedź.

// 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);

Wydruki: angielski, niemiecki, szwedzki

Nawet istnieje lepszy sposób na uzyskanie aktualnego języka urządzenia. Spróbujmy poniżej kodu -

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

Sugerowana przez Abizern na tutaj

Możesz użyć displayNameForKey:value:metody 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"]);

Spowoduje to wydrukowanie:

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

Jeśli podasz taki sam identyfikator lokalizacji dla initWithLocaleIdentifier:a także displayNameForKey:value:metoda, to daje rodzimą nazwę języka. Odkryłem, że jeśli usuniesz kod kraju i użyjesz po prostu, fri enże również pominie kraj w nazwie wyświetlanej (przynajmniej w Mac OS X, nie jestem pewien co do iOS).

Szybki

Aby uzyskać bieżący język urządzenia

NSLocale.preferredLanguages()[0] as String

Aby uzyskać język aplikacji

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

Uwaga:

Pobiera język podany w CFBundleDevelopmentRegion info.plist

jeśli CFBundleAllowMixedLocalizations ma wartość true w info.plist, wówczas zwracana jest pierwsza pozycja CFBundleLocalizations w info.plist

Próbowałem znaleźć odpowiednie rozwiązanie dla siebie. Kiedy używam Locale.preferredLanguages.firstzostał zwrócony preferowany język z ustawień aplikacji.

Jeśli chcesz poznać język z ustawień urządzenia użytkownika, użyj poniższego ciągu:

Szybki 3

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

Aby rozpakować i użyć, spójrz na linię poniżej:

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

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

Aby uzyskać bieżący język urządzenia użytkownika, użyj następującego kodu, który dla mnie zadziałał.

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

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

Użytkownicy mogą wybrać preferowany język aplikacji niezależnie od języka systemu operacyjnego.

Możesz użyć tych:

    // 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

W przypadku programistów MonoTouch C # użyj:

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

Uwaga: wiem, że było to pytanie na iOS, ale ponieważ jestem programistą MonoTouch, odpowiedź na tej stronie poprowadziła mnie we właściwym kierunku i pomyślałem, że podzielę się wynikami.

W Swift:

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

Szybki 3

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

Prosta funkcja Swift 3:

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

Jeśli szukasz preferowanego kodu języka („en”, „de”, „es” ...) i zlokalizowanej nazwy preferowanego języka (dla bieżących ustawień regionalnych), oto proste rozszerzenie w 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;

}

Jeśli chcesz uzyskać tylko język, oto moja sugerowana odpowiedź:

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

W moim przypadku chciałem tylko język regionalny, a nie region regionalny.

Dane wyjściowe: jeśli Twoim językiem lokalizacji jest język japoński, a regionem jest Japonia, to:

langplusreg = ja-JP

langonly = ja

Odpowiedź @amir w Swift:

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

Oczywiście rozwiązania oparte na przykład na

[[NSLocale preferredLanguages] objectAtIndex:0]

zwykle działają dobrze i zwracają bieżący język urządzenia.

Ale w niektórych przypadkach może być mylące:

Jeśli aplikacja, w której chcesz uzyskać tę wartość, już zmieniła język, na przykład za pomocą tego rodzaju kodu:

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

W tym przypadku [NSLocale preferowane języki] faktycznie zwraca preferowany zestaw języków (i używany) w tej konkretnej aplikacji, a nie bieżący język urządzenia!

I ... w tym przypadku jedynym sposobem na poprawne pobranie aktualnego języka urządzenia (a nie tego wcześniej ustawionego w aplikacji) jest najpierw wyczyszczenie klucza @ „appleLanguages” w NSUserDefault:

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

Następnie [NSLocale preferLanguages] zwraca teraz poprawną wartość.

Mam nadzieję, że to pomoże.

Zaktualizowana odpowiedź dla Swift 4

let language = Bundle.main.preferredLocalizations.first

W przypadku Swift 3.0 poniżej można użyć kodu, aby odpowiedzieć na twoje pytanie:

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

W Swift 4.2 i Xcode 10.1

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

Według dokumentacji Apple

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

Format dwóch liter. Apple stosuje normę ISO ISO-3166 .

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

W przypadku Swift 3:

NSLocale.preferredLanguages ​​[0] as String

Począwszy od iOS 9, jeśli chcesz tylko kodu języka bez kodu kraju, będziesz potrzebować tego rodzaju funkcji pomocniczej - ponieważ język będzie zawierał kod kraju.

// 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)