Swift -3 函数和闭包

原创 2015年11月20日 16:12:42

函数

Swift中函数是执行特定任务的代码自包含块。给定一个函数名称标识, 当执行其任务时就可以用这个标识来进行”调用”。
Swift的统一的功能语法足够灵活来表达任何东西,无论是甚至没有参数名称的简单的C风格的函数表达式,还是需要为每个本地参数和外部参数设置复杂名称的Objective-C语言风格的函数。参数提供默认值,以简化函数调用,并通过设置在输入输出参数,在函数执行完成时修改传递的变量。
Swift中的每个函数都有一个类型,包括函数的参数类型和返回类型。您可以方便的使用此类型像任何其他类型一样,这使得它很容易将函数作为参数传递给其他函数,甚至从函数中返回函数类型。函数也可以写在其他函数中来封装一个嵌套函数用以范围内有用的功能。

定义和调用函数

/*
    一.定义函数的语法格式
    func 函数名(形参列表) ->返回值类型{
    // 可执行语句组成的函数
}
*/
func sayHello(personName:String) ->String {

    return "Hello, " + personName + "!"
}
//print(sayHello("Devin"))

函数形参

func max(x: Int, y: Int) -> Int{

    return x > y ? x : y
}
//print(max(5, 3))

// 1.没有参数的函数
func sayHelloWorld() -> String{

    return "Hello World"
}
//print(sayHelloWorld())

// 2.外部参数名 局部参数名:形参类型
func area(width: Double, height: Double) -> Double{

    return width * height // width, height 不能在调用函数时使用,为局部参数
}
//print(area(4.5, height: 3.2))
func area1(宽 width: Double, 高 height: Double) -> Double{

    return width * height //width,height 不能在调用函数时使用,为局部函数
}
//print(area1(宽: 3.4, 高: 4.7))

// 3.外部参数和局部参数一样的话,需要在第一个参数前面加上同样的参数(swift2.0之后的写法)
func area2(width width: Double, height: Double) -> Double{

    return width * height //width,height 不能在调用函数时使用,为局部函数
}
//print(area2(width: 5, height: 2.4))

// 4.可变参数: 在参数类型后面加... 表示该参数可以接受多个参数值
func sum(numbers: Int...) -> Int{

    var total: Int = 0
    for num in numbers{

        total += num
    }
//    print(total)
    return total
}
sum(1, 3, 4, 5)

// 默认参数
func sayHi(msg: String, name: String = "Lily"){ // 这里就是默认参数

    print("\(name), \(msg)")
}
//sayHi("你好啊") // 如果没有传入参数,就会使用默认值
//sayHi("你好啊", name: "Tom")
// 可变参数放在最后面, 默认参数只能出现在次后面


// 6.常量形参和变量形参
func factorial(var number: Int) -> Int{

    var result: Int = 1
    while number > 1{

        result = result * number
        number--  // 这里如果定义的参数不带var的话就是默认常量,常量不能做--操作
    }
    return result
}
//print(factorial(3)) //3的阶乘

// 7.In-Our 形参
func swap(inout a: Int, inout b: Int){

    let tmp = a
    a = b
    b = tmp
}
var a: Int = 1
var b: Int = 3
swap(&a, b: &b)
//print("交换之后的结果为: a = \(a), b = \(b)")
/*
注意:
1.只能传入变量作为实参
2.输入输出参数不能带有默认值
3.如果你用关键字 inout 标记了一个参数,这个参数不能再用var或者let去标记
*/

返回值

// 没有指定返回类型的函数总返回 void,在Swift中,void可以理解为空元组
func sayHi1(){

//    print("Welcome")
}
sayHi1()

// 多个返回值
func area2(width: Double, height: Double) -> (Double, Double){

    let s = width * height
    let c = (width + height) * 2
    return(s, c)
}
//print(area2(3.1, height: 3.4))

函数类型

