函数类型是由函数的参数类型和返回值类型组成

作者: 编程  发布:2019-11-22

/*

Swift 函数用来完成特定任务的独立的代码块。Swift使用一个统一的语法来表示简单的C语言风格的函数到复杂的Objective-C语言风格的方法。函数声明: 告诉编译器函数的名字,返回类型及参数。函数定义: 提供了函数的实体。Swift 函数包含了参数类型及返回值类型:函数定义Swift 定义函数使用关键字 func。定义函数的时候,可以指定一个或多个输入参数和一个返回值类型。每个函数都有一个函数名来描述它的功能。通过函数名以及对应类型的参数值来调用这个函数。函数的参数传递的顺序必须与参数列表相同。函数的实参传递的顺序必须与形参列表相同,-> 后定义函数的返回值类型。语法func funcname -> returntype{ Statement1 Statement2 …… Statement N return parameters}实例以下我们定义了一个函数名为 runoob 的函数,形参的数据类型为 String,返回值也为 String:import Cocoafunc runoob(site: String) -> String { return }print(runoob(site: "www.runoob.com"))以上程序执行输出结果为:www.runoob.com函数调用我们可以通过函数名以及对应类型的参数值来调用函数,函数的参数传递的顺序必须与参数列表相同。以下我们定义了一个函数名为 runoob 的函数,形参 site 的数据类型为 String,之后我们调用函数传递的实参也必须 String 类型,实参传入函数体后,将直接返回,返回的数据类型为 String。import Cocoafunc runoob(site: String) -> String { return }print(runoob(site: "www.runoob.com"))以上程序执行输出结果为:www.runoob.com函数参数函数可以接受一个或者多个参数,这些参数被包含在函数的括号之中,以逗号分隔。以下实例向函数 runoob 传递站点名 name 和站点地址 site:import Cocoafunc runoob(name: String, site: String) -> String { return name + site}print(runoob(name: "菜鸟教程:", site: "www.runoob.com"))print(runoob(name: "Google:", site: "www.google.com"))以上程序执行输出结果为:菜鸟教程:www.runoob.comGoogle:www.google.com不带参数函数我们可以创建不带参数的函数。语法:func funcname() -> datatype { return datatype}实例import Cocoafunc sitename() -> String { return "菜鸟教程"}print(sitename以上程序执行输出结果为:菜鸟教程元组作为函数返回值函数返回值类型可以是字符串,整型,浮点型等。元组与数组类似,不同的是,元组中的元素可以是任意类型,使用的是圆括号。你可以用元组类型让多个值作为一个复合值从函数中返回。下面的这个例子中,定义了一个名为minMax的函数,作用是在一个Int数组中找出最小值与最大值。import Cocoafunc minMax(array: [Int]) -> (min: Int, max: Int) { var currentMin = array[0] var currentMax = array[0] for value in array[1..currentMax { currentMax = value } } return (currentMin, currentMax)}let bounds = minMax(array: [8, -6, 2, 109, 3, 71])print("最小值为 (bounds.min) ,最大值为 (bounds.max)")minMax函数返回一个包含两个Int值的元组,这些值被标记为min和max,以便查询函数的返回值时可以通过名字访问它们。以上程序执行输出结果为:最小值为 -6 ,最大值为 109如果你不确定返回的元组一定不为nil,那么你可以返回一个可选的元组类型。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组,例如?或(String, Int, Bool)?注意可选元组类型如?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型,整个元组是可选的,而不只是元组中的每个元素值。前面的minMax函数返回了一个包含两个Int值的元组。但是函数不会对传入的数组执行任何安全检查,如果array参数是一个空数组,如上定义的minMax在试图访问array[0]时会触发一个运行时错误。为了安全地处理这个"空数组"问题,将minMax函数改写为使用可选元组返回类型,并且当数组为空时返回nil:import Cocoafunc 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..currentMax { currentMax = value } } return (currentMin, currentMax)}if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) { print("最小值为 (bounds.min),组大值为 (bounds.max)")}以上程序执行输出结果为:最小值为 -6,组大值为 109没有返回值函数下面是 runoob 函数的另一个版本,这个函数接收菜鸟教程官网网址参数,没有指定返回值类型,并直接输出 String 值,而不是返回它:import Cocoafunc runoob(site: String) { print("菜鸟教程官网:}runoob(site: " sample(number: Int) { println}以上实例中 number 为局部参数名,只能在函数体内使用。import Cocoafunc sample(number: Int) { print}sample(number: 1)sample(number: 2)sample(number: 3)以上程序执行输出结果为:123外部参数名你可以在局部参数名前指定外部参数名,中间以空格分隔,外部参数名用于在函数调用时传递给函数的参数。如下你可以定义以下两个函数参数名并调用它:import Cocoafunc pow(firstArg a: Int, secondArg b: Int) -> Int { var res = a for _ in 1..(members: N...){

一、函数
1、定义一个无参无返回值的函数并进行调用:
func eat(){
print(“eating”)
}
调用函数: eat()
2、定义一个有参数无返回值的函数
func drink( a: Int , b: Int){ //格式:func 函数名(参数名称:参数类型)
print( a + b)
}
调用函数:drink( 10, 20)
3、定义一个有参有返回值的函数
func relax(a: Int, b: Int) ->Int { //格式:func 函数名(参数名称:参数类型)-> 返回值类型
return a - b
}
调用函数:var result1 = relax(30, b: 10)
4、元组作为函数的返回值
func run(a: Int , b: Int) ->(a1: Int, b1:Int) {
return (a * 10, b * 10)
}
var r = run(10 , 12) //得到 r 为元组, r.a1 和 r.b1 访问元组内的元素
5、多参量函数 。 函数可以有多种不同类型的参数
//函数一:
func greet(personName: String) ->String {
return “ni hao” + presonName
}
//函数二:
fun greetAgain(personName: String) -> String {
return “ni hao a” + personName
}
//实现多参量函数
fun sayHello(personName: String, alreadyGreet: Bool) -> String {
if alreadyGreet {
return greetAgain(personName)
}else {
return greet(personName)
}
}
print(sayHello(“夜凰”, alreadyGreet: false))
6、函数的外部参数。
主要是为了指明每个参数代表的意义
func login(userName para1: String , passWord para2: String) {
print(“用户名 (para1)”) // userName 和 passWord 变为外部参数
}
login(userName: “墨觞”,passWord: “12456”)
//忽略参数
func jump(para1: String , _ para2: String) {

 函数类型:

for i in members {

}
jump (“123”, “456”) //由于下划线的原因,
7、函数的默认参数值
func fly(a: Int, b: Int = 10) -> Int{
return a * b
}
var f = fly(20) //结果:200
var f1 = fly(20, b: 30) //两种方法调用,默认的初始值可以用,可以不用。
8.定义可辨参数的函数
通过 …使得函数的参数个数是动态的,函数的参数必须为统一类型
fun sum(numbers: Int…) -> Int { //传入的参数类型必须全部为Int类型
var result1 = 0
for index in numbers {
result1 += index
}
return result1
}
var sumResult = sum(12, 3, 4, 56)
print(sumResult)
9、函数的常量参数和变量参数
默认情况下,函数的参数默认为常量let类型
func swim(var a: Int, b: Int) -> Int {
a += 10;
return a
}
var s = swim(10, b: 12)
print(s)
10、函数的输入输出函数
使用inout关键字来定义,只有变量才能作为函数的输入输出参数
func change(inout a: Int , inout b: Int) {
let temp = a
a = b
b = temp
}
var c1 = 10
var c2 = 15
change(&c1, b: &c2) //&说明是输入输出参数
11、函数类型的使用
func add(a: Int, b: Int) ->Int {
return a + b
}
fun sub(a: Int, b: Int) ->Int {
return a - b
}
共同特点:参数类型一致 (Int , Int)-> Int
形式一:把函数类型作为类型标注使用
var re1: (Int, Int) -> Int = add
var finalRe2 = re1(10, 5)
形式二:函数类型作为参数类型
func hehe(a: (Int, Int) -> Int , b: Int , c : Int) -> Int {
return a(b , c)
}
var h = hehe(sub , 10, 5)
形式三:函数类型作为函数的返回类型
func text(a: Int, b: Int) ->(Int, Int) ->int { //后面的(Int, Int) ->int 这是一个整体
if a + b > 10 {
return sub
}else {
return add
}
}
var t = test(5, b: 7)
print(t(100, 200)) //结果为:-100

 类似于C语言的指向函数的指针

print

 类似于OC语言的block

}

 函数类型是由函数的参数类型和返回值类型组成的

}

 */

