语言新特性,基本语法

Swift是苹果推出的三个比较新的语言,它除了借鉴语言如C#、Java等剧情外,好像还运用了无数JavaScript脚本里面包车型大巴片段剧本语法,用起来倍感那多少个棒,作为八个使用C#多年的技能控,对这种比较超前的语言特别感兴趣,早前也在就学ES6语法的时候学习了阮大器晚成峰的《ECMAScript 6 入门》,对JavaScript脚本的ES6语法写法美评如潮,这种Swift语言也装有众多这种本子语法的表征,能够说那几个斯威夫特在吸收接纳了Object C的长处并甩掉一些不佳的东西外,同期接纳了大气新一代语言的各样特色,包括泛型、元祖等风味。小编在读书斯威夫特的时候,开掘合法的语言介绍文章(The Swift Programming Language)照旧特别浅显易懂,即便是爱沙尼亚语,但是代码及深入分析表明都很到位,正是内容展现相当多一些,而大家作为本领职员,日常看代码就很好刺探了各个语法特点了,基于那些原因,我对官网的案例代码实行了叁个摘要计算,以代码的不二等秘书籍张开Swift语言的语法特点介绍,总括一句话正是:快看Sample代码,速学Swift语言。

1、斯威夫特 2.0 带给什么新变化

  • 好端端浮动:

    • 1、OS X 10.11、iOS 9 和 watchOS 2 SDK 采取了有个别 Objective-C 的特点用来压实 Swift 的编制程序体验, 如可空性、类型化会集和局地别的脾气。

    • 2、编写翻译器对冗余的磋商少年老成致性,未被利用的绑定值以至能够设为常量的变量那么些情况近期会授予警示或报错。

    • 3、修复了跨文件公约服从时符号不可以见到只怕重新的大错特错。

    • 4、斯威夫特 语言的调用约定特别智能,能够领略 API 所爆发的变化和 Swift 所付出的警告。

    • 5、便利的可失利布局器(failable initializer)能够先回去 nil,而不用首先调用 self.init。那是有益的一 面,但钦点了构造器在回到 nil 前仍要给具有字段起头化。

    • 6、find 函数改名叫 indexOfsort 则形成了 sortInPlacesorted 变成了 sort

    • 7、String.toInt() 重名为 Int(String) 的可失利构造器,因为布局器语法更相符类型转换。

      • String 类型不再遵守 SequenceType,能够行使 .characters.utf8.utf16 对应字符集的运算。允许对泛型加多公共增加。

      • 字符串长度长度总计由 count(String) 变为 String.characters.count

      • 字符串裁剪由 code.substringToIndex(advance(code.startIndex, 6)) 变为 let endIndex = code.startIndex.advancedBy(6) code.substringToIndex(endIndex)

    • 8、标准库中重构了无数泛型的大局函数(如 mapfiltersort),选取合同扩大格局增添这几个办法。那几个利润是对于别的的涉及类型能很好的适配。

      • 非泛型类类型能够持续泛型类(强制类型参数牢固)。

      • 修补了 Swift 中泛型需要打印时 “T==T” 的错误。

      • 在泛型函数中宣称了项目参数但是在函数中绝非采纳时将发出三个编写翻译时不当,举例:

      • func foo<T> () {} // error:generic parameter ’T’ is not used in function signature

    • 9、基本上能够利用 enum SomeEnum<T,U,V> 来证明 multi-payload 风格的枚举,那样就能够不荒谬运转。那用来提醒未产生的指令寄放器(I奇骏)引发的失实。

      • 在 Objective-C 的枚举类型导入到 Swift时,已经废除的枚举成分将不会影响可用成分的运用,那些可能须要Swift 中有的枚举名称的改观。

      • 从 C 中程导弹入的枚举类型都代表为 RawRepresentable,那包含哪些未有被声称为 NS_ENUMNS_OPTIONS 枚举值,全数这么些枚举类型中的 value 属性都亟需重名称为 rawValue.

    • 10、方法和函数今后应用同风流倜傥的参数命名法则了,大家得以用 “_” 符号来轻巧二个表面包车型客车参数名,为了简化使用,用来钦定参数名的简化符号 “#” 被移除,因为 Swift 为暗中同意参数提供了特殊的规行矩步:

      • 声明:

            func printFunction(str:String, newline:Bool)
            func printMethod(str:String, newline:Bool)
            func printFunctionOmitParameterName(str:String, _newline:Bool)
        
      • 调用:

            printFunction("hello", newline:true)
            printMethod("hello", newline:true)
            printFunctionOmitParameterName("hello", true)
        
    • 11、条件循环语句 do/while 循环被重名字为 repeat/while。关键字 do 近年来用来引进贰个新的效率域(那对新引入的错误管理和 defer 关键字很首要)。

          Swift 1.2:
      
              do {
                  ...
              } while <condition>
      
          Swift 2.0:
      
              repeat {
                  ...
              } while <condition>
      
    • 12、打印语句的改变,在 斯威夫特1 中,有 println()print() 五个在调节台打字与印刷语句的诀窍,前边二个是换行打字与印刷,后面一个是连行打字与印刷。在 Swift 2 中,println() 已产生千古,代替他的是他俩的结合体。

          Swift 1.2:
      
              func print(<stuff to print>)
              func println(<stuff to print>)
      
          Swift 2.0:
      
              func print(<stuff to print>, appendNewline:Bool = true)
      
          如果你想做连行打印,现在需要这样写:
      
              print("我要换行!", appendNewline: true)
      
    • 13、Swift 的文书注释(doc comments)换来了 Markdown 语法格式,与 Playgrounds 统生机勃勃(Playgrounds 注释格式源于成效有限的 reStructured Text)。

          参数纵览语法:
      
              ‐ Parameters:
                  ‐ x:...
                  ‐ y:...
      
          单独参数语法:
      
              ‐ parameterx:...
              ‐ parametery:..
      
          返回值:
      
              ‐ returns:...
      
          其他需要在 QuickHelp 中高亮的语法字段,可以参考 Markdown 语法。
      
    • 14、在 Swift 中追加了 @objc(propertyName) 属性,当该属性导入到 Objective-C 时能够行使那些 propertyName 作为 getter/setter 访谈器的暗许名,举个例子:

          class MyClass:NSObject {
      
              // Objective‐C 属性被命名为 “theProperty”
              @objc(theProperty) property:String
      
              // Objective‐Cgetter 访问器被命名为 “theProperty”
              // Objective‐Csetter 访问器被命名为 “setTheProperty:”
          }
      
    • 15、注册布告由

              var types = UIUserNotificationType.Badge | UIUserNotificationType.Sound | UIUserNotificationType.Alert
              var acceptAction = UIMutableUserNotificationAction()
      
              acceptAction.identifier = "ACCEPT_IDENTIFIER"
              acceptAction.title = "Accept"
              acceptAction.activationMode = UIUserNotificationActivationMode.Foreground
              acceptAction.destructive = false
              acceptAction.authenticationRequired = false
      
              var inviteCategory = UIMutableUserNotificationCategory()
      
              inviteCategory.identifier = "INVITE_CATEGORY"
              inviteCategory.setActions([acceptAction], forContext: UIUserNotificationActionContext.Default)
              inviteCategory.setActions([acceptAction], forContext: UIUserNotificationActionContext.Minimal)
      
              var categories = NSSet(object: inviteCategory)
              var mySettings = UIUserNotificationSettings(forTypes: types, categories: categories as Set<NSObject>)
      
              UIApplication.sharedApplication().registerUserNotificationSettings(mySettings)
              UIApplication.sharedApplication().registerForRemoteNotifications()
      
          修改为:
      
              let acceptAction = UIMutableUserNotificationAction()
      
              acceptAction.identifier = "ACCEPT_IDENTIFIER"
              acceptAction.title = "Accept"
              acceptAction.activationMode = UIUserNotificationActivationMode.Foreground
              acceptAction.destructive = false
              acceptAction.authenticationRequired = false
      
              let inviteCategory = UIMutableUserNotificationCategory()
      
              inviteCategory.identifier = "INVITE_CATEGORY"
              inviteCategory.setActions([acceptAction], forContext: UIUserNotificationActionContext.Default)
              inviteCategory.setActions([acceptAction], forContext: UIUserNotificationActionContext.Minimal)
      
              let categories = NSSet(object: inviteCategory) as! Set<UIUserNotificationCategory>
              let mySettings = UIUserNotificationSettings( forTypes: [.Alert, .Badge, .Sound], categories: categories)
      
              UIApplication.sharedApplication().registerUserNotificationSettings(mySettings)
              UIApplication.sharedApplication().registerForRemoteNotifications()
      
  • 内部的可知性:

    • 那解决了单元测验中的二个不小的难题。早前的做法:

      • Swift 文件富含在 test target 中。以往不一致的模块中有重新的类的定义,现身不恐怕将 “X” 转变为 “X” 这样充裕骇人据他们说的不当,有时会不能履行一定的测验。

      • 在测验中引进引进主程序(main program)作为一个模块。今后全部都宣称为 public,所以对于测量检验来讲都以可以看到的,一时候也包涵应当申明为 private 的内部细节。

    • 于今能够启用 testability,它就像 C# 中的 InternalsVisibleTo。主应用程序指标模块的里边细节对测量检验模块可以看到。

      • 在对采用或框架的测量试验设置中,启用 testability。
      • 在单元测验中,使用 @testable import { ModuleName }
    • 那将变成测量检验忽视有些优化行为并保存稍后导入到测量试验模块中的那个内部符号。官方文书档案警示说,由于阻止了好几优化,因而那只适用于调节和测验和测量检验版本。

  • 情势相称:

    • Switch 语句的情势相配(pattern matching)语法和 “if let ..., .... where” 语法一贯在放大。能够在别的决定流中使用逗号操作符和 where 条件语句。还是可以运用新的 case 条件语句,例 - 如:if case .Silly(let a) { }。还大概有生机勃勃种用于 Optional<T> 的新鲜格局:if case let a? = anOptional { }

      • 格局相配在循环语句中也足以行使:for case let thing? in array { }。 这又是值得单独成文的另四个特点。

      • 品种标记不可能用于情势相配,而急需用作评释注解的豆蔻梢头有的:

        • 那意味,在此早先的如此的写法:

          • var (a:Int, b:Float) = foo()
        • 急需被重构为:

          • var (a, b):(Int, Float) = foo()
        • 实在这里个改造原因是为了和元组用法相区分。

  • 错误管理:

    • NSError 产生throw。那不是咱们平昔所认知的不得了,那是三个使函数提前重临 Result 的操作,单隐敝了独具提前重返的对象,也暗藏了不当剖析(error unwrapping)进度等内容。

          let systemAttributes: [NSObject: AnyObject]?
      
          do {
      
              systemAttributes = try NSFileManager.defaultManager()
                                                  .attributesOfFileSystemForPath(documentDirectoryPath.last!)
      
          } catch _ {
      
              systemAttributes = nil
          }
      
          它完美地与 Objective-C 进行互操作,Swift 语言中,将标记为 throws 的方法作为选择器。这是使用 NSError 的方法,
          -(BOOL or nullable type)someMethodTakingParam:(type)param error:(NSError **),
          这种样式会自动引入标记为 throws 的方法。
      
    • 应当明白的是那并不像 Java 中已经被检查过的老大(checked exception)那样。Swift语言并不保护格外的项目,大概管理恐怕不管理。那又是值得单独成文的另意气风发效果特色。

  • guard 语句块:

    • 显式地声称你要恒创制的口径语句,恒成马上跳过一切 guard 语句。那样做的功利是绑定在 guard 语句的变量在函数的任何一些也可用。那就幸免了将持有的事物都围绕一条 if 语句嵌套使用来深入分析(unwrap)可选类型的变量。施行到函数中 guard 语句中的 else 部分,函数一定会退出并抛出拾壹分。也大概会调用带有 @noreturn 标志的函数。
  • Defer 关键字:

    • 第一字 defer 也很关键,因为它能够代替守旧 C 风格的 “if (err) goto cleanup”。获得财富后接着正是 defer { release_resource() }。然后不管函数再次回到结果怎么样,获得的财富都将被清理。这也象征能源的获释紧随获取能源之后。那看起来不起眼儿,实则很关键。
  • NS_OPTIONS 和 OptionSetType:

    • NS_OPTIONS 类型今后根据 OptionSetType 协议,那样能够制止 set 样式的接口调用。位操作枚举(bitwise enumeration)与数组风格的语法相结合,而不行使管道符 “ | ” 按位操作,而且有着全数范围的集聚操作功用。检查一下是或不是具备contains 作用的证明,或能够实施像 isSubsetOfisDisjointWith 等如此群集操作的其余作用。那是明显的改过,表明了不直接对位举办操作的素志。

    • 幸免接收如下位运算的调用方式:

          // Swift1.2:
      
              object.invokeMethodWithOptions(.OptionA | .OptionB)
              object.invokeMethodWithOptions(nil)
      
              if options & .OptionC == .OptionC {
      
                  //.OptionC 被设置
              }
      
    • 选用设置扶植字面量语法和 set 样式的调用,如 contains:

          object.invokeMethodWithOptions([.OptionA, .OptionB])
          object.invokeMethodWithOptions([])
      
          if options.contains(.OptionC) {
      
              //.OptionC is set
          }
      
    • 这种调换代表位操作枚举实际上不再是枚举了。将那一个位操作枚举证明为布局体,完结 OptionSetType 协议,提供 rawValue 属性。况兼创办值作为布局体的静态成员。斯维夫特便会解决其他的全方位,自动提供具备集结的操作。

    • 在 斯维夫特 中二个新的 Option 设置类型能够应用结构体死守 OptionSetType 左券的方法编写。假使该类型中钦赐了一个 rawValue 属性和 static let 的常量定义,那么典型库将会为别的采用提供暗中同意完成:

          structMyOptions:OptionSetType {
      
          let rawValue:Int
              static let TuringMachine = MyOptions(rawValue:1)
              static let LambdaCalculus = MyOptions(rawValue:2)
              static let VonNeumann = MyOptions(rawValue:4)
          }
      
          let churchTuring:MyOptions = [.TuringMachine, .LambdaCalculus]
      
  • 合计增加:

    • 在 Swift 1.0 时代,左券(Protocol)基本上肖似一个接口,定义若干本性和方式,供类、构造体、枚举坚守和兑现。在 Swift 2.0 中,能够对协商进行品质恐怕措施的扩大,和扩大类与布局体相符。,包含与品种限制有关的通用契约。还足以友善提供公约的私下认可完成。那让大家打开了面向公约编制程序的稿子。先前,你不能够,你说:“小编要使用方法 X 来扩张CollectionType,但只有成团中的类型满意有个别法规才得以”。现在,你可以如此做,何况超级多像 map,filter 和 sort 那样的大局函数已经开展了扩展。那样就祛除了不少痛点,那也是值得单独成文的原委。同不平时候,要拜望WWDC 的面向合同编制程序(Protocol Oriented Programming)了然一些细节。

    • Swift 中,大相当多幼功对象都依据了 CustomStringConvertible 公约,举个例子 Array、Dictionary(斯威夫特 1.0 中的 Printable 公约),该左券定义了 description 方法,用于 print 方法打字与印刷对象。未来大家对该公约扩大三个办法,让其打字与印刷出大写的从头到尾的经过:

          var arr = ["hello", "world"]
      
          print(arr.description)         // "[hello, world]"
      
          extension CustomStringConvertible {
              var upperDescription: String {
                  return "(self.description.uppercaseString)"
              }
          }
      
          print(arr.upperDescription)    // "[HELLO, WORLD]"
      
    • 豆蔻年华经在 Swfit 1.0 时代,要想达到上述示范的法力,那么我们须求各自对 Array、Dictionary 进行扩充,所以公约的强大不小的狠抓了大家的编制程序功能,也风流洒脱律使代码更简明和易读。

  • available 检查:

    • 作为 iOS 开拓者,何人都希望利用最新版本 iOS 的 Api 举办付出,省事省力。但日常白璧微瑕,因为我们平常索要适配老版本的 iOS,那就能直面三个标题,一些新特征本性或局地类无法在老版本的 iOS 中央银行使,所以在编码进程中平常会对 iOS 的版本做以咬定,就好像这么:

          if NSClassFromString("NSURLQueryItem") != nil {
              // iOS 8 或更高版本
          } else{
              // iOS8 之前的版本
          }
      
    • 以上那只是少年老成种办法,在 斯威夫特 2.0 早前也从不二个正经的方式或机制帮助开垦者剖断 iOS 版本,何况便于并发脱漏。在 Swift 2.0 到来后,大家有了专门的学问的方式来做那几个工作:

          if #available(iOS 8, *) {
      
              // iOS 8 或更高版本
              let queryItem = NSURLQueryItem()
      
          } else {
              // iOS8 之前的版本
          }
      
    • @available 属性自 Swift 1.2 就存在了同不时间继续协助得很好。加多了叁个新的素不相识语法 if #available(),为管理版本检查提供了扶持。并不是插入你欢跃的方式。

    • 可惜的是你无法只声圣元(Synutra卡塔尔(英语:State of Qatar)(Karicare卡塔尔(قطر‎个性质 UISearchController 并将 target 设置为 iOS 7,然后只同意访问类中的属性。斯维夫特希望全体类的定义都得以大概不得以。也足以不再选取左券,除非支持target设置中装有的操作系统版本,除非将整个类标识为只在校正的操作系统版本可用。

    • 那意味使用 if #available() 存在单独的子类和对创设适当对象的保证。尽管如此,小编个人依旧发掘了一个Bug,应用在 iOS 4.0-4.1 发生崩溃,由于编写翻译器未有发生警示,方法只在 iOS 4.2 才引进,因而我仿佛与按时炸弹相伴。

  • C 函数指针:

    • 斯维夫特 未来得以接收 C 函数指针,CFunctionPointer<T -> U> 类型被移除,C 函数现在利用新的 @convention(c) 属性申明,和任何函数类型同样,@convention(c) T -> U 是三个非空的唯有是它是可选的。任何全局函数,嵌套函数和不抓获状态的闭包都能够作为三个C 函数指针间接传送。你也得以调用来自 C 程序的函数。

    • 你能够展现地选择新属性 @convention(c),表示函数应该选择 C 调用约定,轻易痛快!就算本身想不出在那对块(block)的帮忙有什么用,作为所发生变化的大器晚成某些,@objc_block 也被删掉了,使用 @convention(block) 代替他。@convention(swift) 暗许支持全体函数和闭包。

  • API 审计:

    • 大方的 API 已经更加的进展了审计而更合理。举多少个例子:

      • UITableView 的 dequeueReusableCellWithIdentifier 方法以往归来 UITableViewCell? 类型的靶子。

      • UIKit 的质量未来也被声称为了实际的品质。

      • translatesAutoresizingMaskToConstraints = false 代替了 setTranslatesAutoresizingMaskToConstrains(false)

  • 库:

    • 这并不是编制程序语言商量所特有的。iOS 9 含有分歧版本的 斯威夫特标准库,况且在将来系统中校增添修改后的 斯威夫特 标准库。结合新的 App Thining 技艺,下载进程中苹果商铺会将 斯威夫特标准库抽离出去的。小编如故在追根求源地追逐这毕竟是怎么做事的。
  • 遗漏:

    • 鲜明的一个疏漏是拍卖异步代码。苹果集团为大家提供了 GCD,那是三个无敌的底工类库,能够营造超多异步操作和现身原语。可是,这一个天大家做的每件事,创设客商接口和 API 都要求构思异步性和并发性。大家把一个文本读操作锁定后生可畏段时间,对客户来讲一切世界就都维持原状了。那是个不断的痛点,不是多大的事宜,但假使平常性地每日重复,或许也是非常的。C# 和 JavaScript 都施用了 async/await 来为异步代码提供超级的言语扶持。小编想繁多个人都想知道,Swift会提供哪些的语法糖来扶持大家在落到实处异步操作方面保险正确。

前言

  • Swift 周密帮忙 Unicode 符号。
  • 斯维夫特 中的定义和完成是在同二个单元中的,常常二个 Swift源代码单文件是以 “.Swift” 结尾的。
  • 斯维夫特 没有供给独自编写制定叁个 main 函数作为入口,在 Swift语言中等学园函授数是第一级成员,编写翻译器会自动将超过的率先个函数作为入口。
  • 斯威夫特 允许大家绝不在行尾加分号 “;”。但假设在同生龙活虎行有七个以致四个表明式,供给在各类表明式前边加上分号。

  • Playground 是黄金时代种编写代码时得以立时预览代码运维效果的机能。使用 Playground 后,在事实上项目中可感觉大家节省数不尽效应调试和函数测量检验时间,那几个时刻完全能够从事其余创立性的移位。

  • 斯威夫特 常用标记:

    • // MARK: 增添注释表达,加 “-” 增添分割横线
    • // FIXME: 表示此处有 bug 只怕要优化
    • // TODO: 平日用来写到哪了做个暗记,然后回到继续

1、语法速览

var myVariable = 42
myVariable = 50
let myConstant = 42

变量定义用var,常量则用let,类型自行预计。

 

let apples = 3
let oranges = 5
let appleSummary = "I have (apples) apples."
let fruitSummary = "I have (apples   oranges) pieces of fruit."

用括号富含变量

 

let quotation = """
I said "I have (apples) apples."
And then I said "I have (apples   oranges) pieces of fruit."
"""

代码通过四个双引号来含有预约格式的字符串(富含换行符号),左边缩进空格省略。

 

var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

数组和字典集结开始化相符健康,字典后边能够保留逗号结尾

let emptyArray = [String]()
let emptyDictionary = [String: Float]()

初始化函数也正如轻松。

 

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore  = 3
    } else {
        teamScore  = 1
    }
}
print(teamScore)

调整流的if-else那么些和别的语言未有何样异样,for ... in 则是迭代遍历的语法,调控流情势还扶持任何的while、repeat...while等不等的语法。

 

var optionalString: String? = "Hello"
print(optionalString == nil)

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, (name)"
}

