Auf dem iPhone wird NSLocalizedStringdie Zeichenfolge in der Sprache des iPhone zurückgegeben. Ist es möglich, NSLocalizedStringdie Verwendung einer bestimmten Sprache zu erzwingen , damit die App in einer anderen Sprache als das Gerät angezeigt wird?

NSLocalizedString()(und Varianten davon) greifen Sie auf den Schlüssel "AppleLanguages" NSUserDefaultszu, um die Einstellungen des Benutzers für bevorzugte Sprachen zu bestimmen. Dies gibt eine Reihe von Sprachcodes zurück, wobei der erste vom Benutzer für sein Telefon festgelegt wird und die nachfolgenden als Fallbacks verwendet werden, wenn eine Ressource nicht in der bevorzugten Sprache verfügbar ist. (Auf dem Desktop kann der Benutzer mehrere Sprachen mit einer benutzerdefinierten Reihenfolge in den Systemeinstellungen angeben.)

Sie können die globale Einstellung für Ihre eigene Anwendung überschreiben, wenn Sie möchten, indem Sie die Methode setObject: forKey: verwenden, um Ihre eigene Sprachliste festzulegen. Dies hat Vorrang vor dem global festgelegten Wert und wird an jeden Code in Ihrer Anwendung zurückgegeben, der die Lokalisierung durchführt. Der Code dafür würde ungefähr so ​​aussehen:

[[NSUserDefaults standardUserDefaults] setObject:[NSArray arrayWithObjects:@"de", @"en", @"fr", nil] forKey:@"AppleLanguages"];
[[NSUserDefaults standardUserDefaults] synchronize]; //to make the change immediate

Dies würde Deutsch zur bevorzugten Sprache für Ihre Bewerbung machen, mit Englisch und Französisch als Fallbacks. Sie sollten dies irgendwann früh beim Start Ihrer Anwendung aufrufen. Weitere Informationen zu Sprach- / Gebietsschemaeinstellungen finden Sie hier: Themen der Internationalisierungsprogrammierung: Abrufen der aktuellen Sprache und des Gebietsschemas

Ich hatte kürzlich das gleiche Problem und wollte nicht meinen gesamten NSLocalizedString starten und patchen noch die App zum Neustart zwingen, damit die neue Sprache funktioniert. Ich wollte, dass alles so funktioniert, wie es ist.

Meine Lösung bestand darin, die Klasse des Hauptpakets dynamisch zu ändern und das entsprechende Paket dort zu laden:

Header-Datei

@interface NSBundle (Language)
+(void)setLanguage:(NSString*)language;
@end

Implementierung

#import <objc/runtime.h>

static const char _bundle=0;

@interface BundleEx : NSBundle
@end

@implementation BundleEx
-(NSString*)localizedStringForKey:(NSString *)key value:(NSString *)value table:(NSString *)tableName
{
    NSBundle* bundle=objc_getAssociatedObject(self, &_bundle);
    return bundle ? [bundle localizedStringForKey:key value:value table:tableName] : [super localizedStringForKey:key value:value table:tableName];
}
@end

