हेक्स रंग मूल्यों का उपयोग कैसे करें

Question

मैं कुछ मानक वाले के बजाय स्विफ्ट में हेक्स रंग मूल्यों का उपयोग करने की कोशिश कर रहा हूं UIColorजो आपको उपयोग करने की अनुमति देता है, लेकिन मुझे नहीं पता कि यह कैसे करना है।

उदाहरण: मैं #ffffffरंग के रूप में कैसे उपयोग करूंगा ?

Comments

#ffffffवास्तव में हेक्साडेसिमल नोटेशन में 3 रंग घटक हैं - लाल ff, हरा ffऔर नीला ff। आप 0xउपसर्ग का उपयोग करके स्विफ्ट में हेक्साडेसिमल नोटेशन लिख सकते हैं , जैसे 0xFF।

— सुल्तान

यहाँ जवाब आपको stackoverflow.com/questions/24196528/… से मदद करनी चाहिए ।

— बूओरांगेर

संभव है कि स्विफ्ट में UIColorFromRGB मूल्य का उपयोग कैसे करें

— जैक

Answer 1

#ffffffवास्तव में हेक्साडेसिमल नोटेशन में 3 रंग घटक हैं - लाल ff, हरा ffऔर नीला ff। आप 0xउपसर्ग का उपयोग करके स्विफ्ट में हेक्साडेसिमल नोटेशन लिख सकते हैं , जैसे0xFF

रूपांतरण को सरल बनाने के लिए, आइए एक ऐसा आरंभक बनाएं जो पूर्णांक (0 - 255) मान लेता है:

extension UIColor {
   convenience init(red: Int, green: Int, blue: Int) {
       assert(red >= 0 && red <= 255, "Invalid red component")
       assert(green >= 0 && green <= 255, "Invalid green component")
       assert(blue >= 0 && blue <= 255, "Invalid blue component")

       self.init(red: CGFloat(red) / 255.0, green: CGFloat(green) / 255.0, blue: CGFloat(blue) / 255.0, alpha: 1.0)
   }

   convenience init(rgb: Int) {
       self.init(
           red: (rgb >> 16) & 0xFF,
           green: (rgb >> 8) & 0xFF,
           blue: rgb & 0xFF
       )
   }
}

उपयोग:

let color = UIColor(red: 0xFF, green: 0xFF, blue: 0xFF)
let color2 = UIColor(rgb: 0xFFFFFF)

अल्फा कैसे प्राप्त करें?

आपके उपयोग के मामले के आधार पर, आप बस मूल UIColor.withAlphaComponentविधि का उपयोग कर सकते हैं , जैसे

let semitransparentBlack = UIColor(rgb: 0x000000).withAlphaComponent(0.5)

या आप उपरोक्त विधियों में एक अतिरिक्त (वैकल्पिक) पैरामीटर जोड़ सकते हैं:

convenience init(red: Int, green: Int, blue: Int, a: CGFloat = 1.0) {
    self.init(
        red: CGFloat(red) / 255.0,
        green: CGFloat(green) / 255.0,
        blue: CGFloat(blue) / 255.0,
        alpha: a
    )
}

convenience init(rgb: Int, a: CGFloat = 1.0) {
    self.init(
        red: (rgb >> 16) & 0xFF,
        green: (rgb >> 8) & 0xFF,
        blue: rgb & 0xFF,
        a: a
    )
}

(हम alphaमौजूदा इनिशियलाइज़र के साथ नाम टकराव के कारण पैरामीटर का नाम नहीं दे सकते हैं )।

कहा जाता है:

let color = UIColor(red: 0xFF, green: 0xFF, blue: 0xFF, a: 0.5)
let color2 = UIColor(rgb: 0xFFFFFF, a: 0.5)

अल्फा को पूर्णांक 0-255 के रूप में प्राप्त करने के लिए, हम कर सकते हैं

convenience init(red: Int, green: Int, blue: Int, a: Int = 0xFF) {
    self.init(
        red: CGFloat(red) / 255.0,
        green: CGFloat(green) / 255.0,
        blue: CGFloat(blue) / 255.0,
        alpha: CGFloat(a) / 255.0
    )
}

// let's suppose alpha is the first component (ARGB)
convenience init(argb: Int) {
    self.init(
        red: (argb >> 16) & 0xFF,
        green: (argb >> 8) & 0xFF,
        blue: argb & 0xFF,
        a: (argb >> 24) & 0xFF
    )
}

के रूप में पुकारा गया

let color = UIColor(red: 0xFF, green: 0xFF, blue: 0xFF, a: 0xFF)
let color2 = UIColor(argb: 0xFFFFFFFF)

या पिछले तरीकों का एक संयोजन। तार का उपयोग करने की बिल्कुल आवश्यकता नहीं है।

Comments

महान समाधान! पृथ्वी पर क्यों नहीं होगा Apple पहले से ही इस तरह से कुछ ????

— ओलिवर स्प्रीएन

@confile नहीं, क्योंकि यह मानकीकृत नहीं है। अल्फा पहला घटक या अंतिम हो सकता है। यदि आपको अल्फा की आवश्यकता है, तो बस एक पैरामीटर जोड़ेंalpha

— सुल्तान

एक ही समाधान, स्विफ्ट 1.2 संगत, अल्फा समर्थन के साथ: gist.github.com/berikv/ecf1f79c5bc9921c47ef

— Berik

UInt8 का उपयोग यह मानने के बजाय क्यों करें कि आपके ints 0 0 ... 255 की सीमा में हैं?

— रिचर्ड वेनेबल

यह 2017 है, और Apple के पास अभी भी ऐसा कुछ नहीं है।

— अंबिसव

Answer 2