那有的则是可空类型的利用,甚至可空剖断语句的接纳,可空推断语句在斯维夫特中选择十三分遍布,这种也就是先求值再推断是还是不是步向大括符语句。

 

let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy (x)?")
default:
    print("Everything tastes good in soup.")
}

Switch语法和正规的语言不相同,这种简化了有的语法,种种子条件不用显式的写break语句(暗中同意正是再次回到的),七个标准化逗号分开就可以公用一个确定管理。

 

let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)

下面字典遍历的方法接收for...in的方法展开遍历,其它通过(kind, numbers卡塔尔(英语:State of Qatar)的办法进行一个参数的解构过程,把字典的键值分别交由kind,numbers那多个参数。

 

var total = 0
for i in 0..<4 {
    total  = i
}
print(total)

地点的for...in循环使用了三个语法符号..<归属数学半密闭概念,从0到4,不含4,同理还会有全密闭符号:...全包罗左右七个范围的值。

 

func greet(person: String, day: String) -> String {
    return "Hello (person), today is (day)."
}
greet(person: "Bob", day: "Tuesday")

上边是函数的概念,以func关键字定义,括号内是参数的竹签、名称和档期的顺序内容,重临值通过->内定。

上边函数必要输入参数名称,假设没有供给参数名称,能够通过下划线省略输入,如下

func greet(_ person: String, on day: String) -> String {
    return "Hello (person), today is (day)."
}
greet("John", on: "Wednesday")

除此以外参数名称能够选用标具名称。

func greet(person: String, from hometown: String) -> String {
    return "Hello (person)!  Glad you could visit from (hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// Prints "Hello Bill!  Glad you could visit from Cupertino."

嵌套函数如下所示。

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y  = 5
    }
    add()
    return y
}
returnFifteen()

