SWIFT 计算机编程语言 SWIFT 计算机编程语言 -简介，SWIFT 计算

Swift是苹果于2014年WWDC（苹果开发者大会）发布的新开发语言，可与Objective-C*共同运行于Mac OS和iOS平台，用于搭建基于苹果平台的应用程序。Swift是一款易学易用的编程语言，而且它还是第一套具有与脚本语言同样的表现力和趣味性的系统编程语言。Swift的设计以安全为出发点，以避免各种常见的编程错误类别。2015年12月4日，苹果公司宣布其Swift编程语言现在开放源代码。长600多页的The Swift Programming Language可以在线免费下载。

计算机编程语言_SWIFT[计算机编程语言] -简介

计算机编程语言_SWIFT[计算机编程语言] -发展历史

2014-6-3WWDC2014:苹果2014年开发者大会发布。

2014-6-4《Swift中文版》翻译组在github上进行协同翻译。此项目开始不到一周就获得了1067个star。令人吃惊的是，该项目的发起人是北航的大三学生。

2014-6-12《Swift中文版》第一版发布。

2015年12月4日，苹果公司宣布其Swift编程语言现在开放源代码。长600多页的TheSwiftProgrammingLanguage可以在线免费下载。

计算机编程语言_SWIFT[计算机编程语言] -应用领域

Swift可以允许开发者更快的复制内容，通过非常少的代码来实现更多的内容。在发布会上，苹果演示了如果只通过一行简单的代码就完成了一个完整图片列表加载的过程。另外，Swift还可以让开发人员看到随着时间的推移整个应用程序运行代码的变化，并且还拥有完全控制时间的特性，所以开发人员可以快速的向前或向后预览，测试自己的应用程序在某些特殊情况下的反应。

Swift完全支持Xcode，并且开发指南将通过iBookstore来提供给广大开发者。另外开发者们也可以在年底iOS8系统发布时开始提交通过Swift语言编写的新应用程序。Xcode目前已有1400万次下载量，而全新Swift编程语言改变了Objective-C复杂的语法，并保留了Smalltalk的动态特性，整体来说变得更加简单易用，进一步完善了自己的开发生态圈。

计算机编程语言_SWIFT[计算机编程语言] -Swift是什么

Swift是什么，Swift Code和swift代码是什么？他的中文名字叫做国际路由代码，我们在办理入金和取款的时候经常会用到这个swift代码，他的作用类似一个电话的电话号码，通过这个swift代码，汇款的时候银行就可以确定是需要入金或者取款到哪一个银行，方便银行做审核防止填写汇款的时候资料

计算机编程语言_SWIFT[计算机编程语言] -主要功能

语法简便

Swift是编程语言的最新研究成果，并结合数十年的经验建设苹果平台的结果。结转自Objective-C的命名参数表示在一个干净的语法，使得Swift的API更容易阅读和维护。
推断类型使代码更干净，不易犯错误，而模块消除了头，并提供命名空间。内存自动管理，而你甚至都不需要输入分号。

其他功能

Swift特有许多其他的功能，使你的代码更传神：
闭包的统一与函数指针
元组和多个返回值
泛型
快速而简洁的迭代范围或集合
支持的方法，扩展的协议结构。
函数式编程模式，例如：映射（map）和过滤器（filter）

互动游乐

操场使编写语言代码难以置信的简单和有趣。输入一行代码，结果立即出现。如果您的代码通过一个循环运行一段时间你可以看它在时间轴助理进展。在时间线中的图表显示变量，组成一个视图时绘制每一步，并能起到一个动画SpriteKit现场。当你在操场上完善你的代码，只需将代码到您的项目。有了游乐场，您可以：
设计一种新的算法，看其工作的每一步
创建新的测试，验证他们推动到您的测试套件前工作
尝试新的API来磨练你的Swift的编码技巧

REPL

