SWIFT4.0学习01 - 函数的命名、调用以及注意事项

swift语法中函数的使用大概分为以下几种:

1. swift中函数的命名格式
2. 无返回值函数
3. 有参数有返回值的函数
4. 多个返回值的函数
5. 如何定义外部参数名
6. 如何忽略参数名
7. 如何给参数设置默认值
8. 如何定义可变参数
9. 修改外部参数的值,Inout关键字的使用
10. 函数的类型
11. 函数类型作为参数
12. 函数类型作为返回值

废话不说,直接上代码:

 

• swift中函数的命名格式

 

• •  func <#name#>(<#parameters#>) -> <#return type#> {
            <#function body#>
        }
    

    • <#name#>             :  函数名称(可以使用中文命名)
    • <#parameters#>     :  参数 (参数名:参数类型 -> number:Int)
    • <#return type#>     :  函数返回值类型
    • <#function body#> : 函数体

 

• 无返回值函数

 

• •  func 无返回值() {
            print("无返回值函数")
        }　　　　

 

• 有参数有返回值的函数

 

• •  override func viewDidLoad() {
            super.viewDidLoad()
            let sum = 有参数有返回值(numberOne: 1, numberTwo: 2)
            print(sum)
            
        }
        func 有参数有返回值(numberOne:Int, numberTwo:Int) -> Int {
            return numberOne + numberTwo
        }

 

• 多个返回值的函数

 

• •  override func viewDidLoad() {
            super.viewDidLoad()
            let (sub, sum) = 有多组返回值(numberOne: 10, numberTwo: 2)
            print(sub,sum)
        }
        func 有多组返回值(numberOne:Int, numberTwo:Int) -> (sub:Int , sum:Int) {
           return ((numberOne-numberTwo),(numberOne+numberTwo))
        }

 

• 如何定义外部参数名

 

• • 未定义外部参数 　　

    override func viewDidLoad() {
            super.viewDidLoad()
            let str = 未定义外部参数名(strOne: "鸡", strTwo: "肋")
            print(str)
        }
        func 未定义外部参数名(strOne:String,strTwo:String) -> String {
            return strOne+strTwo
        }
    

     

 

• • 定义了外部参数 这样调整即可: func 函数名:(参数名:参数类型)->返回值,调整为 func 函数名:(外部参数名 参数名:参数类型)->返回值

     override func viewDidLoad() {
     super.viewDidLoad()
     let str = 定义外部参数名(frist: "鸡", second: "肋")
     print(str)
     }
     func 定义外部参数名(frist strOne:String, second strTwo:String) -> String {
     return strOne+strTwo
     }
    

     

• 如何忽略参数名　　
  • 定义了外部参数 这样调整即可: func 函数名:(参数名:参数类型)->返回值,调整为 func 函数名:(_ 参数名:参数类型)->返回值

     override func viewDidLoad() {
            super.viewDidLoad()
            let str = 忽略参数名("鸡", "肋")
            print(str)
        }
        func 忽略参数名(_ strOne:String,_ strTwo:String) -> String {
            return strOne+strTwo
        }
    

     

• 如何给参数设置默认值

  • override func viewDidLoad() {
            super.viewDidLoad()
            let str = 给参数设置默认值(strOne: "!")
            print(str)
        }
        func 给参数设置默认值(strOne:String,strTwo:String = "鸡", strThree:String = "肋") -> String {
            return strOne+strTwo+strThree
        }
    

     

  • 注意事项: 将带有默认值的参数,放在参数列表的最后面!!!
• 如何自定义参数的数量
  • 不确定输入参数个数时,可以在参数类型后加上...来自定义参数数量

    override func viewDidLoad() {
            super.viewDidLoad()
            let a = 自定义参数的数量(argNumbers: 1,2,3)
            print(a)
            let b = 自定义参数的数量(argNumbers: 1,2,3,4)
            print(b)
        }
        func 自定义参数的数量(argNumbers:Int...) -> Int {
            var sum = 0
            for number in argNumbers {
                sum += number
            }
            return sum
        }
    

1. 注意事项: 一个函数最多只能有一个参数数量被自定义,且放在参数列表的最后!!!

通过函数方法,修改外部参入参数的值

• 　　

    override func viewDidLoad() {
          super.viewDidLoad()
          var a = 1
          var b = 2
          修改参入的外部参数值(numOne: &a, numTwo: &b)
          print(a,b)        
      }
      func 修改参入的外部参数值(numOne: inout Int, numTwo: inout Int){
          let temp = numOne
          numOne = numTwo
          numTwo = temp
      }
  

   

• 注意事项: 1>inout修饰的参数不能有默认值;2>调用函数时,传入的参数必须是变量!!!

 

• 函数的类型
  • 函数类型的格式: 函数的参数类型和返回值类型组成,例如下面的函数类型为: (String,String,String)->String

     func 给参数设置默认值(strOne:String,strTwo:String = "鸡", strThree:String = "肋") -> String {
     return strOne+strTwo+strThree
     }
    

     

  • 赋值函数功能 例如: 下面函数最终打印结果:testtesttest
    

     override func viewDidLoad() {
            super.viewDidLoad()
            let 函数赋值的载体:(String , String, String)->String = 给参数设置默认值(strOne:strTwo:strThree:)
            let str = 函数赋值的载体("test", "test", "test")
            print(str)
        }
        func 给参数设置默认值(strOne:String,strTwo:String = "鸡", strThree:String = "肋") -> String {
            return strOne+strTwo+strThree
        }
    

     

    　　
• 函数类型做为参数
  • print(result)最终打印结果为3

      override func viewDidLoad() {
            super.viewDidLoad()
            //调用
            operationResult(funParam: 函数类型作为参数(numOne:numTwo:), numOne: 1, numTwo: 2)
        }
        //准备的函数类型
        func 函数类型作为参数(numOne:Int, numTwo:Int) -> Int {
            return numOne+numTwo
        }
        //operationResult 只关心函数类型是否与(Int, Int) -> Int一致; 不关心函数内部实现。
        func operationResult(funParam:(Int, Int) -> Int, numOne:Int, numTwo:Int){
            let result = funParam(numOne, numTwo)
            print(result)
        }
    

     

• 函数类型作为返回值
  • 　　

    override func viewDidLoad() {
            super.viewDidLoad()
            var currentValue = 5
            //sub为函数:加一或者减一
            let sub = 加一还是减一(currentValue > 0)
            while currentValue != 0 {
                currentValue = sub(currentValue)
                print(currentValue)
            }
        }
        //满足加一还是减一函数的返回值类型((Int)->Int)的函数
        func 加一(_ input: Int) -> Int {
            return input+1
        }
        //满足加一还是减一函数的返回值类型((Int)->Int)的函数
        func 减一(_ input: Int) -> Int {
            return input-1
        }
        //(_ condition:Bool)->参数名:参数类型; (Int)->Int->返回值是一个此类型的函数
        func 加一还是减一(_ condition:Bool) -> (Int)->Int {
            return  condition ? 减一:加一
        }

转载于:https://www.cnblogs.com/wangxiaojingtl/p/10092355.html