Дифференциация между замыканием и функцией в качестве аргумента в swift

Question

У меня почти 4-летний опыт работы с Objective C и новичком в быстром режиме. Я пытаюсь понять концепцию быстрого с точки зрения Objective C. Итак, если я ошибаюсь, пожалуйста, помогите мне через :)

В объективе c у нас есть блоки (фрагмент кода, который может быть выполнен позже асинхронно), который сделал абсолютно идеальный смысл. Но в скором времени мы можем передать функцию как параметр другой функции, которая может быть выполнена позже, а затем мы также закрываем.

В соответствии с Apple«функции являются особыми случаями статей».

Согласно O'Reilly«когда функция передается вокруг как значение, она несет с собой своими внутренними ссылками на внешние переменные. То есть то, что делает функцию замыкания.»

Так что я попытался немного понять то же самое :)

Вот мое закрытие

override func viewDidLoad() { 
     super.viewDidLoad() 
     // Do any additional setup after loading the view, typically from a ni 

     let tempNumber : Int = 5 

     let numbers = [1,2,3,4,5] 
     print (numbers.map({ $0 - tempNumber})) 
} 

Переменная tempNumber объявлена ​​еще до закрытия была объявлена, но крышка имеет доступ к переменная. Теперь, а не карту, я попытался использовать специальный класс, прошедший закрытие в качестве параметра, и попробовал выполнить тот же код :) Хотя теперь закрытие выполняется в разной области, оно все еще имеет доступ к tempNumber.

Я пришел к выводу, что у закрытий есть доступ к переменным и методам, которые объявлены в той же области, что и закрытие, но оно выполняется в разной области.

Теперь, а не проходит закрытие, как параметр Я попытался прохождение функции в качестве параметра,

class test { 
    func testFunctionAsParameter(testMethod : (Int) -> Int){ 
     let seconds = 4.0 
     let delay = seconds * Double(NSEC_PER_SEC) // nanoseconds per seconds 
     let dispatchTime = dispatch_time(DISPATCH_TIME_NOW, Int64(delay)) 

     dispatch_after(dispatchTime, dispatch_get_main_queue(), { 
      self.callLater(testMethod) 
     }) 
    } 

    func callLater(testMethod : (Int) -> Int) -> Int { 
     return testMethod(100) 
    } 
} 

В differrent класса я создал экземпляр теста и использовал его как следовать

/* in differrent class */ 
    override func viewDidLoad() { 
      super.viewDidLoad() 
      // Do any additional setup after loading the view, typically from a ni 

      let tempAge : Int = 5 

      func test2(val : Int) -> Int { 
       return val - tempAge; 
      } 

      let testObj = test(); 
      print(testObj.testFunctionAsParameter(test2)) 
     } 

Объявлен класс, называемый тестом, который имеет метод, называемый testFunctionAsParameter, который, в свою очередь, вызывает другой метод, называемый callLater, и, наконец, этот метод выполняет переданную функцию :)

Теперь все эти цирки, чтобы гарантировать, что переданный метод будет выполнен в разной степени :)

Когда я выполнил вышеуказанный код :), я был потрясен, увидев, что, хотя функция, переданная как параметр, наконец-то выполняется в разной области , по-прежнему имеет доступ к переменному testNumber, который был объявлен в той же области, что и декларация метода :)

Я пришел к выводу: утверждение О'Рейли «когда функция передается как значение, она несет по своим внутренним ссылкам к внешним переменным ". был взломан на :)

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

Другие тогда, синтаксис differrence как закрытие отличается от функции, переданной как аргумент ???Теперь должно быть какое-то различие внутри, иначе Apple не потратила бы столько времени на его разработку :)

Если не объем? то что еще отличает в замыкании и функции? О'Рейли утверждает, что «когда функция передается как значение, она переносит свои внутренние ссылки на внешние переменные, что делает функцию закрытием». так что он пытается указать? что закрытие не будет содержать ссылки на внешние переменные? Теперь они тоже не могут ошибаться, не так ли?

Я схожу с ума с двумя противоречивыми заявлениями от компании Apple и O'Reilly :(Пожалуйста, помогите, я что-то неправильно понять ?? Пожалуйста, помогите мне понять разницу.

Answer 1

В стрижа там действительно нет разницы между функциями и закрытий. замыкание это анонимная функция (функция без имени.) Вот об этом, кроме различий синтаксиса вы заметили.

В функции Objective-C и блоков/закрытия различны.

Answer 2

Основываясь на вашем сообщении, похоже, у вас есть довольно полное понимание по этой теме, и вы может просто потеряться в семантике. Это в основном сводится к:

1. a closure is a closure 
2. a function is a closure with a name 

Вот сообщение с более подробной информацией. Но опять же, это в основном обсуждение семантики. Ответ очень простой.

What is the difference between functions and closures?