@implementation NSBundle (Language)
+(void)setLanguage:(NSString*)language
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^
    {
        object_setClass([NSBundle mainBundle],[BundleEx class]);
    });
    objc_setAssociatedObject([NSBundle mainBundle], &_bundle, language ? [NSBundle bundleWithPath:[[NSBundle mainBundle] pathForResource:language ofType:@"lproj"]] : nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
@end

Wenn Ihre App gestartet wird und bevor Sie Ihren ersten Controller laden, rufen Sie einfach an:

[NSBundle setLanguage:@"en"];

Wenn Ihr Benutzer seine bevorzugte Sprache in Ihrem Einstellungsbildschirm ändert, rufen Sie ihn einfach erneut auf:

[NSBundle setLanguage:@"fr"];

Um auf die Systemstandards zurückzusetzen, übergeben Sie einfach nil:

[NSBundle setLanguage:nil];

Genießen...

Für diejenigen, die eine Swift-Version benötigen:

var bundleKey: UInt8 = 0

class AnyLanguageBundle: Bundle {

    override func localizedString(forKey key: String,
                                  value: String?,
                                  table tableName: String?) -> String {

        guard let path = objc_getAssociatedObject(self, &bundleKey) as? String,
              let bundle = Bundle(path: path) else {

            return super.localizedString(forKey: key, value: value, table: tableName)
            }

        return bundle.localizedString(forKey: key, value: value, table: tableName)
    }
}

extension Bundle {

    class func setLanguage(_ language: String) {

        defer {

            object_setClass(Bundle.main, AnyLanguageBundle.self)
        }

        objc_setAssociatedObject(Bundle.main, &bundleKey,    Bundle.main.path(forResource: language, ofType: "lproj"), .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
    }
}

Normalerweise mache ich das so, aber Sie MÜSSEN alle Lokalisierungsdateien in Ihrem Projekt haben.

@implementation Language

static NSBundle *bundle = nil;

+(void)initialize 
{
    NSUserDefaults* defs = [NSUserDefaults standardUserDefaults];
    NSArray* languages = [defs objectForKey:@"AppleLanguages"];
    NSString *current = [[languages objectAtIndex:0] retain];
    [self setLanguage:current];
}

/*
  example calls:
    [Language setLanguage:@"it"];
    [Language setLanguage:@"de"];
*/
+(void)setLanguage:(NSString *)l
{
    NSLog(@"preferredLang: %@", l);
    NSString *path = [[ NSBundle mainBundle ] pathForResource:l ofType:@"lproj" ];
    bundle = [[NSBundle bundleWithPath:path] retain];
}

+(NSString *)get:(NSString *)key alter:(NSString *)alternate 
{
    return [bundle localizedStringForKey:key value:alternate table:nil];
}

@end

Nicht unter iOS 9 verwenden. Dies gibt null für alle durchlaufenden Zeichenfolgen zurück.

Ich habe eine andere Lösung gefunden, mit der Sie die Sprachzeichenfolgen aktualisieren können, ohne die App neu zu starten und mit Genzeichenfolgen kompatibel:

Fügen Sie dieses Makro in die Datei Prefix.pch ein:

#define currentLanguageBundle [NSBundle bundleWithPath:[[NSBundle mainBundle] pathForResource:[[NSLocale preferredLanguages] objectAtIndex:0] ofType:@"lproj"]]

und wo immer Sie eine lokalisierte Zeichenfolge benötigen:

NSLocalizedStringFromTableInBundle(@"GalleryTitleKey", nil, currentLanguageBundle, @"")

So stellen Sie die Sprache ein:

[[NSUserDefaults standardUserDefaults] setObject:[NSArray arrayWithObject:@"de"] forKey:@"AppleLanguages"];

Funktioniert auch mit aufeinanderfolgenden Sprachsprüngen wie:

NSLog(@"test %@", NSLocalizedStringFromTableInBundle(@"NewKey", nil, currentLanguageBundle, @""));
[[NSUserDefaults standardUserDefaults] setObject:[NSArray arrayWithObject:@"fr"] forKey:@"AppleLanguages"];
NSLog(@"test %@", NSLocalizedStringFromTableInBundle(@"NewKey", nil, currentLanguageBundle, @""));
[[NSUserDefaults standardUserDefaults] setObject:[NSArray arrayWithObject:@"it"] forKey:@"AppleLanguages"];
NSLog(@"test %@", NSLocalizedStringFromTableInBundle(@"NewKey", nil, currentLanguageBundle, @""));
[[NSUserDefaults standardUserDefaults] setObject:[NSArray arrayWithObject:@"de"] forKey:@"AppleLanguages"];
NSLog(@"test %@", NSLocalizedStringFromTableInBundle(@"NewKey", nil, currentLanguageBundle, @""));

Wie bereits erwähnt, machen Sie einfach:

[[NSUserDefaults standardUserDefaults] setObject: [NSArray arrayWithObjects:@"el", nil] forKey:@"AppleLanguages"];

Um jedoch zu vermeiden, dass die App neu gestartet werden muss, setzen Sie die Zeile main.mkurz vor UIApplicationMain(...) in die Hauptmethode von .

Der Trick, eine bestimmte Sprache zu verwenden, indem Sie sie aus der App auswählen, besteht darin, die NSLocalizedStringVerwendung eines bestimmten Bundles abhängig von der ausgewählten Sprache zu erzwingen.

Hier ist der Beitrag, den ich für diese Lernlokalisierung in iOS-Apps geschrieben habe

und hier ist der Code einer Beispiel-App- Vorlokalisierung in iOS-Apps

Was halten Sie von dieser Lösung für Swift 3?

extension String {

    func localized(forLanguage language: String = Locale.preferredLanguages.first!.components(separatedBy: "-").first!) -> String {

        guard let path = Bundle.main.path(forResource: language == "en" ? "Base" : language, ofType: "lproj") else {

            let basePath = Bundle.main.path(forResource: "Base", ofType: "lproj")!

            return Bundle(path: basePath)!.localizedString(forKey: self, value: "", table: nil)
        }

        return Bundle(path: path)!.localizedString(forKey: self, value: "", table: nil)
    }
}

Einfache Verwendung:

"report".localized(forLanguage: "pl") //forced language
"report".localized() //default language selected by user in settings, in case when your app doesnt support selected lanaguage, the default one is selected, here is an english.

Wie Brian Webster erwähnt, muss die Sprache "irgendwann zu Beginn des Starts Ihrer Anwendung" eingestellt werden. Ich dachte applicationDidFinishLaunching:an dieAppDelegate sollte ein geeigneter Ort dafür sein, da ich dort alle anderen Initialisierungen mache.

Aber wie William Denniss erwähnt, scheint dies erst nach dem Neustart der App Auswirkungen zu haben , was irgendwie nutzlos ist.

Es scheint gut zu funktionieren, wenn ich den Code in die Hauptfunktion setze:

int main(int argc, char *argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    // Force language to Swedish.
    [[NSUserDefaults standardUserDefaults]
     setObject:[NSArray arrayWithObject:@"sv"]
     forKey:@"AppleLanguages"];

    int retVal = UIApplicationMain(argc, argv, nil, nil);
    [pool release];
    return retVal;
}

Ich würde mich über Kommentare dazu freuen.

Mir gefällt die Methode von Mauro Delrio am besten. Ich habe auch Folgendes in meine Project_Prefix.pch eingefügt

#import "Language.h"    
#define MyLocalizedString(key, alt) [Language get:key alter:alt]

Wenn Sie also jemals die Standardmethode (die NSLocalizedString verwendet) verwenden möchten, können Sie in allen Dateien eine schnelle Syntaxersetzung vornehmen.

NSLocalizedString()liest den Wert für den Schlüssel AppleLanguagesaus den Standardbenutzerstandards ( [NSUserDefaults standardUserDefaults]). Mit diesem Wert wird zur Laufzeit eine geeignete Lokalisierung unter allen vorhandenen Lokalisierungen ausgewählt. Wenn Apple beim Start der App das Standardwörterbuch für Benutzer erstellt, sucht es in den Systemeinstellungen nach dem Schlüssel für die bevorzugte Sprache und kopiert den Wert von dort. Dies erklärt beispielsweise auch, warum das Ändern der Spracheinstellungen in OS X keine Auswirkungen auf die Ausführung von Apps hat, sondern nur auf Apps, die danach gestartet werden. Nach dem Kopieren wird der Wert nicht aktualisiert, nur weil sich die Einstellungen ändern. Aus diesem Grund startet iOS alle Apps neu, wenn Sie die Sprache ändern.

Allerdings werden alle Werte des Wörterbuchs Benutzereinstellungen können durch Befehlszeilenargumente werden überschrieben. Siehe NSUserDefaultsDokumentation zum NSArgumentDomain. Dies schließt sogar die Werte ein, die aus der App-Einstellungsdatei (.plist) geladen werden. Dies ist sehr gut zu wissen, wenn Sie einen Wert nur einmal zum Testen ändern möchten .

Wenn Sie also die Sprache nur zum Testen ändern möchten, möchten Sie Ihren Code wahrscheinlich nicht ändern (wenn Sie vergessen, diesen Code später zu entfernen ...), sondern Xcode anweisen, Ihre App mit Befehlszeilenparametern zu starten ( zB spanische Lokalisierung verwenden):

Sie müssen Ihren Code überhaupt nicht berühren. Erstellen Sie einfach verschiedene Schemata für verschiedene Sprachen und Sie können die App schnell einmal in einer Sprache und einmal in einer anderen Sprache starten, indem Sie einfach das Schema wechseln.

Ich habe eine Lösung gefunden, mit der Sie sie verwenden können NSLocalizedString. Ich erstelle eine NSBundleAnrufkategorie NSBundle+RunTimeLanguage. Die Schnittstelle ist so.

// NSBundle+RunTimeLanguage.h
#import <Foundation/Foundation.h>
@interface NSBundle (RunTimeLanguage)
#define NSLocalizedString(key, comment) [[NSBundle mainBundle] runTimeLocalizedStringForKey:(key) value:@"" table:nil]
- (NSString *)runTimeLocalizedStringForKey:(NSString *)key value:(NSString *)value table:(NSString *)tableName;
@end

Die Implementierung ist so.

// NSBundle+RunTimeLanguage.m
#import "NSBundle+RunTimeLanguage.h"
#import "AppDelegate.h"

@implementation NSBundle (RunTimeLanguage)

- (NSString *)runTimeLocalizedStringForKey:(NSString *)key value:(NSString *)value table:(NSString *)tableName
{
    AppDelegate *appDelegate = (AppDelegate *)[UIApplication sharedApplication].delegate;
    NSString *path= [[NSBundle mainBundle] pathForResource:[appDelegate languageCode] ofType:@"lproj"];
    NSBundle *languageBundle = [NSBundle bundleWithPath:path];
    NSString *localizedString=[languageBundle localizedStringForKey:key value:key table:nil];
    return localizedString;
}
@end

Fügen Sie dann einfach den Import NSBundle+RunTimeLanguage.hin die verwendeten Dateien hinzu NSLocalizedString.

Wie Sie sehen können, speichere ich meinen languageCode in einer Eigenschaft von AppDelegate. Dies kann überall gespeichert werden, wo Sie möchten.

Das einzige, was ich daran nicht mag, ist eine Warnung, die NSLocalizedStringMarco neu definiert hat. Vielleicht könnte mir jemand helfen, diesen Teil zu reparieren.

Schnelle Version:

NSUserDefaults.standardUserDefaults().setObject(["fr"], forKey: "AppleLanguages")
NSUserDefaults.standardUserDefaults().synchronize()

In einer Nussschale :

Lokalisieren Sie Ihre Anwendung

Als erstes müssen Sie Ihre App in mindestens zwei Sprachen lokalisieren (in diesem Beispiel Englisch und Französisch).

NSLocalizedString überschreiben

Verwenden Sie in Ihrem Code anstelle der NSLocalizedString(key, comment)Verwendung ein Makro, MYLocalizedString(key, comment)das wie folgt definiert ist: #define MYLocalizedString(key, comment) [[MYLocalizationSystem sharedInstance] localizedStringForKey:(key) value:(comment)];

Dieser MYLocalizationSystemSingleton wird:

• Stellen Sie die Sprache ein, indem Sie den richtigen lokalisierten NSBundle- Benutzer festlegen
• Gibt den lokalisierten NSString gemäß dieser zuvor festgelegten Sprache zurück

Benutzersprache einstellen

Wenn der Benutzer die Anwendungssprache auf Französisch geändert hat, rufen Sie an [[MYLocalizationSystem sharedInstance] setLanguage:@"fr"];

- (void)setLanguage:(NSString *)lang
{
    NSString *path = [[NSBundle mainBundle] pathForResource:lang ofType:@"lproj"];
    if (!path)
    {
        _bundle = [NSBundle mainBundle];
        NSLog(@"Warning: No lproj for %@, system default set instead !", lang);
        return;
    }

    _bundle = [NSBundle bundleWithPath:path];
}

In diesem Beispiel hat diese Methode das lokalisierte Bundle auf fr.lproj gesetzt

Lokalisierte Zeichenfolge zurückgeben

Sobald Sie das lokalisierte Bundle festgelegt haben, können Sie mit dieser Methode die richtige lokalisierte Zeichenfolge von ihm erhalten:

- (NSString *)localizedStringForKey:(NSString *)key value:(NSString *)value
{
    // bundle was initialized with [NSBundle mainBundle] as default and modified in setLanguage method
    return [self.bundle localizedStringForKey:key value:value table:nil];
}

Hoffe das wird dir helfen.

Weitere Details finden Sie in diesem Artikel von NSWinery.io

Swift 3-Erweiterungen:

extension Locale {
    static var preferredLanguage: String {
        get {
            return self.preferredLanguages.first ?? "en"
        }
        set {
            UserDefaults.standard.set([newValue], forKey: "AppleLanguages")
            UserDefaults.standard.synchronize()
        }
    }
}

extension String {
    var localized: String {

    var result: String

    let languageCode = Locale.preferredLanguage //en-US

    var path = Bundle.main.path(forResource: languageCode, ofType: "lproj")

    if path == nil, let hyphenRange = languageCode.range(of: "-") {
        let languageCodeShort = languageCode.substring(to: hyphenRange.lowerBound) // en
        path = Bundle.main.path(forResource: languageCodeShort, ofType: "lproj")
    }

    if let path = path, let locBundle = Bundle(path: path) {
        result = locBundle.localizedString(forKey: self, value: nil, table: nil)
    } else {
        result = NSLocalizedString(self, comment: "")
    }
        return result
    }
}

Verwendungszweck:

Locale.preferredLanguage = "uk"

label.text = "localizedKey".localized

In der zu definierenden Datei .pch :

#define currentLanguageBundle [NSBundle bundleWithPath:[[NSBundle mainBundle] pathForResource:[[NSLocale preferredLanguages] objectAtIndex:0] ofType:@"lproj"]]


#define NSLocalizedString(str,nil) NSLocalizedStringFromTableInBundle(str, nil, currentLanguageBundle, @"")

Vielleicht sollten Sie dies ergänzen (in der .pch-Datei nach #import):

extern NSBundle* bundle; // Declared on Language.m

#ifdef NSLocalizedString
    #undef NSLocalizedString
    // Delete this line to avoid warning
    #warning "Undefining NSLocalizedString"
#endif

#define NSLocalizedString(key, comment) \
    [bundle localizedStringForKey:(key) value:@"" table:nil]

Swift 3-Lösung:

let languages = ["bs", "zh-Hant", "en", "fi", "ko", "lv", "ms", "pl", "pt-BR", "ru", "sr-Latn", "sk", "es", "tr"]
UserDefaults.standard.set([languages[0]], forKey: "AppleLanguages")

Gab einige Beispiele für Sprachcodes, die verwendet werden können. Hoffe das hilft

Sie können ein Unterpaket mit den lokalisierten Zeichenfolgen erstellen, mit denen Sie dies tun möchten, und diese dann NSLocalizedStringFromTableInBundle()zum Laden verwenden. (Ich gehe davon aus, dass dies ein Inhalt ist, der von der normalen UI-Lokalisierung, die Sie möglicherweise in der App ausführen, getrennt ist.)

Für meinen Fall habe ich zwei lokalisierte Dateien, ja und en

und ich möchte es zu en zwingen, wenn die bevorzugte Sprache im System weder en noch ja ist

Ich werde die Datei main.m bearbeiten

Ich werde prüfen, ob die erste bevorzugte Sprache en oder ja ist. Wenn nicht, werde ich die zweite bevorzugte Sprache in en ändern.

int main(int argc, char *argv[])
{

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

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

    if (![lang isEqualToString:@"en"]  &&  ![lang isEqualToString:@"ja"]){

        NSMutableArray *array = [[NSMutableArray alloc] initWithArray:[NSLocale preferredLanguages]];
        [array replaceObjectAtIndex:1 withObject:@"en"];

        [[NSUserDefaults standardUserDefaults] setObject:array forKey:@"AppleLanguages"];
        [[NSUserDefaults standardUserDefaults] synchronize];


    }

    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));


    }


}

