मैं हेक्स स्ट्रिंग से UIColor कैसे बना सकता हूं?


543

मैं हेक्साडेसिमल स्ट्रिंग प्रारूप UIColorसे कैसे बना सकता हूं , जैसे कि ?#00FF00



जवाबों:


722

मैंने ऐसा करने का सबसे सरल तरीका ढूंढ लिया है। बस इसे अपने हेडर में शामिल करें और यह आपके पूरे प्रोजेक्ट में उपलब्ध है।

#define UIColorFromRGB(rgbValue) [UIColor colorWithRed:((float)((rgbValue & 0xFF0000) >> 16))/255.0 green:((float)((rgbValue & 0xFF00) >> 8))/255.0 blue:((float)(rgbValue & 0xFF))/255.0 alpha:1.0]

हेक्स मूल्यों के साथ यूरिकोर मैक्रो

इस कोड का स्वरूपित संस्करण:

#define UIColorFromRGB(rgbValue) \
[UIColor colorWithRed:((float)((rgbValue & 0xFF0000) >> 16))/255.0 \
                green:((float)((rgbValue & 0x00FF00) >>  8))/255.0 \
                 blue:((float)((rgbValue & 0x0000FF) >>  0))/255.0 \
                alpha:1.0]

उपयोग:

label.textColor = UIColorFromRGB(0xBC1128);

130
यह बहुत अच्छा है, क्योंकि यह वह नहीं करता है जो प्रश्नकर्ता पूछता है, जो एक हेक्स STRING को UIColor में परिवर्तित करना है। यह एक पूर्णांक को एक UIColor में परिवर्तित करता है।
darrinm

31
@ MohamedA.Karim यह एक हेक्स प्रारूप पूर्णांक (0x ...) से एक UIColor लौटने का एक उदाहरण है, न कि एक हेक्स प्रारूप स्ट्रिंग ("# ...")। यदि आप चाहते हैं तो बढ़िया है, लेकिन प्रश्नकर्ता ने जो नहीं पूछा।
darrinm