// 1.函数类型作为变量
func addTwoInts(a: Int, b: Int) -> Int{

    return a + b
}
func multiplyTwoInts(a: Int, b: Int) -> Int{

    return a * b
}
//var mathFunction:(Int, Int) -> Int = multiplyTwoInts
//print("result:\(mathFunction(2, 3))") // 函数变量赋值

// 2.函数类型作为参数类型
func printMathResult(mathFuction: (Int, Int) -> Int, a: Int, b: Int){

//    print("result:\(mathFuction(a, b))")
}
printMathResult(addTwoInts, a: 3, b: 5) // 这里函数作为参数传进去

// 3.函数类型作为返回值
func squre(num: Int) -> Int{

    return num * num
}
func cube(num: Int) -> Int{

    return num * num * num
}
func getMathFunc(type type: String) -> (Int) -> Int{

    switch(type){
    case "squre":
        return squre
    default:
        return cube
    }
}
var mathFunc = getMathFunc(type: "squr") // 根据传入的字符串判定返回的函数类型
//print(mathFunc(5))

函数重载

// 函数的重载指的是多个函数享有相同的名字都是有不同的参数或返回值类型不同,它们互相成为重载关系
func test1(){

//    print("无参数的test()函数")
}
func test1(mesg: String){

//    print("重载的test()函数\(mesg)")
}
func test1(msg: String) -> String{

//    print("重载的test()函数\(msg), 带返回值")
    return "test"
}
func test1(msg msg: String){

//    print("重载的test()函数,外部参数为\(msg)")
}
test1()
var result1: Void = test1("hello")
var result2: String = test1("welcome")
var result3: Void = test1(msg: "你好啊")

// 错误,仅有局部变量名不算重载
//func test1(message: String){
//    
//    print("重载的test()函数")
//}

闭包

闭包是功能性自包含模块,可以在代码中被传递和使用。Swift 中的闭包与 C 和 Objective-C中的 blocks 以及其他一些编程语言中的 lambdas 比较相似。
闭包可以 捕获 和存储其所在上下文中任意常量和变量的引用。这就是所谓的闭合并包裹着这些常量和变量,俗称闭包。Swift会为您管理在捕获过程中涉及到的内存操作。
在Swift函数中介绍的全局和嵌套函数实际上也是特殊的闭包,闭包采取如下三种形式之一:
全局函数是一个有名字但不会捕获任何值的闭包
嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包

嵌套函数

func getMathFunc1(type type: String) -> (Int) -> Int{

    func squre1(num: Int) -> Int{

        return num * num
    }
    func cube1(num: Int) -> Int{

        return num * num * num
    }
    switch(type){
        case "squre1":
        return squre1
    default:
        return cube1
    }
}
var mathFunc1 = getMathFunc1(type: "squre1")
//print(mathFunc1(4))

闭包表达式

/*
    *{ (形参列表) -> 返回值类型 in
        可执行表达式
}
*/

func getMathFunc2(type type: String) -> (Int) -> Int{

    func squre1(num: Int) -> Int{

        return num * num
    }
    func cube1(num: Int) -> Int{

        return num * num * num
    }

    switch(type){
    case "squre1":

        return {(num: Int) -> Int in
            return num * num
        }
    default:

        return {(num: Int) -> Int in
            return num * num * num
        }

    }
}
// 返回(Int) -> Int 类型的函数
var mathFunc2 = getMathFunc2(type: "squre1")
//print(mathFunc2(3))

利用上下文推断类型

// var squre: (Int) -> Int = {(num) in return num * num}
// print(squre(3))
//var squre: (Int) -> Int = {num in return num * num} // 和上面一样的, 可以省略参数的括号
//print(squre(3))
// 省略形参名,通过$0, $1...来引用第一个,第二个参数
var squre1: (Int) -> Int = {$0 * $0}
//print(squre1(3))

var result: Int = {

    var result = 1
    for i in 1...$1{

        result *= $0
    }
    return result
}(4, 3)
print(result)
// 函数类型和闭包类型是一致的

尾随闭包

func someFunction(num: Int, fn: (Int) -> ()){

    // 执行代码
}
// someFunction(20, {})
// 使用尾随闭包调用函数的格式
// someFunction(20){}

捕获上下文中的变量或者常量

func makeArr(ele: String) -> () -> [String]{

    // 创建一个不包含任何元素的数组
    var arr: [String] = []
    func addElement() -> [String]{

        // 向arr数组中添加一个元素
        arr.append(ele)
        return arr
    }
    return addElement
}
// 闭包和函数都是引用类型,需要重点掌握闭包和函数
版权声明:本文为博主原创文章,未经博主允许不得转载。

Swift 函数,闭包使用

一.Swift中的函数 1. 函数的定义与使用 在介绍Swift中的函数之前,我想用Objective-C中的一个简单的加法函数来作为引子,然后类比着实现一下Swift中相同功能的函数。关...
  • zhangjitao_boke
  • zhangjitao_boke
  • 2016年01月19日 20:44
  • 1067

iOS学习笔记42-Swift(二)函数和闭包

上一节我们讲了Swift的基础部分,例如数据类型、运算符和控制流等,现在我们来看下Swift的函数和闭包一、Swift函数函数是一个完成独立任务的代码块,Swift中的函数不仅可以像C语言中的函数一样...
  • liuting5521826
  • liuting5521826
  • 2016年04月24日 12:20
  • 430

iOS swift3.0 下闭包语法整理

http://www.jb51.net/article/97240.htm IOS swift3.0 下闭包语法整理 一、闭包的概念 有oc基础的都知道,闭包其实是oc里...
  • jeffasd
  • jeffasd
  • 2017年03月08日 15:42
  • 1194

swift 之 如何在函数中把闭包作为参数 进行回调

在之前的OC中我们会经常在一个方法中使用BLOCK回调 来达到数据回传和 执行某些操作 在swift中我们使用闭包 可以达到同样的效果 自己通过对比block和各种测试 有了以下的写法 ,但是...
  • ERIC_Dream
  • ERIC_Dream
  • 2015年07月28日 14:15
  • 3510

五、swift3.0闭包和懒加载

一、懒加载 二、UITableView的使用 三、
  • cwhzm
  • cwhzm
  • 2017年06月18日 11:27
  • 624

Swift详解之四-------妈妈再也不用担心我的闭包了

妈妈再也不用担心我的闭包了 swift中闭包是一个很强大的东西,闭包是自包含的函数代码块,可以在代码中被传递和使用。跟C 和 Objective-C 中的代码块(blocks)很相似 。这个大家必须...
  • u010586842
  • u010586842
  • 2015年08月20日 23:06
  • 2387

swift3.0 传值总结(属性、代理、闭包、通知)

swift3.0 传值总结(属性、代理、闭包、通知)
  • glt_code
  • glt_code
  • 2017年06月08日 18:45
  • 3102

初探swift语言的学习笔记三(闭包-匿名函数)

swfit 中匿名函数的使用
  • fengsh998
  • fengsh998
  • 2014年06月08日 10:11
  • 8416

Object-C--->Swift之(七)嵌套函数与闭包

嵌套函数函数分为全局函数和局部函数,前面已经介绍了全局函数,下面介绍下局部函数,定义在函数体内部的函数可以成为嵌套函数。 注意:嵌套函数对外是隐蔽的,只能在其封闭函数内有效,嵌套函数只能在其封闭函数...
  • IT_DS
  • IT_DS
  • 2016年01月24日 12:15
  • 1009

Swift 各种闭包各种使用 && 设置参数,函数传值

Swift 各种闭包各种使用 && 设置参数,函数传值
  • weixin_35755389
  • weixin_35755389
  • 2016年10月27日 12:58
  • 2732
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Swift -3 函数和闭包
举报原因:
原因补充:

(最多只允许输入30个字)