ग्लोबल कॉन्स्टेंट स्विफ्ट में फाइल करते हैं

Question

अपने उद्देश्य-सी परियोजनाओं में, मैं अक्सर अधिसूचना नाम और कुंजी जैसी चीजों को संग्रहीत करने के लिए एक वैश्विक स्थिरांक फ़ाइल का उपयोग करता हूं NSUserDefaults। यह कुछ इस तरह दिखता है:

@interface GlobalConstants : NSObject

extern NSString *someNotification;

@end

@implementation GlobalConstants

NSString *someNotification = @"aaaaNotification";

@end

मैं स्विफ्ट में बिल्कुल वही काम कैसे करूं?

Comments

आप इस तुतलील

— अनीश

Answer 1

नामस्थान के रूप में संरचनाएं

IMO उस प्रकार के स्थिरांक से निपटने का सबसे अच्छा तरीका एक संरचना बनाना है।

struct Constants {
    static let someNotification = "TEST"
}

फिर, उदाहरण के लिए, इसे अपने कोड में इस तरह से कॉल करें:

print(Constants.someNotification)

घोंसला करने की क्रिया

यदि आप एक बेहतर संगठन चाहते हैं, तो मैं आपको खंडित उप-संरचनाओं का उपयोग करने की सलाह देता हूं

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

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

तब आप सिर्फ उदाहरण के लिए उपयोग कर सकते हैं K.Path.Tmp

वास्तविक विश्व उदाहरण

यह सिर्फ एक तकनीकी समाधान है, मेरे कोड में वास्तविक कार्यान्वयन अधिक दिखता है:

struct GraphicColors {

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

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

तथा

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

Comments

व्यक्तिगत रूप से, मैं एक Constant.swiftफ़ाइल को अलग-अलग संरचनाओं के साथ गया था, लेकिन Constantsएक स्थिर में बहुत लंबी कॉल से बचने के लिए एक बड़ी संरचना में समझाया नहीं । इसलिए मैं NotificationKey.Welcomeइसके बजाय कॉल करता हूंConstants.NotificationKey.Welcome

— केविन हिर्श

@KevinHirsch एक बुरा विचार नहीं है। दूसरी ओर: अगर मेरे पास। पूर्ववर्ती उपसर्ग हैं, तो मुझे पता है कि यह एक स्थानीय चीज नहीं है, लेकिन नाम स्थान में इस तरह की सामग्री निरंतर है

— मई'15

@brainray मैं आपकी बात देख रहा हूं लेकिन मेरे कोड में, स्थिरांक कभी भी स्थानीय नहीं होते हैं (हमेशा एक में Constants.swift) और हमेशा एक जैसे दिखते हैं: अपरकेस के साथ शुरू होता है और "NotificationKey", "SegueIdentifier या" Path ", जैसे सार्थक श्रेणी के नाम के साथ, ।। तो मैं आसानी से देख सकता हूँ जब यह एक स्थिर है;)

— केविन हिर्श

यह ऑब्जेक्टिव-सी कोड के साथ क्रॉस-कम्पेटिबल नहीं है (स्ट्रक्चर, न ही टॉप-लेवल कॉन्स्टेंट को ऑब्जेक्टिव-सी के लिए एक्सपोर्ट किया जाता है)।

— RndmTsk

@ वरुण नैहरियाstruct Helpers { static func RGBCOLOR(red: Int, green: Int, blue: Int) -> UIColor { return UIColor(red: CGFloat(red) / 255.0, green: CGFloat(green) / 255.0, blue: CGFloat(blue) / 255.0, alpha: 1) } static func IOS7VERSION() -> Bool { return UIDevice.currentDevice().systemVersion.compare("7.0", options: .NumericSearch, range: nil, locale: nil) != .OrderedAscending } }

— आंद्रे स्लोट्टा

Answer 2

मुझे पार्टी के लिए देर हो रही है।

यहां कोई बात नहीं है कि मैं कॉन्स्टेंट फाइल को कैसे प्रबंधित करता हूं ताकि यह कोड को तेजी से लिखते समय डेवलपर्स को अधिक समझ में आए।

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

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

एपीपी में इस्तेमाल सभी कुंजी के लिए

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

रंग योजनाओं के लिए:

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

आप नाम के एक आम समूह में इन सभी फ़ाइलों को लपेट कर सकते हैं स्थिरांक अपने Xcode परियोजना में।

और इस वीडियो को और देखने के लिए

Comments

धन्यवाद, मुझे आपकी विधि सबसे सुविधाजनक लगी (कम से कम मेरे लिए), अच्छा हुआ! 8)

— यतको

