Comment puis-je créer un UIColor à partir d'une chaîne hexadécimale?

Réponses:

722

J'ai trouvé le moyen le plus simple de le faire avec une macro. Il vous suffit de l'inclure dans votre en-tête et il sera disponible tout au long de votre projet.

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

macro uicolor avec des valeurs hexadécimales

Version également formatée de ce code:

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

Usage:

label.textColor = UIColorFromRGB(0xBC1128);
À M
la source
130
C'est génial, sauf qu'il ne fait pas ce que le questionneur demande, qui est de convertir un STRING hexadécimal en UIColor. Cela convertit un entier en UIColor.
darrinm
31
@ MohamedA.Karim C'est un exemple de retour d'un UIColor à partir d'un entier au format hexadécimal (0x ...) et non d'une chaîne au format hexadécimal ("# ..."). Génial si c'est ce que vous voulez, mais pas ce que l'interrogateur a demandé.
darrinm
3
@ScottKohlert Votre ligne de code convertit une chaîne au format hexadécimal (préfixée avec "#") en une autre chaîne au format hexadécimal (préfixée avec "0x"). Il ne produit pas un entier.
darrinm
1
Comment l'utiliser comme [UIColor whiteColor] .CGColor?
SleepNot
3
Pour convertir une chaîne au format hexadécimal en un entier à utiliser avec cette macro, voir stackoverflow.com/questions/3648411/… .
devios1
371

Une solution concise:

// 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];
}
darrinm
la source
1
Et une bonne méthode pour effectuer la conversion inverse (comme si vous stockez des couleurs dans des données de base / une base de données distante) peut être trouvée ici - stackoverflow.com/questions/11884227/…
Eric Goldberg
1
Une solution parfaite. Si votre chaîne hexadécimale provient d'une API (très mal documentée), assurez-vous de tester des codes hexadécimaux abrégés comme #FFF ou # FC0. Vous devrez les changer en # FFFFFF / # FFCCOO.
Patrick
10
Vous pouvez également ajouter if ( [hexString rangeOfString:@"#"].location == 0 )avant la setScanLocationligne pour rendre l' #option facultative.
devios1
pouvez-vous s'il vous plaît ajouter la méthode inverse.
hasan
11
Pour la version paresseuse: SWIFT ici .
fabian789
188

J'ai une solution 100% compatible avec les chaînes de format hexadécimal utilisées par Android, que j'ai trouvé très utile lors du développement mobile multiplateforme. Cela me permet d'utiliser une palette de couleurs pour les deux plates-formes. N'hésitez pas à réutiliser sans attribution, ou sous la licence Apache si vous préférez.

#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 
Micah Hainline
la source
3
dans colorComponentFrom:start:length:, ne devrait pas vous avoir return hexComponent / 0xFF; // divide by 255, not 256? La plus grande valeur hexadécimale que vous devriez récupérer est 0xFF, c'est donc ce que vous devez diviser par 0xFF (255).
Sam
Bonne prise Sam. Modifié pour refléter le changement.
Micah Hainline
6
C'est super, bravo. De plus, au lieu d'une catégorie sur UIColor, vous pouvez en créer une sur NSString pour pouvoir avoir une syntaxe comme[@"#538aa4" toColor]
Dan2552
2
Cette solution est excellente, je suggérerais d'ajouter "Privé" pour le nom de l'interface privée pour éviter un avertissement du compilateur. @interface UIColor (Private)
djleop
1
Agréable. Vous devez cependant mettre l' autre fonction dans l'interface.
Bjorn Roche
63

Il y a un bon article sur la façon d'aborder la question de l'OP d'extraire un UIColord'une chaîne hexadécimale. La solution présentée ci-dessous est différente des autres car elle prend en charge les valeurs de chaîne qui peuvent inclure '0x' ou '#' préfixé à la représentation de chaîne hexadécimale ... (voir utilisation)

Voici le bit principal ...

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

Méthode d'assistance ...

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

Usage:

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

Article de référence complet

Swift 2+

J'ai porté cette solution sur Swift 2.2. Notez que j'ai changé le alphaparamètre pour utiliser un ensemble par défaut à 1.0. J'ai également mis à jour le type int UInt32comme requis par la NSScannerclasse dans 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+

En utilisant la même logique avec les changements appliqués pour 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
}

Références hexadécimales de couleur

Noms et codes de couleur HTML

Codes couleur hexadécimaux