vari(members: 4,3,5)

 

vari(members: 4.5, 3.1, 5.6)

// 这两个函数类型为: (Int, Int) -> Int

vari(members: "Google", "Baidu", "Runoob")

func sum(a: Int, b: Int) -> Int

以上程序执行输出结果为:

{

4

    return a + b

3

}

5

 

4.5

func sub(a: Int, b: Int) -> Int

3.1

{

5.6

    return a - b

Google

}

Baidu

 

Runoob

// 可以利用函数类型定义函数变量和常量

常量,变量及 I/O 参数

var funcP:(Int, Int) -> Int = sum

一般默认在函数中定义的参数都是常量参数,也就是这个参数你只可以查询使用,不能改变它的值。

//funcP = sub  // 赋与同一类型都可以

如果想要声明一个变量参数,可以在参数定义前加 inout 关键字,这样就可以改变这个参数的值了。

print(funcP(10,20))

例如:

 

func getName(_ name: inout String).........

// 函数类型可以作为函数的参数

此时这个 name 值可以在函数中改变。

func calFunc(a: Int, b: Int, Option:(Int, Int) -> Int) -> Int

一般默认的参数传递都是传值调用的,而不是传引用。所以传入的参数在函数内改变,并不影响原来的那个参数。传入的只是这个参数的副本。