मेरे जवाब से बेहतर है

— किरीट वाघेला

UIKit :)

— alicanbatur

क्या स्टैटिक वैरिएबल रन टाइम के दौरान ऐप के आकार को नहीं बढ़ाता है क्योंकि जब ऐप चलना शुरू होता है तो सभी स्टैटिक वैरिएबल लोड हो जाते हैं?

— आनंद

मुझे पता है कि यह एक साल से अधिक पुराना है, लेकिन सिर्फ यह कहना चाहता हूं कि यह शानदार है। इस done पर ज्ञान को साझा करने के लिए अच्छी तरह से किया गया

— user1898712

Answer 3

हालाँकि मैं @ फ्रांसेस्कू का रास्ता पसंद करता हूं (स्थिर गुणों के साथ एक संरचना का उपयोग करके), आप वैश्विक स्थिरांक और चर को भी परिभाषित कर सकते हैं:

let someNotification = "TEST"

हालांकि, ध्यान दें कि स्थानीय चर / स्थिरांक और वर्ग / संरचना गुणों से अलग, ग्लोबल्स का अर्थ है कि वे पहली बार एक्सेस किए जाने के दौरान प्रारंभिक रूप से आलसी होते हैं।

सुझाव पठन: वैश्विक और स्थानीय चर , और स्विफ्ट में भी वैश्विक चर नहीं हैं

Comments

स्थिरांक घोषित करने का यह सही तरीका है। पठनीयता के लिए संरचनात्मक दृष्टिकोण बहुत अच्छा है।

— जोए न्युन्स

मैं इस दृष्टिकोण की सिफारिश नहीं करता क्योंकि यह OOP सिद्धांत को टालता है..आप

— अनीश

@ThatlazyiOSGuy hat स्विफ्ट एक ओओपी भाषा है लेकिन फ़ोकस फ़ंक्शनल प्रोग्रामिंग के साथ-साथ फ़ोकस (कम से कम अधिक फ़ंक्शनल कॉन्सेप्ट्स) की ओर अधिक है। यह स्थिरांक घोषित करने के लिए एक पूरी तरह से वैध तरीका है, हालांकि यह किसी भी आईडीई के लिए स्ट्रिंग नाम स्थान को गंभीर रूप से बादल देगा।

— डीन केली

आप कहते हैं कि अंतर निहित आलस्य में है, लेकिन अगर आप एक गणना किए गए स्थिर संस्करण का उपयोग करते हैं तो यह उसी तरह कार्य करेगा जैसे एक वैश्विक करता है और एक बार और केवल एक बार प्रेषण करता है।

— डीन केली

प्रतीक्षा करें, लेकिन संभावित समस्या यह है कि संरचना मूल्य प्रकार है, वर्ग संदर्भ प्रकार है, संरचना में वर्ग उदाहरण असाइन करना वर्ग को मूल्य प्रकार में ले जाएगा, जो अवांछित है ??

— Martian2049

Answer 4

Constant.swift

import Foundation

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

ViewController.swift

var manager = AFHTTPRequestOperationManager(baseURL: kBaseURL)

Comments

किस कारण से BASEURL के बजाय kBaseURL का उपयोग करता है? धन्यवाद!

— जोसेफ एस्कोबार

Problaly वह भी Android अनुप्रयोगों को विकसित कर रहा है और यह एक Android standart है।

— बोराना डे

ऑब्जेक्टिव-सी में स्थिरांक के लिए एक पैटर्न है, आप हमेशा उन्हें अगले प्रारूप का उपयोग करते हुए घोषित करेंगे: संपत्ति का k + ऊंट मामला

— लॉर स्टीफन

Answer 5

गणना पर विचार करें। ये अलग-अलग उपयोग के मामलों के लिए तार्किक रूप से टूट सकते हैं।

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

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

एक अद्वितीय लाभ तब होता है जब आपके पास पारस्परिक रूप से अनन्य विकल्पों की स्थिति होती है, जैसे:

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

इस उदाहरण में, आपको एक संकलित त्रुटि प्राप्त होगी क्योंकि आपने मामले को संभाला नहीं है PhotoMetaKeys.DateTaken।

Comments

Enum मामला डुप्लिकेट मानों को रोक नहीं सकता है। तो यह सभी परिदृश्यों में फिट नहीं होगा।

— अयान जैन

@AainaJain दरअसल, यदि गणना किए गए गुणों का उपयोग एनम कच्चे मान के बजाय मान के लिए किया जाता है, तो विभिन्न एनुम मामलों का एक ही मूल्य आउटपुट होना आसान है।

— भविष्य-एडम

Answer 6

