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