3
@ScottKohlert कोड की आपकी रेखा एक हेक्स प्रारूप स्ट्रिंग ("#" के साथ पूर्वनिर्मित ") को एक और हेक्स प्रारूप स्ट्रिंग (" 0x "के साथ उपसर्ग) में रूपांतरित करती है। यह एक पूर्णांक का उत्पादन नहीं करता है।
darrinm

1
इस तरह का उपयोग कैसे करें [UIColor whiteColor] .CGColor?
SleepNot

3
इस मैक्रो के साथ उपयोग के लिए एक हेक्स प्रारूप स्ट्रिंग को पूर्णांक में बदलने के लिए, stackoverflow.com/questions/3648411/… देखें ।
devios1

371

संक्षिप्त समाधान:

// Assumes input like "#00FF00" (#RRGGBB).
+ (UIColor *)colorFromHexString:(NSString *)hexString {
    unsigned rgbValue = 0;
    NSScanner *scanner = [NSScanner scannerWithString:hexString];
    [scanner setScanLocation:1]; // bypass '#' character
    [scanner scanHexInt:&rgbValue];
    return [UIColor colorWithRed:((rgbValue & 0xFF0000) >> 16)/255.0 green:((rgbValue & 0xFF00) >> 8)/255.0 blue:(rgbValue & 0xFF)/255.0 alpha:1.0];
}

1
और रिवर्स रूपांतरण करने के लिए एक अच्छी विधि (जैसे कि यदि आप कोर डेटा / रिमोट डेटाबेस में रंग जमा कर रहे हैं) यहां पाया जा सकता है - stackoverflow.com/questions/11884227/…
एरिक गोल्डबर्ग

1
एक सही समाधान। यदि आपका हेक्स स्ट्रिंग एपीआई (बहुत खराब दस्तावेज) एपीआई से आता है, तो #FFF या # FC0 जैसे शॉर्टहैंड हेक्स कोड के खिलाफ परीक्षण करना सुनिश्चित करें। आपको उन्हें # FFFFFF / # FFCCOO में बदलने की आवश्यकता होगी।
पैट्रिक

10
आप वैकल्पिक बनाने के if ( [hexString rangeOfString:@"#"].location == 0 )लिए setScanLocationलाइन से पहले जोड़ना चाह सकते हैं #
devios1

क्या आप कृपया रिवर्स मेथड जोड़ सकते हैं।
हसन

11
आलसी के लिए: यहाँ स्विफ्ट संस्करण ।
fabian789

188

मुझे एक समाधान मिला है जो एंड्रॉइड द्वारा उपयोग किए जाने वाले हेक्स प्रारूप के तारों के साथ 100% संगत है, जिसे मैंने क्रॉस-प्लेटफॉर्म मोबाइल विकास करते समय बहुत उपयोगी पाया। यह मुझे दोनों प्लेटफार्मों के लिए एक रंग तालू का उपयोग करने देता है। यदि आप चाहें तो बिना किसी कारण के या अपाचे लाइसेंस के तहत पुन: उपयोग करने के लिए स्वतंत्र महसूस करें।

#import "UIColor+HexString.h"

@interface UIColor(HexString)

+ (UIColor *) colorWithHexString: (NSString *) hexString;
+ (CGFloat) colorComponentFrom: (NSString *) string start: (NSUInteger) start length: (NSUInteger) length;

@end


@implementation UIColor(HexString)

+ (UIColor *) colorWithHexString: (NSString *) hexString {
    NSString *colorString = [[hexString stringByReplacingOccurrencesOfString: @"#" withString: @""] uppercaseString];
    CGFloat alpha, red, blue, green;
    switch ([colorString length]) {
        case 3: // #RGB
            alpha = 1.0f;
            red   = [self colorComponentFrom: colorString start: 0 length: 1];
            green = [self colorComponentFrom: colorString start: 1 length: 1];
            blue  = [self colorComponentFrom: colorString start: 2 length: 1];
            break;
        case 4: // #ARGB
            alpha = [self colorComponentFrom: colorString start: 0 length: 1];
            red   = [self colorComponentFrom: colorString start: 1 length: 1];
            green = [self colorComponentFrom: colorString start: 2 length: 1];
            blue  = [self colorComponentFrom: colorString start: 3 length: 1];          
            break;
        case 6: // #RRGGBB
            alpha = 1.0f;
            red   = [self colorComponentFrom: colorString start: 0 length: 2];
            green = [self colorComponentFrom: colorString start: 2 length: 2];
            blue  = [self colorComponentFrom: colorString start: 4 length: 2];                      
            break;
        case 8: // #AARRGGBB
            alpha = [self colorComponentFrom: colorString start: 0 length: 2];
            red   = [self colorComponentFrom: colorString start: 2 length: 2];
            green = [self colorComponentFrom: colorString start: 4 length: 2];
            blue  = [self colorComponentFrom: colorString start: 6 length: 2];                      
            break;
        default:
            [NSException raise:@"Invalid color value" format: @"Color value %@ is invalid.  It should be a hex value of the form #RBG, #ARGB, #RRGGBB, or #AARRGGBB", hexString];
            break;
    }
    return [UIColor colorWithRed: red green: green blue: blue alpha: alpha];
}

+ (CGFloat) colorComponentFrom: (NSString *) string start: (NSUInteger) start length: (NSUInteger) length {
    NSString *substring = [string substringWithRange: NSMakeRange(start, length)];
    NSString *fullHex = length == 2 ? substring : [NSString stringWithFormat: @"%@%@", substring, substring];
    unsigned hexComponent;
    [[NSScanner scannerWithString: fullHex] scanHexInt: &hexComponent];
    return hexComponent / 255.0;
}

@end 

3
में colorComponentFrom:start:length:, तुम्हारे पास नहीं होना चाहिए return hexComponent / 0xFF; // divide by 255, not 256? सबसे बड़ी हेक्स वैल्यू जो आपको वापस मिलनी चाहिए, वह है 0xFF, इस प्रकार आपको 0xFF (255) से विभाजित किया जाना चाहिए।
सैम

अच्छा कैच सैम। परिवर्तन को प्रतिबिंबित करने के लिए संपादित किया गया।
मीका हैनलाइन

6
यह महान है, चियर्स। इसके अलावा, UIColor पर एक श्रेणी के बजाय आप NSString पर एक वाक्यविन्यास करने में सक्षम होने के लिए कर सकते हैं जैसे[@"#538aa4" toColor]
Dan2552

2
यह समाधान बहुत अच्छा है, मैं संकलक चेतावनी से बचने के लिए निजी इंटरफ़ेस के नाम के लिए "निजी" जोड़ने का सुझाव दूंगा। @interface UIColor (निजी)
djleop

1
अच्छा लगा। आपको दूसरे फ़ंक्शन को इंटरफ़ेस में रखना चाहिए , हालांकि।
ब्योर्न रोच

63

UIColorहेक्स स्ट्रिंग से निकालने के ओपी के सवाल से निपटने के तरीके पर एक अच्छी पोस्ट है । नीचे प्रस्तुत समाधान दूसरों से अलग है क्योंकि यह स्ट्रिंग मानों का समर्थन करता है जिसमें '0x' या '#' हेक्स स्ट्रिंग प्रतिनिधित्व के लिए उपसर्ग शामिल हो सकते हैं ... (उपयोग देखें)

यहाँ मुख्य बिट है ...

- (UIColor *)getUIColorObjectFromHexString:(NSString *)hexStr alpha:(CGFloat)alpha
{
  // Convert hex string to an integer
  unsigned int hexint = [self intFromHexString:hexStr];

  // Create a color object, specifying alpha as well
  UIColor *color =
    [UIColor colorWithRed:((CGFloat) ((hexint & 0xFF0000) >> 16))/255
    green:((CGFloat) ((hexint & 0xFF00) >> 8))/255
    blue:((CGFloat) (hexint & 0xFF))/255
    alpha:alpha];

  return color;
}

सहायक विधि ...

- (unsigned int)intFromHexString:(NSString *)hexStr
{
  unsigned int hexInt = 0;

  // Create scanner
  NSScanner *scanner = [NSScanner scannerWithString:hexStr];

  // Tell scanner to skip the # character
  [scanner setCharactersToBeSkipped:[NSCharacterSet characterSetWithCharactersInString:@"#"]];

  // Scan hex value
  [scanner scanHexInt:&hexInt];

  return hexInt;
}

उपयोग:

NSString *hexStr1 = @"123ABC";
NSString *hexStr2 = @"#123ABC";
NSString *hexStr3 = @"0x123ABC";

UIColor *color1 = [self getUIColorObjectFromHexString:hexStr1 alpha:.9];
NSLog(@"UIColor: %@", color1);

UIColor *color2 = [self getUIColorObjectFromHexString:hexStr2 alpha:.9];
NSLog(@"UIColor: %@", color2);

UIColor *color3 = [self getUIColorObjectFromHexString:hexStr3 alpha:.9];
NSLog(@"UIColor: %@", color3);

पूरा संदर्भ लेख

स्विफ्ट 2+

मैंने इस समाधान को स्विफ्ट 2.2 में पोर्ट किया है। ध्यान दें कि मैंने alphaडिफ़ॉल्ट सेट का उपयोग करने के लिए पैरामीटर को 1.0 में बदल दिया है । मैं भी करने के लिए पूर्णांक प्रकार नवीनीकृत किया है UInt32के रूप में के लिए आवश्यक NSScannerस्विफ्ट 2.2 में वर्ग।

func colorWithHexString(hexString: String, alpha:CGFloat = 1.0) -> UIColor {

    // Convert hex string to an integer
    let hexint = Int(self.intFromHexString(hexString))
    let red = CGFloat((hexint & 0xff0000) >> 16) / 255.0
    let green = CGFloat((hexint & 0xff00) >> 8) / 255.0
    let blue = CGFloat((hexint & 0xff) >> 0) / 255.0 

    // Create color object, specifying alpha as well
    let color = UIColor(red: red, green: green, blue: blue, alpha: alpha)
    return color
}

func intFromHexString(hexStr: String) -> UInt32 {
    var hexInt: UInt32 = 0
    // Create scanner
    let scanner: NSScanner = NSScanner(string: hexStr)
    // Tell scanner to skip the # character
    scanner.charactersToBeSkipped = NSCharacterSet(charactersInString: "#")
    // Scan hex value
    scanner.scanHexInt(&hexInt)
    return hexInt
}

स्विफ्ट 4+

स्विफ्ट 4 के लिए लागू परिवर्तनों के साथ एक ही तर्क का उपयोग करना,

func colorWithHexString(hexString: String, alpha:CGFloat = 1.0) -> UIColor {

    // Convert hex string to an integer
    let hexint = Int(self.intFromHexString(hexStr: hexString))
    let red = CGFloat((hexint & 0xff0000) >> 16) / 255.0
    let green = CGFloat((hexint & 0xff00) >> 8) / 255.0
    let blue = CGFloat((hexint & 0xff) >> 0) / 255.0

    // Create color object, specifying alpha as well
    let color = UIColor(red: red, green: green, blue: blue, alpha: alpha)
    return color
}

func intFromHexString(hexStr: String) -> UInt32 {
    var hexInt: UInt32 = 0
    // Create scanner
    let scanner: Scanner = Scanner(string: hexStr)
    // Tell scanner to skip the # character
    scanner.charactersToBeSkipped = CharacterSet(charactersIn: "#")
    // Scan hex value
    scanner.scanHexInt32(&hexInt)
    return hexInt
}

रंग हेक्स संदर्भ

HTML रंग के नाम और कोड

रंग हेक्स रंग कोड


यहाँ पोस्ट किए गए स्विफ्ट स्निपेट्स स्विफ्ट में वैकल्पिक के उद्देश्य को गलत समझते हैं, जिसमें उन मूल्यों को शामिल करना है जो कभी मौजूद नहीं हो सकते हैं। यह सवाल पूछने के लिए कि क्या किसी पैरामीटर को वैकल्पिक होने की आवश्यकता है, क्या किसी को इसे शून्य पर सेट करने की क्षमता की आवश्यकता हो सकती है। यह संभवतः के लिए कोई मतलब है alphaकरने के लिए कभी नहीं के बराबर करने के लिए सेट किया जा? क्योंकि यह विधि लोगों को वह क्षमता प्रदान करती है, और अगर किसी alphaको शून्य पर सेट करने का निर्णय लेना चाहिए , तो उस वैकल्पिक के जबरन अपरिवर्तनीय रूप से दुर्घटना का कारण बन जाएगा। मैंने इसे संपादित नहीं किया है, हालाँकि, इस मामले में कुछ औचित्य है, जिसकी मुझे जानकारी नहीं है।
जोनाथन थॉर्नटन

@JonathanThornton - सिर के लिए धन्यवाद। संकल्प लिया।
टॉमी सी।

एक विरासत परियोजना पर काम करना और वस्तुनिष्ठ-सी समाधान बहुत अच्छी तरह से काम करता है ... को छोड़कर ... अजीब तरह से ... @ "# ffc107" और @ "# e040fb" सहयोग करने से इनकार करते हैं! विचार?
नथानिएल

51

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

उपयोग:

var color1 = hexStringToUIColor("#d3d3d3")

स्विफ्ट 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: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)
    )
}

