O que é NSLocalizedString equivalente no Swift?

Existe um equivalente Swift de NSLocalizedString(...)? Em Objective-C, geralmente usamos:

NSString *string = NSLocalizedString(@"key", @"comment");

Como posso conseguir o mesmo no Swift? Eu encontrei uma função:

func NSLocalizedString(
    key: String,
    tableName: String? = default,
    bundle: NSBundle = default,
    value: String = default,
    #comment: String) -> String

No entanto, é muito longo e nada conveniente.

Eu uso a próxima solução:

1) criar extensão:

extension String {
    var localized: String {
        return NSLocalizedString(self, tableName: nil, bundle: Bundle.main, value: "", comment: "")
    }
}

2) no arquivo Localizable.strings :

"Hi" = "Привет";

3) exemplo de uso:

myLabel.text = "Hi".localized

desfrutar! ;)

--upd: -

para o caso de comentários, você pode usar esta solução:

1) Extensão:

extension String {
    func localized(withComment:String) -> String {
        return NSLocalizedString(self, tableName: nil, bundle: Bundle.main, value: "", comment: withComment)
    }
}

2) no arquivo .strings:

/* with !!! */
"Hi" = "Привет!!!";

3) usando:

myLabel.text = "Hi".localized(withComment: "with !!!")

O NSLocalizedStringtambém existe no mundo do Swift.

func NSLocalizedString(
    key: String,
    tableName: String? = default,
    bundle: NSBundle = default,
    value: String = default,
    #comment: String) -> String

A tableName, bundlee valueos parâmetros são marcados com uma defaultpalavra-chave que significa que podemos omitir esses parâmetros ao chamar a função. Nesse caso, seus valores padrão serão usados.

Isso leva à conclusão de que a chamada do método pode ser simplificada para:

NSLocalizedString("key", comment: "comment")

Swift 5 - nenhuma mudança, ainda funciona assim.

Uma variação das respostas existentes:

Swift 5.1:

extension String {

    func localized(withComment comment: String? = nil) -> String {
        return NSLocalizedString(self, comment: comment ?? "")
    }

}

Você pode simplesmente usá-lo com ou sem comentário:

"Goodbye".localized()
"Hello".localized(withComment: "Simple greeting")

Observe que genstringsnão funcionará com esta solução.

Usando esta maneira, é possível criar uma implementação diferente para diferentes tipos (por exemplo, Int ou classes personalizadas como CurrencyUnit, ...). Também é possível procurar esse método usando o utilitário genstrings. Basta adicionar o sinalizador de rotina ao comando

genstrings MyCoolApp/Views/SomeView.swift -s localize -o .

extensão:

import UIKit

extension String {
    public static func localize(key: String, comment: String) -> String {
        return NSLocalizedString(key, comment: comment)
    }
}

uso:

String.localize("foo.bar", comment: "Foo Bar Comment :)")

Versão Swift 3:) ...

import Foundation

extension String {
    var localized: String {
        return NSLocalizedString(self, tableName: nil, bundle: Bundle.main, value: "", comment: "")
    }
}

Na verdade, você pode usar duas fases para traduzir seus textos em projetos Swift:

1) A primeira fase é usar a maneira antiga de criar todas as suas strings traduzíveis:

NSLocalisedString("Text to translate", comment: "Comment to comment")

1.1) Então você deve usar genstrings para gerar Localizable.strings:

$ genstrings *swift

2) Depois, você deve usar esta resposta .

2.1) Use a opção "Localizar e substituir" do XCode com base na expressão regular. Quanto ao exemplo dado (se você não tiver comentários), a expressão regular será:

