Cómo usar valores de color hexadecimales

Estoy tratando de usar valores de color hexadecimal en Swift, en lugar de los pocos estándar que UIColor permite usar, pero no tengo ni idea de cómo hacerlo.

Ejemplo: ¿cómo usaría #ffffff como color?

#ffffff son en realidad 3 componentes de color en notación hexadecimal: rojo ff , verde ff y azul ff . Puede escribir notación hexadecimal en Swift usando el prefijo 0x , por ejemplo 0xFF

Para simplificar la conversión, creemos un inicializador que tome valores enteros (0 – 255):

 extension UIColor { convenience init(red: Int, green: Int, blue: Int) { assert(red >= 0 && red < = 255, "Invalid red component") assert(green >= 0 && green < = 255, "Invalid green component") assert(blue >= 0 && blue < = 255, "Invalid blue component") self.init(red: CGFloat(red) / 255.0, green: CGFloat(green) / 255.0, blue: CGFloat(blue) / 255.0, alpha: 1.0) } convenience init(rgb: Int) { self.init( red: (rgb >> 16) & 0xFF, green: (rgb >> 8) & 0xFF, blue: rgb & 0xFF ) } } 

Uso:

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

Cómo obtener alfa?

Dependiendo de su caso de uso, puede simplemente usar el método UIColor.withAlphaComponent nativo, por ejemplo

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

O puede agregar un parámetro adicional (opcional) a los métodos anteriores:

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

(no podemos nombrar el parámetro alpha debido a una colisión de nombre con el inicializador existente).

Llamado:

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

Para obtener el alfa como un entero 0-255, podemos

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

Llamado

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

O una combinación de los métodos anteriores. No hay absolutamente ninguna necesidad de usar cadenas.

Esta es una función que toma una cadena hexadecimal y devuelve un UIColor.
(Puede ingresar cadenas hexagonales con cualquier formato: #ffffff o ffffff )

Uso:

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


Fuente: arshad / gist: de147c42d7b3063ef7bc

Editar: actualizó el código. Gracias, Hlung, jaytrixz y Ahmad F!

Swift 4 extensión UIColor:

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

Uso :

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

Versión Swift 2.x :

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

UIColor :

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

CGColor :

 extension CGColor { class func colorWithHex(hex: Int) -> CGColorRef { return UIColor(hex: hex).CGColor } } 

Uso

 let purple = UIColor(hex: 0xAB47BC) 

Con Swift 2.0 y Xcode 7.0.1 puede crear esta función:

  // Creates a UIColor from a Hex string. func colorWithHexString (hex:String) -> UIColor { var cString:String = hex.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).uppercaseString if (cString.hasPrefix("#")) { cString = (cString as NSString).substringFromIndex(1) } if (cString.characters.count != 6) { return UIColor.grayColor() } let rString = (cString as NSString).substringToIndex(2) let gString = ((cString as NSString).substringFromIndex(2) as NSString).substringToIndex(2) let bString = ((cString as NSString).substringFromIndex(4) as NSString).substringToIndex(2) var r:CUnsignedInt = 0, g:CUnsignedInt = 0, b:CUnsignedInt = 0; NSScanner(string: rString).scanHexInt(&r) NSScanner(string: gString).scanHexInt(&g) NSScanner(string: bString).scanHexInt(&b) return UIColor(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: CGFloat(1)) } 

y luego usarlo de esta manera:

 let color1 = colorWithHexString("#1F437C") 

Actualizado para Swift 4

 func colorWithHexString (hex:String) -> UIColor { var cString = hex.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines).uppercased() if (cString.hasPrefix("#")) { cString = (cString as NSString).substring(from: 1) } if (cString.characters.count != 6) { return UIColor.gray } let rString = (cString as NSString).substring(to: 2) let gString = ((cString as NSString).substring(from: 2) as NSString).substring(to: 2) let bString = ((cString as NSString).substring(from: 4) as NSString).substring(to: 2) var r:CUnsignedInt = 0, g:CUnsignedInt = 0, b:CUnsignedInt = 0; Scanner(string: rString).scanHexInt32(&r) Scanner(string: gString).scanHexInt32(&g) Scanner(string: bString).scanHexInt32(&b) return UIColor(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: CGFloat(1)) } 

