Block syntax in Objective C (and indeed C, I presume) is notoriously incongruous. Passing blocks as arguments looks different than declaring blocks as ivars, which looks different than typedef
ing blocks.
Is there a comprehensive list of block-declaration syntax that I could keep on hand for quick reference?
Throughout, let
return_type
be the type of object/primitive/etc. you'd like to return (commonly void
)blockName
be the variable name of the block you're creatingvar_type
be the type object/primitive/etc. you'd like to pass as an argument (leave blank for no parameters)varName
be the variable name of the given parameterAnd remember that you can create as many parameters as you'd like.
Possibly the most common for of declaration.
return_type (^blockName)(var_type) = ^return_type (var_type varName)
{
// ...
};
Much like declaring blocks as variables, however subtly different.
@property (copy) return_type (^blockName) (var_type);
Note that this is distinct from "Blocks as Arguments"; in this instance, you're declaring a method that wants a block argument.
- (void)yourMethod:(return_type (^)(var_type))blockName;
Note that this is distinct from "Blocks as Parameters"; in this instance, you're calling a method that wants a block argument with an anonymous block. If you have already declared a block variable, it is sufficient to pass the variable name as the argument.
[someObject doSomethingWithBlock: ^return_type (var_type varName)
{
//...
}];
This is functionally an anonymous block, however the syntax for assigning blocks to variables is simply to set the variable equal to an anonymous block.
^return_type (var_type varName)
{
//...
};
typedef
BlockThis allows you to set up a short name that can be referenced just like any other class name during the declaration of blocks.
typedef return_type (^blockName)(var_type);
To then later use blockName
instead of the standard block declaration syntax, simply substitute.
This is arguably a less useful utilization of blocks, but may have its place nonetheless. An inline block is an anonymous block called immediately after instantiation.
^return_type (var_type varName)
{
//...
}(var);
Inline blocks are primarily useful for scope offsetting, and are roughly equivalent to simple brace-delimited chunks of code.
{
//...
}
This allows you to call a block from itself, creating a loop that can be used during callbacks and GCD calls. This instantiation method is free of retain cycles in ARC.
__block return_type (^blockName)(var_type) = [^return_type (var_type varName)
{
if (returnCondition)
{
blockName = nil;
return;
}
// ...
} copy];
blockName(varValue);
A method can return a block,
- (return_type(^)(var_type))methodName
{
// ...
}
as can a function, if a bit strangely.
return_type (^FunctionName())(var_type)
{
// ...
}
If I've missed anything, please let me know in comments, and I'll research/add them.
blockName = (varName: var_type) -> (return_type)
It's almost like it's a language feature.