Jak mogę utworzyć UIColor z ciągu szesnastkowego?


Odpowiedzi:


722

Znalazłem najprostszy sposób, aby to zrobić za pomocą makra. Wystarczy umieścić go w nagłówku, aby był dostępny w całym projekcie.

#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]

uicolor makro z wartościami szesnastkowymi

Również sformatowana wersja tego kodu:

#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]

Stosowanie:

label.textColor = UIColorFromRGB(0xBC1128);

130
Jest to świetne, z wyjątkiem tego, że nie robi tego, o co pytający pyta, czyli przekształcenia szesnastkowego STRINGa w kolor UIC. Konwertuje liczbę całkowitą na kolor UIC.
darrinm

31
@ MohamedA.Kimim Jest to przykład zwracania UIColor z liczby całkowitej w formacie szesnastkowym (0x ...), a nie ciągu w formacie szesnastkowym („# ...”). Świetnie, jeśli tego właśnie chcesz, ale nie tego, o co pytał pytający.
darrinm,

3
@ScottKohlert Twój wiersz kodu konwertuje jeden ciąg formatu szesnastkowego (z prefiksem „#”) na inny ciąg formatu szesnastkowego (z prefiksem „0x”). Nie produkuje liczb całkowitych.
darrinm

1
Jak korzystać z tego jak [UIColor whiteColor] .CGColor?
SleepNot

3
Aby przekonwertować ciąg formatu hex do liczby całkowitej do użytku z tym makro, patrz stackoverflow.com/questions/3648411/... .
devios1

371

Zwięzłe rozwiązanie:

// 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
I dobrą metodę wykonania odwrotnej konwersji (np. Jeśli przechowujesz kolory w podstawowych danych / zdalnej bazie danych) można znaleźć tutaj - stackoverflow.com/questions/11884227/...
Eric Goldberg

1
Idealne rozwiązanie. Jeśli ciąg szesnastkowy pochodzi z (bardzo słabo udokumentowanego) interfejsu API, należy przetestować skrócone kody szesnastkowe, takie jak #FFF lub # FC0. Musisz zmienić je na # FFFFFF / # FFCCOO.
Patrick,

10
Możesz także dodać if ( [hexString rangeOfString:@"#"].location == 0 )przed setScanLocationwierszem, aby uczynić #opcjonalnym.
devios1

czy możesz dodać metodę odwrotną?
hasan

11
Dla leniwych: wersja SWIFT tutaj .
fabian789,

188

Mam rozwiązanie, które jest w 100% zgodne z ciągami formatu szesnastkowego używanymi przez system Android, co okazało się bardzo pomocne podczas tworzenia aplikacji mobilnych na wiele platform. Pozwala mi używać jednego koloru podniebienia dla obu platform. Możesz użyć ponownie bez przypisania lub na podstawie licencji Apache, jeśli wolisz.

#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
w colorComponentFrom:start:length:nie powinieneś return hexComponent / 0xFF; // divide by 255, not 256? Największa wartość heksadecymalna, którą powinieneś odzyskać, to 0xFF, a więc to właśnie powinieneś podzielić przez 0xFF (255).
Sam

Dobrze złap Sam. Edytowane, aby odzwierciedlić zmianę.
Micah Hainline,

6
To wspaniale, na zdrowie. Ponadto zamiast kategorii w UIColor można utworzyć jedną w NSString, aby mieć składnię typu:[@"#538aa4" toColor]
Dan2552

2
To rozwiązanie jest świetne, proponuję dodać „Prywatny” dla nazwy prywatnego interfejsu, aby uniknąć ostrzeżenia kompilatora. @ interfejs UIColor (prywatny)
djleop,

1
Miły. Powinieneś jednak umieścić drugą funkcję w interfejsie.
Bjorn Roche,

63

Jest fajny post, w jaki sposób odpowiedzieć na pytanie OP dotyczące wyodrębnienia UIColorsznurka heksadecymalnego. Rozwiązanie przedstawione poniżej różni się od innych, ponieważ obsługuje wartości ciągów, które mogą zawierać prefiks „0x” lub „#” w reprezentacji ciągu szesnastkowego ... (patrz użycie)

Oto główny kawałek ...

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

Metoda pomocnicza ...

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

Stosowanie:

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);

Pełny artykuł referencyjny

Swift 2+

Przeniesiłem to rozwiązanie do Swift 2.2. Zauważ, że zmieniłem alphaparametr, aby używał domyślnego ustawienia 1.0. Zaktualizowałem również typ int UInt32zgodnie z wymaganiami NSScannerklasy w Swift 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
}

Swift 4+

Używając tej samej logiki ze zmianami zastosowanymi w swift 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
}

Odniesienia do koloru szesnastkowego

Nazwy i kody kolorów HTML

Color Hex Kody kolorów


