web-dev-qa-db-fra.com

Fichier de constantes globales dans Swift

Dans mes projets Objective-C, j'utilise souvent un fichier de constantes globales pour stocker des éléments tels que les noms de notification et les clés pour NSUserDefaults. Cela ressemble à quelque chose comme ça:

@interface GlobalConstants : NSObject

extern NSString *someNotification;

@end

@implementation GlobalConstants

NSString *someNotification = @"aaaaNotification";

@end

Comment faire exactement la même chose à Swift?

iosobjective-cswift
314
user1028028

IMO le meilleur moyen de gérer ce type de constantes est de créer une structure.

struct Constants {
    static let someNotification = "TEST"
}

Ensuite, par exemple, appelez-le comme ceci dans votre code:

print(Constants.someNotification)

Edit: Si vous voulez une meilleure organisation, je vous conseille d’utiliser des sous-structures segmentées.

struct K {
    struct NotificationKey {
        static let Welcome = "kWelcomeNotif"
    }

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

Ensuite, vous pouvez simplement utiliser par exemple K.Path.Tmp

726
Francescu

Je suis un peu en retard pour la fête.

Peu importe comment je gère le fichier de constantes de manière à ce qu'il ait plus de sens pour les développeurs lors de l'écriture de code dans Swift.

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

Pour CUSTOMFONTS: 

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

POUR TOUTES LES TOUCHES UTILISEES DANS APP 

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

POUR LES CONSTANTES DE COULEUR: 

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

Vous pouvez envelopper tous ces fichiers dans un groupe commun nommé , des constantes dans votre projet Xcode.

Et pour plus de regarder cette vidéo

95
LC 웃

Bien que je préfère la manière de @ Francescu (en utilisant une structure avec des propriétés statiques), vous pouvez également définir des constantes globales et des variables:

let someNotification = "TEST"

Notez toutefois que, contrairement aux variables/constantes locales et aux propriétés class/struct, les globales sont implicitement paresseuses, ce qui signifie qu'elles sont initialisées lors du premier accès.

Lecture suggérée: Variables globales et locales , et aussi Les variables globales dans Swift ne sont pas des variables

28
Antonio

Constant.Swift

import Foundation

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

ViewController.Swift

var manager = AFHTTPRequestOperationManager(baseURL: kBaseURL)
20
Kirit Vaghela

Considérer les énumérations. Ceux-ci peuvent être logiquement divisés pour des cas d'utilisation distincts.

enum UserDefaultsKeys: String {
    case SomeNotification = "aaaaNotification"
    case DeviceToken = "deviceToken"
}

enum PhotoMetaKeys: String {
    case Orientation = "orientation_hv"
    case Size = "size"
    case DateTaken = "date_taken"
}

Un avantage unique survient lorsque vous vous trouvez dans une situation d’options mutuellement exclusives, telles que:

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

Dans cet exemple, vous recevrez une erreur de compilation car vous n'avez pas traité le cas de PhotoMetaKeys.DateTaken.

19
William Entriken

Ou simplement dans GlobalConstants.Swift:

import Foundation

let someNotification = "aaaaNotification"
14
ChikabuZ

Comme d'autres ont mentionné tout ce qui est déclaré en dehors d'une classe est globale.

Vous pouvez également créer des singletons:

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

Chaque fois que vous souhaitez utiliser quelque chose de cette classe, par exemple écrire:

TestClass.sharedInstance.number = 1

Si vous écrivez maintenant println(TestClass.sharedInstance.number) de n'importe où dans votre projet, vous imprimerez 1 dans le journal. Cela fonctionne pour toutes sortes d'objets.

tl; dr: Chaque fois que vous souhaitez tout rendre dans une classe globale, ajoutez static let sharedInstance = YourClassName() à la classe et adressez toutes les valeurs de la classe avec le préfixe YourClassName.sharedInstance

7
Jacob R

Ce que j'ai fait dans mon projet Swift
1: Créer un nouveau fichier Swift
2: Créez une structure et une constante statique en elle.
3: Pour utiliser, utilisez simplement YourStructName.baseURL

Remarque: Après la création de l'initialisation prend peu de temps, il apparaîtra dans les autres contrôleurs de vue après 2 à 5 secondes.

import Foundation

    struct YourStructName {
    static let MerchantID = "XXX"
    static let MerchantUsername = "XXXXX"
    static let ImageBaseURL = "XXXXXXX"
    static let baseURL = "XXXXXXX"
    }
5
Vinay Krishna Gupta

Pour les notifications, vous pouvez utiliser l'extension, quelque chose comme ceci:

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

Et utilisez-le comme NotificationCenter.default.post(name: .testNotification, object: nil)

2
B. Shoe

Selon les Swift docs , les variables globales sont déclarées dans la portée du fichier.

Les variables globales sont des variables définies en dehors de tout contexte de fonction, de méthode, de fermeture ou de type.

Créez simplement un fichier Swift (E.g: Constnats.Swift) et déclarez vos constantes à cet emplacement:

// Constants.Swift

let SOME_NOTIF = "aaaaNotification"

et appelez-le de n'importe où dans votre projet sans avoir besoin de mentionner le nom de struct, enum ou class.

// MyViewController.Swift

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

Je pense que c'est beaucoup mieux pour la lisibilité du code.

1
Seif Meddeb

Pour avoir des constantes globales dans mes applications, voici ce que je fais dans un fichier Swift séparé:

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

Il est facile à utiliser et à appeler partout comme ceci:

print(Config.Notifications.awareUser)
1
Ale Mohamad

Couleurs

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

Polices

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

Pour les autres, tout est identique à la réponse acceptée.

1
Bohdan Savych

Version Swift 4

Si vous souhaitez créer un nom pour NotificationCenter:

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

S'abonner aux notifications:

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

Envoyer une notification:

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

Si vous voulez juste une classe avec des variables à utiliser:

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

Ou:

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