Tommie C.
la source
Les extraits de code Swift publiés ici semblent mal comprendre l'objectif des options dans Swift, qui est de contenir des valeurs qui peuvent ne jamais exister. La question à se poser pour savoir si un paramètre doit être facultatif est de savoir si quelqu'un peut avoir besoin de le définir sur zéro. Cela a-t-il un sens alphade ne jamais être réglé sur zéro? Parce que cette méthode donne aux gens cette capacité, et si quelqu'un décide de régler alphasur zéro, le déballage forcé de cette option entraînera invariablement un plantage. Je ne l'ai pas édité, cependant, au cas où il y aurait une justification dont je ne suis pas au courant.
Jonathan Thornton
@JonathanThornton - Merci pour l'avertissement. Résolu.
Tommie
Travailler sur un projet hérité et la solution Objective-C fonctionne très bien ... sauf ... bizarrement ... @ "# ffc107" et @ "# e040fb" refusent de coopérer! Pensées?
Nathaniel
51

Il s'agit d'une fonction qui prend une chaîne hexadécimale et renvoie un UIColor.
(Vous pouvez entrer des chaînes hexadécimales avec l'un #ffffffou l' autre format: ou ffffff)

Usage:

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



Source: arshad / gist: de147c42d7b3063ef7bc

Ethan Strider
la source
J'ai vu dans SVG, où il y a une petite version de la chaîne hexadécimale avec 3 caractères, comme # F0F.
Glenn Howes
C'est une notation abrégée, où '# F0F' est équivalent à '# FF00FF'. Il serait simple d'écrire une fonction qui a vérifié la sténographie et l'a développée.
Ethan Strider
38

Utilisez cette catégorie:

dans le fichier UIColor + Hexadecimal.h

#import <UIKit/UIKit.h>

@interface UIColor(Hexadecimal)

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

@end

dans le fichier 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

En classe, vous voulez l'utiliser:

#import "UIColor+Hexadecimal.h"

et:

[UIColor colorWithHexString:@"#6e4b4b"];
Damien Romito
la source
Aucune manipulation alpha
Ihor Klimov
28

Une excellente implémentation Swift (mise à jour pour Xcode 7) utilisant des extensions, rassemblées à partir d'une variété de réponses et de lieux différents. Vous aurez également besoin des extensions de chaîne à la fin.

Utilisation:

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

REMARQUE: j'ai ajouté une option pour 2 chiffres supplémentaires à la fin de la valeur hexadécimale standard à 6 chiffres pour un canal alpha (passez la valeur de 00- 99). Si cela vous offense, supprimez-le. Vous pouvez l'implémenter pour passer un paramètre alpha facultatif.

Extension:

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

Extensions de chaîne:
Float source
Subscript source

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)
        }
    }
}
Firo
la source
Utilisez-vous également une extension String pour obtenir son indice? par exemple stackoverflow.com/a/24144365/3220708
Craig Grummitt
@CraigGrummitt oh my! Haha, oui. J'ai une liste compilée décente d'extensions et d'indices J'oublie parfois (malheureusement) ce qui est et n'est pas inclus dans l'ensemble de fonctionnalités de langue standard. J'ai mis à jour ma réponse, y compris la source que vous avez donnée. Je ne sais pas si je l'ai même obtenu à partir de là, mais cela semble sûr de près.
Firo
Vous voudrez peut-être mentionner qu'il s'agit d'une extension de chaîne. Vous semblez également avoir raté l'extension String floatValue: stackoverflow.com/a/24088249/3220708 À part cela, bon travail!
Craig Grummitt
Où est countElements () func?
Ε Г И І И О
countElements()a été remplacé par count()dans Swift 1.2, il est intégré dans la langue. J'ai mis à jour ma réponse pour refléter cela.
Firo
27

Vous pouvez créer une extension comme celle-ci

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

Et utilisez-le n'importe où comme ça

UIColor(rgb: 0xffffff, alphaVal: 0.2)
Manu Gupta
la source
Mort simple, définitivement mon préféré.
théorie
Merci, celui-ci est génial, donc concis par rapport aux autres murs de texte!
FrankByte.com
belle fonction mais cela ne répond en rien à la question.
mah
@mah C'est exactement la question que je pense, comment créer un UIColor à partir de hexstring
Manu Gupta
@ManuGupta, vous remarquerez peut-être un manque total de gestion des chaînes dans cette réponse. Un nombre hexadécimal n'est pas une chaîne hexadécimale. La question indique explicitement une chaîne et bien qu'elle ne comporte pas de guillemets, elle #00FF00est clairement destinée à être une chaîne de caractères. Comme d'autres l'ont dit, c'est simple, concis. Mais s'il ne traite pas des chaînes, il ne peut pas répondre à une question demandant comment gérer les chaînes.
mah
26

Il n'y a pas de conversion intégrée d'une chaîne hexadécimale en UIColor(ou CGColor) à ma connaissance. Cependant, vous pouvez facilement écrire quelques fonctions à cet effet - par exemple, voir développement d'iphone accédant aux composants uicolor

Adam Wright
la source
3
+1 Si vous faites défiler vers le bas, la méthode en question est + colorWithHexString :.
Rob Napier
1
@RobNapier +colorWithHexString:ne fonctionne pas. Du moins dans mon cas. :)
पवन
15

J'ai trouvé une bonne UIColorcatégorie pour cela, UIColor + PXExtensions .

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

