Ios 在swift中将数组转换为JSON字符串

如何在swift中将数组转换为JSON字符串？ 基本上我有一个文本字段，里面有一个按钮。 按下按钮时，文本字段文本将添加到

testArray

。 此外，我想将此数组转换为JSON字符串

这就是我尝试过的：

func addButtonPressed() {
    if goalsTextField.text == "" {
        // Do nothing
    } else {
        testArray.append(goalsTextField.text)
        goalsTableView.reloadData()
        saveDatatoDictionary()
    }
}

func saveDatatoDictionary() {
    data = NSKeyedArchiver.archivedDataWithRootObject(testArray)
    newData = NSJSONSerialization.JSONObjectWithData(data!, options: NSJSONReadingOptions(), error: nil) as? NSData
    string = NSString(data: newData!, encoding: NSUTF8StringEncoding) 
    println(string)
}

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)

struct Person: Codable {
    var name: String
    var pets: [Pet]
}

struct Pet: Codable {
    var type: String
}

extension Person {
    static func sampleData() -> [Person] {
        [
            Person(name: "Adam", pets: []),
            Person(name: "Jane", pets: [
                    Pet(type: "Cat")
            ]),
            Person(name: "Robert", pets: [
                    Pet(type: "Cat"),
                    Pet(type: "Rabbit")
            ])
        ]
    }
}

JSONEncoder.encode(from: Person.sampleData())

---

我还想使用我的

saveToDictionary（）

方法返回JSON字符串。

提示：要将包含JSON兼容对象的NSArray转换为包含JSON文档的NSData对象，请使用适当的NSJSONSerialization方法。JSONObjectWithData不是它

---

提示2：您很少希望该数据作为字符串；仅用于调试目的

目前，您正在将其转换为数据，然后尝试将数据转换为JSON形式的对象（失败，它不是JSON）并将其转换为字符串，基本上您有一系列无意义的转换

只要数组只包含JSON可编码的值（字符串、数字、字典、数组、nil），就可以使用NSJSONSerialization来实现

相反，只需执行数组->数据->字符串部分：

Swift 3/4

let array = [ "one", "two" ]

func json(from object:Any) -> String? {
    guard let data = try? JSONSerialization.data(withJSONObject: object, options: []) else {
        return nil
    }
    return String(data: data, encoding: String.Encoding.utf8)
}

print("\(json(from:array as Any))")

原始答案

let array = [ "one", "two" ]
let data = NSJSONSerialization.dataWithJSONObject(array, options: nil, error: nil)
let string = NSString(data: data!, encoding: NSUTF8StringEncoding)

---

虽然您可能不应该使用强制展开，但它为您提供了正确的起点。

如果您已经在使用SwiftyJSON：

您可以这样做：

// 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更新

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

---

有利于传输的JSON字符串不会经常出现，因为您可以对HTTP主体进行JSON编码。但是JSON stringify的一个潜在用例是多部分Post，AlamoFire现在支持它。

Swift 3.0-4.0版本

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

JSONSerialization.WritingOptions.prettyPrinted

选项为最终使用者提供了一种更易于阅读的格式，如果他们要在调试器中打印出来的话

参考：

JSONSerialization.ReadingOptions.mutableContainers

选项允许您修改返回的数组和/或字典

所有阅读选项的参考：

---

注意：Swift 4能够使用新协议对对象进行编码和解码。这是，还有一个。

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

---

注意：-如果要使用，请使用tempJson变量。

如何在swift 2.3中将数组转换为json字符串

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

---

现在您可以将您的Sting用作JSON字符串

对于Swift 3.0，您必须使用以下命令：

func addButtonPressed() {
    if goalsTextField.text == "" {
        // Do nothing
    } else {
        testArray.append(goalsTextField.text)
        goalsTableView.reloadData()
        saveDatatoDictionary()
    }
}

func saveDatatoDictionary() {
    data = NSKeyedArchiver.archivedDataWithRootObject(testArray)
    newData = NSJSONSerialization.JSONObjectWithData(data!, options: NSJSONReadingOptions(), error: nil) as? NSData
    string = NSString(data: newData!, encoding: NSUTF8StringEncoding) 
    println(string)
}

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)

struct Person: Codable {
    var name: String
    var pets: [Pet]
}

struct Pet: Codable {
    var type: String
}

extension Person {
    static func sampleData() -> [Person] {
        [
            Person(name: "Adam", pets: []),
            Person(name: "Jane", pets: [
                    Pet(type: "Cat")
            ]),
            Person(name: "Robert", pets: [
                    Pet(type: "Cat"),
                    Pet(type: "Rabbit")
            ])
        ]
    }
}

JSONEncoder.encode(from: Person.sampleData())

100%工作测试

您可以试试这个

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
    }

---

如果您在模型中使用可编码协议，这些扩展可能有助于获取字典表示形式（Swift 4）

对于Swift 4.2，这些代码仍然可以正常工作

 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

---

Swift 5

确保您的对象确认

Codable

