函数类型

/*

/*

斯维夫特函数用来成功一定职分的独自的代码块。Swift使用三个统壹的语法来代表简单的C语言风格的函数到复杂的Objective-C语言风格的法子。函数注明:
告诉编写翻译器函数的名字,重临类型及参数。函数定义: 提供了函数的实业。Swift函数包括了参数类型及重返值类型:函数定义斯维夫特 定义函数使用主要字
func。定义函数的时候,能够钦点二个或几个输入参数和叁个赶回值类型。各个函数都有一个函数名来描述它的成效。通过函数名以及相应项目标参数值来调用这么些函数。函数的参数字传送递的相继必须与参数列表一样。函数的实参传递的逐1必须与形参列表同样,->
后概念函数的归来值类型。语法func funcname -> returntype{ Statement一Statement二 …… Statement N return
parameters}实例以下大家定义了3个函数名字为 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: “谷歌:”, site:
“www.google.com”))以上程序施行输出结果为:新手教程:www.runoob.com谷歌:www.google.com不带参数函数大家得以成立不带参数的函数。语法:func
funcname() -> datatype { return datatype}实例import Cocoafunc
sitename() -> String { return
“新手教程”}print(sitename以上程序实施输出结果为:新手教程元组作为函数再次回到值函数再次来到值类型能够是字符串,整型,浮点型等。元组与数组类似,不相同的是,元组中的成分得以是轻松档次,使用的是圆括号。你能够用元组类型让四个值作为多个复合值从函数中回到。上边包车型大巴那几个例子中,定义了3个名叫min马克斯的函数,功能是在一个Int数组中找寻最小值与最大值。import
Cocoafunc min马克斯(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)”)min马克斯函数重回1个分包四个Int值的元组,这几个值被标识为min和max,以便查询函数的回来值时能够因此名字访问它们。以上程序施行输出结果为:最小值为
-陆 ,最大值为
拾玖假若您不明确重临的元组一定不为nil,那么你能够回去四个可选的元组类型。你能够因此在元组类型的右括号后放置2个问号来定义二个可选元组,例如?或(String,
Int, Bool)?注意可选元组类型如?与元组包蕴可选类型如(Int?,
Int?)是分歧的.可选的元组类型,整个元组是可选的,而不只是元组中的各样成分值。后边的min马克斯函数再次来到了3个涵盖五个Int值的元组。不过函数不会对传播的数组执行此外安检,假若array参数是两个空数组,如上定义的min马克斯在试图访问array[0]时会触发三个运作时不当。为了安全地处理那些”空数组”难点,将min马克斯函数改写为利用可选元组再次来到类型,并且当数组为空时再次来到nil:import
Cocoafunc min马克斯(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)”)}以上程序推行输出结果为:最小值为 -陆,组大值为
拾玖从未有过重回值函数上边是 runoob
函数的另二个本子,那么些函数接收新手教程官方网址网站参数,未有点名再次来到值类型,并直接出口
String 值,而不是回到它:import Cocoafunc runoob(site: String) {
print(“新手教程官方网址:\}runoob(site:

sample(number: Int) { println}以上实例中 number
为局地参数名,只可以在函数体内使用。import Cocoafunc sample(number: Int) {
print}sample(number: 一)sample(number: 贰)sample(number:
三)以上程序执行输出结果为:1②三表面参数名你能够在局地参数名前线指挥部定外部参数名,中间以空格分隔,外部参数名用于在函数调用时传递给函数的参数。如下你能够定义以下四个函数参数名并调用它:import
Cocoafunc pow(firstArg a: Int, secondArg b: Int) -> Int { var res = a
for _ in 1..(members: N…){

一、函数
一、定义1个无参无重返值的函数并拓展调用:
函数类型。func eat(){
print(“eating”)
}
调用函数: eat()
二、定义七个有参数无重回值的函数
func drink( a: Int , b: Int){ //格式:func
函数名(参数名称:参数类型)
print( a + b)
}
调用函数:drink( 10, 20)
三、定义三个有参有再次来到值的函数
func relax(a: Int, b: Int) ->Int { //格式:func
函数名(参数名称:参数类型)-> 重临值类型
return a – b
}
调用函数:var result1 = relax(30, b: 10)
四、元组作为函数的重临值
func run(a: Int , b: Int) ->(a1: Int, b1:Int) {
return (a * 10, b * 10)
}
var r = run(十 , 1贰) //得到 r 为元组, r.a一 和 r.b一 访问元组内的成分
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))
六、函数的表面参数。
要害是为着指明种种参数代表的意义
func login(userName para1: String , passWord para2: String) {
print(“用户名 (para壹)”) // userName 和 passWord 变为外部参数
}
login(userName: “墨觞”,passWord: “12456”)
//忽略参数
func jump(para1: String , _ para2: String) {

 函数类型:

 函数类型:

for i in members {

}
jump (“12三”, “45六”) //由于下划线的来由,
柒、函数的暗中认可参数值
func fly(a: Int, b: Int = 10) -> Int{
return a * b
}
var f = fly(20) //结果:200
var f一 = fly(20, b: 30) //三种艺术调用,暗中同意的初步值能够用,能够不用。
捌.概念可辨参数的函数
通过 …使得函数的参数个数是动态的,函数的参数必须为联合类型
fun sum(numbers: Int…) -> Int { //传入的参数类型必须1切为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(&c一, 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
花样1:把函数类型作为项目的注使用
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 那是2个完整
if a + b > 10 {
return sub
}else {
return add
}
}
var t = test(5, b: 7)
print(t(100, 200)) //结果为:-100

 类似于C语言的针对性函数的指针

 类似于C语言的对准函数的指针

print

 类似于OC语言的block

 类似于OC语言的block

}

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

 函数类型是由函数的参数类型和再次回到值类型组成的

}

 */

 */

