Swift 函数

今天给大家介绍 swift函数,swift函数和c#,js的写法大致一直,但是与object-c写法有很大不同点。废话不多说,直接开始了。

1:函数 --常量参数

func 函数名 (参数变量:类型, 参数变量:类型...){}
说明: 
  1: func 是函数关键字
  2:{} 函数体
  3: 参数变量是默认常量类型,不能在函数函数体里面直接修改
  即 func A (value:String)  与 func A (let value:String)写法是相同的,即value 是常量。
  
/*1: func 函数关键字
2:两个参数变量  value 和value1都是常量 不能修改
3:SayHello("hello","swift") 调用函数的方法*/
func SayHello(value:String, value1:String){    
    var str = value + " " +  value1
    println(str)
}
SayHello("hello","swift")

运行结果

hello swift

注意点:----------------------错误写法--------------
func SayHello(value:String, value1:String){
   value = "AA" //错误写法 在函数中参数变量默认是常量类型不能修改
}

2:函数 --变量参数

func 函数名( var  参数变量 : 类型,...){}
说明 
  1: func 函数关键字
  2: var 参数变量 :类型   表示参数变量是可变变量,不是常量,可以任意修改
  
func  SayHello(var value :String){
    value = "AA" //value  是被var 修改,value是可变变量   println(value)
}

SayHello("hello")

运行结果
AA

3:函数 --参数默认值

可以为任何参数设定默认值来作为函数的定义的一部分。如果默认值已经定义,调用函数时就可以省略该参数的传值。

提示:将使用默认值的参数放在函数的参数列表的末尾。这确保了所有调用函数的非默认参数使用相同的顺序,并明确地表示在每种情况下相同的函数调用。

func 函数名(参数值 :类型=默认值){}
说明 
  1:func是函数的关键字
  2:如果参数值,不赋值,参数值就采用默认值

func SayHello(value:String = "AA"){
    println("value=\(value)")
}

SayHello(value:"10") //带参数
SayHello()//不带参赛

运行结果
value=10
value=AA

4:函数 --可变参数

一个可变参数的参数接受零个或多个指定类型的值。当函数被调用时,您可以使用一个可变参数的参数来指定该参数可以传递不同数量的输入值。写可变参数的参数时,需要参数的类型名称后加上点字符(...)。

传递一个可变参数的参数的值时,函数体中是以提供适当类型的数组的形式存在。例如,一个可变参数的名称为numbers和类型为Double...在函数体内就作为名为numbers类型为Double[]的常量数组。

func 函数名(参数名 类型...){}
说明 :
  参数名 类型... 说明   该参数可以接触N个参数。

func SayHello(numbers :Double...){
    for temp in numbers{
        println("temp=\(temp)")
    }
    
}

SayHello(1.1,1.2,1.3)

运行结果
temp=1.1
temp=1.2
temp=1.3

提示:函数可以最多有一个可变参数的参数,而且它必须出现在参数列表的最后以避免多参数函 数调用时出现歧义。如果函数有一个或多个参数使用默认值,并且还具有可变参数,将可变参数放在列表的 最末尾的所有默认值的参数之后。

5:函数 --外部参数名

有时当你调用一个函数将每个参数进行命名是非常有用的,以表明你传递给函数的每个参数的目的。

如果你希望用户函数调用你的函数时提供参数名称,除了设置本地地的参数名称,也要为每个参数定义外部参数名称。你写一个外部参数名称在它所支持的本地参数名称之前,之间用一个空格来分隔。

提示:如果您为参数提供一个外部参数名称,调用该函数时外部名称必须始终被使用。

提示:考虑到使用外部参数名称的初衷就是为了在别人第一次阅读你的代码时并不知道你函数参数的目的是什么。 但当函数调用时如果每个参数的目的是明确的和毫不含糊的,你并不需要指定外部参数名称。

func  函数名 (参数变量:类型 ,参数说明  参数变量:类型)
说明: 
  1:函数中的第一个不需要参数说明
  2:参数说明 + 参数名 : 类型 ,构成一个参数
  调用方法
  函数名(参数值,参数说明:参数值,参数说明:参数值....)

// joinStr value1 : String 是一个参数
func SayHello(value : String, joinStr value1 : String){
    var  str = value + value1
    println("str= \(str)")
}

SayHello ("hello ",joinStr:"Swift")

运行结果
str=hello Swift

外部参数名称速记

如果你想为一个函数参数提供一个外部参数名,然而本地参数名已经使用了一个合适的名称了,你不需要为该参数写相同的两次名称。取而代之的是,写一次名字,并用一个hash符号(#)作为名称的前缀。这告诉Swift使用该名称同时作为本地参数名称和外部参数名称。

// 这个例子定义了一个名为containsCharacter的函数,定义了两个参数的外部参数名称并通过放置一个散列标志在他们本地参数名称之前:
func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
  for character in string {
    if character == characterToFind { return true }
  }
  return false
}

