Como posso codificar uma string para Base64 no Swift?

115

Quero converter uma string em Base64. Encontrei respostas em vários lugares, mas não funciona mais no Swift. Estou usando o Xcode 6.2. Acredito que a resposta pode ser trabalhar em versões anteriores do Xcode e não no Xcode 6.2.

Alguém poderia me orientar para fazer isso no Xcode 6.2?

A resposta que encontrei foi esta, mas não funciona na minha versão do 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

Ankahathara
fonte
A extensão Swift é limpa e prática. stackoverflow.com/a/46969102/1996294
Ashok

Respostas:

69

Não tenho o 6.2 instalado, mas não acho que o 6.3 seja diferente a esse respeito:

dataUsingEncoding retorna um opcional, então você precisa desembrulhar isso.

NSDataBase64EncodingOptions.fromRawfoi substituído por NSDataBase64EncodingOptions(rawValue:). Surpreendentemente, este não é um inicializador failable, então você não precisa desembrulhá-lo.

Mas, como NSData(base64EncodedString:) é um inicializador failable, você precisa desembrulhá-lo.

Aliás, todas essas mudanças foram sugeridas pelo migrador Xcode (clique na mensagem de erro na sarjeta e tem uma sugestão de “consertar”).

O código final, reescrito para evitar desempacotamento forçado, tem a seguinte aparência:

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

(se estiver usando o Swift 1.2, você pode usar vários if-lets em vez do mapa)

Atualização do Swift 5:

import Foundation

let str = "iOS Developer Tips encoded in Base64"
print("Original: \(str)")

let utf8str = str.data(using: .utf8)

if let base64Encoded = utf8str?.base64EncodedString(options: Data.Base64EncodingOptions(rawValue: 0)) {
    print("Encoded: \(base64Encoded)")

    if let base64Decoded = Data(base64Encoded: base64Encoded, options: Data.Base64DecodingOptions(rawValue: 0))
    .map({ String(data: $0, encoding: .utf8) }) {
        // Convert back to a string
        print("Decoded: \(base64Decoded ?? "")")
    }
}
Velocidade da velocidade do ar
fonte
3
Você não pode simplesmente fazer em []vez de NSDataBase64EncodingOptions(rawValue: 0)?
Brimstone
Sim você pode; Eu apenas testei. []é o valor padrão, então você pode simplesmente chamar a função sem passar nenhum parâmetro:utf8str?.base64EncodedString()
Peter Schorn
199

Rápido

import Foundation

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

}
Darkngs
fonte
Este é um código seguro, você precisa lidar com opcionais.
Mohammad Zaid Pathan,
Sintaxe do Swift 3 adicionada
Matthew Knippen de
3
Tentei converter esta string de base 64: dfYcSGpvBqyzvkAXkdbHDA==e a saída esperada tinha que ser: u�Hjo���@���mas a função acima retorna nulo. Você pode verificar a saída da string de base 64 acima nestes sites: Site1 , Site2
Chanchal Raj
@ZaidPathan, corrigido!
Darkngs
23

Você poderia simplesmente fazer uma extensão simples 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 e superior

PiXeL16
fonte
20

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))
    }
}
Miralem Cebic
fonte
Estou usando o mesmo código, mas ainda assim, o compilador fornece um erro: O valor do tipo 'Dados' não tem membro 'base64EncodedStringWithOptions' no Swift 4.0.3
Ashwini Chougale
5
Sem Data(self.utf8).base64EncodedString()opcional, seria necessário para toBase64 (). Da resposta abaixo: stackoverflow.com/a/35360697/129202
Jonny
19

Swift 4.2

"abcd1234".data(using: .utf8)?.base64EncodedString()
Den
fonte
13

Após uma pesquisa completa, encontrei a solução

Codificação

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

Decodificação

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

Mais sobre este http://creativecoefficient.net/swift/encoding-and-decoding-base64/

kamau wairegi
fonte
12

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
Leo Dabus
fonte
11

Swift 3 ou 4

let base64Encoded = Data("original string".utf8).base64EncodedString()
Greg Brown
fonte
1
Melhor resposta na página porque é atualizada, retorna um não opcional e não envolve uma operação tão simples em uma extensão.
Jano de
8

Swift 5.1 , Xcode 11 :

public extension String {

    /// Assuming the current string is base64 encoded, this property returns a String
    /// initialized by converting the current string into Unicode characters, encoded to
    /// utf8. If the current string is not base64 encoded, nil is returned instead.
    var base64Decoded: String? {
        guard let base64 = Data(base64Encoded: self) else { return nil }
        let utf8 = String(data: base64, encoding: .utf8)
        return utf8
    }

    /// Returns a base64 representation of the current string, or nil if the
    /// operation fails.
    var base64Encoded: String? {
        let utf8 = self.data(using: .utf8)
        let base64 = utf8?.base64EncodedString()
        return base64
    }

}
Constantine
fonte
Isso funciona muito bem, é um código realmente sucinto e ajudou imensamente.
raddevus
7

Swift 3/4 / 5.1

Aqui está uma Stringextensão simples , permitindo a preservação de opcionais no caso de um erro na decodificação.

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

Exemplo:

let testString = "A test string."

let encoded = testString.toBase64() // "QSB0ZXN0IHN0cmluZy4="

guard let decoded = encoded.fromBase64() // "A test string."
    else { return } 
stef
fonte
2

Depois de toda luta, eu fiz assim.

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

Depois de chamar outra função para converter string decodificada em dicionário

        self .convertStringToDictionary(decodedString as String)
    }


}//function close

// para string para dicionário

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
}
Narasimha Nallamsetty
fonte
2

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)!")
  }
}
Anil shukla
fonte
Sempre me retorna zero. Você pode por favor ajudar.
Pawan de
1

Swift 4.2

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

para decodificar, consulte (em 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)")
    }
}
spnkr
fonte
0

SwiftyBase64 (divulgação completa: eu escrevi) é uma codificação Swift Base64 nativa (sem biblioteca de decodificação. Com ela, você pode codificar Base64 padrão:

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

ou URL e nome de arquivo Safe Base64:

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

Resposta @Airspeed Velocity em 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)")
Avi Cohen
fonte