阅读-分析-打印环路（REPL）：在Xcode调试控制台包括内建Swift使用语法来评估，并与正在运行的应用程序进行交互，或者编写新的代码，看看它是如何工作的一个类似脚本的环境Swift语言的交互式版本。可以从Xcode的控制台内，或在终端。

专为安全

Swift消除了不安全的代码。变量总是初始化之前使用，数组和整数检查溢出，内存自动管理。语法被调整到可以很容易地定义你的意图-例如，简单的三个字符的关键字定义一个变量（var）或常量（let）。

在Swift的安全模式被调整为强大的Cocoa和CocoaTouch的API。认识和妥善处理其中的对象是零案件是基本的框架和Swift的代码使这个非常容易。添加一个字符可以代替曾经Objective-C中整行的代码。这一相互配合，使构建iOS和Mac应用程序比以前更加容易和安全。

高效强大

Swift是为高效而强大的编程而创建的语言。Swift采用了高性能的AppleLLVM编译器，Swift代码转化为优化过的本地代码，充分利用现代化的Mac，iPhone和iPad的硬件。语法和标准库也非常简洁，让编程的流程大大缩短、简化。

Swift采用了C和Objective-C语言中的优秀成分。Swift也包括了很多其他语言的特征，如类型，流程控制和运算符。Swift还提供了面向对象的特性，如类与协议。

计算机编程语言_SWIFT[计算机编程语言] -SwiftCode

含义

查询方法

计算机编程语言_SWIFT[计算机编程语言] -学习入门

Helloworld

第一个程序应该在屏幕上打印“Hello,world”。在Swift中，可以用一行代码实现：
println("Hello,world")
如果你写过C或者Objective-C代码，那你应该很熟悉这种形式――在Swift中，这行代码就是一个
完整的程序。你不需要为了输入输出或者字符串处理导入一个单独的库。全局作用域中的代码会被自动当
做程序的入口点，所以你也不需要main函数。你同样不需要在每个语句结尾写上分号。
这个教程会通过一系列编程例子来让你对Swift有初步了解，如果你有什么不理解的地方也不用担心―
―任何本章介绍的内容都会在后面的章节中详细讲解。
注意：
为了获得最好的体验，在Xcode当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运
行结果。

简单值

使用let来声明常量，使用var来声明变量。一个常量的值在编译时并不需要获取，但是你只能为它赋值一
次。也就是说你可以用常量来表示这样一个值：你只需要决定一次，但是需要使用很多次。
varmyVariable=42
myVariable=50
letmyConstant=42
常量或者变量的类型必须和你赋给它们的值一样。然而，声明时类型是可选的，声明的同时赋值的话，编
译器会自动推断类型。在上面的例子中，编译器推断出myVariable是一个整数（integer）因为它的初始
值是整数。
如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割。
letimplicitInteger=70
letimplicitDouble=70.0
letexplicitDouble:Double=70
创建一个常量，显式指定类型为Float并指定初始值为4。
值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。
letlabel="Thewidthis"
letwidth=94
letwidthLabel=label+String(width)
删除最后一行中的String，错误提示是什么？
有一种更简单的把值转换成字符串的方法：把值写到括号中，并且在括号之前写一个反斜杠。例如：
letapples=3
letoranges=5
letappleSummary="Ihave(apples)apples."
letfruitSummary="Ihave(apples+oranges)piecesoffruit."
使用()来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。
使用方括号[]来创建数组和字典，并使用下标或者键（key）来访问元素。
varshoppingList=["catfish","water","tulips","bluepaint"]
shoppingList[1]="bottleofwater"
varoccupations=[
"Malcolm":"Captain",
"Kaylee":"Mechanic",
]
occupations["Jayne"]="PublicRelations"
要创建一个空数组或者字典，使用初始化语法。
letemptyArray=[String]()
letemptyDictionary=Dictionary<String,Float>()
如果类型信息可以被推断出来，你可以用[]和[:]来创建空数组和空字典――就像你声明变量或者给函数
传参数的时候一样。
shoppingList=[]//去逛街并买点东西

控制流

