当 (NSObject *) 更精确时，为什么在方法签名中使用 (id) ？

发布于 2024-08-13 11:56:26 字数 1366 浏览 5 评论 0原文

每当我在自己的代码中实现一种可以接受或返回多个类的对象的方法时，我总是尝试使用最具体的可用超类。例如，如果我要实现一个可能根据其输入返回 NSArray * 或 NSDictionary * 的方法，我会给该方法一个 NSObject * 的返回类型，因为这是最直接的常见超类。这是一个例子：

@interface MyParser()
- (BOOL)stringExpressesKeyValuePairs:(NSString *)string;
- (BOOL)stringExpressesAListOfEntities:(NSString *)string;
- (NSArray *)parseArrayFromString:(NSString *)string;
- (NSDictionary *)parseDictionaryFromString:(NSString *)string;
@end

@implementation MyParser
- (NSObject *)parseString:(NSString *)string {
    if ([self stringExpressesKeyValuePairs:string]) {
        return [self parseDictionaryFromString:string];
    }
    else if ([self stringExpressesAListOfEntities:string]) {
        return [self parseArrayFromString:string];
    }
}
// etc...
@end

我注意到在 Foundation 和其他 API 中，Apple 在某些方法签名中使用 (id) ，而 (NSObject *) 会更精确。例如，下面是 NSPropertyListSerialization 的方法：

+ (id)propertyListFromData:(NSData *)data 
          mutabilityOption:(NSPropertyListMutabilityOptions)opt 
                    format:(NSPropertyListFormat *)format 
          errorDescription:(NSString **)errorString

该方法可能的返回类型是 NSData、NSString、NSArray、NSDictionary、NSDate 和 NSNumber。在我看来，(NSObject *) 的返回类型将是比 (id) 更好的选择，因为调用者将能够调用 NSObject 方法，例如在没有类型转换的情况下保留。

我通常会尝试模仿官方框架建立的习惯用法，但我也喜欢了解它们的动机。我确信苹果在这种情况下使用 (id) 有一些正当的理由，但我只是没有看到它。我缺少什么？

原文

Whenever I implement a method in my own code that can accept or return objects of more than one class, I always try to use the most specific superclass available. For example, if I were going to implement a method that might return an NSArray * or an NSDictionary * depending on its input, I would give that method a return type of NSObject *, since that's the most direct common superclass. Here's an example:

@interface MyParser()
- (BOOL)stringExpressesKeyValuePairs:(NSString *)string;
- (BOOL)stringExpressesAListOfEntities:(NSString *)string;
- (NSArray *)parseArrayFromString:(NSString *)string;
- (NSDictionary *)parseDictionaryFromString:(NSString *)string;
@end

@implementation MyParser
- (NSObject *)parseString:(NSString *)string {
    if ([self stringExpressesKeyValuePairs:string]) {
        return [self parseDictionaryFromString:string];
    }
    else if ([self stringExpressesAListOfEntities:string]) {
        return [self parseArrayFromString:string];
    }
}
// etc...
@end

I've noticed many cases in Foundation and other APIs where Apple uses (id) in certain method signatures when (NSObject *) would be more precise. For example, here's a method of NSPropertyListSerialization:

+ (id)propertyListFromData:(NSData *)data 
          mutabilityOption:(NSPropertyListMutabilityOptions)opt 
                    format:(NSPropertyListFormat *)format 
          errorDescription:(NSString **)errorString

The possible return types from this method are NSData, NSString, NSArray, NSDictionary, NSDate, and NSNumber. It seems to me that a return type of (NSObject *) would be a better choice than (id), since the caller would then be able to call NSObject methods like retain without a type-cast.

I generally try to emulate the idioms established by the official frameworks, but I also like to understand what motivates them. I'm sure that Apple has some valid reason for using (id) in cases like this, but I'm just not seeing it. What am I missing?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

骄傲 2024-08-20 11:56:26

在方法声明中使用 (id) 的原因有两个：

(1) 该方法可以采用或返回任何类型。 NSArray 包含任何随机对象，因此，objectAtIndex: 将返回任何随机类型的对象。将其转换为 NSObject* 或 id 是不正确的，原因有两个：首先，数组可以包含非 NSObject 子类，只要它们实现特定的一小组方法即可；其次，特定的返回类型需要进行强制转换。

(2) Objective-C 不支持协变声明。考虑一下：

@interface NSArray:NSObject
+ (id) array;
@end

现在，您可以在 NSArray 和 NSMutableArray 上调用 +array。前者返回一个不可变数组，后者返回一个可变数组。由于 Objective-C 缺乏协变声明支持，如果以上声明为返回 (NSArray*)，则子类方法的客户端必须强制转换为 `(NSMutableArray*)。丑陋、脆弱且容易出错。因此，使用泛型类型通常是最直接的解决方案。

所以...如果您声明一个返回特定类实例的方法，请显式进行类型转换。如果您声明一个将被重写的方法，并且该重写可能会返回一个子类，并且它返回一个子类的事实将暴露给客户端，那么请使用 (id) 。

~~无需提交错误 - 已经有几个错误了。~~

请注意，ObjC 现在通过 instancetype 关键字提供有限的协方差支持。

即 NSArray 的 +array 方法现在可以声明为：

+ (instancetype) array;

编译器会将 [NSMutableArray array] 视为返回 NSMutableArray* while < code>[NSArray array] 将被视为返回 NSArray*。

The reason why (id) is used in method declarations is two fold:

(1) The method may take or return any type. NSArray contains any random object and, thus, objectAtIndex: will return an object of any random type. Casting it to NSObject* or id <NSObject> would be incorrect for two reasons; first, an Array can contain non NSObject subclasses as long as they implement a certain small set of methods and, secondly, a specific return type would require casting.

(2) Objective-C doesn't support covariant declarations. Consider:

@interface NSArray:NSObject
+ (id) array;
@end

Now, you can call +array on both NSArray and NSMutableArray. The former returns an immutable array and the latter a mutable array. Because of Objective-C's lack of covariant declaration support, if the above were declared as returning (NSArray*), clients of the subclasses method would have to cast to `(NSMutableArray*). Ugly, fragile, and error prone. Thus, using the generic type is, generally, the most straightforward solution.

So... if you are declaring a method that returns an instance of a specific class, typecast explicitly. If you are declaring a method that will be overridden and that override may return a subclass and the fact that it returns a subclass will be exposed to clients, then use (id).

~~No need to file a bug -- there are several already.~~

Note that ObjC now has limited co-variance support through the instancetype keyword.

I.e. NSArray's +array method could now be declared as:

+ (instancetype) array;

And the compiler would treat [NSMutableArray array] as returning an NSMutableArray* while [NSArray array] would be considered as returning NSArray*.

回复收藏 0 原文