स्विफ्ट 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


मैंने एसवीजी में देखा है, जहां # F0F जैसे 3 वर्णों के साथ हेक्स स्ट्रिंग का एक छोटा संस्करण है।
ग्लेन होव्स

वह शॉर्टहैंड नोटेशन है, जहां '# F0F' '# FF00FF' के बराबर है। एक फ़ंक्शन लिखना सरल होगा, जिसने शॉर्टहैंड के लिए जाँच की और इसे विस्तारित किया।
एथन स्ट्राइडर

38

इस श्रेणी का उपयोग करें:

फ़ाइल में UIColor + Hexadecimal.h

#import <UIKit/UIKit.h>

@interface UIColor(Hexadecimal)

+ (UIColor *)colorWithHexString:(NSString *)hexString;

@end

फ़ाइल UIColor + Hexadecimal.m में

#import "UIColor+Hexadecimal.h"

@implementation UIColor(Hexadecimal)

+ (UIColor *)colorWithHexString:(NSString *)hexString {
    unsigned rgbValue = 0;
    NSScanner *scanner = [NSScanner scannerWithString:hexString];
    [scanner setScanLocation:1]; // bypass '#' character
    [scanner scanHexInt:&rgbValue];

    return [UIColor colorWithRed:((rgbValue & 0xFF0000) >> 16)/255.0 green:((rgbValue & 0xFF00) >> 8)/255.0 blue:(rgbValue & 0xFF)/255.0 alpha:1.0];
}

@end

कक्षा में आप इसका उपयोग करना चाहते हैं:

#import "UIColor+Hexadecimal.h"