使用if和switch来进行条件操作，使用for-in、for、while和do-while来进行循环。包裹条件和循环变
量括号可以省略，但是语句体的大括号是必须的。
letindividualScores=[75,43,103,87,12]
varteamScore=0
forscoreinindividualScores{
ifscore>50{
teamScore+=3
}else{
teamScore+=1
}
}
teamScore
在if语句中，条件必须是一个布尔表达式――这意味着像ifscore{...}这样的代码将报错，而不会隐
形地与0做对比。
你可以一起使用if和let来处理值缺失的情况。有些变量的值是可选的。一个可选的值可能是一个具体的
值或者是nil，表示值缺失。在类型后面加一个问号来标记这个变量的值是可选的。
varoptionalString:String?="Hello"
optionalString==nil
varoptionalName:String?="JohnAppleseed"
vargreeting="Hello!"
ifletname=optionalName{
greeting="Hello,(name)"
}
把optionalName改成nil，greeting会是什么？添加一个else语句，当optionalName是nil时给greeting
赋一个不同的值。
如果变量的可选值是nil，条件会判断为false，大括号中的代码会被跳过。如果不是nil，会将值赋给let
后面的常量，这样代码块中就可以使用这个值了。
switch支持任意类型的数据以及各种比较操作――不仅仅是整数以及测试相等。
letvegetable="redpepper"
switchvegetable{
case"celery":
letvegetableComment="Addsomeraisinsandmakeantsonalog."
case"cucumber","watercress":
letvegetableComment="Thatwouldmakeagoodteasandwich."
caseletxwherex.hasSuffix("pepper"):
letvegetableComment="Isitaspicy(x)?"
default:
letvegetableComment="Everythingtastesgoodinsoup."
}
删除default语句，看看会有什么错误？
运行switch中匹配到的子句之后，程序会退出switch语句，并不会继续向下运行，所以不需要在每个子句
结尾写break。
你可以使用for-in来遍历字典，需要两个变量来表示每个键值对。
letinterestingNumbers=[
"Prime":[2,3,5,7,11,13],
"Fibonacci":[1,1,2,3,5,8],
"Square":[1,4,9,16,25],
]
varlargest=0
for(kind,numbers)ininterestingNumbers{
fornumberinnumbers{
ifnumber>largest{
largest=number
}
}
}
largest
添加另一个变量来记录哪种类型的数字是最大的。
使用while来重复运行一段代码直到不满足条件。循环条件可以在开头也可以在结尾。
varn=2
whilen<100{
n=n*2
}
n
varm=2
do{
m=m*2
}whilem<100
m
你可以在循环中使用..<来表示范围，也可以使用传统的写法，两者是等价的：
varfirstForLoop=0
foriin0..<3{
firstForLoop+=i
}
firstForLoop
varsecondForLoop=0
forvari=0;i<3;++i{
secondForLoop+=1
}
secondForLoop
使用..<创建的范围不包含上界，如果想包含的话需要使用...。

函数闭包

使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值。
funcgreet(name:String,day:String)->String{
return"Hello(name),todayis(day)."
}
greet("Bob","Tuesday")
删除day参数，添加一个参数来表示今天吃了什么午饭。
使用一个元组来返回多个值。
funcgetGasPrices()->(Double,Double,Double){
return(3.59,3.69,3.79)
}
getGasPrices()
函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式：
funcsumOf(numbers:Int...)->Int{
varsum=0
fornumberinnumbers{
sum+=number
}
returnsum
}
sumOf()
sumOf(42,597,12)
函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂
的函数。
funcreturnFifteen()->Int{
vary=10
funcadd(){
y+=5
}
add()
returny
}
returnFifteen()
函数是第一等类型，这意味着函数可以作为另一个函数的返回值。
funcmakeIncrementer()->(Int->Int){
funcaddOne(number:Int)->Int{
return1+number
}
returnaddOne
}
varincrement=makeIncrementer()
increment(7)
函数也可以当做参数传入另一个函数。
funchasAnyMatches(list:Int[],condition:Int->Bool)->Bool{
foriteminlist{
ifcondition(item){
returntrue
}
}
returnfalse
}
funclessThanTen(number:Int)->Bool{
returnnumber<10
}
varnumbers=[20,19,7,12]
hasAnyMatches(numbers,lessThanTen)
函数实际上是一种特殊的闭包，你可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭
包函数体进行分离。
numbers.map({
(number:Int)->Intin
letresult=3*number
returnresult
})
有很多种创建闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和
返回值。单个语句闭包会把它语句的值当做结果返回。
numbers.map({numberin3*number})
你可以通过参数位置而不是参数名字来引用参数――这个方法在非常短的闭包中非常有用。当一个闭包作
为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。
sort([1,5,3,12,2]){$0>$1}

