Konvertieren Sie das Array schnell in einen JSON-String

Swift 3.0 - 4.0 Version

do {

    //Convert to Data
    let jsonData = try JSONSerialization.data(withJSONObject: dictionaryOrArray, options: JSONSerialization.WritingOptions.prettyPrinted)

    //Convert back to string. Usually only do this for debugging
    if let JSONString = String(data: jsonData, encoding: String.Encoding.utf8) {
       print(JSONString)
    }

    //In production, you usually want to try and cast as the root data structure. Here we are casting as a dictionary. If the root object is an array cast as [Any].
    var json = try JSONSerialization.jsonObject(with: jsonData, options: JSONSerialization.ReadingOptions.mutableContainers) as? [String: Any]


} catch {
    print(error.description)
}

Die JSONSerialization.WritingOptions.prettyPrinted-Option gibt dem Endverbraucher ein lesbareres Format, wenn er im Debugger ausgedruckt werden soll.

Referenz: Apple-Dokumentation

Mit der Option JSONSerialization.ReadingOptions.mutableContainers können Sie die zurückgegebenen Arrays und/oder Wörterbücher mutieren. 

Referenz für alle ReadingOptions: Apple-Dokumentation

HINWEIS: Swift 4 kann Ihre Objekte mit einem neuen Protokoll codieren und decodieren. Hier ist Apples Documentation und ein Quick Tutorial für ein Startbeispiel .

Wenn Sie bereits SwiftyJSON verwenden:

https://github.com/SwiftyJSON/SwiftyJSON

Du kannst das:

// this works with dictionaries too
let paramsDictionary = [
    "title": "foo",
    "description": "bar"
]
let paramsArray = [ "one", "two" ]
let paramsJSON = JSON(paramsArray)
let paramsString = paramsJSON.rawString(encoding: NSUTF8StringEncoding, options: nil)

Swift 3 UPDATE

 let paramsJSON = JSON(paramsArray)
 let paramsString = paramsJSON.rawString(String.Encoding.utf8, options: JSONSerialization.WritingOptions.prettyPrinted)!

JSON-Zeichenfolgen, die sich gut für den Transport eignen, werden nicht oft angezeigt, da Sie einen HTTP-Body mit JSON kodieren können. Ein möglicher Anwendungsfall für JSON stringify ist Multipart Post, den AlamoFire unterstützt.

So konvertieren Sie ein Array in Swift 2.3 in einen Json-String

var yourString : String = ""
do
{
    if let postData : NSData = try NSJSONSerialization.dataWithJSONObject(yourArray, options: NSJSONWritingOptions.PrettyPrinted)
    {
        yourString = NSString(data: postData, encoding: NSUTF8StringEncoding)! as String
    }
}
catch
{
    print(error)
}

Und jetzt können Sie IhrenSting als JSON-String verwenden. 

Swift 2.0

var tempJson : NSString = ""
do {
    let arrJson = try NSJSONSerialization.dataWithJSONObject(arrInvitationList, options: NSJSONWritingOptions.PrettyPrinted)
    let string = NSString(data: arrJson, encoding: NSUTF8StringEncoding)
    tempJson = string! as NSString
}catch let error as NSError{
    print(error.description)
}

HINWEIS: - use tempJson variable, wenn Sie verwenden möchten.

Für Swift 3.0 musst du folgendes verwenden:

var postString = ""
    do {
        let data =  try JSONSerialization.data(withJSONObject: self.arrayNParcel, options: .prettyPrinted)
        let string1:String = NSString(data: data, encoding: String.Encoding.utf8.rawValue) as! String

        postString = "arrayData=\(string1)&user_id=\(userId)&markupSrcReport=\(markup)"
    } catch {
        print(error.localizedDescription)
    }
    request.httpBody = postString.data(using: .utf8)

100% arbeitsgeprüft

Hinweis: Um ein NSArray mit JSON-kompatiblen Objekten in ein NSData-Objekt zu konvertieren, das ein JSON-Dokument enthält, verwenden Sie die entsprechende Methode der NSJSONSerialization. JSONObjectWithData ist es nicht. 

Hinweis 2: Sie möchten diese Daten selten als Zeichenfolge. Nur für Debugging-Zwecke. 

Für Swift 4.2 funktioniert dieser Code immer noch einwandfrei

 var mnemonic: [String] =  ["abandon",   "amount",   "liar", "buyer"]
    var myJsonString = ""
    do {
        let data =  try JSONSerialization.data(withJSONObject:mnemonic, options: .prettyPrinted)
       myJsonString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) as! String
    } catch {
        print(error.localizedDescription)
    }
    return myJsonString

extension Array where Element: Encodable {
    func asArrayDictionary() throws -> [[String: Any]] {
        var data: [[String: Any]] = []

        for element in self {
            data.append(try element.asDictionary())
        }
        return data
    }
}

extension Encodable {
        func asDictionary() throws -> [String: Any] {
            let data = try JSONEncoder().encode(self)
            guard let dictionary = try JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any] else {
                throw NSError()
            }
            return dictionary
        }
}

Wenn Sie in Ihren Modellen codierbare Protokolle verwenden, können diese Erweiterungen hilfreich sein, um die Darstellung des Wörterbuchs zu erhalten (Swift 4)

Sie können es versuchen. 

func convertToJSONString(value: AnyObject) -> String? {
        if JSONSerialization.isValidJSONObject(value) {
            do{
                let data = try JSONSerialization.data(withJSONObject: value, options: [])
                if let string = NSString(data: data, encoding: String.Encoding.utf8.rawValue) {
                    return string as String
                }
            }catch{
            }
        }
        return nil
    }