函数类型

By admin in 4858.com on 2019年4月22日

/*

/*

Swift函数用来达成一定职分的单独的代码块。斯维夫特命全权大使用3个会集的语法来表示轻巧的C语言风格的函数到复杂的Objective-C语言风格的不二等秘书技。函数表明:
告诉编译器函数的名字,再次来到类型及参数。函数定义: 提供了函数的实业。斯维夫特函数包蕴了参数类型及重临值类型:函数定义Swift 定义函数使用首要字
func。定义函数的时候,能够内定多个或多少个输入参数和三个赶回值类型。每种函数都有二个函数名来叙述它的职能。通过函数名以及相应品种的参数值来调用那一个函数。函数的参数字传送递的一一必须与参数列表同样。函数的实参传递的各种必须与形参列表一样,->
后概念函数的回来值类型。语法func funcname -> returntype{ Statement一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: “谷歌:”, site:
“www.google.com”))以上程序试行输出结果为:新手教程:www.runoob.com谷歌(Google):www.google.com不带参数函数大家得以制造不带参数的函数。语法:func
funcname() -> datatype { return datatype}实例import Cocoafunc
sitename() -> String { return
“菜鸟教程”}print(sitename以上程序试行输出结果为:新手教程元组作为函数再次回到值函数重回值类型能够是字符串,整型,浮点型等。元组与数组类似,差别的是,元组中的成分得以是随便等级次序,使用的是圆括号。你可以用元组类型让七个值作为1个复合值从函数中回到。上边包车型大巴这些例子中,定义了一个名称叫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马克斯函数重返2个含有多少个Int值的元组,这一个值被标识为min和max,以便查询函数的回来值时能够通过名字访问它们。以上程序实践输出结果为:最小值为
-陆 ,最大值为
十九借使你不明显重临的元组一定不为nil,那么您能够回到三个可选的元组类型。你能够通过在元组类型的右括号后放置一个问号来定义一个可选元组,比方?或(String,
Int, Bool)?注意可选元组类型如?与元组包蕴可选类型如(Int?,
Int?)是不一样的.可选的元组类型,整个元组是可选的,而不只是元组中的每种成分值。后边的min马克斯函数重临了2个分包五个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)”)}以上程序实行输出结果为:最小值为 -6,组大值为
10玖未曾回来值函数上面是 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: 二)sample(number:
三)以上程序实践输出结果为:1二叁表面参数名你能够在局地参数名前点名外部参数名,中间以空格分隔,外部参数名用于在函数调用时传递给函数的参数。如下你能够定义以下多少个函数参数名并调用它:import
Cocoafunc pow(firstArg a: Int, secondArg b: Int) -> Int { var res = a
for _ in 1..(members: N…){

一、函数
壹、定义2个无参无再次来到值的函数并实行调用:
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 result一 = relax(30, b: 十)
四、元组作为函数的重返值
func run(a: Int , b: Int) ->(a1: Int, b1:Int) {
return (a * 10, b * 10)
}
var r = run(拾 , 1贰) //获得 r 为元组, r.a一 和 r.b一 访问元组内的成分
伍、多参量函数 。 函数可以有三种分化类型的参数
//函数一:
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(“用户名 (para一)”) // userName 和 passWord 变为外部参数
}
login(userName: “墨觞”,passWord: “12456”)
//忽略参数
func jump(para1: String , _ para2: String) {

 函数类型:

4858.com, 函数类型:

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 { //传入的参数类型必须全方位为Int类型
var result1 = 0
for index in numbers {
result1 += index
}
return result1
}
var sumResult = sum(12, 3, 4, 56)
print(sumResult)
玖、函数的常量参数和变量参数
暗中同意情形下,函数的参数默以为常量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: &c贰) //&表达是输入输出参数
1一、函数类型的行使
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语言的针对函数的指针

 类似于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  // 赋与同等档案的次序都得以

假定想要声雀巢(Nestle)个变量参数,能够在参数定义前加 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
的值存到3个临时常量 temporaryA 中,然后将 b 的值赋给 a,最终将
temporaryA 赋值给 b。

    return a > b ? b : a

    return a > b ? b : a

亟待专注的是,someInt 和 anotherInt 在传播 swapTwoInts 函数前,都加了 &
的前缀。

}

}

上述程序推行输出结果为:

 

 

x 今后的值 伍, 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

}

函数也足以定义多少个不曾子舆数,也未有重返值的函数,如下所示:

import Cocoa

func inputstr() {

print

print(“www.runoob.com”)

}

inputstr()

上述程序试行输出结果为:

菜鸟教程

www.runoob.com

使用函数类型

在 Swift中,使用函数类型就像是使用别的品种同样。举例,你能够定义三个项目为函数的常量或变量,并将11分的函数赋值给它:

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

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有