swift 学习笔记五

原创已于 2023-09-10 22:36:45 修改 · 510 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#swift #学习 #笔记

于 2016-07-23 21:44:27 首次发布

ios 专栏收录该内容

16 篇文章

订阅专栏

本文详细介绍了Swift语言中函数的定义及使用方法，包括参数传递、返回值处理、默认参数设置等核心概念，并通过实例展示了如何利用闭包进行回调操作。

函数的定义

//swift 函数的定义语法
/*
  func 函数名(参数名:参数类型,参数名:参数类型...)-> 函数返回值类型
 {
    函数实现部分...
 }
 */
func show(name:String) -> String {

    return name+name;
}
print("names:\(show("kk"))")

func showInt(array:[Int]) {
    for a in array{
        print("a:\(a)")
    }
}

showInt([1,2,3,4])

运行结果:

names:kkkk

a:1

a:2

a:3

a:4

函数的参数与返回值

/*
  函数的参数和返回值
    1:函数可以有多个参数
    2:函数可以没有返回值也没参数
    3:函数可以返回多个值
 */
func maxvalue(a : Int,b : Int) -> Int{
    return a>b ? a : b
}
var maxVal=maxvalue(2, b:4);

print(maxVal)


let p0: (Double,Double)=(0,0)
let p1: (Double,Double)=(6,6)

func getLengthAndWidtd(p0:(Double,Double),p1:(Double,Double)) -> (Double,Double) {
    return  (abs(p0.1-p1.1),abs(p0.0-p1.1))
}

print(getLengthAndWidtd(p0, p1: p1))

let w=getLengthAndWidtd(p0, p1: p1).0;
let h=getLengthAndWidtd(p0, p1: p1).1;
print("长:\(h)宽:\(w)")

//定义元祖的昵称

let p2:(x:Double,y:Double)=(0,0)
let p3:(x:Double,y:Double)=(0,0)

func getLengthAndWidth(p0:(x:Double,y:Double),p1:(x:Double,y:Double)) -> (x:Double,y:Double) {
    return (abs(p0.x-p1.x),abs(p0.x-p1.y))
}
let w2=getLengthAndWidth(p2,p1:p3).x;
let h2=getLengthAndWidth(p2,p1:p3).y;

函数的外部参数和内部参数

默认就是内部参数,还可以在内部参数前面再加一个名字,这样就就体现为外部参数,外部参数内部无法访问,只是外部调用的时候名称变化不一样

   static func test(){
        //使用外部参数
        divide(div: 10, dived: 2);
        //内部参数
        divide2(a: 10, b: 2);
    }
    
    static func divide(div a:Double,dived b:Double)->Double{
        return a/b;
    }
    static func divide2(a:Double,b:Double)->Double{
        return a/b;
    }

函数的默认值

函数默认值调用方可以省略,愈发就是变量名:变量类型=默认值

 static func test(){
        print(join(a: "hello", b: "张三"))
    }
    
    static func join(a:String,b:String,tag:String=",")->String{
        return a+tag+b;
    }

最终输出 hello,张三

常量参数和变量参数
参数默认是常量参数无法修改,如果要是变量参数需要主动加var

  func swapTwoInts(_ a: inout Int, _ b: inout Int) {
        let temporaryA = a
        a = b
        b = temporaryA
    }

不定参数

static func count(arr:Int...)->Int{
        var result=0;
        for i in arr {
            result+=i;
        }
        return result;
    }
 static func test(){
        print("count :\(count(arr: 1,4,6))")
    }

闭包

我们可以理解为其他语言的回调,或者oc的block
语法={(参数:参数类型,...)->参数返回值 int

}

static func test(){
        print("========>闭包开始......");
        let sayhello={
            print("xxxx");
        };
        let sayhello2:()->Void={
            print("xxxx222");
        };
        sayhello();
        sayhello2();
        
        let add:(Int,Int)->Int={ (a:Int,b:Int)->Int in
            return a+b;
        }
        print("========>yyy\(add(1,2))");
        print("========>闭包结束......");
    }