यह एक फ़ंक्शन है जो एक हेक्स स्ट्रिंग लेता है और एक यूआईसीकलर लौटाता है।
(आप या तो प्रारूप के साथ हेक्स स्ट्रिंग्स दर्ज कर सकते हैं: #ffffffया ffffff)

उपयोग:

var color1 = hexStringToUIColor("#d3d3d3")

स्विफ्ट 5: (स्विफ्ट 4+)

func hexStringToUIColor (hex:String) -> UIColor {
    var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

    if (cString.hasPrefix("#")) {
        cString.remove(at: cString.startIndex)
    }

    if ((cString.count) != 6) {
        return UIColor.gray
    }

    var rgbValue:UInt64 = 0
    Scanner(string: cString).scanHexInt64(&rgbValue)

    return UIColor(
        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
        blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
        alpha: CGFloat(1.0)
    )
}

स्विफ्ट 3:

func hexStringToUIColor (hex:String) -> UIColor {
    var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

    if (cString.hasPrefix("#")) {
        cString.remove(at: cString.startIndex)
    }

    if ((cString.characters.count) != 6) {
        return UIColor.gray
    }

    var rgbValue:UInt32 = 0
    Scanner(string: cString).scanHexInt32(&rgbValue)

    return UIColor(
        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
        blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
        alpha: CGFloat(1.0)
    )
}

स्विफ्ट 2:

func hexStringToUIColor (hex:String) -> UIColor {
    var cString:String = hex.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet() as NSCharacterSet).uppercaseString

    if (cString.hasPrefix("#")) {
      cString = cString.substringFromIndex(cString.startIndex.advancedBy(1))
    }

    if ((cString.characters.count) != 6) {
      return UIColor.grayColor()
    }

    var rgbValue:UInt32 = 0
    NSScanner(string: cString).scanHexInt(&rgbValue)

    return UIColor(
        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
        blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
        alpha: CGFloat(1.0)
    )
}

---

स्रोत: अरशद / जिस्त: de147c42d7b3063ef7bc

संपादित करें: कोड अपडेट किया गया। धन्यवाद, Hlung, jaytrixz, Ahmad F, Kegham K, और Adam Waite!

Comments

countelementsअब सिर्फ count:)

— Hlung

@ हैलंग और @ हेथस्ट्राइडर ऐसा लगता है कि वे आपको countइसके बजाय अब ऐसा नहीं करने देते countElements, किसी भी विचार के लिए जो वे हमें उपयोग करना चाहते हैं?

— SRMR

कोड की इस पंक्ति बदल दिया cString = cString.substringFromIndex(advance(cString.startIndex, 1))करने के लिए cString = cString.substringFromIndex(cString.startIndex.advancedBy(1))7.3 स्विफ्ट 2.2 Xcode के लिए

— jaytrixz

अगर आप अभी भी iPhone 5 या किसी भी 32 बिट डिवाइस को iOS 11 से पहले सपोर्ट कर रहे हैं तो यह क्रैश हो जाएगा। आप को बदलने की जरूरत UInt32के लिएUInt64

— Kegham लालकृष्ण

Xcode 11 और iOS13 SDK को दर्शाया गया है scanHexInt32। एक UInt64और scanHexInt64इसके बजाय का उपयोग करें ।

— एडम वेट

Answer 3

स्विफ्ट 5 (स्विफ्ट 4, स्विफ्ट 3) यूकोकल एक्सटेंशन:

extension UIColor {
    convenience init(hexString: String) {
        let hex = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
        var int = UInt64()
        Scanner(string: hex).scanHexInt64(&int)
        let a, r, g, b: UInt64
        switch hex.count {
        case 3: // RGB (12-bit)
            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6: // RGB (24-bit)
            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
        case 8: // ARGB (32-bit)
            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
        default:
            (a, r, g, b) = (255, 0, 0, 0)
        }
        self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
    }
}

उपयोग :

let darkGrey = UIColor(hexString: "#757575")

स्विफ्ट 2.x संस्करण:

extension UIColor {
    convenience init(hexString: String) {
        let hex = hexString.stringByTrimmingCharactersInSet(NSCharacterSet.alphanumericCharacterSet().invertedSet)
        var int = UInt32()
        NSScanner(string: hex).scanHexInt(&int)
        let a, r, g, b: UInt32
        switch hex.characters.count {
        case 3: // RGB (12-bit)
            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6: // RGB (24-bit)
            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
        case 8: // ARGB (32-bit)
            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
        default:
            (a, r, g, b) = (255, 0, 0, 0)
        }
        self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
    }
}

Comments

यह मेरा पसंदीदा कार्यान्वयन है क्योंकि यह 3 मामलों को संभालता है। लेकिन मैं डिफ़ॉल्ट को प्राथमिकता देता हूं: सफेद के बजाय शून्य वापस करने के लिए मामला।

— रिचर्ड वेनेबल

वैसे, इस कार्यान्वयन में डिफ़ॉल्ट मामला UIColor.yellow ()

— गुई मौरा

मुझे पता है कि इसका उपयोग कैसे करना है और यह एक आकर्षण की तरह काम करता है। लेकिन मैं सच में समझ में नहीं आता क्यों। शायद कोई मुझे खोज के लिए स्पष्टीकरण या कुछ अच्छे लिंक / शब्द दे सकता है?

— कुजुडु 24:16

यह अल्फा वैल्यू के साथ सही तरीके से काम नहीं करता है। उदाहरण के लिए दोनों इनपुट "ff00ff00" और "# ff00ff00" 0 1 0 का RGBA आउटपुट करेगा (यह 1 0 0 0 होना चाहिए)। इनपुट "# ff00ff" का परिणाम 1 0 1 1 है, जो सही है। (एक्सकोड 8.2.1, आईओएस 9.3।)

— वोमबल

