iOS开发UITableView中行的操作

文章写得很好,转载自:http://my.oschina.net/plumsoft/blog/53271

这篇文章主要讲的表格的操作包括:标记行、移动行、删除行、插入行。

这次就不从头建立工程了,在http://www.oschina.net/code/snippet_164134_9876下载工程。这个工程就是最简单的产生一个表格并向其中写入数据。用Xcode 4.2打开它,在这个工程基础上实现以上操作。

1、标记行

这里讲的标记行指的是单击此行,可以实现在此行右边出现一个勾,如下图所示:

为了实现标记功能,在ViewController.m中@end之前添加代码:

#pragma mark -
#pragma mark Table Delegate Methods
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath { 
    UITableViewCell *oneCell = [tableView cellForRowAtIndexPath: indexPath];
    if (oneCell.accessoryType == UITableViewCellAccessoryNone) {
        oneCell.accessoryType = UITableViewCellAccessoryCheckmark;
    } else 
        oneCell.accessoryType = UITableViewCellAccessoryNone;
    [tableView deselectRowAtIndexPath:indexPath animated:YES]; 
}

该代码实现:单击某行时,若此行未被标记,则标记此行;若此行已经被标记,则取消标记。

运行效果如上图。

上面的代码实际上就是修改某行的accessoryType属性,这个属性可以设为四个常量:

UITableViewCellAccessoryCheckmark
UITableViewCellAccessoryDetailDisclosureButton
UITableViewCellAccessoryDisclosureIndicator
UITableViewCellAccessoryNone

效果依次如下图所示:

            

   UITableViewCellAccessoryCheckmark            UITableViewCellAccessoryDetailDisclosureButton

                 

UITableViewCellAccessoryDisclosureIndicator                   UITableViewCellAccessoryNone

注意,上面第二张图片中的蓝色圆圈不仅仅是一个图标,还是一个控件,点击它可以触发事件,在上一篇博客《iOS开发16:使用Navigation Controller切换视图》使用过。

2、移动行

想要实现移动或者删除行这样的操作,需要启动表格的编辑模式。使用的是setEditing:animated:方法。

2.1 打开ViewController.xib,将其中的表格控件映射成Outlet到ViewController.h,名称为myTableView。

2.2 打开ViewController.m,在viewDidLoad方法最后添加代码:

//启动表格的编辑模式
[self.myTableView setEditing:YES animated:YES];

2.3 在@end之前添加代码:

//打开编辑模式后,默认情况下每行左边会出现红的删除按钮,这个方法就是关闭这些按钮的
- (UITableViewCellEditingStyle)tableView:(UITableView *)tableView
           editingStyleForRowAtIndexPath:(NSIndexPath *)indexPath { 
    return UITableViewCellEditingStyleNone; 
} 

//这个方法用来告诉表格 这一行是否可以移动
- (BOOL)tableView:(UITableView *)tableView canMoveRowAtIndexPath:(NSIndexPath *)indexPath { 
    return YES; 
}

//这个方法就是执行移动操作的
- (void)tableView:(UITableView *)tableView moveRowAtIndexPath:(NSIndexPath *)
        sourceIndexPath toIndexPath:(NSIndexPath *)destinationIndexPath {
    NSUInteger fromRow = [sourceIndexPath row]; 
    NSUInteger toRow = [destinationIndexPath row]; 
    
    id object = [list objectAtIndex:fromRow]; 
    [list removeObjectAtIndex:fromRow]; 
    [list insertObject:object atIndex:toRow]; 
}

editingStyleForRowAtIndexPath这个方法中用到了常量UITableViewCellEditingStyleNone,它表示不可编辑,这里的编辑指的是删除和插入。表示表格行的编辑模式的常量有:

UITableViewCellEditingStyleDelete
UITableViewCellEditingStyleInsert
UITableViewCellEditingStyleNone

顾名思义,第一个表示删除,第二个表示插入,第三个表示不可编辑。

若将editingStyleForRowAtIndexPath方法中的UITableViewCellEditingStyleNone依次换成上面三个值,则它们运行的效果依次如下图所示:

      

2.4 运行,从下图可以看到实现了行的移动:

但是也会发现,现在无法对每行进行标记了。这说明,在编辑模式下,无法选择行,从而didSelectRowAtIndexPath这个方法不会执行。

3、删除行

从第2步过来,实现删除某行,其实比较简单了。

3.1将editingStyleForRowAtIndexPath方法中的UITableViewCellEditingStyleNone修改成UITableViewCellEditingStyleDelete。

3.2 在@end之前添加代码:

//这个方法根据参数editingStyle是UITableViewCellEditingStyleDelete
//还是UITableViewCellEditingStyleDelete执行删除或者插入
- (void)tableView:(UITableView *)tableView commitEditingStyle:
    (UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    NSUInteger row = [indexPath row];
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        [self.list removeObjectAtIndex:row]; 
        [tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath]
                         withRowAnimation:UITableViewRowAnimationAutomatic]; 
    }
}

在这个方法中又出现了一个常量:UITableViewRowAnimationAutomatic,它表示删除时的效果,类似的常量还有:

UITableViewRowAnimationAutomatic
UITableViewRowAnimationTop
UITableViewRowAnimationBottom
UITableViewRowAnimationLeft
UITableViewRowAnimationRight
UITableViewRowAnimationMiddle
UITableViewRowAnimationFade
UITableViewRowAnimationNone

它们的效果就不一一介绍了,可以在实际使用时试试。

3.3 运行,看看效果:

      

刚运行时显示如左边的图片,点击某一行左边的圆圈图标,会显示如中间图片所示。然后点击Delegate按钮,那一行就会被删除掉,如右边的那张图片所示,它显示的是删除时的效果。

4、插入行

这个与删除行类似。

4.1 首先将editingStyleForRowAtIndexPath方法中的UITableViewCellEditingStyleDelete修改成UITableViewCellEditingStyleInsert。

4.2在3.2添加的方法中添加代码:

else {
    //我们实现的是在所选行的位置插入一行,因此直接使用了参数indexPath
    NSArray *insertIndexPaths = [NSArray arrayWithObjects:indexPath,nil];
    //同样,将数据加到list中,用的row
    [self.list insertObject:@"新添加的行" atIndex:row];
    [tableView insertRowsAtIndexPaths:insertIndexPaths withRowAnimation:UITableViewRowAnimationRight];
}

上面的代码中也可以不用insertRowsAtIndexPaths方法,而直接使用[tableView reloadData];语句,但是这样就没有添加的效果了。

4.3 好了,运行一下:

      

刚运行时如上面左图所示,单击了某个加号后,新的一行就从右边飞进来了,因为在insertRowsAtIndexPaths中用了参数UITableViewRowAnimationRight。

Objective-C中的Class(类类型),Selector(选择器SEL),函数指针(IMP)

看到了一篇牛文“Objective-C 2.0 with Cocoa Foundation— 5,Class类型,选择器Selector以及函数指针”,讲得十分精彩,忍不住把它的代码加上注释整理于此,以便日后查看。
个人体会:obj-C中的“Class类型变量”比c#中的Object基类还要灵活,可以用它生成任何类型的实例(但是它又不是NSObject)。而选择器SEL与函数指针IMP,如果非要跟c#扯上关系的话,这二个结合起来,就点类似c#中的反射+委托,可以根据一个方法名称字符串,直接调用方法。
“牛”的基类 Cattle.h
1
2
3
4
5
6
7
8
#import <Foundation/Foundation.h>
@interface Cattle : NSObject {
    int legsCount;
}
- (void)saySomething;
- (void)setLegsCount:(int) count;
@end
 Cattle.m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#import "Cattle.h"
@implementation Cattle
-(void) saySomething
{
    NSLog(@"Hello, I am a cattle, I have %d legs.", legsCount);
}
-(void) setLegsCount:(int) count
{
    legsCount = count;
}
@end
子类“公牛” Bull.h
1
2
3
4
5
6
7
8
9
10
#import <Foundation/Foundation.h>
#import "Cattle.h"
@interface Bull : Cattle {
    NSString *skinColor;
}
- (void)saySomething;
- (NSString*) getSkinColor;
- (void) setSkinColor:(NSString *) color;
@end
Bull.m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#import "Bull.h"
@implementation Bull
-(void) saySomething
{
    NSLog(@"Hello, I am a %@ bull, I have %d legs.", [self getSkinColor],legsCount);
}
-(NSString*) getSkinColor
{
    return skinColor;
}
- (void) setSkinColor:(NSString *) color
{
    skinColor = color;
}
@end
代理类DoProxy.h (关键的代码都在这里)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#import <Foundation/Foundation.h>
//定义几个字符串常量
#define SET_SKIN_COLOR @"setSkinColor:"
#define BULL_CLASS @"Bull"
#define CATTLE_CLASS @"Cattle"
@interface DoProxy : NSObject {
    BOOL notFirstRun;
    
    id cattle[3];
    //定义二个选择器
    SEL say;
    SEL skin;
    
    //定义一个函数指针(传统C语言的处理方式)
    void(*setSkinColor_Func)(id,SEL,NSString*);
    
    //定义一个IMP方式的函数指针(obj-C中推荐的方式)
    IMP say_Func;
    
    //定义一个类
    Class bullClass;
}
-(void) doWithCattleId:(id) aCattle colorParam:(NSString*) color;
-(void) setAllIVars;
-(void) SELFuncs;
-(void) functionPointers;
@end
DoProxy.m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#import "DoProxy.h"
#import "Cattle.h"
#import "Bull.h"
@implementation DoProxy
//初始化所有变量
- (void) setAllIVars
{  
    cattle[0] = [Cattle new];
    
    bullClass = NSClassFromString(BULL_CLASS);
    //即cattle[1],cattle[2]都是Bull类的实例
    cattle[1] = [bullClass new];
    cattle[2] = [bullClass new];
    
    say = @selector(saySomething);
    skin = NSSelectorFromString(SET_SKIN_COLOR);
}
//初始化id
- (void) doWithCattleId:(id) aCattle colorParam:(NSString*) color
{
    //第一次运行的时候
    if(notFirstRun == NO)
    {
        NSString *myName = NSStringFromSelector(_cmd);//取得当前正在执行的方法的名字
        NSLog(@"Running in the method of %@", myName);
        notFirstRun = YES;//修改初次运行标志位
    }
    
    NSString *cattleParamClassName = [aCattle className];//取得aCattle的"类名称"
    
    //如果aCattle是Bull或Cattle类的实例
    if([cattleParamClassName isEqualToString:BULL_CLASS] || [cattleParamClassName isEqualToString:CATTLE_CLASS])
    {
        [aCattle setLegsCount:4];//设置牛的4条腿
        if([aCattle respondsToSelector:skin])//如果aCattle对应的是类中,有定义方法"setSkinColor"
        {
            [aCattle performSelector:skin withObject:color];//则调用setSkinColor方法
        }
        else
        {
            NSLog(@"Hi, I am a %@, have not setSkinColor!", cattleParamClassName);//否则输出相应的提示信息
        }
        [aCattle performSelector:say];//最后执行saySomething方法(这二个方法在Bull与Cattle类中都有,所以肯定能运行)
    }
    else //如果aCattle即不是Bull类也不是Cattle类的实例
    {
        NSString *yourClassName = [aCattle className];
        NSLog(@"Hi, you are a %@, but I like cattle or bull!", yourClassName);//显示这个"异类"的相关信息
    }
}
//初始化选择器以及相应函数
- (void) SELFuncs
{
    [self doWithCattleId:cattle[0] colorParam:@"brown"];
    [self doWithCattleId:cattle[1] colorParam:@"red"];
    [self doWithCattleId:cattle[2] colorParam:@"black"];
    [self doWithCattleId:self colorParam:@"haha"];//这里故意传入一个异类self(即DoProxy本身),DoProxy当然不是Bull或Cattle
}
//函数指针测试
- (void) functionPointers
{
    //取得函数指针的第一种方式
    setSkinColor_Func=(void (*)(id, SEL, NSString*)) [cattle[1] methodForSelector:skin];
    //上面的语句其实等效于下面这种方法
    //IMP setSkinColor_Func = [cattle[1] methodForSelector:skin];
    
    //用第二种方法取得saySomething的函数指针
    say_Func = [cattle[1] methodForSelector:say];
    
    //用函数指针的形式调用setSkinColor
    setSkinColor_Func(cattle[1],skin,@"verbose");
    
    NSLog(@"Running as a function pointer will be more efficiency!");
    
    //调用saySomething方法
    say_Func(cattle[1],say);
}
@end
测试主函数main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#import <Foundation/Foundation.h>
#import "DoProxy.h"
int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    DoProxy *doProxy = [DoProxy new];
    
    [doProxy setAllIVars];
    [doProxy SELFuncs];
    [doProxy functionPointers];
    
    [doProxy release];
    [pool drain];
    return 0;
}

运行结果:

2011-02-28 21:40:33.240 HelloSelector[630:a0f] Running in the method of doWithCattleId:colorParam:
2011-02-28 21:40:33.245 HelloSelector[630:a0f] Hi, I am a Cattle, have not setSkinColor!
2011-02-28 21:40:33.247 HelloSelector[630:a0f] Hello, I am a cattle, I have 4 legs.
2011-02-28 21:40:33.248 HelloSelector[630:a0f] Hello, I am a red bull, I have 4 legs.
2011-02-28 21:40:33.250 HelloSelector[630:a0f] Hello, I am a black bull, I have 4 legs.
2011-02-28 21:40:33.251 HelloSelector[630:a0f] Hi, you are a DoProxy, but I like cattle or bull!
2011-02-28 21:40:33.252 HelloSelector[630:a0f] Running as a function pointer will be more efficiency!
2011-02-28 21:40:33.254 HelloSelector[630:a0f] Hello, I am a verbose bull, I have 4 legs.

作者:菩提树下的杨过
出处:http://yjmyzz.cnblogs.com
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。

Objective-c的动态调用函数的方法

最近在看关于selector的资料,感觉很好玩。

首先我能理解什么叫selector已经不容易了,查阅了很多资料。
其次是要动态调用,首先网上找到的方法是,这样的用法:

-(void)traceThem:(int)a traceThem2:(int)b{

NSLog(@”hello:%d 你好%d”,a,b);

}

