函數參數
/*
內部函數: 默認情況下的參數都是內部參數
外部函數: 如果有多個參數的情況, 調用者並不知道每個參數的含義, 只能通過查看頭文件的形式理解參數的含義
那麽能不能和OC一樣讓調用者直觀的知道參數的含義呢? 使用外部參數
外部參數只能外部用, 函數內部不能使用, 函數內部只能使用內部參數
*/
func divisionOperation1(a: Double, b: Double) -> Double{
return a / b
}
func divisionOperation2(dividend: Double, divisor: Double) -> Double {
return dividend / divisor
}
func divisionOperation3(dividend a:Double, divisor b:Double) -> Double {
// return dividend / divisor
return a / b
}
print(divisionOperation1(a: 10, b: 3.5))
print(divisionOperation2(dividend: 10, divisor: 3.5))
print(divisionOperation3(dividend: 10, divisor: 3.5))
func divisionOperation4(a: Double, divisor b:Double) -> Double {
return a / b
}
print(divisionOperation4(a: 10, divisor: 3.5))
/*
// Swift2.0過時
// 在參數前面加上#相當於該參數即是內部參數, 也是外部參數
// 等價於dividend dividend: Double, divisor divisor:Double
func divisionOpertaion5(#dividend: Double, #divisor:Double) -> Double{
return dividend / divisor
}
print(divisionOpertaion5(dividend: 10, divisor: 3.5))
*/
// 取而代之第二個參數開始默認既是外部又是內部
func divisionOperation5(dividend: Double, divisor: Double) -> Double{
return dividend / divisor
}
print(divisionOperation5(dividend: 10, divisor: 3.8))
/*
默認參數:
可以在定義函數的時候給某個參數賦值, 當外部調用沒有傳遞該參數時會自動使用默認值
*/
func joinString(s1:String ,toString s2:String, jioner s3:String) -> String
{
return s1 + s3 + s2
}
func joinString2(s1:String ,toString s2:String, jioner s3:String = "默認值") -> String
{
return s1 + s3 + s2
}
print(joinString2(s1: "hello", toString: "xiaohange"))
//如果指定了默認參數, 但是卻沒有聲明外部參數時, 系統會自動把內部參數名稱既作為內部參數也作為外部參數名稱, 並且在調用時如果需要修改默認參數的值必須寫上外部參數名稱
func joinString3(s1:String ,toString s2:String, jioner:String = "默認值") -> String
{
return s1 + jioner + s2
}
print(joinString3(s1: "hi", toString: "xiaohange" ,jioner: "??"))
//在其它語言中默認參數智能出現在參數列表的最後面, 但是在Swift中可以出現在任何位置
func joinString4(s1:String ,jioner:String ,toString s2:String) -> String
{
return s1 + jioner + s2
}
print(joinString4(s1: "hello", jioner: "HaRi", toString: "Good"))
/*
常量參數和遍歷參數:
默認情況下Swift中所有函數的參數都是常量參數, 如果想在函數中修改參數, 必須在參數前加上var
OC: (OC中函數的參數是便利參數)
- (void)swap:(int)a b:(int)b
{
NSLog(@"交換前:%d %d", a, b);
int temp = a;
a = b;
b = temp;
NSLog(@"交換後:%d %d", a, b);
}
*/
// 2.0 廢棄
//func swap(var a:Int,var b:Int)
//{
//// var a = a
//// var b = b
// print("交換前 a=\(a), b = \(b)")
// let temp = a
// a = b
// b = temp
// print("交換後 a = \(a), b = \(b)")
//}
func swap(a:Int, b:Int)
{
var a = a
var b = b
print("交換前 a = \(a), b = \(b)")
let temp = a
a = b
b = temp
print("交換後 a = \(a), b = \(b)")
}
swap(a:10,b:20)
/*
inout參數, 如果想在函數中修改外界傳入的參數, 可以將參數的var換成inout, 這回會傳遞參數本身而不是參數的值
OC:
- (void)swap:(int *)a b:(int *)b
{
int temp = *a;
*a = *b;
*b = temp;
}
Swift:
// 在以前的語法中是不能傳遞指針的, 必須把參數的var換成inout才可以
func swap2(var a:Int, var b:Int)
{
let temp = a;
a = b;
b = temp;
}
var x = 10;
var y = 20;
print("交換前 a = \(x) b = \(y)")
swap2(&x, b: &y) // 會報錯
print("交換後 a = \(x) b = \(y)")
*/
func swap3(a: inout Int,b: inout Int)
{
let temp = a
a = b
b = temp
}
var x1 = 10
var y1 = 20
print("交換前 x1 = \(x1), y1 = \(y1)")
swap3(a: &x1, b: &y1)
print("交換後 x1 = \(x1), y1 = \(y1)")
/*
變參函數
如果沒有變參函數 , 並且函數的參數個數又不確定那麽只能寫多個方法或者用將函數參數改為集合
變參只能放到參數列表的最後一位, 變參必須指定數據類型, 變參只能是同種類型的數據
*/
func add1(num1:Int, num2:Int, num3:Int) -> Int
{
let sum = num1 + num2 + num3
return sum
}
print(add1(num1: 1, num2: 2, num3: 3))
func add2(nums:[Int]) -> Int {
var sum = 0
for num in nums {
sum += num
}
return sum
}
print(add2(nums: [1,2,3]))
func add3(nums:Int...) -> Int
{
var sum = 0
for num in nums {
sum += num
}
return sum
}
print(add3(nums: 1,2,3))
func add4(otherNum:Int, nums:Int...) -> Int
{
var sum = 0
for num in nums {
sum += num
}
return sum + otherNum
}
print(add4(otherNum: 100, nums: 1,2,3)) //會將100傳遞給第一個參數, 後面的傳遞給nums
函數參數