¿Qué es NSLocalizedString equivalente en Swift?

¿Hay un equivalente rápido de NSLocalizedString(...)? En Objective-C, usualmente usamos:

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

¿Cómo puedo lograr lo mismo en Swift? Encontré una función:

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

Sin embargo, es muy largo y no es conveniente en absoluto.

Yo uso la siguiente solución:

1) crear extensión:

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

2) en el archivo Localizable.strings :

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

3) ejemplo de uso:

myLabel.text = "Hi".localized

¡disfrutar! ;)

--upd: -

para el caso con comentarios puede usar esta solución:

1) Extensión:

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

2) en el archivo .strings:

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

3) usando:

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

El NSLocalizedStringexiste también en el mundo de Swift.

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

El tableName, bundley valuelos parámetros están marcados con una defaultpalabra clave que significa que podemos omitir estos parámetros al llamar a la función. En este caso, se utilizarán sus valores predeterminados.

Esto lleva a la conclusión de que la llamada al método se puede simplificar para:

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

Swift 5 : sin cambios, todavía funciona así.

Una variación de las respuestas existentes:

Swift 5.1:

extension String {

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

}

Luego puede usarlo simplemente con o sin comentarios:

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

Tenga en cuenta que genstringsno funcionará con esta solución.

Al usar de esta manera, es posible crear una implementación diferente para diferentes tipos (es decir, clases Int o personalizadas como CurrencyUnit, ...). También es posible escanear para invocar este método utilizando la utilidad genstrings. Simplemente agregue la bandera de rutina al comando

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

extensión:

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 :)")

Versión Swift 3:) ...

import Foundation

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

En realidad, puede usar dos fases para traducir sus textos en proyectos Swift:

1) La primera fase es usar la antigua forma de crear todas sus cadenas traducibles:

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

1.1) Entonces deberías usar genstrings para generar Localizable.strings:

$ genstrings *swift

2) Después, debes usar esta respuesta .

2.1) Use su opción XCode "Buscar y reemplazar" basada en la expresión regular. En cuanto al ejemplo dado (si no tiene comentarios) la expresión regular será:

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

y reemplazarlo con

$1.localized

o (si tienes comentarios)

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

y reemplazarlo con

$1.localizedWithComment(comment: $2)

Puedes jugar con expresiones regulares y diferentes combinaciones de extensiones como desees. La forma general es dividir todo el proceso en dos fases. Espero que ayude.

Creó un pequeño método auxiliar para casos, donde el "comentario" siempre se ignora. Menos código es más fácil de leer:

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

Simplemente colóquelo en cualquier lugar (fuera de una clase) y Xcode encontrará este método global.

Probablemente la mejor manera es esta aquí .

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

y

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 :(!")
}

entonces puedes usarlo así

let message: String = .ThisApplicationIsCreated
print(message)

para mí esto es lo mejor porque

• Las cadenas codificadas están en un archivo específico, por lo que el día que desea cambiarlo es realmente fácil
• Más fácil de usar que escribir manualmente las cadenas en su archivo cada vez
• las cadenas gens seguirán funcionando
• puede agregar más extensiones, como una por controlador de vista para mantener las cosas ordenadas

Cuando estás desarrollando un SDK. Necesitas una operación extra.

1) cree Localizable.strings como de costumbre en YourLocalizeDemoSDK.

2) cree las mismas cadenas Localizable.string en YourLocalizeDemo.

3) encuentre su ruta de paquete de 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))le ayuda a encontrar el paquete en YourLocalizeDemoSDK. Si usa Bundle.mainen su lugar, obtendrá un valor incorrecto (de hecho, será la misma cadena con la clave).

Pero si desea utilizar la extensión de cadena mencionada por el Dr. OX . Necesitas hacer un poco más. La extensión de origen se ve así.

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

Como sabemos, estamos desarrollando un SDK, Bundle.mainobtendremos el paquete del paquete de YourLocalizeDemo. Eso no es lo que queremos. Necesitamos el paquete en YourLocalizeDemoSDK. Este es un truco para encontrarlo rápidamente.

Ejecute el código a continuación en una instancia de NSObject en YourLocalizeDemoSDK. Y obtendrá la URL de YourLocalizeDemoSDK.

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

Imprima las dos URL, verá que podemos construir la base bundleURLofSDK en mainBundleURL. En este caso, será:

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

Y la extensión de la cadena 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 eso ayude.

He creado mi propia herramienta Genstrings para extraer cadenas usando una función de traducción 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

Analizará todos sus archivos rápidos y exportará las cadenas y comentarios en su código a un archivo .strings.

Probablemente no sea la forma más fácil de hacerlo, pero es posible.

Aunque esto no responde al problema del acortamiento, pero me ayudó a organizar los mensajes, creé una estructura para los mensajes de error como a continuación

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

De esta manera, puede organizar los mensajes y hacer que funcionen las cadenas gens.

Y este es el comando genstrings utilizado

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

Útil para el uso en pruebas unitarias:

Esta es una versión simple que se puede extender a diferentes casos de uso (por ejemplo, con el 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)
}

Úselo así:

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

O como este con un comentario:

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

Esta es una mejora en el enfoque ".localized". Comience agregando la extensión de clase, ya que esto ayudará con las cadenas que estaba configurando programáticamente:

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

Ejemplo de uso para cadenas que establezca mediante programación:

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

Ahora los archivos de traducción del guión gráfico de Xcode hacen que el administrador de archivos sea desordenado y tampoco manejan bien las actualizaciones del guión gráfico. Un mejor enfoque es crear una nueva clase de etiqueta básica y asignarla a todas las etiquetas de su guión gráfico:

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

Ahora, cada etiqueta que agregue y proporcione el valor predeterminado predeterminado en el guión gráfico se traducirá automáticamente, suponiendo que haya proporcionado una traducción.

Podrías hacer lo mismo para 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)
    }
}

Cuando traduzca, diga del inglés, donde una frase es la misma, a otro idioma donde sea diferente (debido al género, las conjugaciones verbales o la declinación), la forma más simple de NSString en Swift que funciona en todos los casos son los tres argumentos. . Por ejemplo, la frase en inglés "anterior era", se traduce de manera diferente al ruso para el caso de "peso" ("предыдущ ий был") y para "cintura" ("предыдущ ая был а ").

En este caso, necesita dos traducciones diferentes para una Fuente (en términos de la herramienta XLIFF recomendada en WWDC 2018). No puede lograrlo con dos argumentos NSLocalizedString, donde "anterior era" será el mismo tanto para la "clave" como para la traducción al inglés (es decir, para el valor). La única forma es usar la forma de tres argumentos

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

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

donde las claves ("previousWasFeminine" y "previousWasMasculine") son diferentes.

Sé que el consejo general es traducir la frase como un todo, sin embargo, a veces es demasiado lento e inconveniente.

Localización con idioma predeterminado:

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