Swift基础语法

import Foundation

//1.字符串和字符

var sampleStrd:String

var keyNote = "someNote"

if keyNote.isEmpty{

    println(keyNote)

}

let gameName = "2048"

println("hello my program name is
\(gameName)")

var iRadius = 6

println("The circle's area is
\(Double(iRadius)*3.1415926)")

//在Swift中便是字符使用characters类型

var doller:Character =
"$"

//统计字符串中的字符个数要使用countElements函数

let LogTitle =
"Swift is a new object-oriented programming language fir iOS and OS X development."

println("LogTitle has
\(countElements(LogTitle)) characters")

//2.字符串和字符的常用操作

//+连接操作符

let rightName = "Ney"

let leftName = "mar"

var hisName =
leftName + rightName

println(hisName)

//== 判断字符串是否相等  !=
是否不等

let str1 = "qwer"

let str2 = "qwer"

if str1 ==
str2{

    println("These two strings are full equal")

}

//String类型的hasPrefix/hasSuffix检查字符串是否有特定的前缀/后缀

var ExceptionLogs = [

    "Warning: Login In System with no password Check By DB",

    "Warning: View customer list without DB",

    "Error: You have no Jurisdiction",

    "Warning: A Operate is no effect",

    "Error: Illicit close program"]

var warningCount =
0

var errorCount = 0

    //for in 遍历字符串日志数组

for atitle
in ExceptionLogs{

    if atitle.hasPrefix("Warning"){

        warningCount++

    }

    if atitle.hasPrefix("Error"){

        errorCount++

    }

}

println("Warning have
\(warningCount) and error have
\(errorCount).")

//uppercaseString 和 lowercaseString
字符串大小写

let s1 = "ABCDE"

let s2 = "abcde"

var s3 = s1.lowercaseString

if s3 ==
s2 {

    println("The String is equal ")

}

//3.可选 optional

//声明

var roundValue: Int?

println("The round value is
\(roundValue?.description)")

//真正显式的声明

var optionalValue:Optional<Int> =
1

//可选绑定

if var MaxValue =
optionalValue{

    MaxValue += 1

    println("The convert Value is
\(MaxValue)")

}

    //若确定某个可选类型的变量肯定包含值的时候,可以使用名称紧跟!的方式强制获取其中的值,而忽略判断的步骤,但是如果没有值,使用强制解析可选会异常

    var opValue: Int?

    //println("\(opValue!)")//这样强制解析就会崩溃

//可选运算符 ?? a??b:运算符前的可选值a为nil时返回操作数b的值,a不为nil时返回a的值

var succedCreateClass:Int?

var feedBack = 1

var returnValue =
succedCreateClass ?? feedBack

println(returnValue)

//4.元组

//匿名元组

let (appType,appName)=("game","2048")

//匿名元组可以通过其元素名来访问

println("I have
\(appType),it's names
\(appName)")

//标准的元组

let myProject = (oneElement:"game",twoElement:"2048")

println("Project Type is
\(myProject.oneElement)")

println("Project name is
\(myProject.twoElement)")

//5.类型别名

//为Int8取一个别名

typealias ShortInteger =
Int8

//这个时候var myInt:ShortInteger等价于var myInt:Int8

var myInt:
ShortInteger

//6.断言

//在Debug阶段.使用触发异常并提示错误的方式,可以尽量有效地消灭有可能出现的bug

//在Swift中可以调用全局的assert函数来增加一个断言,这里全局的意思是你可以将断言写在程序的任何一个地方

var useDate = -1

assert(useDate <=
0, "数据大于0,错误")
//若<=0,符合条件继续运行;若>0,提出异常:数据大于0
错误

//7.运算符

//在Swift中%为求余运算,符号会和第一个操作数一样.并且可以对浮点数进行求余

var tmp1 = -12 %
5

println(tmp1.description)//输出-2

var tmp2 = 13 % -6

println(String(tmp2))//输出1

var tmp3 = 11.5 %
5

println(tmp3)//输出1.5

var tmpRandom = arc4random() %
100

println(tmpRandom)//输出1~100的随机数

//=== !== 恒等
不恒等 判断两个对象是否引用同一个类实例

//区间运算符 a...b
闭区间 a..<b 半闭半开区间  

for iCount in
512...1024{

    if (iCount % 2) ==
0{

        //println("the cow is \(iCount)")

    }

}

var fruts = ["apple","orange","belaner"]

let icount = fruts.count

for i in
0..<icount{

    println("第\(i+1)个水果是\(fruts[i])")

}

//8.高级运算符

//按位与& 
按位或 按位异或

//溢出运算符  &+  &-  &*  &/  &%

var a = 1

//var b = a/0  当使用的除数或求余数为0时,是错误的

var d = a &/
0

var e = a &%
0//使用溢出运算符来避免错误

println(d)

println(e)

//运算符重载

//举例

struct CenterPointer{

    var x = 0, y =
0

}

 //重载一个中置 +
运算符 计算了两个点相加

func + (left:CenterPointer, right:CenterPointer) ->
CenterPointer{

    return CenterPointer(x: left.x + right.x, y: left.y + right.y)

}

let zPointer = CenterPointer(x:2, y:3)

let yPointer = CenterPointer(x:5, y:3)

let xPointer =
zPointer +
yPointer

println(xPointer.x,xPointer.y)

//重载一个前置或后置运算符,就需要在func
钱加上prefix
或 postfix属性

//为CenterPointer实现坐标取反运算

prefix func - (fPointer:CenterPointer) ->
CenterPointer{

    return CenterPointer(x: -fPointer.x, y: -fPointer.y)

}

let qPointer = -zPointer

println(qPointer.x,qPointer.y)

//组合赋值运算符

//把运算符的左参数设置成inout类型,从而使运算符函数体内部可以直接修改它的值

//实现结构体的加法赋值运算符

func += (inout left:CenterPointer, right:CenterPointer){

    left = left + right

    println(left.x)

}

//qPointer += qPointer //有问题

//9.自定义运算符

//自定义一个运算符通常需要先声明再实现其功能,声明需要使用operator关键字

//先定义运算符

prefix operator +++ {}

//"+++"是实现自加的基础上再加1

prefix func +++ (inout Pointer:CenterPointer)
-> CenterPointer{

    Pointer += Pointer

    Pointer += CenterPointer(x:1,y:1)

    return Pointer

}

var tPointer = CenterPointer(x:
1, y: 3)

var ePointer = +++tPointer

println(ePointer.x.description,ePointer.y.description)//(3,7)

//指定运算符的优先级(precedence :默认值为100)和结合性(associativity:left right none)

infix operator +- {associativity left precedence
140}

func +- (left:CenterPointer, right:CenterPointer) ->
CenterPointer{

    return CenterPointer(x: left.x + right.x, y: left.y - right.y)

}

let Pointer1 = CenterPointer(x:
2, y: 5)

let Pointer2 = CenterPointer(x:
3, y: 6)

let Pointer3 =
Pointer1 +-
Pointer2

println(Pointer3.x,Pointer3.y)//(5,-1)

//10.数组

var emptyArray = [String]()
//创建数组标准格式

var ExceptionTypes = ["none","warning","error"]
//省略类型的数组声明

ExceptionTypes[0] =
"it's safy"
//访问并修改其中的元素

var Arrayname = Array<String>()
//最正式的声明格式

//声明一个空数组

var BrazilTeamMembers = [String]()

BrazilTeamMembers.append("six")//向数组中添加一个元素

BrazilTeamMembers.insert("one", atIndex:
0)//指定位置插入数组元素

//BrazilTeamMembers += "seven" //通过+=添加元素

BrazilTeamMembers.isEmpty
//是否为空

BrazilTeamMembers[1] =
"two"
//为下表为1的元素赋值为two

BrazilTeamMembers.count
//数组元素的个数

BrazilTeamMembers.removeAtIndex(1)//删除下标为2的元素

BrazilTeamMembers.removeLast()//删除最后一个元素

BrazilTeamMembers.removeAll(keepCapacity:
true)//删除所有元素,但保留大小

var addStringArr =
ExceptionTypes + BrazilTeamMembers
// + 来组和两个相同类型的数组

var multArr = Array<Array<Int>>()
//标准声明一个二维数组

//11.字典

var myDictionaries = [

    "apptype":"2dgame",

    "name":2048,

    "company":"Swift In Action"

]

myDictionaries["name"] =
"2048 Update"//修改

myDictionaries.updateValue(4096, forKey:
"name")//修改

myDictionaries.removeValueForKey("company")//删除

myDictionaries.keys//字典的key集合

myDictionaries.values
//value集合

println(myDictionaries)

//12.结构体

struct BookInfo{

    var ID:Int =
0

    var Name:String =
"Default"

    var Author:String =
"Default"

    var RootType:String =
"Default"

    var SubtType:String =
"Default"

    var Position:String =
"0-0-0-0"

}

//调用默认构造器创建一个结构体实例

var ProgramGuide:BookInfo

var BeautyMath = BookInfo(ID:
0021, Name: "The Beauty Math", Author:
"JunMu", RootType:
"It", SubtType: "Math", Position:
"E6-3-7-687")

//13.枚举

//定义一个枚举最好
大写枚举首字母

enum PointRect{

    case top

    case bottom

    case left

    case right

}

//14 if  swith

//switch中每个case块必须包含至少一条语句;switch语句不会同时匹配大写字母和小写字母

//switch语句也支持值绑定

var anotherPoint = (2,2)

switch anotherPoint{

case (var x,
0): //(_,0)

    x--

    println("\(x) on the x-axis")

case (0,
var y): //(0,_)

    y++

    println("\(y) on the y-axis")

case let (x,y)where x == y:
//当x等于y时执行此case块中的语句

    println("(\(x),\(y)) is on the line x == y")

case let (x,y):
//(_,_)

    println("point at (\(x),\(y))")

}

//for

for chare in
"Hello World!"{

    println(chare)

}

//15控制转向语句

//continue 通知一个循环体立刻停止本次循环,直接回到循环条件判断,重新开始下一次循环

let useInput =
"To write the code for class, you must provide three chunks or sections of code."

var OutputCount =
0

for chare in
useInput{

    switch chare{

        case
"a","e","i","o","u":

        //跳出本次循环,直接回到条件判断语句处

        continue

    default:

        OutputCount++

    }

}

println(OutputCount)//55个非元音字符

//break

for chare in
useInput{

    switch chare{

        case
"a","e","i","o","u":

        //跳出整个循环体

        break

    default:

        OutputCount++

    }

}

println(OutputCount)//110

//fallthrough 使switch中case代码继续连接到下一个case执行

//标签语句 Labeled Statements
显示的指出需要跳出的是哪一层循环或switch结构

//为了实现这个目的,使用标签来为循环体或者switch代码块打上标记,当需要使用break或者continue时,带上这个标签就可以控制该标签代表对象的中断或者跳出

var iarea = 100

var compeCount = 0

var primeCount = 0

var i = 2

var j = 2

var NumType = ""

var bFinded = true

mainLoop : while i <
100 {

    bFinded = false

    NumType = ""

    inLoop : while
j < i-1 {

        if i%j ==
0{

            NumType =
"compe"

            bFinded =
true

            break inLoop

        }

        j++

    }

    if !bFinded {

        NumType =
"prime"

    }

    switch
NumType{

        case "compe":compeCount++

        case "prime":primeCount++

    default:break mainLoop

    }

    i++

}

println("1-\(iarea)的合数有\(compeCount)个.")

println("1-\(iarea)的素数有\(primeCount)个.")

//16.函数

func isSell (commodityName:String) ->
Bool{

    return
true

}

if isSell("33"){

    

}

//在实际参数前加上外部形参标签,起到了解释作用

func addString(s1:String, sSex s2:String, sAge s3:String) ->
String{

    return
"Name is " + s1 + " sex is " + s2 +
" age is " + s3

}

println(addString("lily", sSex:
"girl", sAge: "18"))

//用#号作为参数名称的前缀,从而告诉swift,使用名称相同的本地形参名称和外部形参名称

func addString2(#sName:
String, #sSex: String, #sAge:
String) -> String{

    return "Name is " + sName +
" sex is " + sSex +
" age is " + sAge

}

println(addString2(sName:
"sony", sSex: "boy", sAge:
"19"))

//在参数类型后加 ...
声明可变形参,可变形参是指可接受零个或多个指定类型值的形参

func addDoubles(numbers:Double...) ->
Double{

    var count: Double =
0

    for number in numbers{

        count += number

    }

    return count

}

//函数的类型 (String,String,String)->String

//函数的嵌套

func myFunction(#sName:String, #sScore:Int) ->
String{

    func compScore(iScore:Int) ->
String{

        return String(iScore *
2)

    }

    var tmpa = ""

    tmpa = compScore(sScore)

    return
"Name is " + sName + "and Score is " + tmpa

}

//17闭包

//闭包表达式的一般形式为

/*

{

    (parameters) -> returnType in

    statements

}

*/

let names = ["Lily",
"Anna", "Duty",
"Poly", "Gray"]

//数组为String类型,因此排序闭包为(String, String)->Bool类型的函数

func compareName(s1:
String, s2: String) ->
Bool{

    return s1 < s2

}

//由于函数也是一种特殊的闭包,所以在这里compareName函数也可作为数组排序的闭包类型参数

var sortedArray =
names.sorted(compareName)

//与compareName函数对应的匿名闭包表达式版本的代码

var sortedArray2 =
names.sorted({ (s1:String, s2:String) ->
Bool in

    return s1 < s2

})

//打印

var arrayValue = "array value:"

for str in
sortedArray{

    arrayValue += (str +
",")

}

println(arrayValue)

var sortedArray3 =
sorted(names, { (s1:String, s2:String) ->
Bool in

    return s1 > s2

})

//trailing闭包