Wydane tutaj fragmenty Swift wydają się źle rozumieć cel opcji w Swift, czyli zawierać wartości, które mogą nigdy nie istnieć. Pytanie, czy parametr musi być opcjonalny, brzmi, czy ktoś może potrzebować możliwości ustawienia go na zero. Czy to ma sens, alphaaby kiedykolwiek mieć wartość zero? Ponieważ ta metoda daje ludziom taką możliwość, a jeśli ktoś zdecyduje się ustawić alphana zero, wymuszone rozpakowanie tej opcjonalnej opcji niezmiennie doprowadzi do awarii. Nie edytowałem go jednak na wypadek, gdyby nie było jakiegoś uzasadnienia, którego nie jestem świadomy.
Jonathan Thornton

@JonathanThornton - Dzięki za zgłoszenie się. Zdecydowany.
Tommie C.

Praca nad starszym projektem i rozwiązaniem Objective-C działa bardzo dobrze ... z wyjątkiem ... dziwnie ... @ "# ffc107" i @ "# e040fb" odmawiają współpracy! Myśli?
Nathaniel

51

Jest to funkcja, która pobiera ciąg szesnastkowy i zwraca kolor UIColor.
(Możesz wprowadzić ciągi szesnastkowe w dowolnym formacie: #fffffflub ffffff)

Stosowanie:

var color1 = hexStringToUIColor("#d3d3d3")

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

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

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



Źródło: arshad / gist: de147c42d7b3063ef7bc


Widziałem w SVG, gdzie jest mała wersja ciągu szesnastkowego z 3 znakami, np. # F0F.
Glenn Howes

Jest to skrótowy zapis, w którym „# F0F” jest równoważne z „# FF00FF”. Łatwo byłoby napisać funkcję, która sprawdziła skrót i rozszerzyła go.
Ethan Strider,

38

Użyj tej kategorii:

w pliku UIColor + Hexadecimal.h

#import <UIKit/UIKit.h>

@interface UIColor(Hexadecimal)

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

@end

w pliku 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

W klasie chcesz go użyć:

#import "UIColor+Hexadecimal.h"

i:

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

Brak obsługi alfa
Ihor Klimov

28

Świetna implementacja Swift (zaktualizowana do Xcode 7) przy użyciu rozszerzeń, zebranych z różnych odpowiedzi i miejsc. Będziesz także potrzebować rozszerzeń ciągów na końcu.

Posługiwać się:

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

UWAGA: Dodałem opcję 2 dodatkowych cyfr na końcu standardowej 6-cyfrowej wartości szesnastkowej dla kanału alfa (wartość przekazu 00- 99). Jeśli cię to obraża, po prostu ją usuń. Można go zaimplementować, aby przekazać opcjonalny parametr alfa.

Rozbudowa:

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

Rozszerzenia ciągów:
Źródło zmiennoprzecinkowe Źródło
indeksów dolnych

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

Czy używasz również rozszerzenia String, aby uzyskać jego indeks dolny? np. stackoverflow.com/a/24144365/3220708
Craig Grummitt

@CraigGrummitt oh my! Haha tak. Mam przyzwoitą skompilowaną listę rozszerzeń i indeksów, czasami (niestety) zapominam, co jest i nie jest zawarte w standardowym zestawie funkcji języka. Zaktualizowałem swoją odpowiedź, w tym podane źródło. Nie jestem pewien, czy w ogóle dostałem go stamtąd, ale na pewno wygląda na bliski.
Firo

Możesz wspomnieć, że jest to rozszerzenie String. Wygląda na to, że przegapiłeś rozszerzenie String floatValue: stackoverflow.com/a/24088249/3220708 Poza tym dobra robota!
Craig Grummitt

Gdzie jest countElements () func?
Ε Г И І И О

countElements()został zastąpiony count()w Swift 1.2, jest wbudowany w język. Zaktualizowałem swoją odpowiedź, aby to odzwierciedlić.
Firo,

27

Możesz zrobić takie rozszerzenie

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

I używaj go gdziekolwiek tak

UIColor(rgb: 0xffffff, alphaVal: 0.2)

Zupełnie proste, zdecydowanie moje ulubione.
teoria

Dzięki, ten jest świetny, więc zwięzły w porównaniu do innych ścian tekstu!
FrankByte.com

fajna funkcja, ale w żaden sposób nie odpowiada na pytanie.
mah

@mah Myślę, że to jest dokładnie pytanie, jak utworzyć UIColor z szesnastkowego
Manu Gupta

@ManuGupta możesz zauważyć całkowity brak obsługi ciągów w tej odpowiedzi. Liczba szesnastkowa nie jest łańcuchem szesnastkowym. Pytanie wyraźnie określa ciąg znaków i chociaż nie zawiera cudzysłowów, #00FF00wyraźnie ma być ciągiem znaków. Jak powiedzieli inni, jest to proste, zwięzłe. Ale jeśli nie zajmuje się łańcuchami, nie może odpowiedzieć na pytanie, w jaki sposób radzić sobie z łańcuchami.
mah

26

Nie ma wbudowanej konwersji z łańcucha szesnastkowego na UIColor(lub CGColor), o czym jestem świadomy. Możesz jednak z łatwością napisać w tym celu kilka funkcji - na przykład zobacz rozwój iPhone'a z dostępem do komponentów uicolor


3
+1 Jeśli przewiniesz w dół, przedmiotową metodą jest + colorWithHexString :.
Rob Napier

1
@RobNapier +colorWithHexString:nie działa. Przynajmniej w moim przypadku. :)

