Swift函数总结

前端之家收集整理的这篇文章主要介绍了Swift函数总结前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。
//
//  main.swift
//  Swift之函数
//
//  Created by Goddog on 15/7/15.
//  Copyright (c) 2015年 Goddog. All rights reserved.
//

import Foundation

println("Swift融合了面向对象和面向过程的特征,而且Swift支持嵌套函数,每一个函数都有一个类型,包括函数的参数类型和返回值类型,也可以将函数作为参数传递给其他函数,甚至从函数中返回函数类型,函数也可以被写入其他函数中以在函数作用于中封装有用的功能!")

//MARK: - 定义和调用函数
//定义一个函数,声明2个形参,返回值为Int类型
func max(x:Int,y:Int) -> Int
{
    var z = x>y ? x : y
    return z
}
println("x和y最大值是:\(max(1,2))")

//MARK: -无形参函数
func sayHelloSwift() ->String
{
    return "Hello Swift"
}
println("无形参函数: \(sayHelloSwift())")

//MARK: - 函数返回值
//定义一个函数,该函数无形参,也无返回值
func foo()
{
    println("无形参无返回值的函数")
}
//定义一个函数,有形参,无返回值
func sayHi(lug : String) -> ()
{
    println("好好学习\(lug)")
}
//定义一个函数,有形参,无返回值
func showMsg(msg:String,count:Int) ->Void
{
    for _ in 1...count
    {
        println(msg)
    }
}
println(foo())
println(sayHi("Swift"))
println(showMsg("Swift",3))

//MARK: - 多个返回值,你可以使用一个元组类型作为函数的返回类型,来返回一个由多个值组成的复合返回值。
func divide(num:Double) -> (String,String)
{
    var abc = Int64(num)
    var def = round((num - Double(abc)) * 100)
    return ("\(abc)","\(def)")
}
var result = divide(3.14)
println("整数部分:\(result.0),小数部分:\(result.1)")

//MARK: - 递归函数
func fn(n:Int) ->Int
{
    if n==0
    {
        return 1
    }
    else if(n==1)
    {
        return 4
    }
    else
    {
        return 2 * fn(n-1) + fn(n-2)  //函数调用其自身
    }
}
println("递归函数的结果:\(fn(10))")

