//
// main.swift
// xxx
//
// Created by 岳坤 on 15/8/3.
// Copyright (c) 2015年 YK. All rights reserved.
//
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))