// 这个函数选择的参数名称清晰的、函数体极具可读性,使的该函数被调用时没有歧义:
let containsAVee = containsCharacter(string: "aardvark", characterToFind: "v")
// containsAVee equals true, because "aardvark" contains a "v"

有默认值的外部名称参数

在大多数情况下,为所有参数提供一个外部带有默认值的参数的名称是非常有用的(因此要求)。这将确如果当函数被调用时提供的值时参数必须具有明确的目的。

为了使这个过程更容易,当你自己没有提供外部名称时,Swift自动为所有参数定义了缺省的参数外部名称。自动外部名称与本地名称相同,就好像你在你的代码中的本地名称之前写了一个hash符号。

func join(s1: String, s2: String, joiner: String = " ") -> String {
  return s1 + joiner + s2
}

// 在这种情况下,Swift自动为一个具有默认值的参数提供了外部参数名称。调用函数时,为使得参数的目的明确、毫不含糊,因此必须提供外部名称:
join("hello", "world", joiner: "-")
// returns "hello-world"

6:函数 输入输出参数

可变参数,如上所述,只能在函数本身内改变。如果你想有一个函数来修改参数的值,并且想让这些变化要坚持在函数调用结束后,你就可以定义输入-输出参数来代替。

通过在其参数定义的开始添加inout关键字写用来标明输入-输出参数。一个在输入-输出参数都有一个传递给函数的值,由函数修改后,并从函数返回来替换原来的值。

参数列表中只可以传递一个变量作为一个in-out参数。不能传递一个常数或常值作为参数,因为常量和文字不能修改。你直接在变量名前放置一个连字符(&),当你把它作为一个参数传递给一个in-out参数,表明它可以通过该功能进行修改。

提示:in-out参数不能有默认值,可变参数的参数也不能被标记为inout。如果您标记参数为inout,它不能同时被标记为var或let。

提示:输入输出参数与从函数返回的值是不一样的。上述例子没有定义返回类型或返回一个值,但它仍然会修改someInt和anotherInt的值。输入输出参数是一个函数的另一个影响函数体范围之外的方式。

func 函数名(inout 函数变量 类型)
说明:
  inout 修辞的变量 函数内部可以直接修改,其外部可以获取到 

func SayHello (inout value:String){
    value = "Hello Swift"
}

var str = "hello"
SayHello(&str)  //此时传递 字符串的地址
println(str)

运行结果
Hello Swift

7:函数返回值 --元组(一次返回多个值)

/*
func 函数名 ( 参数变量 : 类型 ,参数说明  参数变量 :类型)-> 类型
1:func 函数关键字
2:->类型 ,返回类型*/

//返回 元组
func SayHello(value:String ,nums Value1:String)->(String,String){    
    return (value,Value1)
}

var (A,B)=SayHello("hello",nums:"swift")

println("A=\(A),B=\(B)")

运行结果 A=hello,B=swift

8:函数返回值 --函数类型作为返回值类型

// 自加函数
func addSelf(num : Int)->Int{
    return num + 1
}

//自减函数
func reduce(num : Int)->Int{
    return num - 1
}

//定义返回函数类型
func SayHello(参数:Bool) ->((Int)->Int){ //其中 (Int)->Int 返回参数为整形,返回值为整形的函数
    return 参数 ? addSelf : reduce
}

var num = 10

var fun:(Int)->Int = SayHello(num > 5);//定义一个变量fun, 由于有类型推断可直接写成 var fun = SayHello(num > 5);

num = fun(num)

println("num=\(num)")

运行结果

num=11

9:嵌套函数

迄今为止所有你在本章中遇到函数都是全局函数,在全局范围内定义。其实你还可以在其他函数中定义函数,被称为嵌套函数。嵌套函数默认对外界是隐藏的,但仍然可以调用和使用其内部的函数。内部函数也可以返回一个嵌套函数,允许在嵌套函数内的另一个范围内使用。

//定义返回函数类型
func SayHello(参数:Bool) ->((Int)->Int){ //其中 (Int)->Int 返回参数为整形,返回值为整形的函数
    
    // 自加函数
    func addSelf(num : Int)->Int{
        return num + 1
    }

    //自减函数
    func reduce(num : Int)->Int{
        return num - 1
    }

    return 参数 ? addSelf : reduce
}


func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int {
        return input + 1
    }
    func stepBackward(input: Int) -> Int {
        return input - 1
    }
    return backwards ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    println("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
println("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!

10:函数类型作为参数

func 乘法(a: Int, b: Int) ->Int{
  return a * b;
}

func 显示结果(a: Int, b: Int, 乘法: (Int,Int)->Int){
  let 结果 = 乘法(a,b);
  println("\(a)乘以\(b)结果是\(结果)");
}

//调用
显示结果(2,3,乘法);

网友评论

无吐槽,不精彩,期待您的参与。

吐槽几句

"(必填)"

"(选填)"

"(必填,不公开)"

(必填,最多100个字符。)

先说这么多吧