तथा:

[UIColor colorWithHexString:@"#6e4b4b"];

कोई अल्फा हैंडलिंग
इहोर क्लिमोव

28

एक्सटेंशन का उपयोग करके एक महान स्विफ्ट कार्यान्वयन (Xcode 7 के लिए अपडेट किया गया), विभिन्न उत्तर और स्थानों से एक साथ खींचा गया। आपको अंत में स्ट्रिंग एक्सटेंशन की भी आवश्यकता होगी।

उपयोग:

let hexColor = UIColor(hex: "#00FF00")

नोट: मैं एक अल्फा चैनल के लिए मानक 6 अंकीय हेक्स मान के अंत में 2 अतिरिक्त अंक के लिए एक विकल्प जोड़ा (के मान पास 00- 99)। यदि यह आपको नाराज करता है, तो इसे हटा दें। आप इसे वैकल्पिक अल्फ़ा पैरामीटर में पास करने के लिए कार्यान्वित कर सकते हैं।

एक्सटेंशन:

extension UIColor {

    convenience init(var hex: String) {
        var alpha: Float = 100
        let hexLength = hex.characters.count
        if !(hexLength == 7 || hexLength == 9) {
            // A hex must be either 7 or 9 characters (#RRGGBBAA)
            print("improper call to 'colorFromHex', hex length must be 7 or 9 chars (#GGRRBBAA)")
            self.init(white: 0, alpha: 1)
            return
        }

        if hexLength == 9 {
            // Note: this uses String subscripts as given below
            alpha = hex[7...8].floatValue
            hex = hex[0...6]
        }

        // Establishing the rgb color
        var rgb: UInt32 = 0
        let s: NSScanner = NSScanner(string: hex)
        // Setting the scan location to ignore the leading `#`
        s.scanLocation = 1
        // Scanning the int into the rgb colors
        s.scanHexInt(&rgb)

        // Creating the UIColor from hex int
        self.init(
            red: CGFloat((rgb & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgb & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgb & 0x0000FF) / 255.0,
            alpha: CGFloat(alpha / 100)
        )
    }
}

स्ट्रिंग एक्सटेंशन:
फ्लोट स्रोत
सदस्यता स्रोत

extension String {

    /**
    Returns the float value of a string
    */
    var floatValue: Float {
        return (self as NSString).floatValue
    }

    /**
    Subscript to allow for quick String substrings ["Hello"][0...1] = "He"
    */
    subscript (r: Range<Int>) -> String {
        get {
            let start = self.startIndex.advancedBy(r.startIndex)
            let end = self.startIndex.advancedBy(r.endIndex - 1)
            return self.substringWithRange(start..<end)
        }
    }
}

क्या आप इसकी सबस्क्रिप्ट प्राप्त करने के लिए स्ट्रिंग एक्सटेंशन का भी उपयोग कर रहे हैं? उदाहरण के लिए stackoverflow.com/a/24144365/3220708
क्रेग ग्रुमिट

@CraigGrummitt ओह माय! हा - हा हाँ। मेरे पास एक्सटेंशन की एक संकलित सूची है और मैं कभी-कभी (उदासी से) भूल जाता हूं कि मानक भाषा सुविधा सेट में क्या है और क्या शामिल नहीं है। आपके द्वारा दिए गए स्रोत सहित मैंने अपना उत्तर अपडेट किया। यकीन नहीं होता तो मुझे भी वहीं से मिल जाएगा लेकिन यकीन है कि यह करीब है।
फिराओ

आप यह उल्लेख करना चाहते हैं कि यह एक स्ट्रिंग एक्सटेंशन है। इसके अलावा, आपको लगता है कि स्ट्रिंग फ़्लोटव्यू एक्सटेंशन छूट गया है: stackoverflow.com/a/24088249/3220708 इसके अलावा, अच्छा काम!
क्रेग ग्रुमिट

कहाँ की गणना है?
15 Г И О И О

countElements()count()स्विफ्ट 1.2 के साथ बदल दिया गया था , इसे भाषा में बनाया गया है। मैंने अपने उत्तर को प्रतिबिंबित करने के लिए अद्यतन किया।
फ़िरो

27

आप इस तरह से एक्सटेंशन कर सकते हैं

extension UIColor{
    convenience init(rgb: UInt, alphaVal: CGFloat) {
        self.init(
            red: CGFloat((rgb & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgb & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgb & 0x0000FF) / 255.0,
            alpha: alphaVal
        )
    }
}

और इसे इस तरह से कहीं भी इस्तेमाल कर सकते हैं

UIColor(rgb: 0xffffff, alphaVal: 0.2)

मृत सरल, निश्चित रूप से मेरा पसंदीदा।
सिद्धांत

धन्यवाद, यह एक महान है, इसलिए पाठ की अन्य दीवारों की तुलना में संक्षिप्त है!
फ्रैंकबाइट.कॉम

अच्छा कार्य लेकिन यह किसी भी तरह से सवाल का जवाब नहीं देता है।
महापर्व

@ mah यह ठीक वही सवाल है जो मुझे लगता है, हेक्सस्ट्रिंग से एक UIColor बनाने के लिए कैसे
मनु गुप्ता

@ मनुगुप्त आपको इस उत्तर में किसी भी स्ट्रिंग हैंडलिंग की पूरी कमी दिख सकती है। एक हेक्स संख्या एक हेक्स स्ट्रिंग नहीं है। यह प्रश्न स्पष्ट रूप से एक स्ट्रिंग बताता है और हालांकि इसमें उद्धरण नहीं हैं, #00FF00स्पष्ट रूप से एक चरित्र स्ट्रिंग होने का इरादा है। जैसा कि दूसरों ने कहा है कि यह सरल है, संक्षिप्त है। लेकिन अगर यह तार के साथ सौदा नहीं करता है, तो यह संभवतः एक सवाल का जवाब नहीं दे सकता है कि तार से कैसे निपटना है।
महा

26

हेक्साडेसिमल स्ट्रिंग से UIColor(या CGColor) जो मुझे पता है, उससे कोई अंतर्निहित रूपांतरण नहीं है। हालांकि, आप इस उद्देश्य के लिए आसानी से एक-दो कार्य लिख सकते हैं - उदाहरण के लिए, iPhone विकास को यूरिकोल घटकों तक पहुंचते हुए देखें


3
+1 यदि आप नीचे स्क्रॉल करते हैं, तो सवाल में विधि + colorWithHexString है:।
रोब नेपियर

1
@RobNapier +colorWithHexString:काम नहीं करता है। कम से कम मेरे मामले में। :)
पवन

15

मुझे इसके लिए एक अच्छी UIColorश्रेणी मिली , UIColor + PXExtensions

उपयोग: UIColor *mycolor = [UIColor pxColorWithHexValue:@"#BADA55"];

और, अगर मेरे जिस्ट की लिंक विफल हो जाती है, तो यहां वास्तविक कार्यान्वयन कोड है:

//
//  UIColor+PXExtensions.m
//

#import "UIColor+UIColor_PXExtensions.h"

@implementation UIColor (UIColor_PXExtensions)

+ (UIColor*)pxColorWithHexValue:(NSString*)hexValue
{
    //Default
    UIColor *defaultResult = [UIColor blackColor];

    //Strip prefixed # hash
    if ([hexValue hasPrefix:@"#"] && [hexValue length] > 1) {
        hexValue = [hexValue substringFromIndex:1];
    }

    //Determine if 3 or 6 digits
    NSUInteger componentLength = 0;
    if ([hexValue length] == 3)
    {
        componentLength = 1;
    }
    else if ([hexValue length] == 6)
    {
        componentLength = 2;
    }
    else
    {
        return defaultResult;
    }

    BOOL isValid = YES;
    CGFloat components[3];

    //Seperate the R,G,B values
    for (NSUInteger i = 0; i < 3; i++) {
        NSString *component = [hexValue substringWithRange:NSMakeRange(componentLength * i, componentLength)];
        if (componentLength == 1) {
            component = [component stringByAppendingString:component];
        }
        NSScanner *scanner = [NSScanner scannerWithString:component];
        unsigned int value;
        isValid &= [scanner scanHexInt:&value];
        components[i] = (CGFloat)value / 256.0f;
    }

    if (!isValid) {
        return defaultResult;
    }

    return [UIColor colorWithRed:components[0]
                           green:components[1]
                            blue:components[2]
                           alpha:1.0];
}

@end

@PeterDuniho ठीक है, मैंने कार्यान्वयन कोड :)
Hlung

