Swift初探

?Swift初探

Xcode 7.2

下面swift一些基本的语法。把这些代码写下来，发现swift和一些语言很像，比如javascript和scala。如果对这些语言比较熟悉的话，一看代码就会懂。

总的来说swift的语法还是比较fashion。好评～～～

//:Playground-noun:aplacewherepeoplecanplay

importUIKit

varstr="Hello,playground"

letname="helloworld"

//编译器会自动推断类型,该类型是Int
letimplicitInt=70

//编译器会自动推断类型,该类型是double
letimplicitDouble=10.0

//定义一个常量，并指定类型为double
letexplicitDouble:Double=70

letheight:Float=5


letlabel="thewidthis"

letwidth=90

//值永远不会被隐式转换为其他类型，这里使用String显式转换一个字符串
letwidthLable=label+String(width)

print(widthLable)

letapples=3

letoranges=5


//(apples)是一种简单的方式来转换字符串
letappliSummary="Ihave(apples)apples;"

letfruitSummary="Ihave(apples+oranges)piecesoffruits;"


//创建一个数组
letshoplist=["catfish","water","tulips","bluepaint"];

//使用[String]表明是一种数组类型
varshoppingList:[String]=["Eggs","Milk"]

//使用下标来访问数组元素
print(shoplist[1])

//创建一个空数组
letemptyArray=[];
print(emptyArray)

//创建一个空的数组
letemptyStringArray=[String]()
print(emptyStringArray)


letindividualScores=[12,12,13,25]

varteamScore=0

//swift中基本的for循环控制流
forscoreinindividualScores{
ifscore>13{
teamScore+=3
}else{
teamScore+=1
}
}

print(teamScore)


//使用？表示该变量的值是可选的
varoptionalString:String?="hello"
optionalString=nil
varoptionalName:String?=nil

vargreeting="Hello!"


//如果变量的可选值是nil,条件会判断为false,大括号中的代码会被跳过。如果不是nil,//会将值赋给let后面的常量,这样代码块中就可以使用这个值了。
ifletname=optionalName{
greeting="Hello,(name)"
}else{
greeting="Helloeveryone"
}



//switch语法
letvegetable="redpepper"

switchvegetable{
case"celery":
letvegetableComment="Addsomeraisinsandmakeantsonalog."
case"cucumber","watercress":
letvegetableComment="Thatwouldmakeagoodteasandwich."
caseletxwherex.hasSuffix("pepper"):
letvegetableComment="Isitaspicy(x)?"
default:
letvegetableComment="Everythingtastesgoodinsoup."
}

letvegetable2="watercress"


//switch必须有一个default
switchvegetable2{
case"celery":
letvegetableComment="Addsomeraisinsandmakeantsonalog."
case"cucumber","watercress":
letvegetableComment="Thatwouldmakeagoodteasandwich."
caseletxwherex.hasSuffix("pepper"):
letvegetableComment="Isitaspicy(x)?"
default:
letvegetableComment="Everythingtastesgoodinsoup."
}


//定义字典数组
letinterestingNumbers=[
"prime":[2,3,5,7],"fibonacci":[1,1,2,8],"square":[1,4,9,16,25]
]

varlargest=0


//遍历数组
//字典类型的元素需要两个变量来表示每个键值对
for(kind,numbers)ininterestingNumbers{
fornumberinnumbers{
ifnumber>largest{
largest=number
}
}
}

print(largest)


//1...3是ClosedRangeOperator=>123
varsum=0
foriin1...3{
sum+=i
}
print(sum)

sum=0

//1..<3是Half-OpenRangeOperator=>12
foriin1..<3{
sum+=i
}
print(sum)



//函数的定义
//使用右向箭头表示返回值
funcgreet(name:String,day:String)->String{
return"Hello(name),todayis(day)";
}

greet("LiYi",day:"2016-1-1")
greet("world",day:"2016-1-1")


//函数返回类型为元组
funcgetGasPrices()->(Double,Double,Double){
return(3.56,3.23,3.21)
}

getGasPrices()


//swift的可变参数列表
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()



//=========函数作为返回值

//定义一个函数，返回值是一个函数类型
//函数类型是(Int->Int)，表示该函数接收一个入参Int，返回值是Int
funcmakeIncrementer()->(Int->Int){
funcaddOne(number:Int)->Int{
return1+number
}
returnaddOne
}

varincrement=makeIncrementer()

increment(1)


//定义一个函数makeAdd，其返回值也是一个函数类型，
//(Int,Int)->Int表示返回类型，是一个接收两个Int参数，返回Int的函数
funcmakeAdd()->(Int,Int)->Int{

funcadd(a:Int,b:Int)->Int{
returna+b
}

returnadd;
}

varadd=makeAdd()

add(1,2)


//=========函数作为参数
funchasAnyMatches(list:[Int],condition:Int->Bool)->Bool{
foriteminlist{
ifcondition(item){
returntrue;
}
}
returnfalse
}

funclessThanTen(number:Int)->Bool{
returnnumber<10
}


hasAnyMatches([20,19,7,12],condition:lessThanTen)


varnumbers=[20,12]

//(number:Int)->Int是一个匿名闭包的入参和返回值
//使numbers数组中的元素都变成了三倍
numbers.map(
{
(number:Int)->Intin
letresult=3*number
returnresult
}
)


//map函数
numbers.map(
{
(number:Int)->Intin
ifnumber%2==0{
letresult=3*number
returnresult
}else{
return0
}
}
)

//filter函数
numbers.filter({
(number:Int)->Boolin
returnnumber%2==0
})