{

当传入的参数作为输入输出参数时,需要在参数名前加 & 符,表示这个值可以被函数修改。

    return Option(a, b)

实例

}

import Cocoa

print(calFunc(a: 10, b: 20, Option: sum))

func swapTwoInts(_ a: inout Int, _ b: inout Int) {

print(calFunc(a: 10, b: 20, Option: sub))

let temporaryA = a

 

a = b

// 函数类型可以作为返回值

b = temporaryA

func max(a: Int, b: Int) -> Int

}

{

var x = 1

    return a > b ? a : b

var y = 5

}

swapTwoInts(&x, &y)

func min(a: Int, b: Int) -> Int

print("x 现在的值 , y 现在的值

{

swapTwoInts 函数简单地交换 a 与 b 的值。该函数先将 a 的值存到一个临时常量 temporaryA 中,然后将 b 的值赋给 a,最后将 temporaryA 赋值给 b。

    return a > b ? b : a

需要注意的是,someInt 和 anotherInt 在传入 swapTwoInts 函数前,都加了 & 的前缀。

}

以上程序执行输出结果为:

 

x 现在的值 5, y 现在的值 1

func chooseFunc(getMax:Bool) -> (Int, Int) -> Int

函数类型及使用

{

每个函数都有种特定的函数类型,由函数的参数类型和返回类型组成。

    return getMax ? max : min

func inputs(no1: Int, no2: Int) -> Int {

}

return no1/no2

 

}

var funcP2:(Int, Int) -> Int = chooseFunc(getMax: true)

inputs 函数类型有两个 Int 型的参数并返回一个 Int 型的值。

print(funcP2(10, 20))

实例如下:

 

import Cocoa

func inputs(no1: Int, no2: Int) -> Int {

return no1/no2

}

print(inputs(no1: 20, no2: 10))

print(inputs(no1: 36, no2: 6))

以上程序执行输出结果为:

2

6

以上函数定义了两个 Int 参数类型,返回值也为 Int 类型。

接下来我们看下如下函数,函数定义了参数为 String 类型,返回值为 String 类型。

func inputstr(name: String) -> String {

return name

}

函数也可以定义一个没有参数,也没有返回值的函数,如下所示:

import Cocoa

func inputstr() {

print

print("www.runoob.com")

}

inputstr()

以上程序执行输出结果为:

菜鸟教程

www.runoob.com

使用函数类型

在 Swift 中,使用函数类型就像使用其他类型一样。例如,你可以定义一个类型为函数的常量或变量,并将适当的函数赋值给它:

var addition: -> Int = sum

解析:

"定义一个叫做 addition 的变量,参数与返回值类型均是 Int ,并让这个新变量指向 sum 函数"。

sum 和 addition 有同样的类型,所以以上操作是合法的。

现在,你可以用 addition 来调用被赋值的函数了:

import Cocoa

func sum(a: Int, b: Int) -> Int {

return a + b

}

var addition: -> Int = sum

print("输出结果: (addition")

以上程序执行输出结果为:

输出结果: 129

函数类型作为参数类型、函数类型作为返回类型

我们可以将函数作为参数传递给另外一个参数:

import Cocoa

func sum(a: Int, b: Int) -> Int {

return a + b

}

var addition: -> Int = sum

print("输出结果: (addition")

func another(addition: -> Int, a: Int, b: Int) {

print("输出结果: (addition

}

another(addition: sum, a: 10, b: 20)

以上程序执行输出结果为:

输出结果: 129

输出结果: 30

函数嵌套

函数嵌套指的是函数内定义一个新的函数,外部的函数可以调用函数内定义的函数。

实例如下:

import Cocoa

func calcDecrement(forDecrement total: Int) -> () -> Int {

var overallDecrement = 0

func decrementer() -> Int {

overallDecrement -= total

return overallDecrement

}

return decrementer

}

let decrem = calcDecrement(forDecrement: 30)

print

以上程序执行输出结果为:

-30

本文由9159.com发布于编程,转载请注明出处: 函数类型是由函数的参数类型和返回值类型组成

关键词: