У меня почти 4 года опыта работы с Objective C и новичком в Swift. Я пытаюсь понять концепцию Свифта с точки зрения Цели С. Так что, если я ошибаюсь, проведите меня через :)

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

Согласнояблоко «функции - это особые случаи предложений».

Согласно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)
    }
}

В другом классе я создал экземпляр Test и использовал его следующим образом

/* 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))
        }

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

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

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

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

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

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

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

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