codificacion - ¿Cómo puedo codificar una cadena a Base64 en Swift?

swift 4 string to base64

Question

Quiero convertir una cadena a Base64. Encontré respuestas en varios lugares, pero ya no funciona en Swift. Estoy usando Xcode 6.2. Creo que la respuesta podría funcionar en versiones anteriores de Xcode y no en Xcode 6.2.

¿Podría alguien guiarme para hacer esto en Xcode 6.2?

La respuesta que encontré fue esta, pero no funciona en mi versión de Xcode:

var str = "iOS Developer Tips encoded in Base64"
println("Original: /(str)")
// UTF 8 str from original
// NSData! type returned (optional)
let utf8str = str.dataUsingEncoding(NSUTF8StringEncoding)
// Base64 encode UTF 8 string
// fromRaw(0) is equivalent to objc ''base64EncodedStringWithOptions:0''
// Notice the unwrapping given the NSData! optional
// NSString! returned (optional)
let base64Encoded = utf8str.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.fromRaw(0)!)
println("Encoded: /(base64Encoded)")
// Base64 Decode (go back the other way)
// Notice the unwrapping given the NSString! optional
// NSData returned
let data = NSData(base64EncodedString: base64Encoded, options: NSDataBase64DecodingOptions.fromRaw(0)!)
// Convert back to a string
let base64Decoded = NSString(data: data, encoding: NSUTF8StringEncoding)
println("Decoded: /(base64Decoded)")

ref: http://iosdevelopertips.com/swift-code/base64-encode-decode-swift.html

Answer 1

Después de toda lucha, me gustó esto.

func conversion(str:NSString)
{
if let decodedData = NSData(base64EncodedString: str as String, options:NSDataBase64DecodingOptions(rawValue: 0)),
let decodedString = NSString(data: decodedData, encoding: NSUTF8StringEncoding) {
print(decodedString)//Here we are getting decoded string

Después de llamar a otra función para convertir cadenas decodificadas a diccionario

 self .convertStringToDictionary(decodedString as String)
}
}//function close

// para la cadena al diccionario

func convertStringToDictionary(text: String) -> [String:AnyObject]? {
if let data = text.dataUsingEncoding(NSUTF8StringEncoding) {
do {
let json = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [String:AnyObject]
print(json)
if let stack = json!["cid"] //getting key value here
{
customerID = stack as! String
print(customerID)
}
} catch let error as NSError {
print(error)
}
}
return nil
}

Answer 2

Después de una investigación exhaustiva, encontré la solución

Codificación

 let decodedData = NSData(base64EncodedString: base64String, options:NSDataBase64DecodingOptions.fromRaw(0)!)
let decodedString = NSString(data: decodedData, encoding: NSUTF8StringEncoding)
println(decodedString) // my plain data

Descodificación

"abcd1234".data(using: .utf8)?.base64EncodedString()

Más sobre esto http://creativecoefficient.net/swift/encoding-and-decoding-base64/

Answer 3

No tengo 6.2 instalado, pero no creo que 6.3 sea diferente a este respecto:

dataUsingEncoding devuelve un opcional, por lo que debe desenvolverlo.

NSDataBase64EncodingOptions.fromRaw ha sido reemplazado por NSDataBase64EncodingOptions(rawValue:) . Sorprendentemente, este no es un inicializador disponible, por lo que no necesita desenvolverlo.

Pero dado que NSData(base64EncodedString:) es un inicializador fallable, debe desenvolverlo.

Por cierto, todos estos cambios fueron sugeridos por el migrador de Xcode (haga clic en el mensaje de error en la canaleta y tiene una sugerencia de "arreglarlo").

El código final, reescrito para evitar desenredos forzados, se ve así:

import Foundation
let str = "iOS Developer Tips encoded in Base64"
println("Original: /(str)")
let utf8str = str.dataUsingEncoding(NSUTF8StringEncoding)
if let base64Encoded = utf8str?.base64EncodedStringWithOptions(NSDataBase64EncodingOptions(rawValue: 0))
{
println("Encoded: /(base64Encoded)")
if let base64Decoded = NSData(base64EncodedString: base64Encoded, options: NSDataBase64DecodingOptions(rawValue: 0))
.map({ NSString(data: $0, encoding: NSUTF8StringEncoding) })
{
// Convert back to a string
println("Decoded: /(base64Decoded)")
}
}

(si usa Swift 1.2, podría usar múltiples if-lets en lugar del mapa)

Answer 4

Podrías hacer una extensión simple como:

import UIKit
// MARK: - Mixed string utils and helpers
extension String {
/**
Encode a String to Base64
:returns:
*/
func toBase64()->String{
let data = self.dataUsingEncoding(NSUTF8StringEncoding)
return data!.base64EncodedStringWithOptions(NSDataBase64EncodingOptions(rawValue: 0))
}
}

iOS 7 y superior

Answer 5

Respuesta de @Airspeed Velocity en Swift 2.0:

let str = "iOS Developer Tips encoded in Base64"
print("Original: /(str)")
let base64Encoded = str.dataUsingEncoding(NSUTF8StringEncoding)!.base64EncodedStringWithOptions([])
print("Encoded: /(base64Encoded)")
let base64DecodedData = NSData(base64EncodedString: base64Encoded, options: [])!
var base64DecodedString = String(data: base64DecodedData, encoding: NSUTF8StringEncoding)!
print("Decoded: /(base64DecodedString)")

