Swift에서 문자열을 Base64로 인코딩하려면 어떻게 해야 하나요?

Swift에서 문자열을 Base64로 인코딩하려면 어떻게 해야 하나요?

문자열을 Base64로 변환하고 싶다.여러 곳에서 답을 찾았지만 스위프트에서는 더 이상 작동하지 않습니다.Xcode 6.2를 사용하고 있습니다.답은 Xcode 6.2가 아닌 이전 Xcode 버전에서 작동한다고 생각합니다.

Xcode 6.2에서 이 작업을 수행할 수 있도록 안내해주실 수 있나요?

제가 찾은 답변은 다음과 같습니다만, 제 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)")

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

재빠르다

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

}

6.2는 설치되어 있지 않지만 6.3은 이 점에 있어서 전혀 다르지 않다고 생각합니다.

dataUsingEncoding는 옵션을 반환하기 때문에 래핑을 해제해야 합니다.

NSDataBase64EncodingOptions.fromRaw로 대체되었습니다.NSDataBase64EncodingOptions(rawValue:)조금 의외로 이 이니셜라이저는 고장난 것이 아니기 때문에 개봉할 필요가 없습니다.

하지만 그 이후로는NSData(base64EncodedString:) 는 실패 가능성이 있는 이니셜라이저입니다.따라서 래핑을 해제해야 합니다.

그런데 이러한 모든 변경은 Xcode migrator에 의해 제안되었습니다(거터 내의 오류 메시지를 클릭하면 "fix-it" 제안이 있습니다).

강제 해제를 피하기 위해 다시 작성된 최종 코드는 다음과 같습니다.

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

(Swift 1.2를 사용하는 경우 맵 대신 여러 if-let을 사용할 수 있습니다.)

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

스위프트 4.2

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

Xcode 11.4 • Swift 5.2 이후

extension StringProtocol {
    var data: Data { Data(utf8) }
    var base64Encoded: Data { data.base64EncodedData() }
    var base64Decoded: Data? { Data(base64Encoded: string) }
}

---

extension LosslessStringConvertible {
    var string: String { .init(self) }
}

---

extension Sequence where Element == UInt8 {
    var data: Data { .init(self) }
    var base64Decoded: Data? { Data(base64Encoded: data) }
    var string: String? { String(bytes: 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.base64Decoded?.string ?? "") // iOS Developer Tips encoded in Base64

다음과 같은 간단한 확장을 수행할 수 있습니다.

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 이후

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

철저한 조사 끝에 해결책을 찾았다.

부호화

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

디코딩

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

자세한 내용은 http://creativecoefficient.net/swift/encoding-and-decoding-base64/를 참조해 주세요.

Swift 5.1, X코드 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
    }

}

스위프트 3 또는 4

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

Swift 3/4 / 5.1

여기 간단한 것이 있습니다.String디코딩 시 오류 발생 시 옵션을 유지할 수 있습니다.

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

예:

let testString = "A test string."

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

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

모든 고군분투 끝에 나는 이렇게 했다.

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

디코딩된 문자열을 사전으로 변환하기 위한 다른 함수를 호출한 후

        self .convertStringToDictionary(decodedString as String)
    }


}//function close

//문자열에서 사전으로

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
}

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

데이터를 문자열로 변환하는 간단한 예:

import Foundation

let base64EncodedString = "SGVsbG8sIFdvcmxkIQ=="

if let data = Data(base64Encoded: base64EncodedString) {
  if let str = String(data: data, encoding: .utf8) {
    print(str)  // Output: "Hello, World!"
  }
}

이 코드는 먼저 Data(base64Encoded:) 이니셜라이저를 사용하여 base64 인코딩 문자열에서 Data 개체를 만듭니다.그런 다음 String(data:encoding:) 이니셜라이저를 사용하여 데이터 개체에서 문자열을 만듭니다.

Data(base64Encoded:) 및 String(data:encoding:) 이니셜라이저는 둘 다 오류를 발생시킬 수 있으므로 잠재적인 오류를 처리하기 위해 코드를 do-catch 블록으로 랩하는 것이 좋습니다.

스위프트 4.2

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

를 참조해 주세요(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)")
    }
}

public extension String{
    ///base64EncodedString
    var base64EncodedString:String{
        if let data = data(using: .utf8){
            return data.base64EncodedString()
        }
        return ""
    }
}

SwiftyBase64(완전 공개:작성했습니다)는 네이티브 Swift Base64 인코딩입니다(디코딩 라이브러리 없음).이것에 의해, 표준 Base64 를 부호화할 수 있습니다.

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

또는 URL 및 파일 이름 Safe Base64:

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

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

언급URL : https://stackoverflow.com/questions/29365145/how-can-i-encode-a-string-to-base64-in-swift