import Foundation
/*
func 函数名 (参数名:参数类型) {
}
func 函数名 (参数名:参数类型) ->Void{
}
func 函数名 (参数名:参数类型) ->返回类型{
}
*/
func show_Array(tempArray: [Int]){
for a in tempArray {
println("\(a)")
}
}
func show_Arrays(tempArray:Array<Any>){
for a in tempArray {
println("\(a)")
}
}
//show_Array([2,3,4,5,6,2,1,3,2])
//show_Arrays([2,3,"abc"])
func maxOfValue(start : Int ,end : Int)->Int {
if start>end {
return start
}
return end
}
var temp = maxOfValue(,)
println(temp)
func showHello(){
println("Hello World")
}
showHello()
//返回多个值 即返回一个元组类型
func returnMoreValue(t1:(Double,Double),t2:(Double,Double)) ->(width:Double,height:Double) {
return (abs(t1.-t2.),abs(t1.-t2.))
}
func returnMoreValue_1(t1:(Double,Double),t2:(Double,Double)) ->(Double,Double) {
return (abs(t1.-t2.),abs(t1.-t2.))
}
//函数的内部参数和外部参数
func returnMoreValue_2(t1 a: Double,t2 b: Double) ->Double {
//使用时只能用内部参数
return a/b
}
//函数的内部参数和外部参数 与 returnMoreValue_2相同
func returnMoreValue_3(#t1: Double,#t2: Double) ->Double {
//使用时只能用内部参数
return t1/t2
}
let p0 : (Double,Double) = (,)
let p1 : (Double,Double) = (,)
let p_v=returnMoreValue(p0,p1)
println(p_v.width)
//调用 函数传递外部参数
println(returnMoreValue_2(t1: 3.3, t2: 2.3))
println(returnMoreValue_3(t1: , t2: 6.6))
//默认参数
func joinString(s1: String ,toString s2: String ,joiner s3: String = " && ")->String {
return s1+s3+s2
}
func joinString1(s1: String ,toString s2: String ,joiner: String = " && ")->String {
return s1+joiner+s2
}
let str=joinString("hello", toString: "world", joiner: "#")
println(str)
let stra=joinString("hello", toString: "world")
println(stra)
joinString1("lsq", toString: "Liu", joiner: "#")
joinString1("lsq", toString: "Liu")
//参数的常量和变量
//传递给函数的参数默认是常量，不可以修改 如果想修改参数的值，需要在参数定义的时候指定参数变量形式 var
func swap(a: Int ,var b: Int) {
let t=b
b=a
}
//输入输出 函数inout 类似于c#中的值类型与引用类型
func swap1(inout a : Int ,inout b : Int){
let t=a
a=b
b=t
}
var x=
var y=
swap1(&x, &y) //& 表示传递变量地址
println("\(x),\(y)")
//变参函数
//不确定参数的个数
//通常写法
func add(array: [Int])->Int{
var sum=
for i in array {
sum+=i
}
return sum
}
//标准写法 参数个数不确定多时候 变量名: 类型...
func add1(array: Int...)->Int{
var sum=
for i in array {
sum+=i
}
return sum
}
var temp_t = add([,,,,,])
println(temp_t)
var temp1=add1(,,,,,,,)
println(temp1)
//函数的类型
//给函数总结一下类型 (Int,Int)->Int
func m_add(a: Int ,b: Int)->Int{
return a+b
}
func m_sum(a: Int,b: Int)->Int{
return a-b
}
//定义函数类型的变量
var calFunc:(Int,Int)->Int = m_add;
//定义了参数 那么调用函数
println(calFunc(,))
calFunc = m_sum
println(calFunc(,))
//闭包 可以理解为匿名函数 有参数有返回值 没有函数名称
//嵌套函数
/*
闭包表达式语法
{
(参数) -> 返回值类型 in
执行语句
}
in 用来分割类型及执行语句
*/
//定义一个闭包表达式常量
let sayHello = {
println("无参数无返回值的匿名函数，即闭包表达式")
}
//调用
sayHello()
//定义一个闭包表达式的常量 ，add_b类型是(Int,Int)->Int
let add_b = {(a: Int,b: Int)-> Int in
return a+b
}
//调用
println(add_b(,))
//闭包表达式 回调用法 常用用法 将闭包作为一个函数的回调
func showArray(array : [Int]) {
for a in array {
//print("\(a) ")
}
println(array)
}
//普通的 冒泡排序
func bubbleSort(inout array: [Int]){
let cnt=array.count
for var i = ; i < cnt; i++ {
for var j = ; j < cnt-i; j++ {
if (array[j] > array[j+]) {
var t = array[j]
array[j] = array[j+]
array[j+] = t
}
}
}
}
var array: Array<Int>=[,,,,,,,,]
show_Array(array)
bubbleSort(&array)
println(array)
//用闭包改造
func bubbleSort1(inout array: [Int],cmp:(Int,Int) -> Int){
let cnt=array.count
for var i = ; i < cnt; i++ {
for var j = ; j < cnt-i; j++ {
if (cmp(array[j],array[j+]) == -) {
var t = array[j]
array[j] = array[j+]
array[j+] = t
}
}
}
}
var array_b1=[,,,,,,,,]
//定义一个比较 闭包
let intCmp = {
(a: Int,b: Int) -> Int in
if a>b{
return -
}else if a<b {
return
}else {
return
}
}
//可以这么调用
bubbleSort1(&array_b1,intCmp)
//也可以这么调用 这种方式较多人用
bubbleSort1(&array_b1,{
(a: Int,b: Int) -> Int in
if a>b{
return -
}else if a<b {
return
}else {
return
}
})
println(array_b1)
/*
闭包表达式的优化
1.类型 返回值 让编译器去推断
*/
bubbleSort1(&array_b1,{
(a,b) in
if a>b{
return -
}else if a<b {
return
}else {
return
}
})
println(array_b1)
/*
2.变量名称优化缩写
第一个参数 $0 后面的参数以此类推 $1 $2 $3 ...
*/
bubbleSort1(&array_b1,{
let a = $ , b = $
if a>b{
return -
}else if a<b {
return
}else {
return
}
})
println(array_b1)
//3.简单的闭包表达式代码可以更简洁
/*
{
(a: Int,b: Int) -> Bool in
return a > b
}
优化：
{
return $0 > $1
}
优化:
{
$0 > $1
}
*/
//尾随闭包
//当闭包表达式是函数的最后一个参数时可以用尾随闭包的书写方式，即将闭包表达式写在函数后面，如
bubbleSort1(&array_b1){
let a = $ , b = $
if a>b{
return -
}else if a<b {
return
}else {
return
}
}
println(array_b1)
//优化尾随闭包
bubbleSort1(&array_b1){
if $>${
return -
}else if $<$ {
return
}
return
}
println(array_b1)
//嵌套函数 值捕获
//定义一个函数，范围值是一个闭包类型 函数中定义一个函数，函数中返回一个函数
func get_value(inc: Int) -> (Int)->Int {
func incFunc(v: Int) -> Int{
return inc+v
}
return incFunc
}
func get_value1(inc: Int) -> (Int)->Int {
var mt =
func incFunc(v: Int) -> Int{
mt++
return inc+v+mt
}
return incFunc
}
let incFunc1=get_value()//声明一个变量，调用get_value函数，得到闭包 即该变量是一个闭包
println(incFunc1())//调用闭包
let incFunc2=get_value1()
println(incFunc2())
println(incFunc2())