对象和类

使用class和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文
是类。同样，方法和函数声明也一样。
classShape{
varnumberOfSides=0
funcsimpleDescription()->String{
return"Ashapewith(numberOfSides)sides."
}
}
要创建一个类的实例，在类名后面加上括号。使用点语法来访问实例的属性和方法。
varshape=Shape()
shape.numberOfSides=7
varshapeDescription=shape.simpleDescription()
这个版本的Shape类缺少了一些重要的东西：一个构造函数来初始化类实例。使用init来创建一个构造器
。
classNamedShape{
varnumberOfSides:Int=0
varname:String
init(name:String){
self.name=name
}
funcsimpleDescription()->String{
return"Ashapewith(numberOfSides)sides."
}
}
注意self被用来区别实例变量。当你创建实例的时候，像传入函数参数一样给类传入构造器的参数。每个属性都需要赋值――无论是通过声明（就像numberOfSides）还是通过构造器（就像name）。如果你需要在删除对象之前进行一些清理工作，使用deinit创建一个析构函数。子类的定义方法是在它们的类名后面加上父类的名字，用冒号分割。创建类的时候并不需要一个标准的根类，所以你可以忽略父类。
子类如果要重写父类的方法的话，需要用override标记――如果没有添加override就重写父类方法的话编译器会报错。编译器同样会检测override标记的方法是否确实在父类中。
classSquare:NamedShape{
varsideLength:Double
init(sideLength:Double,name:String){
self.sideLength=sideLength
super.init(name:name)
numberOfSides=4
}
funcarea()->Double{
returnsideLength*sideLength
}
overridefuncsimpleDescription()->String{
return"Asquarewithsidesoflength(sideLength)."
}
}
lettest=Square(sideLength:5.2,name:"mytestsquare")
test.area()
test.simpleDescription()
创建NamedShape的另一个子类Circle，构造器接收两个参数，一个是半径一个是名称，实现area和
describe方法。
属性可以有getter和setter。
classEquilateralTriangle:NamedShape{
varsideLength:Double=0.0
init(sideLength:Double,name:String){
self.sideLength=sideLength
super.init(name:name)
numberOfSides=3
}
varperimeter:Double{
get{
return3.0*sideLength
}
set{
sideLength=newValue/3.0
}
}
overridefuncsimpleDescription()->String{
return"Anequilateraltriaglewithsidesoflength(sideLength)."
}
}
vartriangle=EquilateralTriangle(sideLength:3.1,name:"atriangle")
triangle.perimeter
triangle.perimeter=9.9
triangle.sideLength
在perimeter的setter中，新值的名字是newValue。你可以在set之后显式的设置一个名字。
注意EquilateralTriangle类的构造器执行了三步：
设置子类声明的属性值
调用父类的构造器
改变父类定义的属性值。其他的工作比如调用方法、getters和setters也可以在这个阶段完成。
如果你不需要计算属性但是需要在设置一个新值之前运行一些代码，使用willSet和didSet。
比如，下面的类确保三角形的边长总是和正方形的边长相同。
classTriangleAndSquare{
vartriangle:EquilateralTriangle{
willSet{
square.sideLength=newValue.sideLength
}
}
varsquare:Square{
willSet{
triangle.sideLength=newValue.sideLength
}
}
init(size:Double,name:String){
square=Square(sideLength:size,name:name)
triangle=EquilateralTriangle(sideLength:size,name:name)
}
}
vartriangleAndSquare=TriangleAndSquare(size:10,name:"anothertestshape")
triangleAndSquare.square.sideLength
triangleAndSquare.triangle.sideLength
triangleAndSquare.square=Square(sideLength:50,name:"largersquare")
triangleAndSquare.triangle.sideLength
类中的方法和一般的函数有一个重要的区别，函数的参数名只在函数内部使用，但是方法的参数名需要在
调用的时候显式说明（除了第一个参数）。默认情况下，方法的参数名和它在方法内部的名字一样，不过
你也可以定义第二个名字，这个名字被用在方法内部。
classCounter{
varcount:Int=0
funcincrementBy(amount:Int,numberOfTimestimes:Int){
count+=amount*times
}
}
varcounter=Counter()
counter.incrementBy(2,numberOfTimes:7)
处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加?。如果?之前的值是nil，?后面
的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表
达式的值也是一个可选值。
letoptionalSquare:Square?=Square(sideLength:2.5,name:"optionalsquare")
letsideLength=optionalSquare?.sideLength

