Swift语法基础入门三(函数, 闭包)

Swift语法基础入门三(函数, 闭包)

函数:

  • 函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字，用来标识函数做什么，并且当函数需要执行的时候，这个名字会被用于“调用”函数
  • 格式:
  • func 函数名称(参数名:参数类型, 参数名:参数类型...) -> 函数返回值 { 函数实现部分 }

没有参数没有返回值

  1. 可以写为 ->Void
  2. 可以写为 ->()
  3. 可以省略
  4. Void。它其实是一个空的元组（tuple），没有任何元素，可以写成()
func say() -> Void {
    print("hello")
}
say()

func say1() -> () {
    print("hello")
}
say1()

// 推荐
func say2() {
    print("hello")
}
say2()

有参数没有返回值

内部/外部参数

  • 内部参数: Swift2.0以前, 默认情况下的参数都是内部参数
  • Swift2.0开始, 默认将第二个参数名称作为外部参数
  • 如果没有明确地指定外部参数, 那么系统默认会从第二个参数开始, 将参数的名称作为外部参数
  • 外部参数只能外部用, 函数内部不能使用, 函数内部只能使用内部参数
  • 忽略外部参数: 在内部参数前加_
// Swift2.0之前, 默认是不会将第二个参数开始的参数名称作为外部参数的, 必须自己手动指定
func sum(i: Int, j: Int) {
    print(i + j)
}
sum(10, j: 20)

func sum1(first i: Int, second j: Int) {
    print(i + j)
}
sum1(first: 10, second: 20)

默认参数（Default Parameter Values）

  • 格式: func method(parameter: Int = 0){}
  • 当默认值被定义后，调用这个函数时可以忽略这个参数
  • 其它语言的默认参数必须写在最后面, Swift可以写在任意位置

注意

  • 将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。
func sum2(i: Int, j: Int = 10) {
    print(i + j)
}
//sum2(10, j: 20)
sum2(10)

// 不推荐这样写, 最好将默认参数写在最后
func sum3(i: Int = 20, j: Int) {
    print(i + j)
}

常量参数和变量参数（Constant and Variable Parameters）

  • 函数参数默认是常量, 在函数内部不能修改
  • 如果想在函数中修改参数, 必须在参数前加上var

注意

  • 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中
func sum4(let i: Int, let j: Int) {
    print(i + j)
}
sum4(10, j: 20)

var num1 = 10
var num2 = 20
//func swap(value1: Int, value2: Int){
//    let temp = value1
//    value1 = value2
//    value2 = temp
//}

// 注意: 操作的是局部变量, 对实参没有影响
func swap1(var value1: Int, var value2: Int){
    print("交互前: value1 = \(value1), value2 = \(value2)")
    let temp = value1
    value1 = value2
    value2 = temp
    print("交互后: value1 = \(value1), value2 = \(value2)")
}

swap1(num1, value2: num2)
print(num1)
print(num2)

输入输出参数（In-Out Parameters）

  • 变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）
  • 定义一个输入输出参数时，在参数定义前加 inout 关键字

注意

  • 输入输出参数不能有默认值，而且可变参数不能用 inout 标记。如果你用 inout 标记一个参数，这个参数不能被 var 或者 let 标记。
func swap2(inout value1: Int, inout value2: Int){
    print("交互前: value1 = \(value1), value2 = \(value2)")
    let temp = value1
    value1 = value2
    value2 = temp
    print("交互后: value1 = \(value1), value2 = \(value2)")
}
swap2(&num1, value2: &num2)
print(num1)
print(num2)

可变参数（Variadic Parameters）

  • 一个可变参数可以接收零个或多个值
  • 如果没有变参函数 , 并且函数的参数个数又不确定那么只能写多个方法或者用将函数参数改为集合
  • 格式 func method(parameter: Int...){}
  • 可变参数在函数中可以当做一个数组

注意

  • 一个函数最多只能有一个可变参数
  • 变参只能是同种类型的数据
  • 变参必须指定数据类型
  • 如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后
func sum5(numbers: Int...) {
//    print(numbers)
    var sum = 0
    for number in numbers {
        sum += number
    }
    print(sum)
}
sum5(1, 2, 3)

// 不推荐写法, 和默认值一样, 变参最好写在最后
func sum6(numbers: Int..., var sum: Int) {
    //    print(numbers)
    for number in numbers {
        sum += number
    }
    print(sum)
}
sum6(1, 2, 3, sum: 0)

// 推荐写法
func sum7(var sum: Int = 100, numbers: Int...) {
    //    print(numbers)
    for number in numbers {
        sum += number
    }
    print(sum)
}
sum7(numbers: 1, 2, 3)

