Каковы различия между функциями и методами в Swift?

Я всегда думал, что функции и методы были одинаковыми, пока я не изучал Swift через электронную книгу "Язык программирования Swift". Я узнал, что я не могу использовать greet("John", "Tuesday") чтобы вызвать функцию, которую я объявил внутри класса, как показано в книге на снимке экрана ниже:

объявление функции в swift

Я получил сообщение об ошибке, в котором говорится, что "отсутствует метка аргумента" день: в вызове"в соответствии с этим снимком экрана:

Сообщение об ошибке в Swift

Вот код:-

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.

  1. Каковы различия между функциями и методами в Swift?

  2. Когда мы используем функции и когда мы используем методы в Swift?

Источник

7 ответов

Решение

После нескольких часов чтения и экспериментов вот что я узнал:

Функции в Swift

Функции - это отдельные фрагменты кода, которые выполняют определенную задачу. Вы даете функции имя, которое определяет, что она делает, и это имя используется для "вызова" функции для выполнения ее задачи, когда это необходимо.

Ресурс: Официальная документация Apple по функциям в 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

Методы - это функции, связанные с определенным типом. Классы, структуры и перечисления могут определять методы экземпляров, которые инкапсулируют конкретные задачи и функциональные возможности для работы с экземпляром данного типа.

Ресурс: Официальная документация Apple по методам в Swift

Однако поведение локальных и внешних имен по умолчанию отличается для функций и методов.

В частности, Swift присваивает первому имени параметра в методе локальное имя параметра по умолчанию и по умолчанию дает второму и последующим именам параметров как локальные, так и внешние имена параметров.

Код ниже показывает различия для параметров по умолчанию и не по умолчанию для метода в 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)."
    }
}

Я мог бы пропустить некоторые важные детали. Надеюсь, кто-то может дать лучший ответ.

Источник

Как вы сами сказали, методы - это функции, но в классе. В target-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) {...}
}
Источник

someFile.swift:

func someFunc{
//some code
}

class someClass{

    func someMethod{
    //some code    
    }

}

Примечание: someClass! = SomeFile

someMethod работает только с соответствующим типом, который называется someClass. Однако этого нельзя сказать о некоторых функциях. someFunc есть только в someClass.Swift, потому что семантически он лучше подходит для записи в этот файл. Он мог быть написан в любом другом классе, если он помечен private

Источник

Ну, ответ @ Рики говорит, что это в значительной степени. Я был смущен, что именно они. Итак, вот моя мысль:

Функции могут быть определены вне классов или внутри классов / структур / перечислений, в то время как методы должны быть определены внутри и частью классов / структур / перечислений.

Мы могли бы определить функцию вне определения любого типа и могли бы использовать ее в методах определения любого типа.

Просто мое понимание и иллюстрация здесь, надеюсь, что это поможет кому-то еще, или вы можете отредактировать, если считаете, что необходимо улучшение, ИЛИ дайте мне знать, если что-то не так:

//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)
Источник

функциональный принцип как часть функционального языка

функция - это первоклассный тип (первоклассный гражданин) в Swift

  • присвоить переменной
  • передать как аргумент
  • возвращение

Функция

Functionэто блок кода, который создается для выполнения некоторой задачи. Функция состоит изname, необязательный parameters(name, type), необязательный return type, body.

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

Function type - функции parameter type а также return type

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

Метод

Method - это function который связан с type- класс, структура, перечисление [О программе]:

Instance method - methodкоторый принадлежит экземпляру

MyClass().foo()

Type method - methodкоторый принадлежит самому типу.class или staticиспользуется [О]

MyClass.foo()

Закрытие

Closure- это блок функциональности. Этоfunction который поддерживает capturingконцепция. Это похоже наblockв Objective-C. Также вы можете найти этоClosure это Lambda в мире функциональности, но lambda просто безымянная функция, а Closure сделать копии нелокальной переменной

Замыкание в Swift имеет три следующие формы:

  • global function(с именем, без захвата) - это функция, объявленная в глобальной области видимости (вне области видимости класса). Обычно это определяется как первый уровень.swift файл и не имеет большого объема памяти.
  • nested function(с именем, с захватом включающих переменных функции) - функция внутри другой функции

  • closure expression(без имени, с охватывающим контекстом)

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

    [закрытие без экранирования и закрытие с экранированием]
    http://autoclosure/

Источник

Вот простой ответ о разнице между функциями и методами:

Некоторые люди используют "функцию" и "метод" взаимозаменяемо, но есть небольшая разница: оба они являются кусками кода многократного использования, но методы принадлежат классам, структурам и перечислениям, тогда как функции - нет.

Так:

func thisIsAFunction() {
}

struct Person {
    func thisIsAMethod() {
    }
}

Поскольку методы всегда принадлежат к типу данных, у них есть понятие о себе, которого нет у функций.

источник: https://www.hackingwithswift.com/example-code/language/whats-the-difference-between-a-function-and-a-method

Источник

Множество отличных ответов, но позвольте мне использовать Xcode, чтобы показать что-нибудь визуально из UIKit модуль:

Это функция, потому что она написана на глобальном уровне. Это не метод. Методы ограничены классом.

Снимок экрана, показывающий, что это на глобальном уровне.

Следующая функция находится на глобальном уровне:

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

Иконки для разных символов. (Класс, Метод, Свойство, Протокол, Функция, Расширения - это разные символы)

  • Функция имеет значок вроде 𝓯
  • У метода есть значок M
Источник
Другие вопросы по тегам