NSLocalizedString\((.*)\, comment:\ \"\"\) 

e substitua-o por

$1.localized

ou (se você tiver comentários)

NSLocalizedString\((.*)\, comment:\ (.*)\)

e substitua-o por

$1.localizedWithComment(comment: $2)

Você é livre para jogar com regex e diferentes combinações de extensões, conforme desejar. A maneira geral é dividir todo o processo em duas fases. Espero que ajude.

Criou um pequeno método auxiliar para casos em que "comentário" é sempre ignorado. Menos código é mais fácil de ler:

public func NSLocalizedString(key: String) -> String {
    return NSLocalizedString(key, comment: "")
}

Coloque-o em qualquer lugar (fora de uma classe) e o Xcode encontrará esse método global.

Provavelmente, o melhor caminho é esse aqui .

fileprivate func NSLocalizedString(_ key: String) -> String {
    return NSLocalizedString(key, comment: "")
}

e

import Foundation
extension String {
    static let Hello = NSLocalizedString("Hello")
    static let ThisApplicationIsCreated = NSLocalizedString("This application is created by the swifting.io team")
    static let OpsNoFeature = NSLocalizedString("Ops! It looks like this feature haven't been implemented yet :(!")
}

então você pode usá-lo assim

let message: String = .ThisApplicationIsCreated
print(message)

para mim este é o melhor porque

• As strings codificadas estão em um arquivo específico; portanto, no dia em que você deseja alterá-las, é muito fácil
• Mais fácil de usar do que digitar manualmente as strings no seu arquivo sempre
• Genstrings ainda funcionará
• você pode adicionar mais extensões, como uma por controlador de exibição para manter as coisas organizadas

Quando você está desenvolvendo um SDK. Você precisa de alguma operação extra.

1) crie Localizable.strings como de costume no YourLocalizeDemoSDK.

2) crie as mesmas Localizable.strings em YourLocalizeDemo.

3) encontre o caminho do pacote do YourLocalizeDemoSDK.

Swift4 :

// if you use NSLocalizeString in NSObject, you can use it like this
let value = NSLocalizedString("key", tableName: nil, bundle: Bundle(for: type(of: self)), value: "", comment: "")

Bundle(for: type(of: self))ajuda a encontrar o pacote configurável no YourLocalizeDemoSDK. Se você usar Bundle.main, em vez disso, obterá um valor errado (na verdade, será a mesma string que a chave).

Mas se você quiser usar a extensão String mencionada pelo dr OX . Você precisa fazer um pouco mais. A extensão de origem se parece com isso.

extension String {
    var localized: String {
        return NSLocalizedString(self, tableName: nil, bundle: Bundle.main, value: "", comment: "")
    }
}

Como sabemos, estamos desenvolvendo um SDK, Bundle.mainque receberá o pacote do pacote YourLocalizeDemo. Não é isso que queremos. Precisamos do pacote em YourLocalizeDemoSDK. Este é um truque para encontrá-lo rapidamente.

Execute o código abaixo em uma instância NSObject em YourLocalizeDemoSDK. E você receberá o URL do YourLocalizeDemoSDK.

let bundleURLOfSDK = Bundle(for: type(of: self)).bundleURL
let mainBundleURL = Bundle.main.bundleURL

Imprima os dois URLs, você descobrirá que podemos criar a base bundleURLofSDK em mainBundleURL. Nesse caso, será:

let bundle = Bundle(url: Bundle.main.bundleURL.appendingPathComponent("Frameworks").appendingPathComponent("YourLocalizeDemoSDK.framework")) ?? Bundle.main

E a extensão String será:

extension String {
    var localized: String {
        let bundle = Bundle(url: Bundle.main.bundleURL.appendingPathComponent("Frameworks").appendingPathComponent("YourLocalizeDemoSDK.framework")) ?? Bundle.main
        return NSLocalizedString(self, tableName: nil, bundle: bundle, value: "", comment: "")
    }
}

Espero que ajude.

Eu criei meu próprio tipo de ferramenta para gerar extrações de strings usando uma função de tradução personalizada

extension String {

    func localizedWith(comment:String) -> String {
        return NSLocalizedString(self, tableName: nil, bundle: Bundle.main, value: "", comment: comment)
    }

}

https://gist.github.com/Maxdw/e9e89af731ae6c6b8d85f5fa60ba848c

Ele analisará todos os seus arquivos rápidos e exportará as seqüências de caracteres e os comentários no seu código para um arquivo .strings.

Provavelmente não é a maneira mais fácil de fazer isso, mas é possível.

Embora isso não responda ao problema de encurtamento, mas me ajudou a organizar as mensagens, criei uma estrutura para mensagens de erro como abaixo

struct Constants {
    // Error Messages
    struct ErrorMessages {
        static let unKnownError = NSLocalizedString("Unknown Error", comment: "Unknown Error Occured")
        static let downloadError = NSLocalizedString("Error in Download", comment: "Error in Download")
    }
}

