Comment obtenir le code de langue actuel avec Swift?

Je veux obtenir le code de langue de l'appareil (en, es ...) dans mon application écrit avec Swift. Comment pouvez-vous obtenir cela?

J'essaye ceci:

var preferredLanguages : NSLocale!
let pre = preferredLanguages.displayNameForKey(NSLocaleIdentifier, value: preferredLanguages)

Mais cela renvoie nul.

Dans Swift 3

let langStr = Locale.current.languageCode

Il est important de faire la différence entre la langue de l' application et la langue locale de l' appareil (le code ci-dessous est en Swift 3 )

Renvoie la langue de l' appareil :

let locale = NSLocale.current.languageCode

Renvoie la langue de l' application :

let pre = Locale.preferredLanguages[0]

Swift 4 et 5:

Locale.current.languageCode

Dans Swift 3:

NSLocale.current.languageCode

Pour obtenir la langue actuelle utilisée dans votre application (différente des langues préférées)

NSLocale.currentLocale().objectForKey(NSLocaleLanguageCode)!

Swift 3 et 4 et 4.2 et 5

Locale.current.languageCodene compile pas régulièrement. Parce que vous n'avez pas implémenté la localisation pour votre projet.

Vous avez deux solutions possibles

1) String(Locale.preferredLanguages[0].prefix(2)) Il renvoie correctement la langue du téléphone.

Si vous souhaitez obtenir le type en-En, vous pouvez utiliserLocale.preferredLanguages[0]

2) Sélectionnez Project(MyApp)-> Project (not Target)-> appuyez sur le bouton + dans Localizations, puis ajoutez la langue souhaitée.

rapide 3

let preferredLanguage = Locale.preferredLanguages[0] as String
print (preferredLanguage) //en-US

let arr = preferredLanguage.components(separatedBy: "-")
let deviceLanguage = arr.first
print (deviceLanguage) //en

vous pouvez utiliser le code ci-dessous, cela fonctionne bien avec swift 3

var preferredLanguage : String = Bundle.main.preferredLocalizations.first!

Je souhaite suivre la langue choisie par l'utilisateur dans l'application Paramètres à chaque fois que l'utilisateur lance mon application - qui n'est pas encore localisée (mon application est en anglais uniquement). J'ai adopté cette logique:

1. créer une énumération pour faciliter la gestion des langues dans un tableau

   enum Language: String {
   
   case none = ""
   case en = "English"
   case fr = "French"
   case it = "Italian"
   
   } // add as many languages you want

2. créer une ou deux extensions de Locale

   extension Locale {
   
       static var enLocale: Locale {
   
           return Locale(identifier: "en-EN")
       } // to use in **currentLanguage** to get the localizedString in English
   
       static var currentLanguage: Language? {
   
           guard let code = preferredLanguages.first?.components(separatedBy: "-").last else {
   
               print("could not detect language code")
   
               return nil
           }
   
           guard let rawValue = enLocale.localizedString(forLanguageCode: code) else {
   
               print("could not localize language code")
   
               return nil
           }
   
           guard let language = Language(rawValue: rawValue) else {
   
               print("could not init language from raw value")
   
               return nil
           }
           print("language: \(code)-\(rawValue)")
   
           return language
       }
   }

3. Lorsque vous en avez besoin, vous pouvez simplement utiliser l'extension

   if let currentLanguage = Locale.currentLanguage {
       print(currentLanguage.rawValue)
       // Your code here.
   }

Dans Swift, vous pouvez obtenir les paramètres régionaux en utilisant.

let locale = Locale.current.identifier

Locale.current.languageCode me renvoie un code erroné, j'utilise donc ces extensions:

extension Locale {
    static var preferredLanguageCode: String {
        let defaultLanguage = "en"
        let preferredLanguage = preferredLanguages.first ?? defaultLanguage
        return Locale(identifier: preferredLanguage).languageCode ?? defaultLanguage
    }

    static var preferredLanguageCodes: [String] {
        return Locale.preferredLanguages.compactMap({Locale(identifier: $0).languageCode})
    }
}

C'est ce que j'utilise dans Swift 5 Xcode 11:

À l'intérieur des variables de classe:

let languagePrefix = Bundle.main.preferredLocalizations.first?.prefix(2)

Cela vient comme une chaîne. Il renvoie 2 caractères, c'est à dire "en", "es", "de" ...

À partir de là, je peux facilement déterminer la langue à afficher:

 if languagePrefix == "es" { self.flipCard.setTitle("última carta", for: .normal) }
 if languagePrefix == "en" { self.flipCard.setTitle("Last Card", for: .normal) }

Si vous voulez des informations complètes sur la langue, supprimez? .Prefex (2)