Swift 3: soporte de nombre de color hexadecimal y CSS a través de UIColor

Código Gist

Ejemplos de cadenas:

  • Orange , Lime , Tomato , etc.
  • Rendimiento de cadena Clear , Transparent , nil y vacío [UIColor clearColor]
  • abc
  • abc7
  • #abc7
  • 00FFFF
  • #00FFFF
  • 00FFFF77

Salida del patio de recreo: Salida de juegos infantiles

Esta respuesta muestra cómo hacerlo en Obj-C. El puente es para usar

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

Swift 4 : Combinando las respuestas de Sulthan y Luca Torella:

 extension UIColor { convenience init(hexFromString:String, alpha:CGFloat = 1.0) { var cString:String = hexFromString.trimmingCharacters(in: .whitespacesAndNewlines).uppercased() var rgbValue:UInt32 = 10066329 //color #999999 if string has wrong format if (cString.hasPrefix("#")) { cString.remove(at: cString.startIndex) } if ((cString.count) == 6) { Scanner(string: cString).scanHexInt32(&rgbValue) } self.init( red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0, green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0, blue: CGFloat(rgbValue & 0x0000FF) / 255.0, alpha: alpha ) } } 

Ejemplos de uso:

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

Otro método

Swift 3.0

Escribe una extensión para UIColor

 // To change the HexaDecimal value to Corresponding Color extension UIColor { class func uicolorFromHex(_ rgbValue:UInt32, alpha : CGFloat)->UIColor { let red = CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0 let green = CGFloat((rgbValue & 0xFF00) >> 8) / 255.0 let blue = CGFloat(rgbValue & 0xFF) / 255.0 return UIColor(red:red, green:green, blue:blue, alpha: alpha) } } 

puedes crear UIColor directamente con hex como este

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

Última versión de swift3

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

Úselo en su clase o donde sea que haya convertido a hexicolor en uicolor de esta manera

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

La forma más sencilla de agregar color mediante progtwigción es mediante el uso de ColorLiteral .

Simplemente agregue la propiedad ColorLiteral como se muestra en el ejemplo, Xcode le solicitará una lista completa de colores que puede elegir. La ventaja de hacerlo es un código menor, agregue valores HEX o RGB . También obtendrá los colores utilizados recientemente en el guión gráfico.

Ejemplo: self.view.backgroundColor = ColorLiteral enter image description here

Aquí hay una extensión Swift en UIColor que toma una cadena hexagonal:

 import UIKit extension UIColor { convenience init(hexString: String) { // Trim leading '#' if needed var cleanedHexString = hexString if hexString.hasPrefix("#") { // cleanedHexString = dropFirst(hexString) // Swift 1.2 cleanedHexString = String(hexString.characters.dropFirst()) // Swift 2 } // String -> UInt32 var rgbValue: UInt32 = 0 NSScanner(string: cleanedHexString).scanHexInt(&rgbValue) // UInt32 -> R,G,B let red = CGFloat((rgbValue >> 16) & 0xff) / 255.0 let green = CGFloat((rgbValue >> 08) & 0xff) / 255.0 let blue = CGFloat((rgbValue >> 00) & 0xff) / 255.0 self.init(red: red, green: green, blue: blue, alpha: 1.0) } } 
 public static func hexStringToUIColor (hex:String) -> UIColor { var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased() if (cString.hasPrefix("#")) { cString.remove(at: cString.startIndex) } if ((cString.characters.count) == 6) { var rgbValue:UInt32 = 0 Scanner(string: cString).scanHexInt32(&rgbValue) return UIColor( red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0, green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0, blue: CGFloat(rgbValue & 0x0000FF) / 255.0, alpha: CGFloat(1.0) ) }else if ((cString.characters.count) == 8) { var rgbValue:UInt32 = 0 Scanner(string: cString).scanHexInt32(&rgbValue) return UIColor( red: CGFloat((rgbValue & 0x00FF0000) >> 16) / 255.0, green: CGFloat((rgbValue & 0x0000FF00) >> 8) / 255.0, blue: CGFloat(rgbValue & 0x000000FF) / 255.0, alpha: CGFloat((rgbValue & 0xFF000000) >> 24) / 255.0 ) }else{ return UIColor.gray } } 

Cómo utilizar

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

He combinado algunas ideas de este hilo de respuestas y las he actualizado a Swift 4 .

 extension UIColor { convenience init(hex: String, alpha: CGFloat = 1.0) { var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased() if (cString.hasPrefix("#")) { cString.removeFirst() } if ((cString.count) != 6) { self.init(hex: "ff0000") // return red color for wrong hex input return } var rgbValue: UInt32 = 0 Scanner(string: cString).scanHexInt32(&rgbValue) self.init(red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0, green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0, blue: CGFloat(rgbValue & 0x0000FF) / 255.0, alpha: alpha) } } 

Puede usarlo así:

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

Actualizado en 2018/06/14

La muestra debería funcionar en Swift2.2, Swift2.3, Swift3, Swift4:

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

Úselos como a continuación: Ejemplo

Vieja respuesta

He hecho otra UIColor extension en Swift 2.2, puede usar el valor hexadecimal para UIColor directamente, deseo puede ayudar a alguien:

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

Y úsalo así:

 UIColor(hex: 0xffffff) // r 1.0 g 1.0 b 1.0 a 1.0 UIColor(hex: 0xffffff, alpha: 0.5) // r 1.0 g 1.0 b 1.0 a 0.5 

La versión Swift 4 se ve así:

 extension UIColor { convenience init(hexString: String, alpha: CGFloat = 1.0) { let hexString: String = hexString.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) let scanner = Scanner(string: hexString) if (hexString.hasPrefix("#")) { scanner.scanLocation = 1 } var color: UInt32 = 0 scanner.scanHexInt32(&color) let mask = 0x000000FF let r = Int(color >> 16) & mask let g = Int(color >> 8) & mask let b = Int(color) & mask let red = CGFloat(r) / 255.0 let green = CGFloat(g) / 255.0 let blue = CGFloat(b) / 255.0 self.init(red:red, green:green, blue:blue, alpha:alpha) } func toHexString() -> String { var r:CGFloat = 0 var g:CGFloat = 0 var b:CGFloat = 0 var a:CGFloat = 0 getRed(&r, green: &g, blue: &b, alpha: &a) let rgb:Int = (Int)(r*255)< <16 | (Int)(g*255)<<8 | (Int)(b*255)<<0 return String(format:"#%06x", rgb) } } 

Admite 7 tipos de color Hex.

Hay 7 formatos de color hexadecimales: “” # FF0000 “,” 0xFF0000 “,” FF0000 “,” F00 “,” rojo “, 0x00FF00, 16711935

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

PRECAUCIÓN: Esta no es una “solución de un solo archivo”, existen algunas dependencias, pero buscarlas puede ser más rápido que investigar esto desde cero.

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

Enlace permanente:
https://github.com/eonist/Element/wiki/Progress#supporting-7-hex-color-types

Swift 2.0

El código siguiente se prueba en xcode 7.2

 import UIKit extension UIColor{ public convenience init?(colorCodeInHex: String, alpha: Float = 1.0){ var filterColorCode:String = colorCodeInHex.stringByReplacingOccurrencesOfString("#", withString: "") if filterColorCode.characters.count != 6 { self.init(red: 0.0, green: 0.0, blue: 0.0, alpha: CGFloat(alpha)) return } filterColorCode = filterColorCode.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).uppercaseString var range = Range(start: filterColorCode.startIndex.advancedBy(0), end: filterColorCode.startIndex.advancedBy(2)) let rString = filterColorCode.substringWithRange(range) range = Range(start: filterColorCode.startIndex.advancedBy(2), end: filterColorCode.startIndex.advancedBy(4)) let gString = filterColorCode.substringWithRange(range) range = Range(start: filterColorCode.startIndex.advancedBy(4), end: filterColorCode.startIndex.advancedBy(6)) let bString = filterColorCode.substringWithRange(range) var r:CUnsignedInt = 0, g:CUnsignedInt = 0, b:CUnsignedInt = 0; NSScanner(string: rString).scanHexInt(&r) NSScanner(string: gString).scanHexInt(&g) NSScanner(string: bString).scanHexInt(&b) self.init(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: CGFloat(alpha)) return } } 

Swift 2.0:

Haga una extensión de UIColor.

 extension UIColor { convenience init(hexString:String) { let hexString:NSString = hexString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()) let scanner = NSScanner(string: hexString as String) if (hexString.hasPrefix("#")) { scanner.scanLocation = 1 } var color:UInt32 = 0 scanner.scanHexInt(&color) let mask = 0x000000FF let r = Int(color >> 16) & mask let g = Int(color >> 8) & mask let b = Int(color) & mask let red = CGFloat(r) / 255.0 let green = CGFloat(g) / 255.0 let blue = CGFloat(b) / 255.0 self.init(red:red, green:green, blue:blue, alpha:1) } func toHexString() -> String { var r:CGFloat = 0 var g:CGFloat = 0 var b:CGFloat = 0 var a:CGFloat = 0 getRed(&r, green: &g, blue: &b, alpha: &a) let rgb:Int = (Int)(r*255)< <16 | (Int)(g*255)<<8 | (Int)(b*255)<<0 return NSString(format:"#%06x", rgb) as String } } 

Uso:

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

Swift 2.0:

En viewDidLoad ()

  var viewColor:UIColor viewColor = UIColor() let colorInt:UInt colorInt = 0x000000 viewColor = UIColorFromRGB(colorInt) self.View.backgroundColor=viewColor func UIColorFromRGB(rgbValue: UInt) -> UIColor { return UIColor( red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0, green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0, blue: CGFloat(rgbValue & 0x0000FF) / 255.0, alpha: CGFloat(1.0) ) } 

Para veloz 3

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

Puede usar esta extensión en UIColor que convierte Su Cadena (Hexadecimal, RGBA) a UIColor y viceversa.

 extension UIColor { //Convert RGBA String to UIColor object //"rgbaString" must be separated by space "0.5 0.6 0.7 1.0" 50% of Red 60% of Green 70% of Blue Alpha 100% public convenience init?(rgbaString : String){ self.init(ciColor: CIColor(string: rgbaString)) } //Convert UIColor to RGBA String func toRGBAString()-> String { var r: CGFloat = 0 var g: CGFloat = 0 var b: CGFloat = 0 var a: CGFloat = 0 self.getRed(&r, green: &g, blue: &b, alpha: &a) return "\(r) \(g) \(b) \(a)" } //return UIColor from Hexadecimal Color string public convenience init?(hexString: String) { let r, g, b, a: CGFloat if hexString.hasPrefix("#") { let start = hexString.index(hexString.startIndex, offsetBy: 1) let hexColor = hexString.substring(from: start) if hexColor.characters.count == 8 { let scanner = Scanner(string: hexColor) var hexNumber: UInt64 = 0 if scanner.scanHexInt64(&hexNumber) { r = CGFloat((hexNumber & 0xff000000) >> 24) / 255 g = CGFloat((hexNumber & 0x00ff0000) >> 16) / 255 b = CGFloat((hexNumber & 0x0000ff00) >> 8) / 255 a = CGFloat(hexNumber & 0x000000ff) / 255 self.init(red: r, green: g, blue: b, alpha: a) return } } } return nil } // Convert UIColor to Hexadecimal String func toHexString() -> String { var r: CGFloat = 0 var g: CGFloat = 0 var b: CGFloat = 0 var a: CGFloat = 0 self.getRed(&r, green: &g, blue: &b, alpha: &a) return String( format: "%02X%02X%02X", Int(r * 0xff), Int(g * 0xff), Int(b * 0xff)) } } 

Extensión UIColor, ¡Esto te será de gran ayuda! (versión: Swift 4.0 )

 import UIKit extension UIColor { /// rgb颜色convenience init(r: CGFloat, g: CGFloat, b: CGFloat) { self.init(red: r/255.0 ,green: g/255.0 ,blue: b/255.0 ,alpha:1.0) } /// 纯色(用于灰色) convenience init(gray: CGFloat) { self.init(red: gray/255.0 ,green: gray/255.0 ,blue: gray/255.0 ,alpha:1.0) } /// 随机色class func randomCGColor() -> UIColor { return UIColor(r: CGFloat(arc4random_uniform(256)), g: CGFloat(arc4random_uniform(256)), b: CGFloat(arc4random_uniform(256))) } /// hex颜色-Int convenience init(hex:Int, alpha:CGFloat = 1.0) { self.init( red: CGFloat((hex & 0xFF0000) >> 16) / 255.0, green: CGFloat((hex & 0x00FF00) >> 8) / 255.0, blue: CGFloat((hex & 0x0000FF) >> 0) / 255.0, alpha: alpha ) } /// hex颜色-String convenience init(hexString: String){ var red: CGFloat = 0.0 var green: CGFloat = 0.0 var blue: CGFloat = 0.0 var alpha: CGFloat = 1.0 let scanner = Scanner(string: hexString) var hexValue: CUnsignedLongLong = 0 if scanner.scanHexInt64(&hexValue) { switch (hexString.characters.count) { case 3: red = CGFloat((hexValue & 0xF00) >> 8) / 15.0 green = CGFloat((hexValue & 0x0F0) >> 4) / 15.0 blue = CGFloat(hexValue & 0x00F) / 15.0 case 4: red = CGFloat((hexValue & 0xF000) >> 12) / 15.0 green = CGFloat((hexValue & 0x0F00) >> 8) / 15.0 blue = CGFloat((hexValue & 0x00F0) >> 4) / 15.0 alpha = CGFloat(hexValue & 0x000F) / 15.0 case 6: red = CGFloat((hexValue & 0xFF0000) >> 16) / 255.0 green = CGFloat((hexValue & 0x00FF00) >> 8) / 255.0 blue = CGFloat(hexValue & 0x0000FF) / 255.0 case 8: alpha = CGFloat((hexValue & 0xFF000000) >> 24) / 255.0 red = CGFloat((hexValue & 0x00FF0000) >> 16) / 255.0 green = CGFloat((hexValue & 0x0000FF00) >> 8) / 255.0 blue = CGFloat(hexValue & 0x000000FF) / 255.0 default: log.info("Invalid RGB string, number of characters after '#' should be either 3, 4, 6 or 8") } } else { log.error("Scan hex error") } self.init(red:red, green:green, blue:blue, alpha:alpha) }} 

Versión RGBA Swift 3/4

Me gusta la respuesta de @ Luca porque creo que es la más elegante.

Sin embargo , no quiero que mis colores se especifiquen en ARGB . Prefiero RGBA + también tuve que hackear en el caso de tratar con cadenas que especifican 1 carácter para cada uno de los canales ” #FFFA “.

Esta versión también agrega error tirando + elimina el carácter ‘#’ si está incluido en la cadena. Aquí está mi formulario modificado para Swift.

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

Solo un añadido a la primera respuesta

(no ha cehcked el alfa, puede necesitar agregar un if netHext > 0xffffff ):

 extension UIColor { struct COLORS_HEX { static let Primary = 0xffffff static let PrimaryDark = 0x000000 static let Accent = 0xe89549 static let AccentDark = 0xe27b2a static let TextWhiteSemiTransparent = 0x80ffffff } convenience init(red: Int, green: Int, blue: Int, alphaH: Int) { assert(red >= 0 && red < = 255, "Invalid red component") assert(green >= 0 && green < = 255, "Invalid green component") assert(blue >= 0 && blue < = 255, "Invalid blue component") assert(alphaH >= 0 && alphaH < = 255, "Invalid alpha component") self.init(red: CGFloat(red) / 255.0, green: CGFloat(green) / 255.0, blue: CGFloat(blue) / 255.0, alpha: CGFloat(alphaH) / 255.0) } convenience init(netHex:Int) { self.init(red:(netHex >> 16) & 0xff, green:(netHex >> 8) & 0xff, blue:netHex & 0xff, alphaH: (netHex >> 24) & 0xff) } } 

Swift 2.3: Extensión UIColor. Creo que es más simple.

 extension UIColor { static func colorFromHex(hexString: String, alpha: CGFloat = 1) -> UIColor { //checking if hex has 7 characters or not including '#' if hexString.characters.count < 7 { return UIColor.whiteColor() } //string by removing hash let hexStringWithoutHash = hexString.substringFromIndex(hexString.startIndex.advancedBy(1)) //I am extracting three parts of hex color Red (first 2 characters), Green (middle 2 characters), Blue (last two characters) let eachColor = [ hexStringWithoutHash.substringWithRange(hexStringWithoutHash.startIndex...hexStringWithoutHash.startIndex.advancedBy(1)), hexStringWithoutHash.substringWithRange(hexStringWithoutHash.startIndex.advancedBy(2)...hexStringWithoutHash.startIndex.advancedBy(3)), hexStringWithoutHash.substringWithRange(hexStringWithoutHash.startIndex.advancedBy(4)...hexStringWithoutHash.startIndex.advancedBy(5))] let hexForEach = eachColor.map {CGFloat(Int($0, radix: 16) ?? 0)} //radix is base of numeric system you want to convert to, Hexadecimal has base 16 //return the color by making color return UIColor(red: hexForEach[0] / 255, green: hexForEach[1] / 255, blue: hexForEach[2] / 255, alpha: alpha) } } 

Uso:

 let color = UIColor.colorFromHex("#25ac09") 

Swift 3

 extension UIColor { convenience init(r: Int, g: Int, b: Int, a: Int = 255) { self.init(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: CGFloat(a) / 255.0) } convenience init(netHex:Int) { self.init(r:(netHex >> 16) & 0xff, g:(netHex >> 8) & 0xff, b:netHex & 0xff) } } 

Utilizando:

 self.view.backgroundColor = UIColor(netHex: 0x27ae60) 

Swift 4.0

use this Single line of method

 override func viewDidLoad() { super.viewDidLoad() let color = UIColor(hexColor: "FF00A0") self.view.backgroundColor = color } 

You have to create new Class or use any controller where u need to use Hex color. This extension class provide you UIColor that will convert Hex to RGB color.

 extension UIColor { convenience init(hexColor: String) { let scannHex = Scanner(string: hexColor) var rgbValue: UInt64 = 0 scannHex.scanLocation = 0 scannHex.scanHexInt64(&rgbValue) let r = (rgbValue & 0xff0000) >> 16 let g = (rgbValue & 0xff00) >> 8 let b = rgbValue & 0xff self.init( red: CGFloat(r) / 0xff, green: CGFloat(g) / 0xff, blue: CGFloat(b) / 0xff, alpha: 1 ) } } 
 extension UIColor { convenience init(hex: Int, alpha: Double = 1.0) { self.init(red: CGFloat((hex>>16)&0xFF)/255.0, green:CGFloat((hex>>8)&0xFF)/255.0, blue: CGFloat((hex)&0xFF)/255.0, alpha: CGFloat(255 * alpha) / 255) } } 

Use this extension like:

 let selectedColor = UIColor(hex: 0xFFFFFF) let selectedColor = UIColor(hex: 0xFFFFFF, alpha: 0.5) 

I made a small function,placed it from where I can use it globally & working fine with swift 2.1:

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

uso:

 getColorFromHex(0xffffff)