[self performSelector:@selector(traceThem:traceThem2:) withObject:(id)1 withObject:(id)2];

上面代码的意思要调用函数名为traceThem:traceThem2:的函数,参数分别是1,2

(OC就叫发消息,它的函数说法是有一条traceThem:traceThem2:的消息,reciver是self,其实编译的时候还不是自己改成调用函数的概念。);

performSelector这样的调用函数方法,最多只能支持2个参数,你可以把参数放到NSDictionary传递。

搞到百度到的一大堆blog文都是自己写了一大段代码来支持performSelector多个参数的调用。。。

其实还有个好方法objc_msgSend:

objc_msgSend(self,@selector(traceThem:traceThem2:traceThme3:),参数1,参数2,参数3);

但是动态调用,就是要求@selector()的参数能动态输入,例如是配置到一个配置表中的字符串(NSString),方法如下:

SEL function = NSSelectorFromString(@”traceThem:traceThem2:traceThem3:”);

objc_msgSend(self,function,1,2,3);

BTW:

由于objc_msgSend是运行时的方法,所以要加入头文件,用open quickly可帮到大忙,如下:

,即需要的头文件:#import <objc/message.h>

 

objective-c的动态调用函数的方法 - Sylar_Lin - 低调做人高调做事

WWDC2014之App Extensions

一、关于App Extensions

extension是iOS8新开放的一种对几个固定系统区域的扩展机制,它可以在一定程度上弥补iOS的沙盒机制对应用间通信的限制。

extension的出现,为用户提供了在其它应用中使用我们应用提供的服务的便捷方式,比如用户可以在Todaywidgets中查看应用展示的简略信息,而不用再进到我们的应用中,这将是一种全新的用户体验;但是,extension的出现可能会减少用户启动应用的次数,同时还会增大开发者的工作量。

几个关键词

  • extension point

系统中支持extension的区域,extension的类别也是据此区分的,iOS上共有TodayShareActionPhoto EditingStorage ProviderCustom keyboard几种,其中Today中的extension又被称为widget

每种extension point的使用方式和适合干的活都不一样,因此不存在通用的extension。

  • app extension

即为本文所说的extension。extension并不是一个独立的app,它有一个包含在app bundle中的独立bundle,extension的bundle后缀名是.appex。其生命周期也和普通app不同,这些后文将会详述。

extension不能单独存在,必须有一个包含它的containing app。

另外,extension需要用户手动激活,不同的extension激活方式也不同,比如: 比如Today中的widget需要在Today中激活和关闭;Custom keyboard需要在设置中进行相关设置;Photo Editing需要在使用照片时在照片管理器中激活或关闭;Storage Provider可以在选择文件时出现;ShareAction可以在任何应用里被激活,但前提是开发者需要设置Activation Rules,以确定extension需要在合适出现。

  • containing app

尽管苹果开放了extension,但是在iOS中extension并不能单独存在,要想提交到AppStore,必须将extension包含在一个app中提交,并且app的实现部分不能为空,这个包含extension的app就叫containing app。

extension会随着containing app的安装而安装,同时随着containing app的卸载而卸载。

  • host app

能够调起extension的app被称为host app,比如widget的host app就是Today

二、extension和containing app、host app

2.1 extension和host app

extension和host app之间可以通过extensionContext属性直接通信,该属性是新增加的UIViewController类别:

1
2
3
4
5
6
@interface UIViewController(NSExtensionAdditions) <NSExtensionRequestHandling>
// Returns the extension context. Also acts as a convenience method for a view controller to check if it participating in an extension request.
@property (nonatomic,readonly,retain) NSExtensionContext *extensionContext NS_AVAILABLE_IOS(8_0);
@end

实际上extension和host app之间是通过IPC(interprocess communication)实现的,只是苹果把调用接口高度抽象了,我们并不需要关注那么底层的东西。

2.2 containing app和host app

他们之间没有任何直接关系,也从来不需要通信。

2.3 extension和containing app

这二者之间的关系最复杂,纠纠缠缠扯不清关系。

  • 不能直接通信

首先,尽管extension的bundle是放在containing app的bundle中,但是他们是两个完全独立的进程,之间不能直接通信。不过extension可以通过openURL的方式启动containing app(当然也能启动其它app),不过必须通过extensionContext借助host app来实现:

1
2
3
4
5
6
7
8
//通过openURL的方式启动Containing APP
- (void)openURLContainingAPP
{
    [self.extensionContext openURL:[NSURL URLWithString:@"appextension://123"]
                 completionHandler:^(BOOL success) {
                     NSLog(@"open url result:%d",success);
                 }];
}

extension中是无法直接使用openURL的。

  • 可以共享Shared resources

extension和containing app可以共同读写一个被称为Shared resources的存储区域,这是通过App Groups实现的,后文将会详述。

三者间的关系可以通过官网给的两张图片形象地说明:

detailed_communication

app_extensions_container_restrictions

  • containing app能够控制extension的出现和隐藏

通过以下代码,containing app可以让extension出现或隐藏(当然extension也可以让自己隐藏):

1
2
3
4
5
6
7
8
9
10
11
//让隐藏的插件重新显示
- (void)showTodayExtension
{
    [[NCWidgetController widgetController] setHasContent:YES forWidgetWithBundleIdentifier:@"com.wangzz.app.extension"];
}
//隐藏插件
- (void)hiddeTodayExtension
{
    [[NCWidgetController widgetController] setHasContent:NO forWidgetWithBundleIdentifier:@"com.wangzz.app.extension"];
}

三、App Groups

这是iOS8新开放的功能,在OS X上早就可用了。它主要用于同一group下的app共享同一份读写空间,以实现数据共享。

extension和containing app共同读写一份数据是很合理的需求,比如系统的股市应用,widget和app中都需要展示几个公司的股票数据,这就可以通过App Groups实现。

3.1 功能开启

为了便于后续操作,请先确保你的开发者账号在Xcode上处于登录状态。

  • 在app中开启

App Groups位于:

1
TARGETS-->AppExtensionDemo-->Capabilities-->App Groups

找到以后,将App Groups右上角的开关打开,然后选择添加groups,比如我的是group.wangzz,当然这是为了测试随便起得名字,正规点得命名规则应该是:group.com.company.app。

添加成功以后如下图所示:

app_group

  • 在extension中开启

我创建的是widget,target名称为TodayExtension,对应的App Groups位于:

1
TARGETS-->TodayExtension-->Capabilities-->App Groups

开启方式和app中一样,需要注意的是必须保证这里地App Groups名称和app中的相同,即为group.wangzz。

四、extension和containing app数据共享

App Groups给我们提供了同一group内app可以共同读写的区域,可以通过以下方式实现数据共享:

4.1 通过NSUserDefaults共享数据

  • 存数据

通过以下方式向NSUserDefaults中保存数据:

1
2
3
4
5
6
7
- (void)saveTextByNSUserDefaults
{
    NSUserDefaults *shared = [[NSUserDefaults alloc] initWithSuiteName:@"group.wangzz"];
    [shared setObject:_textField.text forKey:@"wangzz"];
    [shared synchronize];
}

需要注意的是:

1.保存数据的时候必须指明group id;

2.而且要注意NSUserDefaults能够处理的数据只能是可plist化的对象,详情见Property List Programming Guide

3.为了防止出现数据同步问题,不要忘记调用[shared synchronize];

  • 读数据

对应的读取数据方式:

1
2
3
4
5
6
7
- (NSString *)readDataFromNSUserDefaults
{
    NSUserDefaults *shared = [[NSUserDefaults alloc] initWithSuiteName:@"group.wangzz"];
    NSString *value = [shared valueForKey:@"wangzz"];
    return value;
}

4.2 通过NSFileManager共享数据

NSFileManager在iOS7提供了containerURLForSecurityApplicationGroupIdentifier方法,可以用来实现app group共享数据。

  • 保存数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
- (BOOL)saveTextByNSFileManager
{
    NSError *err = nil;
    NSURL *containerURL = [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:@"group.wangzz"];
    containerURL = [containerURL URLByAppendingPathComponent:@"Library/Caches/good"];
    NSString *value = _textField.text;
    BOOL result = [value writeToURL:containerURL atomically:YES encoding:NSUTF8StringEncoding error:&err];
    if (!result) {
        NSLog(@"%@",err);
    } else {
        NSLog(@"save value:%@ success.",value);
    }
    return result;
}
  • 读数据
1
2
3
4
5
6
7
8
9
- (NSString *)readTextByNSFileManager
{
    NSError *err = nil;
    NSURL *containerURL = [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:@"group.wangzz"];
    containerURL = [containerURL URLByAppendingPathComponent:@"Library/Caches/good"];
    NSString *value = [NSString stringWithContentsOfURL:containerURL encoding:NSUTF8StringEncoding error:&err];
    return value;
}

在这里我试着保存和读取的是字符串数据,但读写SQlite我相信也是没问题的。

  • 数据同步

两个应用共同读取同一份数据,就会引发数据同步问题。WWDC2014的视频中建议使用NSFileCoordination实现普通文件的读写同步,而数据库可以使用CoreData,Sqlite也支持同步。

五、extension和containing app代码共享

和数据共享类似,extension和containing app很自然地会有一些业务逻辑上可以共用的代码,这时可以通过iOS8中刚开放使用的framework实现。苹果在App Extension Programming Guide中是这样描述的:

In iOS 8.0 and later, you can use an embedded framework to share code between your extension and its containing app. For example, if you develop image-processing code that you want both your Photo Editing extension and its containing app to share, you can put the code into a framework and embed it in both targets.

即将framework分别嵌入到extension和containing app的target中实现代码共享。但这样岂不是需要分别要将framework分别copy到extension和containing app的main bundle中?

参考extension和containing app数据共享,我试想能不能将framework只保存一份放在App Groups区域?

5.1 copy framework到App Groups

在app首次启动的时候将framework放到App Groups区域:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
- (BOOL)copyFrameworkFromMainBundleToAppGroup
{
    NSFileManager *manager = [NSFileManager defaultManager];
    NSError *err = nil;
    NSURL *containerURL = [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:@"group.wangzz"];
    NSString *sorPath = [NSString stringWithFormat:@"%@/Dylib.framework",[[NSBundle mainBundle] bundlePath]];
    NSString *desPath = [NSString stringWithFormat:@"%@/Library/Caches/Dylib.framework",containerURL.path];
    BOOL removeResult = [manager removeItemAtPath:desPath error:&err];
    if (!removeResult) {
        NSLog(@"%@",err);
    } else {
        NSLog(@"remove success.");
    }
    BOOL copyResult = [[NSFileManager defaultManager] copyItemAtPath:sorPath toPath:desPath error:&err];
    if (!copyResult) {
        NSLog(@"%@",err);
    } else {
        NSLog(@"copy success.");
    }
    return copyResult;
}

5.2 使用framework:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
- (BOOL)loadFrameworkInAppGroup
{
    NSError *err = nil;
    NSURL *containerURL = [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:@"group.wangzz"];
    NSString *desPath = [NSString stringWithFormat:@"%@/Library/Caches/Dylib.framework",containerURL.path];
    NSBundle *bundle = [NSBundle bundleWithPath:desPath];
    BOOL result = [bundle loadAndReturnError:&err];
    if (result) {
        Class root = NSClassFromString(@"Person");
        if (root) {
            Person *person = [[root alloc] init];
            if (person) {
                [person run];
            }
        }
    } else {
        NSLog(@"%@",err);
    }
    return result;
}

经过测试,竟然能够加载成功。

需要说明的是,这里只是说那么用是可以成功加载framework,但还面临不少问题,比如如果用户在启动app之前去使用extension,这时framework还没有copy过去,怎么处理;另外iOS的机制或者苹果的审核是否允许这样使用等。

在一切确定下来之前还是乖乖按文档中的方式使用吧。

六、生命周期

extension和普通app的最大区别之一是生命周期。

  • 开始

在用户通过host app点击extension时,系统就会实例化extension应用,这是生命周期的开始。

  • 执行任务

在extension启动以后,开始执行它的使命。

  • 终止

在用户取消任务,或者任务执行结束,或者开启了一个长时后台任务时,系统会将其杀掉。

由此可见,extension就是为了任务而生!

下图来自官方文档,它将生命周期划分的更详细:

app_extensions_lifecycle

通过打印日志发现,Today中的widget在将Today切换到全部或者未读通知时都会被杀掉。

七、 调试

extension和普通app的调试方式差不多,开始调试前先选中extension对应的target,点击run,就会弹出下图所示选择框:

extension_debug

需要选择一个host app,这里选择Today

然后即可和普通app一样调试了,不过我在实际使用过程中,发现有各种奇怪的事情,比如NSLog无法在控制台输出,应该是bug吧。

八、 iOS8应用文件系统

发现iOS8的文件系统发生了变化,新的文件系统将可执行文件(即原来的.app文件)从沙盒中移到了另外一个地方,这样感觉更合理。

  • 测试代码

下述代码用于打印App Groups路径、应用的可执行文件路径、对应的Documents路径:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
- (void)logAppPath
{
    //app group路径
    NSURL *containerURL = [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:@"group.wangzz"];
    NSLog(@"app group:\n%@",containerURL.path);
    //打印可执行文件路径
    NSLog(@"bundle:\n%@",[[NSBundle mainBundle] bundlePath]);
    //打印documents
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *path = [paths objectAtIndex:0];
    NSLog(@"documents:\n%@",path);
}
  • containing app执行结果
1
2
3
4
5
6
2014-06-23 19:35:03.944 AppExtensionDemo[7471:365131] app group:
/private/var/mobile/Containers/Shared/AppGroup/89CCBFB1-CA5E-4C7F-80CB-A3EB9E841816
2014-06-23 19:35:03.946 AppExtensionDemo[7471:365131] bundle:
/private/var/mobile/Containers/Bundle/Application/1AC73797-A3BB-4BDE-A647-3D083DA6871A/AppExtensionDemo.app
2014-06-23 19:35:03.948 AppExtensionDemo[7471:365131] documents:
/var/mobile/Containers/Data/Application/E5E6E516-0163-4754-9D10-A5F6C33A6261/Documents
  • extension执行结果