let error = Constants.ErrorMessages.unKnownError

Dessa forma, você pode organizar as mensagens e fazer com que as gerações funcionem.

E este é o comando genstrings usado

find ./ -name \*.swift -print0 | xargs -0 genstrings -o .en.lproj

Útil para uso em testes de unidade:

Esta é uma versão simples que pode ser estendida a diferentes casos de uso (por exemplo, com o uso de tableNames).

public func NSLocalizedString(key: String, referenceClass: AnyClass, comment: String = "") -> String 
{
    let bundle = NSBundle(forClass: referenceClass)
    return NSLocalizedString(key, tableName:nil, bundle: bundle, comment: comment)
}

Use-o assim:

NSLocalizedString("YOUR-KEY", referenceClass: self)

Ou assim com um comentário:

NSLocalizedString("YOUR-KEY", referenceClass: self, comment: "usage description")

Esta é uma melhoria na abordagem ".localized". Comece adicionando a extensão de classe, pois isso ajudará em todas as strings que você estava configurando programaticamente:

extension String {
    func localized (bundle: Bundle = .main, tableName: String = "Localizable") -> String {
        return NSLocalizedString(self, tableName: tableName, value: "\(self)", comment: "")
    }
}

Exemplo de uso para seqüências de caracteres definidas programaticamente:

  override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)

Agora, os arquivos de tradução de storyboard do Xcode tornam o gerenciador de arquivos confuso e também não lidam bem com atualizações no storyboard. Uma abordagem melhor é criar uma nova classe básica de etiquetas e atribuí-la a todos os seus rótulos de storyboard:

class BasicLabel: UILabel {
    //initWithFrame to init view from code
    override init(frame: CGRect) {
      super.init(frame: frame)
      setupView()
    }

    //initWithCode to init view from xib or storyboard
    required init?(coder aDecoder: NSCoder) {
      super.init(coder: aDecoder)
      setupView()
    }

    //common func to init our view
    private func setupView() {
        let storyboardText = self.text
        text = storyboardText?.localized()
    }
}

Agora, todos os marcadores que você adicionar e fornecer o padrão padrão no storyboard serão traduzidos automaticamente, desde que você tenha fornecido uma tradução para ele.

Você pode fazer o mesmo com o UIButton:

class BasicBtn: UIButton {
    //initWithFrame to init view from code
    override init(frame: CGRect) {
      super.init(frame: frame)
      setupView()
    }

    //initWithCode to init view from xib or storyboard
    required init?(coder aDecoder: NSCoder) {
      super.init(coder: aDecoder)
      setupView()
    }

    //common func to init our view
    private func setupView() {
        let storyboardText = self.titleLabel?.text
        let lclTxt = storyboardText?.localized()
        setTitle(lclTxt, for: .normal)
    }
}

Quando você traduz, digamos, do inglês, onde uma frase é a mesma, para outro idioma em que é diferente (por causa do sexo, conjugações verbais ou declinação), a forma mais simples do NSString no Swift que funciona em todos os casos é os três argumentos. . Por exemplo, a frase em inglês "previous was" é traduzida de forma diferente para o russo no caso de "weight" ("предыдущ ий был") e para "cintura" ("предыдущ ая был а ").

Nesse caso, você precisa de duas traduções diferentes para uma fonte (em termos da ferramenta XLIFF recomendada na WWDC 2018). Você não pode consegui-lo com dois argumentos NSLocalizedString, onde "anterior era" será o mesmo para a "chave" e a tradução em inglês (ou seja, para o valor). A única maneira é usar a forma de três argumentos

NSLocalizedString("previousWasFeminine", value: "previous was", comment: "previousWasFeminine")

NSLocalizedString("previousWasMasculine", value: "previous was", comment: "previousWasMasculine")

onde chaves ("previousWasFeminine" e "previousWasMasculine") são diferentes.

Eu sei que o conselho geral é traduzir a frase como um todo, no entanto, às vezes é muito demorado e inconveniente.

Localização com idioma padrão:

extension String {
func localized() -> String {
       let defaultLanguage = "en"
       let path = Bundle.main.path(forResource: defaultLanguage, ofType: "lproj")
       let bundle = Bundle(path: path!)

       return NSLocalizedString(self, tableName: nil, bundle: bundle!, value: "", comment: "")
    }
}