@ पहला घटक वह अल्फा है जो अंतिम नहीं है। इसलिए "# ff00ff00" की शुरुआत में "ff" के कारण अल्फा 1 है। मुझे लगता है कि आपका मतलब "# 00ff00ff" था। एक और उदाहरण: "# ff00ff00" यह अल्फा 1 के साथ हरा है, "# 0000ff00" यह अल्फा 0 के साथ हरा है

— Luca Torella

Answer 4

UIColor:

extension UIColor {

    convenience init(hex: Int) {
        let components = (
            R: CGFloat((hex >> 16) & 0xff) / 255,
            G: CGFloat((hex >> 08) & 0xff) / 255,
            B: CGFloat((hex >> 00) & 0xff) / 255
        )
        self.init(red: components.R, green: components.G, blue: components.B, alpha: 1)
    }

}

CGColor:

extension CGColor {

    class func colorWithHex(hex: Int) -> CGColorRef {

        return UIColor(hex: hex).CGColor

    }

}

---

प्रयोग

let purple = UIColor(hex: 0xAB47BC)

Comments

मेरी विनम्र राय में, मुझे यह उपयोग करने में सबसे आसान लगा और अन्य उत्तरों की तुलना में बहुत स्पष्ट था।

— thandasoru

आप 123ABC को कैसे संभालेंगे? संकलक इसे एक अंक नहीं होने के कारण दफन कर रहा है।

— इस्लाम Q।

पूर्णता के लिए: let foo: Int = 0x123ABC- '0x' पर ध्यान दें

— Carsten

काश, कई अन्य हेक्स कन्वर्टर्स की तरह, यह अल्फा घटकों को संभाल नहीं करता है। इसलिए, उदाहरण के लिए, आपको इससे UIColor.clear मान नहीं मिल सकता है।

— वोमबल

हालांकि यह अल्फा @Womble को हैंडल नहीं करता है, यह जोड़ने के लिए तुच्छ है। मुझे स्विफ्ट कंपाइलर को "बहुत लंबा" लेने और छोड़ने के लिए "घटकों" के लिए एक स्पष्ट प्रकार सेट करना था।

— नॉर्मन

Answer 5

स्विफ्ट 4 : सुलतान और लुका टोरेला के जवाबों का मेल:

extension UIColor {
    convenience init(hexFromString:String, alpha:CGFloat = 1.0) {
        var cString:String = hexFromString.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
        var rgbValue:UInt32 = 10066329 //color #999999 if string has wrong format

        if (cString.hasPrefix("#")) {
            cString.remove(at: cString.startIndex)
        }

        if ((cString.count) == 6) {
            Scanner(string: cString).scanHexInt32(&rgbValue)
        }

        self.init(
            red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
            alpha: alpha
        )
    }
}

उपयोग के उदाहरण:

let myColor = UIColor(hexFromString: "4F9BF5")

let myColor = UIColor(hexFromString: "#4F9BF5")

let myColor = UIColor(hexFromString: "#4F9BF5", alpha: 0.5)

Comments

यह स्वीकृत उत्तर होना चाहिए, बहुत बहुत धन्यवाद।

— कीहन कामंगर

Answer 6

स्विफ्ट 2.0 और Xcode 7.0.1 के साथ आप यह फ़ंक्शन बना सकते हैं:

    // Creates a UIColor from a Hex string.
    func colorWithHexString (hex:String) -> UIColor {
        var cString:String = hex.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).uppercaseString

        if (cString.hasPrefix("#")) {
            cString = (cString as NSString).substringFromIndex(1)
        }

        if (cString.characters.count != 6) {
            return UIColor.grayColor()
        }

        let rString = (cString as NSString).substringToIndex(2)
        let gString = ((cString as NSString).substringFromIndex(2) as NSString).substringToIndex(2)
        let bString = ((cString as NSString).substringFromIndex(4) as NSString).substringToIndex(2)

        var r:CUnsignedInt = 0, g:CUnsignedInt = 0, b:CUnsignedInt = 0;
        NSScanner(string: rString).scanHexInt(&r)
        NSScanner(string: gString).scanHexInt(&g)
        NSScanner(string: bString).scanHexInt(&b)


        return UIColor(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: CGFloat(1))
    }

और फिर इसे इस तरह से उपयोग करें:

let color1 = colorWithHexString("#1F437C")

स्विफ्ट 4 के लिए अपडेट किया गया

func colorWithHexString (hex:String) -> UIColor {

    var cString = hex.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines).uppercased()

    if (cString.hasPrefix("#")) {
        cString = (cString as NSString).substring(from: 1)
    }

    if (cString.characters.count != 6) {
        return UIColor.gray
    }

    let rString = (cString as NSString).substring(to: 2)
    let gString = ((cString as NSString).substring(from: 2) as NSString).substring(to: 2)
    let bString = ((cString as NSString).substring(from: 4) as NSString).substring(to: 2)

    var r:CUnsignedInt = 0, g:CUnsignedInt = 0, b:CUnsignedInt = 0;
    Scanner(string: rString).scanHexInt32(&r)
    Scanner(string: gString).scanHexInt32(&g)
    Scanner(string: bString).scanHexInt32(&b)


    return UIColor(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: CGFloat(1))
}

Answer 7

स्विफ्ट 5.1: हेक्स और सीएसएस रंग नाम समर्थन एक यूआईसीकलर के माध्यम से

जीएसटी कोड

स्विफ्ट पैकेज

उदाहरण के तार:

• Orange, Lime, Tomato, आदि
• Clear, Transparent, nil, और रिक्त स्ट्रिंग उपज[UIColor clearColor]
• abc
• abc7
• #abc7
• 00FFFF
• #00FFFF
• 00FFFF77

खेल का मैदान उत्पादन:

Answer 8

कलरलैमरल का उपयोग करके प्रोग्राम को रंग जोड़ने का सबसे सरल तरीका है ।

