1.函数
语法：
func funcname(形参) -> returntype{
return parameters
}
func runner(speed:String,jk:String) -> String {
return speed + jk
}
func func2() -> String {
return "无参数函数"
}
func func3(hh: String) -> Void {
print("无返回值函数")
}
func func4(kk: String){
print("无返回值函数")
}
func func5(){
print("无参数+无返回值函数")
}
//返回值类型为元组，元组和数组类似，不同的是里面可以是任意类型的数据
//关于for循环：1...arry.count :闭区间循环，从1-arry.count；1..<arry.count:开区间，从1-(arry.count-1)
//如果不确定返回的元组一定不为nil，可以返回一个可选的元组类型：func minMax(array:[Int]) -> (min:Int,max:Int)?{}
func minMax(array:[Int]) -> (min:Int,max:Int)?{
if array.isEmpty {
return nil
}
var currentMin = array[0];
var currentMax = array[0];
for value in array[1..<array.count] {
if value < currentMin {
currentMin = value
}else if value > currentMax {
currentMax = value
}
}
return (currentMin,currentMax)
}
//外部参数名
func pow(firstStr a : Int,secondStr b : Int)->Int{
return a + b
}
//有外部参数时，调用的时候也要有外部参数
pow(firstStr: 5, secondStr: 6)
//可变参数函数
func funsMu(first:Int,second:Int,others:Int...)->Int{
var result = first + second
for num in others{
result += num
}
return result
}
//修改外部参数=======
var aa = 5
var bb = 9
change(a: &aa, b: &bb)
print("aa=\(aa)\n bb=\(bb)\n")//aa=9;bb=5
//改变参数的值
func change(a:inout Int,b:inout Int){
let temp = a
a = b
b = temp
}
//=================
//函数作为参数-先定义一个函数
func sum(a:Int,b:Int) -> Int {
return a + b
}
//定义一个参数是函数的函数
func anotherFunc(funck:(Int,Int)->Int,a:Int,b:Int) -> Int {
return funck(a,b) + a + b
}
//调用
let addition: (Int,Int)->Int = sum;
let funcResult = anotherFunc(funck: addition, a: 2, b: 3)
print(funcResult)
//=================
//函数嵌套,返回值是一个函数：()->Int，一个无参数，返回值是Int的函数
func calcDecrement(total:Int) -> ()->Int {
var aa = 0
func decrement()->Int{
aa -= total
return aa
}
return decrement
}
//调用：
let decrem = calcDecrement(total: 20)
print(decrem())
//=================
2.Swift闭包
闭包的有点：
1.根据上下文推断参数和返回值的类型
2.从单行的表达式闭包中隐式返回（也就是比好只有一行代码，可以省略return）
3.语法：{parameters->return type in
//表达式
}
//闭包----单行、隐式返回，省略return
let studyName = {print("swift 闭包示例，单行、隐式返回，省略return")}
studyName()//调用
//多参闭包
let divide = {(val1:Int,val2:Int) ->Int in
return val1 / val2
}
//调用
let divideResult = divide(10,5)
print(divideResult)
//sorted 方法============
let names = ["AT","AE","D","S","K","BE"]
//闭包
let backwards = {(a:String,b:String)->Bool in
return a > b
}
//用闭包排序
let reversed = names.sorted(by: backwards)
print(reversed)
//用函数排序
let reversed2 = names.sorted(by: backwards2)
print(reversed2)
//函数
func backwards2(a:String,b:String) -> Bool {
return a > b
}
//Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过$0,$1,$2来顺序调用闭包的参数。
let reversed3 = names.sorted(by: {$0 > $1})
print(reversed3)
//更简洁的方法
let reversed4 = names.sorted(by: >)
print(reversed4)
//=======================
尾随闭包
尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
func someFunctionThatTakesAClosure(closure: () -> Void) {
// 函数体部分
}
let names = ["AT", "AE", "D", "S", "BE"]
//尾随闭包
var reversed = names.sorted() { $0 > $1 }
print(reversed)
sort() 后的 { $0 > $1} 为尾随闭包
3.结构体
struct markStuct {
var mark:Int
var fk:Int
init(mark:Int,fk:Int) {
self.mark = mark
self.fk = fk
}
}
let astruct = markStuct(mark: 100, fk: 200)
var bstruct = astruct//复制一份值给bstruct
bstruct.fk = 300//不会改变astruct的值
print(astruct.fk)//输出200
print(bstruct.fk)//输出300
4.类方法
//可以直接用类名调用
class func abs(number:Int)->Int{
return number*2
}
//调用
var hhh = ViewController.abs(number: 20)
print(hhh)
