programar programación programacion online objective lenguaje entre diferencias ios objective-c swift

ios - programación - Archivo de constantes globales en Swift



swift to objective c online (13)

Estructuras como espacio de nombres

En mi opinión, la mejor manera de lidiar con ese tipo de constantes es crear un Struct.

struct Constants { static let someNotification = "TEST" }

Luego, por ejemplo, llámalo así en tu código:

print(Constants.someNotification)

Anidamiento

Si desea una mejor organización, le aconsejo que use subestructuras segmentadas.

struct K { struct NotificationKey { static let Welcome = "kWelcomeNotif" } struct Path { static let Documents = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as String static let Tmp = NSTemporaryDirectory() } }

Entonces puede usar, por ejemplo, K.Path.Tmp

Ejemplo del mundo real

Esta es solo una solución técnica, la implementación real en mi código se parece más a:

struct GraphicColors { static let grayDark = UIColor(0.2) static let grayUltraDark = UIColor(0.1) static let brown = UIColor(rgb: 126, 99, 89) // etc. }

y

enum Env: String { case debug case testFlight case appStore } struct App { struct Folders { static let documents: NSString = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0] as NSString static let temporary: NSString = NSTemporaryDirectory() as NSString } static let version: String = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as! String static let build: String = Bundle.main.object(forInfoDictionaryKey: "CFBundleVersion") as! String // This is private because the use of ''appConfiguration'' is preferred. private static let isTestFlight = Bundle.main.appStoreReceiptURL?.lastPathComponent == "sandboxReceipt" // This can be used to add debug statements. static var isDebug: Bool { #if DEBUG return true #else return false #endif } static var env: Env { if isDebug { return .debug } else if isTestFlight { return .testFlight } else { return .appStore } } }

En mis proyectos de Objective-C, a menudo uso un archivo de constantes globales para almacenar cosas como nombres de notificación y claves para NSUserDefaults . Se ve algo como esto:

@interface GlobalConstants : NSObject extern NSString *someNotification; @end @implementation GlobalConstants NSString *someNotification = @"aaaaNotification"; @end

¿Cómo hago exactamente lo mismo en Swift?


Aunque prefiero la forma de @ Francescu (usando una estructura con propiedades estáticas), también puede definir constantes y variables globales:

let someNotification = "TEST"

Sin embargo, tenga en cuenta que, a diferencia de las variables / constantes locales y las propiedades de clase / estructura, los globales son implícitamente vagos, lo que significa que se inicializan cuando se accede por primera vez.

Lectura sugerida: las variables globales y locales , y también las variables globales en Swift no son variables


Como otros han mencionado, cualquier cosa declarada fuera de una clase es global.

También puedes crear singletons:

class TestClass { static let sharedInstance = TestClass() // Anything else goes here var number = 0 }

Cada vez que quiera usar algo de esta clase, por ejemplo, escriba:

TestClass.sharedInstance.number = 1

Si ahora escribe println(TestClass.sharedInstance.number) desde cualquier parte de su proyecto, imprimirá 1 en el registro. Esto funciona para todo tipo de objetos.

tl; dr: cada vez que desee hacer que todo en una clase sea global, agregue static let sharedInstance = YourClassName() a la clase y aborde todos los valores de la clase con el prefijo YourClassName.sharedInstance


Considere enumeraciones. Estos se pueden dividir lógicamente para casos de uso separados.

enum UserDefaultsKeys: String { case SomeNotification = "aaaaNotification" case DeviceToken = "deviceToken" } enum PhotoMetaKeys: String { case Orientation = "orientation_hv" case Size = "size" case DateTaken = "date_taken" }

Un beneficio único ocurre cuando tiene una situación de opciones mutuamente excluyentes, como:

for (key, value) in photoConfigurationFile { guard let key = PhotoMetaKeys(rawvalue: key) else { continue // invalid key, ignore it } switch (key) { case.Orientation: { photo.orientation = value } case.Size: { photo.size = value } } }

En este ejemplo, recibirá un error de compilación porque no ha manejado el caso de PhotoMetaKeys.DateTaken .


Constant.swift

import Foundation let kBaseURL = NSURL(string: "http://www.example.com/")

ViewController.swift

var manager = AFHTTPRequestOperationManager(baseURL: kBaseURL)


De acuerdo con los documentos rápidos, las variables globales se declaran en el alcance del archivo.

Las variables globales son variables que se definen fuera de cualquier función, método, cierre o contexto de tipo.

Simplemente cree un archivo rápido (por ejemplo: Constnats.swift) y declare sus constantes allí:

// Constants.swift let SOME_NOTIF = "aaaaNotification"

y llámalo desde cualquier parte de tu proyecto sin la necesidad de mencionar struct, enum o nombre de clase.

// MyViewController.swift NotificationCenter.default.post(name: SOME_NOTIF, object: nil)

Creo que esto es mucho mejor para la legibilidad del código.


Lo que hice en mi proyecto Swift
1: Crear nuevo archivo Swift
2: Crear una estructura y una constante estática en ella.
3: Para usar solo use YourStructName.baseURL

Nota: Después de crear la inicialización toma poco tiempo, por lo que se mostrará en otros controles de vista después de 2-5 segundos.

import Foundation struct YourStructName { static let MerchantID = "XXX" static let MerchantUsername = "XXXXX" static let ImageBaseURL = "XXXXXXX" static let baseURL = "XXXXXXX" }


O simplemente en GlobalConstants.swift:

import Foundation let someNotification = "aaaaNotification"


Para las notificaciones, puede usar la extensión, algo como esto:

extension Notification.Name { static let testNotification = "kTestNotification" }

Y NotificationCenter.default.post(name: .testNotification, object: nil) como NotificationCenter.default.post(name: .testNotification, object: nil)


Para tener constantes globales en mis aplicaciones, esto es lo que hago en un archivo Swift separado:

import Foundation struct Config { static let baseURL = "https://api.com" static APIKeys { static let token = "token" static let user = "user" } struct Notifications { static let awareUser = "aware_user" } }

Es fácil de usar y llamar a todas partes de esta manera:

print(Config.Notifications.awareUser)


Colores

extension UIColor { static var greenLaPalma: UIColor { return UIColor(red:0.28, green:0.56, blue:0.22, alpha:1.00) } }

Fuentes

enum CustomFontType: String { case avenirNextRegular = "AvenirNext-Regular", avenirDemiBold = "AvenirNext-DemiBold" } extension UIFont { static func getFont(with type: CustomFontType, size: CGFloat) -> UIFont { let font = UIFont(name: type.rawValue, size: size)! return font } }

Para otro, todo igual que en la respuesta aceptada.


Llego un poco tarde a la fiesta.

No importa cómo administro el archivo de constantes para que tenga más sentido para los desarrolladores mientras escribo código rápidamente.

PARA URL:

//URLConstants.swift struct APPURL { private struct Domains { static let Dev = "http://test-dev.cloudapp.net" static let UAT = "http://test-UAT.com" static let Local = "192.145.1.1" static let QA = "testAddress.qa.com" } private struct Routes { static let Api = "/api/mobile" } private static let Domain = Domains.Dev private static let Route = Routes.Api private static let BaseURL = Domain + Route static var FacebookLogin: String { return BaseURL + "/auth/facebook" } }

Para clientes:

//FontsConstants.swift struct FontNames { static let LatoName = "Lato" struct Lato { static let LatoBold = "Lato-Bold" static let LatoMedium = "Lato-Medium" static let LatoRegular = "Lato-Regular" static let LatoExtraBold = "Lato-ExtraBold" } }

PARA TODAS LAS CLAVES UTILIZADAS EN LA APLICACIÓN

//KeyConstants.swift struct Key { static let DeviceType = "iOS" struct Beacon{ static let ONEXUUID = "xxxx-xxxx-xxxx-xxxx" } struct UserDefaults { static let k_App_Running_FirstTime = "userRunningAppFirstTime" } struct Headers { static let Authorization = "Authorization" static let ContentType = "Content-Type" } struct Google{ static let placesKey = "some key here"//for photos static let serverKey = "some key here" } struct ErrorMessage{ static let listNotFound = "ERROR_LIST_NOT_FOUND" static let validationError = "ERROR_VALIDATION" } }

PARA CONSTANTES DE COLOR:

//ColorConstants.swift struct AppColor { private struct Alphas { static let Opaque = CGFloat(1) static let SemiOpaque = CGFloat(0.8) static let SemiTransparent = CGFloat(0.5) static let Transparent = CGFloat(0.3) } static let appPrimaryColor = UIColor.white.withAlphaComponent(Alphas.SemiOpaque) static let appSecondaryColor = UIColor.blue.withAlphaComponent(Alphas.Opaque) struct TextColors { static let Error = AppColor.appSecondaryColor static let Success = UIColor(red: 0.1303, green: 0.9915, blue: 0.0233, alpha: Alphas.Opaque) } struct TabBarColors{ static let Selected = UIColor.white static let NotSelected = UIColor.black } struct OverlayColor { static let SemiTransparentBlack = UIColor.black.withAlphaComponent(Alphas.Transparent) static let SemiOpaque = UIColor.black.withAlphaComponent(Alphas.SemiOpaque) static let demoOverlay = UIColor.black.withAlphaComponent(0.6) } }

Puede envolver todos estos archivos en un grupo común llamado Constantes en su Proyecto Xcode.

Y para más mira este video


Versión Swift 4

Si desea crear un nombre para NotificationCenter:

extension Notification.Name { static let updateDataList1 = Notification.Name("updateDataList1") }

Suscríbase a las notificaciones:

NotificationCenter.default.addObserver(self, selector: #selector(youFunction), name: .updateDataList1, object: nil)

Enviar notificación:

NotificationCenter.default.post(name: .updateDataList1, object: nil)

Si solo quieres usar una clase con variables:

class Keys { static let key1 = "YOU_KEY" static let key2 = "YOU_KEY" }

O:

struct Keys { static let key1 = "YOU_KEY" static let key2 = "YOU_KEY" }