Function Swift中的函数和方法有什么区别？

我一直认为函数和方法是一样的，直到我通过“Swift编程语言”电子书学习Swift。我发现我不能使用

greet（“John”，“tuday”）

调用我在类中声明的函数，如下面屏幕截图中的电子书所示：

根据此屏幕截图，我收到一个错误，提示“调用中缺少参数标签'day:”：

代码如下：-

import Foundation
import UIKit

class ViewController2: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        //var dailyStatement = greet("John", "Tuesday")
        var dailyStatement = greet("John", day: "Tuesday")
        println(dailyStatement)
    }

    func greet(name: String, day: String) -> String {
        return "Hello \(name), today is \(day)."
    }
}

经过一些研究，我发现了这篇文章：，在我看来，我在类中声明的函数实际上被称为方法。因此，我用来调用方法的语法与我用来调用函数的语法不同

当我用Objective-C编程时，我从未意识到这一点

Swift中的函数和方法有什么区别

我们什么时候在Swift中使用函数，什么时候使用方法

---

正如您自己所说，方法是函数，但在类中。在objective-c中，您从未意识到这一点，因为我们只是在类中编码。我们编写的每个函数都是一个类的方法（ViewController或我们创建的其他类）

在Swift中，我们能够创建不在某个类中的函数。这样做的主要原因是编写不与任何类绑定的函数，并且可以在我们需要它们的任何地方使用它们。因此，如果您有一个与类相关的函数，您可以在类中编写它，并且可以从类的每个实例访问它：

class Square {
   var length: Double
   func area() -> Double {
      return length * length
   }
}

但是如果您需要从任何地方访问函数，那么您就不需要在类中编写它。例如：

func squared(number: Int) -> Int {
    return number * number
}

关于函数和方法之间的语法问题：您猜对了，方法和函数的调用略有不同。这是因为在Objective-C中，我们有很长的方法名，我们喜欢它们，因为我们可以读取方法在做什么，以及参数的用途。因此，在大多数情况下，方法中的第一个参数由函数名本身描述。其他参数不应该只是一些数字、字符串或实例，它们也应该被描述，所以Swift会自动写入变量的名称。如果您想自己描述它，您也可以这样做：

class Something {
    func desc(firstString string1: String, secondString string2:String) {...}
}

---

经过几个小时的阅读和实验，我发现了以下几点：-

在Swift中的功能

函数是执行特定任务的自包含代码块 任务您为函数指定一个名称，该名称标识函数的功能 此名称用于在以下情况下“调用”函数以执行其任务： 需要

资源：

函数参数名称

但是，这些参数名称仅在 函数本身，并且在调用函数时不能使用。这些 各种参数名称为本地参数名，因为 它们仅可在函数体中使用

这意味着默认情况下，函数的所有参数都是本地参数

但是，有时我们想指出每个参数的用途。因此，我们实际上可以为每个参数定义一个外部参数名。示例代码：

func someFunction(externalParameterName localParameterName: Int) {
    // function body goes here, and can use localParameterName
    // to refer to the argument value for that parameter
}

另一种生成外部参数名称的方法是使用哈希符号（#）来缩短名称

func someFunction(#localParameterName: Int) {
    // function body goes here, and can use localParameterName
    // to refer to the argument value for that parameter
}

要使用外部参数调用上述函数，可以使用

someFunction(localParameterName:10)

Swift中的方法

方法是与特定类型关联的函数。 类、结构和枚举都可以定义实例方法， 它封装了使用 给定类型的实例

资源：

但是，本地名称和外部名称的默认行为是 函数和方法不同

具体地说，Swift将方法中的第一个参数名指定为local 默认情况下，参数名，并给出第二个和后续参数 默认情况下，参数名称包括本地和外部参数名称

下面的代码显示了Swift中方法的默认参数和非默认参数的差异

import Foundation
import UIKit

class ViewController2: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        //Default methods calling
        var dailyStatement = greet("Rick", day: "Tuesday")
        println(dailyStatement)

        //First parameter is also an external parameter
        var dailyStatement2 = greet2(name:"John", day: "Sunday")
        println(dailyStatement2)
    }

    //Default: First Parameter is the local parameter, the rest are external parameters
    func greet (name: String, day: String) -> String {
        return "Hello \(name), today is \(day)."
    }

    //Use Hash symbol to make the First parameter as external parameter
    func greet2 (#name: String, day: String) -> String {
        return "Hello \(name), today is \(day)."
    }
}

---

我可能会错过一些重要的细节。希望有人能提供一个更好的答案。

主要是这些名字可以互换使用，而没有人真正想要区分它们。但最终它们确实有区别

someFile.swift

：

func someFunc{
//some code
}

class someClass{

    func someMethod{
    //some code    
    }

}

注意：someClass！=某个文件

someMethod仅对其关联类型“someClass”起作用。然而，对于someFunc来说，情况并非如此。someFunc只在someClass.Swift中，因为从语义上讲，它更适合写在该文件中。只要它标记有

private

---

显然，该方法可以访问

self

。对于函数，没有

self.

。更多信息请参见：

好吧，@Ricky的回答说得差不多。我不知道它们到底是什么。我的想法是：

函数可以在类外部或类/结构/枚举内部定义，而方法必须在类/结构/枚举内部和部分内部定义

我们可以在任何类型定义之外定义函数，也可以在任何类型定义的方法中使用它

这里只是我的理解和说明，希望这有助于其他人，或者如果您觉得需要改进，您可以编辑，或者如果有任何问题，请告诉我：

//This is a Function which prints a greeting message based on the category defined in an 'enum'
func greet(yourName name: String, category: GreetingsCategory) {
    switch  category {
        case .Person:
            print("Hello, " + name + " Today is Tuesday")
        case .Vehicle:
            print("Hello, " + name + " your Vehicle is a Car")
    }
}

//This is an 'enum' for greetings categories
enum GreetingsCategory: String {
    case Person
    case Vehicle
}

//Type: Person
class Person {

    //This is a method which acts only on Person type
    func personGreeting() {
        greet(yourName: "Santosh", category: .Person)
    }
}

//Type: Vehicle
class Vehicle {

    //This is a method which acts only on Vehicle type
    func vehicleGreeting() {
        greet(yourName: "Santosh", category: .Vehicle)
    }
}

//Now making use of our Function defined above by calling methods of defferent types.
let aPerson = Person()
aPerson.personGreeting()
//prints : Hello, Santosh Today is Tuesday

let aVehicle = Vehicle()
aVehicle.vehicleGreeting()
//prints: Hello, Santosh your Vehicle is a Car

//We can also call the above function directly
greet(yourName: "Santosh", category: .Person)

---

下面是关于函数和方法之间区别的简单答案：

有些人交替使用“函数”和“方法”，但有一个 小差别：它们都是可重用的代码块，但是 方法属于类、结构和类

func thisIsAFunction() {
}

struct Person {
    func thisIsAMethod() {
    }
}

func name(parameterName1: Int, parameterName2: String) -> Bool {
    //statements
    return true
}

//Function type for the sample above
(Int, String) -> Bool

MyClass().foo()

MyClass.foo()

//declaration
{ (<parameters>) -> <return type> in
        //body
}

let someClosure:() -> () = {
//closure between {}   
}

//call
someClosure()

public func UIApplicationMain(_ argc: Int32, _ argv: UnsafeMutablePointer<UnsafeMutablePointer<Int8>>!,
 _ principalClassName: String?, _ delegateClassName: String?) -> Int32