//MARK: - 外部形参名及其简化形式
func girth(width:Double,height:Double) ->Double
{
    return Double(2) * (width+height)
}
println("矩形周长函数之一:\(girth(2,11))")
//或
func girth(宽 width:Double,高 height:Double) ->Double  //用别名
{
    return Double(2) * (width+height)
}
println("矩形周长函数之二:\(girth(宽:2,高:11))")
//或
func girth(#width:Double,高 height:Double) ->Double   //用#
{
    return Double(2) * (width+height)
}
println("矩形周长函数之三:\(girth(width:2,高:11))")

//MARK: - 形参默认值
//name形参既有默认值又有外部形参名
func saySwift(user name:String="曹操",msg:String)
{
    println("\(name),\(msg)")
}
println(saySwift("魏国"))
println(saySwift(user: "刘备","蜀国"))
//或
func saySwiftTo(msg:String,name:String="曹操")//用_取消外部参数名,func saySwiftTo(msg:String,_ name:String="曹操")
{
    println("\(name),\(msg)")
}
println(saySwiftTo("吴国",name:"孙权"))    //println(saySwiftTo("吴国","孙权"))

//MARK: - 个数可变的形参
func test(a:Int,books : String...)   //加上三点...
{
    //books当作数组处理
    for temp in books
    {
        println(temp)
    }
    println("a的值是:\(a)")
}
println(test(5,"Swift","OC","PHP"))

//MARK: - 常量形参和变量形参,默认是常量形参
func girth(var #width:Double,#height:Double) ->Double
{
    //width是变量形参,可以重新赋值
    width = (width + height) * 2
    return width
}
var s = 2.1
println("变量形参\(girth(width:s,height:10))")
println("s的值没有改变:\(s)")


//MARK: - In-Out形参
/**
对于Swift,程序执行变量赋值,参数传递,程序所传递的只是副本,但是传递的是引用类型时候,函数体内就可以对参数本身发生改变了
除了类、函数、闭包是引用类型之外,Swift绝大部分都是值类型,如何程序确实需要把值类型的参数传入函数内部,则可以使用In-Out参数
In-out形参不同于从函数返回一个值。上边swapTwoInts例子没有定义返回类型或者返回值,但它仍然会修改someInt和anotherInt的值。对函数来说,In-out形参是一个影响函数主体范围外的可选方式。
*/
func swap(inout a:Int,inout b:Int)
{
    let tmp = a
    a = b
    b = tmp
}

var a = 1
var b = 2
swap(&a,&b)   //只可以传入变量,这样就把本身传入了,这里实质是传入变量的指针
println("调用函数之后a值:\(a),b值:\(b)")


//MARK: - 函数类型
//定义一个变量,其类型为(Int,Int) ->Int
var myEare : (Int,Int) ->Int
//计算面积的函数
func area(#width:Int,#height:Int) ->Int
{
    return width * height
}
myEare = area    //函数赋值
println("面积是:\(myEare(3,4))")

//MARK: - 函数类型作为形参类型
//定义函数类型的形参,其中fn是(Int) -> Int 类型的形参
func map(var #data : [Int],#fn : (Int) -> Int) -> [Int]
{
    //遍历data数组中每个元素,并用fn函数对data[i]进行计算
    //然后将计算结果作为新的数组元素
    for var i=0; i<data.count; i++
    {
        data[i] = fn(data[i])
    }
    return data
}
//定义一个计算平方的函数
func square(val : Int) -> Int
{
    return val * val
}
//定义一个计算立方的函数
func cube(val : Int) -> Int
{
    return val * val * val
}
var data = [1,2,3,4,5]
println("计算数组平方:\(map(data:data,fn: square))")
println("计算数组立方:\(map(data:data,fn: cube))")


//MARK: - 使用函数类型作为返回值类型
//定义函数,该函数返回值类型为(Int) -> Int  这是函数类型
func getMathFunc(#type:String) -> (Int) ->Int
{
    switch(type)
    {
        case "square":
            return square
        default:
            return cube
    }
}
var mathFunc = getMathFunc(type: "square")  //这里类似  var mathFunc = getMathFunc
println(mathFunc(2))
mathFunc = getMathFunc(type: "others")
println(mathFunc(3))


//MARK: - 函数重载
//Swift的函数可以定义多个同名函数,只要形参列表或者返回值类型不同就行
func gettest()
{
    println("无参数的test()函数")
}
func gettest(msg : String)
{
    println("有参数无返回值的test()函数")
}
func gettest(msg : String) ->String
{
    println("有参数,有返回值的test()函数:\(msg)")
    return "test"
}
/*
func gettest(books : String...)  //但是调用不能确定是调用func test(msg : String)
{
    println("可变形参:\(books)")
}
*/
gettest()
//gettest("java","swift")


//MARK: - 嵌套函数
//定义函数,该函数返回值类型是(Int)->Int
func getM(#type : String) -> (Int)->Int
{
    //定义一个计算平方的函数
    func square(val : Int) -> Int
    {
        return val * val
    }
    //定义一个计算立方的函数
    func cube(val : Int) -> Int
    {
        return val * val * val
    }
    //该函数返回嵌套函数
    switch(type)
    {
        case "square":
            return square
        default:
            return cube
    }
}
var getmathFunc = getM(type: "square")  //这里类似  var mathFunc = getMathFunc
println(getmathFunc(2))
getmathFunc = getM(type: "others")
println(getmathFunc(3))
Swift融合了面向对象和面向过程的特征,而且Swift支持嵌套函数,每一个函数都有一个类型,包括函数的参数类型和返回值类型,也可以将函数作为参数传递给其他函数,甚至从函数中返回函数类型,函数也可以被写入其他函数中以在函数作用于中封装有用的功能!
x和y最大值是:2
无形参函数: Hello Swift
无形参无返回值的函数

好好学习Swift

Swift
Swift
Swift

整数部分:3,小数部分:14.0
递归函数的结果:10497
矩形周长函数之一:26.0
矩形周长函数之二:26.0
矩形周长函数之三:26.0
曹操,魏国

刘备,蜀国

孙权,吴国

Swift
OC
PHP
a的值是:5

变量形参24.2
s的值没有改变:2.1
调用函数之后a值:2,b值:1
面积是:12
计算数组平方:[1,9,16,25]
计算数组立方:[1,8,27,64,125]
4
27
无参数的test()函数
4
27
Program ended with exit code: 0
原文链接:https://www.f2er.com/swift/326609.html

猜你在找的Swift相关文章