swift（4）
编程学习（3）
(转载自:http://blog.csdn.net/ios_of_swift/article/details/)
1.在swift1.0时代，解析的前几句可能是这样的
或者是这样的
但是一旦你用在Swift2.0里面就......Extra argument ’error‘ in call了
然后我就必应了一下
发现Swift2.0的拋错误的正确姿势是这样的
顿时hehe了
所以说应该这样写喽
原来如此，这里Swift2.0的抛错误方式再也不是error:nil了
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：8583次
排名：千里之外
(1)(2)(2)(3)(1)如何在 Swift 中优雅地处理 JSON - 技术翻译 - 开源中国社区
如何在 Swift 中优雅地处理 JSON
【已翻译100%】
英文原文：
推荐于 3年前 (共 4 段, 翻译完成于 07-22)
参与翻译&(3人)&: ,
因为Swift对于类型有非常严格的控制，它在处理JSON时是挺麻烦的，因为它天生就是隐式类型。SwiftyJSON是一个能帮助我们在Swift中使用JSON的开源类库。开始之前，让我们先看一下在Swift中处理JSON是多么痛苦。
在Swift中使用JSON的问题
以Twitter API为例。使用Swift，应该非常简单。下面就是我们要处理的JSON：
&&&&......
&&&&"text":&"just&another&test",
&&&&......
&&&&"user":&{
&&&&&&"name":&"OAuth&Dancer",
&&&&&&"favourites_count":&7,
&&&&&&"entities":&{
&&&&&&&&"url":&{
&&&&&&&&&&"urls":&[
&&&&&&&&&&&&{
&&&&&&&&&&&&&&"expanded_url":&null,
&&&&&&&&&&&&&&"url":&"http://bit.ly/oauth-dancer",
&&&&&&&&&&&&&&"indices":&[
&&&&&&&&&&&&&&&&0,
&&&&&&&&&&&&&&&&26
&&&&&&&&&&&&&&],
&&&&&&&&&&&&&&"display_url":&null
&&&&&&&&&&&&}
&&&&&&&&&&]
&&&&&&......
&&&&"in_reply_to_screen_name":&null,
在Swift中，你必须这样使用：
let&jsonObject&:&AnyObject!&=&NSJSONSerialization.JSONObjectWithData(dataFromTwitter,&options:&NSJSONReadingOptions.MutableContainers,&error:&nil)
if&let&statusesArray&=&jsonObject&as?&NSArray{
&&&&if&let&aStatus&=&statusesArray[0]&as?&NSDictionary{
&&&&&&&&if&let&user&=&aStatus["user"]&as?&NSDictionary{
&&&&&&&&&&&&if&let&userName&=&user["name"]&as?&NSDictionary{
&&&&&&&&&&&&&&&&//Finally&We&Got&The&Name
&&&&&&&&&&&&}
或者，你可以用另外的一个方法，但这不易于阅读：
let&jsonObject&:&AnyObject!&=&NSJSONSerialization.JSONObjectWithData(dataFromTwitter,&options:&NSJSONReadingOptions.MutableContainers,&error:&nil)
if&let&userName&=&(((jsonObject&as?&NSArray)?[0]&as?&NSDictionary)?["user"]&as?&NSDictionary)?["name"]{
&&//What&A&disaster&above
&翻译得不错哦！
下载在下载SwiftyJSON,或者直接在GitHub克隆它：
git&clone&/lingoer/SwiftyJSON.git
SwiftyJSON的使用十分的简单：
典型的NSURLSessionTask抓取Twitter的API将产生dataFromNetwork: NSData!：
你首先应该做的事情是初始化JSONValue：
let&json&=&JSONValue(dataFromNetwork)
JSONValue是一个枚举类型表示一个典型的JSON数据结构。
你能使用subscripts检索不同的值从原始的JSONValue中，像这样：
let&userName:JSONValue&=&json[0]["user"]["name"]
注意userName仍然是一个JSONValue。那怎样得到一个字符串呢？
你能用.string属性得到JSON数据表示的真正值。
let&userNameString&=&userName.string!
对每一种JSON类型， JSONValue都提供了一种属性检索它：
var&string:&String?
var&number:&NSNumber?
var&bool:&Bool?&
var&array:&Array&JSONValue&?
var&object:&Dictionary&String,&JSONValue&?
注意每一种属性都是一个Optional值。这是因为JSON数据能包含任何它定义的有效类型。
因此，建议的方式是用Optional绑定检索值：
if&let&name&=&userName.string{
&&&&//This&could&avoid&lots&of&crashes&caused&by&the&unexpected&data&types
if&let&name&=&userName.number{
&&&&//As&the&value&of&the&userName&is&Not&a&number.&It&won't&execute.
.number属性产生一个NSNumber值，在Swift中这通常不是很有用。你能用.double或者.integer得到一个Double值或者一个Int值。
if&let&intValue&=&numberValue.integer{
&&&&count&+=&intValue
&翻译得不错哦！
枚举（Enumeration）
在Swift中JSONValue实际上是一个枚举：
enum&JSONValue&{
&&&&case&JNumber(NSNumber)
&&&&case&JString(String)
&&&&case&JBool(Bool)
&&&&case&JNull
&&&&case&JArray(Array&JSONValue&)
&&&&case&JObject(Dictionary&String,JSONValue&)
&&&&case&JInvalid(NSError)
你可以使用一个switch子句去更有效地获取值：
let&json&=&JSONValue(jsonObject)
switch&json["user_id"]{
case&.JString(let&stringValue):
&&&&let&id&=&stringValue.toInt()
case&.JNumber(let&numberValue):
&&&&let&id&=&numberValue.integerValue
&&&&println("ooops!!!&JSON&Data&is&Unexpected&or&Broken")
下标（Subscripts）
注意，在JSON中一个数组结构被包装成intoArray&JSONVlaue&，它意味着数组里的每一个元素都是一个JSONValue。甚至你从JSONValue中取出一个数组，你仍然可以使用基本的属性去获取元素的值：
if&let&array&=&json["key_of_array"].array{
&&&&if&let&string&=&array[0].string{
&&&&&&&&//The&array[0]&is&still&a&JSONValue!
对象也是一样。因此，推荐的方式是访问每一个数组和对象时使用JSONValue的下标。
if&let&string&=&json["key_of_array"][0].string{
实际上，你可以用下标访问一个JSONValue，还不用担心运行时错误导致的崩溃：
let&userName&=&json[99999]["wrong_key"]
如果你使用推荐的方式去取数据，它是安全的：
if&let&userName&=&json[99999]["wrong_key"]["name"].string{
&&&&//It's&always&safe
&翻译得不错哦！
JSONValue遵守Printable协议.所以很容易在原始字符串中得到JSON数据:
let&json&=&JSONValue(dataFromNetwork)
println(json)
/*You&can&get&a&well&printed&human&readable&raw&JSON&string:
&&&&&&&&"url":&{
&&&&&&&&&&"urls":&[
&&&&&&&&&&&&{
&&&&&&&&&&&&&&"expanded_url":&null,
&&&&&&&&&&&&&&"url":&"http://bit.ly/oauth-dancer",
&&&&&&&&&&&&&&"indices":&[
&&&&&&&&&&&&&&&&0,
&&&&&&&&&&&&&&&&26
&&&&&&&&&&&&&&],
&&&&&&&&&&&&&&"display_url":&null
&&&&&&&&&&&&}
&&&&&&&&&&]
如果你不想打印出来，你可以使用.description属性来得到上述字符串。
let&printableString&=&json.description
调试与错误处理
要是JSON数据出错或者我们错误地检索数据，那会怎么样呢？你可以使用if语句来测试：
let&json&=&JSONValue(dataFromNetworking)["some_key"]["some_wrong_key"]["wrong_name"]
&&//JSONValue&it&self&conforms&to&Protocol&"LogicValue",&with&JSONValue.JInvalid&stands&for&false&and&others&stands&true
如果我们尝试使用错误的键值或索引来访问数据，description属性会高数你KeyPath在哪里出错了.
let&json&=&JSONValue(dataFromNetworking)["some_key"]["some_wrong_key"]["wrong_name"]
&&println(json)
&&//&&JSON&Keypath&Error:&Incorrect&Keypath&"some_wrong_key/wrong_name"
&&//It&always&tells&you&where&your&key&went&wrong
&&switch&json{
&&case&.JInvalid(let&error):
&&&&//An&NSError&containing&detailed&error&information&
&SwiftyJSON的开发将会发布在, 请持续关注后续版本。
&翻译得不错哦！
我们的翻译工作遵照 ，如果我们的工作有侵犯到您的权益，请及时联系我们
我也觉得，不过自己封装个类似eval之类的函数应该也不麻烦，不过swift的语法看着真是纠结
因为基本都不会，哈哈
不值得 一喷， 对语言，就像对待女人一样，有爱才有恨，一点关系都没有哪来的爱和很，所以没啥人喷。。13:51 提问
SWIFT 如何解析
[{"Date(time)":"","DayOfWeek(time)":"3","Time(time)":"11:38:23","Hour(time)":"11"},
{"Date(time)":"","DayOfWeek(time)":"4","Time(time)":"11:38:23","Hour(time)":"11"},
{"Date(time)":"","DayOfWeek(time)":"5","Time(time)":"12:38:23","Hour(time)":"12"},
{"Date(time)":"","DayOfWeek(time)":"6","Time(time)":"11:38:23","Hour(time)":"11"},
{"Date(time)":"","DayOfWeek(time)":"7","Time(time)":"11:38:23","Hour(time)":"11"}]
以上JSON数组如何解析？是json数组 ，单个的json已经回解析了，下面是解析单个json的方法
json : AnyObject = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions.AllowFragments, error: nil)!
var name: AnyObject? = json[0].objectForKey("name")
按赞数排序
楼主理解错了，json没有单个和json数组之分，只有json里是数组还是字典的分别，楼主给出的数据可见该json数据是由一个数组包裹着5个字典组成，解析方法如下：
let resultArray = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions.AllowFragments, error: nil) as? Array
resultArray则为包括着5个字典的数组。
还有目前swift2 后 JSONObjectWithData操作需要try catch :
var resultDict: NSArray?
resultDict = try NSJSONSerialization.JSONObjectWithData(nonNilData, options: NSJSONReadingOptions.MutableContainers) as? NSArray
debugPrint("JSONObjectWithDataError: (error)")
var resultDict = try? NSJSONSerialization.JSONObjectWithData(nonNilData, options: NSJSONReadingOptions.MutableContainers) as? NSArray
建议json解析完后转换成json的真实类型，不要继续拿着anyObject来使用：
例：如果json为字典 则： let MyDict = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions.AllowFragments, error: nil) as? Dictionary
----------------------同志你好，我是CSDN问答机器人小N，奉组织之命为你提供参考答案，编程尚未成功，同志仍需努力！
可以用swiftjson这个第三方模块 封装很好
其他相似问题使用 Swift 进行 JSON 解析 - 推酷
使用 Swift 进行 JSON 解析
作者：Soroush Khanlou，
，原文日期：
使用 Swift 解析 JSON 是件很痛苦的事。你必须考虑多个方面：可选类性、类型转换、基本类型（primitive types）、构造类型（constructed types）（其构造器返回结果也是可选类型）、字符串类型的键（key）以及其他一大堆问题。
对于强类型（well-typed）的 Swift 来说，其实更适合使用一种强类型的有线格式(wire format)。在我的下一个项目中，我将会选择使用 Google 的
说明了它的好处）。我希望在得到更多经验后，写篇文章说说它和 Swift 配合起来有多么好用。但目前这篇文章主要是关于如何解析 JSON 数据 —— 一种被最广泛使用的有线格式。
对于 JSON 的解析，已经有了许多优秀的解决方案。第一个方案，使用如
这样的库，采用函数式操作符来柯里化一个初始化构造器：
extension User: Decodable {
static func decode(j: JSON) -& Decoded&User& {
return curry(User.init)
&^& j &| &id&
&*& j &| &name&
&*& j &|? &email& // Use ? for parsing optional values
&*& j &| &role& // Custom types that also conform to Decodable just work
&*& j &| [&company&, &name&] // Parse nested objects
Argo 是一个非常好的解决方案。它简洁，灵活，表达力强，但柯里化以及奇怪的操作符都是些不太好理解的东西。(Thoughtbot 的人已经写了一篇
来对这些加以解释)
另外一个常见的解决方案是，手动使用
进行处理以得到非可选值。这个方案需要手动做的事儿会多一些，对于每个属性的处理都需要两行代码：一行用来在 guard 语句中生成非可选的局部变量，另一行设置属性。若要得到上例中同样的结果，代码可能长这样：
class User {
init?(dictionary: [String: AnyObject]?) {
let dictionary = dictionary,
let id = dictionary[&id&] as? String,
let name = dictionary[&name&] as? String,
let roleDict = dictionary[&role&] as? [String: AnyObject],
let role = Role(dictionary: roleDict)
let company = dictionary[&company&] as? [String: AnyObject],
let companyName = company[&name&] as? String,
return nil
self.id = id
self.name = name
self.role = role
self.email = dictionary[&email&] as? String
self.companyName = companyName
这份代码的好处在于它是纯 Swift 的，不过看起来比较乱，可读性不佳，变量间的依赖链并不明显。举个例子，由于
的定义中，所以它必须在
被定义前定义，但由于代码如此繁杂，很难清晰地找出这种依赖关系。
（我甚至都不想提在 Swift 1 中解析 JSON 时，大量
嵌套而成的鞭尸金字塔（pyramid-of-doom），那可真是糟透了，很高兴现在我们有了多行的
发布的时候，我觉得这东西糟透了。似乎不管从哪一个方面都不及
你无法直接访问到错误：Swift 的错误处理机制在
类型之上，添加了一些必须使用的语法（是的，事实如此），这让人们无法直接访问到错误。
你不能像使用
一样进行链式处理。
链接起来进行有效的处理。
Swift 错误模型无法异步使用（除非你进行一些 hack，比如说
结果)， 但
尽管 Swift 的错误处理模型有着这些看起来相当明显的缺点，但
讲述了一个使用 Swift 错误模型的例子，在该例子中 Swift 的错误模型明显比 Objective-C 的版本更加简洁，也比
可读性更强。这是怎么回事呢？
这里的秘密在于，当你的代码中有许多
调用的时候，利用带有
结构的 Swift 错误模型进行处理，效果会非常好。在 Swift 中对代码进行错误处理时需要写一些模板代码。在声明函数时，你需要加入
结构显式地处理所有错误。对于单个
语句来说，做这些事让人觉得很麻烦。然而，就多个
语句而言，这些前期工作就变得物有所值了。
我曾试图寻找一种方法，能够在 JSON 缺失某个键时打印出某种警告。如果在访问缺失的键时，能够得到一个报错，那么这个问题就解决了。由于在键缺失的时候，原生的
Dictionary
类型并不会抛出错误，所以需要有个对象对字典进行封装。我想实现的代码大概长这样：
struct MyModel {
let aString: String
let anInt: Int
init?(dictionary: [String: AnyObject]?) {
let parser = Parser(dictionary: dictionary)
self.aString = try parser.fetch(&a_string&)
self.anInt = try parser.fetch(&an_int&)
} catch let error {
print(error)
return nil
理想的说来，由于类型推断的存在，在解析过程中我甚至不需要明确地写出类型。现在让我们丝分缕解，看看怎么实现这份代码。首先从
ParserError
struct ParserError: ErrorType {
let message: String}
接下来，我们开始搞定
。它可以是一个
。（由于它不会被用在别的地方，所以他的引用语义并不重要。）
struct Parser {
let dictionary: [String: AnyObject]?
init(dictionary: [String: AnyObject]?) {
self.dictionary = dictionary
我们的 parser 将会获取一个字典并持有它。
函数开始显得有点复杂了。我们来一行一行地进行解释。类中的每个方法都可以类型参数化，以充分利用类型推断带来的便利。此外，这个函数会抛出错误，以使我们能够获得处理失败的数据：
func fetch&T&(key: String) throws -& T {
下一步是获取键对应的对象，并保证它不是空的，否则抛出一个错误。
let fetchedOptional = dictionary?[key]guard let fetched = fetchedOptional else {
throw ParserError(message: &The key \&\(key)\& was not found.&)}
最后一步是，给获得的值加上类型信息。
guard let typed = fetched as? T else {
throw ParserError(message: &The key \&\(key)\& was not the correct type. It had value \&\(fetched).\&&)}
最终，返回带类型的非空值。
return typed}
（我将会在文末附上包含所有代码的 gist 和 playground）
这份代码是可用的！类型参数化及类型推断为我们处理了一切。上面写的 “理想” 代码完美地工作了：
self.aString = try parser.fetch(&a_string&)
我还想添加一些东西。首先，添加一种方法来解析出那些确实可选的值（译者注：也就是我们允许这些值为空）。由于在这种情况下我们并不需要抛出错误，所以我们可以实现一个简单许多的方法。但很不幸，这个方法无法和上面的方法同名，否则编译器就无法知道应该使用哪个方法了，所以，我们把它命名为
fetchOptional
。这个方法相当的简单。
func fetchOptional&T&(key: String) -& T? {
return dictionary?[key] as? T}
（如果键存在，但是并非你所期望的类型，则可以抛出一个错误。为了简略起见，我就不写了）
另外一件事就是，在字典中取出一个对象后，有时需要对它进行一些额外的转换。我们可能得到一个枚举的
，需要构建出对应的枚举，或者是一个嵌套的字典，需要处理它包含的对象。我们可以在
函数中接收一个闭包作为参数，作进一步地类型转换，并在转换失败的情况下抛出错误。泛型中
参数类型能够帮助我们明确
transformation
闭包转换得到的结果值类型和
方法得到的值类型一致。
func fetch&T, U&(key: String, transformation: (T) -& (U?)) throws -& U {
let fetched: T = try fetch(key)
guard let transformed = transformation(fetched) else {
throw ParserError(message: &The value \&\(fetched)\& at key \&\(key)\& could not be transformed.&)
return transformed}
最后，我们希望
fetchOptional
也能接受一个转换闭包作为参数。
func fetchOptional&T, U&(key: String, transformation: (T) -& (U?)) -& U? {
return (dictionary?[key] as? T).flatMap(transformation)}
的力量！注意，转换闭包
transformation
接收的闭包有着一样的形式：
现在我们可以解析带有嵌套项或者枚举的对象了。
class OuterType {
let inner: InnerType
init?(dictionary: [String: AnyObject]?) {
let parser = Parser(dictionary: dictionary)
self.inner = try parser.fetch(&inner&) { InnerType(dictionary: $0) }
} catch let error {
print(error)
return nil
再一次注意到，Swift 的类型推断魔法般地为我们处理了一切，而我们根本不需要写下任何
用类似的方法，我们也可以处理数组。对于基本数据类型的数组，
方法已经能很好地工作了：
let stringArray: [String]//...do {
self.stringArray = try parser.fetch(&string_array&)//...
对于我们想要构建的特定类型（Domain Types）的数组， Swift 的类型推断似乎无法那么深入地推断类型，所以我们必须加入另外的类型注解：
self.enums = try parser.fetch(&enums&) { (array: [String]) in array.flatMap(SomeEnum(rawValue: $0)) }
由于这行显得有些粗糙，让我们在
中创建一个新的方法来专门处理数组：
func fetchArray&T, U&(key: String, transformation: T -& U?) throws -& [U] {
let fetched: [T] = try fetch(key)
return fetched.flatMap(transformation)}
这里使用 flatMap 来帮助我们移除空值，减少了代码量:
self.enums = try parser.fetchArray(&enums&) { SomeEnum(rawValue: $0) }
末尾的这个闭包应该被作用于
元素，而不是整个数组（你也可以修改
fetchArray
方法，以在任意值无法被构建时抛出错误。）
我很喜欢泛型模式。它很简单，可读性强，而且也没有复杂的依赖（这只是个 50 行的 Parser 类型）。它使用了 Swift 风格的结构， 还会给你非常特定的错误提示，告诉你
解析失败了，当你在从服务器返回的 JSON 沼泽中摸爬滚打时，这显得非常有用。最后，用这种方法解析的另外一个好处是，它在结构体和类上都能很好地工作，这使得从引用类型切换到值类型，或者反之，都变得很简单。
是包含所有代码的一个 gist，而
是一个作为补充的 Playground.
本文由 SwiftGG 翻译组翻译，已经获得作者翻译授权，最新文章请访问http://swift.gg。
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致}