复杂一点的函数的参数可以流传函数进行利用,这种近乎闭包的拍卖了

func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)

上边是一个闭包的函数,闭包通过in 来区分参数和重回的函数体

numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    return result
})

 

 

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with (numberOfSides) sides."
    }
}

类的概念通过class关键字伸开标记,暗中认可的权能是internal,在品种模块内部能够访谈的,极其平价。

动用则如下所示,可以由此点语法直接拿走属性和调用方法。

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

 

class NamedShape {
    var numberOfSides: Int = 0
    var name: String

    init(name: String) {
        self.name = name
    }

    func simpleDescription() -> String {
        return "A shape with (numberOfSides) sides."
    }
}

类经过运用init的钦点名称作为布局函数,使用deinit来做析构函数,使用self来收获当前的类援引,相近于任何语言的this语法,super获取基类的援用。

别的的管理方式如继续、重写的语法和C#类似。

class Square: NamedShape {
    var sideLength: Double

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }

    func area() -> Double {
        return sideLength * sideLength
    }

    override func simpleDescription() -> String {
        return "A square with sides of length (sideLength)."
    }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

 

类的品质使用get、set语法关键字,和C#类似

class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }

    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }

 

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }

类属性的赋值可以开展观测,如通过willSet在装置以前调用,didSet在设置之后调用,完毕对品质值得监察和控制管理。

 

enum Rank: Int {
    case ace = 1
    case two, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king
    func simpleDescription() -> String {
        switch self {
        case .ace:
            return "ace"
        case .jack:
            return "jack"
        case .queen:
            return "queen"
        case .king:
            return "king"
        default:
            return String(self.rawValue)
        }
    }
}
let ace = Rank.ace
let aceRawValue = ace.rawValue

和类及别的类型一样,枚举类型在Swift中仍能有主意定义,是后生可畏种特别灵活的类型定义,这么些和大家从前接触过的貌似语言有所出入。

enum ServerResponse {
    case result(String, String)
    case failure(String)
}

let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure("Out of cheese.")

switch success {
case let .result(sunrise, sunset):
    print("Sunrise is at (sunrise) and sunset is at (sunset).")
case let .failure(message):
    print("Failure...  (message)")
}

 

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The (rank.simpleDescription()) of (suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

结构类型和类的各样方面很周边,布局帮忙构造函数,方法定义,属性等,首要一点莫衷一是是布局在代码传递的是别本,而类实例传递的是类的引用。

 

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

此间的合计,肖似比非常多语言的接口概念,可是比正规语言(包蕴C#)的接口更增加种化、复杂化一些。

Swift的左券,能够有局地方法达成,合同能够可选,继承其余协商等等。

 

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number (self)"
    }
    mutating func adjust() {
        self  = 42
    }
}
print(7.simpleDescription)

扩充函数通过extension进行标记,可以为已有的类进行增加部分独特的方式管理,这几个形似C#的恢宏函数。

 

func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    return "Job sent"
}

十一分处理中,函数注明通过throws关键字标记有特别抛出,在函数里面通过throw实行极度抛出管理。