vari(members: 4,3,5)

 

 

vari(members: 4.5, 3.1, 5.6)

// 那八个函数类型为: (Int, Int) -> Int

// 那四个函数类型为: (Int, Int) -> Int

vari(members: “Google”, “Baidu”, “Runoob”)

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

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

如上程序实行输出结果为:

{

{

4

    return a + b

    return a + b

3

}

}

5

 

 

4.5

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

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

3.1

{

{

5.6

    return a – b

    return a – b

Google

}

}

Baidu

 

 

Runoob

// 能够应用函数类型定义函数变量和常量

// 能够采纳函数类型定义函数变量和常量

常量,变量及 I/O 参数

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

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

诚如默许在函数中定义的参数都以常量参数,也正是其1参数你只可以够查询利用,不可能改换它的值。

//funcP = sub  // 赋与一样连串都足以

//funcP = sub  // 赋与同等品种都得以

倘诺想要声澳优(Ausnutria Hyproca)个变量参数,可以在参数定义前加 inout
关键字,那样就能够转移那一个参数的值了。

print(funcP(10,20))

print(funcP(10,20))

例如:

 

 

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

// 函数类型能够看做函数的参数

// 函数类型能够视作函数的参数

此刻以此 name 值可以在函数中改动。

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

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

貌似暗许的参数字传送递都以传值调用的,而不是传引用。所以传入的参数在函数内转移,并不影响原本的特别参数。传入的只是其1参数的别本。

{

{

当传入的参数作为输入输出参数时,必要在参数名前加 &
符,表示这么些值能够被函数修改。

    return Option(a, b)

    return Option(a, b)

实例

}

}

import Cocoa

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

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

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

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

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

let temporaryA = a

 

 

a = b

// 函数类型能够当做再次回到值

// 函数类型能够作为重临值

b = temporaryA

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

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

}

{

{

var x = 1

    return a > b ? a : b

    return a > b ? a : b

var y = 5

}

}

swapTwoInts(&x, &y)

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

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

print(“x 今后的值 \, y 未来的值 \

{

{

swapTwoInts 函数简单地调换 a 与 b 的值。该函数先将 a
的值存到1个权且常量 temporaryA 中,然后将 b 的值赋给 a,最终将
temporaryA 赋值给 b。

    return a > b ? b : a

    return a > b ? b : a

内需小心的是,someInt 和 anotherInt 在传出 swapTwoInts 函数前,都加了 &
的前缀。

}

}

上述程序实施输出结果为:

 

 

x 以往的值 5, y 现在的值 一

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

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

函数类型及利用

{

{

各样函数都有种特定的函数类型,由函数的参数类型和重临类型组成。

    return getMax ? max : min

    return getMax ? max : min

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

}

}

return no1/no2

 

 

}

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

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

inputs 函数类型有三个 Int 型的参数并赶回一个 Int 型的值。

print(funcP2(10, 20))

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

}

函数也足以定义2个尚未参数,也未曾重返值的函数,如下所示:

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”)

上述程序实践输出结果为:

输出结果: 12玖

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

咱俩得以将函数作为参数字传送递给其余贰个参数:

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)

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

出口结果: 12玖

出口结果: 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

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website