Sie können so etwas tun:

NSString *bundlePath = [[NSBundle mainBundle] pathForResource:@"Localizable" ofType:@"strings" inDirectory:nil forLocalization:@"es"];


NSBundle *spanishBundle = [[NSBundle alloc] initWithPath:[bundlePath stringByDeletingLastPathComponent]];

NSLocalizedStringFromTableInBundle(@"House", nil, spanishBundle, nil):

Basierend auf der Antwort von Tudorizer , die Sprache zu ändern, ohne die Anwendung zu verlassen oder neu zu starten .

Verwenden Sie anstelle eines Makros eine Klasse für den Zugriff auf die bevorzugte Sprache, um zu überprüfen, ob ein bestimmter Sprachcode vorhanden ist.

Im Folgenden finden Sie eine Klasse, mit der Sie das aktuelle Sprachpaket erhalten, das für iOS 9 funktioniert:

@implementation OSLocalization

+ (NSBundle *)currentLanguageBundle
{
    // Default language incase an unsupported language is found
    NSString *language = @"en";

    if ([NSLocale preferredLanguages].count) {
        // Check first object to be of type "en","es" etc
        // Codes seen by my eyes: "en-US","en","es-US","es" etc

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

        if ([letterCode rangeOfString:@"en"].location != NSNotFound) {
            // English
            language = @"en";
        } else if ([letterCode rangeOfString:@"es"].location != NSNotFound) {
            // Spanish
            language = @"es";
        } else if ([letterCode rangeOfString:@"fr"].location != NSNotFound) {
            // French
            language = @"fr";
        } // Add more if needed
    }

    return [NSBundle bundleWithPath:[[NSBundle mainBundle] pathForResource:language ofType:@"lproj"]];
}