而在拍卖有特其余地方进行阻拦,则经过do...catch的法子开展管理,在do的话语里面,通过try来堵住大概出现的不胜,暗中同意catch里面包车型地铁不胜名称叫error。

do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}

能够对八个十二分实行判断管理

do {
    let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
    print(printerResponse)
} catch PrinterError.onFire {
    print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
    print("Printer error: (printerError).")
} catch {
    print(error)
}

还是能透过利用try?的方法张开和睦的不得了管理,假诺有十三分重临nil,否者获取结果赋值给变量

let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")

 

var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]

func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true
    defer {
        fridgeIsOpen = false
    }

    let result = fridgeContent.contains(food)
    return result
}
fridgeContains("banana")
print(fridgeIsOpen)

使用defer的重要字来在函数再次回到前管理代码块,假诺有多个defer函数,则是后进先出的措施实行调用,末了的defer先调用,依次倒序。

 

func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result = [Item]()
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

Swift援助泛型,因而得以大大简化比超多函数的编排,提供更抓实有力的功效。

enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

 

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element {
        for lhsItem in lhs {
            for rhsItem in rhs {
                if lhsItem == rhsItem {
                    return true
                }
            }
        }
        return false
}
anyCommonElements([1, 2, 3], [3])

泛型的参数补助where的尤为重要字张开泛型类型的自律,如能够钦定泛型的参数选择什么左券可能连续哪个基类等等。

 

2、Swift 2.2 新特性

  • 同意越来越多的显要字用做参数名:

    • 好的参数名对于拉长代码可读性很入眼。在 斯威夫特 中过多种中之重字举例in,repeat,defer 都无法用做参数名。2.2中,除了少数修饰参数的关键字外都将同意作为参数名。

      图片 1

  • 为 Tuples 扩展比较操作符:

    • 现阶段,Tuples 的数目不能够应用 == 操作符,2.2 元帅扶助 Tuples。

      图片 2

  • 波及已存在项目时,不再动用 typealias:

    • typealias 今后有八个用项:
      • 为八个业已存在的类别取个小名
      • 在商量中作为二个门类的占位名称
    • 代码如下:

      图片 3

    • 那是三种截然两样的用法,不应当用同豆蔻年华的重要字。2.2 大校率先种意况时,启用新的显要字 associatedtype

  • 函数签字将囊括参数名:

    • 二个函数有同样的函数名,参数名分裂有四个重载很广泛。当有多少个重载时,在调用时能够由此参数名来分别。但是在收获项目时,却不饱含参数名。

    • 比如 UIView 中犹如此多少个方式:

      图片 4

    • 行使时得以经过参数名分别:

      图片 5

    • 而是这么使用时却会报错,2.2 少将会缓慢解决这么些难点。

      • let fn = someView.insertSubview // ambiguous: could be any of the three methods
  • 叁个新的主意生成 selector:

    • 近年来为了转移 OC 下选择的 selector 只可以利用字符串生成,未有项目检查,十分轻易产生失误。将提供三个 #selector(卡塔尔 方法生成 selector,如下:

    • let sel = #selector(UIView.insertSubview(_:at:)) // produces the Selector "insertSubview:atIndex:" 增加 #if swift 语法剖断当前 swift 版本

    • 使用如下:

      图片 6

