Swift学习一

let 声明常量，var 声明变量

//创建一个按钮
var btn = UIButton()
btn.frame = CGRectMake(100,100,100,100)
btn.backgroundColor = UIColor.redColor()
self.view.addSubview(btn)
//创建一张图像
var imageView = UIImageView()
imageView.image = UIImage(name:"1.png")
imageView.frame = CGRectMake(100,100,100,100)
self.view.addSubview(imageView)
//字符串处理
var str1 = "123"
var str2 = "456"
var str = str1 + str2

var age = 10
var hang = 2
var str = "I have (hand) hands,(age)years old"

//字符串强转
var age = 10
var str = String(age)
var str = "(age)"

//类型
var a:Int = 10
let b:String = "123"
let a:float = 3.14
let a = 3.14

//数字的表现形式
let money = 1000_0000
let money = 1_000_000

//类型别名
typealias myInt = Int

//运算符
范围运算符 ..<   ...
for i in 0..<5
{
//0..<5 即[0,5) ...即[0,5]
println(i) i为0,1,2,3,4
}
溢出运算符 &+ &- &* &/ &%

swift中赋值运算符没有返回值，可以避免=和==的使用错误

//元组赋值
let (x,y) = (1,2)
var point = (x:10,y:20)
访问元组元素
point.x point.y
point.0 point.1
赋值
point.x = 30
明确元素类型
var person:(Int,String) = (20."123")
使用下划线忽略某个元素的值
var person = (20,"jack")
var (_,name) = person

//for循环
用到变量i
for i in 1...4{
println(i)
}
不用变量i
for _ in 1...4{
println("****")
}

//swift中switch语句不用加break
当执行的语句一样的情况
var scroe = 95
switch score/10{
case9,10:
println("优秀")
case 6,7,8,9:
println("及格")
default:
println("不及格")
}
当执行的的条件是个范围的时候
switch score{
case 90...100:
println("优秀")
case 60...89:
println("及格")
default:
println("不及格")
}

fallthrough 后面不能使用变量
fallthrough  相当于c语言中switch case 去掉break语句，不中断执行
，继续执行后面的语句

//标签 标注一个循环，可以直接找到该循环
out: for _ in 1...2{
for _ in 1...3{
println("做俯卧撑")
break out
}
println("休息一下")
s}

//函数
格式：func 函数名(形参列表) ->返回值类型 {
函数体...
}
参数列表：形参名1：形参类型，形参名2：形参类型
func sum(num1:Int,num2:Int) -> Int {
return num1 + num2
}
返回值为空的表现形式：void 空元组() 直接不写
返回一个元组类型
func find(id:Int) -> (name:Int,age:Int) {
return ("jack",20)
}
var p = p.find(2)
println("name = /(p.0),age = /(p.1)")

//外部参数
第一种：外部参数：在形参前面加一个外部参数名
func sum(sum_num1 num1:Int, sum_num2 num2:Int) -> Int
{
return num1 + num2
}
sum(sum_num1:20,sum_num2:30)
第二种：直接在形参前面加一个#号
func sum(#num1:Int,#num2:Int) -> Int
{
return num1 + num2
}
sum(num1:20,num2:30)
默认参数
func sum(name:String,age:Int = 20)
{
函数体...
}
sum("jack",age:30)
默认参数值：带有默认参数值得的形参，swift会自动给它生成一个跟形参
名相同的外部参数名
在前面加一个下划线可以取消外部参数，下划线表示取消一切
func sum(name:String,_age:Int = 20)
{
函数体...
}
sum("jack",30)

//可变参数
注意：一个函数只能有一个可变参数
可变参数必须放在参数表中的最后位置
func function(number:Double...) -> Double{

}

//常量和变量参数
常量参数：默认情况下，函数的参数都是常量参数，是不能被修改的，
即(let name:String)

变量参数：在变量前面加var变成变量
func sum(var name:String,_age:Int = 20)
{
函数体...
var name = "jack"
}

//在swift中没有函数指针，但是可以使用输入输出参数在函数内部修改外
部变量的值，输入输出参数就是在参数前面加一个inout
func change(inout num:Int) {
num = 10
}
var a = 20
change(&a) //类似于改变变量a的地址，其实不是。
println(a) = 10
inout 与var、let不能同时使用

//函数类型（是一种数据类型，类似于C语言的函数指针，OC里的Block）
分三步：1、定义函数。2、声明函数类型变量或常量。3、给函数类型变量
赋值
1、定义函数
func addTwoInts(a:Int,b:Int) -> Int {
return a+b
}
2、声明函数类型变量
var mathFunction:(Int,Int) -> Int
3、给函数类型变量赋值
mathFunction = addTwoInts
4、使用
mathFunction(2,3)

//函数类型作为参数
func result(mathFunction:(Int,Int) -> Int,a:Int,b:Int) -> Int{

}

//函数类型作为返回值
定义两个函数
func first(a:Int) -> Int {
return a
}
func second(b:Int) -> Int {
return b
}
函数作为返回值
func choose(true:bool) -> (Int) -> Int {
return true?first:second
}
var true = 3
let chooseFunction = choose(true > 0)
println(chooseFunction) 输出的是函数名
println(chooseFunction(10)) 输出结果

//闭包函数
一般形式：{(parameters) -> returnType in
statements

}

let names = ["123","456","789"]
不使用闭包：
func backwards(s1:String,s2:String) -> Bool{
return s1 > s2
}
var reversed = sort(names,backwards) sort()Swift标准库函数
println(reversed)

使用闭包
reversed = sort(names,{(s1:String,s2:String) -> Bool in
return s1 > s2
})

简化（根据上下文判断类型）
reversed = sort(names,{s1,s2 in return s1 > s2})

再简化（闭包隐式返回）
如果闭包只有一个表达式，那么return可以返回
reversed = sort(names,{s1,s2 in s1 > s2})

参数名称简写
$0和$1表示闭包中第一个和第二个String类型的参数
reversed = sort(names,{$0>$1})

运算符函数
Swift的String类型定义了关于大于号>的字符串实现
reversed = sort(names, >)

尾随闭包
如果需要将一个很长的闭包表达式（以至于不能在一行书写时）作为最后一
个参数传递给函数，可以使用尾随闭包来增强函数的可读性，尾随闭包是一
个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用
reversed = sort(names){$0 > $1}

//捕获值
1、闭包可以在其定义的上下文中捕获常量或者变量，即使定义这些常量和
变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值
2、Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内
的函数。嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量

func makeIncrementor(forIncrementor amount:Int) -> () -> Int {
var runningTotal = 0
//incrementor函数并没有获取任何参数，但是incrementor捕获
了当前runningTotal变量的引用，捕获一个引用保证了当makeIncrementor
结束的时候并不会消失，也保证了当下一次执行incrementor函数时，
runningTotal可以继续增加
func incrementor() -> Int {
runningTotal += amount
return runningTotal
}
return incrementor
}
定义了一个叫做incrementByTen的常量，该常量指向一个每次调用会增
加10的incrementor函数
let incrementByTen = makeIncrementor(forIncrementor:10)
println(incrementByTen()) 结果为10
println(incrementByTen()) 结果为20
println(incrementByTen()) 结果为30