13

स्विफ्ट संस्करण। फ़ंक्शन या एक्सटेंशन के रूप में उपयोग करें।

समारोह
  func UIColorFromRGB(colorCode: String, alpha: Float = 1.0) -> UIColor{
    var scanner = NSScanner(string:colorCode)
    var color:UInt32 = 0;
    scanner.scanHexInt(&color)

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

    return UIColor(red: r, green: g, blue: b, alpha: CGFloat(alpha))
}
एक्सटेंशन
extension UIColor {
    convenience init(colorCode: String, alpha: Float = 1.0){
        var scanner = NSScanner(string:colorCode)
        var color:UInt32 = 0;
        scanner.scanHexInt(&color)

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

        self.init(red: r, green: g, blue: b, alpha: CGFloat(alpha))
    }
}
कैसे कॉल करें
let hexColorFromFunction = UIColorFromRGB("F4C124", alpha: 1.0)
let hexColorFromExtension = UIColor(colorCode: "F4C124", alpha: 1.0)
आप Hex Colorइंटरफ़ेस बिल्डर से अपने परिभाषित भी कर सकते हैं ।

यहाँ छवि विवरण दर्ज करें


12

यह एक और विकल्प है।

- (UIColor *)colorWithRGBHex:(UInt32)hex
{
    int r = (hex >> 16) & 0xFF;
    int g = (hex >> 8) & 0xFF;
    int b = (hex) & 0xFF;

    return [UIColor colorWithRed:r / 255.0f
                           green:g / 255.0f
                            blue:b / 255.0f
                           alpha:1.0f];
}

वैकल्पिक प्रश्न का वैकल्पिक उत्तर ... हालांकि इस पृष्ठ पर प्रश्न का उचित उत्तर नहीं है।
महापर्व

11

HEX स्ट्रिंग को वास्तविक UIColor में बदलने के लिए आप विभिन्न ऑनलाइन टूल का उपयोग कर सकते हैं। की जाँच करें uicolor.org या यूआई रंग पिकर । आउटपुट को उद्देश्य-सी कोड में परिवर्तित किया जाएगा, जैसे:

[UIColor colorWithRed:0.93 green:0.80 blue:0.80 alpha:1.0];

जिसे आप अपने एप्लिकेशन में एम्बेड कर सकते हैं। उम्मीद है की यह मदद करेगा!


एक और ऑनलाइन टूल, वास्तव में एक ही नाम, यूआई कलर पिकर
जो

आम तौर पर जब लोग इस तरह की एक काफी सरल समस्या को हल करने के लिए कोड के साथ मदद मांगते हैं, तो एक जवाब जो कहता है "पहले कुछ ऑनलाइन साइट पर जाएं ..." वास्तव में वह उत्तर होने के करीब भी नहीं है जो पूछने वाला चाहता था।
महापर्व