Answer 6

Swift 3 o 4

let base64Encoded = Data("original string".utf8).base64EncodedString()

Answer 7

Swift 4.2

var base64String = "my fancy string".data(using: .utf8, allowLossyConversion: false)?.base64EncodedString()

para decodificar, ver (de https://gist.github.com/stinger/a8a0381a57b4ac530dd029458273f31a )

//: # Swift 3: Base64 encoding and decoding
import Foundation
extension String {
//: ### Base64 encoding a string
func base64Encoded() -> String? {
if let data = self.data(using: .utf8) {
return data.base64EncodedString()
}
return nil
}
//: ### Base64 decoding a string
func base64Decoded() -> String? {
if let data = Data(base64Encoded: self) {
return String(data: data, encoding: .utf8)
}
return nil
}
}
var str = "Hello, playground"
print("Original string: /"/(str)/"")
if let base64Str = str.base64Encoded() {
print("Base64 encoded string: /"/(base64Str)/"")
if let trs = base64Str.base64Decoded() {
print("Base64 decoded string: /"/(trs)/"")
print("Check if base64 decoded string equals the original string: /(str == trs)")
}
}

Answer 8

SwiftyBase64 (divulgación completa: lo escribí) es una codificación nativa de Swift Base64 (sin biblioteca de decodificación. Con ella, puede codificar Base64 estándar:

let bytesToEncode : [UInt8] = [1,2,3]
let base64EncodedString = SwiftyBase64.EncodeString(bytesToEncode)

o URL y nombre de archivo Safe Base64:

let bytesToEncode : [UInt8] = [1,2,3]
let base64EncodedString = SwiftyBase64.EncodeString(bytesToEncode, alphabet:.URLAndFilenameSafe)

Answer 9

PARA SWIFT 3.0

let str = "iOS Developer Tips encoded in Base64"
print("Original: /(str)")
let utf8str = str.data(using: String.Encoding.utf8)
if let base64Encoded = utf8str?.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))
{
print("Encoded: /(base64Encoded)")
if let base64Decoded = NSData(base64Encoded: base64Encoded, options: NSData.Base64DecodingOptions(rawValue: 0))
.map({ NSString(data: $0 as Data, encoding: String.Encoding.utf8.rawValue) })
{
// Convert back to a string
print("Decoded: /(base64Decoded)!")
}
}

Answer 10

Rápido

import UIKit
extension String {
func fromBase64() -> String? {
guard let data = Data(base64Encoded: self) else {
return nil
}
return String(data: data, encoding: .utf8)
}
func toBase64() -> String {
return Data(self.utf8).base64EncodedString()
}
}

Answer 11

Swift 3

Aquí hay una extensión de String simple actualizada para Swift 3, que permite preservar opciones en caso de un error al decodificar.

extension String {
/// Encode a String to Base64
func toBase64() -> String {
return Data(self.utf8).base64EncodedString()
}
/// Decode a String from Base64. Returns nil if unsuccessful.
func fromBase64() -> String? {
guard let data = Data(base64Encoded: self) else { return nil }
return String(data: data, encoding: .utf8)
}
}

Ejemplo:

let testString = "A test string."
let encoded = testString.toBase64() // "QSB0ZXN0IHN0cmluZy4="
guard let decoded = encoded.fromBase64() // "A test string."
else { return } 

Answer 12

Swift 4.0.3

import UIKit
extension String {
func fromBase64() -> String? {
guard let data = Data(base64Encoded: self, options: Data.Base64DecodingOptions(rawValue: 0)) else {
return nil
}
return String(data: data as Data, encoding: String.Encoding.utf8)
}
func toBase64() -> String? {
guard let data = self.data(using: String.Encoding.utf8) else {
return nil
}
return data.base64EncodedString(options: Data.Base64EncodingOptions(rawValue: 0))
}
}

Answer 13

Swift 4.2

 let plainData = (plainString as NSString).dataUsingEncoding(NSUTF8StringEncoding)
let base64String =plainData.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.fromRaw(0)!)
println(base64String) // bXkgcGxhbmkgdGV4dA==

Answer 14

Xcode 8.3.2 • Swift 3.1

extension String {
var data: Data { return Data(utf8) }
var base64Encoded: Data { return data.base64EncodedData() }
var base64Decoded: Data? { return Data(base64Encoded: self) }
}
extension Data {
var string: String? { return String(data: self, encoding: .utf8) }
}

let original = "iOS Developer Tips encoded in Base64"
let utf8Data = original.data // 36 bytes
let base64EncodedString = utf8Data.base64EncodedString() // aU9TIERldmVsb3BlciBUaXBzIGVuY29kZWQgaW4gQmFzZTY0/n"
let base64EncodedData = utf8Data.base64EncodedData() // 48 bytes"
print("base64EncodedData:", original.base64Encoded) // 48 bytes
print("base64EncodedString:", original.base64Encoded.string ?? "") // "aU9TIERldmVsb3BlciBUaXBzIGVuY29kZWQgaW4gQmFzZTY0"
print("base64DecodedData:", original.base64Encoded.string?.base64Decoded ?? "") // 36 bytes
print("base64DecodedString:", original.base64Encoded.string?.base64Decoded?.string ?? "") // iOS Developer Tips encoded in Base64