swift函数

来源：互联网发布：数据机房建设方案编辑：程序博客网时间：2024/04/30 13:49

// main.swift

// xxx

// Created by岳坤 on 15/8/3.

import Foundation

print("Hello, World!")

/* 一.函数的定义和调用

函数的概念：完成某个特定任务的代码块

给代码块起一个合适的名字，称之为函数名

swift函数定义的语法：

fun函数名(参数名:参数类型, 参数名: 参数类型，...) -> 函数返回值类型 {

函数实现部分

}

swift函数调用语法:

函数名(实际参数)

/*函数的参数和返回值

1.函数可以有多个参数

2.函数可以没有返回值或者没有参数

3.函数可以返回多个值 (元组）

//定义一个函数,有一个返回值

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

return a > b ? a : b

}

//函数调用

let max = maxOfValue(3, b: 4)

print("max= \(max)")

//定义一个函数,没有返回值

func showIntegerInArray(array: [Int]) {

for integer in array {

print(integer)

}

//函数的调用

showIntegerInArray([1,2,3,4])

//定义一个函数,返回多个参数(元组)

func getWidthAndHeight(p0: (x: Double, y: Double), p1: (x: Double, y: Double)) -> (width: Double, length: Double) {

return (abs(p1.0 - p0.0), abs(p1.1-p0.1))

}

//函数的调用

let rect = getWidthAndHeight((0,0), p1: (2,1))

print(rect.width)

print(rect.length)

//二:函数的内部参数和外部参数

//函数的使用和声明者不是同一人时，可读性差，不知道参数的含义

//func division(a: Double, b: Double) -> Double {

// return a/b

//}

//let test = division(10, b: 4)

//print(test)

//func division(dividend: Double, divisor: Double) -> Double {

// return dividend/divisor

//}

//let test = division(10, divisor: 4)

//print(test)

//func devision(devidend a: Double, divisor b: Double) -> Double {

// //devidend divisor外部参数

// // a b内部参数

// return a/b

//}

//第二个参数和后续参数默认内部参数名称和外部参数名称一致 (swift2.0 ios项目中都加 #才能让内部和外部参数一致)

func devision(devidend devidend: Double, divisor: Double) -> Double {

return devidend / divisor

}

let test = devision(devidend: 10, divisor: 4)

print(test)

//三:函数的默认参数

//可以给参数设定一个默认值直接赋值

func joinString(s3: String = "#",s1: String, toString s2: String) -> String {

return s1 + s3 + s2

}

////当不传值时间，未默认值

//let str = joinString("111", toString: "22")

//print(str)

////当传值时间,使用传递的参数带有默认参数的参数默认内部和外部参数名一致

//let str1 = joinString("111", toString: "22", s3: "?")

//print(str1)

//默认参数放在第一个参数时间，可省略外部参数名称， c++中，默认参数一般放在最后一个参数

print(joinString("?" ,s1: "aaa", toString: "bb"))

//四:函数的常量和变量性

//func swap(a: Int, b: Int) {

// //默认函数的参数是常量

// let t = a

// a = b

// b = t

//}

//如果我们要在函数内部改变参数的值，要定义为 var变量属性

func swap(var a: Int, var b: Int) {

let t = a

a = b

b = t

}

var a = 2

var b = 3

//swap(a, b: b) //值传递

swap(&a, &b) //把 a 和 b 传递进函数

print(a)

print(b)

//五:inout函数

//inout //输入输出函数

func swap1(inout a: Int, inout b: Int) {

let t = a

a = b

b = t

}

var x = 2

var y = 3

swap1(&x, b:&y)

print(x)

print(y)

//六:变参函数

//参数的个数不确定，组合成数组

func add(array: [Int]) -> Int {

var sum = 0

for value in array {

sum += value

}

return sum

}

print(add([1,2,3,4,5]))

//参数类型一致，用一个参数名代表所有的参数

//可以把这个参数看成一个数组

func add1(array: Int...) -> Int {

var sum = 0

for value in array {

sum += value

}

return sum

}

print(add1(1,2,3,4,5))

//注意变参函数一定要放在最后一个参数上

func addValue(value: Int, array: Int...) -> Int {

var sum = 0

for value1 in array {

sum += value1 + value

}

return sum

}

print(addValue(1, array: 1,2,3,4,5))

//七:函数类型

//函数类型变量/常量

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

return a + b

}

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

return a - b

}

//函数的类型是由函数的参数类型和返回值类型决定的

//(Int, Int) -> Int

//定义一个函数类型的变量

var func1: (Int, Int) -> Int = add2

print(func1(10,11))

func1 = sub

print(func1(11,10))

//函数作为一个参数传递

func funcFunc(a: Int, b:Int, op:(Int,Int)->Int) -> Int {

return op(a,b)

}

print(funcFunc(10, b: 11, op: add2))

print(funcFunc(10, b: 11, 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: Bool) -> (Int, Int)-> Int {

return getMax ? max : min

}

var myFunc = chooseFunc(true)

print(myFunc(10,11))

myFunc = chooseFunc(false)

print(myFunc(10,11))

0 0