Cómo usar los valores de color hexadecimal

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

Ejemplo: ¿Cómo utilizarí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, creamemos un inicializador que tome valores integers (0 – 255):

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

Uso:

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

¿Cómo get alfa?

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

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

O puede agregar un parámetro adicional (opcional) a los methods anteriores:

 convenience init(networking: Int, green: Int, blue: Int, a: CGFloat = 1.0) { self.init( networking: CGFloat(networking) / 255.0, green: CGFloat(green) / 255.0, blue: CGFloat(blue) / 255.0, alpha: a ) } convenience init(rgb: Int, a: CGFloat = 1.0) { self.init( networking: (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(networking: 0xFF, green: 0xFF, blue: 0xFF, a: 0.5) let color2 = UIColor(rgb: 0xFFFFFF, a: 0.5) 

Para get el alfa como un número integer 0-255, podemos

 convenience init(networking: Int, green: Int, blue: Int, a: Int = 0xFF) { self.init( networking: CGFloat(networking) / 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( networking: (argb >> 16) & 0xFF, green: (argb >> 8) & 0xFF, blue: argb & 0xFF, a: (argb >> 24) & 0xFF ) } 

Llamado

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

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

Esta es una function que toma una cadena hexadecimal y devuelve una UIColor.
(Puede ingresar cadenas hexadecimales con cualquier formatting: #ffffff o ffffff )

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( networking: 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( networking: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0, green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0, blue: CGFloat(rgbValue & 0x0000FF) / 255.0, alpha: CGFloat(1.0) ) } 

Uso:

 var color1 = hexStringToUIColor("#d3d3d3") 


Fuente: arshad / gist: de147c42d7b3063ef7bc

Editar: actualizado el código. Gracias, Hlung y jaytrixz!

Swift 3 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.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(networking: 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(networking: 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(networking: 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 function:

  // 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(networking: 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") 

Swift 3: Soporte de nombre de color Hex y CSS a través de UIColor

Código de la key

Cadenas de ejemplo:

  • 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 del patio de recreo

Esta respuesta muestra cómo hacerlo en Obj-C. El puente es 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(networking:r, green: g, blue: b, alpha: 1.0) 

Versión Swift 3 de Ethan Strider respuesta:

 func hexStringToUIColor (_ hex:String) -> UIColor { var cString:String = hex.trimmingCharacters(in: NSCharacterSet.whitespacesAndNewlines as CharacterSet).uppercased() if (cString.hasPrefix("#")) { cString = cString.substring(from: cString.characters.index(cString.startIndex, offsetBy: 1)) } if ((cString.characters.count) != 6) { return UIColor.gray } var rgbValue:UInt32 = 0 Scanner(string: cString).scanHexInt32(&rgbValue) return UIColor( networking: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0, green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0, blue: CGFloat(rgbValue & 0x0000FF) / 255.0, alpha: CGFloat(1.0) ) } 

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 networking = CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0 let green = CGFloat((rgbValue & 0xFF00) >> 8) / 255.0 let blue = CGFloat(rgbValue & 0xFF) / 255.0 return UIColor(networking:networking, green:green, blue:blue, alpha: alpha) } } 

puedes crear directamente UIColor con hex como este

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

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

 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 networking = CGFloat((rgbValue >> 16) & 0xff) / 255.0 let green = CGFloat((rgbValue >> 08) & 0xff) / 255.0 let blue = CGFloat((rgbValue >> 00) & 0xff) / 255.0 self.init(networking: networking, green: green, blue: blue, alpha: 1.0) } } 

La última versión 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(networking: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255) } } 

Úselo en su class o en cualquier lugar que haya convertido en hexcolor a uicolor como en esta forma

  let color1 = UIColor(hexString: "#FF323232") 
 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( networking: 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( networking: 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 

Swift 2.0

El código a continuación se testing 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(networking: 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(networking: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: CGFloat(alpha)) return } } 

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( networking: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0, green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0, blue: CGFloat(rgbValue & 0x0000FF) / 255.0, alpha: CGFloat(1.0) ) } 

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

 extension UIColor { convenience init(hex: Int, alpha: Double = 1.0) { self.init(networking: 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 utilícelo 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 

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(networking: 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) ) } 

}

Solo un poco de adicion a la primera respuesta

(no se ha cehcked el alfa, es posible que deba 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(networking: Int, green: Int, blue: Int, alphaH: Int) { assert(networking >= 0 && networking <= 255, "Invalid networking 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(networking: CGFloat(networking) / 255.0, green: CGFloat(green) / 255.0, blue: CGFloat(blue) / 255.0, alpha: CGFloat(alphaH) / 255.0) } convenience init(netHex:Int) { self.init(networking:(netHex >> 16) & 0xff, green:(netHex >> 8) & 0xff, blue:netHex & 0xff, alphaH: (netHex >> 24) & 0xff) } } 

Compatible con 7 types de colors hexadecimales

Hay 7 formattings de color hexadecimal: "" # FF0000 "," 0xFF0000 "," FF0000 "," F00 "," rojo ", 0x00FF00, 16711935

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

PRECAUCIÓN: esta no es una "solución de un solo file", existen algunas dependencies, pero searchlas puede ser más rápido que investigar esto desde cero.

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

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

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 networking = CGFloat(r) / 255.0 let green = CGFloat(g) / 255.0 let blue = CGFloat(b) / 255.0 self.init(networking:networking, 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(networking: 228, green: 48, blue: 56, alpha: 1.0).toHexString() 

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(networking: hexForEach[0] / 255, green: hexForEach[1] / 255, blue: hexForEach[2] / 255, alpha: alpha) } } 

Uso:

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

Para swift 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(networking: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255) } } 

Apple Shud ha construido de esta manera pero estamos personalizando para su facilidad. Para todos los que provienen de otro lenguaje de progtwigción, este método se aliviará.

Uso:

Valor RGB en decimal:

 UIColor(255,155,55) UIColor(255,155,55, 200) 

RGB Val en hexagonal:

 UIColor("FDB") UIColor("FFDDBB") UIColor("AAFFDDBB") |OR| UIColor("#FDB") UIColor("#FFDDBB") UIColor("#AAFFDDBB") 

Pegar código debajo de cualquier file fuera de la class

 extension UIColor { convenience init(_ RedPsgVar: Int, _ GrnPsgVar: Int, _ BluPsgVar: Int, _ OpcPsgVar: Int? = 255) { let RedVal = CGFloat(RedPsgVar)/255 let GrnVal = CGFloat(GrnPsgVar)/255 let BluVal = CGFloat(BluPsgVar)/255 let OpcVal = CGFloat(OpcPsgVar!)/255 self.init(networking: RedVal, green: GrnVal, blue: BluVal, alpha: OpcVal) } convenience init(_ HexPsgVar: String) { var HexVar:String = HexPsgVar.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet() as NSCharacterSet).uppercaseString if (HexVar.hasPrefix("#")) { HexVar = HexVar.substringFromIndex(HexVar.startIndex.advancedBy(1)) } var RgbVar:UInt32 = 0 NSScanner(string: HexVar).scanHexInt(&RgbVar) let OpcVal, RedVal, GrnVal, BluVal: UInt32 switch HexVar.characters.count { case 3: // RGB (12-bit) (OpcVal, RedVal, GrnVal, BluVal) = (255, (RgbVar >> 8) * 17, (RgbVar >> 4 & 0xF) * 17, (RgbVar & 0xF) * 17) case 6: // RGB (24-bit) (OpcVal, RedVal, GrnVal, BluVal) = (255, RgbVar >> 16, RgbVar >> 8 & 0xFF, RgbVar & 0xFF) case 8: // ARGB (32-bit) (OpcVal, RedVal, GrnVal, BluVal) = (RgbVar >> 24, RgbVar >> 16 & 0xFF, RgbVar >> 8 & 0xFF, RgbVar & 0xFF) default: (OpcVal, RedVal, GrnVal, BluVal) = (100, 100, 100, 100) } self.init(networking: CGFloat(RedVal) / 255, green: CGFloat(GrnVal) / 255, blue: CGFloat(BluVal) / 255, alpha: CGFloat(OpcVal) / 255) } } 
 extension UIColor { convenience init(hex: Int, alpha: Double = 1.0) { self.init(networking: 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 esta extensión como:

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

Swift 3

 extension UIColor { convenience init(r: Int, g: Int, b: Int, a: Int = 255) { self.init(networking: 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) 

Hice una pequeña function, la puse desde donde puedo usarla globalmente y funcionando bien con Swift 2.1:

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

uso:

 getColorFromHex(0xffffff) 
 extension UIColor { convenience init(r: CGFloat, g: CGFloat, b: CGFloat, a: CGFloat = 1) { self.init(networking: r/255, green: g/255, blue: b/255, alpha: a) } convenience init(hex: Int, alpha: CGFloat = 1) { self.init(r: CGFloat((hex >> 16) & 0xff), g: CGFloat((hex >> 08) & 0xff), b: CGFloat((hex >> 00) & 0xff), a: alpha) } } 

La forma más simple de agregar color mediante progtwigción es usando ColorLiteral .

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

Ejemplo: self.view.backgroundColor = ColorLiteral introduzca la descripción de la imagen aquí