उदाहरण में दिखाए गए अनुसार प्रॉपर्टी ColorLiteral जोड़ें, Xcode आपको उन रंगों की पूरी सूची के साथ संकेत देगा, जिन्हें आप चुन सकते हैं। ऐसा करने का लाभ कम कोड है, HEX मान या RGB जोड़ें । आपको स्टोरीबोर्ड से हाल ही में उपयोग किए गए रंग भी मिलेंगे।

उदाहरण: self.view.backgroundColor = ColorLiteral

Comments

वाह! आप

— शैंपू

यह उपयोगी है!

— ब्रैड थॉमस

वर्तमान में सबसे आसान और सबसे अच्छा समाधान है यदि रंग गतिशील रूप से सेट नहीं है

— पीनी चेनी

Answer 9

चेतावनी "'ScanHexInt32' को iOS 13.0 में पदावनत कर दिया गया"।

नमूना Swift2.2 और इसके बाद के संस्करण पर काम करना चाहिए (Swift2.x, Swift3.x, Swift4.x, Swift5.x):

extension UIColor {

    // hex sample: 0xf43737
    convenience init(_ hex: Int, alpha: Double = 1.0) {
        self.init(red: CGFloat((hex >> 16) & 0xFF) / 255.0, green: CGFloat((hex >> 8) & 0xFF) / 255.0, blue: CGFloat((hex) & 0xFF) / 255.0, alpha: CGFloat(255 * alpha) / 255)
    }

    convenience init(_ hexString: String, alpha: Double = 1.0) {
        let hex = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
        var int = UInt64()
        Scanner(string: hex).scanHexInt64(&int)

        let r, g, b: UInt64
        switch hex.count {
        case 3: // RGB (12-bit)
            (r, g, b) = ((int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6: // RGB (24-bit)
            (r, g, b) = (int >> 16, int >> 8 & 0xFF, int & 0xFF)
        default:
            (r, g, b) = (1, 1, 0)
        }

        self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(255 * alpha) / 255)
    }

    convenience init(r: CGFloat, g: CGFloat, b: CGFloat, a: CGFloat = 1) {
        self.init(red: (r / 255), green: (g / 255), blue: (b / 255), alpha: a)
    }
}

उन्हें नीचे की तरह उपयोग करें:

UIColor(0xF54A45)
UIColor(0xF54A45, alpha: 0.7)
UIColor("#f44")
UIColor("#f44", alpha: 0.7)
UIColor("#F54A45")
UIColor("#F54A45", alpha: 0.7)
UIColor("F54A45")
UIColor("F54A45", alpha: 0.7)
UIColor(r: 245.0, g: 73, b: 69)
UIColor(r: 245.0, g: 73, b: 69, a: 0.7)

Comments

'ScanHexInt32' को आईओएस 13.0 में चित्रित किया गया था

— दिमितर स्टेफानोवस्की

@Dimitar Stefanovski मैंने तय कर लिया है।

— रानीस

Answer 10

यह उत्तर बताता है कि इसे ओब्ज-सी में कैसे करना है। पुल का उपयोग करना है

let rgbValue = 0xFFEEDD
let r = Float((rgbValue & 0xFF0000) >> 16)/255.0
let g = Float((rgbValue & 0xFF00) >> 8)/255.0
let b = Float((rgbValue & 0xFF))/255.0
self.backgroundColor = UIColor(red:r, green: g, blue: b, alpha: 1.0)

Answer 11

मैंने उत्तर के इस धागे से कुछ विचारों को मिला दिया है और इसे iOS 13 और स्विफ्ट 5 के लिए अपडेट किया है ।

extension UIColor {

  convenience init(hex: String, alpha: CGFloat = 1.0) {
    var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

    if (cString.hasPrefix("#")) { cString.removeFirst() }

    if ((cString.count) != 6) {
      self.init(hex: "ff0000") // return red color for wrong hex input
      return
    }

    var rgbValue: UInt64 = 0
    Scanner(string: cString).scanHexInt64(&rgbValue)

    self.init(red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
              green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
              blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
              alpha: alpha)
  }

}

आप इसे इस तरह उपयोग कर सकते हैं:

UIColor(hex: "#ff0000") // with #
UIColor(hex: "ff0000")  // without #
UIColor(hex: "ff0000", alpha: 0.5) // using optional alpha value

Answer 12

स्विफ्ट 5: आप Xcode में रंग बना सकते हैं जैसा कि निम्नलिखित दो चित्रों में बताया गया है:

आपको रंग का नाम देना चाहिए क्योंकि आप नाम से रंग का संदर्भ देते हैं। चित्र 2 में दिखाया गया है:

Comments

मुझे नहीं लगा कि आप रंगों को एसेट्स के रूप में परिभाषित कर सकते हैं। वास्तव में खुशी है कि मुझे यह जवाब मिला!

— जस्टिन

Answer 13

एक और तरीका

स्विफ्ट 3.0

UIColor के लिए एक विस्तार लिखें

// To change the HexaDecimal value to Corresponding Color
extension UIColor
{
    class func uicolorFromHex(_ rgbValue:UInt32, alpha : CGFloat)->UIColor

    {
        let red = CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0
        let green = CGFloat((rgbValue & 0xFF00) >> 8) / 255.0
        let blue = CGFloat(rgbValue & 0xFF) / 255.0
        return UIColor(red:red, green:green, blue:blue, alpha: alpha)
    }
}

आप सीधे इस तरह से हेक्स के साथ UIColor बना सकते हैं

let carrot = UIColor.uicolorFromHex(0xe67e22, alpha: 1))

Answer 14