1
2
3
4
5
6
Jun 23 19:37:49 autonavis-iPad com.foogry.AppExtensionDemo.TodayExtension[7638] <Warning>: app group:
  /private/var/mobile/Containers/Shared/AppGroup/89CCBFB1-CA5E-4C7F-80CB-A3EB9E841816
Jun 23 19:37:49 autonavis-iPad com.foogry.AppExtensionDemo.TodayExtension[7638] <Warning>: bundle:
  /private/var/mobile/Containers/Bundle/Application/596717B7-7CB8-4F53-BCD4-380F34ABD30F/AppExtensionDemo.app/PlugIns/com.foogry.AppExtensionDemo.TodayExtension.appex
Jun 23 19:37:49 autonavis-iPad com.foogry.AppExtensionDemo.TodayExtension[7638] <Warning>: documents:
  /var/mobile/Containers/Data/PluginKitPlugin/57581433-3DBD-4930-971F-78D30C150E8A/Documents

由此可见,不管是extension还是containing app,他们的可执行文件和保存数据的目录都是分开存放的,即所有app的可执行文件都放在一个大目录下,保存数据的目录保存在另一个大目录下,同样,AppGroup放在另一个大目录下。

说明

  • 本文用到的demo已经上传到github上。

  • 文中可能有理解有误的地方,还请指出。

参考文档

Swift中文教程(23)高级运算符

转载自letsswift.com

除了基本操作符中所讲的运算符,Swift还有许多复杂的高级运算符,包括了C语和Objective-C中的位运算符和移位运算。

不同于C语言中的数值计算,Swift的数值计算默认是不可溢出的。溢出行为会被捕获并报告为错误。你是故意的?好吧,你可以使用Swift为你准备的另一套默认允许溢出的数值运算符,如可溢出加&+。所有允许溢出的运算符都是以&开始的。

自定义的结构,类和枚举,是否可以使用标准的运算符来定义操作?当然可以!在Swift中,你可以为你创建的所有类型定制运算符的操作。

可定制的运算符并不限于那些预设的运算符,自定义有个性的中置,前置,后置及赋值运算符,当然还有优先级和结合性。这些运算符的实现可以运用预设的运算符,也可以运用之前定制的运算符。

位运算符

位操作符通常在诸如图像处理和创建设备驱动等底层开发中使用,使用它可以单独操作数据结构中原始数据的比特位。在使用一个自定义的协议进行通信的时候,运用位运算符来对原始数据进行编码和解码也是非常有效的。

Swift支持如下所有C语言的位运算符:

按位取反运算符

按位取反运算符~对一个操作数的每一位都取反。

Art/bitwiseNOT_2x.png

这个运算符是前置的,所以请不加任何空格地写着操作数之前。

let initialBits:UInt8=0b00001111
let invertedBits =~initialBits  // 等于 0b11110000

UInt8是8位无符整型,可以存储0~255之间的任意数。这个例子初始化一个整型为二进制值00001111(前4位为0,后4位为1),它的十进制值为15

使用按位取反运算~initialBits操作,然后赋值给invertedBits这个新常量。这个新常量的值等于所有位都取反的initialBits,即1变成00变成1,变成了11110000,十进制值为240

按位与运算符

按位与运算符对两个数进行操作,然后返回一个新的数,这个数的每个位都需要两个输入数的同一位都为1时才为1。

Art/bitwiseAND_2x.png

以下代码,firstSixBitslastSixBits中间4个位都为1。对它俩进行按位与运算后,就得到了00111100,即十进制的60

let firstSixBits:UInt8=0b11111100
let lastSixBits:UInt8=0b00111111
let middleFourBits = firstSixBits & lastSixBits  // 等于 00111100
按位或运算

按位或运算符|比较两个数,然后返回一个新的数,这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为1,或都为1)。

Art/bitwiseOR_2x.png

如下代码,someBitsmoreBits在不同位上有1。按位或运行的结果是11111110,即十进制的254

let someBits:UInt8=0b10110010
let moreBits:UInt8=0b01011110
let combinedbits = someBits | moreBits  // 等于 11111110
按位异或运算符

按位异或运算符^比较两个数,然后返回一个数,这个数的每个位设为1的条件是两个输入数的同一位不同,如果相同就设为0

Art/bitwiseXOR_2x.png

以下代码,firstBitsotherBits都有一个1跟另一个数不同的。所以按位异或的结果是把它这些位置为1,其他都置为0

let firstBits:UInt8=0b00010100
let otherBits:UInt8=0b00000101
let outputBits = firstBits ^ otherBits  // 等于 00010001
按位左移/右移运算符

左移运算符<<和右移运算符>>会把一个数的所有比特位按以下定义的规则向左或向右移动指定位数。

按位左移和按位右移的效果相当把一个整数乘于或除于一个因子为2的整数。向左移动一个整型的比特位相当于把这个数乘于2,向右移一位就是除于2

无符整型的移位操作

对无符整型的移位的效果如下:

已经存在的比特位向左或向右移动指定的位数。被移出整型存储边界的的位数直接抛弃,移动留下的空白位用零0来填充。这种方法称为逻辑移位。

以下这张把展示了 11111111 << 1(11111111向左移1位),和 11111111 >> 1(11111111向右移1位)。蓝色的是被移位的,灰色是被抛弃的,橙色的0是被填充进来的。

Art/bitshiftUnsigned_2x.png

let shiftBits:UInt8=4// 即二进制的00000100
shiftBits <<1// 00001000
shiftBits <<2// 00010000
shiftBits <<5// 10000000
shiftBits <<6// 00000000
shiftBits >>2// 00000001

你可以使用移位操作进行其他数据类型的编码和解码。

let pink:UInt32=0xCC6699
let redComponent =(pink &0xFF0000)>>16// redComponent 是 0xCC, 即 204
let greenComponent =(pink &0x00FF00)>>8// greenComponent 是 0x66, 即 102
let blueComponent = pink &0x0000FF// blueComponent 是 0x99, 即 153

这个例子使用了一个UInt32的命名为pink的常量来存储层叠样式表CSS中粉色的颜色值,CSS颜色#CC6699在Swift用十六进制0xCC6699来表示。然后使用按位与(&)和按位右移就可以从这个颜色值中解析出红(CC),绿(66),蓝(99)三个部分。

0xCC66990xFF0000进行按位与&操作就可以得到红色部分。0xFF0000中的0了遮盖了OxCC6699的第二和第三个字节,这样6699被忽略了,只留下0xCC0000

然后,按向右移动16位,即 >> 16。十六进制中每两个字符是8比特位,所以移动16位的结果是把0xCC0000变成0x0000CC。这和0xCC是相等的,都是十进制的204

同样的,绿色部分来自于0xCC66990x00FF00的按位操作得到0x006600。然后向右移动8們,得到0x66,即十进制的102

最后,蓝色部分对0xCC66990x0000FF进行按位与运算,得到0x000099,无需向右移位了,所以结果就是0x99,即十进制的153

有符整型的移位操作

有符整型的移位操作相对复杂得多,因为正负号也是用二进制位表示的。(这里举的例子虽然都是8位的,但它的原理是通用的。)

有符整型通过第1个比特位(称为符号位)来表达这个整数是正数还是负数。0代表正数,1代表负数。

其余的比特位(称为数值位)存储其实值。有符正整数和无符正整数在计算机里的存储结果是一样的,下来我们来看+4内部的二进制结构。

Art/bitshiftSignedFour_2x.png

符号位为0,代表正数,另外7比特位二进制表示的实际值就刚好是4

负数呢,跟正数不同。负数存储的是2的n次方减去它的绝对值,n为数值位的位数。一个8比特的数有7个数值位,所以是2的7次方,即128。

我们来看-4存储的二进制结构。

Art/bitshiftSignedMinusFour_2x.png

现在符号位为1,代表负数,7个数值位要表达的二进制值是124,即128 – 4。

Art/bitshiftSignedMinusFourValue_2x.png

负数的编码方式称为二进制补码表示。这种表示方式看起来很奇怪,但它有几个优点。

首先,只需要对全部8个比特位(包括符号)做标准的二进制加法就可以完成 -1 + -4 的操作,忽略加法过程产生的超过8个比特位表达的任何信息。

Art/bitshiftSignedAddition_2x.png

第二,由于使用二进制补码表示,我们可以和正数一样对负数进行按位左移右移的,同样也是左移1位时乘于2,右移1位时除于2。要达到此目的,对有符整型的右移有一个特别的要求:

对有符整型按位右移时,使用符号位(正数为0,负数为1)填充空白位。

Art/bitshiftSigned_2x.png

这就确保了在右移的过程中,有符整型的符号不会发生变化。这称为算术移位。

正因为正数和负数特殊的存储方式,向右移位使它接近于0。移位过程中保持符号会不变,负数在接近0的过程中一直是负数。

溢出运算符

默认情况下,当你往一个整型常量或变量赋于一个它不能承载的大数时,Swift不会让你这么干的,它会报错。这样,在操作过大或过小的数的时候就很安全了。

例如,Int16整型能承载的整数范围是-3276832767,如果给它赋上超过这个范围的数,就会报错:

var potentialOverflow =Int16.max
// potentialOverflow 等于 32767, 这是 Int16 能承载的最大整数
potentialOverflow +=1// 噢, 出错了

对过大或过小的数值进行错误处理让你的数值边界条件更灵活。

当然,你有意在溢出时对有效位进行截断,你可采用溢出运算,而非错误处理。Swfit为整型计算提供了5个&符号开头的溢出运算符。

  • 溢出加法 &+
  • 溢出减法 &-
  • 溢出乘法 &*
  • 溢出除法 &/
  • 溢出求余 &%
值的上溢出

下面例子使用了溢出加法&+来解剖的无符整数的上溢出

var willOverflow =UInt8.max
// willOverflow 等于UInt8的最大整数 255
willOverflow = willOverflow &+1// 这时候 willOverflow 等于 0

willOverflowInt8所能承载的最大值255(二进制11111111),然后用&+加1。然后UInt8就无法表达这个新值的二进制了,也就导致了这个新值上溢出了,大家可以看下图。溢出后,新值在UInt8的承载范围内的那部分是00000000,也就是0

Art/overflowAddition_2x.png

值的下溢出

数值也有可能因为太小而越界。举个例子:

UInt8的最小值是0(二进制为00000000)。使用&-进行溢出减1,就会得到二进制的11111111即十进制的255

Art/overflowUnsignedSubtraction_2x.png

Swift代码是这样的:

var willUnderflow =UInt8.min
// willUnderflow 等于UInt8的最小值0
willUnderflow = willUnderflow &-1// 此时 willUnderflow 等于 255

有符整型也有类似的下溢出,有符整型所有的减法也都是对包括在符号位在内的二进制数进行二进制减法的,这在 “按位左移/右移运算符” 一节提到过。最小的有符整数是-128,即二进制的10000000。用溢出减法减去去1后,变成了01111111,即UInt8所能承载的最大整数127

Art/overflowSignedSubtraction_2x.png

来看看Swift代码:

var signedUnderflow =Int8.min
// signedUnderflow 等于最小的有符整数 -128
signedUnderflow = signedUnderflow &-1// 如今 signedUnderflow 等于 127
除零溢出

一个数除于0 i / 0,或者对0求余数 i % 0,就会产生一个错误。

let x =1
let y = x /0

使用它们对应的可溢出的版本的运算符&/&%进行除0操作时就会得到0值。

let x =1
let y = x &/ 0
// y 等于0

优先级和结合性

运算符的优先级使得一些运算符优先于其他运算符,高优先级的运算符会先被计算。

结合性定义相同优先级的运算符在一起时是怎么组合或关联的,是和左边的一组呢,还是和右边的一组。意思就是,到底是和左边的表达式结合呢,还是和右边的表达式结合?

在混合表达式中,运算符的优先级和结合性是非常重要的。举个例子,为什么下列表达式的结果为4

2+3*4%5// 结果是 4

如果严格地从左计算到右,计算过程会是这样:

  • 2 plus 3 equals 5;
  • 2 + 3 = 5
  • 5 times 4 equals 20;
  • 5 * 4 = 20
  • 20 remainder 5 equals 0
  • 20 / 5 = 4 余 0

但是正确答案是4而不是0。优先级高的运算符要先计算,在Swift和C语言中,都是先乘除后加减的。所以,执行完乘法和求余运算才能执行加减运算。

乘法和求余拥有相同的优先级,在运算过程中,我们还需要结合性,乘法和求余运算都是左结合的。这相当于在表达式中有隐藏的括号让运算从左开始。

2+((3*4)%5)

(3 4) is 12, so this is equivalent to: 3 4 = 12,所以这相当于:

2+(12%5)

(12 % 5) is 2, so this is equivalent to: 12 % 5 = 2,所这又相当于

2+2

计算结果为 4。

查阅Swift运算符的优先级和结合性的完整列表,请看表达式。

注意:

Swift的运算符较C语言和Objective-C来得更简单和保守,这意味着跟基于C的语言可能不一样。所以,在移植已有代码到Swift时,注意去确保代码按你想的那样去执行。

运算符函数

让已有的运算符也可以对自定义的类和结构进行运算,这称为运算符重载。

这个例子展示了如何用+让一个自定义的结构做加法。算术运算符+是一个两目运算符,因为它有两个操作数,而且它必须出现在两个操作数之间。

例子中定义了一个名为Vector2D的二维坐标向量 (x,y) 的结构,然后定义了让两个Vector2D的对象相加的运算符函数。

structVector2D{var x =0.0, y =0.0}@infix func +(left:Vector2D, right:Vector2D)->Vector2D{returnVector2D(x: left.x + right.x, y: left.y + right.y)}

该运算符函数定义了一个全局的+函数,这个函数需要两个Vector2D类型的参数,返回值也是Vector2D类型。需要定义和实现一个中置运算的时候,在关键字func之前写上属性 @infix 就可以了。

在这个代码实现中,参数被命名为了leftright,代表+左边和右边的两个Vector2D对象。函数返回了一个新的Vector2D的对象,这个对象的xy分别等于两个参数对象的xy的和。

这个函数是全局的,而不是Vector2D结构的成员方法,所以任意两个Vector2D对象都可以使用这个中置运算符。

let vector =Vector2D(x:3.0, y:1.0)
let anotherVector =Vector2D(x:2.0, y:4.0)
let combinedVector = vector + anotherVector
// combinedVector 是一个新的Vector2D, 值为 (5.0, 5.0)