/// Check if preferred language is English
+ (BOOL)isCurrentLanguageEnglish
{
    if (![NSLocale preferredLanguages].count) {
        // Just incase check for no items in array
        return YES;
    }

    if ([[[NSLocale preferredLanguages] objectAtIndex:0] rangeOfString:@"en"].location == NSNotFound) {
        // No letter code for english found
        return NO;
    } else {
        // Tis English
        return YES;
    }
}

/*  Swap language between English & Spanish
 *  Could send a string argument to directly pass the new language
 */
+ (void)changeCurrentLanguage
{
    if ([self isCurrentLanguageEnglish]) {
        [[NSUserDefaults standardUserDefaults] setObject:@[@"es"] forKey:@"AppleLanguages"];
    } else {
        [[NSUserDefaults standardUserDefaults] setObject:@[@"en"] forKey:@"AppleLanguages"];
    }
}
@end

Verwenden Sie die obige Klasse, um auf eine Zeichenfolgendatei / image / video / etc zu verweisen:

// Access a localized image
[[OSLocalization currentLanguageBundle] pathForResource:@"my_image_name.png" ofType:nil]
// Access  a localized string from Localizable.strings file
NSLocalizedStringFromTableInBundle(@"StringKey", nil, [OSLocalization currentLanguageBundle], @"comment")

