Explanation of how weakify and strongify work in ReactiveCocoa / libextobjc

Question

I understand that you should use @weakify @strongify to avoid retain cycles but I don't completely understand how they actually achieve this?

Answer 1

code before preprocess:

@weakify(self)
[[self.searchText.rac_textSignal
  map:^id(NSString *text) {
      return [UIColor yellowColor];
  }]
 subscribeNext:^(UIColor *color) {
     @strongify(self)
     self.searchText.backgroundColor = color;
 }];

code after preprocess:

@autoreleasepool {} __attribute__((objc_ownership(weak))) __typeof__(self) self_weak_ = (self);
    [[self.searchText.rac_textSignal
      map:^id(NSString *text) {
          return [UIColor yellowColor];
      }]
     subscribeNext:^(UIColor *color) {
         @try {} @finally {}
 __attribute__((objc_ownership(strong))) __typeof__(self) self = self_weak_; // 1
 self.searchText.backgroundColor = color;  //2
     }];

1: define a new local variable “self”. this will shadow the global one.

2: so here we used the local variable “self”--self_weak_.

tips:

1.if we used self.xxx in block, we should place @strongify(self) over it.

2.don't forget use @weakify(self) to define the variable self_weak_.

（PS: I'm trying to learn English. I hope that you can understand what I'm saying.）

Answer 2

When writing the question I stared harder at the macro definitions and I think it works as you might guess.

@weakify creates a new weakly referenced variable of the same type you pass in and assigns the original value to it

@strongify creates a variable that matches the original variable but it exists in the local scope and assigns to it the variable created by @weakify

Answer 3

First and foremost, it matters what implementation of @weakify & @strongify you're using as these aren't part of the standard language. Assuming you're using the ReactiveCocoa version, here's a nice article about what they are and how they work.

Here are a few relevant quotes:

Even the code not written by us can use self safely, e.g. NSAssert macro. It's still possible to reference the real self, by using an ivar. It leads to a warning, though, so it's a mistake that's easy to spot

Now, you may ask: what if I forget to use strongify? This is a cool part: weakify creates a new local variable, so if it's not used at all we get a warning.

As you can imagine, if you forget to use weakify, but strongify is in its place, the compiler shows an error