11

स्विफ्ट 4

आप convenienceइस तरह से विस्तार में एक अच्छा निर्माता बना सकते हैं :

extension UIColor {
    convenience init(hexString: String, alpha: CGFloat = 1.0) {
        var hexInt: UInt32 = 0
        let scanner = Scanner(string: hexString)
        scanner.charactersToBeSkipped = CharacterSet(charactersIn: "#")
        scanner.scanHexInt32(&hexInt)

        let red = CGFloat((hexInt & 0xff0000) >> 16) / 255.0
        let green = CGFloat((hexInt & 0xff00) >> 8) / 255.0
        let blue = CGFloat((hexInt & 0xff) >> 0) / 255.0
        let alpha = alpha

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

और बाद में इसका उपयोग करें

let color = UIColor(hexString: "#AABBCCDD")

'ScanHexInt32' को iOS 13.0
कॉस्मो अरुण

10
extension UIColor {
    convenience init(hexaString: String, alpha: CGFloat = 1) {
        let chars = Array(hexaString.dropFirst())
        self.init(red:   .init(strtoul(String(chars[0...1]),nil,16))/255,
                  green: .init(strtoul(String(chars[2...3]),nil,16))/255,
                  blue:  .init(strtoul(String(chars[4...5]),nil,16))/255,
                  alpha: alpha)}
}

उपयोग:

let redColor       = UIColor(hexaString: "#FF0000")              // r 1,0 g 0,0 b 0,0 a 1,0
let transparentRed = UIColor(hexaString: "#FF0000", alpha: 0.5)  // r 1,0 g 0,0 b 0,0 a 0,5

7

यह कोकोपॉड सपोर्ट के साथ अच्छा है

https://github.com/mRs-/HexColors

// with hash
NSColor *colorWithHex = [NSColor colorWithHexString:@"#ff8942" alpha:1];

// wihtout hash
NSColor *secondColorWithHex = [NSColor colorWithHexString:@"ff8942" alpha:1];

// short handling
NSColor *shortColorWithHex = [NSColor colorWithHexString:@"fff" alpha:1]

सुंदर सामान ब्रो :)
सेसरफेरेरा

4

अल्फा के साथ एक और संस्करण

#define UIColorFromRGBA(rgbValue) [UIColor colorWithRed:((float)((rgbValue & 0xFF000000) >> 24))/255.0 green:((float)((rgbValue & 0xFF0000) >> 16))/255.0 blue:((float)((rgbValue & 0xFF00) >> 8 ))/255.0 alpha:((float)((rgbValue & 0xFF))/255.0)]

4

@ टॉम के जवाब के बराबर स्विफ्ट, हालांकि पारदर्शिता का समर्थन करने के लिए RGBA Int मूल्य प्राप्त करना:

func colorWithHex(aHex: UInt) -> UIColor
{
    return UIColor(red: CGFloat((aHex & 0xFF000000) >> 24) / 255,
        green: CGFloat((aHex & 0x00FF0000) >> 16) / 255,
        blue: CGFloat((aHex & 0x0000FF00) >> 8) / 255,
        alpha: CGFloat((aHex & 0x000000FF) >> 0) / 255)
}

//usage
var color = colorWithHex(0x7F00FFFF)

और यदि आप इसे स्ट्रिंग से उपयोग करने में सक्षम होना चाहते हैं तो आप स्ट्रैटोल का उपयोग कर सकते हैं:

var hexString = "0x7F00FFFF"

let num = strtoul(hexString, nil, 16)

var colorFromString = colorWithHex(num)

4

यहाँ एक Swift 1.2संस्करण को विस्तार के रूप में लिखा गया है UIColor। यह आपको करने की अनुमति देता है

let redColor = UIColor(hex: "#FF0000")

जो मुझे लगता है कि यह करने का सबसे स्वाभाविक तरीका है।

extension UIColor {
  // Initialiser for strings of format '#_RED_GREEN_BLUE_'
  convenience init(hex: String) {
    let redRange    = Range<String.Index>(start: hex.startIndex.advancedBy(1), end: hex.startIndex.advancedBy(3))
    let greenRange  = Range<String.Index>(start: hex.startIndex.advancedBy(3), end: hex.startIndex.advancedBy(5))
    let blueRange   = Range<String.Index>(start: hex.startIndex.advancedBy(5), end: hex.startIndex.advancedBy(7))

    var red     : UInt32 = 0
    var green   : UInt32 = 0
    var blue    : UInt32 = 0

    NSScanner(string: hex.substringWithRange(redRange)).scanHexInt(&red)
    NSScanner(string: hex.substringWithRange(greenRange)).scanHexInt(&green)
    NSScanner(string: hex.substringWithRange(blueRange)).scanHexInt(&blue)

    self.init(
      red: CGFloat(red) / 255,
      green: CGFloat(green) / 255,
      blue: CGFloat(blue) / 255,
      alpha: 1
    )
  }
}

Xcode 6.3.2 में उस लाइन पर जो let greenRange = ...मुझे एक अपवाद के साथ शुरू होती है:fatal error: can not increment endIndex
क्लिफ्टन लैब्रम

@CliftonLabrum मैंने Xcode 7 बीटा 3 पर इसका परीक्षण किया है, और यह समान काम करता है। क्या आप अभी भी इस मुद्दे पर हैं?
मॉर्गन वाइल्ड

3

एक और क्रियान्वयन जैसे स्ट्रिंग का उपयोग करना "FFF"या "FFFFFF"अल्फा की अनुमति देना:

+ (UIColor *) colorFromHexString:(NSString *)hexString alpha: (CGFloat)alpha{
    NSString *cleanString = [hexString stringByReplacingOccurrencesOfString:@"#" withString:@""];
    if([cleanString length] == 3) {
        cleanString = [NSString stringWithFormat:@"%@%@%@%@%@%@",
                       [cleanString substringWithRange:NSMakeRange(0, 1)],[cleanString substringWithRange:NSMakeRange(0, 1)],
                       [cleanString substringWithRange:NSMakeRange(1, 1)],[cleanString substringWithRange:NSMakeRange(1, 1)],
                       [cleanString substringWithRange:NSMakeRange(2, 1)],[cleanString substringWithRange:NSMakeRange(2, 1)]];
    }
    if([cleanString length] == 6) {
        cleanString = [cleanString stringByAppendingString:@"ff"];
    }

    unsigned int baseValue;
    [[NSScanner scannerWithString:cleanString] scanHexInt:&baseValue];

    float red = ((baseValue >> 24) & 0xFF)/255.0f;
    float green = ((baseValue >> 16) & 0xFF)/255.0f;
    float blue = ((baseValue >> 8) & 0xFF)/255.0f;

    return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
}

3

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

class func colorWithHexString (hex:String) -> UIColor {
    var cString: NSString = hex.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).uppercaseString

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

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