枚举

使用enum来创建一个枚举。就像类和其他所有命名类型一样，枚举可以包含方法。
enumRank:Int{
caseAce=1
caseTwo,Three,Four,Five,Six,Seven,Eight,Nine,Ten
caseJack,Queen,King
funcsimpleDescription()->String{
switchself{
case.Ace:
return"ace"
case.Jack:
return"jack"
case.Queen:
return"queen"
case.King:
return"king"
default:
returnString(self.toRaw())
}
}
}
letace=Rank.Ace
letaceRawValue=ace.toRaw()
写一个函数，通过比较它们的原始值来比较两个Rank值。
在上面的例子中，枚举原始值的类型是Int，所以你只需要设置第一个原始值。剩下的原始值会按照顺序
赋值。你也可以使用字符串或者浮点数作为枚举的原始值。
使用toRaw和fromRaw函数来在原始值和枚举值之间进行转换。
ifletconvertedRank=Rank.fromRaw(3){
letthreeDescription=convertedRank.simpleDescription()
}
枚举的成员值是实际值，并不是原始值的另一种表达方法。实际上，如果原始值没有意义，你不需要设置
。
enumSuit{
caseSpades,Hearts,Diamonds,Clubs
funcsimpleDescription()->String{
switchself{
case.Spades:
return"spades"
case.Hearts:
return"hearts"
case.Diamonds:
return"diamonds"
case.Clubs:
return"clubs"
}
}
}
lethearts=Suit.Hearts
letheartsDescription=hearts.simpleDescription()
给Suit添加一个color方法，对spades和clubs返回“black”，对hearts和diamonds返回“red”。
注意，有两种方式可以引用Hearts成员：给hearts常量赋值时，枚举成员Suit.Hearts需要用全名来引用
，因为常量没有显式指定类型。在switch里，枚举成员使用缩写.Hearts来引用，因为self的值已经知道
是一个suit。已知变量类型的情况下你可以使用缩写。
使用struct来创建一个结构体。结构体和类有很多相同的地方，比如方法和构造器。它们之间最大的一个
区别就是结构体是传值，类是传引用。
structCard{
varrank:Rank
varsuit:Suit
funcsimpleDescription()->String{
return"The(rank.simpleDescription())of
(suit.simpleDescription())"
}
}
letthreeOfSpades=Card(rank:.Three,suit:.Spades)
letthreeOfSpadesDescription=threeOfSpades.simpleDescription()
给Card添加一个方法，创建一副完整的扑克牌并把每张牌的rank和suit对应起来。
一个枚举成员的实例可以有实例值。相同枚举成员的实例可以有不同的值。创建实例的时候传入值即可。
实例值和原始值是不同的：枚举成员的原始值对于所有实例都是相同的，而且你是在定义枚举的时候设置
原始值。
例如，考虑从服务器获取日出和日落的时间。服务器会返回正常结果或者错误信息。
enumServerResponse{
caseResult(String,String)
caseError(String)
}
letsuccess=ServerResponse.Result("6:00am","8:09pm")
letfailure=ServerResponse.Error("Outofcheese.")
switchsuccess{
caselet.Result(sunrise,sunset):
letserverResponse="Sunriseisat(sunrise)andsunsetisat(sunset)."
caselet.Error(error):
letserverResponse="Failure...(error)"
}
给ServerResponse和switch添加第三种情况。
注意如何从ServerResponse中提取日升和日落时间。

