4.0新 swift_xcode 10.2由swift3.0改成4.0错误 - CSDN
  • Swift 4.0 更新合集、功能汇总

    万次阅读 2017-06-10 11:48:24
    Swift 4是苹果计划于2017年秋季推出的最新版本,其主要重点是提供与Swift 3代码的源兼容性,并努力实现ABI稳定性。 本文重点介绍对Swift的更改将对您的代码产生最大的影响。 而且,让我们开始吧!

    本文由陈云峰翻译,转载请注明。

    注意:本教程将使用Swift 4版本捆绑在Xcode 9 beta 1中。

    Swift 4

    Swift 4是苹果计划于2017年秋季推出的最新版本,其主要重点是提供与Swift 3代码的源兼容性,并努力实现ABI稳定性。

    本文重点介绍对Swift的更改将对您的代码产生最大的影响。 而且,让我们开始吧!

    入门

    Swift 4包含在Xcode 9中。您可以从Apple的开发者门户下载最新版本的Xcode 9(您必须拥有一个活跃的开发者帐户)。 每个Xcode测试版将在发布时捆绑最新的Swift 4快照。

    在阅读时,您会注意到[SE-xxxx]格式的链接。 这些链接将带您到相关的Swift Evolution提案。 如果您想了解有关任何主题的更多信息,请务必查看。

    我建议您在操场上尝试每个Swift 4功能或更新。 这将有助于巩固您的头脑中的知识,并使您有能力深入了解每个主题。 试图扩大/打破他们的例子来玩弄这些例子。 玩得开心!

    注意:本文将针对每个Xcode测试版进行更新。 如果您使用不同的Swift快照,这里的代码不能保证工作。

    迁移到Swift 4

    从Swift 3迁移到4将比从2.2到3更麻烦。一般来说, 大多数变化是相加的,不应该需要大量的个人感觉。 因此,Swift迁移工具将为您处理大部分更改。

    Xcode 9同时支持Swift 4以及Swift 3.2中的Swift 3中间版本。 您的项目中的每个目标可以是Swift 3.2或Swift 4,如果需要,您可以逐个迁移。 然而,转换为Swift 3.2并不是完全免费的 – 您可能需要更新代码部分才能与新SDK兼容,并且由于Swift尚未ABI稳定,因此您将需要使用Xcode 9重新编译依赖项。

    当您准备迁移到Swift 4时,Xcode再次提供了一个迁移工具来帮助您。 在Xcode中,您可以导航到编辑/转换/到当前Swift语法…以启动转换工具。

    选择要转换的目标后,Xcode将提示您对Objective-C推理的偏好。 选择推荐的选项通过限制引用来减少二进制大小(有关此主题的更多信息,请查看下面的限制@objc推断 )

    为了更好地了解您的代码中期望的更改,我们将首先介绍Swift 4中的API更改。

    API更改

    在跳转到Swift 4中介绍的补充之前,我们先来看看现有API所做的更改/改进。

    字符串

    String在Swift 4中获得了很多很好的爱。这个提案包含很多变化,所以让我们分解最大的。 [SE-0163] :

    如果你感觉怀旧,字符串再次收藏,就像他们是Swift 2.0之前一样。 此更改消除了对String上的String数组的需求。 您现在可以直接在String对象上进行迭代:

    let galaxy = "Milky Way "
    for char in galaxy {
      print(char)
    }

    是!

    您不仅可以通过String逻辑迭代,还可以从SequenceCollection获取所有的响铃和口哨:

    galaxy.count       // 11
    galaxy.isEmpty     // false
    galaxy.dropFirst() // "ilky Way "
    String(galaxy.reversed()) // " yaW ykliM"
    
    // Filter out any none ASCII characters
    galaxy.filter { char in
      let isASCII = char.unicodeScalars.reduce(true, { $0 && $1.isASCII })
      return isASCII
    } // "Milky Way "

    上面的ASCII示例显示了对Character 。 您现在可以直接从Character访问Character 。 以前,您需要实例化一个新的String [SE-0178] 。

    另外还有一个是StringProtocol 。 它声明了以前在String上声明的大部分功能。 这种变化的原因是改善切片如何工作。 Swift 4添加了Substring类型,用于引用String上的子序列。

    StringSubstring实现了StringProtocol使它们具有几乎相同的功能:

    // Grab a subsequence of String
    let endIndex = galaxy.index(galaxy.startIndex, offsetBy: 3)
    var milkSubstring = galaxy[galaxy.startIndex...endIndex]   // "Milk"
    type(of: milkSubstring)   // Substring.Type
    
    // Concatenate a String onto a Substring
    milkSubstring += ""     // "Milk"
    
    // Create a String from a Substring
    let milkString = String(milkSubstring) // "Milk"

    另一个很大的改进是String如何解释图形集合。 此解决方案来自于Unicode 9的改编。以前,由多个代码点组成的Unicode字符会导致count大于1.常见的情况是具有所选肤色的表情符号。 以下是几个示例,显示前后行为:

    "‍".count // Now: 1, Before: 2
    "".count // Now: 1, Before: 2
    "‍❤️‍‍".count // Now: 1, Before, 4

    这只是“ 字符串宣言”中提到的更改的一个子集。 您可以阅读有关将来希望看到的原始动机和提出的解决方案。

    词典和集合

    至于Collection类型, SetDictionary并不总是最直观的。 幸运的是,斯威夫特队给了他们一些非常需要的爱[SE-0165] 。

    基于序列的初始化
    列表首先是从一系列键值对(元组)创建一个字典的能力:

    let nearestStarNames = ["Proxima Centauri", "Alpha Centauri A", "Alpha Centauri B", "Barnard's Star", "Wolf 359"]
    let nearestStarDistances = [4.24, 4.37, 4.37, 5.96, 7.78]
    
    // Dictionary from sequence of keys-values
    let starDistanceDict = Dictionary(uniqueKeysWithValues: zip(nearestStarNames, nearestStarDistances)) 
    // ["Wolf 359": 7.78, "Alpha Centauri B": 4.37, "Proxima Centauri": 4.24, "Alpha Centauri A": 4.37, "Barnard's Star": 5.96]

    重复键处理
    您现在可以使用重复的键来处理初始化字典的任何方式。 这有助于避免覆盖键值对,而不会有任何问题:

    // Random vote of people's favorite stars
    let favoriteStarVotes = ["Alpha Centauri A", "Wolf 359", "Alpha Centauri A", "Barnard's Star"]
    
    // Merging keys with closure for conflicts
    let mergedKeysAndValues = Dictionary(zip(favoriteStarVotes, repeatElement(1, count: favoriteStarVotes.count)), uniquingKeysWith: +) // ["Barnard's Star": 1, "Alpha Centauri A": 2, "Wolf 359": 1]

    上面的代码使用zip和速记+来通过添加两个冲突的值来解析重复的键。

    注意:如果您不熟悉zip ,您可以在Apple的Swift文档中快速了解它

    过滤
    DictionarySet现在都可以将结果过滤到原始类型的新对象中:

    // Filtering results into dictionary rather than array of tuples
    let closeStars = starDistanceDict.filter { $0.value < 5.0 }
    closeStars // Dictionary: ["Proxima Centauri": 4.24, "Alpha Centauri A": 4.37, "Alpha Centauri B": 4.37]

    字典映射
    Dictionary获得了一个非常有用的方法来直接映射其值:

    // Mapping values directly resulting in a dictionary
    let mappedCloseStars = closeStars.mapValues { "\($0)" }
    mappedCloseStars // ["Proxima Centauri": "4.24", "Alpha Centauri A": "4.37", "Alpha Centauri B": "4.37"]

    字典默认值
    在Dictionary上访问某个值时,常见的做法是使用nil coalescing运算符给出默认值,以防数值为nil 。 在Swift 4中,这变得更加清洁,并允许您在线突变中做一些真棒:

    // Subscript with a default value
    let siriusDistance = mappedCloseStars["Wolf 359", default: "unknown"] // "unknown"
    
    // Subscript with a default value used for mutating
    var starWordsCount: [String: Int] = [:]
    for starName in nearestStarNames {
      let numWords = starName.split(separator: " ").count
      starWordsCount[starName, default: 0] += numWords // Amazing 
    }
    starWordsCount // ["Wolf 359": 2, "Alpha Centauri B": 3, "Proxima Centauri": 2, "Alpha Centauri A": 3, "Barnard's Star": 2]

    以前,这种类型的突变将需要在一个blo肿的if-let语句中包装。 在Swift 4中,可能是一条线!

    字典分组
    另一个令人惊讶的有用的补充是从Sequence Dictionary并将它们分组到桶中的能力:

    // Grouping sequences by computed key
    let starsByFirstLetter = Dictionary(grouping: nearestStarNames) { $0.first! }
    
    // ["B": ["Barnard's Star"], "A": ["Alpha Centauri A", "Alpha Centauri B"], "W": ["Wolf 359"], "P": ["Proxima Centauri"]]

    当通过特定模式对数据进行分组时,这很方便。

    预留容量
    SequenceDictionary现在都具有明确保留容量的能力。

    // Improved Set/Dictionary capacity reservation
    starWordsCount.capacity  // 6
    starWordsCount.reserveCapacity(20) // reserves at _least_ 20 elements of capacity
    starWordsCount.capacity // 24
    

    这些类型的重新分配可能是一项昂贵的任务。 使用reserveCapacity(_:)是一个简单的方法来提高性能,当您了解需要存储多少数据时。

    这是一大堆信息,所以绝对检查这两种类型,并寻找使用这些添加剂来调整代码的方法。

    私有访问修饰符

    Swift 3的一个元素,一些不太喜欢的是添加fileprivate 。 从理论上讲,这是非常好的,但实际上它的使用往往会令人困惑。 目标是在成员本身中使用private的,并且在您想要在同一文件中的成员共享访问的情况下很少使用fileprivate 。

    问题是Swift鼓励使用扩展将代码分解成逻辑组。 扩展被认为在原始成员声明范围之外,这导致对fileprivate的广泛需求。

    Swift 4通过在类型和所述类型的任何扩展之间共享相同的访问控制范围来实现原始意图。 这只适用于相同的源文件[SE-0169] :

    struct SpaceCraft {
      private let warpCode: String
    
      init(warpCode: String) {
        self.warpCode = warpCode
      }
    }
    
    extension SpaceCraft {
      func goToWarpSpeed(warpCode: String) {
        if warpCode == self.warpCode { // Error in Swift 3 unless warpCode is fileprivate
          print("Do it Scotty!")
        }
      }
    }
    
    let enterprise = SpaceCraft(warpCode: "KirkIsCool")
    //enterprise.warpCode  // error: 'warpCode' is inaccessible due to 'private' protection level
    enterprise.goToWarpSpeed(warpCode: "KirkIsCool") // "Do it Scotty!"

    这允许您使用fileprivate作为其预期目的,而不是作为带状编码组织。

    新增API

    现在让我们来看看Swift 4的新功能。这些更改不应该打破你现有的代码,因为它们是简单的加法。

    归档和序列化

    谷物人

    到目前为止,在Swift中,为了序列化和归档您的自定义类型,您必须跳过一些环。对于class类型,您需要对NSObject进行子类化并实现NSCoding协议。

    structenum这样的值类型需要许多hacks,例如创建一个可以扩展NSObjectNSCoding的子对象。

    Swift 4通过将序列化到所有三种Swift类型[SE-0166]来解决这个问题:

    struct CuriosityLog: Codable {
      enum Discovery: String, Codable {
        case rock, water, martian
      }
    
      var sol: Int
      var discoveries: [Discovery]
    }
    
    // Create a log entry for Mars sol 42
    let logSol42 = CuriosityLog(sol: 42, discoveries: [.rock, .rock, .rock, .rock])

    在这个例子中,您可以看到,使Swift类型可Encodable和可Decodable所需的唯一Decodable是实现可编Codable协议。 如果所有属性都是Codable ,则协议实现由编译器自动生成。

    本文由陈云峰翻译,转载请注明。

    要实际编码对象,您需要将其传递给编码器。 Swift编码器正在Swift 4中积极实施。每个编码器根据不同的方案对您的对象进行编码[SE-0167] ( 注意:此提案的一部分仍在开发中):

    let jsonEncoder = JSONEncoder() // One currently available encoder
    
    // Encode the data
    let jsonData = try jsonEncoder.encode(logSol42)
    // Create a String from the data
    let jsonString = String(data: jsonData, encoding: .utf8) // "{"sol":42,"discoveries":["rock","rock","rock","rock"]}"

    这采取了一个对象,并自动将其编码为JSON对象。 确保查看JSONEncoder暴露的属性来自定义其输出。

    该过程的最后一部分是将数据解码为具体对象:

    let jsonDecoder = JSONDecoder() // Pair decoder to JSONEncoder
    
    // Attempt to decode the data to a CuriosityLog object
    let decodedLog = try jsonDecoder.decode(CuriosityLog.self, from: jsonData)
    decodedLog.sol         // 42
    decodedLog.discoveries // [rock, rock, rock, rock]

    使用Swift 4编码/解码,您可以在Swift中获得预期的类型安全性,而不依赖于@objc协议的开销和限制。

    键值编码

    到目前为止,您可以参考函数而不调用它们,因为函数是Swift中的闭包。 你不能做的是保持对属性的引用,而不实际访问属性保存的底层数据。

    对Swift 4来说,令人兴奋的补充是能够引用类型的关键路径来获取/设置实例的基础值[SE-0161] :

    struct Lightsaber {
      enum Color {
        case blue, green, red
      }
      let color: Color
    }
    
    class ForceUser {
      var name: String
      var lightsaber: Lightsaber
      var master: ForceUser?
    
      init(name: String, lightsaber: Lightsaber, master: ForceUser? = nil) {
        self.name = name
        self.lightsaber = lightsaber
        self.master = master
      }
    }
    
    let sidious = ForceUser(name: "Darth Sidious", lightsaber: Lightsaber(color: .red))
    let obiwan = ForceUser(name: "Obi-Wan Kenobi", lightsaber: Lightsaber(color: .blue))
    let anakin = ForceUser(name: "Anakin Skywalker", lightsaber: Lightsaber(color: .blue), master: obiwan)

    在这里,您将通过设置他们的名字,光剑和主人来创建强制用户的几个实例。 要创建一个关键路径,您只需使用一个反斜杠后跟您感兴趣的属性:

    // Create reference to the ForceUser.name key path
    let nameKeyPath = \ForceUser.name
    
    // Access the value from key path on instance
    let obiwanName = obiwan[keyPath: nameKeyPath]  // "Obi-Wan Kenobi"

    在这种情况下,您正在为ForceUsername属性创建一个关键路径。 然后,通过将其传递给新的下标keyPath来使用此键路径。 默认情况下,此下标现在可用于每种类型。

    以下是使用关键路径深入到子对象,设置属性和构建关键路径引用的更多示例:

    // Use keypath directly inline and to drill down to sub objects
    let anakinSaberColor = anakin[keyPath: \ForceUser.lightsaber.color]  // blue
    
    // Access a property on the object returned by key path
    let masterKeyPath = \ForceUser.master
    let anakinMasterName = anakin[keyPath: masterKeyPath]?.name  // "Obi-Wan Kenobi"
    
    // Change Anakin to the dark side using key path as a setter
    anakin[keyPath: masterKeyPath] = sidious
    anakin.master?.name // Darth Sidious
    
    // Note: not currently working, but works in some situations
    // Append a key path to an existing path
    //let masterNameKeyPath = masterKeyPath.appending(path: \ForceUser.name)
    //anakin[keyPath: masterKeyPath] // "Darth Sidious"

    Swift的关键路径的美丽在于它们是强类型的! 没有更多的Objective-C字符串风格混乱!

    多行字符串文字

    许多编程语言的一个非常常见的特征是能够创建多行字符串文字。 Swift 4通过在三个引号[SE-0168]中包装文本来添加这个简单而有用的语法:

    let star = "⭐️"
    let introString = """
      A long time ago in a galaxy far,
      far away....
    
      You could write multi-lined strings
      without "escaping" single quotes.
    
      The indentation of the closing quotes
           below deside where the text line
      begins.
    
      You can even dynamically add values
      from properties: \(star)
      """
    print(introString) // prints the string exactly as written above with the value of star

    这在构建XML / JSON消息或构建长格式的文本以在UI中显示时非常有用。

    单面范围

    为了减少冗长度并提高可读性,标准库现在可以使用单面范围[SE-0172]来推断起始和终点索引。

    派上用场的一种方法是创建一个从索引到集合的开始或结束索引的范围:

    / Collection Subscript
    var planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
    let outsideAsteroidBelt = planets[4...] // Before: planets[4..<planets.endIndex]
    let firstThree = planets[..<4]          // Before: planets[planets.startIndex..<4]

    如您所见,单面范围减少了明确指定开始索引或结束索引的需要。

    无限序列
    当起始索引为可数类型时,它们还允许您定义无限Sequence :

    // Infinite range: 1...infinity
    var numberedPlanets = Array(zip(1..., planets))
    print(numberedPlanets) // [(1, "Mercury"), (2, "Venus"), ..., (8, "Neptune")]
    
    planets.append("Pluto")
    numberedPlanets = Array(zip(1..., planets))
    print(numberedPlanets) // [(1, "Mercury"), (2, "Venus"), ..., (9, "Pluto")]

    模式匹配
    单面范围的另一个很好的用途是模式匹配:

    // Pattern matching
    
    func temperature(planetNumber: Int) {
      switch planetNumber {
      case ...2: // anything less than or equal to 2
        print("Too hot")
      case 4...: // anything greater than or equal to 4
        print("Too cold")
      default:
        print("Justtttt right")
      }
    }
    
    temperature(planetNumber: 3) // Earth

    通用下标

    下标是使数据类型以简洁方式可访问的重要组成部分。 为了提高其有用性,下标现在可以是通用的[SE-0148] :

    struct GenericDictionary<Key: Hashable, Value> {
      private var data: [Key: Value]
    
      init(data: [Key: Value]) {
        self.data = data
      }
    
      subscript<T>(key: Key) -> T? {
        return data[key] as? T
      }
    }

    在这个例子中,返回类型是通用的。 你可以使用这个通用的下标,如下所示:

    // Dictionary of type: [String: Any]
    var earthData = GenericDictionary(data: ["name": "Earth", "population": 7500000000, "moons": 1])
    
    // Automatically infers return type without "as? String"
    let name: String? = earthData["name"]
    
    // Automatically infers return type without "as? Int"
    let population: Int? = earthData["population"]

    返回类型不仅可以是通用的,而且实际的下标类型也可以是通用的:

    extension GenericDictionary {
      subscript<Keys: Sequence>(keys: Keys) -> [Value] where Keys.Iterator.Element == Key {
        var values: [Value] = []
        for key in keys {
          if let value = data[key] {
            values.append(value)
          }
        }
        return values
      }
    }
    
    // Array subscript value
    let nameAndMoons = earthData[["moons", "name"]]        // [1, "Earth"]
    // Set subscript value
    let nameAndMoons2 = earthData[Set(["moons", "name"])]  // [1, "Earth"]

    在这个例子中,你可以看到,传递两个不同的Sequence类型( ArraySet )会导致一个数组的各自的值。

    更多更新

    它处理了Swift 4中最大的变化。现在让我们通过一些较小的位和块来更快速地进行一些。

    MutableCollection.swapAt(_:_ )

    MutableCollection现在具有mutate方法swapAt(_:_:) ,就像它的声音一样; 交换给定索引值[SE-0173] :

    // Very basic bubble sort with an in-place swap
    func bubbleSort<T: Comparable>(_ array: [T]) -> [T] {
      var sortedArray = array
      for i in 0..<sortedArray.count - 1 {
        for j in 1..<sortedArray.count {
          if sortedArray[j-1] > sortedArray[j] {
            sortedArray.swapAt(j-1, j) // New MutableCollection method
          }
        }
      }
      return sortedArray
    }
    
    bubbleSort([4, 3, 2, 1, 0]) // [0, 1, 2, 3, 4]

    相关类型限制

    您现在可以使用where子句来限制关联类型[SE-0142] :

    protocol MyProtocol {
      associatedtype Element
      associatedtype SubSequence : Sequence where SubSequence.Iterator.Element == Iterator.Element
    }

    使用协议约束,许多associatedtype声明可以直接约束其值,而不必跳过环。

    类和协议存在

    最终将其从Objective-C转换为Swift的功能是定义符合类和一组协议的类型的能力[SE-0156] :

    protocol MyProtocol { }
    class View { }
    class ViewSubclass: View, MyProtocol { }
    
    class MyClass {
      var delegate: (View & MyProtocol)?
    }
    
    let myClass = MyClass()
    //myClass.delegate = View() // error: cannot assign value of type 'View' to type '(View & MyProtocol)?'
    myClass.delegate = ViewSubclass()

    限制@objc推论

    要将Objective-C或Swift API公开,请使用@objc编译器属性。 在许多情况下,Swift编译器为您推断出这一点。 质量推理的三个主要问题是:

      1. 潜在的二进制大小显着增加
      2. 知道何时@objc

    被推断不明显

    1. 不经意间创建Objective-C选择器碰撞的机会增加。

    Swift 4通过限制@objc [SE-0160]的推论来解决这个问题。 这意味着在需要Objective-C的完整动态调度功能的情况下,您需要使用@objc 。

    您需要进行这些更改的几个示例包括private方法, dynamic声明和NSObject子类的任何方法。

    NSNumber桥接

    NSNumber和Swift数字之间已经有很多时髦的行为,这些行为一直困扰着语言太久。 幸运的是,Swift 4压缩了这些错误[SE-0170] 。

    以下是一个示例演示示例:

    let n = NSNumber(value: 999)
    let v = n as? UInt8 // Swift 4: nil, Swift 3: 231

    Swift 3中的奇怪行为表明,如果数字溢出,则从0开始。在此示例中,999%2 ^ 8 = 231。

    Swift 4通过强制可选的转换来解决问题,只有当数字可以在包含类型中被安全地表达时才返回值。

    Swift包管理器

    在过去几个月里,Swift Package Manager已经有了一些更新。 一些最大的变化包括:

    • 从分支或提交哈希采购依赖关系
    • 更多控制可接受的包版本
    • 用更为常见的解决方案替代非直观的钉扎命令
    • 能够定义用于编译的Swift版本
    • 指定每个目标的源文件的位置

    这些都是获得SPM所需要的重大步骤。 SPM还有很长的路要走,但是我们可以通过保持积极的建议来帮助形成一个。

    有关最近解决的提案的全面了解,请查看“ Swift 4软件包管理器更新” 。

    从哪里走?

    还在举行视频
    想要更快学习吗?节省时间与我们的视频课程

    Swift语言多年来一直在增长和成熟。 提案过程和社区参与使得跟踪管道中出现的变化非常容易。 它也使东方任何一个人直接影响演变。

    随着Swift 4中的这些变化,我们终于到了一个ABI稳定性就在拐角处的地方。 升级Swift版本的痛苦越来越小。 构建性能和工具大大提高。 在苹果生态系统之外使用Swift变得越来越可行。 并且想一想,我们可能只是从一个直观的实现中完全重写String的一些;]。

    斯威夫特还有更多的东西。 要保持最新的所有更改,请确保查看以下资源:

    你对Swift 4有什么想法? 你最喜欢的变化是什么? 你还想从语言中看到什么? 你有没有找到新的和令人兴奋的东西,这里没有涵盖? 让我们在下面的评论中知道!

    本文由陈云峰翻译,转载请注明。原文地址

    展开全文
  • swift4.0最新官方文档(中文版) 学习swift4.0 从现在开始吧
  • Swift4.0】属性

    2017-12-28 15:19:36
    希望对Swift的学习者有所帮助,使用的编写工具:JQNote  InNote(iPhone) 属性是把值和某个类,结构体或者枚举联系在一起。存储型属性存储一个实例的常量和变量值部分,然而计算型属性会计算出(而不是...

    翻译能力有限,如有不对的地方,还请见谅!希望对Swift的学习者有所帮助,使用的编写工具:JQNote    InNote(iPhone)


    属性是把值和某个类,结构体或者枚举联系在一起。存储型属性存储一个实例的常量和变量值部分,然而计算型属性会计算出(而不是存储)一个值。类,结构体和枚举都支持计算型属性,而存储型属性只有类和结构体支持。这两种属性通常跟某个类型的实例关联。然而,属性也可以跟类型本身关联起来,这种属性称之为类型属性。另外,你可以定义一个属性观察者来检测该属性值的改变。


    存储属性

    一个存储属性是一个常量或者变量,被存储作为一个类或者结构体实例的一部分。你可以在定义它的时候给它一个缺省值,也可以在初始化方法中设置和修改存储属性的初始化值,即便是该存储属性是常量。如果你创建了一个常量结构体实例,那么就不能修改该实例的属性,即使属性被声明为变量。


    let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)

    // this range represents integer values 0, 1, 2, and 3

    rangeOfFourItems.firstValue = 6

    // this will report an error, even though firstValue is a variable property”


    因为结构体是值类型,当一个结构体实例被声明为常量,那么它的所有属性都不能被改变。但是对于类来说,是引用类型,如果类实例被声明为常量,你还可以改变它的变量属性的。


    懒存储属性

    这种属性直到它第一次被使用才会初始化。在声明存储属性前面加上lazy关键字就表示为懒存储属性。


    你必须总是声明懒存储属性为变量(var),因为直到实例初始化完成之后,它的初始化值可能不能被获取,而常量属性必须总是在实例初始化完成之前有一个值。


    class DataImporter {

        /*DataImporter is a class to import data from an external ”

    “file.

         The class is assumed to take a non-trivial amount of time to initialize.

         */


        var filename = "data.txt"

        // the DataImporter class would provide data importing functionality here

    }

     

    class DataManager {

        lazy var importer = DataImporter()

        var data = [String]()

        // the DataManager class would provide data management functionality here

    }

     

    let manager = DataManager()

    manager.data.append("Some data")

    manager.data.append("Some more data")”


    如上面的例子,因为importer 被声明为一个lazy 属性,DataImporter实例仅仅是当 importer属性第一次被调用获取的时候,才会创建。

    print(manager.importer.filename)

    // the DataImporter instance for the importer property has now been created

    // Prints "data.txt”


    计算型属性

    计算型属性实际上不会存储一个值,相反,它们提供了一个getter和一个可选的setter方法来直接获取或者设置其它属性的值。

    struct Point {

        var x = 0.0, y = 0.0

    }


    struct Size {

        var width = 0.0, height = 0.0

    }


    struct Rect {

        var origin = Point()

        var size = Size()

        var center: Point {

            get {

                let centerX = origin.x + (size.width / 2)

                let centerY = origin.y + (size.height / 2)

                return Point(x: centerX, y: centerY)

            }

            set(newCenter) {

                origin.x = newCenter.x - (size.width / 2)

                origin.y = newCenter.y - (size.height / 2)

            }

        }

    }


    var square = Rect(origin: Point(x: 0.0, y: 0.0),

                      size: Size(width: 10.0, height: 10.0))

    let initialSquareCenter = square.center

    square.center = Point(x: 15.0, y: 15.0)


    只读的计算型属性

    一个计算型的属性,如果只有getter方法,没有setter方法,那就被认为是一个只读的计算属性。你可以声明一个简单的只读计算属性,不需要get关键字:

    struct Cuboid {

        var width = 0.0, height = 0.0, depth = 0.0

        var volume: Double {

            return width * height * depth

        }

    }


    let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)

    print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")

    // Prints "the volume of fourByFiveByTwo is 40.0”


    属性观察者

    属性观察者观察和响应一个属性值的改变。当属性值每次被set的时候,观察者都会被调用,即使新的值和当前的值相同。除了lazy属性,你可以将属性观察者添加到任何存储属性:


    >> willSet :值被存储之前调用

    >> didSet :新值被存储之后调用


    当你实现了willSet,它会传递一个新的值作为一个常量参数。你也可以给这个参数特定一个名字。如果你没有写这个参数名,那么默认newValue可以被使用。类似,如果实现了didSet,你也可以特定一个参数名或者使用默认的oldValue。

    class StepCounter {

        var totalSteps: Int = 0 {

            willSet(newTotalSteps) {

                print("About to set totalSteps to \(newTotalSteps)")

            }

            didSet {

                if totalSteps > oldValue  {

                    print("Added \(totalSteps - oldValue) steps")

                }

            }

        }

    }


    类型属性

    实例属性属于某个类型的实例,每次在创建实例的时候,它有自己的一系列属性。与其它实例是分开的。

    你也可以定义属于类型自己的属性,而不属于每个该类型的实例。类型属性只会拷贝一次,无论该类型被创建了多少个实例。

    不像存储实例属性,存储类型属性必须赋一个缺省值,这是因为类型自己没有一个初始化器可以在初始化的时候给类型属性设置值。

    定义一个类型属性,使用staic关键字:

    struct SomeStructure {

        static var storedTypeProperty = "Some value."

        static var computedTypeProperty: Int {

            return 1

        }

    }

    enum SomeEnumeration {

        static var storedTypeProperty = "Some value."

        static var computedTypeProperty: Int {

            return 6

        }

    }

    class SomeClass {

        static var storedTypeProperty = "Some value."

        static var computedTypeProperty: Int {

            return 27

        }

        class var overrideableComputedTypeProperty: Int {

             return 107

        }

    }


    获取和设置类型属性:

    print(SomeStructure.storedTypeProperty)

    // Prints "Some value."

    SomeStructure.storedTypeProperty = "Another value."

    print(SomeStructure.storedTypeProperty)

    // Prints "Another value."

    print(SomeEnumeration.computedTypeProperty)

    // Prints "6"

    print(SomeClass.computedTypeProperty)

    // Prints "27”



    展开全文
  • Swift4.0 特性----字符串改进

    万次阅读 2019-09-22 21:25:26
    注:文章转自这里 1.Unicode 字符串在计算 count 时的正确性改善 在 Unicode 中,有些字符是由几个其它字符组成的,比如 é 这个字符,它可以用 \u{E9} 来表示,也可以用 e 字符和上面一撇字符组合在一起表示 \u...

    注:文章转自这里

    1.Unicode 字符串在计算 count 时的正确性改善

     

    在 Unicode 中,有些字符是由几个其它字符组成的,比如 é 这个字符,它可以用 \u{E9} 来表示,也可以用 e 字符和上面一撇字符组合在一起表示 \u{65}\u{301}。

    看以下代码:

    var family = "x"
    family += "\u{200D}x"
    family += "\u{200D}x" 
    family += "\u{200D}x"
    print(family)
    print(family.characters.count)

     

    这个 family 是一个由多个字符组合成的字符,打印出来的结果是一个特殊的emoji表情。上面的代码在 Swift 3 中打印的 count 数是 4,在 Swift 4 中打印出的 count 是 1。


    2.更快的字符处理速度

     

    Swift 4 的字符串优化了底层实现,对于英语、法语、德语、西班牙语的处理速度提高了 3.5 倍。

    对于简体中文、日语的处理速度提高了 2.5 倍。(数据来源于官方PPT)
     

    3.去掉 characters

     

    Swift 3 中的 String 需要通过 characters 去调用的属性方法,在 Swift 4 中可以通过 String 对象本身直接调用,例如:

    let values = "one,two,three..."
    var i = values.characters.startIndex
    while let comma = values.characters[i...<values.characters.endIndex].index(of: ",") {
        if values.characters[i..<comma] == "two" {
            print("found it!")
        }
        i = values.characters.index(after: comma)
    }



    Swift 4 可以把上面代码中的所有的 characters 都去掉,修改如下:

    let values = "one,two,three..."
    var i = values.startIndex
    while let comma = values[i...<values.endIndex].index(of: ",") {
        if values[i..<comma] == "two" {
            print("found it!")
        }
        i = values.index(after: comma)
    }
    


     

    4.One-sided Slicing

     

    Swift 4 新增了一个语法糖 ... 可以对字符串进行单侧边界取子串。

    Swift 3:

    let values = "abcdefg"
    let startSlicingIndex = values.index(values.startIndex, offsetBy: 3)
    let subvalues = values[startSlicingIndex..<values.endIndex]


    Swift 4:

    let values = "abcdefg"
    let startSlicingIndex = values.index(values.startIndex, offsetBy: 3)
    let subvalues = values[startSlicingIndex...] // One-sided Slicing
    
    let newStr = String(str[..<index]) // = str.substring(to: index) In Swift 3
    let newStr = String(str[index...]) // = str.substring(from: index) In Swif 3
    let newStr = String(str[range]) // = str.substring(with: range) In Swift 3


     

    5.String 当做 Collection 来用

     

    Swift 4 中 String 可以当做 Collection 来用,并不是因为 String 实现了 Collection 协议,而是 String 本身增加了很多 Collection 协议中的方法,使得 String 在使用时看上去就是个 Collection。例如:
    翻转字符串:

    let abc: String = "abc"
    print(String(abc.reversed()))
    // cba



    遍历字符:

    let abc: String = "abc"
    for c in abc {
        print(c)
    }
    /*
    a
    b
    c
    */



    Map、Filter、Reduce:

    // map
    let abc: String = "abc"
    _ = abc.map {
        print($0.description)
    }
    // filter
    let filtered = abc.filter { $0 == "b" }
    // reduce
    let result = abc.reduce("1") { (result, c) -> String in
        print(result)
        print(c)
        return result + String(c)
    }
    print(result)


     


    6.Substring

    在 Swift 中,String 的背后有个 Owner Object 来跟踪和管理这个 String,String 对象在内存中的存储由内存起始地址、字符数、指向 Owner Object 指针组成。Owner Object 指针指向 Owner Object 对象,Owner Object 对象持有 String Buffer。当对 String 做取子字符串操作时,子字符串的 Owner Object 指针会和原字符串指向同一个对象,因此子字符串的 Owner Object 会持有原 String 的 Buffer。当原字符串销毁时,由于原字符串的 Buffer 被子字符串的 Owner Object 持有了,原字符串 Buffer 并不会释放,造成极大的内存浪费。


    在 Swift 4 中,做取子串操作的结果是一个 Substring 类型,它无法直接赋值给需要 String 类型的地方。必须用 String() 包一层,系统会通过复制创建出一个新的字符串对象,这样原字符串在销毁时,原字符串的 Buffer 就可以完全释放了。

    let big = downloadHugeString()
    let small = extractTinyString(from: big)
    mainView.titleLabel.text = small // Swift 4 编译报错
    mainView.titleLabel.text = String(small) // 编译通过

     

     

    7.多行字符串字面量

     

    Swift 3 中写很长的字符串只能写在一行。

    func tellJoke(name: String, character: Character) {
        let punchline = name.filter { $0 != character }
        let n = name.count - punchline.count
        let joke = "Q: Why does \(name) have \(n) \(character)'s in their name?\nA: I don't know, why does \(name) have \(n) \(character)'s in their name?\nQ: Because otherwise they'd be called \(punchline)."
        print(joke)
    }
    tellJoke(name: "Edward Woodward", character: "d")


    字符串中间有换行只能通过添加 \n 字符来代表换行。

    Swift 4 可以把字符串写在一对 """ 中,这样字符串就可以写成多行。

    func tellJoke(name: String, character: Character) {
        let punchline = name.filter { $0 != character }
        let n = name.count - punchline.count
        let joke = """
            Q: Why does \(name) have \(n) \(character)'s in their name?
            A: I don't know, why does \(name) have \(n) \(character)'s in their name?
            Q: Because otherwise they'd be called \(punchline).
            """
        print(joke)
    }
    tellJoke(name: "Edward Woodward", character: "d")

     

    展开全文
  • The Swift Programming Language 4.0 中文版学习笔记 11. 基础部分注释嵌套注释: /* A /* B */ /常量和变量常量和变量名可以使用Unicode字符来命名,但不能包含数学符号,箭头,保留的(或者非法的)Unicode码位...

    The Swift Programming Language 4.0 中文版学习笔记 1

    1. 基础部分

    注释

    嵌套注释:
    /* A
    /* B */
    /

    常量和变量

    常量和变量名可以使用Unicode字符来命名,但不能包含数学符号,箭头,保留的(或者非法的)Unicode码位,连线与制表符。也不能以数字开头。

    常量和变量一旦声明为确定的类型,即不能改变其存储的值的类型。同时,常量和变量不能互转。

    数字

    除非需要特定长度的整数,一般来说使用Int就够了,这样可以提供代码一致性和可复用性。

    尽量不要使用UInt,除非需要存储一个和当前平台原生字长相同的无符号整数。否则,最好使用Int,即使要存储的值已知是非负的。统一使用Int可以提高代码的可复用性,避免不同类型数字之间的转换,并且匹配数字的类型推断。

    Double类型的精确度高于Float,选择哪个类型取决于代码需要处理的值的范围,在两种类型都匹配的情况下,优先选择Double

    类型推断

    数字类字面量可由编译器推断类型,而数字类常量和变量必须显式转换为其他类型。

    类型别名

    类型别名typealias就是给现有类型定义另一个名字。

    元组

    可以把任何顺序的类型组合成一个元组,这个元组可以包含所有类型。

    可以将一个元组的内容分解为单独的常量和变量。如果只需要一部分元组值,分解的时候可以把要忽略的部分用下划线(_)标记。

    定义元组的时候,可以给单个元素命名。

    let http200Status = (statusCode: 200, description: “OK")
    print(“status code: \(http200Status.statusCode), description: \(http200Status.1)”)
    let (justTheStatusCode, _) = http200Status

    可选类型

    可选类型可以暗示任意类型的值缺失,并不需要一个如Objective-C中的NSNotFound这样的特殊值来标记非对象类型。

    可以给可选变量赋值为nil来表示它没有值,nil不能用于非可选的常量和变量。

    Swift的nil和Objective-C的nil并不一样。后者是一个指向不存在对象的指针。在Swift中,nil不是指针——它是一个确定的值,用来表示值缺失。

    可选绑定

    使用可选绑定(optional binding)来判断可选类型是否包含值,如果包含值就把值赋值给一个临时常量/变量。可选绑定可以用在ifwhile语句中。

    注意:在if条件语句中使用常量/变量来创建一个可选绑定,仅在if语句的句中(body)中才能获取到值。相反,在guard语句中使用常量/变量来创建一个可选绑定,仅在guard语句外且在语句后才能获取到值。

    隐式解析可选类型

    有时在程序架构中,第一次赋值之后可以确定一个可选类型总会有值。这种情况下,每次都要判断和解析可选类型是非常低效的。这种类型的可选状态被定义为隐式解析可选类型(implicitly unwrapped optionals)。把想要用做可选类型的后面的问号(String?)改为感叹号(String!)来声明一个隐式解析可选类型。

    注意:只在确定一个变量不可能变为nil时才使用隐式解析可选类型。否则在隐式解析可选类型没有值的时候尝试取值,会触发运行时错误;正如和没有值的普通可选类型后面加一个惊叹号一样。

    2. 基本运算

    空合运算符(Nil Coalescing Operator)

    空合运算符(a ?? b)将对可选类型a进行空判断,如果包含一个值就进行解封,否则就返回一个默认值b。注意这里,a 必须是可选类型, 默认值b的类型必须与a存储值的类型保持一致。

    区间运算符(Range Operators)

    a…b // 闭区间运算符
    a..<b // 半开区间运算符
    array[2…] // 单侧区间1
    array[…2] // 单侧区间2

    3. 字符串和字符

    多行字符串字面量

    由一对三个双引号"""包裹着文本,可实现跨越多行的字符串。注意:从开启引号当前行之后的第一行开始,到关闭引号当前行之前的一行为止。可以在行尾写一个反斜杠(\)作为续行符来实现增强代码可读性且避免换行。

    关闭引号当前行之前的空白字符串告诉Swift编译器其他各行多少空白字符串需要忽略。

    字符串是值类型

    Swift的String是值类型。拷贝的方式保证了在函数/方法中传递的是字符串的值。

    连接字符串和字符

    字符串支持的运算符包括+ += == !=,也可以使用append()方法将一个字符附加到一个字符串变量的尾部。

    字符串插值

    字符串插值是构建新字符串的方式之一,可以包含常量、变量、字面量和表达式。

    4. 集合类型(Collection Types)

    Swift语言提供Array(有序数据集合)、Set(无序不重复数据集合)、 Dictionary(无序键值对集合)三种基本集合类型用来存储集合数据。它们存储的数据类型必须明确。

    集合的可变性

    如果集合赋值给一个变量,则这个集合是可变的;否则分配给一个常量,则是不可变的。

    数组(Array)

    数组Array支持使用加法运算符+和加法赋值运算符+=[]是空数组。

    注意:自定义类型通过实现Hashable协议,可以作为集合的值的类型或者是字典的键的类型。实现Hashable协议,需要提供一个类型为Int的可读属性hashValue

    集合(Set)

    你可以高效地完成Set的一些基本操作,比如把两个集合组合到一起,判断两个集合共有元素,或者判断两个集合是否全包含,部分包含或者不相交。

    字典(Dictionary)

    通过访问keys或者values属性,我们也可以遍历字典的键或者值。

    5. 控制流

    Swift提供了多种流程控制结构,包括可以多次执行任务的while/(repeat-while)循环,基于特定条件选择执行不同代码分支的if、guard和switch语句,还有控制流程跳转到其他代码位置的break和continue语句。
    Swift 还提供了for-in循环,用来更简单地遍历数组(Array),字典(Dictionary),区间(Range),字符串(String)和其他序列类型。
    Swift 的switch语句比 C 语言中更加强大。case 还可以匹配很多不同的模式,包括范围匹配,元组(tuple)和特定类型匹配。switch语句的 case 中匹配的值可以声明为临时常量或变量,在 case 作用域内使用,也可以配合where来描述更复杂的匹配条件。

    Switch

    区间匹配

    case 分支的模式也可以是一个值的区间。

    元组

    我们可以使用元组在同一个switch语句中测试多个值。元组中的元素可以是值,也可以是区间。另外,使用下划线(_)来匹配所有可能的值。

    值绑定(Value Bindings)

    case 分支允许将匹配的值声明为临时常量或变量,并且在case分支体内使用 —— 这种行为被称为值绑定(value binding)。

    case 分支的模式可以使用where语句来判断额外的条件。

    复合匹配

    当多个条件可以使用同一种方法来处理时,可以将这几种可能放在同一个case后面,并且用逗号隔开。

    控制转移语句

    控制转移语句改变代码的执行顺序,通过它可以实现代码的跳转。

    Swift有五种控制转移语句:

    • continue
    • break
    • fallthrough
    • return
    • throw

    在 Swift 里,switch语句不会从上一个 case 分支跳转到下一个 case 分支中。

    相比之下,C 语言要求你显式地插入break语句到每个 case 分支的末尾来阻止自动落入到下一个 case 分支中。

    如果你确实需要 C 风格的贯穿的特性,你可以在每个需要该特性的 case 分支中使用fallthrough关键字。

    可以使用标签(statement label)来标记一个循环体或者条件语句,对于一个条件语句,你可以使用break加标签的方式,来结束这个被标记的语句。对于一个循环语句,你可以使用break或者continue加标签,来结束或者继续这条被标记语句的执行。

    例如,针对循环体的标签:

    label name: while condition { statements }

    提前退出

    if语句一样,guard的执行取决于一个表达式的布尔值。我们可以使用guard语句来要求条件必须为真时,以执行guard语句后的代码。不同于if语句,一个guard语句总是有一个else从句,如果条件不为真则执行else从句中的代码。

    guard let/var condition else {
        return // break/continue/throw/fatalError()
    }

    相比于可以实现同样功能的if语句,按需使用guard语句会提升我们代码的可读性。它可以使你的代码连贯的被执行而不需要将它包在else块中,它可以使你在紧邻条件判断的地方,处理违规的情况。

    检测API可用性

    if #available(platform name version, ..., *) {
        APIs 可用,语句将执行
    } else {
        APIs 不可用,语句将不执行
    }

    6. 函数(Functions)


    1. The Swift Programming Language http://wiki.jikexueyuan.com/project/swift/
    展开全文
  • Swift,苹果于2014年在苹果开发者大会发布的开发语音,可与OC共同运行于Mac OS 和ios平台,用于搭建基于苹果平台的应用程序。之前Swift一直不稳定,看过书,读过blog,今天开始,我以对比(OC:Swift)的形式将swift...
  • swift4.0 特性

    2017-08-21 11:09:18
    #1.添加Codable协议,方便自定义数据类型序列化 #2.添加定义多行字符串语法 #3.... #4....#5....在Objective-C中值类型的相互影响是十分糟糕的。比如NSCoding协议,类继承它之后,我们需要在类中重写自定义的 e
  • Swift4.0 简单项目demo

    千次阅读 2018-06-13 19:00:48
    swift4.0基于MVVM开发模式的简单demo1.Alamofire (swift版的AFNetworking)封装与使用2.ESPullToRefresh 上拉加载下拉刷新 简单使用3.Kingfisher(swift版的SDWebImage)使用4.SnapKit(swift版的Masonry)使用5....
  • //// ViewController.swift// 014-UICollectionView//// Created by 庄壮勇 on 2018/1/4.// Copyright © 2018年 Personal. All rights reserved.//import UIKitclass ViewController: ...
  • Swift4.0 guard,Array,Dictionary

    千次阅读 2017-09-26 15:57:33
    guard是Swift新增语法. guard语句必须带有else语句当条件表达式为true时候跳过else语句中的内容,执行语句组内容;条件表达式为false时候执行else语句中的内容,跳转语句一般是return、break、continue和throw guard ...
  • Swift 4 在 Swift 3 的基础上,提供了更强大的稳健性和稳定性,为 Swift 3 提供源码兼容性,对标准库进行改进,并添加了归档和序列化等功能。 你可以通过观看 WWDC 2017: What’s New in Swift 或完整发行说明...
  • Swift4.0 study1 语法

    2018-01-19 10:29:45
    swift学习第一天 :语法 1.常量和变量 var 修饰变量 (可以修改) let 修饰常量(不可变) print代理oc中的NSLog输出 2.数据类型转换:Swift是强语言(OC是弱语言)故进行转换时必须指明数据类型,即...
  • Swift中的函数相当于OC中的方法Swift中函数的格式 func 函数名(参数列表) -&gt;返回值类型{ 代码块 return 返回值 }常见的函数类型:// 1.无参数,无返回值类型 箭头和void都可以省略 func test() -&gt; ...
  • Swift 4.0 特性

    千次阅读 2017-08-15 19:37:46
    WWDC 2017 带来了很多惊喜,在这次大会上,Swift 4 也伴随着 Xcode 9 测试版来到了我们的面前,虽然正式版要8月底9月初才会公布,但很多强大的特性正吸引我们去学习它。根据大会上已经开放的特性,先一睹为快。...
  • Swift:没有隐式转换,必须指明类型后才能运算。 1.算数运算符:+ - * / +=(swift中的++变成了+=) -=(swift中的--变成了-=) 2.关系运算符: &gt; &lt; &gt;= &lt;= == != 3.赋值运算:= += ...
  • coreBluetooth4.0(swift)

    2015-07-09 15:49:50
    看过一些蓝牙App的事例,大体上对蓝牙的连接过程...这里所说的蓝牙是针对 bluetooth 4.0的。  第一步就是去看官方的关于蓝牙框架的文档,即Core Bluetooth Programming Guide,在苹果的官方网站上可以轻松找到,不管
  • Swift4.0中AFNetworking的桥接和使用

    千次阅读 2018-08-05 09:21:40
    一、创建AFnetworking桥接文件: Github里面down下来AFNetworking的压缩包,解压缩然后将里面的AFNetworking和UIKit+AFNetworking这两个文件夹直接拖进去要用的那个工程里面去。 在Build Phrases下的Compile...
  • 1.在ios开发中,数组经常用到,今天我们就来说说数组// 1.定义一个不可变数组 let arrayC = [1,2,3] // 2....// 2.1 定义一个任意类型的数组 //var arrayM = Array&lt;T&...var arrayM2 = [3,...
  • 蓝牙是设备近距离通信的一种方便手段,在App引入蓝牙4.0后,设备之间的通讯变得更加简单。通过蓝牙进行通讯交互分为两方,一方为中心设备central,一方为外设peripheral,外设通过广播的方式向外发送信息,中心设备...
  • Core Data by Tutorials v4.0 Core Data by Tutorials v4.0
1 2 3 4 5 ... 20
收藏数 5,517
精华内容 2,206
关键字:

4.0新 swift