    var rString: String = cString.substringToIndex(2)
    var gString: String = (cString.substringFromIndex(2) as NSString).substringToIndex(2)
    var bString: String = (cString.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(Float(r) / 255.0), green: CGFloat(Float(g) / 255.0), blue: CGFloat(Float(b) / 255.0), alpha: CGFloat(1))

}

3

इसके लिए सुरुचिपूर्ण एक्सटेंशन बनाएं UIColor:

extension UIColor {

convenience init(string: String) {

        var uppercasedString = string.uppercased()
        uppercasedString.remove(at: string.startIndex)

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

        let red = CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0
        let green = CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0
        let blue = CGFloat(rgbValue & 0x0000FF) / 255.0

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

लाल रंग बनाएं:

let red = UIColor(string: "#ff0000") 

3
extension UIColor 
{
    class func fromHexaString(hex:String) -> UIColor
    {
        let scanner           = Scanner(string: hex)
        scanner.scanLocation  = 0
        var rgbValue: UInt64  = 0
        scanner.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)
        )
    }
}

//you can call like this.

UIColor.fromHexaString(hex:3276b1)

2
 You Can Get UIColor From String Code Like
   circularSpinner.fillColor = [self getUIColorObjectFromHexString:@"27b8c8" alpha:9];

 //Function For Hex Color Use
    - (unsigned int)intFromHexString:(NSString *)hexStr
    {
        unsigned int hexInt = 0;

        // Create scanner
        NSScanner *scanner = [NSScanner scannerWithString:hexStr];

        // Tell scanner to skip the # character
        [scanner setCharactersToBeSkipped:[NSCharacterSet characterSetWithCharactersInString:@"#"]];

        // Scan hex value
        [scanner scanHexInt:&hexInt];

        return hexInt;
    }




    - (UIColor *)getUIColorObjectFromHexString:(NSString *)hexStr alpha:(CGFloat)alpha
    {
        // Convert hex string to an integer
        unsigned int hexint = [self intFromHexString:hexStr];

        // Create color object, specifying alpha as well
        UIColor *color =
        [UIColor colorWithRed:((CGFloat) ((hexint & 0xFF0000) >> 16))/255
                        green:((CGFloat) ((hexint & 0xFF00) >> 8))/255
                         blue:((CGFloat) (hexint & 0xFF))/255
                        alpha:alpha];

        return color;
    }

    /Function For Hex Color Use
    - (unsigned int)intFromHexString:(NSString *)hexStr
    {
        unsigned int hexInt = 0;

        // Create scanner
        NSScanner *scanner = [NSScanner scannerWithString:hexStr];

        // Tell scanner to skip the # character
        [scanner setCharactersToBeSkipped:[NSCharacterSet characterSetWithCharactersInString:@"#"]];

        // Scan hex value
        [scanner scanHexInt:&hexInt];

        return hexInt;
    }




    - (UIColor *)getUIColorObjectFromHexString:(NSString *)hexStr alpha:(CGFloat)alpha
    {
        // Convert hex string to an integer
        unsigned int hexint = [self intFromHexString:hexStr];

        // Create color object, specifying alpha as well
        UIColor *color =
        [UIColor colorWithRed:((CGFloat) ((hexint & 0xFF0000) >> 16))/255
                        green:((CGFloat) ((hexint & 0xFF00) >> 8))/255
                         blue:((CGFloat) (hexint & 0xFF))/255
                        alpha:alpha];

        return color;
    }

यदि आप इस कोड का उपयोग करना चाहते हैं, तो यू कॉल [आत्म getUIColorObjectFromHexString: @ "27b8c8" अल्फा: 9]; केवल ....
मनीष सैनी

2

मुझे रंग के अलावा अल्फा सुनिश्चित करना पसंद है, इसलिए मैं अपनी श्रेणी लिखता हूं

+ (UIColor *) colorWithHex:(int)color {

    float red = (color & 0xff000000) >> 24;
    float green = (color & 0x00ff0000) >> 16;
    float blue = (color & 0x0000ff00) >> 8;
    float alpha = (color & 0x000000ff);

    return [UIColor colorWithRed:red/255.0 green:green/255.0 blue:blue/255.0 alpha:alpha/255.0];
}

इस तरह का उपयोग करने के लिए आसान है

[UIColor colorWithHex:0xFF0000FF]; //Red
[UIColor colorWithHex:0x00FF00FF]; //Green
[UIColor colorWithHex:0x00FF00FF]; //Blue
[UIColor colorWithHex:0x0000007F]; //transparent black

2