//类的定义
classShape{
//定义一个常量
lethappy=true
//定义一个变量
varnumberOfSides=0
funcsimpleDscription()->String{
return"Ashapewith(numberOfSides)sides"
}

functoHappy()->Bool{
returnhappy
}
}



//创建类的实例
varshape=Shape()

shape.numberOfSides=10

shape.simpleDscription()

shape.toHappy()


//定义类的构造函数
classNamedShape{

varnumberOfSides:Int=0

varname:String

//定义类的构造函数
init(name:String){
self.name=name
}

funcsimpleDescription()->String{
return"Ashapewith(numberOfSides)sides"
}
}

varnamedShape=NamedShape(name:"helloworld")

namedShape.name
namedShape.simpleDescription()


//继承类的继承
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.12,name:"mytestsquare")
test.area()
test.simpleDescription()



classEquilateralTriangle:NamedShape{

varsideLength:Double=0.0

init(sideLength:Double,name:String){

self.sideLength=sideLength
super.init(name:name)
numberOfSides=3
}


//定义属性的setter和getter方法
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



//定义一个类，类中有一个函数
classCounter{
varcount:Int=0

//该方法的第二个参数有两个参数名
//第一个参数名是numberOfTimes，给方法的外部调用者使用
//第二个参数名是times，给方法内部使用
funcincrementBy(amount:Int,numberOfTimestimes:Int){
count+=amount*times
}
}


//创建一个实例
varcounter=Counter()
counter.incrementBy(2,numberOfTimes:7)



//定义一个枚举
//枚举原始值的类型是Int,所以你只需要设置第一个原始值。
//剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。
enumRank:Int{

//指定该枚举实例的原始值为1
caseAce=1
caseTwo,Three,Four,Five,Six,Seven,Eight,Nine,Ten
caseJack,Queen,King

funcsimpelDescription()->String{

switchself{
case.Ace:
return"ace"
case.Jack:
return"jack"
case.Queen:
return"queue"
case.King:
return"king"
default:
returnString(self.rawValue)
}
}
}


letace=Rank.Ace

//调用rawValue方法
letaceRawValue=ace.rawValue
ace.simpelDescription()



//定义不需要原始值的枚举
enumSuit{
caseSpades,Hearts,Diamonds,Clubs

funcsimepleDescription()->String{

switchself{
case.Spades:
return"spades"
case.Hearts:
return"hearts"
case.Diamonds:
return"diamonds"
case.Clubs:
return"clubs"
}
}
}


lethearts=Suit.Hearts
letheartsHashValue=hearts.hashValue
letheartDescription=hearts.simepleDescription()


//创建一个结构体
structCard{
varrank:Rank
varsuit:Suit

funcsimpleDescription()->String{
return"The(rank.simpelDescription())of(suit.simepleDescription())"

}
}

//使用struct来创建一个结构体。
//结构体和类有很多相同的地方,比如方法和构造器。
//它们结构体之间最大的一个区别就是,结构体是传值,类是传引用。
letthreeOfSpades=Card(rank:.Three,suit:.Spades)
letthreeOfSpadesDescription=threeOfSpades.simpleDescription()



//该枚举也不需要原始值

//一个枚举成员的实例可以有实例值。
//相同枚举成员的实例可以有不同的值。
//创建实例的时候传入值即可。
//实例值和原始值是不同的:枚举成员的原始值对于所有实例都是相同的
//而且你是在定义枚举的时候设置原始值。
enumServerResponse{
caseResult(String,String)
caseError(String)
}


//创建一个枚举值的实例
letsuccess=ServerResponse.Result("6:00am","8:09pm")
//创建一个枚举值的实例
letfailure=ServerResponse.Error("outofcheese")


//success是一个枚举实例
switchsuccess{
caselet.Result(sunrise,sunset):
letserverResponse="sunriseisat(sunrise)andsunsetisat(sunset)"
caselet.Error(error):
letserverResponse="Failure...(error)"
}



//============接口和扩展
//使用protocol来声明一个接口
protocolExampleProtocol{
varsimpleDescription:String{get}

mutatingfuncadjust()
}

//类、枚举和结构体都可以实现接口
classSimpleClass:ExampleProtocol{
varsimpleDescription:String="averysimpleclass"
varanotherProperty:Int=123

funcadjust(){
simpleDescription+="now100%adjusted"
}
}

vara=SimpleClass()
a.adjust()
letdesc=a.simpleDescription



//该结构体实现协议
structSimpleStructure:ExampleProtocol{
varsimpleDescription:String="averysimplestructure"
//mutating关键字用来标记一个会修改结构体的方法
mutatingfuncadjust(){
simpleDescription+="(adjusted)"
}
}


//枚举继承协议
enumSimpleEnum:ExampleProtocol{
caseFirst(String)
caseSecond(String)

//属性的get方法
varsimpleDescription:String{
get{
switchself{
caselet.First(text):
returntext
default:
return"hi"
}
}

}

mutatingfuncadjust(){
print("description:hi")
}
}

vars=SimpleEnum.First("dingding")
s.simpleDescription
s.adjust()




//使用extension来为现有的类型添加功能,比如添加一个计算属性的方法。
//你可以使用扩展来给任意类型添加协议
//甚至是你从外部库或者框架中导入的类型
extensionInt:ExampleProtocol{
varsimpleDescription:String{
return"thenumber(self)"
}

mutatingfuncadjust(){
self+=42
}
}

7.simpleDescription



//定义一个泛型函数
funcrepeatItem<T>(item:T,times:Int)->[T]{

//定义一个空的数组
varresult=[T]()

foriin0...times{
//数组元素的追加
result.append(item)
}

returnresult
}

repeatItem(3,times:4)

============END============

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!