这个例子实现两个向量 (3.0,1.0) 和 (2.0,4.0) 相加,得到向量 (5.0,5.0) 的过程。如下图示:

Art/vectorAddition_2x.png

前置和后置运算符

上个例子演示了一个双目中置运算符的自定义实现,同样我们也可以玩标准单目运算符的实现。单目运算符只有一个操作数,在操作数之前就是前置的,如-a; 在操作数之后就是后置的,如i++

实现一个前置或后置运算符时,在定义该运算符的时候于关键字func之前标注 @prefix 或 @postfix属性。

@prefix func -(vector:Vector2D)->Vector2D{returnVector2D(x:-vector.x, y:-vector.y)}

这段代码为Vector2D类型提供了单目减运算-a@prefix属性表明这是个前置运算符。

对于数值,单目减运算符可以把正数变负数,把负数变正数。对于Vector2D,单目减运算将其xy都进进行单目减运算。

let positive =Vector2D(x:3.0, y:4.0)
let negative =-positive
// negative 为 (-3.0, -4.0)
let alsoPositive =-negative
// alsoPositive 为 (3.0, 4.0)
组合赋值运算符

组合赋值是其他运算符和赋值运算符一起执行的运算。如+=把加运算和赋值运算组合成一个操作。实现一个组合赋值符号需要使用@assignment属性,还需要把运算符的左参数设置成inout,因为这个参数会在运算符函数内直接修改它的值。

@assignment func +=(inout left:Vector2D, right:Vector2D){
    left = left + right
}

因为加法运算在之前定义过了,这里无需重新定义。所以,加赋运算符函数使用已经存在的高级加法运算符函数来执行左值加右值的运算。

var original =Vector2D(x:1.0, y:2.0)
let vectorToAdd =Vector2D(x:3.0, y:4.0)
original += vectorToAdd
// original 现在为 (4.0, 6.0)

你可以将 @assignment 属性和 @prefix 或 @postfix 属性起来组合,实现一个Vector2D的前置运算符。

@prefix@assignment func ++(inout vector:Vector2D)->Vector2D{
    vector +=Vector2D(x:1.0, y:1.0)return vector
}

这个前置使用了已经定义好的高级加赋运算,将自己加上一个值为 (1.0,1.0) 的对象然后赋给自己,然后再将自己返回。

var toIncrement =Vector2D(x:3.0, y:4.0)
let afterIncrement =++toIncrement
// toIncrement 现在是 (4.0, 5.0)// afterIncrement 现在也是 (4.0, 5.0)

注意:

默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 a?b:c 也是不可重载。

比较运算符

Swift无所知道自定义类型是否相等或不等,因为等于或者不等于由你的代码说了算了。所以自定义的类和结构要使用比较符==!=就需要重载。

定义相等运算符函数跟定义其他中置运算符雷同:

@infix func ==(left:Vector2D, right:Vector2D)->Bool{return(left.x == right.x)&&(left.y == right.y)}@infix func !=(left:Vector2D, right:Vector2D)->Bool{return!(left == right)}

上述代码实现了相等运算符==来判断两个Vector2D对象是否有相等的值,相等的概念就是他们有相同的x值和相同的y值,我们就用这个逻辑来实现。接着使用==的结果实现了不相等运算符!=

现在我们可以使用这两个运算符来判断两个Vector2D对象是否相等。

let twoThree =Vector2D(x:2.0, y:3.0)
let anotherTwoThree =Vector2D(x:2.0, y:3.0)if twoThree == anotherTwoThree {
    println("这两个向量是相等的.")}// prints "这两个向量是相等的."
自定义运算符

标准的运算符不够玩,那你可以声明一些个性的运算符,但个性的运算符只能使用这些字符/ = - + * % < >!& | ^。~

新的运算符声明需在全局域使用operator关键字声明,可以声明为前置,中置或后置的。

operator prefix +++{}

这段代码定义了一个新的前置运算符叫+++,此前Swift并不存在这个运算符。此处为了演示,我们让+++Vector2D对象的操作定义为 双自增 这样一个独有的操作,这个操作使用了之前定义的加赋运算实现了自已加上自己然后返回的运算。

@prefix@assignment func +++(inout vector:Vector2D)->Vector2D{
    vector += vector
    return vector
}

Vector2D 的 +++ 的实现和 ++ 的实现很接近, 唯一不同的前者是加自己, 后者是加值为 (1.0, 1.0) 的向量.

var toBeDoubled =Vector2D(x:1.0, y:4.0)
let afterDoubling =+++toBeDoubled
// toBeDoubled 现在是 (2.0, 8.0)// afterDoubling 现在也是 (2.0, 8.0)
自定义中置运算符的优先级和结合性

可以为自定义的中置运算符指定优先级和结合性。可以回头看看优先级和结合性解释这两个因素是如何影响多种中置运算符混合的表达式的计算的。

结合性(associativity)的值可取的值有leftrightnone。左结合运算符跟其他优先级相同的左结合运算符写在一起时,会跟左边的操作数结合。同理,右结合运算符会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。

结合性(associativity)的值默认为none,优先级(precedence)默认为100

以下例子定义了一个新的中置符+-,是左结合的left,优先级为140

operator infix +-{ associativity left precedence 140}
func +-(left:Vector2D, right:Vector2D)->Vector2D{returnVector2D(x: left.x + right.x, y: left.y - right.y)}
let firstVector =Vector2D(x:1.0, y:2.0)
let secondVector =Vector2D(x:3.0, y:4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector 此时的值为 (4.0, -2.0)

这个运算符把两个向量的x相加,把向量的y相减。因为他实际是属于加减运算,所以让它保持了和加法一样的结合性和优先级(left140)。查阅完整的Swift默认结合性和优先级的设置,请移步表达式;

本文部分原文来自于http://www.swiftguide.cn/翻译小组的译文,共同校对中。

感谢翻译小组成员:李起攀(微博)、若晨(微博)、YAO、粽子、山有木兮木有枝、渺-Bessie、墨离、矮人王、CXH、Tiger大顾(微博)
个人转载请注明出处和原始链接http://letsswift.com/2014/06/advanced-operators/ ‎,商业转载请联系我们~ 感谢您对我们工作的支持~

Swift中文教程(22)泛型

转载自letsswift.com

泛型代码可以让你写出根据自我需求定义、适用于任何类型的,灵活且可重用的函数和类型。它的可以让你避免重复的代码,用一种清晰和抽象的方式来表达代码的意图。

泛型是 Swift 强大特征中的其中一个,许多 Swift 标准库是通过泛型代码构建出来的。事实上,泛型的使用贯穿了整本语言手册,只是你没有发现而已。例如,Swift 的数组和字典类型都是泛型集。你可以创建一个Int数组,也可创建一个String数组,或者甚至于可以是任何其他 Swift 的类型数据数组。同样的,你也可以创建存储任何指定类型的字典(dictionary),而且这些类型可以是没有限制的。

泛型所解决的问题

这里是一个标准的,非泛型函数swapTwoInts,用来交换两个Int值:

func swapTwoInts(inout a:Int, inout b:Int)
    let temporaryA = a
    a = b
    b = temporaryA
}

这个函数使用写入读出(in-out)参数来交换ab的值,请参考[写入读出参数][1]。

swapTwoInts函数可以交换b的原始值到a,也可以交换a的原始值到b,你可以调用这个函数交换两个Int变量值:

var someInt =3var anotherInt =107
swapTwoInts(&someInt,&anotherInt)
println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")// 输出 "someInt is now 107, and anotherInt is now 3"

swapTwoInts函数是非常有用的,但是它只能交换Int值,如果你想要交换两个String或者Double,就不得不写更多的函数,如 swapTwoStringsswapTwoDoublesfunctions,如同如下所示:

func swapTwoStrings(inout a:String, inout b:String){
    let temporaryA = a
    a = b
    b = temporaryA
}

func swapTwoDoubles(inout a:Double, inout b:Double){
    let temporaryA = a
    a = b
    b = temporaryA
}

你可能注意到 swapTwoInts、 swapTwoStringsswapTwoDoubles函数功能都是相同的,唯一不同之处就在于传入的变量类型不同,分别是IntStringDouble

但实际应用中通常需要一个用处更强大并且尽可能的考虑到更多的灵活性单个函数,可以用来交换两个任何类型值,很幸运的是,泛型代码帮你解决了这种问题。(一个这种泛型函数后面已经定义好了。)

注意: 在所有三个函数中,ab的类型是一样的。如果ab不是相同的类型,那它们俩就不能互换值。Swift 是类型安全的语言,所以它不允许一个String类型的变量和一个Double类型的变量互相交换值。如果一定要做,Swift 将报编译错误。

泛型函数

泛型函数可以工作于任何类型,这里是一个上面swapTwoInts函数的泛型版本,用于交换两个值:

func swapTwoValues<T>(inout a: T, inout b: T){
    let temporaryA = a
    a = b
    b = temporaryA
}

swapTwoValues函数主体和swapTwoInts函数是一样的,它只在第一行稍微有那么一点点不同于swapTwoInts,如下所示:

func swapTwoInts(inout a:Int, inout b:Int)
func swapTwoValues<T>(inout a: T, inout b: T)

这个函数的泛型版本使用了占位类型名字(通常此情况下用字母T来表示)来代替实际类型名(如InStringDoubl)。占位类型名没有提示T必须是什么类型,但是它提示了ab必须是同一类型T,而不管T表示什么类型。只有swapTwoValues函数在每次调用时所传入的实际类型才能决定T所代表的类型。

另外一个不同之处在于这个泛型函数名后面跟着的展位类型名字(T)是用尖括号括起来的()。这个尖括号告诉 Swift 那个TswapTwoValues函数所定义的一个类型。因为T是一个占位命名类型,Swift 不会去查找命名为T的实际类型。

swapTwoValues函数除了要求传入的两个任何类型值是同一类型外,也可以作为swapTwoInts函数被调用。每次swapTwoValues被调用,T所代表的类型值都会传给函数。

在下面的两个例子中,T分别代表IntString

var someInt =3var anotherInt =107
swapTwoValues(&someInt,&anotherInt)// someInt is now 107, and anotherInt is now 3var someString ="hello"var anotherString ="world"
swapTwoValues(&someString,&anotherString)// someString is now "world", and anotherString is now "hello"

注意 上面定义的函数swapTwoValues是受swap函数启发而实现的。swap函数存在于 Swift 标准库,并可以在其它类中任意使用。如果你在自己代码中需要类似swapTwoValues函数的功能,你可以使用已存在的交换函数swap函数。

类型参数

在上面的swapTwoValues例子中,占位类型T是一种类型参数的示例。类型参数指定并命名为一个占位类型,并且紧随在函数名后面,使用一对尖括号括起来(如)。

一旦一个类型参数被指定,那么其可以被使用来定义一个函数的参数类型(如swapTwoValues函数中的参数ab),或作为一个函数返回类型,或用作函数主体中的注释类型。在这种情况下,被类型参数所代表的占位类型不管函数任何时候被调用,都会被实际类型所替换(在上面swapTwoValues例子中,当函数第一次被调用时,TInt替换,第二次调用时,被String替换。)。

你可支持多个类型参数,命名在尖括号中,用逗号分开。

命名类型参数

在简单的情况下,泛型函数或泛型类型需要指定一个占位类型(如上面的swapTwoValues泛型函数,或一个存储单一类型的泛型集,如数组),通常用一单个字母T来命名类型参数。不过,你可以使用任何有效的标识符来作为类型参数名。

如果你使用多个参数定义更复杂的泛型函数或泛型类型,那么使用更多的描述类型参数是非常有用的。例如,Swift 字典(Dictionary)类型有两个类型参数,一个是键,另外一个是值。如果你自己写字典,你或许会定义这两个类型参数为KeyTypeValueType,用来记住它们在你的泛型代码中的作用。

注意 请始终使用大写字母开头的驼峰式命名法(例如TKeyType)来给类型参数命名,以表明它们是类型的占位符,而非类型值。

泛型类型

通常在泛型函数中,Swift 允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型,如同ArrayDictionary的用法。

这部分向你展示如何写一个泛型集类型–Stack(栈)。一个栈是一系列值域的集合,和Array(数组)类似,但其是一个比 Swift 的Array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作,而栈,只允许在集合的末端添加新的项(如同push一个新值进栈)。同样的一个栈也只能从末端移除项(如同pop一个值出栈)。

注意 栈的概念已被UINavigationController类使用来模拟试图控制器的导航结构。你通过调用UINavigationControllerpushViewController:animated:方法来为导航栈添加(add)新的试图控制器;而通过popViewControllerAnimated:的方法来从导航栈中移除(pop)某个试图控制器。每当你需要一个严格的后进先出方式来管理集合,堆栈都是最实用的模型。

下图展示了一个栈的压栈(push)/出栈(pop)的行为:

![此处输入图片的描述][2]

  1. 现在有三个值在栈中;
  2. 第四个值“pushed”到栈的顶部;
  3. 现在有四个值在栈中,最近的那个在顶部;
  4. 栈中最顶部的那个项被移除,或称之为“popped”;
  5. 移除掉一个值后,现在栈又重新只有三个值。

这里展示了如何写一个非泛型版本的栈,Int值型的栈:

structIntStack{var items =Int[]()
    mutating func push(item:Int){
        items.append(item)}
    mutating func pop()->Int{return items.removeLast()}}

这个结构体在栈中使用一个Array性质的items存储值。Stack提供两个方法:pushpop,从栈中压进一个值和移除一个值。这些方法标记为可变的,因为他们需要修改(或转换)结构体的items数组。

上面所展现的IntStack类型只能用于Int值,不过,其对于定义一个泛型Stack类(可以处理任何类型值的栈)是非常有用的。

这里是一个相同代码的泛型版本:

structStack<T>{var items = T[]()
    mutating func push(item: T){
        items.append(item)}
    mutating func pop()-> T {return items.removeLast()}}

注意到Stack的泛型版本基本上和非泛型版本相同,但是泛型版本的占位类型参数为T代替了实际Int类型。这种类型参数包含在一对尖括号里(<T>),紧随在结构体名字后面。