// 一个函数中只能有一个变参
//func sum8(numbers: Int..., values: Int...){
//    print(numbers)
//    print(values)
//}

// 有参数有返回值
func sum8(i: Int, j: Int) -> Int {
    return i + j
}
let result = sum8(10, j: 20)
print(result)

闭包

闭包

  • 闭包是自包含的函数代码块，可以在代码中被传递和使用。Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的匿名函数比较相似
  • 闭包可以捕获和存储其所在上下文中任意常量和变量的引用。这就是所谓的闭合并包裹着这些常量和变量，俗称闭包
  • 闭包的使用和block一样, 用于保存一段代码, 用作回调, 用作执行耗时操作
  • 闭包格式: in关键字的目的是便于区分返回值和执行语句 
     {
     (形参列表) -> 返回值类型
     in
     执行语句
 }

        // 正常写法
        loadData ({ () -> () in
            print("执行了")
        })
        */

        /*
        // 闭包的其它写法
        // 1.如果闭包是函数的最后一个参数, 那么可以把闭包写在调用函数的()后面
        // 这种写法, 我们称之为 "尾随闭包"
        loadData("123") {
            () -> ()
            in
            print("执行了")
        }

        // 2.如果函数只接收一个参数, 并且这个参数是闭包, 那么调用函数的()可以省略
        // 这种写法, 我们称之为 "尾随闭包"
        loadData {
            () -> ()
            in
            print("执行了")
        }

func loadData(since_id: String, finished: ()->()) -> Void {
        dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
            print("子线程做耗时操作 \(NSThread.currentThread())")

            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                print("主线程更新UI \(NSThread.currentThread())")
                finished()
            })
        }
    }

    /*
    func loadData(finished: ()->()) -> Void {
        dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
            print("子线程做耗时操作 \(NSThread.currentThread())")

            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                print("主线程更新UI \(NSThread.currentThread())")
                finished()
            })
        }
    }

闭包的循环引用

  • 闭包循环强引用
  • block
    • 闭包和block很像, 都是提前准备好代码, 在需要时执行
    • block会对外部变量进行强引用, 保证执行代码时变量还在
    • block中用到self一定要非常小心 闭包
    • 闭包也一样, 会对外部变量进行强引用, 保证执行代码时变量还在
    • 如果您将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，您将创建一个在闭包和该实例间的循环强引用
    • Swift开发中能不写self就不写self, 一看到self就想到闭包
  • OC中如何解决循环引用
    • __weak typeof(self) weakSelf = self;
    • 特点: 对象释放后会自动将变量赋值为nil
    • __unsafe_unretained typeof(self) weakSelf = self;
    • 特点: 对象释放后不会自动将变量赋值为nil, 指向一块废弃的存储空间
  • Swift中如何解决循环引用
    • weak var weakSelf = self
    • weak 相当于OC中的 __weak, 和OC一样 对象释放后会自动将变量赋值为nil
    • 所以被weak修饰的变量是可选类型
    • unowned var weakSelf = self
    • unowned 相当于OC中的__unsafe_unretained, 和OC一样, 对象释放后不会自动将变量赋值为nil
    • 所以被unowned修饰的变量, 不是可选类型

      注意: weak和unowned只能修饰对象类型, 因为只有对象类型才有引用计数

  • 应用场景:
    • 什么时候用weak

      • 当被保存的对象有可能提前释放时就用weak
    • 什么时候用unowned
      • 当被保存的对象在使用时不会被提前释放时就用unowned
  • 捕获列表
    • 可以在调用闭包时在形参列表前面通过[]指定捕获列表, 告诉系统如何处理指定的这些值
        //weak var weakSelf = self
        //unowned var weakSelf = self

        callBack = { [unowned self ,weak btn = self.button] () -> () in
            //self.view.backgroundColor = UIColor.redColor()
            //weakSelf.view.backgroundColor = UIColor.redColor()
            self.view.backgroundColor = UIColor.redColor()
            print(btn)
        }

        loadData(callBack!)
    }

    func loadData(finished: ()->()) -> Void {

        dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
            print("子线程做耗时操作 \(NSThread.currentThread())")

            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                print("主线程更新UI \(NSThread.currentThread())")
                finished()
            })
        }
    }
  • 析构函数

    • 析构器只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用
    • 类似于OC中的dealloc方法
    • 析构器是在实例释放发生前被自动调用。你不能主动调用析构器
    • 一般情况下, 当使用自己的资源时, 在析构函数中进行一些额外的清理
    • 例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件

    deinit {
        print("88")
    }

End

时间： 2024-05-09 06:50:37

Swift语法基础入门三(函数, 闭包)的相关文章

javascript语法基础-变量与函数

三 javascript语法基础-变量与函数 (一)变量的声明与运用 JavaScript中的变量与Java.C等强类型语言有很大区别,虽然在JavaScript中具有字符串.数字等数据类型. 变量申明语句的结构是var保留字加标识符,var和标识符之间用空格隔开. 赋值语句的结构是在变量和需要赋的值之间加上一个等号,例如a=1的含义是将变量a的值指定为1. 变量在定义的时候也可以同时赋值,如var a=1. PS:在变量使用前事先进行声明是个良好的编程习惯,这对将来学习Java等其他语言有帮助

《Swift语法快速入门》已可购买，《Swift殿堂之路》接受预定

<Swift语法快速入门>已由电子工业出版社出版,京东当当有售.需要签名版本的朋友,请与我联系.另外,IOS开发常用类库实例演练<Swift殿堂之路>已接受预订,预订链接:http://www.swiftbang.com/read-5-1 在学习Swift的过程中,如有任何疑问,请加入Swift书友会QQ群:259152129,与作者一起讨论.研究Swift开发技术! 欢迎你!

python3 入门 (三) 函数与lambda表达式、闭包

函数 是组织好的.可重复使用的.用来实现单一或相关联功能的代码段. 函数代码块以def关键词开头,后接函数标识符名称和圆括号() 任何传入参数和自变量必须放在圆括号中间.圆括号之间可以用于定义参数 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明 函数内容以冒号起始,并且缩进 Return[expression]结束函数,选择性地返回一个值给调用方.不带表达式的return相当于返回 None 函数的定义: 1 def test0(): 2 "函数_文档字符串" 3 pri

iOS开发笔记--swift语法基础

基础数据类型 Swift 的类型是在 C 和 Objective-C 的基础上提出的,Int是整型:Double和Float是浮点型:Bool是布尔型:String是字符串.Swift 还有两个有用的集合类型,Array和Dictionary,请参考集合类型. Swift 还增加了 Objective-C 中没有的类型比如元组(Tuple).元组可以让你创建或者传递一组数据,比如作为函数的返回值时,你可以用一个元组可以返回多个值. Swift 还增加了可选(Optional)类型,用于处理值缺失

Swift语法简介（二）闭包

突然看到别人写的关于Block的帖子,让我突然有一种想写一篇关于闭包的帖子.在我的认知中,Swift中的闭包,就是Object-C中的Block--(或许我的认知太浅了).先上一个闭包的简单例子 let isInputEven = { (input:Int)->(Bool) in if input % 2 == 0 { return false } return true } print(isInputEven(3)) 上述代码定义了一个闭包,名字是 isInputEven.接收一个Int类型的

Python基础入门 (三)

一.set 特点: set是一个无序且不重复的元素集合访问速度快:天生解决元素重复问题 方法: 初始化 >>> s1 = set()>>> print(type(s1))<class 'set'> add() 增加元素 >>> s1.add('tom')>>> print(s1){'tom'} clear() 清空 >>> s1.clear()>>> print(s1)set() 差集

python基础（三）闭包与装饰器

闭包(closure): 内嵌函数通过调用外部嵌套函数作用域内的变量,则这个内嵌函数就是闭包. 闭包必须满足三个条件: 必须有一个内嵌函数 内嵌函数必须引用外部嵌套函数中的变量 外部函数的返回值必须是内嵌函数 eg: def make_power(y): def fn(x): return x ** y return fn pow = make_power(2) print pow(5) #25 #声明pow时返回了函数fn并将2作为嵌套函数的参数传入 #闭包内嵌套函数传递参数时,参数保留 装饰

Scala基础01：语法基础入门

Scala REPL res1,res2,... res5等分别表示输出结果.若一次计算输出的结果被标识为res2,那么在之后的调用中,可以直接使用res2. 例: Scala IDE 中的 Scala WorkSheek 这是Scala IDE提供的非常有用的功能.其功能就相当于Scala REPL.可以动态的将结果显示出来. 输入输出 输出通常使用print或println函数. 输入通常使用read函数. readLine是从控制台读取一行输入.指定类型时为readT,T是所要指定的类型,

js语法基础入门（5.2）

5.2.循环结构 当一段代码被重复调用多次的时候,可以用循环结构来实现,就像第一个实例中出现的场景一样,需要重复询问对方是否有空,这样就可以使用循环结构来搞定 5.2.1.for循环语句 //语法结构: for(初始化表达式:条件表达式:条件改变表达式){ 循环体: } 程序流程图 实例: /** *输出1-100的整数 */ for(var i=1;i<100;i++){ document.write(i+"<br />"); } for循环详解 //假如要循环输出