मैंने उसके लिए एक सुविधा init बनाया:

extension UIColor {
convenience init(hex: String, alpha: CGFloat)
{
    let redH = CGFloat(strtoul(hex.substringToIndex(advance(hex.startIndex,2)), nil, 16))
    let greenH = CGFloat(strtoul(hex.substringWithRange(Range<String.Index>(start: advance(hex.startIndex, 2), end: advance(hex.startIndex, 4))), nil, 16))
    let blueH = CGFloat(strtoul(hex.substringFromIndex(advance(hex.startIndex,4)), nil, 16))

    self.init(red: redH/255, green: greenH/255, blue: blueH/255, alpha: alpha)
}
}

तो आप इस तरह से अपनी परियोजना में कहीं भी एक यूआईसीओलर बना सकते हैं:

UIColor(hex: "ffe3c8", alpha: 1)

उम्मीद है की यह मदद करेगा...


2

आप UIColor का विस्तार वर्ग बना सकते हैं: -

विस्तार UIColor {

// मार्क: - getColorFromHex / ** यह फ़ंक्शन कलर हेक्स कोड को RGB में बदल देगा।

- parameter color  hex string.

- returns: RGB color code.
*/
class func getColorFromHex(hexString:String)->UIColor{

    var rgbValue : UInt32 = 0
    let scanner:NSScanner =  NSScanner(string: hexString)

    scanner.scanLocation = 1
    scanner.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))
}

}


2

तेजी के लिए 2.0+। यह कोड मेरे लिए ठीक काम करता है।

extension UIColor {
    /// UIColor(hexString: "#cc0000")
    internal convenience init?(hexString:String) {
        guard hexString.characters[hexString.startIndex] == Character("#") else {
            return nil
        }
        guard hexString.characters.count == "#000000".characters.count else {
            return nil
        }
        let digits = hexString.substringFromIndex(hexString.startIndex.advancedBy(1))
        guard Int(digits,radix:16) != nil else{
            return nil
        }
        let red = digits.substringToIndex(digits.startIndex.advancedBy(2))
        let green = digits.substringWithRange(Range<String.Index>(start: digits.startIndex.advancedBy(2),
            end: digits.startIndex.advancedBy(4)))
        let blue = digits.substringWithRange(Range<String.Index>(start:digits.startIndex.advancedBy(4),
            end:digits.startIndex.advancedBy(6)))
        let redf = CGFloat(Double(Int(red, radix:16)!) / 255.0)
        let greenf = CGFloat(Double(Int(green, radix:16)!) / 255.0)
        let bluef = CGFloat(Double(Int(blue, radix:16)!) / 255.0)
        self.init(red: redf, green: greenf, blue: bluef, alpha: CGFloat(1.0))
    }
}

इस कोड में स्ट्रिंग प्रारूप जाँच शामिल है। जैसे

let aColor = UIColor(hexString: "#dadada")!
let failed = UIColor(hexString: "123zzzz")

और जहां तक ​​मुझे पता है, मेरा कोड असफल स्थिति के शब्दार्थ को बनाए रखने और वैकल्पिक मूल्य वापस करने के लिए कोई नुकसान नहीं है। और यह सबसे अच्छा जवाब होना चाहिए।


2

समाधान का स्विफ्ट 2.0 संस्करण जो रंग के अल्फा मान को संभालेगा और सही त्रुटि से निपटने के लिए यहां है:

func RGBColor(hexColorStr : String) -> UIColor?{

    var red:CGFloat = 0.0
    var green:CGFloat = 0.0
    var blue:CGFloat = 0.0
    var alpha:CGFloat = 1.0

    if hexColorStr.hasPrefix("#"){

        let index   = hexColorStr.startIndex.advancedBy(1)
        let hex     = hexColorStr.substringFromIndex(index)
        let scanner = NSScanner(string: hex)
        var hexValue: CUnsignedLongLong = 0

        if scanner.scanHexLongLong(&hexValue)
        {
            if hex.characters.count == 6
            {
                red   = CGFloat((hexValue & 0xFF0000) >> 16) / 255.0
                green = CGFloat((hexValue & 0x00FF00) >> 8)  / 255.0
                blue  = CGFloat(hexValue & 0x0000FF) / 255.0
            }
            else if hex.characters.count == 8
            {
                red   = CGFloat((hexValue & 0xFF000000) >> 24) / 255.0
                green = CGFloat((hexValue & 0x00FF0000) >> 16) / 255.0
                blue  = CGFloat((hexValue & 0x0000FF00) >> 8)  / 255.0
                alpha = CGFloat(hexValue & 0x000000FF)         / 255.0
            }
            else
            {
                print("invalid hex code string, length should be 7 or 9", terminator: "")
                return nil
            }
        }
        else
        {
            print("scan hex error")
       return nil
        }
    }

    let color: UIColor =  UIColor(red:CGFloat(red), green: CGFloat(green), blue:CGFloat(blue), alpha: alpha)
    return color
}

2
    //UIColorWithHexString

    static UIColor * UIColorWithHexString(NSString *hex) {
        unsigned int rgb = 0;
        [[NSScanner scannerWithString:
          [[hex uppercaseString] stringByTrimmingCharactersInSet:
           [[NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEF"] invertedSet]]]
         scanHexInt:&rgb];
        return [UIColor colorWithRed:((CGFloat)((rgb & 0xFF0000) >> 16)) / 255.0
                               green:((CGFloat)((rgb & 0xFF00) >> 8)) / 255.0
                                blue:((CGFloat)(rgb & 0xFF)) / 255.0
                               alpha:1.0];
    }

प्रयोग

self.view.backgroundColor = UIColorWithHexString(@"#0F35C0");
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.