T定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下,T在如下三个地方被用作节点:

  • 创建一个名为items的属性,使用空的T类型值数组对其进行初始化;
  • 指定一个包含一个参数名为itempush方法,该参数必须是T类型;
  • 指定一个pop方法的返回值,该返回值将是一个T类型值。

当创建一个新单例并初始化时, 通过用一对紧随在类型名后的尖括号里写出实际指定栈用到类型,创建一个Stack实例,同创建ArrayDictionary一样:

var stackOfStrings =Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")// 现在栈已经有4个string了

下图将展示stackOfStrings如何push这四个值进栈的过程:

![此处输入图片的描述][3]

从栈中pop并移除值”cuatro”:

let fromTheTop = stackOfStrings.pop()// fromTheTop is equal to "cuatro", and the stack now contains 3 strings

下图展示了如何从栈中pop一个值的过程: ![此处输入图片的描述][4]

由于Stack是泛型类型,所以在 Swift 中其可以用来创建任何有效类型的栈,这种方式如同ArrayDictionary

类型约束

swapTwoValues函数和Stack类型可以作用于任何类型,不过,有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数,或者遵循一个特定的协议或协议构成。

例如,Swift 的Dictionary类型对作用于其键的类型做了些限制。在[字典][5]的描述中,字典的键类型必须是可哈希,也就是说,必须有一种方法可以使其是唯一的表示。Dictionary之所以需要其键是可哈希是为了以便于其检查其是否包含某个特定键的值。如无此需求,Dictionary即不会告诉是否插入或者替换了某个特定键的值,也不能查找到已经存储在字典里面的给定键值。

这个需求强制加上一个类型约束作用于Dictionary的键上,当然其键类型必须遵循Hashable协议(Swift 标准库中定义的一个特定协议)。所有的 Swift 基本类型(如StringInt, DoubleBool)默认都是可哈希。

当你创建自定义泛型类型时,你可以定义你自己的类型约束,当然,这些约束要支持泛型编程的强力特征中的多数。抽象概念如可哈希具有的类型特征是根据他们概念特征来界定的,而不是他们的直接类型特征。

类型约束语法

你可以写一个在一个类型参数名后面的类型约束,通过冒号分割,来作为类型参数链的一部分。这种作用于泛型函数的类型约束的基础语法如下所示(和泛型类型的语法相同):