接口扩展

使用protocol来声明一个接口。
protocolExampleProtocol{
varsimpleDescription:String{get}
mutatingfuncadjust()
}
类、枚举和结构体都可以实现接口。
classSimpleClass:ExampleProtocol{
varsimpleDescription:String="Averysimpleclass."
varanotherProperty:Int=69105
funcadjust(){
simpleDescription+="Now100%adjusted."
}
}
vara=SimpleClass()[6]
a.adjust()
letaDescription=a.simpleDescription
structSimpleStructure:ExampleProtocol{
varsimpleDescription:String="Asimplestructure"
mutatingfuncadjust(){
simpleDescription+="(adjusted)"
}
}
varb=SimpleStructure()
b.adjust()
letbDescription=b.simpleDescription
写一个实现这个接口的枚举。
注意声明SimpleStructure时候mutating关键字用来标记一个会修改结构体的方法。SimpleClass的声明
不需要标记任何方法因为类中的方法经常会修改类。
使用extension来为现有的类型添加功能，比如添加一个计算属性的方法。你可以使用扩展来给任意类型
添加协议，甚至是你从外部库或者框架中导入的类型。
extensionInt:ExampleProtocol{
varsimpleDescription:String{
return"Thenumber(self)"
}
mutatingfuncadjust(){
self+=42
}
}
7.simpleDescription
给Double类型写一个扩展，添加absoluteValue功能。
你可以像使用其他命名类型一样使用接口名――例如，创建一个有不同类型但是都实现一个接口的对象集
合。当你处理类型是接口的值时，接口外定义的方法不可用。
letprotocolValue:ExampleProtocol=a
protocolValue.simpleDescription
//protocolValue.anotherProperty//Uncommenttoseetheerror
即使protocolValue变量运行时的类型是simpleClass，编译器会把它的类型当做ExampleProtocol。这表
示你不能调用类在它实现的接口之外实现的方法或者属性。

泛型

在尖括号里写一个名字来创建一个泛型函数或者类型。
funcrepeat<ItemType>(item:ItemType,times:Int)->ItemType[]{[6]
varresult=ItemType[]()
foriin0..<times{
result+=item
}
returnresult
}
repeat("knock",4)
你也可以创建泛型类、枚举和结构体。
//ReimplementtheSwiftstandardlibrary'soptionaltype
enumOptionalValue<T>{
caseNone
caseSome(T)
}
varpossibleInteger:OptionalValue<Int>=.None
possibleInteger=.Some(100)
在类型名后面使用where来指定一个需求列表――例如，要限定实现一个协议的类型，需要限定两个类型
要相同，或者限定一个类必须有一个特定的父类。
funcanyCommonElements<T,UwhereT:Sequence,U:Sequence,T.GeneratorType.Element:
Equatable,T.GeneratorType.Element==U.GeneratorType.Element>(lhs:T,rhs:U)->Bool{
forlhsIteminlhs{
forrhsIteminrhs{
iflhsItem==rhsItem{
returntrue
}
}
}
returnfalse
}
anyCommonElements([1,2,3],[3])
修改anyCommonElements函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。
简单起见，你可以忽略where，只在冒号后面写接口或者类名。<T:Equatable>和<TwhereT:Equatable>是等价的。

爱华网本文地址 » http://www.aihuau.com/a/8103220103/16205.html