या सिर्फ GlobalConstants.swift में:

import Foundation

let someNotification = "aaaaNotification"

Answer 7

जैसा कि दूसरों ने उल्लेख किया है, एक वर्ग के बाहर घोषित कुछ भी वैश्विक है।

आप एकल भी बना सकते हैं:

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

जब भी आप इस वर्ग से कुछ का उपयोग करना चाहते हैं, तो आप लिखते हैं:

TestClass.sharedInstance.number = 1

यदि आप अब println(TestClass.sharedInstance.number)अपने प्रोजेक्ट में कहीं से भी लिखते हैं तो आप प्रिंट करेंगे1 लॉग में । यह सभी प्रकार की वस्तुओं के लिए काम करता है।

tl; dr: किसी भी समय आप कक्षा में सब कुछ वैश्विक बनाना चाहते हैं, वर्ग में जोड़ें static let sharedInstance = YourClassName(), और उपसर्ग के साथ वर्ग के सभी मूल्यों को संबोधित करेंYourClassName.sharedInstance

Comments

आपके लिए एक प्रश्न। अन्य उत्तरों में जानकारी को संग्रहीत करने के लिए संरचना का उपयोग करना शामिल है, लेकिन संभावित समस्या यह है कि संरचना मूल्य प्रकार है, वर्ग संदर्भ प्रकार है, संरचना में वर्ग उदाहरण असाइन करना वर्ग को मूल्य प्रकार में ले जाएगा, जो अवांछित है, सही है?

— Martian2049

Answer 8

मैंने अपनी स्विफ्ट परियोजना
1 में क्या किया : नई स्विफ्ट फ़ाइल
2 बनाएँ: इसमें एक संरचनात्मक और स्थिर स्थिरांक बनाएँ।
3: केवल YourStructName.baseURL का उपयोग करने के लिए

नोट: इनिशियलाइज़ेशन बनाने के बाद थोड़ा समय लगता है इसलिए यह 2-5 सेकंड के बाद अन्य व्यू-कंट्रोलर में दिखाई देगा।

import Foundation

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

Answer 9

सूचनाओं के लिए आप एक्सटेंशन का उपयोग कर सकते हैं, कुछ इस तरह से:

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

और इसका उपयोग करें NotificationCenter.default.post(name: .testNotification, object: nil)

Answer 10

मेरे ऐप्स में वैश्विक स्थिरांक हैं, यह मैं एक अलग स्विफ्ट फ़ाइल में करता हूं :

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

इसका उपयोग करना आसान है, और इस तरह से हर जगह कॉल करना है:

print(Config.Notifications.awareUser)

Answer 11

रंग की

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

फोंट्स

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

अन्य के लिए - स्वीकृत उत्तर में सब कुछ वैसा ही।

Answer 12

स्विफ्ट डॉक्स के अनुसार वैश्विक चर को फ़ाइल दायरे में घोषित किया जाता है।

वैश्विक चर वे चर होते हैं जो किसी फ़ंक्शन, विधि, बंद करने या संदर्भ के प्रकार के बाहर परिभाषित किए जाते हैं

बस एक स्विफ्ट फ़ाइल बनाएं (जैसे: Constnats.swift) और अपने कॉन्स्टेंट को वहां घोषित करें:

// Constants.swift

let SOME_NOTIF = "aaaaNotification"

और इसे अपनी परियोजना में कहीं से भी बिना संरचना, एनम या वर्ग के नाम का उल्लेख करने के लिए कहें।

// MyViewController.swift

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

मुझे लगता है कि यह कोड पठनीयता के लिए बहुत बेहतर है।

Answer 13

स्विफ्ट 4 संस्करण

यदि आप NotificationCenter के लिए एक नाम बनाना चाहते हैं:

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

सूचनाओं के लिए सदस्यता लें:

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

सूचना भेजें:

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

यदि आप केवल एक वर्ग चाहते हैं जिसमें चर का उपयोग किया जाए:

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

या:

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

Answer 14

कैसलेस एनम का उपयोग भी किया जा सकता है।

फायदा - उन्हें तुरंत नहीं किया जा सकता है।

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

Answer 15

Apple से सीखें सबसे अच्छा तरीका है।

उदाहरण के लिए, Apple का कीबोर्ड सूचना:

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

}

अब मैं Apple से सीखता हूं:

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

---

और क्या है 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

}

अब मैं ऐप्पल सीखता हूं:

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"

}

उपयोग:

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

---

Apple से सीखें वह तरीका है जो हर कोई कर सकता है और अपनी कोड गुणवत्ता को आसानी से बढ़ावा दे सकता है।