iOS. Приемы программирования Нахавандипур Вандад

До того как появился GCD, программисту приходилось создавать собственные потоки для параллельного решения задач. Примерно такой поток разработчик iOS создаст для того, чтобы выполнить определенную операцию 1000 раз:

— (void) doCalculation{

/* Здесь происходят вычисления. */

}

— (void) calculationThreadEntry{

@autoreleasepool {

NSUInteger counter = 0;

while ([[NSThread currentThread] isCancelled] == NO){

[self doCalculation];

counter++;

if (counter >= 1000){

break;

}

}

}

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

/* Начинаем поток. */

[NSThread detachNewThreadSelector:@selector(calculationThreadEntry)

toTarget: self

withObject: nil];

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Программист должен создать поток вручную, а потом придать ему требуемую структуру (точку входа, автоматически высвобождаемый пул и основной цикл потока). Когда мы пишем аналогичный код с помощью GCD, нам на самом деле приходится сделать не так уж много. Мы просто помещаем наш код в блоковый объект и направляем этот блок в GCD для выполнения. Где именно будет выполняться данный код — в главном потоке или в каком-нибудь другом, — зависит именно от нас. Вот пример:

dispatch_queue_t queue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

size_t numberOfIterations = 1000;

dispatch_async(queue, ^(void) {

dispatch_apply(numberOfIterations, queue, ^(size_t iteration){

/* Здесь выполняется операция. */

});

});

В этой главе будет рассказано обо всем, что нужно знать о GCD. Здесь вы научитесь писать современные многопоточные приложения для iOS и Mac OS X, помогающие достичь впечатляющей производительности на таких многоядерных устройствах, как iPad 2.

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

 Главная очередь — занимается выполнением всех задач из главного потока, и именно здесь Cocoa и Cocoa Touch требуют от программиста вызывать все методы, относящиеся к пользовательскому интерфейсу. Пользуйтесь функцией dispatch_get_main_queue, помогающей управлять главной очередью.

 Параллельные очереди — это очереди, которые можно получать из GCD для выполнения синхронных или асинхронных задач. В нескольких параллельных очередях могут одновременно выполняться несколько задач, причем с завидной легкостью. Представляете, больше никакого управления потоками, ур-р-ра! Пользуйтесь функцией dispatch_get_global_queue, помогающей управлять параллельными очередями.

 Последовательные очереди — всегда выполняют поставленные в них задачи по принципу «первым пришел — первым обслужен» (First In First Out, FIFO). При этом не имеет значения, являются эти задачи синхронными или асинхронными. Такой принцип работы означает, что последовательная очередь может выполнять в любой момент только один блок кода. Однако такие очереди не применяются в главном потоке, поэтому отлично подходят для решения задач, которые должны выполняться в строгом порядке и не блокировать при этом главный поток. Чтобы создать последовательную очередь, пользуйтесь функцией dispatch_queue_create.

Существуют два механизма отправки задач в диспетчерские очереди:

блочные объекты (см. раздел 7.1);

• функции C.

Блочные объекты позволяют наиболее эффективно использовать GCD и его огромный потенциал. Некоторые функции GCD были расширены таким образом, чтобы программист мог использовать функции C вместо блочных объектов. Однако в действительности лишь небольшое подмножество GCD-функций допускают замену объектов функциями C, поэтому перед дальнейшим изучением материала обязательно ознакомьтесь с разделом о блочных объектах (разделом 7.1).

Функции C, предоставляемые различным GCD-функциям, должны относиться к типу dispatch_function_t. Вот как этот тип определяется в библиотеках Apple:

typedef void (*dispatch_function_t)(void *);

Итак, если мы хотим, например, создать функцию под названием myGCDFunction, потребуется реализовать ее следующим образом:

void myGCDFunction(void * paramContext){

/* Вся работа выполняется здесь */

}

Параметр paramContext относится к контексту, который GCD позволяет передавать C-функциям при диспетчеризации задач к этим функциям. Вскоре мы подробно об этом поговорим.

Блочные объекты, передаваемые GCD-функциям, не всегда имеют одинаковую структуру. Некоторые должны принимать параметры, другие — нет, но ни один блочный объект, передаваемый GCD, не возвращает значения.

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

Блоковые объекты — это пакеты с кодом, которые в Objective-C обычно имеют форму методов. Блоковые объекты вместе с GCD образуют гармоничную среду, в которой можно создавать высокопроизводительные многопоточные приложения для iOS и Mac OS X. Вы можете спросить: «А что же такого особенного в блоковых объектах и GCD?» Ответ прост: больше никаких потоков! Все, что от вас требуется, — поместить код в блоковые объекты и перепоручить GCD выполнение этого кода.

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

Блоковые объекты в Objective-C — это сущности, которые в среде программистов принято называть объектами первого класса. Это означает, что вы можете создавать код динамически, передавать блоковый объект методу в качестве параметра и возвращать блоковый объект от метода. Все это позволяет более уверенно выбирать, что вы хотите делать во время исполнения и изменять ход действия программы. В частности, GCD может выполнять блоковые объекты в отдельных потоках. Поскольку блоковые объекты являются объектами Objective-C, с ними можно обращаться как с любыми другими объектами.

Иногда блоковые объекты называются замкнутыми выражениями (Closures).

Создание блоковых объектов напоминает создание обычных функций языка C, как будет показано в разделе 7.1. Блоковые объекты могут возвращать значения и принимать параметры. Блоковые объекты можно определять как встраиваемые либо обрабатывать как отдельные блоки кода наподобие функций языка C. При создании встраиваемым способом область видимости переменных, доступных блоковым объектам, существенно отличается от аналогичной области видимости, если блоковый объект реализуется как отдельный блок кода.

GCD работает с блоковыми объектами. При выполнении задач с помощью GCD вы можете передавать блоковый объект, код которого будет выполняться синхронно или асинхронно в зависимости от того, какие методы используются в GCD. Следовательно, вы можете создать блоковый объект, который будет отвечать за загрузку данных по URL (универсальному идентификатору ресурса), передаваемому в качестве параметра. Такой отдельный блоковый объект можно синхронно или асинхронно использовать в различных местах приложения на ваш выбор. Не требуется делать блоковый объект синхронным или асинхронным по сути. Вы всего лишь будете вызывать его с помощью тех или иных методов, относящихся к GCD, — синхронных или асинхронных, — и блоковый объект будет просто работать.

Блоковые объекты — довольно новое явление для программистов, создающих приложения для iOS и Mac OS X. На самом деле блоковые объекты пока еще уступают по популярности потокам, поскольку их синтаксис несколько отличается от организации обычных методов Objective-C и более сложен. Тем не менее потенциал блоковых объектов огромен, и Apple довольно активно внедряет их в свои библиотеки. Такие дополнения уже можно заметить в некоторых классах, например NSMutableArray. Здесь программист может сортировать массив с помощью блокового объекта.

Эта глава целиком посвящена созданию и использованию блоковых объектов в приложениях для iOS и Mac OS X, использованию GCD для передачи задач операционной системе, а также работе с потоками и таймерами. Я хотел бы подчеркнуть, что единственный способ освоить синтаксис блоковых объектов — написать несколько таких объектов самостоятельно. Изучите код примеров, которые сопровождают эту главу, и попробуйте реализовать собственные блоковые объекты.

В данной главе будут рассмотрены базовые вопросы, связанные с блоковыми объектами, а потом мы обсудим некоторые более сложные темы. В частности, поговорим об интерфейсе Grand Central Dispatch, о потоках, таймерах, операциях и очередях операций. Вы усвоите все, что необходимо знать о блоковых объектах, а потом перейдете к материалу о GCD. По моему опыту, лучше всего изучать блоковые объекты на примерах, поэтому данная глава изобилует примерами. Обязательно опробуйте их в Xcode, чтобы по-настоящему усвоить синтаксис блоковых объектов.

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

В Cocoa выполняются операции трех типов:

 блоковые операции — обеспечивают выполнение одного или нескольких блоковых объектов;

 активизирующие операции — позволяют активизировать метод в другом, уже существующем объекте;

 обычные операции — это классы обычных операций, от которых необходимо создавать подклассы. Код, который нужно выполнить, следует писать в методе main объекта операции.

Как уже упоминалось ранее, управлять операциями можно с помощью очередей операций, относящихся к типу данных NSOperationQueue. После инстанцирования операции любого из упомянутых типов (блоковой, активизирующей или обычной) их можно добавить в очередь операций и перепоручить управление операцией самой очереди.

Объект операции может зависеть от других объектов операций. Можно приказать объекту операции дождаться, пока не выполнится одна или несколько иных операций, и только после этого приказать ему решить ассоциированную с ним задачу. Без применения зависимостей вы никак не сможете влиять на порядок выполнения операций. Так, если добавить операции в очередь в определенном порядке, это не гарантирует выполнения операций в том же порядке, несмотря на то что термин «очередь» это как бы подразумевает.

Работая с операциями и очередями операций, не следует забывать о нескольких важных вещах.

По умолчанию операция выполняется в том потоке, который ее начал с помощью их метода экземпляра start. Если вы хотите, чтобы операции выполнялись асинхронно, нужно использовать либо очередь операций, либо подкласс NSOperation и выделить новый поток в методе экземпляра main, относящегося к операции.

• Операция может дождаться окончания выполнения другой операции и только после этого начаться. Будьте осторожны и не создавайте взаимозависимых операций. Такая распространенная ошибка называется взаимоблокировкой, или клинчем (Deadlock). Иными словами, нельзя ставить операцию А в зависимость от операции B, если операция B уже зависит от операции A. В таком случае они обе будут ждать вечно, расходуя память и, возможно, вызывая зависание приложения.

• Операции можно отменять. Так, если вы создаете подклассы от NSOperation, чтобы делать собственные виды объектов операций, обязательно пользуйтесь методом экземпляра isCancelled. Он применяется, чтобы проверить, не была ли отменена определенная операция, прежде чем переходить к выполнению задачи, связанной с этой операцией. Например, если задача вашей операции — проверять доступность соединения с Интернетом раз в 20 с, то перед каждым запуском операции нужно вызвать метод экземпляра isCancelled, чтобы сначала убедиться, что операция не отменена, и только после этого пытаться проверять наличие соединения с Интернетом. Если на выполнение операции уходит более нескольких секунд (например, если это загрузка файла), то при выполнении задачи нужно также периодически проверять метод isCancelled.

• Объекты операций обязаны выполнять «уведомление наблюдателей об изменениях в свойствах наблюдаемого объекта» (KVO, Key-Value Observing) на различных ключевых путях, в частности isFinished, isReady и isExecuting. В одной из следующих глав мы обсудим механизм KVO, а также KVC — механизм для доступа к полям объекта по именам этих полей.

• Если вы планируете создавать подкласс от NSOperation и выполнять специальную реализацию для операции, вам следует создать собственный автоматически высвобождаемый пул в методе main, относящемся к операции. Данный метод вызывается из метода start. Эти вопросы мы подробнее рассмотрим далее в этой главе.

• Всегда сохраняйте ссылки на создаваемые вами объекты операций. Сама параллельная природа, присущая очередям операций, исключает возможность получения ссылки на операцию после того, как она добавлена в очередь.

Потоки и таймеры — это объекты, являющиеся подклассами от NSObject. Для порождения потока выполняется больше работы, чем для создания таймеров, а настройка цикла потока — более сложная задача, чем обычное слушание таймера, запускающего селектор. Когда приложение работает в операционной системе iOS, система создает для этого приложения как минимум один поток. Этот поток называется главным (Main Thread). Все потоки и таймеры должны добавляться в цикл исполнения (Run Loop). Цикл исполнения, как понятно из его названия, — это цикл, в ходе которого могут происходить разные события, например запуск таймера или выполнение потока. Обсуждение циклов исполнения выходит за рамки этой главы, но иногда я буду упоминать такой цикл.

Цикл исполнения — это, в сущности, обычный цикл, у которого есть начальная точка, условие завершения и серия событий, которые необходимо обработать в ходе этого цикла. Поток или таймер прикрепляются к циклу исполнения, и, в сущности, именно они заставляют цикл исполнения работать.

Главный поток приложения — это тот поток, который обрабатывает события пользовательского интерфейса. Если вы выполняете в главном потоке долговременную задачу, то быстро станет заметно, что интерфейс перестает отвечать на запросы или реагирует медленно. Во избежание этого можно создавать отдельные потоки и/или таймеры, каждый из которых выполняет собственную задачу (даже если она сравнительно долговременная). Но при этом главный поток не будет блокироваться.

7.1. Создание блоковых объектов

Постановка задачи

Необходимо иметь возможность писать собственные блоковые объекты либо использовать блоковые объекты с классами из iOS SDK.

Решение

Просто необходимо понимать базовую разницу между синтаксисом блоковых объектов и синтаксисом классических функций языка C. Эта разница рассматривается в подразделе «Обсуждение» данного раздела.

Обсуждение

Блоковые объекты могут быть либо встраиваемыми, либо записываемыми как отдельные блоки кода. Начнем с объектов второго типа. Предположим, у нас есть метод языка Objective-C, принимающий два целочисленных значения типа NSInteger и возвращающий разницу двух этих значений в форме NSInteger. Разница получается в результате вычитания одного значения из другого:

— (NSInteger) subtract:(NSInteger)paramValue

from:(NSInteger)paramFrom{

return paramFrom — paramValue;

}

Очень просто, правда? Теперь преобразуем этот код Objective-C в классическую функцию языка C, обеспечивающую такую же функциональность. Это еще на шаг приблизит нас к пониманию синтаксиса блоковых объектов:

NSInteger subtract(NSInteger paramValue, NSInteger paramFrom){

return paramFrom — paramValue;

}

Как видите, синтаксис функции на C значительно отличается от синтаксиса аналогичной функции на языке Objective-C. Теперь рассмотрим, как можно написать ту же функцию в виде блокового объекта:

NSInteger (^subtract)(NSInteger, NSInteger) =

^(NSInteger paramValue, NSInteger paramFrom){

return paramFrom — paramValue;

};

Прежде чем перейти к детальному описанию синтаксиса блоковых объектов, приведу еще несколько примеров. Предположим, что у нас есть функция на языке C, принимающая параметр типа NSUInteger (беззнаковое целое число) и возвращающая строку типа NSString. Вот как данная функция реализуется на C:

NSString* intToString (NSUInteger paramInteger){

return [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

}

Чтобы научиться форматировать строки с применением системонезависимых указателей формата на языке Objective-C, ознакомьтесь с String Programming Guide in the iOS Developer Library (Руководство по программированию строк в библиотеке разработчика iOS). Адрес документа на сайте Apple: https://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/Strings/Articles/formatSpecifiers.html.

Блоковый объект, эквивалентный данной функции языка C, показан в примере 7.1.

Пример 7.1. Образец блокового объекта, определенного в виде функции

NSString* (^intToString)(NSUInteger) = ^(NSUInteger paramInteger){

NSString *result = [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

return result;

};

Простейший независимый блоковый объект — это блоковый объект, возвращающий void и не принимающий никаких параметров:

void (^simpleBlock)(void) = ^{

/* Здесь реализуется блоковый объект. */

};

Блоковые объекты инициируются точно так же, как и функции на языке C. Если у них есть какие-либо параметры, то вы передаете их так, как и в функции C. Любое возвращаемое значение можно получить точно так же, как и возвращаемое значение функции на языке C. Вот пример:

NSString* (^intToString)(NSUInteger) = ^(NSUInteger paramInteger){

NSString *result = [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

return result;

};

— (void) callIntToString{

NSString *string = intToString(10);

NSLog(@"string = %@", string);

}

Метод callIntToString языка Objective-C вызывает блоковый объект intToString, передавая этому блоковому объекту в качестве единственного параметра значение 10 и помещая возвращаемое значение данного блокового объекта в локальную переменную string.

Теперь, когда мы знаем, как писать блоковые объекты в виде независимых блоков кода, рассмотрим передачу блоковых объектов как передачу параметров методам языка Objective-C. Чтобы понять смысл следующего примера, нужно прибегнуть к определенным абстракциям.

Предположим, у нас есть метод Objective-C, принимающий целое число и выполняющий над ним какое-либо преобразование. Такое преобразование может меняться в зависимости от того, что еще происходит в программе. Мы уже знаем, что у нас будет целое число в качестве ввода и строка в качестве вывода, но сам процесс преобразования поручим блоковому объекту — а этот объект может быть иным при каждом вызове метода. Следовательно, в качестве параметров данный метод будет принимать и целое число, которое необходимо преобразовать, и тот блок, который будет выполнять преобразование.

Для блокового объекта воспользуемся тем же блоковым объектом intToString, который мы реализовали в примере 7.1. Теперь нам нужен метод на языке Objective-C, который будет принимать в качестве параметра беззнаковое целое число, а в качестве еще одного параметра — блоковый объект. С беззнаковым целым в качестве параметра все просто, но как сообщить методу, что он должен принимать блоковый объект того же типа, к которому относится блоковый объект intToString? Сначала определяем псевдоним сигнатуры блокового объекта intToString (с помощью ключевого слова typedef) и таким образом сообщаем компилятору, какие параметры должен принимать блоковый объект:

typedef NSString* (^IntToStringConverter)(NSUInteger paramInteger);

Объявление typedef просто сообщает компилятору, что блоковые объекты, принимающие в качестве параметра целое число и возвращающие строку, можно представлять с помощью обычного идентификатора, называемого IntToStringConverter. Итак, пойдем дальше и напишем метод на Objective-C, который будет принимать в качестве параметров и целое число, и блоковый объект типа IntToStringConverter:

— (NSString *) convertIntToString-NSUInteger)paramInteger

usingBlockObject-IntToStringConverter)paramBlockObject{

return paramBlockObject(paramInteger);

}

Теперь требуется просто вызвать метод convertIntToString:, сопровождаемый объектом на наш выбор (пример 7.2).

Пример 7.2. Вызов блокового объекта в другом методе

— (void) doTheConversion{

NSString *result = [self convertIntToString:123

usingBlockObject: intToString];

NSLog(@"result = %@", result);

}

Теперь, когда мы немного разбираемся в независимых блоковых объектах, поговорим о встраиваемых блоковых объектах. В только что рассмотренном методе doTheConversion мы передавали методу convertIntToString: usingBlockObject: в качестве параметра блоковый объект intToString. Что если бы у нас не было в распоряжении готового блокового объекта, который можно было бы передать этому методу? На самом деле это не доставило бы нам никаких проблем. Как уже упоминалось, блоковые объекты — это функции первого класса и их можно создавать во время исполнения. Рассмотрим альтернативную реализацию метода doTheConversion (пример 7.3).

Пример 7.3. Блоковый объект, определенный в виде функции

— (void) doTheConversion{

IntToStringConverter inlineConverter = ^(NSUInteger paramInteger){

NSString *result = [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

return result;

};

NSString *result = [self convertIntToString:123

usingBlockObject: inlineConverter];

NSLog(@"result = %@", result);

}

Сравните примеры 7.1 и 7.3. Я удалил имевшийся в первом варианте код, в котором мы формировали сигнатуру блокового объекта. Данная сигнатура состояла из имени и аргумента — (^intToString) (NSUInteger). Остальную часть блокового объекта я не трогаю, и теперь он становится анонимным объектом. Но это не означает, что я никак не могу сослаться на блоковый объект. С помощью знака равенства (=) я присваиваю блоковый объект типу и имени: IntToStringConverter inlineConverter. Теперь я могу воспользоваться типом данных, чтобы стимулировать правильную работу методов, а при самой операции передачи блокового объекта использовать его имя.

Кроме того способа создания встраиваемых блоковых объектов, который только что был продемонстрирован, существует способ создания блокового объекта на этапе передачи его как параметра:

— (void) doTheConversion{

NSString *result =

[self convertIntToString:123

usingBlockObject: ^NSString *(NSUInteger paramInteger) {

NSString *result = [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

return result;

}];

NSLog(@"result = %@", result);

}

Сравните этот пример с примером 7.2. Оба метода используют блоковый объект с применением синтаксиса usingBlockObject. Но, в то время как при применении первого варианта мы ссылались по имени на предварительно определенный блоковый объект (intToString), во втором варианте блоковый объект создается на лету. В этом коде мы создали встраиваемый блоковый объект, который передается методу convertIntToString: usingBlockObject: как второй параметр.

7.2. Доступ к переменным в блоковых объектах

Постановка задачи

Необходимо понять разницу между доступом к переменным в методах Objective-C и доступом к этим переменным в блоковых объектах.

Решение

Вот краткое обобщение того, что необходимо знать о переменных в блоковых объектах.

Локальные переменные в блоковых объектах работают точно так же, как и в методах Objective-C.

• При работе со встраиваемыми блоковыми объектами к локальным относятся не только те переменные, которые определены внутри блока, но и те, что определены в методе, реализующем данный блоковый объект (чуть позже рассмотрим примеры).

• Нельзя ссылаться на self в независимых блоковых объектах, реализованных в классе Objective-C. Если необходим доступ к self, то вам нужно передать его объект блоковому объекту в качестве параметра. Чуть позже рассмотрим на примере и такую ситуацию.

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

• При работе со встраиваемыми блоковыми объектами локальные переменные, определяемые внутри реализации блокового объекта, доступны для считывания, но не для записи. Однако есть и исключение. Блоковый объект может записывать информацию в такие переменные, если они определены с типом хранения __block. Пример мы также рассмотрим.

• Предположим, у вас есть блоковый объект типа NSObject, а внутри реализации этого объекта вы используете блоковый объект с GCD. Внутри данного блокового объекта у вас будет доступ для чтения и записи к объявленным свойствам того NSObject, внутри которого реализован блок.

• Вы можете получать доступ к объявленным свойствам NSObject внутри независимых блоковых объектов, только если вы работаете с методами-установщиками и методами-получателями этих свойств. Вы не сможете получить доступ к объявленным свойствам объекта внутри независимого блокового объекта с помощью точечной нотации.

Обсуждение

Сначала научимся работать с переменными, которые являются локальными для реализаций двух блоковых объектов. Один из этих блоковых объектов будет встраиваемым, а другой — независимым:

void (^independentBlockObject)(void) = ^(void){

NSInteger localInteger = 10;

NSLog(@"local integer = %ld", (long)localInteger);

localInteger = 20;

NSLog(@"local integer = %ld", (long)localInteger);

};

При активизации этого блокового объекта те значения, которые мы присваиваем, выводятся в окне консоли:

local integer = 10

local integer = 20

Пока все несложно. Теперь рассмотрим встраиваемые блоковые объекты и переменные, которые являются для них локальными:

— (void) simpleMethod{

NSUInteger outsideVariable = 10;

NSMutableArray *array = [[NSMutableArray alloc]

initWithObjects:@"obj1",

@"obj2", nil];

[array sortUsingComparator: ^NSComparisonResult(id obj1, id obj2) {

Страницы: «« ... 2526272829303132 ... »»

Читать бесплатно другие книги:

Рассмотрены основы информатики и описаны современные аппаратные средства персонального компьютера. С...
Молодые парни из экстремистской организации «Русский трибунал» объявили партизанскую войну «предател...
Покончив с несчастливым браком, Грейс решила, что больше никогда не доверится мужчине и не поставит ...
Лиз Сазерленд только мечтала о том, чтобы черная полоса ее жизни когда-нибудь сменилась белой. Пробл...
В старину ставили храмы на полях сражений в память о героях и мучениках, отдавших за Родину жизнь. Н...
В учебном пособии представлены вариативные авторские методики воспитания и развития волевых качеств ...