Ändern Sie die Sprache inline wie unten oder aktualisieren Sie die Methode "changeCurrentLanguage" in der obigen Klasse, um einen Zeichenfolgenparameter zu verwenden, der auf die neue Sprache verweist.

[[NSUserDefaults standardUserDefaults] setObject:@[@"es"] forKey:@"AppleLanguages"];

In Swift 4 habe ich es gelöst, ohne neu starten oder Bibliotheken verwenden zu müssen.

Nachdem ich viele Optionen ausprobiert hatte, fand ich diese Funktion, bei der Sie die zu übersetzende Zeichenfolge stringToLocalize (von Localizable.String, die Zeichenfolgendatei) und die Sprache, in die Sie sie übersetzen möchten, sowie den zurückgegebenen Wert übergeben der String, den Sie in der Strings-Datei haben:

    func localizeString (stringToLocalize: String, language: String) -> String
    {
        let path = Bundle.main.path (forResource: language, ofType: "lproj")
        let languageBundle = Bundle (path: path!)
        return languageBundle! .localizedString (forKey: stringToLocalize, value: "", table: nil)
    }

Unter Berücksichtigung dieser Funktion habe ich diese Funktion in einer Swift-Datei erstellt:

struct CustomLanguage {

    func createBundlePath () -> Bundle {
        let selectedLanguage = //recover the language chosen by the user (in my case, from UserDefaults)
        let path = Bundle.main.path(forResource: selectedLanguage, ofType: "lproj")
        return Bundle(path: path!)!
    }
}

