Liste de syntaxe de déclaration de bloc

La syntaxe de bloc dans l’objective C (et C, je suppose) est notoirement incongrue. Passer des blocs en tant qu’arguments est différent de déclarer des blocs en ivars, ce qui est différent des blocs de typage.

Existe-t-il une liste complète de syntaxe de déclaration de bloc que je pourrais garder sous la main pour une référence rapide?

Liste des syntaxes de déclaration de bloc

Tout au long, laissez

  • return_type soit le type d’object / primitive / etc. vous souhaitez revenir (généralement void )
  • blockName est le nom de la variable du bloc que vous créez
  • var_type soit l’object type / primitive / etc. vous souhaitez passer en argument (laissez vide pour aucun paramètre)
  • varName est le nom de la variable du paramètre donné

Et rappelez-vous que vous pouvez créer autant de parameters que vous le souhaitez.

Blocs en tant que variables

Peut-être le plus commun pour la déclaration.

 return_type (^blockName)(var_type) = ^return_type (var_type varName) { // ... }; 

Blocs en tant que propriétés

Tout comme déclarer des blocs en tant que variables, même si elles sont subtilement différentes.

 @property (copy) return_type (^blockName) (var_type); 

Blocs en parameters

Notez que ceci est distinct de “Blocs as Arguments”; dans ce cas, vous déclarez une méthode qui veut un argument de bloc.

 - (void)yourMethod:(return_type (^)(var_type))blockName; 

Les blocs comme arguments

Notez que ceci est distinct de “Blocs as Parameters”; Dans ce cas, vous appelez une méthode qui veut un argument de bloc avec un bloc anonyme. Si vous avez déjà déclaré une variable de bloc, il suffit de passer le nom de la variable comme argument.

 [someObject doSomethingWithBlock: ^return_type (var_type varName) { //... }]; 

Bloc anonyme

C’est fonctionnellement un bloc anonyme, cependant la syntaxe pour assigner des blocs aux variables consiste simplement à définir la variable comme un bloc anonyme.

 ^return_type (var_type varName) { //... }; 

typedef Block

Cela vous permet de définir un nom court pouvant être référencé comme n’importe quel autre nom de classe lors de la déclaration des blocs.

 typedef return_type (^blockName)(var_type); 

Pour ensuite utiliser blockName au lieu de la syntaxe de déclaration de bloc standard, remplacez simplement.

Bloc Inline

Ceci est sans doute une utilisation moins utile des blocs, mais peut néanmoins avoir sa place. Un bloc en ligne est un bloc anonyme appelé immédiatement après l’instanciation.

 ^return_type (var_type varName) { //... }(var); 

Les blocs en ligne sont principalement utiles pour le décalage de scope et sont à peu près équivalents à des blocs de code séparés par des accolades simples.

 { //... } 

Blocs récursifs

Cela vous permet d’appeler un bloc de lui-même, en créant une boucle qui peut être utilisée lors des rappels et des appels GCD. Cette méthode d’instanciation est exempte de cycles de rétention dans ARC.

 __block return_type (^blockName)(var_type) = [^return_type (var_type varName) { if (returnCondition) { blockName = nil; return; } // ... } copy]; blockName(varValue); 

Blocs de retour

Une méthode peut retourner un bloc,

 - (return_type(^)(var_type))methodName { // ... } 

comme peut une fonction, si un peu étrangement.

 return_type (^FunctionName())(var_type) { // ... } 

Addendums

Si j’ai manqué quelque chose, faites-le moi savoir dans les commentaires, et je les rechercherai / appendai.

Oh, et à Swift …

 blockName = (varName: var_type) -> (return_type) 

C’est presque comme s’il s’agissait d’une fonctionnalité linguistique.

J’aime personnellement utiliser ce site Web ( http://fuckingblocksyntax.com ). Le nom est plus facile à retenir que la syntaxe du bloc elle-même:

http://fuckingblocksyntax.com

et si vous ne pouvez pas charger d’URL contenant des mots incorrects, vous pouvez utiliser ce miroir: http://goshdarnblocksyntax.com

site de fuckingblocksyntax

Typedef:

 typedef void (^block)(NSSsortingng *arg); 

En ligne:

 void (^block)(NSSsortingng *) = ^(NSSsortingng *param) { // do something.... }; 

Méthode:

 - (void)method:(void (^)(NSSsortingng *param))handler 

La bibliothèque d’extraits de code Xcode 4 contient des modèles pour les types de bloc et les blocs en ligne en tant que variables. Ils sont également disponibles par auto-complétion ( typedefblock et inlineblock ).

Pour les blocs comme arguments des méthodes, je vous recommande de déclarer un typedef , puis de l’utiliser simplement. Cela rend le code beaucoup plus facile à lire.

J’ai écrit un closingBlock pour une classe qui renverra les valeurs d’un dé après qu’elles aient été secouées:

  1. Définir typedef avec returnType ( .h ci-dessus la déclaration @interface)

     typedef void (^CompleteDiceRolling)(NSInteger diceValue); 
  2. Définir un @property pour le bloc ( .h )

     @property (copy, nonatomic) CompleteDiceRolling completeDiceRolling; 
  3. Définir une méthode avec finishBlock ( .h )

     - (void)getDiceValueAfterSpin:(void (^)(NSInteger diceValue))finishBlock; 
  4. Insérer la méthode précédemment définie dans le fichier .m et valider finishBlock à @property définie avant

     - (void)getDiceValueAfterSpin:(void (^)(NSInteger diceValue))finishBlock{ self.completeDiceRolling = finishBlock; } 
  5. Pour déclencher completionBlock passez-lui la variableType prédéfinie (N’oubliez pas de vérifier si completionBlock existe)

     if( self.completeDiceRolling ){ self.completeDiceRolling(self.dieValue); } 
 typedef void (^OkBtnBlock)(id data); typedef void (^CancelBtnBlock)(); @property (nonatomic, strong) OkBtnBlock okBtnBlock; @property (nonatomic, strong) CancelBtnBlock cancelBtnBlock; + (void)foo:(OkBtnBlock)okBtn andCancel:(CancelBtnBlock)btnCancel; 

Si vous avez besoin de travailler dans Xcode 4.2, vous pouvez également synthétiser un bloc déclaré comme une propriété, comme vous le feriez avec une propriété non bloquante. Ne laissez pas la syntaxe du bloc vous lancer.

Si votre propriété de bloc est la suivante:

 @property (copy) return_type (^blockName) (var_type); 

Alors votre @synthesize est la suivante:

 @property blockName; 

À votre santé.