swift学习初步（四）-- 函数

好了，让我们开始接着前几天写的系列博客开始今天的这篇博客。在swift里面如果你需要定义一个方法的话，你需要使用关键字：func，请看下面的这段代码：

func sayHello(name:String)->String{

return "hello"+name;

}

在这个方法里面，我们定义了一个String的name参数，同时这个方法返回一个String类型的返回值。请看下面其他类型的方法：

func sayHello(name:String){

println("hello,xiaocai");   //不带返回值，其实在swift里面是返回一个Void类型，一个空的元组

}

func sayHello(number1:Int,number2:Int)->Int{

return number1+number2;   //带多个参数的方法，实参之间用","隔开

}

func sayHello()->String{

return "hello";  //不带实参的方法

}

上面这些方法结构跟其他语言里面都是大同小异的，但是在swift里面还有一些自己特有的方法结构，请看：

func getStudent()->(id:Int,name:String,age:Int){

return (2010,"xiaocai","0");   //我们可以直接组合一个元组返回信息，然后从元组里面取出对应的数值

}

看到上面的那个方法，你可能会疑惑我应该怎样去接受这样的一个返回值呢？其实很简单：

let (id,name,age)=getStudent();   //返回值就对应到三个常量里面去了

上面我们定义的方法只是带有局部的参数，在swift里面还允许我们定义外部参数。那么局部参数和外部参数有什么区别呢？其实局部参数的作用域只在该方法里面，然而外部参数的作用域是可以在方法外的。请看下面的方法：

func localPara(name:String,age:Int)->String{

return "hello name,you are \(age)";

}

然后我们可以这样调用该方法：

println(localPara("xiaocai",age:23));

这是怎么回事呢？为什么第一个实参我们可以直接传入参数，但是第二个实参我们却要在前面加上age:呢？其实在swift里面除了第一个实参之外，后面的参数默认都是全局的参数。那么我们有什么方法可以将所有的实参都定义成全局的吗？有两种方法：

func extendPara(extentName localName:String)->String{

return localName;   //先申明一个全局的参数，然后给出一个本地的参数

}

调用的时候，我们应该如下：

println(extentPara(extentName:"xiaocai"));   //使用这种全局实参的好处就是使代码更加的易懂，读起来就像一句话，这点跟oc是很像的

还有一种申明全局实参的方法如下：

func extentPara(#name:String,#age:Int)->String{

return name+String(age);

}

调用如下：extentPara(name:"xiaocai",age:23);

在swift里面还有另外一种特殊结构的方法，请看：

func keBianPara(numbers:Double...)->Double{

Double sum;

for number in  numbers{

sum+=number;

}

return sum;

}

初一看，你可能会很疑惑这是什么东东呢？参数里面的Double...表示什么意思呢？如果你看过前面的博客你应该还记得...是闭包运算吧！其实Double...就相当于一个Double类型的数组。并且这个数组的长度是可变的，这个方法接收的参数就是可变的Double类型数组。

在swift里面所有的实参默认都是常量的，也就是说在方法里面我们是不允许修改实参的数值。如下的代码：

func changePara(number1:Int,number2:Int)->Int{

number1+=number2;

return number1;

}

这段代码有没有错误呢？这段代码在编译的时候肯定是通不过的，因为number1默认是let类型。如果我们想修改实参的话，我们应该怎么做呢？

func changePara(var number1:Int,number2:Int)->Int{

number1+=number2;

return number1;

}

这样编译运行就是OK的了。让我们来想一想在其他语言里面可以进行这样的操作吗？比如c#里面：

private int ChangePara(int number1,int number2)

{

number1+=number2;

return number1;     //这样可行吗？

}

这样应该是可以的，但是我们一般不进行这样的操作，我们直接：return number1+number2;不是更加的简单直接吗？

在c#里面，我们可以使用in,out关键字来标记当前的参数是按照应用来传递的，让我们来看一看在c#里面的out关键字的使用：

private void UseOutPara(out sting origionName)

{

origionName="xiaocai";

}

那么我们应该怎样去调用呢？

private void TestUseOut()

{

string newName;

UseOutPara(newName);

Console.Writeln(newName);

}

想一想最终输出的newName是什么呢？会是为null,还是“xiaocai”呢？

其实在swift里面也是有inout类型的，但是使用方式不太一样，请看：

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

let temp=a;

a=b;

b=temp;

}

我们再来看一看调用的方式：

var oneInt=3;

var twoInt=107;

swapTwoInts(&oneInt,&twoInt);

println("One:\(ontInt),Two:\(twoInt)");

这个输出会是什么呢？你有没有注意到调用方法里面的实参前面添加了一个&，这个&就是表示该实参是可以修改的。

在swift里面还有一个比较牛逼的地方就是可以允许申明一个函数类型，哈哈哈这个性能真的很有趣。让我们先来搞清楚什么是函数类型呢？我们来看一下下面这个函数结构：

func testFunc(number1:Int,number2:Int)->Int{

return number1+number2;

}

上面那个函数类型是什么呢？有两个Int类型的实参，一个Int类型的返回值，那么我们就说该函数的类型为：(Int,Int)->Int,如果我们将函数类型传递到另外一个函数里面会产生什么效果呢？是不是就相当于产生了一个委托了。我们来看一看下面这个代码：

func testFuncType(funcType:(Int,Int)->Int,number1:Int,number2:Int)->Int{

return funcType(number1,number2);

}

调用这个方法如下：testFuncType(testFunc,10,20);