1、简单函数
func add(a:Int ,b:Int) -> Int{
return a+b
}
//add 是一个函数名，剩下（）里是参数和对应的参数所属的类型，->是返回参数类型
print("1+2=\(add(a:1,b:2))") //输出 1+2=3
2、无参函数
func sayHello() -> String{
return "hello"
}
print(sayHello())
3、无返回值函数
func welcom() {
print("welcom")
}
welcom()
func welocm2() -> (){
print("welcome2")
}
welocm2()
func welcome3() -> Void{
print("welcome3")
}
welcome3()
4、多个返回值函数
func studentInfo(id: String) -> (name: String, age: Int, sex: String){
var name = "lili"
var age = 13
var sex = "man"
if id == "lili" {
name = "lele"
age = 23
sex = "woman"
}
return (name, age, sex)
}
print(studentInfo(id: "lili"))
let people = studentInfo(id: "lili")
print(people.name)
5、外部参数函数
以上的a、b、id都是在函数内部使用的，这些叫做局部参数名
//如果我们在这些参数名前面再加一个参数名，那前面加的这个参数名就要给外部参数，用的时候必须显示出来
例如
func add2(num1 a: Int, num2 b: Int) -> Int{
return a + b
}
print(add2(num1: 1, num2: 2))
6、含有默认参数的函数
func sayWord(message: String, name: String = "lili") {
print(message, name)
}
sayWord(message: "hello")
sayWord(message: "hi", name: "gg")
7、可变参数的函数
一个可变参数可以接受0个或者多个指定类型的值，函数调用时，使用可变参数来指定函数可以被传入
func addSum(nums: Double...) -> Double{
var sum: Double = 0
for i in nums {
sum += i
}
return sum
}
print(addSum(nums: 1,2,4,5,6,78,9))
8、In - Out（输入输出）函数
一般参数仅仅是在函数内可以改变的，当一个函数执行完后变量就会被销毁，如果想通过一个函数可以修改参数值，并且让这个参数调用结束后依然存在
func testInout(a: inout Int, b: inout Int){
a = 1
b = 2
}
func testInout2(a: inout Int, b: inout Int){
a += 1
b += 2
}
var numA = 100
var numB = 30
testInout(a: &numA, b: &numB)
print("numA = \(numA), numB = \(numB)")
testInout2(a: &numA, b: &numB)
print("numA = \(numA), numB = \(numB)")
testInout2(a: &numA, b: &numB)
print("numA = \(numA), numB = \(numB)")
9、嵌套函数
前面定义的函数都是一个全局函数，定义在全局的作用域中，那我们还有一种函数是定义在另一个函数里面，对外是不可见的，但是可以被外围函数调用的
获取数组中最大的值
func getMaxFromArray(arr: Array<Int>) -> Int{
func compareMax(a: Int, b: Int) -> Int{
if a > b {
return a
}
return b
}
var max = 0
for i in arr {
max = compareMax(a: max, b: i)
}
return max
}
var arr: Array<Int> = [3,7,2,8,4,2,7,3,6,8,4,3,6,3,23]
print(getMaxFromArray(arr: arr))
计算器
func calculator(str: String) -> (Int,Int) -> Int{
func add(a: Int, b: Int) -> Int{
return a + b
}
func sub(a: Int, b: Int) -> Int{
return a - b
}
var result:(Int, Int) -> Int
switch str {
case "+":
result = add
default:
result = sub
}
return result
}
other
func maxMin() -> (Int,Int){
return (Int.min,Int.max)
}
maxMin().0
maxMin().1
func add2(x:Int,increment:Int = 2) -> Int{
return x+increment
}
add2(x:2)
func calculate(x:Int , y: Int ,method : (Int,Int) -> Int) -> Int{
return method(x,y)
}
func xxx(x: Int,y: Int) -> Int{
return x*y
}
calculate(x: 3,y: 4,method: add)
calculate(x: 3,y: 4,method: xxx)