func someFunction<T:SomeClass, U:SomeProtocol>(someT: T, someU: U){// function body goes here}

上面这个假定函数有两个类型参数。第一个类型参数T,有一个需要T必须是SomeClass子类的类型约束;第二个类型参数U,有一个需要U必须遵循SomeProtocol协议的类型约束。

类型约束行为

这里有个名为findStringIndex的非泛型函数,该函数功能是去查找包含一给定String值的数组。若查找到匹配的字符串,findStringIndex函数返回该字符串在数组中的索引值(Int),反之则返回nil

func findStringIndex(array:String[], valueToFind:String)->Int?{for(index, value)in enumerate(array){if value == valueToFind {return index
        }}returnnil}

findStringIndex函数可以作用于查找一字符串数组中的某个字符串:

let strings =["cat","dog","llama","parakeet","terrapin"]if let foundIndex = findStringIndex(strings,"llama"){
    println("The index of llama is \(foundIndex)")}// 输出 "The index of llama is 2"

如果只是针对字符串而言查找在数组中的某个值的索引,用处不是很大,不过,你可以写出相同功能的泛型函数findIndex,用某个类型T值替换掉提到的字符串。

这里展示如何写一个你或许期望的findStringIndex的泛型版本findIndex。请注意这个函数仍然返回Int,是不是有点迷惑呢,而不是泛型类型?那是因为函数返回的是一个可选的索引数,而不是从数组中得到的一个可选值。需要提醒的是,这个函数不会编译,原因在例子后面会说明:

func findIndex<T>(array: T[], valueToFind: T)->Int?{for(index, value)in enumerate(array){if value == valueToFind {return index
        }}returnnil}

上面所写的函数不会编译。这个问题的位置在等式的检查上,“if value == valueToFind”。不是所有的 Swift 中的类型都可以用等式符(==)进行比较。例如,如果你创建一个你自己的类或结构体来表示一个复杂的数据模型,那么 Swift 没法猜到对于这个类或结构体而言“等于”的意思。正因如此,这部分代码不能可能保证工作于每个可能的类型T,当你试图编译这部分代码时估计会出现相应的错误。

不过,所有的这些并不会让我们无从下手。Swift 标准库中定义了一个Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的 Swift 标准类型自动支持Equatable协议。

任何Equatable类型都可以安全的使用在findIndex函数中,因为其保证支持等式操作。为了说明这个事实,当你定义一个函数时,你可以写一个Equatable类型约束作为类型参数定义的一部分:

func findIndex<T:Equatable>(array: T[], valueToFind: T)->Int?{for(index, value)in enumerate(array){if value == valueToFind {return index
        }}returnnil}

findIndex中这个单个类型参数写做:T: Equatable,也就意味着“任何T类型都遵循Equatable协议”。

findIndex函数现在则可以成功的编译过,并且作用于任何遵循Equatable的类型,如DoubleString:

let doubleIndex = findIndex([3.14159,0.1,0.25],9.3)// doubleIndex is an optional Int with no value, because 9.3 is not in the array
let stringIndex = findIndex(["Mike","Malcolm","Andrea"],"Andrea")// stringIndex is an optional Int containing a value of 2

关联类型

当定义一个协议时,有的时候声明一个或多个关联类型作为协议定义的一部分是非常有用的。一个关联类型给定作用于协议部分的类型一个节点名(或别名)。作用于关联类型上实际类型是不需要指定的,直到该协议接受。关联类型被指定为typealias关键字。

关联类型行为

这里是一个Container协议的例子,定义了一个ItemType关联类型:

protocol Container{
    typealias ItemType
    mutating func append(item:ItemType)var count:Int{get}
    subscript(i:Int)->ItemType{get}}

Container协议定义了三个任何容器必须支持的兼容要求:

  • 必须可能通过append方法添加一个新item到容器里;
  • 必须可能通过使用count属性获取容器里items的数量,并返回一个Int值;
  • 必须可能通过容器的Int索引值下标可以检索到每一个item。

这个协议没有指定容器里item是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循Container类型所必须支持的功能点。一个遵循的类型也可以提供其他额外的功能,只要满足这三个条件。

任何遵循Container协议的类型必须指定存储在其里面的值类型,必须保证只有正确类型的items可以加进容器里,必须明确可以通过其下标返回item类型。

为了定义这三个条件,Container协议需要一个方法指定容器里的元素将会保留,而不需要知道特定容器的类型。Container协议需要指定任何通过append方法添加到容器里的值和容器里元素是相同类型,并且通过容器下标返回的容器元素类型的值的类型是相同类型。

为了达到此目的,Container协议声明了一个ItemType的关联类型,写作typealias ItemType。The protocol does not define what ItemType is an alias for—that information is left for any conforming type to provide(这个协议不会定义ItemType是遵循类型所提供的何种信息的别名)。尽管如此,ItemType别名支持一种方法识别在一个容器里的items类型,以及定义一种使用在append方法和下标中的类型,以便保证任何期望的Container的行为是强制性的。

这里是一个早前IntStack类型的非泛型版本,适用于遵循Container协议:

structIntStack:Container{// original IntStack implementationvar items =Int[]()
    mutating func push(item:Int){
        items.append(item)}
    mutating func pop()->Int{return items.removeLast()}// conformance to the Container protocol
    typealias ItemType=Int
    mutating func append(item:Int){self.push(item)}var count:Int{return items.count
    }
    subscript(i:Int)->Int{return items[i]}}

IntStack类型实现了Container协议的所有三个要求,在IntStack类型的每个包含部分的功能都满足这些要求。

此外,IntStack指定了Container的实现,适用的ItemType被用作Int类型。对于这个Container协议实现而言,定义 typealias ItemType = Int,将抽象的ItemType类型转换为具体的Int类型。

感谢Swift类型参考,你不用在IntStack定义部分声明一个具体的IntItemType。由于IntStack遵循Container协议的所有要求,只要通过简单的查找append方法的item参数类型和下标返回的类型,Swift就可以推断出合适的ItemType来使用。确实,如果上面的代码中你删除了 typealias ItemType = Int这一行,一切仍旧可以工作,因为它清楚的知道ItemType使用的是何种类型。

你也可以生成遵循Container协议的泛型Stack类型:

structStack<T>:Container{// original Stack<T> implementationvar items = T[]()
    mutating func push(item: T){
        items.append(item)}
    mutating func pop()-> T {return items.removeLast()}// conformance to the Container protocol
    mutating func append(item: T){self.push(item)}var count:Int{return items.count
    }
    subscript(i:Int)-> T {return items[i]}}

这个时候,占位类型参数T被用作append方法的item参数和下标的返回类型。Swift 因此可以推断出被用作这个特定容器的ItemTypeT的合适类型。

扩展一个存在的类型为一指定关联类型

在[使用扩展来添加协议兼容性][6]中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。

Swift的Array已经提供append方法,一个count属性和通过下标来查找一个自己的元素。这三个功能都达到Container协议的要求。也就意味着你可以扩展Array去遵循Container协议,只要通过简单声明Array适用于该协议而已。如何实践这样一个空扩展,在[使用扩展来声明协议的采纳][7]中有描述这样一个实现一个空扩展的行为:

extension Array:Container{}

如同上面的泛型Stack类型一样,Array的append方法和下标保证Swift可以推断出ItemType所使用的适用的类型。定义了这个扩展后,你可以将任何Array当作Container来使用。

Where 语句

[类型约束][8]中描述的类型约束确保你定义关于类型参数的需求和一泛型函数或类型有关联。

对于关联类型的定义需求也是非常有用的。你可以通过这样去定义where语句作为一个类型参数队列的一部分。一个where语句使你能够要求一个关联类型遵循一个特定的协议,以及(或)那个特定的类型参数和关联类型可以是相同的。你可写一个where语句,通过紧随放置where关键字在类型参数队列后面,其后跟着一个或者多个针对关联类型的约束,以及(或)一个或多个类型和关联类型的等于关系。

下面的列子定义了一个名为allItemsMatch的泛型函数,用来检查是否两个Container单例包含具有相同顺序的相同元素。如果匹配到所有的元素,那么返回一个为trueBoolean值,反之,则相反。

这两个容器可以被检查出是否是相同类型的容器(虽然它们可以是),但他们确实拥有相同类型的元素。这个需求通过一个类型约束和where语句结合来表示:

func allItemsMatch<
    C1:Container, C2:Containerwhere C1.ItemType== C2.ItemType, C1.ItemType:Equatable>(someContainer: C1, anotherContainer: C2)->Bool{// check that both containers contain the same number of itemsif someContainer.count != anotherContainer.count {returnfalse}// check each pair of items to see if they are equivalentfor i in0..someContainer.count {if someContainer[i]!= anotherContainer[i]{returnfalse}}// all items match, so return truereturntrue}

这个函数用了两个参数:someContaineranotherContainersomeContainer参数是类型C1anotherContainer参数是类型C2C1C2是容器的两个占位类型参数,决定了这个函数何时被调用。

这个函数的类型参数列紧随在两个类型参数需求的后面:

  • C1必须遵循Container协议 (写作 C1: Container)。
  • C2必须遵循Container协议 (写作 C2: Container)。
  • C1ItemType同样是C2的ItemType(写作 C1.ItemType == C2.ItemType)。
  • C1ItemType必须遵循Equatable协议 (写作 C1.ItemType: Equatable)。

第三个和第四个要求被定义为一个where语句的一部分,写在关键字where后面,作为函数类型参数链的一部分。

这些要求意思是:

someContainer是一个C1类型的容器。 anotherContainer是一个C2类型的容器。 someContaineranotherContainer包含相同的元素类型。 someContainer中的元素可以通过不等于操作(!=)来检查它们是否彼此不同。

第三个和第四个要求结合起来的意思是anotherContainer中的元素也可以通过 != 操作来检查,因为他们在someContainer中元素确实是相同的类型。

这些要求能够使allItemsMatch函数比较两个容器,即便他们是不同的容器类型。

allItemsMatch首先检查两个容器是否拥有同样数目的items,如果他们的元素数目不同,没有办法进行匹配,函数就会false

检查完之后,函数通过for-in循环和半闭区间操作(..)来迭代someContainer中的所有元素。对于每个元素,函数检查是否someContainer中的元素不等于对应的anotherContainer中的元素,如果这两个元素不等,则这两个容器不匹配,返回false

如果循环体结束后未发现没有任何的不匹配,那表明两个容器匹配,函数返回true

这里演示了allItemsMatch函数运算的过程:

var stackOfStrings =Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")var arrayOfStrings =["uno","dos","tres"]if allItemsMatch(stackOfStrings, arrayOfStrings){
    println("All items match.")}else{
    println("Not all items match.")}// 输出 "All items match."

上面的例子创建一个Stack单例来存储String,然后压了三个字符串进栈。这个例子也创建了一个Array单例,并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型,但他们都遵循Container协议,而且他们都包含同样的类型值。你因此可以调用allItemsMatch函数,用这两个容器作为它的参数。在上面的例子中,allItemsMatch函数正确的显示了所有的这两个容器的items匹配。

本文部分原文来自于http://www.swiftguide.cn/翻译小组的译文,共同校对中。

感谢翻译小组成员:李起攀(微博)、若晨(微博)、YAO、粽子、山有木兮木有枝、渺-Bessie、墨离、矮人王、CXH、Tiger大顾(微博)
个人转载请注明出处和原始链接http://letsswift.com/2014/06/generics/,商业转载请联系我们~ 感谢您对我们工作的支持~

Swift中文教程(21)协议

转载自letsswift.com

Protocol(协议)用于统一方法和属性的名称,而不实现任何功能。协议能够被类,枚举,结构体实现,满足协议要求的类,枚举,结构体被称为协议的遵循者

遵循者需要提供协议指定的成员,如属性,方法,操作符,下标等。

协议的语法

协议的定义与类,结构体,枚举的定义非常相似,如下所示:

protocol SomeProtocol{// 协议内容}

在类,结构体,枚举的名称后加上协议名称,中间以冒号:分隔即可实现协议;实现多个协议时,各协议之间用逗号,分隔,如下所示:

structSomeStructure:FirstProtocol,AnotherProtocol{// 结构体内容}

当某个类含有父类的同时并实现了协议,应当把父类放在所有的协议之前,如下所示:

classSomeClass:SomeSuperClass,FirstProtocol,AnotherProtocol{// 类的内容}

属性要求

协议能够要求其遵循者必须含有一些特定名称和类型实例属性(instance property)类属性 (type property),也能够要求属性的(设置权限)settable 和(访问权限)gettable,但它不要求属性存储型属性(stored property)还是计算型属性(calculate property)

通常前置var关键字将属性声明为变量。在属性声明后写上{ get set }表示属性为可读写的。{ get }用来表示属性为可读的。即使你为可读的属性实现了setter方法,它也不会出错。

protocol SomeProtocol{var musBeSettable :Int{getset}var doesNotNeedToBeSettable:Int{get}}

用类来实现协议时,使用class关键字来表示该属性为类成员;用结构体或枚举实现协议时,则使用static关键字来表示:

protocol AnotherProtocol{classvar someTypeProperty:Int{getset}}

protocol FullyNamed{var fullName:String{get}}

FullyNamed协议含有fullName属性。因此其遵循者必须含有一个名为fullName,类型为String的可读属性。

structPerson:FullyNamed{var fullName:String}
let john =Person(fullName:"John Appleseed")//john.fullName 为 "John Appleseed"

Person结构体含有一个名为fullName存储型属性,完整的遵循了协议。(若协议未被完整遵循,编译时则会报错)。

如下所示,Startship遵循FullyNamed协议:

classStarship:FullyNamed{var prefix:String?var name:String
    init(name:String, prefix:String?=nil){self.anme = name
        self.prefix = prefix
    }var fullName:String{return(prefix ? prefix !+" ":" ")+ name
    }}var ncc1701 =Starship(name:"Enterprise", prefix:"USS")// ncc1701.fullName == "USS Enterprise"

Starship类将fullName实现为可读的计算型属性。它的每一个实例都有一个名为name的必备属性和一个名为prefix的可选属性。 当prefix存在时,将prefix插入到name之前来为Starship构建fullName

方法要求

协议能够要求其遵循者必备某些特定的实例方法类方法。协议方法的声明与普通方法声明相似,但它不需要方法内容。

注意:

协议方法支持变长参数(variadic parameter),不支持默认参数(default parameter)

前置class关键字表示协议中的成员为类成员;当协议用于被枚举结构体遵循时,则使用static关键字。如下所示:

protocol SomeProtocol{class func someTypeMethod()}

protocol RandomNumberGenerator{
    func random()->Double}

RandomNumberGenerator协议要求其遵循者必须拥有一个名为random, 返回值类型为Double的实例方法。(我们假设随机数在[0,1]区间内)。

LinearCongruentialGenerator遵循RandomNumberGenerator协议,并提供了一个叫做线性同余生成器(linear congruential generator)的伪随机数算法。

classLinearCongruentialGenerator:RandomNumberGenerator{var lastRandom =42.0
    let m =139968.0
    let a =3877.0
    let c =29573.0
    func random()->Double{
        lastRandom =((lastRandom * a + c)% m)return lastRandom / m
    }}
let generator =LinearCongruentialGenerator()
println("Here's a random number: \(generator.random())")// 输出 : "Here's a random number: 0.37464991998171"
println("And another one: \(generator.random())")// 输出 : "And another one: 0.729023776863283"

突变方法要求

能在方法函数内部改变实例类型的方法称为突变方法。在值类型(Value Type)(译者注:特指结构体和枚举)中的的函数前缀加上mutating关键字来表示该函数允许改变该实例和其属性的类型。 这一变换过程在实例方法(Instance Methods)章节中有详细描述。

(译者注:类中的成员为引用类型(Reference Type),可以方便的修改实例及其属性的值而无需改变类型;而结构体枚举中的成员均为值类型(Value Type),修改变量的值就相当于修改变量的类型,而Swift默认不允许修改类型,因此需要前置mutating关键字用来表示该函数中能够修改类型)

注意:

class实现协议中的mutating方法时,不用写mutating关键字;用结构体枚举实现协议中的mutating方法时,必须写mutating关键字。

如下所示,Togglable协议含有toggle函数。根据函数名称推测,toggle可能用于切换或恢复某个属性的状态。mutating关键字表示它为突变方法

protocol Togglable{
    mutating func toggle()}

当使用枚举结构体来实现Togglabl协议时,必须在toggle方法前加上mutating关键字。

如下所示,OnOffSwitch枚举遵循Togglable协议,OnOff两个成员用于表示当前状态

enumOnOffSwitch:Togglable{caseOff,On
    mutating func toggle(){switchself{caseOff:self=OncaseOn:self=Off}}}var lightSwitch =OnOffSwitch.Off
lightSwitch.toggle()//lightSwitch 现在的值为 .On

协议类型

协议本身不实现任何功能,但你可以将它当做类型来使用。

使用场景:

  • 作为函数,方法或构造器中的参数类型,返回值类型
  • 作为常量,变量,属性的类型
  • 作为数组,字典或其他容器中的元素类型

注意:

协议类型应与其他类型(Int,Double,String)的写法相同,使用驼峰式

classDice{
    let sides:Int
    let generator:RandomNumberGenerator
    init(sides:Int, generator:RandomNumberGenerator){self.sides = sides
        self.generator = generator
    }
    func roll()->Int{returnInt(generator.random()*Double(sides))+1}}

这里定义了一个名为 Dice的类,用来代表桌游中的N个面的骰子。

Dice含有sidesgenerator两个属性,前者用来表示骰子有几个面,后者为骰子提供一个随机数生成器。由于后者为RandomNumberGenerator的协议类型。所以它能够被赋值为任意遵循该协议的类型。

此外,使用构造器(init)来代替之前版本中的setup操作。构造器中含有一个名为generator,类型为RandomNumberGenerator的形参,使得它可以接收任意遵循RandomNumberGenerator协议的类型。

roll方法用来模拟骰子的面值。它先使用generatorrandom方法来创建一个[0-1]区间内的随机数种子,然后加工这个随机数种子生成骰子的面值。

如下所示,LinearCongruentialGenerator的实例作为随机数生成器传入Dice构造器

var d6 =Dice(sides:6,generator:LinearCongruentialGenerator())for _ in1...5{
    println("Random dice roll is \(d6.roll())")}//输出结果//Random dice roll is 3//Random dice roll is 5//Random dice roll is 4//Random dice roll is 5//Random dice roll is 4

委托(代理)模式

委托是一种设计模式,它允许类或结构体将一些需要它们负责的功能交由(委托)给其他的类型。

委托模式的实现很简单: 定义协议封装那些需要被委托的函数和方法, 使其遵循者拥有这些被委托的函数和方法

委托模式可以用来响应特定的动作或接收外部数据源提供的数据,而无需要知道外部数据源的类型。

下文是两个基于骰子游戏的协议:

protocol DiceGame{var dice:Dice{get}
    func play()}
protocol DiceGameDelegate{
    func gameDidStart(game:DiceGame)
    func game(game:DiceGame, didStartNewTurnWithDiceRoll diceRoll:Int)
    func gameDidEnd(game:DiceGame)}

DiceGame协议可以在任意含有骰子的游戏中实现,DiceGameDelegate协议可以用来追踪DiceGame的游戏过程。

如下所示,SnakesAndLaddersSnakes and Ladders(译者注:控制流章节有该游戏的详细介绍)游戏的新版本。新版本使用Dice作为骰子,并且实现了DiceGameDiceGameDelegate协议

classSnakesAndLadders:DiceGame{
    let finalSquare =25
    let dic =Dice(sides:6, generator:LinearCongruentialGenerator())var square =0var board:Int[]
    init(){
        board =Int[](count: finalSquare +1, repeatedValue:0)
        board[03]=+08; board[06]=+11; borad[09]=+09; board[10]=+02
        borad[14]=-10; board[19]=-11; borad[22]=-02; board[24]=-08}vardelegate:DiceGameDelegate?
     func play(){
         square =0delegate?.gameDidStart(self)
         gameLoop:while square != finalSquare {
             let diceRoll = dice.roll()delegate?.game(self,didStartNewTurnWithDiceRoll: diceRoll)switch square + diceRoll {case finalSquare:break gameLoop
             case let newSquare where newSquare > finalSquare:continue gameLoop
             default:
             square += diceRoll
             square += board[square]}}delegate?.gameDIdEnd(self)}}

游戏的初始化设置(setup)SnakesAndLadders类的构造器(initializer)实现。所有的游戏逻辑被转移到了play方法中。

注意:

因为delegate并不是该游戏的必备条件,delegate被定义为遵循DiceGameDelegate协议的可选属性

DicegameDelegate协议提供了三个方法用来追踪游戏过程。被放置于游戏的逻辑中,即play()方法内。分别在游戏开始时,新一轮开始时,游戏结束时被调用。

因为delegate是一个遵循DiceGameDelegate的可选属性,因此在play()方法中使用了可选链来调用委托方法。 若delegate属性为nil, 则委托调用优雅地失效。若delegate不为nil,则委托方法被调用

如下所示,DiceGameTracker遵循了DiceGameDelegate协议

classDiceGameTracker:DiceGameDelegate{var numberOfTurns =0
    func gameDidStart(game:DiceGame){
        numberOfTurns =0if game isSnakesAndLadders{
            println("Started a new game of Snakes and Ladders")}
        println("The game is using a \(game.dice.sides)-sided dice")}
    func game(game:DiceGame, didStartNewTurnWithDiceRoll diceRoll:Int){++numberOfTurns
        println("Rolled a \(diceRoll)")}
    func gameDidEnd(game:DiceGame){
        println("The game lasted for \(numberOfTurns) turns")}}

DiceGameTracker实现了DiceGameDelegate协议的方法要求,用来记录游戏已经进行的轮数。 当游戏开始时,numberOfTurns属性被赋值为0;在每新一轮中递加;游戏结束后,输出打印游戏的总轮数。

gameDidStart方法从game参数获取游戏信息并输出。game在方法中被当做DiceGame类型而不是SnakeAndLadders类型,所以方法中只能访问DiceGame协议中的成员。

DiceGameTracker的运行情况,如下所示:

let tracker =DiceGameTracker()
let game =SnakesAndLadders()
game.delegate= tracker
game.play()// Started a new game of Snakes and Ladders// The game is using a 6-sided dice// Rolled a 3// Rolled a 5// Rolled a 4// Rolled a 5// The game lasted for 4 turns”

在扩展中添加协议成员

即便无法修改源代码,依然可以通过扩展(Extension)来扩充已存在类型(译者注: 类,结构体,枚举等)。扩展可以为已存在的类型添加属性方法下标协议等成员。详情请在扩展章节中查看。

注意:

通过扩展为已存在的类型遵循协议时,该类型的所有实例也会随之添加协议中的方法

TextRepresentable协议含有一个asText,如下所示:

protocol TextRepresentable{
    func asText()->String}

通过扩展为上一节中提到的Dice类遵循TextRepresentable协议

extension Dice:TextRepresentable{
    cun asText()->String{return"A \(sides)-sided dice"}}

从现在起,Dice类型的实例可被当作TextRepresentable类型:

let d12 =Dice(sides:12,generator:LinearCongruentialGenerator())
println(d12.asText())// 输出 "A 12-sided dice"

SnakesAndLadders类也可以通过扩展的方式来遵循协议:

extension SnakeAndLadders:TextRepresentable{
    func asText()->String{return"A game of Snakes and Ladders with \(finalSquare) squares"}}
println(game.asText())// 输出 "A game of Snakes and Ladders with 25 squares"

通过延展补充协议声明

当一个类型已经实现了协议中的所有要求,却没有声明时,可以通过扩展来补充协议声明:

structHamster{var name:String
    func asText()->String{return"A hamster named \(name)"}}
extension Hamster:TextRepresentabl{}

从现在起,Hamster的实例可以作为TextRepresentable类型使用

let simonTheHamster =Hamster(name:"Simon")
let somethingTextRepresentable:TextRepresentabl= simonTheHamester
println(somethingTextRepresentable.asText())// 输出 "A hamster named Simon"

注意:

即时满足了协议的所有要求,类型也不会自动转变,因此你必须为它做出明显的协议声明

集合中的协议类型

协议类型可以被集合使用,表示集合中的元素均为协议类型:

let things:TextRepresentable[]=[game,d12,simoTheHamster]

如下所示,things数组可以被直接遍历,并调用其中元素的asText()函数:

for thing in things {
    println(thing.asText())}// A game of Snakes and Ladders with 25 squares// A 12-sided dice// A hamster named Simon

thing被当做是TextRepresentable类型而不是DiceDiceGameHamster等类型。因此能且仅能调用asText方法

协议的继承

协议能够继承一到多个其他协议。语法与类的继承相似,多个协议间用逗号,分隔

protocol InheritingProtocol:SomeProtocol,AnotherProtocol{// 协议定义}

如下所示,PrettyTextRepresentable协议继承了TextRepresentable协议

protocol PrettyTextRepresentable:TextRepresentable{
    func asPrettyText()->String}

遵循``PrettyTextRepresentable协议的同时,也需要遵循TextRepresentable`协议。

如下所示,用扩展SnakesAndLadders遵循PrettyTextRepresentable协议:

extension SnakesAndLadders:PrettyTextRepresentable{
    func asPrettyText()->String{var output = asText()+":\n"for index in1...finalSquare {switch board[index]{case let ladder where ladder >0:
                output +="▲ "case let snake where snake <0:
                output +="▼ "default:
                output +="○ "}}return output
    }}

for in中迭代出了board数组中的每一个元素:

  • 当从数组中迭代出的元素的值大于0时,用表示
  • 当从数组中迭代出的元素的值小于0时,用表示
  • 当从数组中迭代出的元素的值等于0时,用表示

任意SankesAndLadders的实例都可以使用asPrettyText()方法。

println(game.asPrettyText())// A game of Snakes and Ladders with 25 squares:// ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○

协议合成

一个协议可由多个协议采用protocol<SomeProtocol, AnotherProtocol>这样的格式进行组合,称为协议合成(protocol composition)

举个例子:

protocol Named{var name:String{get}}
protocol Aged{var age:Int{get}}structPerson:Named,Aged{var name:Stringvar age:Int}
func wishHappyBirthday(celebrator: protocol<Named,Aged>){
    println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")}
let birthdayPerson =Person(name:"Malcolm", age:21)
wishHappyBirthday(birthdayPerson)// 输出 "Happy birthday Malcolm - you're 21!

Named协议包含String类型的name属性;Aged协议包含Int类型的age属性。Person结构体遵循了这两个协议。

wishHappyBirthday函数的形参celebrator的类型为protocol<Named,Aged>。可以传入任意遵循这两个协议的类型的实例

注意:

协议合成并不会生成一个新协议类型,而是将多个协议合成为一个临时的协议,超出范围后立即失效。

检验协议的一致性

使用is检验协议一致性,使用as将协议类型向下转换(downcast)为的其他协议类型。检验与转换的语法和之前相同(详情查看类型检查):

  • is操作符用来检查实例是否遵循了某个协议
  • as?返回一个可选值,当实例遵循协议时,返回该协议类型;否则返回nil
  • as用以强制向下转换型。
@objc protocol HasArea{var area:Double{get}}

注意:

@objc用来表示协议是可选的,也可以用来表示暴露给Objective-C的代码,此外,@objc型协议只对有效,因此只能在中检查协议的一致性。详情查看Using Siwft with Cocoa and Objectivei-c

classCircle:HasArea{
    let pi =3.1415927var radius:Doublevar area:≈radius }
    init(radius:Double){self.radius = radius }}classCountry:HasArea{var area:Double
    init(area:Double){self.area = area }}

CircleCountry都遵循了HasArea协议,前者把area写为计算型属性(computed property),后者则把area写为存储型属性(stored property)。

如下所示,Animal类没有实现任何协议

classAnimal{var legs:Int
    init(legs:Int){self.legs = legs }}

Circle,Country,Animal并没有一个相同的基类,所以采用AnyObject类型的数组来装载在他们的实例,如下所示:

let objects:AnyObject[]=[Circle(radius:2.0),Country(area:243_610),Animal(legs:4)]

如下所示,在迭代时检查object数组的元素是否遵循HasArea协议:

forobjectin objects {if let objectWithArea =objectas?HasArea{
        println("Area is \(objectWithArea.area)")}else{
        println("Something that doesn't have an area")}}// Area is 12.5663708// Area is 243610.0// Something that doesn't have an area

当数组中的元素遵循HasArea协议时,通过as?操作符将其可选绑定(optional binding)objectWithArea常量上。

objects数组中元素的类型并不会因为向下转型而改变,当它们被赋值给objectWithArea时只被视为HasArea类型,因此只有area属性能够被访问。

可选协议要求

可选协议含有可选成员,其遵循者可以选择是否实现这些成员。在协议中使用@optional关键字作为前缀来定义可选成员。

可选协议在调用时使用可选链,详细内容在可选链章节中查看。

someOptionalMethod?(someArgument)一样,你可以在可选方法名称后加上?来检查该方法是否被实现。可选方法可选属性都会返回一个可选值(optional value),当其不可访问时,?之后语句不会执行,并返回nil

注意:

可选协议只能在含有@objc前缀的协议中生效。且@objc的协议只能被遵循。

Counter类使用CounterDataSource类型的外部数据源来提供增量值(increment amount),如下所示:

@objc protocol CounterDataSource{@optional func incrementForCount(count:Int)->Int@optionalvar fixedIncrement:Int{get}}

CounterDataSource含有incrementForCount可选方法fiexdIncrement可选属性

注意:

CounterDataSource中的属性和方法都是可选的,因此可以在类中声明但不实现这些成员,尽管技术上允许这样做,不过最好不要这样写。

Counter类含有CounterDataSource?类型的可选属性dataSource,如下所示:

@objcclassCounter{var count =0var dataSource:CounterDataSource?
    func increment(){if let amount = dataSource?.incrementForCount?(count){
            count += amount
        }elseif let amount = dataSource?.fixedIncrement?{
            count += amount
        }}}

count属性用于存储当前的值,increment方法用来为count赋值。

increment方法通过可选链,尝试从两种可选成员中获取count

  1. 由于dataSource可能为nil,因此在dataSource后边加上了?标记来表明只在dataSource非空时才去调用incrementForCount`方法。
  2. 即使dataSource存在,但是也无法保证其是否实现了incrementForCount方法,因此在incrementForCount方法后边也加有?标记。

在调用incrementForCount方法后,Int可选值通过可选绑定(optional binding)自动拆包并赋值给常量amount

incrementForCount不能被调用时,尝试使用可选属性``fixedIncrement来代替。

ThreeSource实现了CounterDataSource协议,如下所示:

classThreeSource:CounterDataSource{
    let fixedIncrement =3}

使用ThreeSource作为数据源开实例化一个Counter

var counter =Counter()
counter.dataSource =ThreeSource()for _ in1...4{
    counter.increment()
    println(counter.count)}// 3// 6// 9// 12

TowardsZeroSource实现了CounterDataSource协议中的incrementForCount方法,如下所示:

classTowardsZeroSource:CounterDataSource{
func incrementForCount(count:Int)->Int{if count ==0{return0}elseif count <0{return1}else{return-1}}}

下边是执行的代码:

counter.count =-4
counter.dataSource =TowardsZeroSource()for _ in1...5{
    counter.increment()
    println(counter.count)}// -3// -2// -1// 0// 0

本文部分原文来自于http://www.swiftguide.cn/翻译小组的译文,共同校对中。

感谢翻译小组成员:李起攀(微博)、若晨(微博)、YAO、粽子、山有木兮木有枝、渺-Bessie、墨离、矮人王、CXH、Tiger大顾(微博)
个人转载请注明出处和原始链接http://letsswift.com/2014/06/protocols/,商业转载请联系我们~ 感谢您对我们工作的支持~

Swift中文教程(20)扩展

转载自letsswift.com

扩展就是向一个已有的类、结构体或枚举类型添加新功能(functionality)。这包括在没有权限获取原始源代码的情况下扩展类型的能力(即逆向建模)。扩展和 Objective-C 中的分类(categories)类似。(不过与Objective-C不同的是,Swift 的扩展没有名字。)

Swift 中的扩展可以:

  • 添加计算型属性和计算静态属性
  • 定义实例方法和类型方法
  • 提供新的构造器
  • 定义下标
  • 定义和使用新的嵌套类型
  • 使一个已有类型符合某个接口

注意:

如果你定义了一个扩展向一个已有类型添加新功能,那么这个新功能对该类型的所有已有实例中都是可用的,即使它们是在你的这个扩展的前面定义的。

扩展语法(Extension Syntax)

声明一个扩展使用关键字extension

extension SomeType{// 加到SomeType的新功能写到这里}

一个扩展可以扩展一个已有类型,使其能够适配一个或多个协议(protocol)。当这种情况发生时,接口的名字应该完全按照类或结构体的名字的方式进行书写:

extension SomeType:SomeProtocol,AnotherProctocol{// 协议实现写到这里}

按照这种方式添加的协议遵循者(protocol conformance)被称之为在扩展中添加协议遵循者

计算型属性(Computed Properties)

扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建Double类型添加了5个计算型实例属性,从而提供与距离单位协作的基本支持。

extension Double{var km:Double{returnself*1_000.0}var m :Double{returnself}var cm:Double{returnself/100.0}var mm:Double{returnself/1_000.0}var ft:Double{returnself/3.28084}}
let oneInch =25.4.mm
println("One inch is \(oneInch) meters")// 打印输出:"One inch is 0.0254 meters"
let threeFeet =3.ft
println("Three feet is \(threeFeet) meters")// 打印输出:"Three feet is 0.914399970739201 meters"

这些计算属性表达的含义是把一个Double型的值看作是某单位下的长度值。即使它们被实现为计算型属性,但这些属性仍可以接一个带有dot语法的浮点型字面值,而这恰恰是使用这些浮点型字面量实现距离转换的方式。

在上述例子中,一个Double型的值1.0被用来表示“1米”。这就是为什么m计算型属性返回self——表达式1.m被认为是计算1.0Double值。

其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米,所以km计算型属性要把值乘以1_000.00来转化成单位米下的数值。类似地,1米有3.28024英尺,所以ft计算型属性要把对应的Double值除以3.28024来实现英尺到米的单位换算。

这些属性是只读的计算型属性,所有从简考虑它们不用get关键字表示。它们的返回值是Double型,而且可以用于所有接受Double的数学计算中:

let aMarathon =42.km+195.m
println("A marathon is \(aMarathon) meters long")// 打印输出:"A marathon is 42495.0 meters long"

注意:

扩展可以添加新的计算属性,但是不可以添加存储属性,也不可以向已有属性添加属性观测器(property observers)。

构造器(Initializers)

扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型,将你自己的定制类型作为构造器参数,或者提供该类型的原始实现中没有包含的额外初始化选项。

注意:

如果你使用扩展向一个值类型添加一个构造器,该构造器向所有的存储属性提供默认值,而且没有定义任何定制构造器(custom initializers),那么对于来自你的扩展构造器中的值类型,你可以调用默认构造器(default initializers)和成员级构造器(memberwise initializers)。 正如在值类型的构造器授权中描述的,如果你已经把构造器写成值类型原始实现的一部分,上述规则不再适用。

下面的例子定义了一个用于描述几何矩形的定制结构体Rect。这个例子同时定义了两个辅助结构体SizePoint,它们都把0.0作为所有属性的默认值:

structSize{var width =0.0, height =0.0}structPoint{var x =0.0, y =0.0}structRect{var origin =Point()var size =Size()}

因为结构体Rect提供了其所有属性的默认值,所以正如默认构造器中描述的,它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的Rect实例:

let defaultRect =Rect()
let memberwiseRect =Rect(origin:Point(x:2.0, y:2.0),
    size:Size(width:5.0, height:5.0))

你可以提供一个额外的使用特殊中心点和大小的构造器来扩展Rect结构体:

extension Rect{
    init(center:Point, size:Size){
        let originX = center.x -(size.width /2)
        let originY = center.y -(size.height /2)self.init(origin:Point(x: originX, y: originY), size: size)}}

这个新的构造器首先根据提供的centersize值计算一个合适的原点。然后调用该结构体自动的成员构造器init(origin:size:),该构造器将新的原点和大小存到了合适的属性中:

let centerRect =Rect(center:Point(x:4.0, y:4.0),
    size:Size(width:3.0, height:3.0))// centerRect的原点是 (2.5, 2.5),大小是 (3.0, 3.0)

注意:

如果你使用扩展提供了一个新的构造器,你依旧有责任保证构造过程能够让所有实例完全初始化。

方法(Methods)

扩展可以向已有类型添加新的实例方法和类型方法。下面的例子向Int类型添加一个名为repetitions的新实例方法:

extension Int{
    func repetitions(task:()->()){for i in0..self{
            task()}}}

这个repetitions方法使用了一个() -> ()类型的单参数(single argument),表明函数没有参数而且没有返回值。

定义该扩展之后,你就可以对任意整数调用repetitions方法,实现的功能则是多次执行某任务:

3.repetitions({
    println("Hello!")})// Hello!// Hello!// Hello!

可以使用 trailing 闭包使调用更加简洁:

3.repetitions{
    println("Goodbye!")}// Goodbye!// Goodbye!// Goodbye!

修改实例方法(Mutating Instance Methods)

通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改self或其属性的方法必须将该实例方法标注为mutating,正如来自原始实现的修改方法一样。

下面的例子向Swift的Int类型添加了一个新的名为square的修改方法,来实现一个原始值的平方计算:

extension Int{
    mutating func square(){self=self*self}}var someInt =3
someInt.square()// someInt 现在值是 9

下标(Subscripts)

扩展可以向一个已有类型添加新下标。这个例子向Swift内建类型Int添加了一个整型下标。该下标[n]返回十进制数字从右向左数的第n个数字

  • 123456789[0]返回9
  • 123456789[1]返回8

…等等

extension Int{
    subscript(digitIndex:Int)->Int{var decimalBase =1for _ in1...digitIndex {
                decimalBase *=10}return(self/ decimalBase)%10}}746381295[0]// returns 5746381295[1]// returns 9746381295[2]// returns 2746381295[8]// returns 7

如果该Int值没有足够的位数,即下标越界,那么上述实现的下标会返回0,因为它会在数字左边自动补0:

746381295[9]//returns 0, 即等同于:0746381295[9]

嵌套类型(Nested Types)

扩展可以向已有的类、结构体和枚举添加新的嵌套类型:

extension Character{enumKind{caseVowel,Consonant,Other}var kind:Kind{switchString(self).lowercaseString {case"a","e","i","o","u":return.Vowelcase"b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","y","z":return.Consonantdefault:return.Other}}}

该例子向Character添加了新的嵌套枚举。这个名为Kind的枚举表示特定字符的类型。具体来说,就是表示一个标准的拉丁脚本中的字符是元音还是辅音(不考虑口语和地方变种),或者是其它类型。

这个类子还向Character添加了一个新的计算实例属性,即kind,用来返回合适的Kind枚举成员。

现在,这个嵌套枚举可以和一个Character值联合使用了:

func printLetterKinds(word:String){
    println("'\\(word)' is made up of the following kinds of letters:")for character in word {switch character.kind {case.Vowel:print("vowel ")case.Consonant:print("consonant ")case.Other:print("other ")}}print("\n")}
printLetterKinds("Hello")// 'Hello' is made up of the following kinds of letters:// consonant vowel consonant consonant vowel

函数printLetterKinds的输入是一个String值并对其字符进行迭代。在每次迭代过程中,考虑当前字符的kind计算属性,并打印出合适的类别描述。所以printLetterKinds就可以用来打印一个完整单词中所有字母的类型,正如上述单词"hello"所展示的。

注意:

由于已知character.kindCharacter.Kind型,所以Character.Kind中的所有成员值都可以使用switch语句里的形式简写,比如使用 .Vowel代替Character.Kind.Vowel

本文部分原文来自于http://www.swiftguide.cn/翻译小组的译文,共同校对中。

感谢翻译小组成员:李起攀(微博)、若晨(微博)、YAO、粽子、山有木兮木有枝、渺-Bessie、墨离、矮人王、CXH、Tiger大顾(微博)
个人转载请注明出处和原始链接http://letsswift.com/2014/06/extensions/ ‎,商业转载请联系我们~ 感谢您对我们工作的支持~

Swift中文教程(19)类型嵌套

转载自letsswift.com

枚举类型常被用于实现特定类或结构体的功能。也能够在有多种变量类型的环境中,方便地定义通用类或结构体来使用,为了实现这种功能,Swift允许你定义类型嵌套,可以在枚举类型、类和结构体中定义支持嵌套的类型。

要在一个类型中嵌套另一个类型,将需要嵌套的类型的定义写在被嵌套类型的区域{}内,而且可以根据需要定义多级嵌套。

类型嵌套实例

下面这个例子定义了一个结构体BlackjackCard(二十一点),用来模拟BlackjackCard中的扑克牌点数。BlackjackCard结构体包含2个嵌套定义的枚举类型Suit 和 Rank

BlackjackCard规则中,Ace牌可以表示1或者11,Ace牌的这一特征用一个嵌套在枚举型Rank的结构体Values来表示。

structBlackjackCard{// 嵌套定义枚举型SuitenumSuit:Character{caseSpades="♠",Hearts="♡",Diamonds="♢",Clubs="♣"}// 嵌套定义枚举型RankenumRank:Int{caseTwo=2,Three,Four,Five,Six,Seven,Eight,Nine,TencaseJack,Queen,King,AcestructValues{
           let first:Int, second:Int?}var values:Values{switchself{case.Ace:returnValues(first:1, second:11)case.Jack,.Queen,.King:returnValues(first:10, second:nil)default:returnValues(first:self.toRaw(), second:nil)}}}// BlackjackCard 的属性和方法
    let rank:Rank, suit:Suitvar description:String{var output ="suit is \(suit.toRaw()),"
        output +=" value is \(rank.values.first)"if let second = rank.values.second {
            output +=" or \(second)"}return output
    }}

枚举型的Suit用来描述扑克牌的四种花色,并分别用一个Character类型的值代表花色符号。

枚举型的Rank用来描述扑克牌从Ace~10,J,Q,K,13张牌,并分别用一个Int类型的值表示牌的面值。(这个Int类型的值不适用于Ace,J,Q,K的牌)。

如上文所提到的,枚举型Rank在自己内部定义了一个嵌套结构体Values。这个结构体包含两个变量,只有Ace有两个数值,其余牌都只有一个数值。结构体Values中定义的两个属性:

first, 为Int second, 为 Int?, 或 “optional Int

Rank定义了一个计算属性values,这个计算属性会根据牌的面值,用适当的数值去初始化Values实例,并赋值给values。对于J,Q,K,Ace会使用特殊数值,对于数字面值的牌使用Int类型的值。

BlackjackCard结构体自身有两个属性—ranksuit,也同样定义了一个计算属性descriptiondescription属性用ranksuit的中内容来构建对这张扑克牌名字和数值的描述,并用可选类型second来检查是否存在第二个值,若存在,则在原有的描述中增加对第二数值的描述。

因为BlackjackCard是一个没有自定义构造函数的结构体,在Memberwise Initializers for Structure Types中知道结构体有默认的成员构造函数,所以你可以用默认的initializer去初始化新的常量theAceOfSpades:

let theAceOfSpades =BlackjackCard(rank:.Ace, suit:.Spades)
println("theAceOfSpades: \(theAceOfSpades.description)")// 打印出 "theAceOfSpades: suit is ♠, value is 1 or 11"

尽管RankSuit嵌套在BlackjackCard中,但仍可被引用,所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中description属性能正确得输出对Ace牌有1和11两个值。

类型嵌套的引用

在外部对嵌套类型的引用,以被嵌套类型的名字为前缀,加上所要引用的属性名:

let heartsSymbol =BlackjackCard.Suit.Hearts.toRaw()// 红心的符号 为 "♡"

对于上面这个例子,这样可以使SuitRank, 和 Values的名字尽可能的短,因为它们的名字会自然的由被定义的上下文来限定。

本文部分原文来自于http://www.swiftguide.cn/翻译小组的译文,共同校对中。

感谢翻译小组成员:李起攀(微博)、若晨(微博)、YAO、粽子、山有木兮木有枝、渺-Bessie、墨离、矮人王、CXH、Tiger大顾(微博)
个人转载请注明出处和原始链接http://letsswift.com/2014/06/nested-types/,商业转载请联系我们~ 感谢您对我们工作的支持~

Swift中文教程(18)类型检查

转载自letsswift.com

类型检查是一种检查类实例的方式,并且或者也是让实例作为它的父类或者子类的一种方式。

类型检查在 Swift 中使用is 和 as操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。

你也可以用来检查一个类是否实现了某个协议,就像在 Protocols Checking for Protocol Conformance部分讲述的一样。

定义一个类层次作为例子

你可以将它用在类和子类的层次结构上,检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组,作为类型检查的例子。

第一个代码片段定义了一个新的基础类MediaItem。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的,它声明了一个 String 类型的 name 属性,和一个init name初始化器。(它假定所有的媒体项都有个名称。)

classMediaItem{var name:String
    init(name:String){self.name = name
    }}

下一个代码段定义了 MediaItem 的两个子类。第一个子类Movie,在父类(或者说基类)的基础上增加了一个director(导演) 属性,和相应的初始化器。第二个类在父类的基础上增加了一个artist(艺术家) 属性,和相应的初始化器:

classSong:MediaItem{var artist:String
    init(name:String, artist:String){self.artist = artist
        super.init(name: name)}}

最后一个代码段创建了一个数组常量 library ,包含两个Movie实例和三个Song实例。library的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出Movie和 Song 有共同的父类 MediaItem,所以它推断出 MediaItem[] 类作为 library 的类型。

let library =[Movie(name:"Casablanca", director:"Michael Curtiz"),Song(name:"Blue Suede Shoes", artist:"Elvis Presley"),Movie(name:"Citizen Kane", director:"Orson Welles"),Song(name:"The One And Only", artist:"Chesney Hawkes"),Song(name:"Never Gonna Give You Up", artist:"Rick Astley")]// the type of "library" is inferred to be MediaItem[]

在幕后library 里存储的媒体项依然是 Movie 和 Song 类型的,但是,若你迭代它,取出的实例会是 MediaItem 类型的,而不是 Movie 和 Song 类型的。为了让它们作为它们本来的类型工作,你需要检查它们的类型或者向下转换它们的类型到其它类型,就像下面描述的一样。

检查类型

用类型检查操作符(is)来检查一个实例是否属于特定子类型。类型检查操作符返回 true 若实例属于那个子类型,若不属于返回 false 。

下面的例子定义了两个变量,movieCount 和 songCount,用来计算数组library 中 Movie 和 Song 类型的实例数量。

var movieCount =0var songCount =0for item in library {if item isMovie{++movieCount
    }elseif item isSong{++songCount
    }}

println("Media library contains \(movieCount) movies and \(songCount) songs")// prints "Media library contains 2 movies and 3 songs"

示例迭代了数组 library 中的所有项。每一次, forin 循环设置 item 为数组中的下一个MediaItem

若当前 MediaItem 是一个 Movie 类型的实例, item is Movie 返回 true,相反返回 false。同样的,item is Song检查item是否为Song类型的实例。在循环结束后,movieCount 和 songCount的值就是被找到属于各自的类型的实例数量。

向下转型(Downcasting)

某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信,上面就是这种情况。你可以尝试向下转到它的子类型,用类型检查操作符(as)

因为向下转型可能会失败,类型检查操作符带有两种不同形式。可选形式( optional form) as?返回一个你试图下转成的类型的可选值(optional value)。强制形式 as 把试图向下转型和强制解包(force-unwraps)结果作为一个混合动作。

当你不确定下转可以成功时,用类型检查的可选形式(as?)。可选形式的类型检查总是返回一个可选值(optional value),并且若下转是不可能的,可选值将是 nil 。这使你能够检查下转是否成功。

只有你可以确定下转一定会成功时,才使用强制形式。当你试图下转为一个不正确的类型时,强制形式的类型检查会触发一个运行时错误。

下面的例子,迭代了library里的每一个 MediaItem ,并打印出适当的描述。要这样做,item需要真正作为Movie或 Song的类型来使用。不仅仅是作为 MediaItem。为了能够使用Movie 或 Songdirector 或 artist属性,这是必要的。

在这个示例中,数组中的每一个item可能是 Movie 或 Song。 事前你不知道每个item的真实类型,所以这里使用可选形式的类型检查 (as?)去检查循环里的每次下转。

for item in library {if let movie = item as?Movie{
        println("Movie: '\(movie.name)', dir. \(movie.director)")}elseif let song = item as?Song{
        println("Song: '\(song.name)', by \(song.artist)")}}// Movie: 'Casablanca', dir. Michael Curtiz// Song: 'Blue Suede Shoes', by Elvis Presley// Movie: 'Citizen Kane', dir. Orson Welles// Song: 'The One And Only', by Chesney Hawkes// Song: 'Never Gonna Give You Up', by Rick Astley

示例首先试图将 item 下转为 Movie。因为 item 是一个 MediaItem 类型的实例,它可能是一个Movie;同样,它可能是一个 Song,或者仅仅是基类 MediaItem。因为不确定,as?形式在试图下转时将返还一个可选值。item as Movie 的返回值是Movie?类型或 “optional Movie”。

当下转为 Movie 应用在两个 Song 实例时将会失败。为了处理这种情况,上面的例子使用了可选绑定(optional binding)来检查可选 Movie真的包含一个值(这个是为了判断下转是否成功。)可选绑定是这样写的“if let movie = item as? Movie”,可以这样解读:

“尝试将 item 转为 Movie类型。若成功,设置一个新的临时常量 movie 来存储返回的可选Movie

若下转成功,然后movie的属性将用于打印一个Movie实例的描述,包括它的导演的名字director。当Song被找到时,一个相近的原理被用来检测 Song 实例和打印它的描述。

注意:

转换没有真的改变实例或它的值。潜在的根本的实例保持不变;只是简单地把它作为它被转换成的类来使用。

AnyAnyObject的类型检查

Swift为不确定类型提供了两种特殊类型别名:

  • AnyObject可以代表任何class类型的实例。
  • Any可以表示任何类型,除了方法类型(function types)。

注意:

只有当你明确的需要它的行为和功能时才使用AnyAnyObject。在你的代码里使用你期望的明确的类型总是更好的。

AnyObject类型

当需要在工作中使用 Cocoa APIs,它一般接收一个AnyObject[]类型的数组,或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是,你常常可以确定包含在仅从你知道的 API 信息提供的这样一个数组中的对象的类型。

在这些情况下,你可以使用强制形式的类型检查(as)来下转在数组中的每一项到比 AnyObject 更明确的类型,不需要可选解析(optional unwrapping)。

下面的示例定义了一个 AnyObject[] 类型的数组并填入三个Movie类型的实例:

let someObjects:AnyObject[]=[Movie(name:"2001: A Space Odyssey", director:"Stanley Kubrick"),Movie(name:"Moon", director:"Duncan Jones"),Movie(name:"Alien", director:"Ridley Scott")]

因为知道这个数组只包含 Movie 实例,你可以直接用(as)下转并解包到不可选的Movie类型(ps:其实就是我们常用的正常类型,这里是为了和可选类型相对比)。

forobjectin someObjects {
    let movie =objectasMovie
    println("Movie: '\(movie.name)', dir. \(movie.director)")}// Movie: '2001: A Space Odyssey', dir. Stanley Kubrick// Movie: 'Moon', dir. Duncan Jones// Movie: 'Alien', dir. Ridley Scott

为了变为一个更短的形式,下转someObjects数组为Movie[]类型来代替下转每一项方式。

for movie in someObjects asMovie[]{
    println("Movie: '\(movie.name)', dir. \(movie.director)")}// Movie: '2001: A Space Odyssey', dir. Stanley Kubrick// Movie: 'Moon', dir. Duncan Jones// Movie: 'Alien', dir. Ridley Scott
Any类型

这里有个示例,使用 Any 类型来和混合的不同类型一起工作,包括非class类型。它创建了一个可以存储Any类型的数组 things

var things =Any[]()

things.append(0)
things.append(0.0)
things.append(42)
things.append(3.14159)
things.append("hello")
things.append((3.0,5.0))
things.append(Movie(name:"Ghostbusters", director:"Ivan Reitman"))

things 数组包含两个 Int 值,2个 Double 值,1个 String 值,一个元组 (Double, Double) ,Ivan Reitman 导演的电影“Ghostbusters”。

你可以在 switch cases里用is 和 as 操作符来发觉只知道是 Any 或 AnyObject的常量或变量的类型。 下面的示例迭代 things数组中的每一项的并用switch语句查找每一项的类型。这几种switch语句的情形绑定它们匹配的值到一个规定类型的常量,让它们可以打印它们的值:

for thing in things {switch thing {case0asInt:
        println("zero as an Int")case0asDouble:
        println("zero as a Double")case let someInt asInt:
        println("an integer value of \(someInt)")case let someDouble asDoublewhere someDouble >0:
        println("a positive double value of \(someDouble)")caseisDouble:
        println("some other double value that I don't want to print")case let someString asString:
        println("a string value of \"\(someString)\"")case let (x, y)as(Double,Double):
        println("an (x, y) point at \(x), \(y)")case let movie asMovie:
        println("a movie called '\(movie.name)', dir. \(movie.director)")default:
        println("something else")}}// zero as an Int// zero as a Double// an integer value of 42// a positive double value of 3.14159// a string value of "hello"// an (x, y) point at 3.0, 5.0// a movie called 'Ghostbusters', dir. Ivan Reitman

本文部分原文来自于http://www.swiftguide.cn/翻译小组的译文,共同校对中。

感谢翻译小组成员:李起攀(微博)、若晨(微博)、YAO、粽子、山有木兮木有枝、渺-Bessie、墨离、矮人王、CXH、Tiger大顾(微博)
个人转载请注明出处和原始链接http://letsswift.com/2014/06/type-casting/ ,商业转载请联系我们~ 感谢您对我们工作的支持~