15

Znalazłem do tego dobrą UIColorkategorię, UIColor + PXExtensions .

Stosowanie: UIColor *mycolor = [UIColor pxColorWithHexValue:@"#BADA55"];

I tak na wszelki wypadek, gdy link do mojej treści nie powiedzie się, oto aktualny kod implementacyjny:

//
//  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 ok, dodałem kod implementacyjny :)
Hlung

13

szybka wersja. Użyj jako funkcji lub rozszerzenia.

Funkcjonować
  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))
}
Rozbudowa
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))
    }
}
Jak zadzwonić
let hexColorFromFunction = UIColorFromRGB("F4C124", alpha: 1.0)
let hexColorFromExtension = UIColor(colorCode: "F4C124", alpha: 1.0)
Możesz także zdefiniować swój Hex Colorkonstruktor interfejsu.

wprowadź opis zdjęcia tutaj


12

To kolejna alternatywa.

- (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];
}

alternatywna odpowiedź na alternatywne pytanie ... nie jest to jednak rozsądna odpowiedź na pytanie na tej stronie.
mah

11

Możesz użyć różnych narzędzi online do konwersji łańcucha HEX na rzeczywisty kolor UIC. Sprawdź uicolor.org lub UI Color Picker . Dane wyjściowe zostaną przekonwertowane na kod Celu C, na przykład:

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

Które możesz osadzić w swojej aplikacji. Mam nadzieję że to pomoże!


Kolejne narzędzie online o tej samej nazwie, UI Color Picker .
Joe

Zasadniczo, gdy ludzie proszą o pomoc w rozwiązaniu dość prostego problemu takiego jak ten, odpowiedź, która brzmi „najpierw przejdź do jakiejś strony internetowej ...”, nie jest tak naprawdę bliska odpowiedzi, o którą pytał pytający.
mah

11

SWIFT 4

Możesz stworzyć fajnego conveniencekonstruktora w takim rozszerzeniu:

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

I użyj go później jak

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

„scanHexInt32” został uznany za przestarzały w iOS 13.0
Cosmo Arun

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

Stosowanie:

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

To miłe z obsługą cocoapod

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]

Piękne rzeczy bracie :)
cesarferreira,

4

Kolejna wersja z alfa

#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

Szybki odpowiednik odpowiedzi @ Toma, chociaż odbiera wartość Int RGBA w celu obsługi przezroczystości:

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)

A jeśli chcesz móc używać go z łańcucha, możesz użyć strtoul:

var hexString = "0x7F00FFFF"

let num = strtoul(hexString, nil, 16)

var colorFromString = colorWithHex(num)

4

Oto Swift 1.2wersja napisana jako rozszerzenie do UIColor. To pozwala ci to zrobić

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

Który uważam za najbardziej naturalny sposób na zrobienie tego.

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

W Xcode 6.3.2 na linii, która zaczyna się od let greenRange = ..., otrzymuję wyjątek:fatal error: can not increment endIndex
Clifton Labrum

@CliftonLabrum Przetestowałem to na Xcode 7 beta 3 i działa tak samo. Nadal masz ten problem?
Morgan Wilde,

3

Kolejna realizacja pozwalając sznurki jak "FFF"albo "FFFFFF"i za pomocą alfa:

+ (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

zaktualizowano do wersji swift 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

Utwórz eleganckie rozszerzenie dla 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)
    }
}

Utwórz czerwony kolor:

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

jeśli chcesz użyć tego kodu, to wywołujesz [self getUIColorObjectFromHexString: @ "27b8c8" alpha: 9]; tylko ....
Manish Saini

2

Lubię kolor oprócz koloru, więc piszę własną kategorię

+ (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];
}

łatwy w użyciu w ten sposób

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

2

Stworzyłem dla tego wygodną inicjację:

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

możesz utworzyć UIColor w dowolnym miejscu swojego projektu, tak jak to:

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

mam nadzieję że to pomoże...


2

Możesz utworzyć klasę rozszerzenia UIColor jako: -

rozszerzenie UIColor {

// ZNAK: - getColorFromHex / ** Ta funkcja konwertuje kolorowy kod Hex na 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

Dla szybkiego 2.0+. Ten kod działa dla mnie dobrze.

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

Ten kod obejmuje sprawdzanie formatu ciągu. na przykład

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

I o ile wiem, mój kod nie jest niekorzystny, ponieważ utrzymuje semantię stanu awaryjnego i zwraca wartość opcjonalną. I to powinna być najlepsza odpowiedź.


2

Oto wersja rozwiązania Swift 2.0 , które będzie obsługiwać wartość alfa koloru i z doskonałą obsługą błędów:

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

Stosowanie

self.view.backgroundColor = UIColorWithHexString(@"#0F35C0");
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.