Quelles sont les différences entre les fonctions et les méthodes dans Swift?
J'ai toujours pensé que les fonctions et les méthodes étaient les mêmes, jusqu'à ce que j'apprenne Swift via le livre électronique "Swift Programming Language". J'ai découvert que je ne pouvais pas utiliser greet("John", "Tuesday") pour appeler un fonction que j'ai déclarée dans une classe, comme le montre le livre électronique dans la capture d'écran ci-dessous:
J'ai reçu une erreur disant que " Libellé d'argument manquant 'jour:' dans l'appel " selon cette capture d'écran:
Voici le code: -
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)."
}
}
Après quelques recherches, j'ai trouvé ce post: Différence entre une méthode et une fonction , et il me semble que la fonction que j'ai déclarée à l'intérieur d'une classe s'appelle en fait une méthode. Ainsi, la syntaxe que j'utilise pour appeler la méthode est différente de la syntaxe que j'utilise pour appeler une fonction.
Je n'ai jamais réalisé cette différence lorsque je programmais en Objective-C.
Quelles sont les différences entre les fonctions et les méthodes dans Swift?
Quand utilisons-nous des fonctions et quand utilisons-nous des méthodes dans Swift?
Après quelques heures de lecture et d'expérimentation, voici les choses que j'ai découvertes: -
Fonctions dans Swift
Les fonctions sont des morceaux de code autonomes qui effectuent une tâche spécifique. Vous donnez à une fonction un nom qui identifie ce qu'elle fait, et ce nom est utilisé pour "appeler" la fonction pour effectuer sa tâche en cas de besoin.
Ressource : Officiel Apple Documentation sur les fonctions dans Swift
Noms des paramètres de fonction
Cependant, ces noms de paramètres sont uniquement utilisés dans le corps de la fonction elle-même et ne peuvent pas être utilisés lors de l'appel de la fonction. Ces types de noms de paramètres sont appelés noms de paramètres locaux, car ils ne sont disponibles que dans le corps de la fonction.
Cela signifie que par défaut, tous les paramètres de Function sont des paramètres locaux .
Mais, parfois, nous voulons indiquer le but de chaque paramètre. Ainsi, nous pouvons réellement définir un nom de paramètre externe pour chaque paramètre. Exemple de code:
func someFunction(externalParameterName localParameterName: Int) {
// function body goes here, and can use localParameterName
// to refer to the argument value for that parameter
}
Une autre façon de créer le nom du paramètre externe consiste à utiliser le symbole de hachage (#) pour raccourcir le nom.
func someFunction(#localParameterName: Int) {
// function body goes here, and can use localParameterName
// to refer to the argument value for that parameter
}
Pour appeler les fonctions ci-dessus avec un paramètre externe, vous pouvez utiliser
someFunction(localParameterName:10)
Méthodes dans Swift
Les méthodes sont des fonctions associées à un type particulier. Les classes, les structures et les énumérations peuvent toutes définir des méthodes d'instance, qui encapsulent des tâches et des fonctionnalités spécifiques pour travailler avec une instance d'un type donné.
Ressource : Officiel Apple Documentation sur les méthodes dans Swift
Cependant, le comportement par défaut des noms locaux et des noms externes est différent pour les fonctions et les méthodes.
Plus précisément, Swift donne au premier nom de paramètre dans une méthode un nom de paramètre local par défaut , et donne au second et les paramètres suivants désignent les noms de paramètres locaux et externes par défaut.
Le code ci-dessous montre les différences pour les paramètres par défaut et non par défaut pour la méthode dans 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)."
}
}
Je pourrais manquer certains détails importants. J'espère que quelqu'un pourra fournir une meilleure réponse.
Comme vous l'avez dit vous-même, les méthodes sont des fonctions, mais dans une classe. En objectif-c, vous ne l'avez jamais réalisé, car nous ne codions que dans les classes. Chaque fonction que nous avons écrite était une méthode d'une classe (ViewController ou une autre classe que nous avons créée).
Dans Swift nous avons la possibilité de créer des fonctions qui ne sont pas dans une classe. La principale raison pour cela est d'écrire des fonctions qui ne sont liées à aucune classe, et peuvent être utilisées où nous en avons besoin Donc, si vous avez une fonction qui est liée à une classe, vous l'écrivez à l'intérieur de la classe et vous pouvez y accéder à partir de chaque instance de la classe:
class Square {
var length: Double
func area() -> Double {
return length * length
}
}
Mais si vous avez besoin d'accéder à la fonction de partout, alors vous ne l'écrivez pas dans une classe. Par exemple:
func squared(number: Int) -> Int {
return number * number
}
À propos de vos problèmes de syntaxe entre les fonctions et les méthodes: vous l'avez deviné, les méthodes et les fonctions sont appelées un peu différemment. C'est parce que dans Objective-C, nous avions des noms de méthode longs et nous les aimions parce que nous pouvions lire ce que faisaient les méthodes et à quoi servaient les paramètres. Ainsi, le premier paramètre d'une méthode est dans la plupart des cas décrit par le nom de la fonction elle-même. Et les autres paramètres ne doivent pas seulement être des nombres, des chaînes ou des instances, ils doivent également être décrits, donc Swift écrit automatiquement le nom de la variable. Si vous voulez la décrire par vous-même vous pouvez aussi le faire:
class Something {
func desc(firstString string1: String, secondString string2:String) {...}
}
Eh bien, la réponse de @ Ricky le dit assez bien. J'étais confus ce qu'ils sont exactement. Voici donc ma pensée:
Les fonctions peuvent être définies en dehors des classes ou à l'intérieur des classes/structs/enums, tandis que les méthodes doivent être définies à l'intérieur et une partie des classes/structs/enums.
Nous pourrions définir une fonction en dehors de la définition de tout type et l'utiliser dans les méthodes de la définition de n'importe quel type.
Juste ma compréhension et mon illustration ici, j'espère que cela aide quelqu'un d'autre ou vous pouvez modifier si vous pensez qu'une amélioration est nécessaire OR faites-moi savoir si quelque chose ne va pas:
//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)
Les noms sont principalement utilisés de manière interchangeable sans que les gens aient une réelle intention de les distinguer. Mais finalement, ils ont une différence.
someFile.Swift:
func someFunc{
//some code
}
class someClass{
func someMethod{
//some code
}
}
Remarque: someClass! = SomeFile
someMethod ne fonctionne que sur son type associé qui est "someClass". Cependant, la même chose ne peut pas être dite pour someFunc. someFunc est uniquement dans le someClass.Swift car sémantiquement il est mieux adapté pour être écrit dans ce fichier. Il aurait pu être écrit dans n'importe quelle autre classe tant qu'il est marqué avec private
Et évidemment, la méthode peut accéder à self. Avec les fonctions, il n'y a pas de self.. Pour plus d'informations, voir: Quelle est la différence entre une méthode et une fonction?
Voici une réponse simple sur la différence entre les fonctions et les méthodes:
Certaines personnes utilisent de manière interchangeable "fonction" et "méthode", mais il y a une petite différence: les deux sont des morceaux de code réutilisables, mais les méthodes appartiennent à des classes, des structures et des énumérations, contrairement aux fonctions.
Donc:
func thisIsAFunction() {
}
struct Person {
func thisIsAMethod() {
}
}
Parce que les méthodes appartiennent toujours à un type de données, elles ont un concept de soi qui ne fonctionne pas.