Wie kann ich einen String von UTF-8 in Swift?

Es ist möglich, konvertieren in UTF8-code verweist auf einen Swift String idiomatically mit der UTF8 Swift Klasse. Obwohl es viel einfacher ist die Konvertierung von String nach UTF8!

import Foundation

public class UTF8Encoding {
  public static func encode(bytes: Array<UInt8>) -> String {
    var encodedString = ""
    var decoder = UTF8()
    var generator = bytes.generate()
    var finished: Bool = false
    do {
      let decodingResult = decoder.decode(&generator)
      switch decodingResult {
      case .Result(let char):
        encodedString.append(char)
      case .EmptyInput:
        finished = true
      /* ignore errors and unexpected values */
      case .Error:
        finished = true
      default:
        finished = true
      }
    } while (!finished)
    return encodedString
  }

  public static func decode(str: String) -> Array<UInt8> {
    var decodedBytes = Array<UInt8>()
    for b in str.utf8 {
      decodedBytes.append(b)
    }
    return decodedBytes
  }
}

func testUTF8Encoding() {
  let testString = "A UTF8 String With Special Characters: ??"
  let decodedArray = UTF8Encoding.decode(testString)
  let encodedString = UTF8Encoding.encode(decodedArray)
  XCTAssert(encodedString == testString, "UTF8Encoding is lossless: \(encodedString) != \(testString)")
}

Die anderen alternativen vorgeschlagen:

• Mit NSString ruft die Objective-C-Brücke;

• Mit UnicodeScalar ist Fehler-anfällig, weil es wandelt UnicodeScalars direkt zu Zeichen, zu ignorieren komplexe grapheme Cluster; und

• Mit String.fromCString ist potenziell unsicher, wie es verwendet Zeiger.

InformationsquelleAutor Tim WB

Habe ich für eine umfassende Antwort bezüglich der string-manipulation in Swift selbst. Unter Berufung auf Stimmen, um und aus NSString und andere unsichere Zeiger Magie war einfach nicht tun es für mich. Hier ist eine sichere alternative:

Ersten, wir wollen verlängern UInt8. Dies ist der primitive Typ hinter CodeUnit.

extension UInt8 {
    var character: Character {
        return Character(UnicodeScalar(self))
    }
}

Dies wird uns erlauben, so etwas zu tun:

let codeUnits: [UInt8] = [
    72, 69, 76, 76, 79
]

let characters = codeUnits.map { $0.character }
let string     = String(characters)

// string prints "HELLO"

Ausgestattet mit dieser Erweiterung können wir nun ändern von strings.

let string = "ABCDEFGHIJKLMONP"

var modifiedCharacters = [Character]()
for (index, utf8unit) in string.utf8.enumerate() {

    //Insert a "-" every 4 characters
    if index > 0 && index % 4 == 0 {
        let separator: UInt8 = 45 //"-" in ASCII
        modifiedCharacters.append(separator.character)
    }
    modifiedCharacters.append(utf8unit.character)
}

let modifiedString = String(modifiedCharacters)

// modified string == "ABCD-EFGH-IJKL-MONP"

InformationsquelleAutor dbart

Ich würde so etwas tun, kann es nicht so elegant als die Arbeit mit den 'Zeiger', aber es macht den job gut, das sind ziemlich genau über ein paar neue += Betreiber für String wie:

@infix func += (inout lhs: String, rhs: (unit1: UInt8)) {
    lhs += Character(UnicodeScalar(UInt32(rhs.unit1)))
}

@infix func += (inout lhs: String, rhs: (unit1: UInt8, unit2: UInt8)) {
    lhs += Character(UnicodeScalar(UInt32(rhs.unit1) << 8 | UInt32(rhs.unit2)))
}

@infix func += (inout lhs: String, rhs: (unit1: UInt8, unit2: UInt8, unit3: UInt8, unit4: UInt8)) {
    lhs += Character(UnicodeScalar(UInt32(rhs.unit1) << 24 | UInt32(rhs.unit2) << 16 | UInt32(rhs.unit3) << 8 | UInt32(rhs.unit4)))
}

HINWEIS: Sie können erweitern die Liste der unterstützten Operatoren mit übergeordneten + Betreiber als auch, die Definition einer Liste der vollständig kommutativen Operatoren für String.

und jetzt sind Sie in der Lage, fügen Sie eine String mit unicode (UTF-8, UTF-16 oder UTF-32) Zeichen wie z.B.:

var string: String = "signs of the Zodiac: "
string += (0x0, 0x0, 0x26, 0x4b)
string += (38)
string += (0x26, 76)

InformationsquelleAutor holex

Wenn Sie beginnen, mit einem raw-Puffer, wie aus den Daten-Objekt zurückgegeben, die von einem Datei-handle (in diesem Fall aus einer Pipe object):

let data = pipe.fileHandleForReading.readDataToEndOfFile()
var unsafePointer = UnsafeMutablePointer<UInt8>.allocate(capacity: data.count)

data.copyBytes(to: unsafePointer, count: data.count)

let output = String(cString: unsafePointer)

InformationsquelleAutor johnkzin

Es ist Swift 3.0-version Martin R Antwort

public class UTF8Encoding {
  public static func encode(bytes: Array<UInt8>) -> String {
    var encodedString = ""
    var decoder = UTF8()
    var generator = bytes.makeIterator()
    var finished: Bool = false
    repeat {
      let decodingResult = decoder.decode(&generator)
      switch decodingResult {
      case .scalarValue(let char):
        encodedString += "\(char)"
      case .emptyInput:
        finished = true
      case .error:
        finished = true
      }
    } while (!finished)
    return encodedString
  }
  public static func decode(str: String) -> Array<UInt8> {
    var decodedBytes = Array<UInt8>()
    for b in str.utf8 {
      decodedBytes.append(b)
    }
    return decodedBytes
  }
}

Wenn Sie möchten, zeigen emoji von UTF-8-string nur Benutzer convertEmojiCodesToString Methode unten. Es funktioniert für Zeichenketten wie "U+1F52B" (emoji) oder "U+1F1E6 U+1F1F1" (Land-flag emoji)

class EmojiConverter {
  static func convertEmojiCodesToString(_ emojiCodesString: String) -> String {
    let emojies = emojiCodesString.components(separatedBy: " ")
    var resultString = ""
    for emoji in emojies {
      var formattedCode = emoji
      formattedCode.slice(from: 2, to: emoji.length)
      formattedCode = formattedCode.lowercased()
      if let charCode = UInt32(formattedCode, radix: 16),
        let unicode = UnicodeScalar(charCode) {
        let str = String(unicode)
        resultString += "\(str)"
      }
    }
    return resultString
  }
}

InformationsquelleAutor Alex Shoshiashvili