swift学习文档(笔记)
Swift是供iOS和OSX应用编程的新编程语言，基于C和Objective-C，而却没有C的一些兼容约束。Swift采用了安全的编程模式和添加现代的功能来是的编程更加简单、灵活和有趣。界面则基于广受人民群众爱戴的Cocoa和CocoaTouch框架，展示了软件开发的新方向。
变量与常量
变量定义使用var，常量使用let，类型安全，有自动类型推导，注意赋值的=号两边必须有空格。变量和常量名是可以几乎所有字符，这些都非常像javascript。中文编程一下牛逼了。
vara=123//a为Int letb="helo"//b为String var猫叫＝"喵"
数字
- 十进制
- 二进制0b101
- 八进制0o5
- 十六进制0x5
比较长的数字间可以加上_用来提高程序的可读性，比如0_0其实就是0，_线不能加在开头
布尔类型
true和false，流程控制if的时候，判断语句返回必须是一个Bool值，比如：
leti=1
ifi{
//编译报错
}
这样就可以通过
ifi==1{
}
它不像js里会有自动类型转换
类型别名
给现在的类型添加别名，同样可以提高程序的可读性，如
typealias音频采样=UInt16
可以在别的地方使用var已发现的最大振幅=音频采样.min
元组
它可以是一组值，这些值不必是相同的类型，例如，定义我自己：
varjserme=("183cm",26,"76kg")
可以像数组一样访问
println(jserme.0)//返回183cm
元组还原为独立的变量或者常量
letjserme=("183cm",26,"76kg")
let(身高,年龄,体重)=jserme
println("身高是\(身高)")
也可以给每个值命名（这就像在JS里把数组搞成了对象了。。。）
letjserme=(身高:"183cm",年龄:26,体重:"76kg")
println("身高是\(jserme.身高)")
字符串
字符串字面量只能用""来定义，String本质上是Character的有序集合。
forcharin"一言既出"{
println(char)
}
/*
一
言
既
出
*/
字面量与判断是否为空
var字符串="我是字符串"
var空字符串=""
if空字符串.isEmpty{
println("这是一个空的字符串")
}
if空字符串==""{
println("这是一个空的字符串")
}
字符串实例有两个方法hasPrefix与hasSuffix，如：
var成语数组=[
"一言既出",
"一触即发",
"一呼百应",
"一槌定音",
"一无所有",
"一生一世",
"一见钟情"
]
varcount=0
for成语in成语数组{
if(成语.hasPrefix("一")){
count++
}
}
println(count)//输出7
与js一样，string也是传值引用，下面的两个变量的修改不会影响到彼此
var一串="我是字符串一"
var二串=一串
二串="我是字符串二"
println("字符串一:\(一串)，字符串二:\(二串)")
区间运算符
闭区间使用a...b，从a到b，包含a与b，半区间a..b，从a到b，不包含b，例如：
var成语数组=[
"一言既出",
"一触即发",
"一呼百应"
]
foriin0..成语数组.count{
println("第\(i)个成语是:\(成语数组[i])")
}
//这里如何使用...会报错，因为成语数组[3]是没有值的
两种集合,array和dictionaries
相对于js对数组和对象成员松散的要求，swift要求数组和dictionaries里成员类型必须一致
var购物清单:String[]=["鸡蛋","牛奶"] //也可以是下面的这样 //var购物清单=["鸡蛋","牛奶"]
数组的修改可以使用append方法或者+=
var购物清单=["鸡蛋","牛奶"]
购物清单.append("苹果")
购物清单+="草莓"
println("\(购物清单)")//[鸡蛋,牛奶,苹果,草莓]
数组的获取，可以通过索引，也可以通过区间运算符
var购物清单=["鸡蛋","牛奶"]
println("\(购物清单[0])")//鸡蛋
println("\(购物清单[0..1])")//[鸡蛋]
println("\(购物清单[0...1])")//[鸡蛋,牛奶]
println("\(购物清单[0...2])")//[鸡蛋,牛奶,]
dictionaries的定义
varairports:Dictionary<String,String>=["TYO":"Tokyo","DUB":"Dublin"] //也可以简化为 //varairports=["TYO":"Tokyo","DUB":"Dublin"]
它的修改与读取使用[],而不能使用.
airports["BJ"]="Beijin"
控制语句
如前面的几个例子所示，控制语句的条件不像js有小括号
forvarindex=0;index<3;index++{
println("indexis\(index)")
}
//indexis0
//indexis1
//indexis2
函数
函数的声明与调用：
funcsayHello(personName:String)->String{
letgreeting="Hello,"+personName+"!"
returngreeting
}
println(sayHello("jserme"))
无返回的函数，其实质是返回一个Void，它等同于一个空的元组()
多返回值的函数与默认参数：
funcinfo(word:String="aha")->(length:Int,containA:Bool){
varcontainA=false
forcharinword{
if(char=="a"){
containA=true
break
}
}
return(word.utf16count,containA)
}
println(info(word:"波波"))//(2,false)
println(info())//(3,true)
便于阅读的外部参数名，在参数定义之前，与参数定义以空格隔开，如下面的多个参数
funcjoin(strings1:String,toStrings2:String,withJoinerjoiner:String)
->String{
returns1+joiner+s2
}
//调用的时候
join(string:"hello",toString:"world",withJoiner:",")
//returns"hello,world"
参数名与外部参数名一致，可以给参数名加#标识：
funccontainsCharacter(#string:String,#characterToFind:Character)->Bool{
forcharacterinstring{
ifcharacter==characterToFind{
returntrue
}
}
returnfalse
}
letcontainsAVee=containsCharacter(string:"aardvark",characterToFind:"v")
//containsAVeeequalstrue,because"aardvark"containsa"v"
函数的参数是常量，不可以修改，如果在函数内修改，变量定义前加var
funcalignRight(varstring:String,count:Int,pad:Character)->String{
letamountToPad=count-countElements(string)
for_in1...amountToPad{
string=pad+string
}
returnstring
}
letoriginalString="hello"
letpaddedString=alignRight(originalString,10,"-")
//paddedStringisequalto"-----hello"
//originalStringisstillequalto"hello"
如果想在函数内修改传入的参数，可以使用inout关键字来标识，传入的参数需要前缀&，这内部实现应该是指针。
funcswapTwoInts(inouta:Int,inoutb:Int){
lettemporaryA=a
a=b
b=temporaryA
}
varsomeInt=3
varanotherInt=107
swapTwoInts(&someInt,&anotherInt)
println("someIntisnow\(someInt),andanotherIntisnow\(anotherInt)")
//prints"someIntisnow107,andanotherIntisnow3"
函数类型，可以像js一样使用函数作为参数及返回值
funcaddTwoInts(a:Int,b:Int)->Int{
returna+b
}//函数类型为(Int,Int)->Int
funcmultiplyTwoInts(a:Int,b:Int)->Int{
returna*b
}//函数类型为(Int,Int)->Int
//接收名为mathFunction的函数类型
funcprintMathResult(mathFunction:(Int,Int)->Int,a:Int,b:Int){
println("Result:\(mathFunction(a,b))")
}
printMathResult(addTwoInts,3,5)
//prints"Result:8"
//返回函数类型
funcstepForward(input:Int)->Int{
returninput+1
}
funcstepBackward(input:Int)->Int{
returninput-1
}
funcchooseStepFunction(backwards:Bool)->(Int)->Int{
returnbackwards?stepBackward:stepForward
}
varcurrentValue=3
letmoveNearerToZero=chooseStepFunction(currentValue>0)
//moveNearerToZeronowreferstothestepBackward()function
闭包
函数与它包含的上下文的变量在一起称为闭包。如sort函数:
letnames=["Chris","Alex","Ewa","Barry","Daniella"]
funcbackwards(s1:String,s2:String)->Bool{
returns1>s2
}
varreversed=sort(names,backwards)
println(reversed)
//reversedisequalto["Ewa","Daniella","Chris","Barry","Alex"]s
使用闭包可以表示为:
letnames=["Chris","Alex","Ewa","Barry","Daniella"]
varreversed=sort(names,{(s1:String,s2:String)->Boolin
returns1>s2
})
println(reversed)
//reversedisequalto["Ewa","Daniella","Chris","Barry","Alex"]
也可以简化为
letnames=["Chris","Alex","Ewa","Barry","Daniella"]
varreversed=sort(names,{s1,s2ins1>s2})
println(reversed)
枚举
通过下面的语法声明
enumBarcode{
caseUPCA(Int,Int,Int)=(1,2,3)
caseQRCode(String)="hello"
}
类与结构体
推荐使用首字母大写来命名
structResolution{
varwidth=0
varheigth=0
}
classVideoMode{
varresolution=Resolution()
varinterlaced=false
varframeRate=0.0
varname:String?
}
生成实例：
letsomeResolution=Resolution() letsomeVideoMode=VideoMode()
属性访问与修改，使用.语法：
println("ThewidthofsomeVideoModeis\(someVideoMode.resolution.width)")
someVideoMode.resolution.width=12880
println("ThewidthofsomeVideoModeisnow\(someVideoMode.resolution.width)")
结构体有自动成员初始化器，类实例没有：
letvga=resolution（width:640,heigth:480）
结构体与枚举都是值类型，类是引用类型
对于引用了同一个实例的值，可以使用===和!==来进行判断
延迟属性,@lazy，设置在调用的时候才初始化特定的属性
classDataImporter{
/*
DataImporter是一个将外部文件中的数据导入的类。
这个类的初始化会消耗不少时间。
*/
varfileName="data.txt"
//这是提供数据导入功能
}
classDataManager{
@lazyvarimporter=DataImporter()
vardata=String[]()
//这是提供数据管理功能
}
letmanager=DataManager()
manager.data+="Somedata"
manager.data+="Somemoredata"
//DataImporter实例的importer属性还没有被创建
类、结构体、枚举都可以通过设置setter与getter来
structAlternativeRect{
varorigin=Point()
varsize=Size()
varcenter:Point{
get{
letcenterX=origin.x+(size.width/2)
letcenterY=origin.y+(size.height/2)
returnPoint(x:centerX,y:centerY)
}
set{//这里setter没有定义表示新值的参数名，则可以使用默认名称newValue
origin.x=newValue.x-(size.width/2)
origin.y=newValue.y-(size.height/2)
}
}
}
只读属性去掉get与set
属性监视可以使用willset和didset来处理
类型属性有点像静态变量，以static关键字声明
structSomeStructure{
staticvarstoredTypeProperty="Somevalue."
staticvarcomputedTypeProperty:Int{
//这里返回一个Int值
}
}
下标
类、结构体、枚举都可以有下标，它有像给它们增加了一个快捷方式，如下：
structTimesTable{
letmultiplier:Int
subscript(index:Int)->Int{
returnmultiplier*index
}
}
letthreeTimesTable=TimesTable(multiplier:3)
println("3的6倍是\(threeTimesTable[6])")
//输出"3的6倍是18"
继承
定义一个类
classVehicle{
varnumberOfWheels:Int
varmaxPassengers:Int
funcdescription()->String{
return"\(numberOfWheels)wheels;upto\(maxPassengers)passengers"
}
init(){
numberOfWheels=0
maxPassengers=1
}
}
继承类
classBicycle:Vehicle{
init(){
super.init()
numberOfWheels=2
}
}
重写属性与方法
classCar:Vehicle{
varspeed:Double=0.0
overridevarspeed:Double{
get{
returnsuper.speed
}
set{
super.speed=min(newValue,40.0)
}
}
init(){
super.init()
maxPassengers=5
numberOfWheels=4
}
overridefuncdescription()->String{
returnsuper.description()+";"
+"travelingat\(speed)mph"
}
}
防止重写，在方法与属性前加关键字@final，编译时会出错
构造函数
声明里可以写多个init，这有点像重载
structCelsius{
vartemperatureInCelsius:Double=0.0
init(fromFahrenheitfahrenheit:Double){
temperatureInCelsius=(fahrenheit-32.0)/1.8
}
init(fromKelvinkelvin:Double){
temperatureInCelsius=kelvin-273.15
}
}
letboilingPointOfWater=Celsius(fromFahrenheit:212.0)
//boilingPointOfWater.temperatureInCelsius是100.0
letfreezingPointOfWater=Celsius(fromKelvin:273.15)
//freezingPointOfWater.temperatureInCelsius是0.0”
类的析构
有些地方叫反初始化，很别扭的名字哦
classPlayer{
varcoinsInPurse:Int
init(coins:Int){
coinsInPurse=Bank.vendCoins(coins)
}
funcwinCoins(coins:Int){
coinsInPurse+=Bank.vendCoins(coins)
}
deinit{
Bank.receiveCoins(coinsInPurse)
}
}
varplayer=Player(coins:200)
player=nil//调用deinit方法
扩展
对于类、结构体、枚举，可以扩展它们的一切
classPlayer{
varage:Int
}
extensionPlayer{
funcrepetitions(task:()->()){
foriin0..self{
task()
}
}
}
协议
其实就是接口描述
protocolSomeProtocol{
varmustBeSettable:Int{getset}
vardoesNotNeedToBeSettable:Int{get}
funcsomeTypeMethod()
}
协议继承
protocolInheritingProtocol:SomeProtocol,AnotherProtocol{
//protocoldefinitiongoeshere
}
泛型
这个函数的泛型版本使用了节点类型命名（通常此情况下用字母T来表示）来代替实际类型名（如Int、String或Double）。节点类型名并不是表示T必须是任何类型，但是其规定a和b必须是同一类型的T，而不管T表示任何类型。只有swapTwoValues函数在每次调用时所传入的实际类型决定了T所代表的类型。
funcswapTwoValues<T>(inouta:T,inoutb:T){
lettemporaryA=a
a=b
b=temporaryA
}
运算符重载
这里演示重载+号运算符
structVector2D{
varx=0.0,y=0.0
}
@infixfunc+(left:Vector2D,right:Vector2D)->Vector2D{
returnVector2D(x:left.x+right.x,y:left.y+right.y)
}
- 前置运算符@prefix
- 后置运算符@postfix
- 组合赋值运算符@assignment
- 比较运算符@infix
@prefix@assignmentfunc++(inoutvector:Vector2D)->Vector2D{
vector+=Vector2D(x:1.0,y:1.0)
returnvector
}
自定义运算符
个性的运算符只能使用这些字符/=-+*%<>！&|^。~
operatorprefix+++{}
@prefix@assignmentfunc+++(inoutvector:Vector2D)->Vector2D{
vector+=vector
returnvector
}
结合性(associativity)的值默认为none,可用left,right,none，优先级(precedence)默认为100。
operatorinfix+-{associativityleftprecedence140}
func+-(left:Vector2D,right:Vector2D)->Vector2D{
returnVector2D(x:left.x+right.x,y:left.y-right.y)
}
letfirstVector=Vector2D(x:1.0,y:2.0)
letsecondVector=Vector2D(x:3.0,y:4.0)
letplusMinusVector=firstVector+-secondVector
//plusMinusVector此时的值为(4.0,-2.0)
来自：http://jser.me