नवीनतम स्विफ्ट 3 संस्करण

        extension UIColor {
convenience init(hexString: String) {
    let hex = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
    var int = UInt32()
    Scanner(string: hex).scanHexInt32(&int)
    let a, r, g, b: UInt32
    switch hex.characters.count {
    case 3: // RGB (12-bit)
        (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
    case 6: // RGB (24-bit)
        (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
    case 8: // ARGB (32-bit)
        (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
    default:
        (a, r, g, b) = (255, 0, 0, 0)
    }
      self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue:      CGFloat(b) / 255, alpha: CGFloat(a) / 255)
}
}

अपनी कक्षा में उपयोग करें या जहाँ आप कभी भी इस तरह से हेक्ज़ोलॉर से यूरिकॉल में परिवर्तित हो जाते हैं

             let color1 = UIColor(hexString: "#FF323232")

Answer 15

यहाँ मैं उपयोग कर रहा हूँ। # प्रतीक के साथ या उसके बिना 6 और 8 वर्ण रंग तार के साथ काम करता है। अमान्य स्ट्रिंग के साथ आरंभ होने पर डिबग में काले रंग में कमी और क्रैश में क्रैश।

extension UIColor {
    public convenience init(hex: String) {
        var r: CGFloat = 0
        var g: CGFloat = 0
        var b: CGFloat = 0
        var a: CGFloat = 1

        let hexColor = hex.replacingOccurrences(of: "#", with: "")
        let scanner = Scanner(string: hexColor)
        var hexNumber: UInt64 = 0
        var valid = false

        if scanner.scanHexInt64(&hexNumber) {
            if hexColor.count == 8 {
                r = CGFloat((hexNumber & 0xff000000) >> 24) / 255
                g = CGFloat((hexNumber & 0x00ff0000) >> 16) / 255
                b = CGFloat((hexNumber & 0x0000ff00) >> 8) / 255
                a = CGFloat(hexNumber & 0x000000ff) / 255
                valid = true
            }
            else if hexColor.count == 6 {
                r = CGFloat((hexNumber & 0xff0000) >> 16) / 255
                g = CGFloat((hexNumber & 0x00ff00) >> 8) / 255
                b = CGFloat(hexNumber & 0x0000ff) / 255
                valid = true
            }
        }

        #if DEBUG
            assert(valid, "UIColor initialized with invalid hex string")
        #endif

        self.init(red: r, green: g, blue: b, alpha: a)
    }
}

उपयोग:

UIColor(hex: "#75CC83FF")
UIColor(hex: "75CC83FF")
UIColor(hex: "#75CC83")
UIColor(hex: "75CC83")

Answer 16

यहाँ UIColorएक हेक्स स्ट्रिंग पर एक स्विफ्ट एक्सटेंशन है :

import UIKit

extension UIColor {

    convenience init(hexString: String) {
        // Trim leading '#' if needed
        var cleanedHexString = hexString
        if hexString.hasPrefix("#") {
//            cleanedHexString = dropFirst(hexString) // Swift 1.2
            cleanedHexString = String(hexString.characters.dropFirst()) // Swift 2
        }

        // String -> UInt32
        var rgbValue: UInt32 = 0
        NSScanner(string: cleanedHexString).scanHexInt(&rgbValue)

        // UInt32 -> R,G,B
        let red = CGFloat((rgbValue >> 16) & 0xff) / 255.0
        let green = CGFloat((rgbValue >> 08) & 0xff) / 255.0
        let blue = CGFloat((rgbValue >> 00) & 0xff) / 255.0

        self.init(red: red, green: green, blue: blue, alpha: 1.0)
    }

}

Comments

ड्रॉप ड्रॉप पहले क्या है?

— किशोर कुमार

Answer 17

public static func hexStringToUIColor (hex:String) -> UIColor {
    var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

    if (cString.hasPrefix("#")) {
        cString.remove(at: cString.startIndex)
    }

    if ((cString.characters.count) == 6) {

        var rgbValue:UInt32 = 0
        Scanner(string: cString).scanHexInt32(&rgbValue)

        return UIColor(
            red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
            alpha: CGFloat(1.0)
        )
    }else if ((cString.characters.count) == 8) {

        var rgbValue:UInt32 = 0
        Scanner(string: cString).scanHexInt32(&rgbValue)

        return UIColor(
            red: CGFloat((rgbValue & 0x00FF0000) >> 16) / 255.0,
            green: CGFloat((rgbValue & 0x0000FF00) >> 8) / 255.0,
            blue: CGFloat(rgbValue & 0x000000FF) / 255.0,
            alpha: CGFloat((rgbValue & 0xFF000000) >> 24) / 255.0
        )
    }else{
        return UIColor.gray
    }
}

कैसे इस्तेमाल करे

var color: UIColor = hexStringToUIColor(hex: "#00ff00"); // Without transparency
var colorWithTransparency: UIColor = hexStringToUIColor(hex: "#dd00ff00"); // With transparency

Answer 18

मान्यता के साथ हेक्स

एडुआर्डो के उत्तर के आधार पर

विवरण

• Xcode 10.0, स्विफ्ट 4.2
• Xcode 10.2.1 (10E1001), स्विफ्ट 5

समाधान

import UIKit

extension UIColor {

    convenience init(r: UInt8, g: UInt8, b: UInt8, alpha: CGFloat = 1.0) {
        let divider: CGFloat = 255.0
        self.init(red: CGFloat(r)/divider, green: CGFloat(g)/divider, blue: CGFloat(b)/divider, alpha: alpha)
    }

    private convenience init(rgbWithoutValidation value: Int32, alpha: CGFloat = 1.0) {
        self.init(
            r: UInt8((value & 0xFF0000) >> 16),
            g: UInt8((value & 0x00FF00) >> 8),
            b: UInt8(value & 0x0000FF),
            alpha: alpha
        )
    }

    convenience init?(rgb: Int32, alpha: CGFloat = 1.0) {
        if rgb > 0xFFFFFF || rgb < 0 { return nil }
        self.init(rgbWithoutValidation: rgb, alpha: alpha)
    }

    convenience init?(hex: String, alpha: CGFloat = 1.0) {
        var charSet = CharacterSet.whitespacesAndNewlines
        charSet.insert("#")
        let _hex = hex.trimmingCharacters(in: charSet)
        guard _hex.range(of: "^[0-9A-Fa-f]{6}$", options: .regularExpression) != nil else { return nil }
        var rgb: UInt32 = 0
        Scanner(string: _hex).scanHexInt32(&rgb)
        self.init(rgbWithoutValidation: Int32(rgb), alpha: alpha)
    }
}

प्रयोग

let alpha: CGFloat = 1.0

// Hex
print(UIColor(rgb: 0x4F9BF5) ?? "nil")
print(UIColor(rgb: 0x4F9BF5, alpha: alpha) ?? "nil")
print(UIColor(rgb: 5217269) ?? "nil")
print(UIColor(rgb: -5217269) ?? "nil")                  // = nil
print(UIColor(rgb: 0xFFFFFF1) ?? "nil")                 // = nil

// String
print(UIColor(hex: "4F9BF5") ?? "nil")
print(UIColor(hex: "4F9BF5", alpha: alpha) ?? "nil")
print(UIColor(hex: "#4F9BF5") ?? "nil")
print(UIColor(hex: "#4F9BF5", alpha: alpha) ?? "nil")
print(UIColor(hex: "#4F9BF56") ?? "nil")                // = nil
print(UIColor(hex: "#blabla") ?? "nil")                 // = nil

// RGB
print(UIColor(r: 79, g: 155, b: 245))
print(UIColor(r: 79, g: 155, b: 245, alpha: alpha))
//print(UIColor(r: 792, g: 155, b: 245, alpha: alpha))  // Compiler will throw an error, r,g,b = [0...255]

Comments

आपको NSPredicateकेवल नियमित अभिव्यक्ति का परीक्षण करने की आवश्यकता नहीं है । string.range(of: pattern, options: .regularExpression)काम भी करता है।

— सुल्तान

Answer 19

आप इसे स्विफ्ट 5 में उपयोग कर सकते हैं

स्विफ्ट 5

import UIKit

extension UIColor {
    static func hexStringToUIColor (hex:String) -> UIColor {
        var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

        if (cString.hasPrefix("#")) {
            cString.remove(at: cString.startIndex)
        }

        if ((cString.count) != 6) {
            return UIColor.gray
        }

        var rgbValue:UInt32 = 0
        Scanner(string: cString).scanHexInt32(&rgbValue)

        return UIColor(
            red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
            alpha: CGFloat(1.0)
        )
    }
}

Answer 20

स्विफ्ट 5 / स्विफ्टयूआई के लिए सरल रंग विस्तार

उदाहरण:

let myColor = Color(hex:0xF2C94C)

कोड:

import Foundation
import SwiftUI

extension UIColor {
    convenience init(hex: Int) {
        let components = (
            R: CGFloat((hex >> 16) & 0xff) / 255,
            G: CGFloat((hex >> 08) & 0xff) / 255,
            B: CGFloat((hex >> 00) & 0xff) / 255
        )
        self.init(red: components.R, green: components.G, blue: components.B, alpha: 1)
    }
}

extension Color {
    public init(hex: Int) {
        self.init(UIColor(hex: hex))
   }
}

Answer 21

स्विफ्ट 2.0:

ViewDidLoad () में

 var viewColor:UIColor
    viewColor = UIColor()
    let colorInt:UInt
    colorInt = 0x000000
    viewColor = UIColorFromRGB(colorInt)
    self.View.backgroundColor=viewColor



func UIColorFromRGB(rgbValue: UInt) -> UIColor {
    return UIColor(
        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
        blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
        alpha: CGFloat(1.0)
    )
}

Comments

तुमने मेरा दिन बचाया, दोस्त!

— ऑस्करको

Answer 22

स्विफ्ट 5

extension UIColor{

/// Converting hex string to UIColor
///
/// - Parameter hexString: input hex string
convenience init(hexString: String) {
    let hex = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
    var int = UInt64()
    Scanner(string: hex).scanHexInt64(&int)
    let a, r, g, b: UInt64
    switch hex.count {
    case 3:    
        (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
    case 6: 
        (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
    case 8: 
        (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
    default:
        (a, r, g, b) = (255, 0, 0, 0)
    }
    self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
}
}

UIColor (hexString: "your hex string") का उपयोग करके कॉल करें

Answer 23

सहायक 7 हेक्स रंग प्रकार

7 हेक्स रंग प्रारूप हैं: "" # FF0000 "," 0xFF0000 "," FF0000 "," F00 "," लाल ", 0x00FF00, 16711935

NSColorParser.nsColor("#FF0000",1)//red nsColor
NSColorParser.nsColor("FF0",1)//red nsColor
NSColorParser.nsColor("0xFF0000",1)//red nsColor
NSColorParser.nsColor("#FF0000",1)//red nsColor
NSColorParser.nsColor("FF0000",1)//red nsColor
NSColorParser.nsColor(0xFF0000,1)//red nsColor
NSColorParser.nsColor(16711935,1)//red nsColor

चेतावनी: यह "वन-फाइल-सॉल्यूशन" नहीं है, कुछ निर्भरताएं हैं, लेकिन इन्हें नीचे से खंगालना इस पर शोध करने से तेज हो सकता है।

https://github.com/eonist/swift-utils/blob/2882002682c4d2a3dc7cb3045c45f66ed59d566d/geom/color/NSColorParser.swift

पर्मलिंक:
https://github.com/eonist/Element/wiki/Progress#supporting-7-hex-color-types

Answer 24

स्विफ्ट 2.0

नीचे कोड xcode 7.2 पर परीक्षण किया गया है

import UIKit
extension UIColor{

    public convenience init?(colorCodeInHex: String, alpha: Float = 1.0){

        var filterColorCode:String =  colorCodeInHex.stringByReplacingOccurrencesOfString("#", withString: "")

        if  filterColorCode.characters.count != 6 {
            self.init(red: 0.0, green: 0.0, blue: 0.0, alpha: CGFloat(alpha))
            return
        }

        filterColorCode = filterColorCode.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).uppercaseString

        var range = Range(start: filterColorCode.startIndex.advancedBy(0), end: filterColorCode.startIndex.advancedBy(2))
        let rString = filterColorCode.substringWithRange(range)

        range = Range(start: filterColorCode.startIndex.advancedBy(2), end: filterColorCode.startIndex.advancedBy(4))
        let gString = filterColorCode.substringWithRange(range)


        range = Range(start: filterColorCode.startIndex.advancedBy(4), end: filterColorCode.startIndex.advancedBy(6))
        let bString = filterColorCode.substringWithRange(range)

        var r:CUnsignedInt = 0, g:CUnsignedInt = 0, b:CUnsignedInt = 0;
        NSScanner(string: rString).scanHexInt(&r)
        NSScanner(string: gString).scanHexInt(&g)
        NSScanner(string: bString).scanHexInt(&b)


        self.init(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: CGFloat(alpha))
        return
    }
}

Answer 25

स्विफ्ट 2.0:

UIColor का विस्तार करें।

extension UIColor {
    convenience init(hexString:String) {
        let hexString:NSString = hexString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())
        let scanner            = NSScanner(string: hexString as String)
        if (hexString.hasPrefix("#")) {
            scanner.scanLocation = 1
        }

        var color:UInt32 = 0
        scanner.scanHexInt(&color)

        let mask = 0x000000FF
        let r = Int(color >> 16) & mask
        let g = Int(color >> 8) & mask
        let b = Int(color) & mask

        let red   = CGFloat(r) / 255.0
        let green = CGFloat(g) / 255.0
        let blue  = CGFloat(b) / 255.0
        self.init(red:red, green:green, blue:blue, alpha:1)
    }

    func toHexString() -> String {
        var r:CGFloat = 0
        var g:CGFloat = 0
        var b:CGFloat = 0
        var a:CGFloat = 0
        getRed(&r, green: &g, blue: &b, alpha: &a)
        let rgb:Int = (Int)(r*255)<<16 | (Int)(g*255)<<8 | (Int)(b*255)<<0
        return NSString(format:"#%06x", rgb) as String
    }

}

उपयोग:

//Hex to Color
    let countPartColor =  UIColor(hexString: "E43038")

//Color to Hex
let colorHexString =  UIColor(red: 228, green: 48, blue: 56, alpha: 1.0).toHexString()

Comments

कृपया डुप्लिकेट उत्तर पोस्ट करने से बचें । यदि कोई प्रश्न डुप्लिकेट है, तो उसे उत्तर देने के बजाय इस तरह से फ़्लैग करें। धन्यवाद।

— एरिक आया

Answer 26

स्विफ्ट 3 के लिए

extension String {
    var hexColor: UIColor {        
        let hex = trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
        var int = UInt32()       
        Scanner(string: hex).scanHexInt32(&int)
        let a, r, g, b: UInt32
        switch hex.characters.count {
        case 3: // RGB (12-bit)
            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6: // RGB (24-bit)
            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
        case 8: // ARGB (32-bit)
            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
        default:
            return .clear
        }
        return UIColor(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
    }
}

Answer 27

आप इस एक्सटेंशन का उपयोग UIColor पर कर सकते हैं जो Your String (Hexadecimal, RGBA) को UIColor और इसके विपरीत में परिवर्तित करता है।

extension UIColor {

  //Convert RGBA String to UIColor object
  //"rgbaString" must be separated by space "0.5 0.6 0.7 1.0" 50% of Red 60% of Green 70% of Blue Alpha 100%
  public convenience init?(rgbaString : String){
      self.init(ciColor: CIColor(string: rgbaString))
  }

  //Convert UIColor to RGBA String
  func toRGBAString()-> String {
    var r: CGFloat = 0
    var g: CGFloat = 0
    var b: CGFloat = 0
    var a: CGFloat = 0
    self.getRed(&r, green: &g, blue: &b, alpha: &a)
    return "\(r) \(g) \(b) \(a)"
  }

  //return UIColor from Hexadecimal Color string
  public convenience init?(hexString: String) {  
    let r, g, b, a: CGFloat

    if hexString.hasPrefix("#") {
      let start = hexString.index(hexString.startIndex, offsetBy: 1)
      let hexColor = hexString.substring(from: start)

      if hexColor.characters.count == 8 {
        let scanner = Scanner(string: hexColor)
        var hexNumber: UInt64 = 0

        if scanner.scanHexInt64(&hexNumber) {
          r = CGFloat((hexNumber & 0xff000000) >> 24) / 255
          g = CGFloat((hexNumber & 0x00ff0000) >> 16) / 255
          b = CGFloat((hexNumber & 0x0000ff00) >> 8) / 255
          a = CGFloat(hexNumber & 0x000000ff) / 255
          self.init(red: r, green: g, blue: b, alpha: a)
          return
        }
      }
    }

    return nil
  }

  // Convert UIColor to Hexadecimal String
  func toHexString() -> String {
    var r: CGFloat = 0
    var g: CGFloat = 0
    var b: CGFloat = 0
    var a: CGFloat = 0
    self.getRed(&r, green: &g, blue: &b, alpha: &a)
    return String(
        format: "%02X%02X%02X",
        Int(r * 0xff),
        Int(g * 0xff),
        Int(b * 0xff))
  }
}

Comments

अल्फा को toHexString ()

— Womble

Answer 28

UIColor विस्तार, यह आपकी बहुत मदद करेगा! (संस्करण ：स्विफ्ट 4.0 )

import UIKit
extension UIColor {
/// rgb颜色
convenience init(r: CGFloat, g: CGFloat, b: CGFloat) {
    self.init(red: r/255.0 ,green: g/255.0 ,blue: b/255.0 ,alpha:1.0)
}

/// 纯色（用于灰色）
convenience init(gray: CGFloat) {
    self.init(red: gray/255.0 ,green: gray/255.0 ,blue: gray/255.0 ,alpha:1.0)
}
/// 随机色
class func randomCGColor() -> UIColor {
    return UIColor(r: CGFloat(arc4random_uniform(256)), g: CGFloat(arc4random_uniform(256)), b: CGFloat(arc4random_uniform(256)))
}

/// hex颜色-Int
convenience init(hex:Int, alpha:CGFloat = 1.0) {
    self.init(
        red:   CGFloat((hex & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((hex & 0x00FF00) >> 8)  / 255.0,
        blue:  CGFloat((hex & 0x0000FF) >> 0)  / 255.0,
        alpha: alpha
    )
}
/// hex颜色-String
convenience init(hexString: String){
    var red:   CGFloat = 0.0
    var green: CGFloat = 0.0
    var blue:  CGFloat = 0.0
    var alpha: CGFloat = 1.0
    let scanner = Scanner(string: hexString)
    var hexValue: CUnsignedLongLong = 0
    if scanner.scanHexInt64(&hexValue) {
        switch (hexString.characters.count) {
        case 3:
            red   = CGFloat((hexValue & 0xF00) >> 8)       / 15.0
            green = CGFloat((hexValue & 0x0F0) >> 4)       / 15.0
            blue  = CGFloat(hexValue & 0x00F)              / 15.0
        case 4:
            red   = CGFloat((hexValue & 0xF000) >> 12)     / 15.0
            green = CGFloat((hexValue & 0x0F00) >> 8)      / 15.0
            blue  = CGFloat((hexValue & 0x00F0) >> 4)      / 15.0
            alpha = CGFloat(hexValue & 0x000F)             / 15.0
        case 6:
            red   = CGFloat((hexValue & 0xFF0000) >> 16)   / 255.0
            green = CGFloat((hexValue & 0x00FF00) >> 8)    / 255.0
            blue  = CGFloat(hexValue & 0x0000FF)           / 255.0
        case 8:
            alpha = CGFloat((hexValue & 0xFF000000) >> 24) / 255.0
            red   = CGFloat((hexValue & 0x00FF0000) >> 16) / 255.0
            green = CGFloat((hexValue & 0x0000FF00) >> 8)  / 255.0
            blue  = CGFloat(hexValue & 0x000000FF)         / 255.0
        default:
            log.info("Invalid RGB string, number of characters after '#' should be either 3, 4, 6 or 8")
        }
    } else {
        log.error("Scan hex error")
    }
    self.init(red:red, green:green, blue:blue, alpha:alpha)
}}

Comments

पिछले उत्तरों का सिर्फ एक संयोजन।

— सुल्तान

Answer 29

RGBA संस्करण स्विफ्ट 3/4

मुझे @ लुका का जवाब पसंद है क्योंकि मुझे लगता है कि यह सबसे सुरुचिपूर्ण है।

हालाँकि मैं नहीं चाहता कि मेरे रंग ARGB में निर्दिष्ट हों। मैं बल्कि RGBA + मैं भी तार के साथ काम करने के मामले में हैक करने की जरूरत है कि " #FFFA "चैनलों में से प्रत्येक के लिए 1 चरित्र निर्दिष्ट करें।

यदि यह स्ट्रिंग में शामिल है, तो यह संस्करण '#' वर्ण को फेंकने में त्रुटि भी जोड़ता है। यहाँ स्विफ्ट के लिए मेरा संशोधित रूप है।

public enum ColourParsingError: Error
{

    case invalidInput(String)
}
extension UIColor {
    public convenience init(hexString: String) throws
    {
        let hexString = hexString.replacingOccurrences(of: "#", with: "")
        let hex = hexString.trimmingCharacters(in:NSCharacterSet.alphanumerics.inverted)
        var int = UInt32()
        Scanner(string: hex).scanHexInt32(&int)
        let a, r, g, b: UInt32
        switch hex.count 
        {
        case 3: // RGB (12-bit)
            (r, g, b,a) = ((int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17,255)
        //iCSS specification in the form of #F0FA
        case 4: // RGB (24-bit)
            (r, g, b,a) = ((int >> 12) * 17, (int >> 8 & 0xF) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6: // RGB (24-bit)
            (r, g, b, a) = (int >> 16, int >> 8 & 0xFF, int & 0xFF,255)
        case 8: // ARGB (32-bit)
            (r, g, b, a) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
        default:
            throw ColourParsingError.invalidInput("String is not a valid hex colour string: \(hexString)")
        }
        self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
    }
}

Answer 30

extension UIColor {
    public convenience init?(hex: String) {
        let r, g, b, a: CGFloat

        if hex.hasPrefix("#") {
            let start = hex.index(hex.startIndex, offsetBy: 1)
            let hexColor = String(hex[start...])

            if hexColor.count == 8 {
                let scanner = Scanner(string: hexColor)
                var hexNumber: UInt64 = 0

                if scanner.scanHexInt64(&hexNumber) {
                    r = CGFloat((hexNumber & 0xff000000) >> 24) / 255
                    g = CGFloat((hexNumber & 0x00ff0000) >> 16) / 255
                    b = CGFloat((hexNumber & 0x0000ff00) >> 8) / 255
                    a = CGFloat(hexNumber & 0x000000ff) / 255

                    self.init(red: r, green: g, blue: b, alpha: a)
                    return
                }
            }
        }

        return nil
    }
}

उपयोग:

let white = UIColor(hex: "#ffffff")