swift语言学习教程 苹果swift编程语言基础教程
- 绿茶文章中心
&&&&&&&&&swift语言学习教程 苹果swift编程语言基础教程
swift语言学习教程 苹果swift编程语言基础教程
作者：佚名
来源：绿茶软件园
　　swift语言学习教程，绿茶小编胖胖带来了苹果swift编程语言基础教程，对于苹果发布的这款编程语言很多朋友可能不是很了解，没关系，下文将会详细介绍这款语言的基础代码，一起来了解吧~
　　--基本概念
　　注：这一节的代码源自The Swift Programming Language中的A Swift Tour。
　　--Hello, world
　　类似于脚本语言，下面的代码即是一个完整的Swift程序。
　　◾println(&Hello, world&) 变量与常量
　　Swift使用var声明变量，let声明常量。
　　◾var myVariable = 42
　　◾myVariable = 50
　　◾let myConstant = 42
　　--类型推导
　　Swift支持类型推导(Type Inference)，所以上面的代码不需指定类型，如果需要指定类型：
　　◾let explicitDouble : Double = 70
　　Swift不支持隐式类型转换(Implicitly casting)，所以下面的代码需要显式类型转换(Explicitly casting)：
　　◾let label = &The width is &
　　◾let width = 94
　　◾let width = label + String(width)
　　--字符串格式化
　　Swift使用\(item)的形式进行字符串格式化：
　　◾let apples = 3
　　◾let oranges = 5
　　◾let appleSummary = &I have \(apples) apples.&
　　◾let appleSummary = &I have \(apples + oranges) pieces of fruit.&
　　--数组和字典
　　Swift使用[]操作符声明数组(array)和字典(dictionary)：
　　◾var shoppingList = [&catfish&, &water&, &tulips&, &blue paint&]
　　◾shoppingList[1] = &bottle of water&
　　◾var occupations = [
　　◾ &Malcolm&: &Captain&,
　　◾ &Kaylee&: &Mechanic&,
　　◾]
　　◾occupations[&Jayne&] = &Public Relations&
　　一般使用初始化器(initializer)语法创建空数组和空字典：
　　◾ let emptyArray = String[]()
　　◾ let emptyDictionary = Dictionary()
　　如果类型信息已知，则可以使用[]声明空数组，使用[:]声明空字典。
　　--控制流
　　Swift的条件语句包含if和switch，循环语句包含for-in、for、while和do-while，循环/判断条件不需要括号，但循环/判断体(body)必需括号：
　　◾let individualScores = [75, 43, 103, 87, 12]
　　var teamScore = 0
　　for score in individualScores {
　　if score & 50 {
　　teamScore += 3
　　} else {
　　teamScore += 1
　　可空类型
　　结合if和let，可以方便的处理可空变量(nullable variable)。对于空值，需要在类型声明后添加?显式标明该类型可空。
　　◾var optionalString: String? = &Hello&
　　optionalString == nil
　　var optionalName: String? = &John Appleseed&
　　var gretting = &Hello!&
　　if let name = optionalName {
　　gretting = &Hello, \(name)&
　　灵活的switch
　　Swift中的switch支持各种各样的比较操作：
　　◾let vegetable = &red pepper&
　　◾switch vegetable {
　　◾case &celery&:
　　◾ let vegetableComment = &Add some raisins and make ants on a log.&
　　◾case &cucumber&, &watercress&:
　　◾ let vegetableComment = &That would make a good tea sandwich.&
　　◾case let x where x.hasSuffix(&pepper&):
　　◾ let vegetableComment = &Is it a spicy \(x)?&
　　◾default:
　　◾ let vegetableComment = &Everything tastes good in soup.&
　　◾}
　　其它循环
　　for-in除了遍历数组也可以用来遍历字典：
　　◾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
　　◾ }
　　◾ }
　　◾}
　　◾largest
　　while循环和do-while循环：
　　◾var n = 2
　　◾while n & 100 {
　　◾ n = n * 2
　　◾}
　　◾n
　　◾var m = 2
　　◾do {
　　◾ m = m * 2
　　◾} while m & 100
　　◾m
　　Swift支持传统的for循环，此外也可以通过结合..(生成一个区间)和for-in实现同样的逻辑。
　　◾var firstForLoop = 0
　　◾for i in 0..3 {
　　◾ firstForLoop += i
　　◾}
　　◾firstForLoop
　　◾var secondForLoop = 0
　　◾for var i = 0; i & 3; ++i {
　　◾ secondForLoop += 1
　　◾}
　　注意：Swift除了..还有...：..生成前闭后开的区间，而...生成前闭后闭的区间。
　　--函数和闭包
　　Swift使用func关键字声明函数：
　　◾func greet(name: String, day: String) -& String {
　　◾ return &Hello \(name), today is \(day).&
　　◾}
　　◾greet(&Bob&, &Tuesday&)
　　通过元组(Tuple)返回多个值：
　　◾func getGasPrices() -& (Double, Double, Double) {
　　◾ return (3.59, 3.69, 3.79)
　　◾}
　　◾getGasPrices()
　　支持带有变长参数的函数：
　　◾func sumOf(numbers: Int...) -& Int {
　　◾ var sum = 0
　　◾ for number in numbers {
　　◾ sum += number
　　◾ }
　　◾ return sum
　　◾}
　　◾sumOf()
　　◾sumOf(42, 597, 12)
　　函数也可以嵌套函数：
　　◾func returnFifteen() -& Int {
　　◾ var y = 10
　　◾ func add() {
　　◾ y += 5
　　◾ }
　　◾ add()
　　◾ return y
　　◾}
　　◾returnFifteen()
　　作为头等对象，函数既可以作为返回值，也可以作为参数传递：
　　◾func makeIncrementer() -& (Int -& Int) {
　　◾ func addOne(number: Int) -& Int {
　　◾ return 1 + number
　　◾ }
　　◾ return addOne
　　◾}
　　◾var increment = makeIncrementer()
　　◾increment(7)
　　◾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(numbers, lessThanTen)
　　本质来说，函数是特殊的闭包，Swift中可以利用{}声明匿名闭包：
　　◾numbers.map({
　　◾ (number: Int) -& Int in
　　◾ let result = 3 * number
　　◾ return result
　　◾ })
　　当闭包的类型已知时，可以使用下面的简化写法：
　　◾numbers.map({ number in 3 * number })
　　此外还可以通过参数的位置来使用参数，当函数最后一个参数是闭包时，可以使用下面的语法：
　　◾sort([1, 5, 3, 12, 2]) { $0 & $1 } 类和对象 创建和使用类
　　Swift使用class创建一个类，类可以包含字段和方法：
　　◾class Shape {
　　◾var numberOfSides = 0
　　◾func simpleDescription() -& String {
　　◾return &A shape with \(numberOfSides) sides.&
　　◾}
　　◾}
　　创建Shape类的实例，并调用其字段和方法。
　　◾var shape = Shape()
　　◾shape.numberOfSides = 7
　　◾varshapeDescription = shape.simpleDescription()
　　通过init构建对象，既可以使用self显式引用成员字段(name)，也可以隐式引用(numberOfSides)。
　　◾class NamedShape {
　　◾ var numberOfSides: Int = 0
　　◾ var name: String
　　◾ init(name: String) {
　　◾ self.name = name
　　◾ }
　　◾ func simpleDescription() -& String {
　　◾ return &A shape with \(numberOfSides) sides.&
　　◾ }
　　◾}
　　使用deinit进行清理工作。
　　--继承和多态
　　Swift支持继承和多态(override父类方法)：
　　◾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()
　　注意：如果这里的simpleDescription方法没有被标识为override，则会引发编译错误。
本类推荐本类排行
热门软件热门标签苹果要用Swift语言颠覆传统编程
[摘要]Swift可以在不牺牲程序运行速度的前提下使开发者更为高效的编写代码。
腾讯科技讯 美国知名科技媒体《连线》日前对从市场前景、核心优势和竞争对手等方面对最新推出的Swift编程语言进行了一番全面剖析。文章认为，虽然Swift作为后来者面临着诸如Objective-C、C++这类语言以及()、这些企业的前后夹击，但Swift自身的巨大优势以及苹果设备在开发者心目中的巨大影响力，还是为其赋予了能够颠覆传统编程模式的巨大潜力。以下是文章主要内容：知名开发人克里斯-莱特纳(Chris Lattner)此前花费了一年半的时间在一款全新编程语言的开发工作上。在这段时间内，他没有将自己的工作内容向任何一个人透露过。这个项目是在2010年的夏天正式展开的，当时的莱特纳几乎每个周末和晚上都扑在这个项目中，到2011年底这个全新编程语言的基本架构终于成形。也就是在那个时候，莱特纳决定把这个秘密项目告诉公司高管。在深入了解了这一项目后，这些高管认为该项目非常有潜力，并特地为其指定了数名有经验的工程师协助开发。在18个月后，该项目已经成为了该公司最重要的项目之一，大量工程师都参与到了这一项目中，且公司认为这是一个有可能彻底颠覆传统电脑编程流程的全新语言。众所周知，这个项目就是Swift编程语言，而莱特纳则是目前苹果开发者工具部门总监。今年6月2日，苹果首次针对广大开发者放出了Swift编程语言的测试版本，并对外宣称这是一个能让开发者更快、更轻松为iOS设备编写软件的工具。莱特纳就读伊利诺伊大学厄巴纳-香槟分校时的研究生导师维克拉姆-艾夫(Vikram Adve)曾经同莱特纳一起开发了Swift语言的最基层软件平台，但就连他都不知道莱特纳竟然独自一人在这个编程项目上花费了如此巨大的心血。“苹果实在太保密了，莱特纳也深受真传。我当时只知道他正在负责一个项目，但我并不知道这个项目的具体内容。”艾夫笑着说道。通常来说，如果一款编程语言被刚刚编写完成后，它通常需要多年的时间才能拥有足够多的开发者用户，即便该语言拥有像苹果这样巨型企业的支持也不例外。举例来说，谷歌曾在2009年推出了一个名为“Go”的全新编程语言，虽然这一语言的开发者包括了诸如Unix操作系统联合开发者、同时也是C语言之父肯-汤普逊(Ken Thompson)以及前贝尔实验室研究员卢勃-帕克(Rob Pike)这些业内泰斗，但该语言直到目前还没有得到全球大多数程序员的认可。但我们认为，Swift的命运将同Go截然不同，该语言甚至有可能在今秋正式发布后迅速得到业内的认可，并超过当年Java和C#语言的发展速度。这主要是因为该语言是一款面向普通开发者的编程语言，它拥有着无与伦比的易用性，即便是最初级的编程员都能够很快掌握该语言。同时，目前有许多的程序员都专注于为iOS平台编写应用，此前他们所使用的主要语言是Objective-C，但全新Swift显然比前者拥有更多优势，而这也就在一定程度上确保了该语言的使用基数。“谷歌Go没有给予开发者足够的理由去采用这一语言，而Swift却并非如此。人们会争先恐后的拥抱这一全新语言，因为它的编程流程相比Objective-C更为简单。”专注于全球编程语言动态的Tiobe公司总经理保罗-詹森（Paul Jansen）说道。目前，尽管Swift还处于自己的测试阶段，但代码托管网站GitHub上已经有超过2400个项目基于Swift代码开发。本月，Swift还登上了Tiobe发布的全球讨论率最高编程语言第16名的位置。需要指出的是，当谷歌在2009年推出Go语言的时候也曾取得过类似的成绩，但该语言随后在Tiobe上的排名便一落千丈。然而，詹森认为这样的情况恐怕不会在Swift身上重演。“因为Swift处于苹果生态系统的最核心地位，而他们只要不将其搞砸就可以了。”C++语言领域的泰斗级人物安德烈-亚历克斯德苏（Andrei Alexandrescu）说道。未来前景目前，莱特纳是苹果开发者工具部门总监，他的主要工作是负责管理所有可以让苹果工程师和开发者为公司设备编写程序的工具。在此之前，莱特纳曾主持开展了构架编译器框架系统LLVM的开发工作，而LLVM也恰恰是目前苹果开发工具Xcode的基础架构平台。2005年，莱特纳加盟苹果，并开始致力于LLVM在苹果开发体系中的应用。同时，苹果也一直是LLVM计划的主要资助方之一。我们曾在撰写这篇文章时向莱特纳提出了采访邀请，但后者表示只有得到苹果公关部门的批准才能接受采访。不过，莱特纳还是在自己的博客中简单谈到了这个项目的开展初衷，那就是他希望Swift能够同苹果现有开发工具兼容，甚至可以让开发者在使用Objective-C的同时使用Swift。平息而论，苹果仍然需要提供更加充足的理由来鼓励开发者从Objective-C转投Swift平台。毕竟，现有开发者大都从未接触过Swift。“我是第一个、也是目前唯一一个拥有四年Swift使用经验的开发者。”莱特纳在Twitter上这样说道。对此，已经为苹果各类硬件产品编写了15年程序的资深开发人员麦克-阿什（Mike Ash）也承认：“大多数全新编程语言都会止步不前，少数获得开发者青睐的语言通常也需要经历许多年的过渡时期。”但话虽如此，阿什目前已经开始利用这一全新语言编写应用了。因为虽然Swift并见得比诸如C#、Ruby、Python优秀多少，但它还是相较于上世纪80年代问世的Objective-C有着太多的优势。当下，许多程序员都认为Objective-C句法规则太过怪异，而Swift的设计则更加贴心，并内置了许多可以帮助开发人员的实用纠错工具。核心优势在Swift语言中，最为出彩的功能或许就Playgrounds了。该功能提供了不可思议的互动效果，能让Swift代码在编写过程中实时进行编译和效果显示。最为重要的是，这一服务能够使开发者的编程变得更具效率，同时帮助Swift和其他编程语言展开差异化竞争。目前，诸如Objective-C、C++这类语言通常要求开发者首先编写好代码，等待编撰器将代码转换为可执行的软件程序，然后开发者才能够操作这一可执行软件。而诸如Python、Ruby和PHP这些语言则允许开发者在编写代码的同时测试自己的软件，但该软件的实际运行速度却会大打折扣。然而，Swift的出现就彻底解决了上述两者的不足，该语言可以在不牺牲程序运行速度的前提下使开发者更为高效的编写代码。“Swift是一个对开发者和设备都非常友好的语言，虽然这一语言的实际表现还有待测试，但苹果到目前为止的工作成果看起来相当了不起。”麦克-阿什这样说道。市场竞争需要指出的是，苹果并非是唯一一家试图在编程领域掀起波澜的企业，包括谷歌、Facebook、Mozilla这些公司也都在研发自己的编程语言平台，且其中部分语言甚至已经比Swift取得了更大的成就。比如，谷歌已经利用Go语言重新定义了自己的内部工作流程，而Facebook则利用旗下开源编程语言“Hack”重新打造了自己的大量在线服务。更为重要的是，以上这些企业所推出的编程语言大多是开源的，这就意味着它们或将可以更容易面向全球开发者进行推广。然而，Swift并不是一个开源编程语言（至少目前还不是）。同时，考虑到苹果一贯的软硬件高度控制的做法，外界对于该公司政策是否会对Swift的未来推广构成负面影响也持有保留意见。“目前业内对于苹果是否会限制该语言的前进方向存在着一定的担忧，就比如该公司是否会允许开发者利用其编写跨平台代码等。”阿什解释道。不过，阿什相信Swift的开源化将只是时间问题而已，因为克里斯-莱特纳从来都是编程开源理念的支持者，他此前所开发的轻量级编译器Clang就是一个最好的例子。当然，即便Swift始终处于苹果的严格管控之下，我们也认为该语言的开发者采用率也将超越近年来所推出的任何一个编程语言，因为这就是诸如iPhone、iPad和Mac这些设备施加在开发者身上的魔力所在。（汤姆）
[责任编辑：jimmonzang]
您认为这篇文章与"新一网（08008.HK）"相关度高吗？
Copyright & 1998 - 2017 Tencent. All Rights Reserved
还能输入140字1042人阅读
mac ios iphone ipad（12）
目前随着公司开发模式的变更,swift也显得越发重要,相对来说,swift语言更加简洁,严谨.但对于我来说,感觉swift细节的处理很繁琐,可能是还没适应的缘故吧.基本每写一句代码,都要对变量的数据类型进行判断,还要进行强转等等.
好了,废话不多说了,直接把我对swift的语法的一些理解奉献给大家,希望能对学习swift语法的朋友有所帮助,如有不足之处,还请多多包涵,如果有错误之处,欢迎指正
Swift 介绍
Swift 语言由苹果公司在 2014 年推出，用来撰写 OS X 和 iOS 应用程序
2014 年，在 Apple WWDC 发布
2010 年 7 月，苹果开发者工具部门总监&Chris Lattner&开始着手 Swift 编程语言的设计工作
用一年时间，完成基本架构
Swift 大约历经 4 年的开发期，2014 年 6 月发表
克里斯·拉特纳何许人?
& && &&&&&LLVM 项目的主要发起人与作者之一
& && &&&&&Clang 编译器的作者
& && &&&&&苹果公司『开发者工具』部门的主管
& && &&&&&领导Xcode、Instruments等编译器团队
& && &&&&&Swift的大部分基础架构均由他1人完成
&&&&&从它的语法中能看到`Objective-C、JavaScript、C#、Python`等语言的影子
&&&&&语法简单、代码简洁、使用方便
&&&&&可与Objective-C混合使用（相互调用）
&&&&&提供了类似 Java 的名字空间(namespace)、泛型(generic)、运算对象重载（operator overloading）
为什么设计Swift语言
&&&&&让应用开发更简单、更快、更稳定
&&&&&确保最终应用有着更好的质量
Swift初体验
Playground是什么?
从Xcode6开始出现(Swift开始出现)
翻译为:操场/游乐场
对于学习Swift基本语法非常方便
&&&&&所见即所得(快速查看结果)
&&&&&语法特性发生改变时,可以快速查看.
一.Swift最基本的语法变化
1.导入框架&&
1 OC: #import &UIKit/UIKit.h&
2 Swift: import UIKit&
2.定义标识符
&&&&&OC: int a = 20;
&&&&&Swift: let a : Int = 20 & == &let a = 20 & &&
& & &定义标识符格式: let / var 标识符 : 数据类型 = 赋值 & &
&&&&&注意:let声明的是常量,不可以对常量重新赋值
&&&&&Swift中定义标识符,必须声明该标识符是变量(var)还是常量(let)
&&&&&注意:在swift中如果一行代码中只有一条语句,那么语句后面的 ;(分号) 可以省略
& & & & & & &一行内有多条语句 ; 不可以省略, & 不建议一行写多条语句
3.Swift中的打印& &&
1 OC: NSLog(@&Hello world”);
NSLog(@&%d&, a);
2 //Swift中字符串不需要@
3 print(a)
print(&hello world&)
二.常量&变量
1.什么是常量和变量?
& & &在Swift中规定:在定义一个标识符时,必须明确说明该标识符是常量还是变量
& & &使用let来定义常量,定义之后,不能进行修改
& & &使用var来定义变量,定义之后,可以进行修改
2.常量个变量的使用注意
& & &在使用中,建议先使用常量,这样更安全,防止不小心修改之前的值
& & &如果需要修改时,再把常量修改为变量
& & &注意:常量的本质是,指向的内存地址不能修改,但可以找到内存地址对应的对象,修改对象内部的属性
1 let view : UIView = UIView()
2 view.alpha = 0.5
3 view.backgroundColor = UIColor.orangeColor()
三.类型推导
1.什么是类型推导?
& & &在Swift中,如果在定义标识符的同时直接对其进行赋值,那么系统会自动根据赋的值的数据类型,推导出标识符的类型
& & &如果定义标识符的同时直接赋值,那么标识符后面的数据类型可以省略
& & &可以通过option + 鼠标左键来查看标识符的类型
1 let n = 3.14
2 let View = UIView()
四.Swift中的基本运算
1.swift中在进行基本运算时,必须保证两个参与运算的值得数据类型一致,否则会报错
& & &因为swift中没有隐式转换
1 let m = 20
2 let n = 3.44
3 // let result = m + n 错误写法&
2.数据类型的转化
& & &将Int 转换为 Double &Double(m)
& & &将Double 转换为 Int Int(n)
1 let a : Double = 2.44
2 let b : CGFloat = 4.55
3 let result1 = a + Double(b)
五.逻辑分支
1.什么是逻辑分支?
& & &分支就是if / witch / 三目运算符 等判断语句
& & &通过分支语句可以控制程序的执行流程
2.if分支语句
&OC中if的写法 : BOOL --& YES/NO
int a = 20
if (a & 0) {
NSLog(@&a大于0&)
NSLog(@&a不等于0&)
&Swift和OC的差异
&&& 1. if后面的()可以省略掉
&&& 2. swift中没有非0(nil)即真 &Bool --& true/false
1 let a = 20
2 if a & 0 {
print(&a大于0&)
4 } else {
print(&a不大于0&)
3.三目运算符
& & &swift中的三目运算符合OC没什么差别
let result = m & n ? m : n
4.guard的使用
&&&&&4.1 guard是Swift2.0新增的语法
&&&&&4.2 它与if语句非常类似，它设计的目的是提高程序的可读性
&&&&&4.3 guard语句必须带有else语句，它的语法如下：
& & & & & 4.3.1当条件表达式为true时候跳过else语句中的内容，执行语句组内容
& & & & & 4.3.2条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue和throw
1 func online(age : Int , IDCard : Bool , money : Int)
guard age &= 18 else {
print(&回家叫家长&)
guard IDCard == true else {
print(&回家拿身份证&)
guard money &= 5 else {
print(&回家拿钱&)
print(&留下来上网&)
16 online(19, IDCard: true, money: 4)&
5.switch分支
& & &5.1苹果在swift中对swift中对switch进行了很大的加强
& & &5.2 Swift中switch和OC中switch的差异
& & & & & switch中后面的()可以省略
& & & & & case结束之后可以不加break,也不会产生case穿透
& & & & &补充:如果希望产生case穿透,需要在语句结束之后加上fallthrough
& & & & & & & & &在swift中switch的case后面可以跟上多个条件, 并且多个条件以 , 分割&
1 switch sex {
2 case 0, 1:
print(&正常&)
4 default:
print(&非正常人&)
&& & &5.3 swift支持多种数据类型判断&
1 //浮点型switch判断
2 switch m {
3 case 3.14:
print(&m是π&)
5 default:
print(&m非π&)
9 //字符串switch判断
10 switch opration {
case &+&:
result = a + b
result = a - b
result = a * b
result = a / b
19 default:
print(&非法操作&)
判断区间类型
什么是区间?
&&&&&通常我们指的是数字区间:0~10,100~200
swift中的区间常见有两种
&&&&&半开半闭区间:0..&10 表示:0~9,不包括10
&&&&&闭区间:0...10 表示:0~10
1 let score = 92
3 switch score {
4 case 0..&60:
print(&不及格&)
6 case 60..&80:
print(&及格&)
8 case 80..&90:
print(&良好&)
10 case 90...100:
print(&优秀&)
12 default:
print(&不合理分数&)
常见的循环有:for/while/do while
& & &1.1 OC中的for循环写法
for (int i = 0; i & 10; i++) {
& & &1.2 swift中的写法&
1 // 区间遍历 0..&10 0...9
2 for i in 0..&10 {
6 for i in 0...9 {
10 // 如果一个标识符不需要使用, 那么可以通过 _ 来代替
11 for _ in 0..&10 {
print(&hello world&)
2.while循环
& & &2.1 OC中的写法
int a = 20
while (a) {
& & &2.2 swift中的写法
& && &&&&&2.2.1while后面的()可以省略
& && &&&&&2.2.2没有非0(nil)即真
1 var i = 10
2 while i & 0 {
3.do while循环
1 // 区别: 不再使用do while --& repeat while
2 var m = 0
3 repeat {
m += 1
6 } while m & 10
1.字符串的介绍&
&&&&&1.1字符串在任何的开发中使用都是非常频繁的
&&&&&1.2OC和Swift中字符串的区别
& && &&&&&在OC中字符串类型时NSString,在Swift中字符串类型是String
& && &&&&&OC中字符串@&&,Swift中字符串&&
&&&&&1.3使用&String 的原因
& && &&&&&String 是一个结构体，性能更高
& & & & &&NSString 是一个 OC 对象，性能略差
& && &&&&&String 支持直接遍历
& && &&&&&String 提供了&String 和&NSString之间的无缝转换
2.字符串的定义
& & &2.1定义不可变字符串
let str = &hello swift&
& & &2.2定义可变字符串
var strM = &hello world&
strM = &hello china&&
3.获取字符串的长度
&&&&&先获取字符集合,再获取集合的count属性
let length = str.characters.count
4.遍历字符串
for c in str.characters {
5.字符串的拼接
& & &5.1字符串之间的拼接
let str1 = &Hello&
let str2 = &World&
let str3 = str1 + str2
& & &5.2字符串和其它标识符间的拼接
let name = &lgp&
let age = 18
let height = 1.98
let infoStr = &my name is \(name), age is \(age), height is \(height)&
& & &5.3字符串格式化
& & & & &&比如时间:03:04 &如果显示 3 : 4 就不好.所以需要格式化
let min = 3
let second = 4
let timeStr = String(format: &%02d:%02d&, arguments: [min, second])
6.字符串的截取
& & &6.1简单的方式是将String转成NSString来使用
& && &&&&&在标识符后加:as NSString即可
1 // 1.方式一: 将String类型转成NSString类型, 再进行截取
2 // (urlString as NSString) --& NSString
3 let header = (urlString as NSString).substringToIndex(3)
4 let footer = (urlString as NSString).substringFromIndex(10)
5 let range = NSMakeRange(4, 5)
6 let middle = (urlString as NSString).substringWithRange(range)
&&&&&6.1Swift中提供了特殊的截取方式
& && &&&&&该方式非常麻烦
& && &&&&&Index创建较为麻烦
1 // 2.方式二: Swift原生方式进行截取
2 let headerIndex = urlString.startIndex.advancedBy(3)
3 let header1 = urlString.substringToIndex(headerIndex)
5 let footerIndex = urlString.endIndex.advancedBy(-3)
6 let footer1 = urlString.substringFromIndex(footerIndex)
8 let range1 = headerIndex.advancedBy(1)..&footerIndex.advancedBy(-1)
9 let middle1 = urlString.substringWithRange(range1)
八.数组的使用
1.数组的介绍
& & &1.1 数组（Array）是一串有序的由相同类型元素构成的集合
& & &1.2 数组中的集合元素是有序的，可以重复出现
& & &1.3 Swift中的数组
& && &&&&&swift数组类型是Array，是一个泛型集合
2.数组的初始化
& & &2.1 定义不可变数组,使用let修饰 &
& & & & & 注意:不可变数组要在定义的同时初始化,否则没有意义
let array = [&why&, &yz&]
& & &2.2 定义可变数组,使用var修饰
& & & & & 注意:数组是泛型集合,必须确定该数组中存放元素的类型
//基本写法
var arrayM = Array&String&()
var arrayM = [String]()
3.对可变数组的基本操作(增删改查)
& & &3.1 添加元素
arrayM.append(&ljp&)& &&
& & &3.2 删除元素&
let removeItem = arrayM.removeAtIndex(1)
返回值为删除的元素
arrayM.removeAll()
& & &3.3 修改元素
arrayM[0] = &why&
& & &3.4 查找元素(根据下标获取元素)
let item = arrayM[0]
4.数组的遍历
& & &4.1 遍历下标值
1 for i in 0..&array.count {
print(array[i])
&&&&&4.2遍历元素
for name in array {
print(name)
&&&&&&4.3遍历下标值和元素
1 for (index, name) in array.enumerate() {
print(index)
print(name)
5.数组的合并
& & &相同类型的数组可以相加进行合并
& && 可变数组和不可变的数组也能合并
1 let array1 = [&why&, &yz&]
2 let array2 = [&lmj&, &lnj&]
3 let resultArray = array1 + array2
九.字典的使用
1.字典的介绍
& & &1.1字典允许按照某个键来访问元素
& & &1.2字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合
& & &1.3键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的
&&&&&1.4Swift中的字典
& && &&&&&Swift字典类型是Dictionary，也是一个泛型集合
2.字典的初始化
& & &2.1 定义不可变字典,使用let修饰 &
& & & & & 注意:不可变字典要在定义的同时初始化,否则没有意义
& & & & && &系统会根据[]中存放的是键值对,还是一个个元素,来判断该[]是一个数组还是字典& &
let dict = [&name& : &why&, &age& : 18, &height& : 1.88]
&&&&&2.2 定义可变字典,使用var修饰
& & & & & 注意:字典是泛型集合,必须制定该数组中存放元素的类型
&&&&&基本写法 &&& &
var dictM = Dictionary&String, NSObject&()
&&&&&简单写法& &
var dictM = [String : NSObject]() // 常见
3.对可变字典的基本操作(增删改查)
& & &3.1 添加元素
dictM.updateValue(&why&, forKey: &name&)& &&
& & &3.2 删除元素&
1 dictM.removeValueForKey(&age&)&
& & &3.3 修改元素
1 //如果原有没有对应的key/value, 那么就添加键值对
2 // 如果原有已经有对应的key/value, 那么直接修改
3 dictM.updateValue(&1.77&, forKey: &height&)
4 dictM[&name&] = &why&
& & &3.4 查找元素(获取元素)
1 let item = dictM[&name&]
4.字典的遍历
& & &4.1 遍历字典中所有的key
1 for key in dict.keys {
print(key)
　　4.2&遍历字典中所有的value
1 for value in dict.values {
print(value)
&&&&&&4.3&遍历字典中所有的key / value
1 for (key, value) in dict {
print(key)
print(value)
5.字典的合并
& & &相同类型的字典也不可以相加进行合并
& & &可以把其中一个字典改为可变的,遍历不可变得字典,把元素一个一个的添加到另一个不可变字典中
1 let dict1 = [&name& : &why&, &age& : 18]
2 var dict2 = [&height& : 1.88, &phoneNum& : &+86 110&]
4 for (key, value) in dict1 {
dict2[key] = value
十.元组的使用
1.元组的介绍
& & &1.1元组是Swift中特有的,OC中并没有相关类型
&&&&&1.2它是什么呢?
& & & & & 1.2.1 它是一种数据结构，在数学中应用广泛
& & & & & 1.2.2 类似于数组或者字典
& & & & & 1.2.3 可以用于定义一组数据
& & & & & 1.2.4 组成元组类型的数据可以称为“元素”
2.为什么使用元组?
& & &如果字典或数组保存多种数据类型,那么从字典会数组取出来的数据类型是NSObject,我们使用的时候很不方便,要先转换为真实类型
& & &元组保存多种数据类型,取出来就是该数据的真实类型,不需要转换就能直接使用
3.元组的定义
1 let infoTuple = (&why&, 18, 1.88, &+86 110&)
2 // 使用元组描述一个人的信息
3 (&1001&, &张三&, 30, 90)
4 // 给元素加上元素名称,之后可以通过元素名称访问元素
5 (id:&1001&, name:&张三&, english_score:30, chinese_score:90)
前言:swift语法基础篇(二)来了,想学习swift的朋友可以拿去参考哦,有兴趣可以相互探讨,共同学习哦.&
一.可选类型(重点内容)
1.什么是可选类型?
& & &1.1在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)
& & &1.2在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言)
&&&&&1.3但是开发中赋值nil,在所难免.因此推出了可选类型
&&&&&&目的:让代码更加严谨
2.可选类型的取值
& & &可选类型要么是:空值 , 要么是:有值
& & &只有为可选类型,才能赋值为nil
3.定义可选类型
& & & &3.1 普通写法
var name : Optional&String& = nil
&&&&&& 3.2 简单写法(语法糖)&
var name : String? = nil
4.给可选类型赋值
& & &4.1 普通赋值
name = Optional(&why&)
& & &4.2 直接赋值
name = &why& // 系统会对字符串进行包装Optional, 再进行赋值
5.强制解包(取出可选类型中具体的值)
& & &5.1 为什么要强制解包
& & & & & 可选类型的值的格式为: Optional(&why&) 我们要想使用其真实值,必须要解包
& & &5.2 怎么解包?
& & & & & 在可选类型的标识符后面加!
print(name!)
& & & & & 注意:解包前,要先判断可选类型是否为nil , 如果为nil,强制解包会报错
6.可选绑定
1 if let name = name {
print(name)
print(name)
& & &6.1 系统先判断可选类型是否为nil,如果为nil,就跳过{}中的内容
& & &6.2 如果有值,会先对name进行强制解包,然后把解包结果赋值给name
7.可选类型的应用场景
&&&&&可选类型能让代码变得更加严谨
& & &类型转换后的数据类型一般都为可选类型,因为转换不成功就为nil , 只有可选类型能接收nil
& & &7.1字符串类型转Int类型
& & &可以看到,类型转换后的类型为可选类型
& & &使用转换后的结果的时候,一定要先判断是否为nil, 如果为nil, 使用会报错
& & &7.2 根据string创建一个NSURL
1 let urlString = &&
3 let url : NSURL? = NSURL(string: urlString)
4 if let url = url {
let request = NSURLRequest(URL: url)
&&&&&if let url = url 内部做了以下判断:
&&&&&1.判断url是否为nil,为nil 就跳过{}中的内容
&&&&&2.不为nil,就对url进行强制解包
&&&&&3.将解包后的结果赋值给前面的url
& & &7.3 根据一个plist文件创建一个数组
1 let path = NSBundle.mainBundle().pathForResource(&123.plist&, ofType: nil)
3 if let path = path {
NSArray(contentsOfFile:path)
二.类型转化
1.is的使用:判断是否是某种类型
1 //1.is的使用
2 let infoArray = [&why& , 18 , 1.98]
3 let item = infoArray[1]
5 //item.isKindOfClass(UIButton.self)
7 //string是结构体,不能用isKindOfClass
8 if item is String {
print(&是字符串&)
10 }else {
print(&不是字符串&)
2.as的使用
& & &2.1 as直接使用: swift类型和oc类型的转化
1 let urlString = &&
2 (urlString as NSString).substringToIndex(3)
& & &2.2 as? 的使用: 将NSObject转成某一确定类型的可选类型
1 let item1 = infoArray[0]
2 let name = item1 as? String
3 if let name = name {
print(name.characters.count)
7 if let name = infoArray[0] as? String {
print(name.characters.count)
　　 &2.3 as! 的使用: 将NSObject转成确定的类型,但如果转化不成功,则程序会崩溃
1 let count = (infoArray[0] as! String).characters.count
1.函数的介绍
& & 1.1 函数相当于OC中的方法
& & 1.2 函数的格式如下
&&&&&func&函数名(参数列表)&-&&返回值类型&{
& & &&&&&代码块
& & &&&&&return&返回值
& & &1.3 func是关键字,多个参数列表之间可以用逗号（,）分隔，也可以没有参数
& & &1.4 使用箭头“-&”指向返回值类型
& & &1.5 如果函数没有返回值，返回值为Void.并且“-& 返回值类型”部分可以省略
2.常见的函数类型
3.内部参数和外部参数
& & &3.1 什么是内部参数
& & & & & 3.11 在函数内部就可以看到的参数(标识符)就是内部参数
& & & & & 3.12 默认所有的参数都是内部参数
& & &3.2 什么是外部参数
& & & & & 3.21&在函数外部就可以看到的参数(标识符)就是外部参数
& & & & & 3.22 默认从第二个参数开始都是外部参数
& & & & & 3.23&如果想让第一个参数成为外部参数,可以设置标签:在变量名前加标签即可
& & & & & 3.24 如果不想要外部参数,可以在参数名称前加_ &(_ 和参数名称中间要加一个 空格)
& & & & & 3.25 也可以给外部参数设置标签 &,相当于给外部参数起别名
4.默认参数
& & &4.1 什么是默认参数?
& & & & & 如果一个函数需要参数,而我们调用的时候又不想传参,那么在设计函数的时候,可以给函数一个默认的参数
& & & & & 如果调用函数,不传参数,就按照默认的参数对函数进行处理
5.可变参数
& & &5.1 swift中函数的参数个数可以变化，它可以接收不确定数量的输入类型参数
&&&&&5.2&它们必须具有相同的类型
&&&&&5.3&我们可以通过在参数类型名后面加入（...）的方式来指示这是可变参数
& & &作用:方便需求变化时,更改代码,当参数个数需求变更或很多时,可以轻松些代码
6.指针参数
& & &6.1 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
& & &6.2 必须是变量,因为需要在内部改变其值
& & &6.3 Swift提供的inout关键字就可以实现
7.函数的嵌套
& & &swift中函数是可以嵌套的,即函数中包含函数,但是不推荐该写法
& & &OC中方法不可以嵌套
1 // 函数的嵌套
2 let value = 55
3 func test() {
func demo() {
print(&demo \(value)&)
print(&test&)
10 demo() // 错误
必须在对应的作用域内调用
11 test() // 执行函数会先打印'test',再打印'demo'
8.函数的类型
& & &8.1什么是函数的类型?
& & & & & 每个函数都有自己的类型, 函数的类型由 函数的参数类型和返回值类型组成
1 // 定义两个函数
2 func addTwoInts(a : Int, b : Int) -& Int {
return a + b
6 func multiplyTwoInt(a : Int, b : Int) -& Int {
return a * b
&&&&&这两个函数的类型是 (Int, Int) -& Int
&&&&&8.2抽取两个函数的类型,并且使用
1 // 定义函数的类型
2 var mathFunction : (Int, Int) -& Int = addTwoInts
4 // 使用函数的名称
5 mathFunction(10, 20)
7 // 给函数的标识符赋值其他值
8 mathFunction = multiplyTwoInt
10 // 使用函数的名称
11 mathFunction(10, 20)
&&&&&8.3 函数作为方法的参数
1 // 3.将函数的类型作为方法的参数
2 func printResult(a : Int, b : Int, calculateMethod : (Int, Int) -& Int) {
print(calculateMethod(a, b))
6 printResult(10, b: 20, calculateMethod: addTwoInts)
7 printResult(10, b: 20, calculateMethod: multiplyTwoInt)
&&&&&8.4函数作为方法的返回值
1 // 1.定义两个函数
2 func stepForward(num : Int) -& Int {
return num + 1
6 func stepBackward(num : Int) -& Int {
return num - 1
10 // 2.定义一个变量,希望该变量经过计算得到0
11 var num = -4
13 // 3.定义获取哪一个函数
14 func getOprationMethod(num : Int) -& (Int) -& Int {
return num &= 0 ? stepForward : stepBackward
18 // 4.for循环进行操作
19 while num != 0 {
let oprationMethod = getOprationMethod(num)
num = oprationMethod(num)
print(num)
四.枚举类型
1.什么是枚举?
& & &1.1 枚举是一种数据类型,枚举是一组具有共同特性的数据的集合
& & &1.2 枚举可以让我们更安全的使用数据
& & &1.3 oc中只能对枚举成员赋值为整型
& & &1.4 swift中的枚举更加灵活,可以给每一枚举成员赋值,这些值可以为字符,字符串,整型,浮点型等
2.枚举类型的定义
& & &2.1 使用enum关键词,把枚举定义在一个大括号内
enum &#name#& {
case &#case#&
& & &2.2&case关键词表明新的一行成员值将被定义
& & &2.3&不像 C 和 Objective-C 一样，Swift 的枚举成员在被创建时不会被赋予一个默认的整数值 (0.1.2.3...)
& & &2.4 定义方式二: 多个成员值可以写在同一行
1 enum Planet {
case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
3.枚举类型的使用
1 enum Direction : Int{
case East = 1 , West , North , Sourth
4 //完整写法
5 let d : Direction = Direction.North
6 //简单写法:根据上下文能推导出确定的类型
7 var d1 = Direction.East
8 d1 = .West
10 //枚举类型的使用
11 let btn = UIButton(type: .Custom)
4.给枚举类型赋值
& & &4.1&枚举类型赋值可以是字符串/字符/整型/浮点型
& & &4.2&注意: 如果给枚举类型赋值, 则必须在枚举类型后面说明赋值的类型&
& & &4.3 给枚举类型赋的值的类型,必须跟说明的类型一致,否则会报错
1 let btn = UIButton(type: .Custom)
3 enum Direction : String{
case East = &1&
case West = &3&
case North = &6&
case Sourth = &9&
9 var b : Direction = .West
11 let a = Direction(rawValue: “6”)
注意: 通过rawValue:方式取出来的值的类型 &为 对应类型的 可选类型
& & &因为通过这种方法不一定能取出来值,可能为nil & 所以为可选类型 &比较严谨
&&&&&4.4给枚举类型赋值方式二
enum Direction2 : Int{
case East = 1 , West , North , Sourth
3 //只要给第一个成员赋值,会自动按照递增的方式给后面的成员赋值
4 //相当于 West = 2, North = 3, Sourth = 4
5 //注意:这种赋值方法只对整型有效,赋值其它类型无效
1.什么是结构体?
& & &1.1结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合
&&&&&1.2结构体(struct)指的是一种数据结构
&&&&&1.3结构体是值类型,在方法中传递时是值传递
2.结构的定义格式
struct&结构体名称&{
& & //&属性和方法
3.在swift中对结构体进行了很大的增强
& & &3.1 扩充构造函数
& & & & & 3.11 默认情况下,创建Location &只能使用Location (x: Double , y : Double) 方法创建
& & & & & 3.12 但为了让结构体的使用更加灵活, swift中,可以对其构造方法就行扩充&
& & & & & 3.13 注意: 结构体中值必须为可变的var ,否则没有意义
& & &3.2 为结构体扩充方法
1.类的介绍和定义
&&&&&1.1 Swift也是一门面向对象开发的语言,面向对象的基础是类,类产生了对象
& & &1.2 在swift中如何定义类?
& && &&&&&class是Swift中的关键字,用于定义类
&&&&&1.3 定义的类,可以没有父类.那么该类是rootClass
& & &1.4 通常情况下,定义类时.继承自NSObject
1 class 类名 : SuperClass {
// 定义属性和方法
4 class Person {
var name : String = &&
var age : Int = 0
8 let p = Person()
9 p.name = &lkj&
10 p.age = 18
2.类的属性定义
& & &2.1类的属性介绍:Swift中类的属性有多种
&&&&&存储属性:存储实例的常量和变量
&&&&&计算属性:通过某种方式计算出来的属性
&&&&&类属性:与整个类自身相关的属性
3.监听属性的改变
& & &3.1 在OC中我们可以重写set方法来监听属性的改变 (kvc监听系统属性的改变)
& & &3.2 Swift中可以通过属性观察者来监听和响应属性值的变化
&&&&&3.3 通常是监听存储属性和类属性的改变.(对于计算属性不需要定义属性观察者，因为可以在计算属性的set方法中直接观察)
&&&&&3.4 怎么监听? &&
& & & & & 通过willSet 和didSet两个方法来监听 , 统称为属性监听器
& & & & &&
4.类的构造函数
& & &4.1 构造函数类似于OC中的初始化方法: init方法
& & &4.2 创建一个类,系统会默认提供一个构造函数
& & &4.3 自定义构造函数 , 一般用来初始化时给属性赋值
& & & & & 注意:如果自定义构造函数,会覆盖系统默认提供的构造函数 , 如果想保留,需要重写
class Person {
var name : String
var age : Int
// 自定义构造函数,会覆盖init()函数
init(name : String, age : Int) {
// 如果在一个方法中, 属性名称产生了歧义(重名), self.不可以省略
self.name = name
self.age = age
11 // 创建一个Person对象
12 let p = Person(name: &why&, age: 18)
15 class Person: NSObject {
var name : String
var age : Int
// 重写了NSObject(父类)的构造方法
在init前面加上override
override init() {
24 // 创建一个Person对象
25 let p = Person()
5.字典转模型
& & &5.1 使用kvc的条件?
& & & & & 5.11 必须继承自NSObject
& & & & & 5.12 在构造函数中使用,必须先调用super.init()
& & &5.2 利用kvc字典转模型非常方便
& & &5.3 使用kvc注意点
& & & & & 5.31 属性需要有默认的值
& & & & & 5.32 基本数据类型默认值一般设置为0
& & & & & 5.33 对象或结构体类型定义为可选类型(可选类型没有赋值前为nil)
1 class Person: NSObject {
// 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值
var name : String?
// 基本数据类型不能是可选类型,否则KVC无法转化
var age : Int = 0
// 自定义构造函数,会覆盖init()函数
init(dict : [String : NSObject]) {
// 必须先初始化对象
super.init()
// 调用对象的KVC方法字典转模型
setValuesForKeysWithDictionary(dict)
//如果字典中某些键值对,在类中找不到对应的属性,就会报错
//不想让它报错,可以重写setValue
forUndefinedKey key:
override func setValue(value: AnyObject?, forUndefinedKey key: String) {
18 // 创建一个Person对象
19 let dict = [&name& : &why&, &age& : 18]
20 let p = Person(dict: dict)
6.析构函数
& & &6.1 swift会自动释放不需要的实例以释放资源
& & & & & 6.11 swift 通过ARC 处理实例的内存管理
& & & & & 6.12 当引用计数为0时,系统会自动调用析构函数(不可以手动调用)
& & & & & 6.13 通常在析构函数中释放一些资源(如:移除通知等操作)
& & &6.2 析构函数的写法
1 deinit {
// 执行析构过程
& & & & & 6.21 示例练习
1 class Person {
var name : String
var age : Int
init(name : String, age : Int) {
self.name = name
self.age = age
print(&Person-deinit&)
15 var p : Person? = Person(name: &why&, age: 18)
16 p = nil
前言:swift语法基础篇(二)来了,想学习swift的朋友可以拿去参考哦,有兴趣可以相互探讨,共同学习哦.&
一.自动引用计数
1.自动引用计数工作机制
& & &1.1 swift和oc一样,采用自动引用计数来管理内存
& & &1.2 当有强引用指向对象,对象的引用计数 +1 , 强引用消失,自动计数 -1
& & &1.3 如果对象的引用计数为0 , 那么该对象会被销毁
2.循环引用
& & &2.1 什么是循环引用?
& && &&&&&两个(或多个)对象互相强引用
& & &2.2 循环引用对项目有什么影响
& & & & & 循环引用会让对象不会被销毁,一直保存在内存中,可能导致项目运行不畅
& & &2.3 怎么解决强引用问题?
& & & & & 只需要让其中一个对象对另外一个对象的引用变为弱引用即可
& & & & & 在swift中用waek 相当于OC中的 __weak ,或者使用 unowned 相当于OC中的 __unsafe_unretained
3.weak 和 unowned的区别
& & &3.1 相同点:
& && &&&&&都是一个弱引用,不会对对象进行retain
& & &3.2 不同点
& & & & & 3.21 weak(__weak) :当弱引用指向的对象销毁时,该引用会指向nil & 所以用weak指向的数据类型为可选类型
& & & & & 3.22 unowned(__unsafe_unretained) :当弱引用指向的对象销毁时,依然指向原来的内存地址, 容易产生错误(野指针/访问僵尸对象)
& & & & & 3.23 unowned不支持可选类型
1.什么是可选链?
& & &简单的说,就是可选类型的对象组成的链条
2.为什么会产生可选链?
& & &2.1 假设有三个类, 人,狗,玩具 &&
& & &2.2 人里面有狗这个属性,狗里面有玩具这个属性, 玩具里面有价格这个属性
& & &2.3 把玩具这个对象赋值给狗(让狗拥有玩具), 把狗这个对象赋值给人(让人拥有这只狗)
& & &2.4 想要通过人来修改玩具的价格,就需要 person.dog.toy.price 来修改
& & &2.5 person.dog这个值得类型是可选类型 ,因为人的狗属性可能为nil & 属性,想要使用person.dog ,必须要强制解包
& & &2.6&person.dog.toy也是可选类型,像这样由可选类型的对象组成的链条就是可选链
3.可选链注意点
& & &3.1 利用可选链赋值的时候一定要解包
& & &3.2&利用可选链取值的时候也不要忘记解包
& & &3.3 利用可选链调用方法的时候 也要先解包
4.利用可选链赋值, 取值,调用方法
& & &4.1 给可选链赋值:
person.dog!.toy!.price = 50 太危险
强制解包,如果没值,直接程序崩溃
3 if let dog = person.dog {
if let toy = dog.toy {
toy.price = 50
这样解包虽然安全,但是太麻烦
苹果在swift中推荐使用这种方式来给可选链赋值
1 person.dog?.toy?.price = 50
2 //当person.dog 为nil的时候,后面的操作就不再执行
& & &4.2 从可选链取值: 从可选链中取出的值得类型一定是可选类型 (有可能取不到)
let price = person.dog?.toy?.price
& & &4.3 可选链调用方法:系统会自动判断可选类型是否有值
person.dog?.toy?.flying()
1.如何定义协议
& & &1.1 swift中协议的方式和类,结构体,枚举相似
protocol SomeProtocol {
// 协议方法
& & &1.2 例如:定义一个运动协议
1 protocol SportProtocol {
func playBasketball()
func playFootball()
2.声明一个类,并且遵守协议
& & &2.1 声明一个基类(不继承其它类),并遵守协议
1 class SomeClass:FirstProtocol,AnotherProtocol {
// 类的内容
// 实现协议中的方法
7 class Person : SportProtocol {
var name : String = &&
func playBasketball() {
print(&打篮球&)
func playFootball() {
print(&踢足球&)
& & &2.2 类继承自其他类,并遵守协议
1 class SomeClass:SomeSuperClass, FirstProtocol,AnotherProtocol {
// 类的内容
// 实现协议中的方法
3.OC swift不支持多继承, 但是可以通过协议,间接实现多继承
4.协议的继承关系
& & &4.1 swift中的及协议和OC(NSObject)中的不同 是:NSObjectProtocol
1 protocol CrazySportProtocol : NSObjectProtocol {
func jumping()
& & &4.2 一个协议,可以遵守另一个协议
1 protocol SportProtocol : CrazySportProtocol {
func playBasketball()
& & &当一个类遵守了这个协议(SportProtocol) 相当于也遵守了CrazySportProtocol 协议, 所以必须实现这两个协议中的方法
5.协议的可选性
& & &5.1 OC中协议可以定义为可选和必选,默认是必选的
& & &5.2 默认情况下,swift中的协议都是必须实现的 ,否则编译器会报错
& & &5.3 在swift中如何让协议成为可选的(不用必须实现)
& & & & & 要在协议前加 @objc ,可以保留OC某些特性,在方法前加optional &该方法就是可选的了
& && &&&&&在实现协议方法时,在方法前面也要加@objc
1 @objc protocol SportProtocol {
func playBasketball()
func playFootball()
//加optional该方法就成为可选的了
optional func jumping()
8 class Person: SportProtocol {
@objc func playBasketball() {
在方法前也要加上关键字@objc,不管是可选还是必选
@objc func playFootball() {
@objc func jumping() {
6.协议在代理模式中的使用
&&&&&6.1 一般来说协议都用weak来修饰(弱引用)
&&&&&6.2 weak只能用来修饰类
&&&&&6.3 在swift中协议既可以被类遵守,也可以被结构体,枚举遵守
& & &6.4 如何让协议只能被类准守
& & & & & 在协议名称后面加上 &:class &即可
1.什么是闭包?
& & &闭包和OC中的block非常相似,一般都用来函数的回调
2.block的回顾
& & &block作为属性的格式: `@property (nonatomic, strong) void(^finishedCallback)(NSString *)`;
& & &block作为参数的定义格式:` (void (^)(NSString * str))finishedCallback`
3.闭包的格式:
& & &(参数列表) -& (返回值类型)
4.闭包的使用
5.尾随闭包
// 尾随闭包 : 如果函数的最后一个参数是一个闭包.那么可以将函数调用写成尾随闭包
//就是把闭包写到()的后面, 本来是写在()里面的
tools?.loadData() { (result) in
print(&在ViewController中获取到数据:\(result)&)
// 如果函数有且只有一个参数,并且是一个闭包, 那么()也可以省略
tools?.loadData { (result) in
print(&在ViewController中获取到数据:\(result)&)
6.闭包的循环引用
& & &6.1 一般在定义工具类的时候,会在工具类的方法中用到闭包
& & &6.2 当工具类对闭包有强引用,一个控制器又调用包含该闭包的方法,在闭包方法中使用控制器的属性,就会发生循环引用
& & &6.3 控制器调用方法,就会对工具类有一个强引用, 闭包又拿到控制器的属性,闭包对象就对控制器有一个强引用
& & &6.4 在内存中就相当于这种表现
& & &&&&&&
7.怎么解决闭包的循环引用
& & &与oc中类型,只需要把闭包对控制器的引用改为弱引用
& & &当闭包修改控制器的属性时,拿到控制器的属性时,把self(控制器)改成weakself即可
weak var weakself : ViewController? = self
五.swift项目的目录结构简介
1.swift项目目录中没有.h和.m的文件, 只有一个.swift的文件,相当于
2.swift目录中.swift文件就相当于oc中的.h和.m文件
3.在swift中,调用项目中的其他源文件不需要导入头文件 &(一个 .swift文件就是一个源文件)
1.懒加载的介绍
& & &1.1 和OC中不同,swift有专门的关键字实现懒加载
& & &1.2 懒加载本质:当第一次使用时再加载,而且只会被加载一次
2.swift中用lazy关键字来实现懒加载
& & &2.1 懒加载格式 &
lazy var 变量: 类型 = { 创建变量代码 }()
&&&&&= 后面是一个闭包 苹果推荐用闭包来实现懒加载,可在闭包中对变量属性进行初始化
& & &2.2 懒加载的使用
1 lazy var names : [String] = {
return [&why&, &yz&, &lmj&]
& & & & & 当执行到上面代码的时候,names不会被加载到内存中, 当names第一次使用时,才会被加载
& & & & & 无论names使用多少次,只会被加载一次,也就是说内存中只有一个names属性地址
七.swift中的常见注释
1.单行注释
& & &和OC中的单行注释一样 &使用 &// 注释内容
2.多行注释
& & &和OC中的多行注释格式一样 & /* &注释内容 &*/
& & &不同的是,swift中多行注释可以嵌套使用
3.文档注释
& & &与oc中不一样 &, swift中 用 /// 注释内容 &来实现文档注释
4.分组注释
& & &和oc不一样 oc:& #pragma mark - 注释内容
&&&&&swift:& //MARK : - 注释内容
八.访问权限
1.internal :内部的
& & &1.1 当不指定具体的访问权限时,默认为internal
& & &1.2 internal的访问权限: 在当前项目(包)的任何地方都能访问
2.private : 私有的
& & &private的访问权限: 在当前源文件中能够访问 & &一个 .swift文件就是一个源文件
3.public :公共的
& & &3.1 public的访问权限 : 可以跨包访问
& & &3.2 包的概念: 就是一个项目或一个框架 & UIKit也是一个框架
九.异常处理
1.在swift中,如果一个方法的最后有一个throws,那么这个方法能抛出异常
& & &正则表达式就能抛出异常:
& & &NSRegularExpression(pattern: &#T##String#&, options: &#T##NSRegularExpressionOptions#&)
2.如果一个方法抛出异常,必须要对异常进行处理,否则编译报错
3.异常处理的三种方式
& & &3.1 try : 手动处理异常,可以拿到异常(error)
& & & & & 要在方法前面加上try & 而且外面要用do 包装
//try方式 --& 手动处理异常, 并且可以获取到最终的异常结果
//如果有异常error有值
let regex = try NSRegularExpression(pattern: &&, options: .CaseInsensitive)
//通过error拿到异常结果
print(error)
& & &3.2 try? : 系统处理异常
&&&&&try?方式 : 如果有异常,则返回nil,如果没有异常,则返回结果 & 结果(regex)为可选类型
&&&&&&&&&&&& let regex = try? NSRegularExpression(pattern: &&, options: .CaseInsensitive)
&&&&&&&&&&&& regex?.matchesInString(&&, options: [], range: NSMakeRange(0, 0))
& & &3.3 try! :告诉系统不可能有异常
& & &&&&&& try!方式(不推荐) &注意:一旦发生异常,程序就会崩溃
&&&&&&&&&&& let regex = try! NSRegularExpression(pattern: &&, options: .CaseInsensitive)
十.如何抛出异常
1.在方法参数的后面加上 throws &,一定要有返回值
2.在某些具体的情况下抛出异常
& & &比如:传的参数不对等等 &,内部要对参数进行判断
3.抛出的异常,一般定义为枚举类型 &枚举后面要跟上 ErrorType 这种类型
十一.OC和swift相互调用
1.swift中调用oc
& & &1.1 创建一个桥接文件 (.h的文件) 文件名一般为 Bridge.h
& & &1.2 在桥接文件中导入oc的头文件
& & &1.3 配置桥接文件 & & 工程 —& BuildSetting —& 搜索bridging & 在后面写入Bridge.h 的相对路径
2.oc中调用swift
& & &2.1 项目名称要规范 (不能有中文和特殊字符)
& & &2.2 swift中的类,属性,方法名 前面要加 public
& & &2.3 在oc文件中导入 &工程名-Swift.h &的头文件 &工程名-Swift.h &系统会自动生成
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：3562753次
积分：37710
积分：37710
排名：第96名
原创：583篇
转载：784篇
评论：586条
(26)(3)(3)(1)(1)(2)(3)(7)(2)(1)(2)(2)(3)(2)(8)(5)(2)(4)(1)(1)(1)(26)(63)(63)(49)(35)(8)(16)(13)(17)(34)(46)(18)(32)(45)(13)(10)(66)(88)(57)(34)(34)(27)(23)(11)(18)(11)(84)(21)(28)(70)(6)(5)(17)(37)(12)(23)(14)(2)(8)(1)(10)(15)(23)(3)(19)(19)(7)(4)(1)(5)(2)