Et, juste au cas où le lien vers mon gist échoue, voici le code d'implémentation réel:

//
//  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
Hlung
la source
@PeterDuniho ok, j'ai ajouté le code d'implémentation :)
Hlung
13

version rapide. Utiliser comme une fonction ou une extension.

Une fonction
  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
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))
    }
}
Comment appeler
let hexColorFromFunction = UIColorFromRGB("F4C124", alpha: 1.0)
let hexColorFromExtension = UIColor(colorCode: "F4C124", alpha: 1.0)
Vous pouvez également définir votre Hex Colorconstructeur d'interface.

entrez la description de l'image ici

fatihyildizhan
la source
12

Ceci est une autre alternative.

- (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];
}
Pistolet
la source
réponse alternative à une question alternative ... pas une réponse raisonnable à la question sur cette page.
mah
11

Vous pouvez utiliser divers outils en ligne pour convertir une chaîne HEX en une véritable UIColor. Consultez uicolor.org ou UI Color Picker . La sortie serait convertie en code Objective-C, comme:

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

Que vous pourriez intégrer dans votre application. J'espère que cela t'aides!

Zorayr
la source
Un autre outil en ligne, du même nom en fait, UI Color Picker .
Joe
Généralement, lorsque les gens demandent de l'aide avec du code pour résoudre un problème assez simple comme celui-ci, une réponse qui dit "allez d'abord sur un site en ligne ..." n'est vraiment pas proche de la réponse que le demandeur voulait.
mah
11

SWIFT 4

Vous pouvez créer un joli convenienceconstructeur dans l'extension comme ceci:

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

Et l'utiliser plus tard comme

let color = UIColor(hexString: "#AABBCCDD")
George Maisuradze
la source
'scanHexInt32' est déconseillé dans 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)}
}

Usage:

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
Leo Dabus
la source
7

C'est bien avec le support 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]
Nath
la source
Beautiful stuff bro :)
cesarferreira
4

Une autre version avec alpha

#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)]
gheese
la source
4

Équivalent rapide de la réponse de @ Tom, bien que recevant la valeur RGBA Int pour prendre en charge la transparence:

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)

Et si vous voulez pouvoir l'utiliser à partir d'une chaîne, vous pouvez utiliser strtoul:

var hexString = "0x7F00FFFF"

let num = strtoul(hexString, nil, 16)

var colorFromString = colorWithHex(num)
hris.to
la source
4

Voici une Swift 1.2version écrite en tant qu'extension de UIColor. Cela vous permet de faire

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

Je pense que c'est la façon la plus naturelle de le faire.

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
    )
  }
}
Morgan Wilde
la source
Dans Xcode 6.3.2 sur la ligne qui commence par let greenRange = ...j'obtiens une exception:fatal error: can not increment endIndex
Clifton Labrum
@CliftonLabrum J'ai testé cela sur Xcode 7 beta 3, et cela fonctionne de la même manière. Avez-vous toujours ce problème?
Morgan Wilde
3

Une autre implémentation permettant des chaînes comme "FFF"ou "FFFFFF"et utilisant alpha:

+ (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];
}
Renato Lochetti
la source
3

mis à jour pour 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))

}
RiceAndBytes
la source
3

Créez une extension élégante pour 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)
    }
}

Créez une couleur rouge:

let red = UIColor(string: "#ff0000") 
Bartłomiej Semańczyk
la source
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)
Vinayak
la source
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;
    }
Manish Saini
la source
si vous voulez utiliser ce code, alors appelez [self getUIColorObjectFromHexString: @ "27b8c8" alpha: 9]; seulement ....
Manish Saini
2

J'aime assurer l'alpha en plus de la couleur, donc j'écris ma propre catégorie

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

facile à utiliser comme ça

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

J'ai créé une init de commodité pour cela:

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

alors vous pouvez créer un UIColor n'importe où dans votre projet comme ceci:

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

J'espère que cela t'aides...

Lucas Martins Juviniano
la source
2

Vous pouvez créer une classe d'extension UIColor comme: -

extension UIColor {

// MARK: - getColorFromHex / ** Cette fonction convertira le code couleur Hex en RVB.

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

}

Abhishek Verma
la source
2

Pour swift 2.0+. Ce code me convient parfaitement.

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

Ce code inclut la vérification du format de chaîne. par exemple

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

Et pour autant que je sache, mon code n'est d'aucun inconvénient pour le maintien de la sémantique de la condition défaillante et le retour d'une valeur facultative. Et cela devrait être la meilleure réponse.

AntiMoron
la source
2

La version Swift 2.0 de la solution qui gérera la valeur alpha de la couleur et avec une gestion parfaite des erreurs est ici:

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
}
Teja Kumar Bethina
la source
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];
    }

Usage

self.view.backgroundColor = UIColorWithHexString(@"#0F35C0");
Usman
la source