funcpi() ->Double{
return 3.1415926
}
//形参默认是let 也只能是let
funcsum(x:Int,y:Int) ->Int{
returnx + y
}
print(sum(x:1,y:2))
//隐式返回
funcsum1(x:Int,y:Int) ->Int{
//函数内部只有一句表达式可以不写return
x + y
}
print(sum1(x:1,y:2))
//无返回值写法
func funcReturn() -> Void {
print("无返回值写法一")
}
funcfuncReturn1() -> () {
print("无返回值写法二")
}
func funcReturn2() {
print("无返回值写法三")
}
//返回元组 实现多返回值
funccaluelate(x:Int,y:Int) -> (sum:Int,difference:Int, average :Int) {
letsum = x + y
return(sum,x - y , sum >>1)
}
letresult= caluelate(x:1,y:2)
result.sum
result.difference
result.average
/// 求和(方法备注写法)
///
///将两个数相加
///
/// - Parameter x: 第一个整数
/// - Parameter y: 第二个整数
/// - Returns: 两个整数的和
/// - Note:传入两个整数即可(批准)
///
funcsum2(x:Int,y:Int) ->Int{x + y}
//参数标签
funcgoToWork(attime:String) {
print("this time is\(time)")
}
goToWork(at:"9:00")
//可以使用_省略标签 不推荐使用
funcsum3(_v1 :Int,_v2 :Int) ->Int{v1 + v2}
sum3(1,2)
//参数可以有默认值
funccheck(name:String="zx",age:Int,jod:String="NONE") {
print("name is\(name)age is\(age)jod is\(jod)")
}
check(name:"js", age:18, jod:"code")
check(name:"ee", age:19)
check(age:20, jod:"ces")
check(age:21)
/*
可变参数
注意事项
一个函数只能包含一个可变参数
可变参数后面第一个参数不可省略参数标签名
*/
functest(_numbers :Int...,string:String,_other :String) { }
test(1,2,3,4, string:"text","哈哈哈")
/*
print 使用方法
打印参数可以传多个
separator 多个参数之间的分隔符(默认空格)
terminator 结束后的分隔符(默认换行)
*/
print("弟",2,"哈哈")
print("123","456","789", separator:"____")
print("咕咕哒", separator: "", terminator: "")
/*
inout 输入输出参数
注意事项
inout不能作用于可变参数
inout不能有默认值
inout本质就是指针传递
inout 只能接收可以多次赋值的参数
*/
funcswapValues(_v1 :inoutInt,_v2 :inoutInt) {
lettmp = v1
v1 = v2
v2 = tmp
}
var number1 = 10
var number2 = 20
swapValues(&number1, &number2)
//进阶写法
funcswapValues1(_v1 :inoutInt,_v2 :inoutInt) {
(v1,v2) = (v2,v1)
}
//系统交换方法
swap(&number1, &number2)
/*
函数重载(Function Overload)
规则
函数名相同
函数个数不同 | 参数类型不同 | 参数标签不同
注意点
返回值类型跟函数重载无关
可变参数 省略参数标签 和函数重载一起使用会产生二义性 编译器有可能会报错
*/
func functionOverload(v1 : Int, v2 : Int) -> Int {
returnv1 + v2
}
///参数个数不同
funcfunctionOverload(v1:Int,v2:Int,v3:Int) ->Int{
returnv1 + v2 + v3
}
///参数类型不同
func functionOverload(v1 : Int, v2 : Double) -> Double {
returnDouble(v1) + v2
}
///参数标签不同
funcfunctionOverload(_v1 :Int,_v2 :Int) ->Int{
returnv1 + v2
}
funcfunctionOverload(av1 :Int,bv2 :Int) ->Int{
returnv1 + v2
}
functionOverload(v1:1, v2:2)
functionOverload(v1:1, v2:2, v3:3)
functionOverload(v1:1, v2:1.2)
functionOverload(1,2)
functionOverload(a:1, b:2)
//函数作为参数
funcsum4(v1:Int,v2:Int) ->Int{
returnv1 + v2
}
functest1(_sumFunc : (Int,Int) ->Int,_v3 :Int,_v4 :Int){
print(sumFunc(v3,v4))
}
test1(sum4,1,2)
//函数作为返回类型(高阶函数)
funcnext1(_input :Int) ->Int{
returninput +1
}
funcnext2(_input :Int) ->Int{
returninput -1
}
funcforward(_forward :Bool) -> (Int) ->Int{
forward ? next1 : next2
}
forward(true)(3)
//关键字 typealias用来给类型起别名
typealias Bate = Int8
typealiasDate= (year:Int,month:Int,day:Int)
functest3(_dat :Date) {
print(dat.0)
print(dat.month)
}
test3((2001,2,3))
typealiasintFunc= (Int,Int) ->Int
funcdifference(v1:Int,v2:Int) ->Int{
v1 + v2
}
letfn: intFunc =difference
fn(1,2)
funcsetFn(_fn : intFunc) {}
setFn(difference)
funcgetFn() -> intFunc {
difference
}
//嵌套函数
functest6(isTest:Bool) -> (Int) ->Int{
functest(number:Int) ->Int{
number +1
}
functest2(number:Int) ->Int{
number -1
}
returnisTest ? test : test2
}
test6(isTest:false)
//内联函数关键字(了解)
//never 永远不进行内联优化
//__always 开启编译器优化 方法内代码很多也会内联(递归和动态派发函数依然不会内联)
@inline(never) func test7() {
print("123")
}
@inline(__always)functest8() {
print("456")
}
