ios - programacion - tipos de datos en swift

Funciones nativas Swift para tener números como cadenas hexagonales

Question

¿Hay alguna forma nativa de Swift para cualquier número (al menos entero) para obtener su representación hexadecimal en una cadena? Y lo inverso. No debe usar Foundation. Por ejemplo, la clase String tiene una función

func toInt() -> Int?

que convierte una cadena que representa un entero en su valor Int. Estoy buscando algo similar, usando las cadenas hexagonales. Sé que esto es fácilmente implementable, pero si Swift lo tiene allí, ya sería mejor. De lo contrario, si ya hizo una extensión de String e Int para lograr lo siguiente:

let anHex = "0xA0"
if let anInt = anHex.toInt() {
   println(anInt)               // prints 128
   println(anInt.toHexString()) // prints "0xA0"
}

Sé que no es ciencia espacial, pero en caso de que lo comparta.

PD: Esto es similar a esta pregunta , la diferencia es que estaba muy relacionado con el marco de la Fundación, mientras que no lo estoy usando en mi código (ni estoy importando nada más) y por ahora me gustaría guardarlo en de esta manera, también con fines de aprendizaje.

Answer 1

Swift 3 :

String a UInt :

let str = "fcd7d7"
let number = UInt(str, radix: 16)!
print(number)

Resultado: 16570327

UInt para hexagonal String :

let number = UInt(exactly: 16570327)!
let str = String(number, radix: 16, uppercase: false)
print(str)

resultado: fcd7d7

Answer 2

A partir de Swift 2, todos los tipos enteros tienen un constructor

init?(_ text: String, radix: Int = default)

de modo que tanto las cadenas de enteros hexadecimales como las de cadena hexadecimal a enteros pueden realizarse con métodos incorporados. Ejemplo:

let num = 1000
let str = String(num, radix: 16)
print(str) // "3e8"

if let num2 = Int(str, radix: 16) {
    print(num2) // 1000
}

(Respuesta anterior para Swift 1 :) La conversión de un número entero a una cadena hexadecimal se puede hacer con

let hex = String(num, radix: 16)

(ver, por ejemplo, Cómo convertir un número decimal a binario en Swift? ). Esto no requiere la importación de ningún Marco y funciona con cualquier base entre 2 y 36.

La conversión de una cadena hexadecimal a un entero se puede hacer con la función de biblioteca BSD strtoul() (compare Cómo convertir un binario a decimal en Swift? ) Si está dispuesto a import Darwin .

De lo contrario, no hay (hasta donde yo sé) ningún método Swift incorporado. Aquí hay una extensión que convierte una cadena en un número de acuerdo con una base dada:

extension UInt {
    init?(_ string: String, radix: UInt) {
        let digits = "0123456789abcdefghijklmnopqrstuvwxyz"
        var result = UInt(0)
        for digit in string.lowercaseString {
            if let range = digits.rangeOfString(String(digit)) {
                let val = UInt(distance(digits.startIndex, range.startIndex))
                if val >= radix {
                    return nil
                }
                result = result * radix + val
            } else {
                return nil
            }
        }
        self = result
    }
}

Ejemplo:

let hexString = "A0"
if let num = UInt(hexString, radix: 16) {
    println(num)
} else {
    println("invalid input")
}

Answer 3

Para Float, si desea IEEE754 coma flotante a HEX

extension Float {
 func floatToHex()->String {
    return String(self.bitPattern, radix: 16, uppercase: true)
 }
}
let f:Float = 3.685746e+19
let hex = f.floatToHex()

print("/(hex)")//5FFFC000

O Visa-versa

extension String {

 func hexToFloat() -> Float {
    var toInt = Int32(truncatingBitPattern: strtol(self, nil, 16))
    var float:Float32!
    memcpy(&float, &toInt, MemoryLayout.size(ofValue: float))
    return float
 }
}

Answer 4

actualización: Xcode 7.2 • Swift 2.1.1

extension String {
    var drop0xPrefix:          String { return hasPrefix("0x") ? String(characters.dropFirst(2)) : self }
    var drop0bPrefix:          String { return hasPrefix("0b") ? String(characters.dropFirst(2)) : self }
    var hexaToDecimal:            Int { return Int(drop0xPrefix, radix: 16) ?? 0 }
    var hexaToBinaryString:    String { return String(hexaToDecimal, radix: 2) }
    var decimalToHexaString:   String { return String(Int(self) ?? 0, radix: 16) }
    var decimalToBinaryString: String { return String(Int(self) ?? 0, radix: 2) }
    var binaryToDecimal:          Int { return Int(drop0bPrefix, radix: 2) ?? 0 }
    var binaryToHexaString:    String { return String(binaryToDecimal, radix: 16) }
}

extension Int {
    var toBinaryString: String { return String(self, radix: 2) }
    var toHexaString:   String { return String(self, radix: 16) }
}

Pruebas:

print("7fffffffffffffff".hexaToDecimal)      // "9223372036854775807" decimal integer
print("0x7fffffffffffffff".hexaToDecimal)    // "9223372036854775807" decimal integer
print("7fffffffffffffff".hexaToBinaryString) // "111111111111111111111111111111111111111111111111111111111111111" binary (String)
print("0x7fffffffffffffff".hexaToBinaryString) // "111111111111111111111111111111111111111111111111111111111111111"

print("255".decimalToHexaString)   // "ff"       hexa (String)
print("255".decimalToBinaryString) // "11111111" binary (String)
0b11111111

print("11111111".binaryToHexaString)      // "ff"  hexa (String)
print("0b11111111".binaryToHexaString)    // "ff"  hexa (String)
print("11111111".binaryToDecimal)         // 255 decimal (Int)
print("0b11111111".binaryToDecimal)       // 255 decimal (Int)

print(255.toBinaryString) // "11111111" binary (String)
print(255.toHexaString)   // "ff"       hexadecimal (String)