1、Swift 基本数据类型

  • 1)变量与常量

    • 在 Swift 语言中声称变量使用 var 关键字,注脚常量使用 let 关键字。

          // 定义 String 类型的字符串  str
          let str:String = "hello world"
      
    • 扬言时类型是可选的,倘若在表明时从没点名项目且对变量赋了初值,编写翻译器会活动测算常量也许变量的连串,这种体制被称为 “类型预计”。假若在宣称时内定了品种又赋了初值,那么钦赐的门类必需和赋给它们的值同样,Swift是一门强类型语言,不能够将变量本人类型之外的值赋值给它。若无赋给初值,必须注解变量大概常量的花色,并用冒号充任分隔符,否则编写翻译会报错。

    • 斯维夫特 语言将现实的某类别型的值称之为类型字面量。比如 let num = 2.8 中的 "2.8" 就是浮点类型字面量。

  • 2)整型

    • 斯维夫特 语言具备持续自 C 语言的有号子类型 Int、Int8、Int16、Int32、Int64,以致无符号整形 UInt、UInt8、UInt16、UInt32、UInt64。其中 IntUInt 类型的字长始终和近年来平台的原生字长雷同,即 叁16人系统下表明获得的是 32 位的整型,64 位系统下得到的是 陆玖人的整型。

    • 整型的取值范围:

      • 最小值:Int8.minINT8_MIN
      • 最大值:Int8.maxINT8_MAX
    • 整型的证明:

      • 隐式表明机制:

            // 自动调用构造函数
            let intNum:Int = 12
        
      • 显式注脚机制:

            // 显式的调用初始化构造器
            let intNum = Int.init(22)
        
    • 其他措施或质量:

          // 计算两个数字之间的距离(两数之差)
          num.distanceTo(15)
      
          // 访问变量或常量的字符串版本
          num.description
      
          。。。。。
      
  • 3)浮点型

    • 斯威夫特 语言为大家提供了两种有号子浮点数类型,FloatDoubleFloat 是 32 位浮点数类型,Double 是 陆拾人浮点数类型。当使用场目估量声飞鹤个浮点型变量也许常量时,变量或常量总是暗中同意被测度为类 Double 型。

    • 浮点型的申明:

          let floatNum:Float = 2.1
      
          // 默认被推断为 Double 型
          let doubleNum = 2.2`         
      
  • 4)布尔型

    • 斯威夫特 语言中,布尔型只有二种值,truefalse。假若在 Swift语言中央行政机关接选取零可能非零来表示逻辑真假,编写翻译器一定会弹出格外。能够向来在布尔变量前加 “!”,来达成布尔值取反的意义。

    • 布尔型的宣示:

          let boolNum:Bool = false
      
  • 5)值类型/援用类型

    • 在 斯威夫特 语言中,全数的项目都能够被分为 “值类型” 或然“引用类型”,能够将其精晓为函数参数传递的点子。
    • 从程序的角度来看,值类型和引用类型是绝没有错三个定义,在那之中的歧异就在于:对新的靶子爆发赋值等目的性的操作之后,再一次操作赋值对象或被赋值对象是或不是会联手于别的三个指标。
    • 在 Swift语言中,超过59%门类都以值类型的,可是也许有部分特种意况,比方能够在函数参数定义中动用 inout 关键字将参数定义为引用类型。

          // a,b 都是引用类型
          func swapT<T>(inout a:T, inout b:T)
      
  • 6)可选类型

    • 斯维夫特 语言为大家提供了生机勃勃种崭新的、特别安全的门类 —— 可选类型。可选类型是使用范型枚举的样式来公司的,约等于说此天性能够使用于具备的品种、构造体、类照旧其余复杂数据类型。

    • 可选是指当一个变量、常量恐怕别的类中储存有值的时候回来里面储存的值,未有值的时候回来 nil。nil 不能够用于非可选的变量恐怕常量,假诺注明了四个可选的变量可能常量未有开始化,程序会默许赋值 nil。在 OC 中 nil 表示的是一个照准不设有对象的指针,而 斯维夫特向往味空的最首要字为 “nil”,它并没有别的意思。

    • 可选的扬言:

      • 可选的科班注解方式是在程序中动用场目名紧跟 “ ? ”。

            var value:Int?
        
            print("(value)")
            // 或 
            print("(value?.description)")
        
            // 输出为 nil
        
      • 可选的显式评释方式。

            var value:Optional<Int>
        
            print("(value)")
            // 或 
            print("(value?.description)")
        
            // 输出为 nil
        
    • <1>、可选绑定(Optional binding):

          var value:Optional<Int> 
          if var maxValue = value { 
              maxValue  
              print("(maxValue)") 
          }
      
      • 大器晚成经 value 值为 nil,则不进行变量 maxValue 的宣示,同期也不执行 if 决断语句中率先个分支的代码段,那样程序会比较轻松被清楚,何况只供给如此简单的两行代码就幸免了因为运用值为 nil 的目的形成的次第特别。
    • <2>、强制分析可选:

      • 若是明确那一个可选类型中的变量料定包蕴值的时候,能够行使名称紧跟 “ ! ” 的办法强制获取项目可选中的值,从而省略决断步骤。不过假使那一个变量中尚无值,使用强制深入分析可选恐怕会在运作期弹出卓殊。这种机制叫做“强制剖判可选”。
    • <3>、隐式剖判可选:

      • 在一些程序结构中,在一定模块中能够规定有个别可选变量总是有值的,这种时候能够采用隐式拆解深入分析可选深入解析可选,隐式深入剖判可接纳于二个规定会有值的可选类型实例申明。能够将可选变量表明中的“ ? ”改为“ ! ” 来标记三个隐式深入分析可选。

            var nullValue:String! = "Not Null String"
            print(nullValue)
        
    • <4>、可选运算符:

      • 可选运算符 “ ?? ” 的进行逻辑是表明式 var value = a ?? b 中当操作数 a 不为 nil 时表明式重回操作数 a 的值,当操作数 a 为 nil 时表达式重回操作数 b 的值。

            var value1:Int?
            var value2 = 3
            var value = value1 ?? value2
        
            print(value)
        
    • <5>、可选链:

      • 不畏将可选的调用链接在协作形成一个链,借使其余多少个节点为空(nil),将招致整个链失效。而不会掀起强制解包可选时产生的荒诞。可选链可以多层可选。
  • 7)泛型

    • 行使相符的操作能够行使于分化的数据类型。泛型编程的落到实处是大家前后相继在另风流倜傥种抽象档案的次序上的升官。类是切实可行世界事物的画个饼来解除饥饿,而泛型则是切实可行世界行为的空洞。在 斯威夫特 语言中,泛型能够说是用的最广最精锐的特点之风流浪漫,因为在 Swift语言本人的言语底层大批量的施用了泛型。

    • 泛型同任何语言相仿,用“< >” 符号来声称泛型。

          func  <T : _IntegerArithmeticType>(lhs: T, rhs: T) -> T
      
    • 泛型使得大家能够在编写好生机勃勃份代码之后,应用于两种数据类型,以至为了选取安全起见,大家仍是可以限定响应的泛型数据类型,必需遵循某个约束。

          func swapT<T>(inout a:T, inout b:T)
          struct Dictionary<Key : Hashable, Value> : CollectionType, DictionaryLiteralConvertible { }
      
  • 8)元组

    • 能够经过动用元组,把八个不等类别的值组合在一块儿,组成三个复合值。元组中的成分类型能够是相近的,也能够是不一样的。元组的扬言中也得以应用场目推测。元组能够用作函数再次来到值,它能够使函数能叁回回到越多的消息。

      • 元组的扬言:

        • 标准注明:

              // 定义时指定元组名称、元素名称并且初始化
              let myProject = (oneElement:"game", twoElement:2048)
          
        • 匿威望明:

              // 声明一个匿名的元组
              let (appType, appName) = ("game", 2048)
          
      • 元组瓜月素的走访:

        • 典型证明的元组:

              // 使用元素名访问
              print(myProject.oneElement)
          
              // 使用元素在元组中的顺序下标访问
              print(myProject.0)
          
        • 匿威望明的元组:

              // 使用元素名访问
              print(appType)
          
  • 9)枚举

    • 枚举是意气风发种自定义的数据类型,在 Swift中枚举类型具备一定高的自由度。在 Swift语言中枚举是顶尖类型,它兼具在任何语言中唯有类技能备的部分特征,举例实例方法,实例构造器等。枚举定义了一个常用的保有相关性的生机勃勃组数据,并在你的代码中以三个康宁的方法选择它们。

    • 两个枚举常常包含七个枚举成员,枚举成员能够包涵总结型属性、类型别名,以至别的枚举、构造体和类。枚举注脚中,每二个事件块都由三个case 关键字领头。多个分子的值能够出今后一行上,用逗号分隔。

    • 枚举是值类型,而且独有在予以变量或常量,或许被函数调用时才被复制。

    • <1>、标准定义格式:

          enum enumerationName {
      
              case enumerationCase1
              case enumerationCase2
              .....
          }
      
          enum PointRect {
      
              case top
              case bottom
              case left
              case right
          }
      
    • <2>、和 C 语言差异的是,标准的枚举定义格局成功定义枚举后,成员值并不会隐式被钦赐为 0、1、2、…… 这种样式。假如供给在概念时钦点开首值,大家得以应用另生龙活虎种样式。在宣称的时候赋予的值叫做原始值(raw value),那些值的项目会自行实行剖断,原始值必得是字面上的整数、浮点数、字符恐怕字符串。如果原始值类型变量被内定为整型,则不用为种种成员展现地钦定值,它们会被隐式的被标为值 0、1、2 、…… 等。

      • 带原始值的注脚情势:

            enum enumerationName: rawValueType {
        
                case enumerationCase1 = rawValue1
                case enumerationCase2 = rawValue2
                .....
            }
        
            enum PointRect:Int {
        
                case top
                case bottom = 2
                case left
                case right
            }
        
            // 枚举原始值类型变量被指定为整型,只显示的指定一个值,其它会被隐式的指定值(top == 0, left == 3, right == 4)
            print(PointRect.top.rawValue)           
        
    • <3>、其余能够通过为各样枚举成员设定二个或八个关系值,进而选取枚举来存款和储蓄和护卫一些刻意的数据。

          enum PointRect {
      
              case top(Int, Int)
              case bottom(Int, Int)
              case left(Double, Double)
              case right(Double, Double)
          }
      
    • <4>、枚举与类和布局体的关系:

      • 枚举与其余两个最大的相近之处就在于都足以定义方法。而任何的越来越多特点,对于枚举基本没有,未有品质,每四个枚举值都以常量。枚举中所定义的主意也遵照对自身值的操作,不可能定义一些非亲非故的属性和操作。
  • 10)结构体

    • 布局体是值类型的,其实例将会在被赋予变量大概常量和被函数调用时被赋值。

    • 业钦赐义格式:

          struct structName {
      
              var 成员1: 数据类型 1
              var 成员2: 数据类型 2
              .....
          }
      
          struct BookInfo {
      
              var ID:Int = 0
              var Name:String = "Default"
              var Author:String = "Default"
              var RootType:String = "Default"
          }
      
  • 11)类型别称

    • 在 Swift 语言中接纳 typealias 定义类型外号。

          typealias ShortInteger = Int8
      
  • 12)类型调换

    • 隐式类型调换:如 C 语言的类型转变
    • 显式类型调换:斯威夫特语言是后生可畏种强类型语言,其整型的强制类型调换正是调用了参数类型对应的整形增添构造方法,然后经过相应扩张构造方法的拍卖回来一个当下整形字长的整形值。

          // 将字符型转换成整型
          Int(12.4)
      

2、运算符

  • 斯威夫特 语言帮助大多数行业内部 C 语言的运算符,并且改良了多数特色来使大家的代码越发专门的学问,在那之中主要含有算数运算符、区间运算符、逻辑运算符、关系运算符、赋值运算符、自增自减运算符、溢出运算符等。

    图片 7

  • 1)组合赋值运算符:是将此外运算符和赋值运算符组合在合营实践的运算。算数自反赋值运算符归于整合赋值运算符。

    • 要兑现三个重新组合赋值符号供给把运算符的左参数设置成 inout 类型,从而使运算符函数体内部能够直接改革他的值。

          func  = (inout lhs: Int, rhs: Int) {
              lhs = lhs   rhs
          }
      
  • 2)自定义运算符:自定义运算符是新的编程语言才支撑的性状,分歧于组合赋值运算符,你能够利用 / = - * % < > ! & | ^ ~ 来组合构成新的运算符。

    • 自定义一个运算符平常要求先评释再贯彻其功能,证明自定义的运算符须求利用 operator 关键字。

          operator      :表示要进行运算符重载
          infixpostfix  :表示这是一个二元运算符,操作符在两个操作数中间。 
          prefix        :表示这是一个一元运算符,操作符在操作数前边。
          postfix       :表示这是一个一元运算符,操作符在操作数后边。
          associativity :结合性,包含 left(左结合)、right(右结合)和 none(自动),默认值为 none。
          precedence    :优先级,默认为 100,可省略。
      
          // 声明自定义运算符 <>
          infix operator <> {associativity none precedence 100}
      
          // 实现自定义的运算符 <>
          func <> (lhs: Int, rhs: Int) -> Int {
      
              return (lhs   rhs) * (lhs - rhs)
          }
      
          // 输出值等于 20
          let n1 = 6;   let n2 = 4;   let value = n1 <> n2;   print(value)
      
  • 3)运算符重载:让已部分运算符对自定义的类和组织进行演算只怕重新定义原来就有运算符的运算准则,这种体制被喻为运算符重载。同三个运算符在处理分化数据类型时,达成的是莫衷一是的效能。

        // 声明运算符
        infix operator >< { associativity left }
    
        // 实现运算符
        func >< (inout leftValue:String, inout rightValue:String) -> String {
    
            var tmp = leftValue
            leftValue = rightValue
            rightValue = tmp
    
            return tmp
        }
    
    • 默许的赋值符 “=” 和三目条件运算符( ? : )是不可重载的。

    • Swift语言和任何高端语言不一样,其原生的涉及运算符无法剖断自定义的类型是或不是等于,所以我们须求重载自定义的类和组织的相比较符 “==”或 “!=”。

          func == (left: CenterPointer, right: CenterPointer) -> Bool {
              return (left.x == right.x) && (left.y == right.y)
          }
      
          func != (left: CenterPointer, right: CenterPointer) -> Bool {
              return  !(left == right)
          }
      
  • 4)运算符优先级和结合性:运算符的事情未发生前级使得有个别运算符优先于任何运算符,进而使得高优先级的演算符会先被总括。结合性用于定义肖似优先级的运算符在合作时和表达式结合或提到的规规矩矩。

    • 结合性(associativity)包含 left(左结合)、right(右结合)和 none(自动),结合性的暗中认可值为 none。优先级( precedence )默感到 100。

          // 指定运算符的优先级和结合性 左结合 优先级 140
          infix operator  - {associativity left precedence 140}
      

      图片 8

3、表达式

  • 斯威夫特语言应用表明式来代表程序中的最小单位,平常三个表明式可以由数字、字符、运算符、变量、常量、函数调用等能够求得值的有意义的排列组合的组合。依据组合情势的不如,表达式可以分为宗旨表明式、多元表明式、前缀表达式、后缀表明式。

  • 1)基本表明式:

    • self 表明式:用于对这段时间项目大概项目实例自己进行援用,进而访问其内部成员。

          self.menberFunc
      
    • super 表明式:超类表明式,也能够领略为父类,用于访问当前类还是实例的父类成员要么措施。

          super.menber
      
    • 隐式成员表达式:用于在能够估量出类型的内外文中援用这一个类别的成员。

          var poNum = SomType.max
          poNum = .min
      
    • 圆括号表明式:用于私分运算符优先级和创办元组,经常由意气风发对圆括号和几何个自表达式和逗号同盟构成。

          (表达式1, lab2:表达式2, lab3:表达式3, ...)
      
    • 通配符表达式:首要运用标记 “_” 来忽视表明式中的有个别参数,那和正则表明式的通配符的概念是莫衷一是的。

          (a, _) = (1, 2)
      
  • 2)前缀表达式:

    • 函数调用表明式:平日由函数名加上参数列表组成。

          FuncName(value1, lab2:value2)
      
    • 初步化函数表明式:即有个别项目用于初步化其实例的函数表明式。

          SomeClass.init
      
    • 显式成员表达式:是显式的拜见类型、元组恐怕其余模块成员变量的风姿洒脱种方法。

          var cat:Tanimal()
          var iFoots = cat.hasfoot
      
    • 后缀 self 表达式:平时常有二种情势的后缀表明式。

      • 1、表达式.self 这种样式的表明式重临表明式的自个儿的值。
      • 2、类型实例.self 这种样式的表达式重返当前实例所属的门类,平时用于需求动态获取实例类型的光景中。
    • 动态类型表明式:特意用来动态获取项指标表达式。
      • 正式情势是:表达式.dynamicType ,在那之中表明式无法为项目名称。
      • 能够透过利用 .dynamicType 取妥贴前实例对象所属的体系,并拜见其类措施。
    • 附属脚本表明式:可以通过从属脚本表明式访谈 getter/setter 的不二秘籍,他的着力方式是:表达式1 [index 表达式2]

    • 强制取值表明式:使用 “!” 来强制获取有个别不为 nil 的可选表达式的值。

    • 可选链表明式:使用 “?” 来声称几个可选类型变量只怕目的,当对象不为 nil 时就能够访谈对象的方式照旧成员。

      • 在二个后缀表明式的子表明式中,有贰个可选表明式,那么独有最外层的表明式再次回到的才是一个可选值。

4、调节流(调整布局)

  • 一声令下的实施各样在程序布局中,大家誉为调节流。调整流,也称之为调节布局,平常蕴含:顺序布局、条件结构、循环布局、转向布局。

  • 1)条件构造(分支协会):

    • if 语句:

          if <条件表达式> {
              语句体 1
          } else {
              语句体 2
          }
      
    • switch 语句:

          switch value {
      
              case value1:
                  语句体1
              case value2:
                  语句体2
              default:
                  默认语句体
          }
      
      • 和 OC 中的 switch 语句分裂,在 switch 语言中你无需在 case 块中显式的运用 break 语句跳出 switch,当相称到的 case 块中的代码块中的代码实践达成后,程序会告大器晚成段落 switch 语句,而不会继续实行下三个 case 块。

      • 能够行使 fallthrough 在 switch 语句中使代码继续实践到下贰个case 中的代码,而不会检讨它下二个将会落入试行的 case 中的条件是不是协作,进而达到和 C 语言专门的学业中 switch 语句天性雷同的功能。

      • 在 switch 语言中每种 case 块后的相称原则可以有多个,各类匹配原则之间用逗号隔开。switch 语句不会同时宽容大些字母和小写字母。 如:case 1, 2, 3, 4, 5,

      • 在 switch 语言中每贰个 case 块都必须要带有最少一条语句。

      • 能够使用元组在同贰个 switch 语句中非常四个值,元组中的成分得以是值,也能够是约束。

      • switch 语句允许三个 case 相配同叁个值,可是如果存在多少个可非凡分支的时候,只会进行第一个被相配到的 case 块。

      • 像 if 语句同样,switch 语句也支撑值绑定,case 块允许将杰出的值绑定到一个有时的常量或变量,这几个常量或变量在该 case 块里就足以被引述了。

  • 2)循环结构:

    • for-in 循环语句:

          for 循环变量 in <范围,集合,队列...> {
      
              循环体.....
          }
      
      • 当无需选择节制内的每意气风发项的值时,能够选取下划线 “_” 变量名来忽视对值的访谈。

      • 遍历字典时,字典的每项因素会以(key, value)元组的款型再次回到。

      • 循环变量无需定义。

            for num in 0...10 {
                print(num)
            }
        
    • for 循环语句:

          for initialization; condation; increment {
      
              statements
          }
      
      • initialization:起头化表明式,condation:循环条件,increment:改换循环条件的表明式。

      • 在 斯维夫特 2.2 中 C 语言样式的 for 循环语句被撇下,C-style for statement is deprecated and will be removed in a future version of Swift。

    • while 循环语句:

          while <条件表达式> {
      
              statements
          }
      
          do {
              statements
      
          } while <条件表达式>
      
      • 在 斯维夫特 2.2 中 do-while 循环语句被撇下,使用 repeat-while 循环语句代替,'do-while' statement is not allowed; use 'repeat-while' instead。

            repeat {
                statements
        
            } while <条件表达式>
        
  • 3)控制转向语句:

    • continue :会打招呼三个循环体立时停下本次巡回,直接再次回到循环条件推断,重新开端下一次循环。

    • break :会及时暂停该循环体,然后跳转到表示循环体结束的大括号后的首先行代码,即跳出本层循环体。能够在 switch 和巡回布局中选用。

    • fallthrough :在 switch 语句中使代码继续实施到下二个 case 中的代码,而不会检查它下叁个将会落入履行的 case 中的条件是或不是相称,进而完成和 C 语言专门的学问中 switch 语句性格相似的效劳。

    • 标签语句 :Swift语言提供了更苍劲的跳出体制,你能够显式的提议供给跳出的是哪风度翩翩层循环或 switch 结构。为了促成这么些目标,大家得以应用标签来为循环体或然switch 代码打上标识,当供给选取 break 恐怕 continue 时,带上那么些标签就足以决定跳出或行车制动器踏板的是哪多个循环往复或 switch 布局。

          label loopName: for number in sArray {
      
              statements
          }
      
          // 跳出 loopName 循环
          break loopName              
      

5、函数

  • 函数是施行一定任务的代码块,各类函数都有叁个门类,能够像使用 斯威夫特语言中此外类型同样选用函数类型,将函数作为参数字传送递给别的函数,可能将函数类型当作重返类型。在 Swift 语言中平昔不主函数。在 Swift语言中等高校函授数分为两类,风华正茂种是库和框架中的函数,风华正茂种是自定义的函数。

  • 函数定义须求注重字 func,其貌似格式为:

        // 使用时第一个参数名(参数名1)会被省略
        func 函数名 (参数名1:参数类型, 参数名2:参数类型 ...) -> 函数返回类型 {
    
            函数体 .....
    
            return 返回值
        }
    
  • 在 斯威夫特语言中,函数的形参和再次回到值是极其具备灵活性的,在急需的时候,能够定义八个要么八个以致采取性的简便。实际上,在概念的时候不经意再次回到值等于隐式表明了函数的回来值类型为 void,而实际函数依旧回到了三个空的元组作为重返值。

  • 1)外界形参:

    • Swift 语言也能扶植 OC 的函数参数标签情势,这种方式被喻为外界形参。然则假使您为参数拟订了表面形参名,那么在调用的时候就非得显式的接纳。

      • 定义格式:

            // 使用时本地形参名(本地形参名1、本地形参名2 ...)会被省略
            func 函数名 (外部形参名1 本地形参名1:参数类型, 外部形参名2 本地形参名2:参数类型 ...) -> 函数返回类型 {
        
                函数体 .....
        
                return 返回值
            }
        
    • 若果人家首先次阅读你的代码,使用外界形参名称能够使您要发挥的意趣尤其爱憎分明,上下文越发清清晰。在写外界形参名时,完全能够只写一回名字,只须求用一个hash 符号“#” 作为参数名称的前缀,进而告诉 斯维夫特,大家运用了名称风姿洒脱致的地头形参名称和外界形参名称。

      • 定义格式:

            // Xcode 7.3.1  Swift 2.2 中不支持该种定义方式
            func 函数名 (#参数名1:参数类型, #参数名2:参数类型 ...) -> 函数返回类型 {
        
                函数体 .....
        
                return 返回值
            }
        
  • 2)私下认可值形参:

    • 在 斯威夫特语言中可认为任何形参定义暗许值以作为函数定义的大器晚成局部,尽管已经定义了默许值,那么调用函数时就可以简轻便单该形参。为了防止疏漏参数或然参数字传送递的二义性,需在函数形参列表的末尾放置带暗中认可值的形参,不要在非暗许值的形参前放置。

      • 定义格式:

            func 函数名 (参数名1:参数类型, 参数名2:参数类型, sAge:String = "20") -> 函数返回类型 {
        
                函数体 .....
        
                return 返回值
            }
        
    • 在有定义暗中同意值的景况下,当未有一点名外界形参名称时,斯威夫特语言将为你定义的其它默许值形参提供一个自行外界形参名,这么些活动外界形参名和地方形参名相通。

  • 3)可变多少形参:

    • 可变多少形参是指可接收零个或八个钦命类型值的形参,能够用它来传递放肆数量的输入参数。评释可变形参须求用到“...”,当参数传递进函数体后,参数在函数体内能够通过集结的样式拜谒。三个函数最多能够有五个可变参数,并且它必需出现在参数列表的尾声。

      • 定义格式:

            func 函数名 (参数名1:参数类型, 参数名2:参数类型, numbers:Double...) -> 函数返回类型 {
        
                函数体 .....
        
                return 返回值
            }
        
  • 4)可变值形参:

    • 斯维夫特语言函数的形参暗许是常量,我们无法直接在函数体内部改动形参的值,也正是说函数的形参私下认可是值类型的。可是借使须求在函数体内部改过函数参数值,能够应用可变形参,要定义可变形参能够在参数名前使用 var 关键字。可变形参可以让您可见改善形参的值,它能够给函数体三个可改善的形参值别本,但那并不表示可变形参就是引用类型的。

      • 定义格式:

            func 函数名 (var 参数名1:参数类型, var 参数名2:参数类型, ...) -> 函数返回类型 {
        
                函数体 .....
        
                return 返回值
            }
        
  • 5)援用类型形参:

    • 在实际上的编码中,大家一再供给在函数体内部修正形参值,并同期作用到实参本人,进而节省扩大重临值数量的手续。那时能够把形参定义为 in-out 类型,要定义 in-out 类型的参数,必要在参数名前应用 inout 关键字。当把变量传递给 in-out 形参时,必得在变量前加多 “&” 符号,以注明他被函数内部改正的是它自己的引用。

      • 定义格式:

            func 函数名 (inout 参数名1:参数类型, var 参数名2:参数类型, ...) {
        
                函数体 .....
            }
        
            func *= (inout lhs: UInt, rhs: UInt)
        
    • 行使 in-out 参数的还要有几条准则须要当心:

      • 1、被标识为 inout 后不能够将常量和字面量传递进函数。
      • 2、不可能何况将参数标志为 var、let、inout。
      • 3、可变多少参数的参数不能够标志为 inout。
      • 4、函数不可能有私下认可值。
  • 6)函数类型:

    • 各样函数都有特定的函数类型,函数类型平时由函数的形参类型和重返值类型组成。假诺多少个函数未有形参或重临值,那么这几个函数的门类是 (卡塔尔 -> (卡塔尔(قطر‎ 。比如函数

          func addString(s1:string, s2:string, s2:string) -> String { } 的类型就是 (String, String, String) -> String 。
      
    • 能够在 Swift语言中像使用别的任何项目同样的采取函数类型。举例能够定义一个函数常量或函数变量,并像相通数据类型钦定早先值相像为他内定一个对应的函数。与其余类型同样,当您给函数赋一个变量或然常量时,你能够让 斯威夫特 语言去猜度函数的体系。

          // 指定函数类型
          var addSome:(String, String, String) -> String = addString
      
          // 推断函数类型
          let anotherAddSome = addString
      
    • 您也得以行使贰个函数类型作为另三个函数的形参类型和重临值类型,使用方法和日常的数据类型相符。

  • 7)嵌套函数:

    • 在叁个函数体中定义其余二个函数体就称为嵌套函数。嵌套的函数暗中认可对外是隐形的,但还是能够由此包装他们的函数调用和使用它们。

      • 定义格式:

            func 函数名1 (参数名1:参数类型, 参数名2:参数类型 ...) -> 函数返回类型1 {
        
                func 函数名2 (参数名3:参数类型, 参数名4:参数类型 ...) -> 函数返回类型2 {
        
                函数体2 .....
        
                return 返回值2
                }
        
                函数体1 .....
        
                return 返回值1
            }
        

6、断言

  • 对每回运转都会现出的不当经常不会过分抑郁,能够应用断点调节和测验可能“try-catch”之类的方法推断并修复它。不过一些不时候(以致是许数次运营才汇合世三回)的大错特错单靠断点之类的点子是很难破除掉的,为此,引进三个不是很常用的调弄整理工具函数:assert(condition: Bool, message: String卡塔尔(英语:State of Qatar),assert 是仅仅地触发断言即甘休程序,不会让您有机遇将也许出错的设计走过它那一关。

  • 在其实编码中,为了保障程序不荒谬运营,独有在一些供给条件被满足的景色下才实行一定代码段,这种编制程序观念叫做防错性编制程序。

  • 在 斯维夫特 语言中能够调用全局的 assert 函数来扩大叁个预感,这里的大局意思是您可以将断言放在你程序的别的三个地点。程序在施行到 assert 时会剖断个中的逻辑条件表明式参数是或不是为 true。若是基准判别为 true,代码运维会继续拓宽。若是条件判定为 false,程序将截止。平常,在为顺序参与并触发断言后,Xcode 会准明确位到不行代码段,并报告极度音讯等改良 bug 必须的调节和测量试验音信。

  • 职业的断言格式:

        assert(condition: Bool, message: String) 
    
    • condition 剖断标准,message 自定义调节和测验新闻,断言中的调节和测量试验消息参数是可选的。
  • 定义:

        func assert(condition: @autoclosure () -> Bool, 
                    _ message: @autoclosure () -> String = default, 
                         file: StaticString = default, 
                         line: UWord = default)
    
        @inline(__always) func assertionFailure(_ message: @autoclosure () -> String = default, 
                                                     file: StaticString = default, 
                                                     line: UWord = default)
    
  • 使用:

        var usedate = -1
        usedate = 2
    
        // 当 usedate 大于 0 时,程序中断,进入断言函数打印调试信息
        assert(usedate <= 0, "超出试用期,不能启动程序!")
    
  • 系统在断言的源代码中步向了相似 “#if NDEBUG”那样的编写翻译字,使其只好用来 debug 期,当您在发布 release 版本可能更新版的时候,编写翻译器会利用一个编写翻译字段将断言无效化,所以当您的出品在付出给客商之后还亟需持续收罗错误消息时,需选取任何形式。

  • 断言函数中用到的“@autoclosure”属性,使用这种性质的参数意味着大家得以在此个参数的岗位传入叁个表达式,那几个表明式会被活动封包成贰个闭包,那也正是其字面包车型客车意味:“自动闭包”。在 assert 函数中它起到的意义也是分外精通的,假诺在这里间大家使用的是惯常的布尔型参数,那么在推行到 assert 函数时,就会先运算条件表明式的值,而使用“@autoclosure”属性后,程序会先在 assert 函数内剖断 debug 期的编写翻译字是还是不是留存,假使存在才会运算条件表明式的值,当然,这时候条件表明式已经被活动封装成了三个闭包。

  • 预知使用的二种境况:

    • 评释参数的合法性。
    • 快要采取一个目的,可是不明确其是不是业已不错创建。
    • 数组或许别的集合类、字典等复杂数据类型下标未有处于安全限定引致或许会越界。
    • assert 函数的基准表明式参数最棒三遍只决断二个标准化,因为假诺决断八个规范,当断言被触发时,往往会不或许直观的判别终归是哪二个尺度不被满意。

7、闭包

  • 闭包 在 Swift中充裕实用。通俗的讲授便是三个 Int 类型里积攒着贰个卡尺头,一个 String 类型包涵着意气风发串字符,相通,闭包是三个包涵着函数的体系。有了闭包,你就足以处理非常多在某些古老的语言中无法管理的事情。这是因为闭包使用的多种性,举例你能够将闭包赋值给一个变量,你也足以将闭包作为三个函数的参数,你居然能够将闭包作为三个函数的重返值。它的兵不血刃之处可以看到意气风发斑。在 斯威夫特的成百上千文书档案教材中都说函数是“一等公民”,初始小编还不是很通晓“一等平民”是怎么意思,但当自个儿驾驭了闭包以致它的刚劲效能后,小编醒来、一语中的、一语中的。原来闭包的那一个特征正是“一等国民”的特征啊!

  • 闭包是效率性自饱含模块,能够在代码中被传送和应用。黄金年代段程序代码平常由常量、变量和表明式组成,然后采纳少年老成对花括号“{}” 来代表闭合并包裹着这几个代码,由这对花括号包裹着的代码块正是三个闭包。Swift中的闭包与 C 和 Objective-C 中的 Block 以至别的一些编程语言中的 lambdas 相比相通。Block 和闭包的界别只是语法的不如而已,何况闭包的可读性相比较强。

  • 闭包是引用类型,无论你将函数/闭包赋值给一个常量依然变量,实际上都以在将常量/变量设置为对应函数/闭包的引用,那也代表如若你将闭包赋值给了七个不等的常量/变量,三个值都会针对同叁个闭包。

  • 在 Swift 语言中有两种闭包方式:

    • 全局函数:是三个有名字但不会捕获任何值的闭包。
    • 嵌套函数:是三个盛名字并得以捕获到其密闭函数域内的值的闭包。
    • 佚名闭包:闭包表达式是贰个运用轻量级语法所写的,能够捕获其左右文中变量或常量值。
  • 1)函数形式:

        func myConpare(s1:String, s2:String) -> Bool {
    
            return s1 > s2
        }
    
        let namesArray:Array = ["Jill", "Tim", "Chris"]
    
        let names = namesArray.sort(myConpare)
    
  • 2)日常情势:

        { (parameters参数) -> returnType返回类型 in
    
            statements
        }
    
    • 可以采取常量、变量、inout、可变参数、元组类型作为闭包的参数,但不可能在闭包参数中安装暗中认可值,定义再次来到值和函数再次回到值的花色相通。

    • 闭包表明式中的 in 关键字表示闭包的参数和再次回到值类型定义已经到位,这么些参数和再次来到值都就要下边的闭包函数体中获得管理。

          let namesArray:Array = ["Jill", "Tim", "Chris"]
      
          let names = namesArray.sort { (s1:String, s2:String) -> Bool in
      
              return s1 > s2
          }
      
  • 3)参数类型隐蔽方式:

    • 斯威夫特 中有品种忖度的性状,所以我们得以去掉参数类型。

          let namesArray:Array = ["Jill", "Tim", "Chris"]
      
          let names = namesArray.sort { (s1, s2) -> Bool in
      
              return s1 > s2
          }
      
  • 4)再次回到值类型掩盖情势:

    • Swift 中有品种预计的表征,所以我们得以去掉重临值类型。

          let namesArray:Array = ["Jill", "Tim", "Chris"]
      
          let names = namesArray.sort { (s1, s2) in
      
              return s1 > s2
          }
      
  • 5)return 掩盖方式:

    • 单行表明式的闭包能够透过遮盖关键字 return 来隐式地将单行表达式的结果作为重返值。

          let namesArray:Array = ["Jill", "Tim", "Chris"]
      
          let names = namesArray.sort { (s1, s2) in
      
              s1 > s2
          }
      
  • 6)参数名省略形式:

    • 闭包的行使极其的灵敏,大家得以简轻巧单闭包参数列表中的参数的参数类型定义,被略去的参数类型会通过闭包函数的项目实行估量。同临时候,大家也能够在闭包函数体中通过利用闭包的参数名简写功效,直接动用 $0、$1、$2 等名字就足以引用的闭包参数值。若是同偶然间省略了参数名和参数类型,那么 in 关键字也亟须被略去,那时候闭包表明式完全由闭包函数体构成。

          let namesArray:Array = ["Jill", "Tim", "Chris"]
      
          let names = namesArray.sort {
      
              $0 > $1
          }
      
  • 7)trailing 闭包格局:

    • 闭包能够做任何函数的参数,况兼平常都以函数的尾声三个参数。可是若是作为参数的那么些闭包表明式相当长,那么很有希望会潜移暗化函数调用表明式的可读性,这时大家就相应运用 trailing 闭包。trailing 闭包和不足为奇闭包的不一样之处在于它是三个挥毫在函数参数括号之外(之后)的闭包表明式,函数会自动将其充当最后贰个参数调用。

    • 当函数有且唯有贰个参数,并该参数是闭包时,不但能够将闭包写在 ()外,还足以省略 (卡塔尔(قطر‎。Swift 2.2 中可以不管参数的个数完整个省略 (卡塔尔。

          let namesArray:Array = ["Jill", "Tim", "Chris"]
      
          let names = namesArray.sort() {
      
              $0 > $1
          }
      
  • 8)闭包捕获:

    • 闭包能够在其定义的上下文中抓获常量或变量,尽管定义那么些常量或变量的原文用域已经一纸空文,依然能够在闭包函数体内引用和改动这一个常量或变量,这种体制被称之为闭包捕获。比如:嵌套函数就足以捕获其父函数的参数以致定义的常量和变量,全局函数能够捕获其前后文中的常量或变量。

          func increment(amount: Int) -> (() -> Int) {
      
              var total = 0
      
              func incrementAmount() -> Int {
      
              // total 是外部函数体内的变量,这里是可以捕获到的
                  total  = amount
      
                  return total
              }
      
              // 返回的是一个嵌套函数(闭包)
              return incrementAmount
          }
      
          // 闭包是引用类型,所以 incrementByTen 声明为常量也可以修改 total
          let incrementByTen = increment(10)
          incrementByTen()    // return 10,incrementByTen 是一个闭包
      
          // 这里是没有改变对 increment 的引用,所以会保存之前的值
          incrementByTen()    // return 20
          incrementByTen()    // return 30
      
          let incrementByOne = increment(1)
          incrementByOne()    // return 1,incrementByOne 是一个闭包
          incrementByOne()    // return 2
          incrementByTen()    // return 40
          incrementByOne()    // return 3
      

8、下标脚本

  • 下标脚本 允许你通过在实例前面包车型大巴方括号中传来叁个要么多少个的索引值来对实例举办拜候和赋值。语法肖似于实例方法和总结型属性的搅拌。与概念实例方法相通,定义下标脚本使用 subscript 关键字,显式证明入参(五个或七个卡塔尔(قطر‎和重回类型,每种输入参数的连串也尚Infiniti定,重回值能够是此外项目,并无界定。输入参数也足以行使可变参数,但选取输入/输出(in-out)参数或和给参数设置默许值都以不容许的。与实例方法差别的是下标脚本能够设定为读写或只读。这种艺术又有一点像计算型属性的 getter 和 setter 方法。

  • 下标脚本正是对一个东西通过索引,飞快取值的豆蔻梢头种语法,举个例子数组的 a[0]。那便是叁个下标脚本。通过索引 0 来快捷取值。在 Swift中,大家能够对类(Class)、结构体(structure)和枚举(enumeration)中温馨定义下标脚本的语法。

  • 重点:

    • 下标脚本使用 subscript 关键字来定义。
    • 下标脚本使用 get、set 来定义读、写属性,并无需 2 个属性都有,能够只读,何况读必需有。
    • 概念 set 属性时,传入的参数默许名叫 newValue。况兼 newValue 的品种和 subscript 函数重临值相通。
  • 1卡塔尔(قطر‎ 下标脚本的选择 1

    • 下标脚本的概念

          struct myString {
      
              var str:String = ""
      
              subscript(start:Int, length:Int) -> String {
      
                  get {
                      return (str as NSString).substringWithRange(NSRange(location: start, length: length))
                  }
      
                  set {
      
                      str = newValue
                  }
              }
          }
      
    • 下标脚本的选用

          let str1 = myString(str: "hello world")
      
          let str2 = str1[2, 5]
      
          // 输出 hello world
          print(str1[0, 11])
      
          // 输出 llo w
          print(str2)
      
          var str3 = myString()
      
          // [0, 0] 参数无意义
          str3[0, 0] = "world"
      
          // 输出 world
          print(str3[0, 5])
      
  • 2卡塔尔国 下标脚本的运用 2

    • 下标脚本的概念

          class Student1 {
      
              var scores:[Int] = Array(count:5, repeatedValue:0)
      
              subscript(index:Int) -> Int {
      
                  get {
      
                      return scores[index];
                  }
      
                  set {
      
                      scores[index] = newValue
                  }
              }
      
              subscript(indexs:Int...) -> [Int] {
      
                  get {
                      var values:[Int] = Array()
      
                      for index in indexs {
                          values.append(scores[index])
                      }
                      return values
                  }
      
                  set {
                      var i = 0
      
                      for index in indexs {
      
                          scores[index] = newValue[i]
      
                          i  = 1
                      }
                  }
              }
          }
      
    • 下标脚本的应用

          let stu1 = Student1()
      
          stu1[0] = 1
          stu1[1] = 2
      
          // 输出 a[0]:1, a[1]:2
          print("a[0]:(stu1[0]), a[1]:(stu1[1])")
      
          let stu2 = Student1()
      
          stu2[1, 2, 3] = [5, 6, 7]
      
          // 输出 [0, 5, 6, 7, 0]
          print(stu2[0, 1, 2, 3, 4])
      

本文由星彩网app下载发布于计算机编程,转载请注明出处:语言新特性,基本语法

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。