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