So greifen Sie von der gesamten App und in jeder Zeichenfolge der übrigen ViewController zu, anstatt Folgendes zu setzen:

NSLocalizedString ("StringToLocalize", comment: “")

Ich habe es durch ersetzt

let customLang = CustomLanguage() //declare at top
let bundleLanguage = customLang.createBundle()

NSLocalizedString("StringToLocalize", tableName: nil, bundle: bundleLanguage, value: "", comment: “”) //use in each String

Ich weiß nicht, ob es der beste Weg ist, aber ich fand es sehr einfach und es funktioniert für mich, ich hoffe es hilft dir!

Diese Funktion versucht, eine lokalisierte Zeichenfolge für die aktuelle Sprache abzurufen. Wenn sie nicht gefunden wird, wird sie in englischer Sprache abgerufen.

- (NSString*)L:(NSString*)key
{
    static NSString* valueNotFound = @"VALUE_NOT_FOUND";
    static NSBundle* enBundle = nil;

    NSString* pl = [NSLocale preferredLanguages][0];
    NSString* bp = [[NSBundle mainBundle] pathForResource:pl ofType:@"lproj"];
    NSBundle* b = [NSBundle bundleWithPath:bp];

    NSString* s = [b localizedStringForKey:key value:valueNotFound table:nil];
    if ( [s isEqualToString:valueNotFound] ) {
        if ( !enBundle ) {
            bp = [[NSBundle mainBundle] pathForResource:@"en" ofType:@"lproj"];
            enBundle = [NSBundle bundleWithPath:bp];
        }
        s = [enBundle localizedStringForKey:key value:key table:nil];
    }

    return s;
}

Ich wollte Unterstützung für eine Sprache hinzufügen, die von iOS nicht offiziell unterstützt wird (nicht im Abschnitt Sprache unter Systemeinstellungen aufgeführt). Indem ich dem Internationalization Tutorial von Apple und einigen Hinweisen von Brian Webster und geon gefolgt bin, habe ich mir diesen Code ausgedacht (in main.m):

int main(int argc, char * argv[]) {
    @autoreleasepool {
        // Grab regional settings locale, for Slovenian this is either sl_SI or en_SI
        NSLocale *locale = [NSLocale currentLocale];
        NSString *ll = [locale localeIdentifier]; // sl_SI

        // Grab the first part of language identifier
        NSArray *comp = [ll componentsSeparatedByString:@"_"];
        NSString *ll1 = @"en";
        if (comp.count > 0) {
            ll1 = comp[0]; // sl, en, ...
        }
        // Check if we already saved language (user can manually change it inside app for example)
        if (![[NSUserDefaults standardUserDefaults] objectForKey:@"SelectedLanguage"]) {
            //   Slovenian (Slovenia),            Slovenia
            if ([ll isEqualToString:@"sl_SI"] || [ll isEqualToString:@"en_SI"]) {
                ll1 = @"sl-SI"; // This is the part of localized path for Slovenian language that Xcode generates
            }
            // Add more unsupported languages here...

            [[NSUserDefaults standardUserDefaults] setObject:ll1 forKey:@"SelectedLanguage"]; // Save language
        }
        else {
            // Restore language as we have previously saved it
            ll1 = [[NSUserDefaults standardUserDefaults] objectForKey:@"SelectedLanguage"];
        }
        // Overwrite NSLocalizedString and StoryBoard language preference
        [[NSUserDefaults standardUserDefaults] setObject:[NSArray arrayWithObjects:ll1, @"en", @"fr", nil] forKey:@"AppleLanguages"];
        // Make sure settings are stored to disk
        [[NSUserDefaults standardUserDefaults] synchronize];

        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

Dies funktioniert sowohl für Storyboard- als auch für NSLocalizedString-Code. Der Code geht davon aus, dass der Benutzer die Möglichkeit hat, die Sprache in der App später manuell zu ändern.

Vergessen Sie natürlich nicht, die richtigen Storyboard-Übersetzungen und Localizable.strings-Übersetzungen hinzuzufügen (siehe dazu den Link zur Apple-Seite oben).

Hier ist eine anständige Lösung für dieses Problem, und es ist kein Neustart der Anwendung erforderlich.

https://github.com/cmaftuleac/BundleLocalization

Diese Implementierung funktioniert durch Optimieren in NSBundle. Die Idee ist, dass Sie die Methode localizedStringForKey für die Instanz des NSBundle-Objekts überschreiben und diese Methode dann für ein anderes Bundle mit einer anderen Sprache aufrufen. Einfach und elegant, voll kompatibel mit allen Arten von Ressourcen.

Was auch immer Sie alle tun, der beste Weg ist, den Kurznamen für die angegebene Sprache zu verwenden, dh: fr, en, nl, de, it usw., und diesen einem globalen Wert zuzuweisen.

Erstellen Sie eine Auswahlansicht, die wie ein Dropdown-Menü angezeigt wird (Kombination einer Schaltfläche, auf deren Klicken eine Auswahlansicht von unten mit einer Liste von Sprachen angezeigt wird), und wählen Sie die gewünschte Sprache aus. Lassen Sie den Kurznamen intern speichern. Erstellen Sie eine .h + .m-Datei mit dem Namen LocalisedString.

Stellen Sie den globalen Wert von short_name so ein, dass er dem erhaltenen Wert in LocalisedString.m entspricht. Wenn die gewünschte Sprache ausgewählt ist, weisen Sie NSBundlePath zu, um Projektunterverzeichnisse für die benötigte Sprache zu erstellen. für zB nl.proj, en.proj.

Wenn der jeweilige Projektordner ausgewählt ist, rufen Sie die lokalisierte Zeichenfolge für die jeweilige Sprache auf und ändern Sie die Sprache dynamisch.

Keine Regeln gebrochen.

Für Swift können Sie die main.swiftDatei überschreiben und dort die UserDefaults-Zeichenfolge festlegen, bevor die App ausgeführt wird. Auf diese Weise müssen Sie die App nicht neu starten, um den gewünschten Effekt zu erzielen.

import Foundation
import UIKit

// Your initialisation code here
let langCultureCode: String = "LANGUAGE_CODE"

UserDefaults.standard.set([langCultureCode], forKey: "AppleLanguages")
UserDefaults.standard.synchronize()

UIApplicationMain(CommandLine.argc, CommandLine.unsafeArgv, nil, NSStringFromClass(AppDelegate.self))

zusammen mit dem Entfernen von @UIApplicationMainin Ihrer AppDelegate.swiftDatei gepaart .