Swift的默认变量类型，如Int、String、Double和…，都是

Codable

，这意味着我们可以将主题转换为数据，反之亦然

例如，让我们将Int数组转换为字符串Base64

let array = [1, 2, 3]
let data = try? JSONEncoder().encode(array)
nsManagedObject.array = data?.base64EncodedString()

如果对核心数据对象使用自定义类，请确保核心数据架构编辑器和自定义类中的

NSManaged

变量类型为

String

让我们将base64字符串转换回数组：

var getArray: [Int] {
    guard let array = array else { return [] }
    guard let data = Data(base64Encoded: array) else { return [] }
    guard let val = try? JSONDecoder().decode([Int].self, from: data) else { return [] }
    return val
}

---

不要将您自己的对象转换为

Base64

并在CoreData中存储为字符串，反之亦然，因为我们在CoreData（数据库）中有一个名为

关系的对象。
Swift 5

此通用的
扩展
将对象的
数组
转换为JSON
字符串
，该字符串可以是：


保存到应用程序的文档目录（iOS/MacOS）
直接输出到桌面上的文件（MacOS）


用法：

func addButtonPressed() {
    if goalsTextField.text == "" {
        // Do nothing
    } else {
        testArray.append(goalsTextField.text)
        goalsTableView.reloadData()
        saveDatatoDictionary()
    }
}

func saveDatatoDictionary() {
    data = NSKeyedArchiver.archivedDataWithRootObject(testArray)
    newData = NSJSONSerialization.JSONObjectWithData(data!, options: NSJSONReadingOptions(), error: nil) as? NSData
    string = NSString(data: newData!, encoding: NSUTF8StringEncoding) 
    println(string)
}

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)

struct Person: Codable {
    var name: String
    var pets: [Pet]
}

struct Pet: Codable {
    var type: String
}

extension Person {
    static func sampleData() -> [Person] {
        [
            Person(name: "Adam", pets: []),
            Person(name: "Jane", pets: [
                    Pet(type: "Cat")
            ]),
            Person(name: "Robert", pets: [
                    Pet(type: "Cat"),
                    Pet(type: "Rabbit")
            ])
        ]
    }
}

JSONEncoder.encode(from: Person.sampleData())

输出：

func addButtonPressed() {
    if goalsTextField.text == "" {
        // Do nothing
    } else {
        testArray.append(goalsTextField.text)
        goalsTableView.reloadData()
        saveDatatoDictionary()
    }
}

func saveDatatoDictionary() {
    data = NSKeyedArchiver.archivedDataWithRootObject(testArray)
    newData = NSJSONSerialization.JSONObjectWithData(data!, options: NSJSONReadingOptions(), error: nil) as? NSData
    string = NSString(data: newData!, encoding: NSUTF8StringEncoding) 
    println(string)
}

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)

struct Person: Codable {
    var name: String
    var pets: [Pet]
}

struct Pet: Codable {
    var type: String
}

extension Person {
    static func sampleData() -> [Person] {
        [
            Person(name: "Adam", pets: []),
            Person(name: "Jane", pets: [
                    Pet(type: "Cat")
            ]),
            Person(name: "Robert", pets: [
                    Pet(type: "Cat"),
                    Pet(type: "Rabbit")
            ])
        ]
    }
}

JSONEncoder.encode(from: Person.sampleData())

这将创建以下格式正确的
Output.json
文件：

[
  {
    "name" : "Adam",
    "pets" : [

    ]
  },
  {
    "name" : "Jane",
    "pets" : [
      {
        "type" : "Cat"
      }
    ]
  },
  {
    "name" : "Robert",
    "pets" : [
      {
        "type" : "Cat"
      },
      {
        "type" : "Rabbit"
      }
    ]
  }
]

我试图先将“testArray”转换为NSData格式，然后再转换为json。感谢您的响应WiftyJSON是一个比在Swift中处理NSString更优雅/快捷的解决方案。但我建议使用
if let str=json.rawString（）…
来检测是否出现了问题，并返回nil。使用上面的swiftyjson片段，我得到了
“[\'one\”，\'two\”]”
，我现在如何将其返回到原始字符串数组？感谢您不能让Swift推断某些参数的类型–例如
让jsonData=尝试JSONSerialization.data（使用JSONObject:DictionaryArray，选项：。预打印）
–
字符串（数据：jsonData，编码：.utf8）
。另外，如果您要强制转换到本机Swift集合，则不需要使用
.mutableContainers
选项。使用上面的代码片段，我得到了
“[\'one\'，\'two\']””
，现在如何将其转换回字符串数组？thanks@sweepez我认为您看到的只是调试器的一个工件。它当然可以工作，但为什么要注释
String
，而初始化
NSString
，并强制转换为
String
<代码>让string1=String（数据：数据，编码：.utf8）已足够。在Swift中根本不要使用
NSString
。需要单独转换数组，这就是为什么相信我，不需要使用
NSString
。始终使用本机Swift
字符串
。这种转变是毫无疑问的。