setValue：ForKey：而不是set（whatever）？

Question

In Objective-C, there are various ways to set a value for a property(or a key) as I know. If a given property's name is "foo", I would primarily do something like:

[object setFoo:@"value"];

or even something like:

object.foo = @"value";

However, in some cases, I have seen codes where they use this instead:

[object setValue:@"value" forKey:@"foo"];

What is the exact difference between those two methods(except for the fact that Xcode autocompletes the first method for you)?

Plus, is it even safe to use the second method?(setValue:forKey:)

Thank you for taking your time to read this question. I appreciate your help a lot.

Answer 1

Here is the definition of the Key-Value Coding according to Apple's official documentation:

Key-value coding is a mechanism for accessing an object's properties indirectly, using strings to identify properties, rather than through invocation of an accessor method or accessing them directly through instance variables.

let's see it through some simple examples:

Let's suppose that we have a property named firstname, and we want to assign the value John to it. Normally, what we would write in code to do it is this:

self.firstname = @"John";

or this:

_firstname = @"John";

Quite familiar, right? Now, using the KVC mechanism the above assignment would look like the next one:

[self setValue:@"John" forKey:@"firstname"];

If you look closely, this looks similar to the way we set values to dictionaries, or when converting scalar values and structs to NSValue objects. As you see, we set the value John for the key firstname. One more example:

[someObject.someProperty setText:@"This is a text"];

Using KVC:

[self setValue:@"This is a text" forKeyPath:@"someObject.someProperty.text"];

In both of these examples, instead of directly setting the value (first example) to the property or use the setter method (second example) of the property, we simply match values to keys or keypaths (more about keys and keypaths in just a moment). As you assume, because we use keys and values, the above technique is called Key-Value Coding.

I hope you will get idea about this methods and its difference. :)

Answer 2

[object setFoo:@"value"];

and

object.foo = @"value";

should be equivalent with the compiler basically generating the same code for both.

[object setValue:@"value" forKey:@"foo"];

however is fundamentally different. It uses the NSKeyValueCoding Protocol aka KVC . It's advantage is that the key here is a string, that means it can be dynamically determined (for example taken from some configuration file or similar). But there are some downsides too:

• The compiler can not check if @"key" is a valid property of object . That means if it isn't, you'll end up with an exception during runtime (aka crash or RUT: Rapid Unscheduled Termination).

• It is somewhat slower

Internally KVC ends up using the same accessors as mentioned above. See here for the Accessor Search Implementation Details .