In meinen Objective-C-Projekten verwende ich häufig eine globale Konstantendatei, um Dinge wie Benachrichtigungsnamen und Schlüssel für zu speichern NSUserDefaults. Es sieht ungefähr so ​​aus:

@interface GlobalConstants : NSObject

extern NSString *someNotification;

@end

@implementation GlobalConstants

NSString *someNotification = @"aaaaNotification";

@end

Wie mache ich genau das gleiche in Swift?

Strukturen als Namespace

IMO Der beste Weg, um mit dieser Art von Konstanten umzugehen, besteht darin, eine Struktur zu erstellen.

struct Constants {
    static let someNotification = "TEST"
}

Nennen Sie es dann zum Beispiel in Ihrem Code so:

print(Constants.someNotification)

Nisten

Wenn Sie eine bessere Organisation wünschen, empfehle ich Ihnen, segmentierte Unterstrukturen zu verwenden

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

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

Dann können Sie zum Beispiel einfach verwenden K.Path.Tmp

Beispiel aus der realen Welt

Dies ist nur eine technische Lösung. Die eigentliche Implementierung in meinem Code sieht eher so aus:

struct GraphicColors {

    static let grayDark = UIColor(0.2)
    static let grayUltraDark = UIColor(0.1)

    static let brown  = UIColor(rgb: 126, 99, 89)
    // etc.
}

und

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

Ich bin etwas spät zur Party.

Egal, wie ich die Konstantendatei so verwalte, dass es für Entwickler sinnvoller ist, Code schnell zu schreiben.

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

Für BENUTZERDEFINIERTE:

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

FÜR ALLE IN APP VERWENDETEN SCHLÜSSEL

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

FÜR FARBKONSTANTEN:

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

Sie können diese alle Dateien in eine gemeinsame Gruppe mit dem Namen einschließen Konstanten in Ihrem Xcode-Projekt einschließen.

Und für mehr sehen Sie dieses Video

Obwohl ich @ Francescus Weg bevorzuge (unter Verwendung einer Struktur mit statischen Eigenschaften), können Sie auch globale Konstanten und Variablen definieren:

let someNotification = "TEST"

Beachten Sie jedoch, dass Globals anders als lokale Variablen / Konstanten und Klassen- / Struktureigenschaften implizit faul sind, was bedeutet, dass sie beim ersten Zugriff initialisiert werden.

Empfohlene Lektüre: Globale und lokale Variablen sowie globale Variablen in Swift sind keine Variablen

Constant.swift

import Foundation

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

ViewController.swift

var manager = AFHTTPRequestOperationManager(baseURL: kBaseURL)

Betrachten Sie Aufzählungen. Diese können für separate Anwendungsfälle logisch aufgeteilt werden.

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

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

Ein einzigartiger Vorteil ergibt sich, wenn Sie sich gegenseitig ausschließende Optionen haben, wie z.

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

In diesem Beispiel wird ein Kompilierungsfehler angezeigt, da Sie den Fall von nicht behandelt haben PhotoMetaKeys.DateTaken.

Oder einfach in GlobalConstants.swift:

import Foundation

let someNotification = "aaaaNotification"

Wie andere bereits erwähnt haben, ist alles, was außerhalb einer Klasse deklariert wird, global.

Sie können auch Singletons erstellen:

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

Wann immer Sie etwas aus dieser Klasse verwenden möchten, schreiben Sie zB:

TestClass.sharedInstance.number = 1

Wenn Sie jetzt println(TestClass.sharedInstance.number)von einer beliebigen Stelle in Ihrem Projekt aus schreiben, werden Sie drucken1 in das Protokoll . Dies funktioniert für alle Arten von Objekten.

tl; dr: Wenn Sie alles in einer Klasse global machen möchten, fügen Sie static let sharedInstance = YourClassName()es der Klasse hinzu und adressieren Sie alle Werte der Klasse mit dem PräfixYourClassName.sharedInstance

Was ich in meinem Swift-Projekt
1 getan habe : Neue Swift-Datei
erstellen 2: Erstellen Sie eine Struktur und eine statische Konstante darin.
3: Verwenden Sie zur Verwendung einfach YourStructName.baseURL

Hinweis: Nach dem Erstellen dauert die Initialisierung nur wenig, sodass sie nach 2-5 Sekunden in anderen Ansichtssteuerungen angezeigt wird.

import Foundation

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

Für Benachrichtigungen können Sie eine Erweiterung wie die folgende verwenden:

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

Und benutze es gerne NotificationCenter.default.post(name: .testNotification, object: nil)

Um globale Konstanten in meinen Apps zu haben, gehe ich wie folgt in einer separaten Swift- Datei vor:

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 ist einfach zu bedienen und überall so anzurufen:

print(Config.Notifications.awareUser)

Farben

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

Schriftarten

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

Für andere - alles das gleiche wie in der akzeptierten Antwort.

Gemäß den schnellen Dokumenten werden globale Variablen im Dateibereich deklariert.

Globale Variablen sind Variablen, die außerhalb von Funktionen, Methoden, Abschlüssen oder Typkontexten definiert werden

Erstellen Sie einfach eine schnelle Datei (zB: Constnats.swift) und deklarieren Sie dort Ihre Konstanten:

// Constants.swift

let SOME_NOTIF = "aaaaNotification"

und rufen Sie es von überall in Ihrem Projekt auf, ohne Struktur, Enumeration oder Klassennamen angeben zu müssen.

// MyViewController.swift

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

Ich denke, dies ist viel besser für die Lesbarkeit des Codes.

Swift 4 Version

Wenn Sie einen Namen für NotificationCenter erstellen möchten:

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

Benachrichtigungen abonnieren:

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

Benachrichtigung senden:

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

Wenn Sie nur eine Klasse mit Variablen verwenden möchten:

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

Oder:

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

Caseless Enums können ebenfalls verwendet werden.

Vorteil - Sie können nicht instanziiert werden.

enum API {
    enum Endpoint {
        static let url1 = "url1"
        static let url2 = "url2"
    }
    enum BaseURL {
        static let dev = "dev"
        static let prod = "prod"
    }
}

Von Apple lernen ist der beste Weg.

Beispiel: Apples Tastaturbenachrichtigung:

extension UIResponder {

    public class let keyboardWillShowNotification: NSNotification.Name

    public class let keyboardDidShowNotification: NSNotification.Name

    public class let keyboardWillHideNotification: NSNotification.Name

    public class let keyboardDidHideNotification: NSNotification.Name

}

Jetzt lerne ich von Apple:

extension User {
    /// user did login notification
    static let userDidLogInNotification = Notification.Name(rawValue: "User.userDidLogInNotification")
}

Was ist mehr NSAttributedString.Key.foregroundColor:

extension NSAttributedString {

    public struct Key : Hashable, Equatable, RawRepresentable {

        public init(_ rawValue: String)

        public init(rawValue: String)
    }
}

extension NSAttributedString.Key {

    /************************ Attributes ************************/

    @available(iOS 6.0, *)
    public static let foregroundColor: NSAttributedString.Key // UIColor, default blackColor

}

Jetzt lerne ich von Apple:

extension UIFont {

    struct Name {

    }

}

extension UIFont.Name {

    static let SFProText_Heavy = "SFProText-Heavy"
    static let SFProText_LightItalic = "SFProText-LightItalic"
    static let SFProText_HeavyItalic = "SFProText-HeavyItalic"

}

Verwendungszweck:

let font = UIFont.init(name: UIFont.Name.SFProText_Heavy, size: 20)

Von Apple lernen ist die Art und Weise, wie jeder Ihre Codequalität auf einfache Weise verbessern kann.