Eu tenho UTF-8 codificado NSDatano servidor Windows e quero convertê-lo NSStringpara o iPhone. Como os dados contêm caracteres (como um símbolo de grau) que possuem valores diferentes nas duas plataformas, como converter dados em sequência?

Se os dados não tiverem terminação nula, você deverá usar -initWithData:encoding:

NSString* newStr = [[NSString alloc] initWithData:theData encoding:NSUTF8StringEncoding];

Se os dados forem nulos, você deve usar -stringWithUTF8String:para evitar o extra \0no final.

NSString* newStr = [NSString stringWithUTF8String:[theData bytes]];

(Observe que, se a entrada não estiver corretamente codificada em UTF-8, você receberá nil.)

Variante rápida:

let newStr = String(data: data, encoding: .utf8)
// note that `newStr` is a `String?`, not a `String`.

Se os dados tiverem terminação nula, você poderá seguir o caminho seguro, que é remover o caractere nulo, ou o caminho não seguro, semelhante à versão Objective-C acima.

// safe way, provided data is \0-terminated
let newStr1 = String(data: data.subdata(in: 0 ..< data.count - 1), encoding: .utf8)
// unsafe way, provided data is \0-terminated
let newStr2 = data.withUnsafeBytes(String.init(utf8String:))

Você poderia chamar esse método

+(id)stringWithUTF8String:(const char *)bytes.

Humildemente, envio uma categoria para tornar isso menos irritante:

@interface NSData (EasyUTF8)

// Safely decode the bytes into a UTF8 string
- (NSString *)asUTF8String;

@end

e

@implementation NSData (EasyUTF8)

- (NSString *)asUTF8String {
    return [[NSString alloc] initWithData:self encoding:NSUTF8StringEncoding];    
}

@end

(Observe que se você não estiver usando o ARC, precisará de um autorelease.)

Agora, em vez do assustadoramente detalhado:

NSData *data = ...
[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

Você pode fazer:

NSData *data = ...
[data asUTF8String];

A versão Swift de String para Data e de volta para String:

Xcode 10.1 • Swift 4.2.1

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

extension StringProtocol {
    var data: Data {
        return Data(utf8)
    }
}

extension String {
    var base64Decoded: Data? {
        return Data(base64Encoded: self)
    }
}

Parque infantil

let string = "Hello World"                                  // "Hello World"
let stringData = string.data                                // 11 bytes
let base64EncodedString = stringData.base64EncodedString()  // "SGVsbG8gV29ybGQ="
let stringFromData = stringData.string                      // "Hello World"

let base64String = "SGVsbG8gV29ybGQ="
if let data = base64String.base64Decoded {
    print(data)                                    //  11 bytes
    print(data.base64EncodedString())              // "SGVsbG8gV29ybGQ="
    print(data.string ?? "nil")                    // "Hello World"
}

let stringWithAccent = "Olá Mundo"                          // "Olá Mundo"
print(stringWithAccent.count)                               // "9"
let stringWithAccentData = stringWithAccent.data            // "10 bytes" note: an extra byte for the acute accent
let stringWithAccentFromData = stringWithAccentData.string  // "Olá Mundo\n"

Às vezes, os métodos nas outras respostas não funcionam. No meu caso, estou gerando uma assinatura com minha chave privada RSA e o resultado é NSData. Eu descobri que isso parece funcionar:

Objetivo-C

NSData *signature;
NSString *signatureString = [signature base64EncodedStringWithOptions:0];

Rápido

let signatureString = signature.base64EncodedStringWithOptions(nil)

Apenas para resumir, aqui está uma resposta completa, que funcionou para mim.

Meu problema era que quando eu usava

[NSString stringWithUTF8String:(char *)data.bytes];

A cadeia de caracteres que obtive era imprevisível: cerca de 70% continha o valor esperado, mas muitas vezes resultava Nullou até pior: lixo no final da cadeia.

Depois de algumas escavações, mudei para

[[NSString alloc] initWithBytes:(char *)data.bytes length:data.length encoding:NSUTF8StringEncoding];

E sempre obtém o resultado esperado.

Com o Swift 5, você pode usar Stringo init(data:encoding:)inicializador para converter uma Datainstância em uma Stringinstância usando UTF-8. init(data:encoding:)tem a seguinte declaração:

init?(data: Data, encoding: String.Encoding)

Retorna um Stringinicializado convertendo dados fornecidos em caracteres Unicode usando uma determinada codificação.

O seguinte código do Playground mostra como usá-lo:

import Foundation

let json = """
{
"firstName" : "John",
"lastName" : "Doe"
}
"""

let data = json.data(using: String.Encoding.utf8)!

let optionalString = String(data: data, encoding: String.Encoding.utf8)
print(String(describing: optionalString))

/*
 prints:
 Optional("{\n\"firstName\" : \"John\",\n\"lastName\" : \"Doe\"\n}")
*/