Swift 基础学习(函数)

/*
(1)函数的定义和调用
函数的概念:完成某个特定任务的代码块,给代码块起一个合
适的名字,称之为函数名,简单来讲,当函数需要被执行的时候,调
用这个名字就可以了.
函数的分类: (1)程序员自定义并实现的函数.(2)"他
人"定义实现的函数
Swift函数定义的语法:
func 函数名(参数名:参数类型,参数名:参数类型...)->
函数返回值类型 { 函数实现部分... }
Swift函数调用语法:
函数名(实际参数...)
*/
//无返回值的函数
func showIntegerArray(array:[Int]){
for a in array {
print("\(a)")
}
}
showIntegerArray([1,6,7,8])

/*
(2)函数的参数和返回值
1.函数可以有多个参数
2.函数可以没有返回值也没有参数
3.函数可以返回多个值
*/
//有多个参数,一个返回值的函数
func maxOfValue(a: Int, b: Int) -> Int {
return a > b ? a : b
}
print(maxOfValue(7, b: 1))
//无返回值无参数的函数
func showHelloWorld() {
print("hello World")
}
showHelloWorld()
//有多个返回值的函数
let p20:(Double, Double) = (1, 1)
let p21:(Double, Double) = (5, 5)
func getLengthAndWidth(p20: (Double, Double), p21: (Double, Double)) -> (length:Double, width:Double) {
return (abs(p20.1-p21.1),abs(p20.0-p21.0))
}
let w12 = getLengthAndWidth(p20, p21: p21).width
let len = getLengthAndWidth(p20, p21: p21).length
print("\(len):\(w12)")

/*
(3)函数的内部参数和外部参数
命名规则遵循四个字:见名之意
*/
func divisionOpertaion(dividend: Double, divsior: Double) ->Double {
return dividend / divsior
}
let res12 = divisionOpertaion(2.9, divsior:4.2)
print(res12)

func divisionOpertaion1(dividend a: Double, divsior b: Double) ->Double {
//要使用内部参数调用
return a / b
}
//调用的时候是显示定义的外部参数,意义在于更加的明了,易于辨识
let res13 = divisionOpertaion1(dividend: 2.9, divsior:4.2)
print(res13)

/*
(4)函数的默认参数
*/
//以前版本默认参数要放在最后边,现在版本没有要求,可以放在前边也可以放在后边
// "hello","world",joiner:"#" --->"hello#world"
func joinString(string100: String, sti: String, joiner: String = "#") -> String {
return string100+joiner+sti
}
let strin = joinString("hello", sti: "world")
print(strin)

/*
(5)常量参数和变量参数
*/
//如果不定义参数类型的话,默认是常量参数,常量参数是不能被修改,以下就会报错
//func swap(a: Int,b: Int) {
//    let tu = a
//    a = b
//    b = tu
//}
//如果我们想要修改,需要将其修改为变量参数即可
func swap1(var a: Int, var b: Int) {
let tu = a
a = b
b = tu
}

/*
(6)输入输出参数(inout)
*/
var qw = 10
var qe = 23
swap1(qw, b: qe)
//输出结果未改变,并没有交换两个数值
print("\(qw),\(qe)")

//如果想要修改,需要将其改为输入输出函数
func swap2(inout a: Int, inout b: Int) {
let tu = a
a = b
b = tu
}
swap2(&qw, b: &qe)
print("\(qw),\(qe)")

/*
(7)变参函数
*/
//参数个数不确定时,但类型都一样时,可以使用数组,变参函数一定要放在尾部
func add(array: Int...) -> Int {
var sum00 = 0
for i in array {
sum00 += i
}
return sum00
}
print(add(1,5,7,7))

/*
(8)函数类型
函数类型变量 / 常量
函数类型参数
函数类型返回值
函数类型由:函数参数类型和返回值类型所决定的
*/
//两个类型相同的函数
func add1(a: Int, b: Int) ->Int{
return a+b
}
func sub(a: Int, b: Int) ->Int{
return a-b
}
//(Int, Int) -> Int,所谓的函数类型
//声明一个函数类型的变量
var calPFunc: (Int, Int) ->Int = add1
calPFunc = sub
print(calPFunc(3, 5))

//函数类型参数,声明一个参数
func calFunc1(a: Int, b: Int, op:(Int, Int) -> Int) -> Int {
return op(a, b)
}
print(calFunc1(3, b: 5, op:sub))

//函数类型返回值
func max(a: Int, b: Int) -> Int {
return a > b ? a : b
}
func min(a : Int, b: Int) -> Int {
return a > b ? b : a
}
func chooseFunc(getMax getMax: Bool) -> (Int, Int) ->Int {
return getMax ? max : min
}
var myFunc: (Int , Int) ->Int = chooseFunc(getMax: true)
print(myFunc(2, 5))