方法

Objective-C中的方法有两种:

实例方法

-开头的方法是实例方法。它属于类的某一个或某几个实例对象,即类对象必须实例化后才可以使用的方法,将消息发送给实例对象:

// Deck.h

#import <Foundation/Foundation.h>
#import "Card.h"

@interface Deck : NSObject

@property(nonatomic) int cardNum;

// 实例方法
- (Card *)randomDrawCard;

+ (NSString *)CardKinds;

@end

实例方法中可以使用该类的所有实例变量:

// Deck.m

#import "Card.h"

@implementation Deck

- (Card *)drawCardFromTop
{
    // 实例变量
    _cardNum--;

    //TODO.....
}

+ (NSString *)CardKinds
{
    NSLog("Cards are divided into four kinds: spades, diamonds, clubs and hearts");
}

@end 

类方法

+开头的方法是类方法。Objc中的类方法类似Java中的static静态方法,它是属于类本身的方法,不属于类的某一个实例对象,所以不需要实例化类,用类名即可使用,是将消息发送给类:

// Deck.h

#import <Foundation/Foundation.h>
#import "Card.h"

@interface Deck : NSObject

- (Card *)randomDrawCard;

// 类方法
+ (NSString *)CardKinds;

@end    

类方法不能使用任何实例变量:

// Deck.m

#import "Card.h"

@implementation Deck

- (Card *)drawCardFromTop
{
    // 实例变量
    _cardNum--;

    //TODO.....
}

// 不能使用该类的实例变量_carNum
+ (NSString *)CardKinds
{
    NSLog("Cards are divided into four kinds: spades, diamonds, clubs and hearts");
}

@end 

所以我们使用类方法一般有两种情况:

  • 创建一些事物,比如特殊格式的字符串等。
  • 作为工具方法,比如返回常数等。

类方法和实例方法认知的误区

  • 类方法常驻内存,所以比实例方法效率高。
    事实上,在加载时机和占用内存上,类方法和实例方法是一样的,在类第一次被使用时加载方法,所以在效率上没有什么区别。

  • 类方法分配在堆上,实例方法分配在栈上。
    事实上,所有的方法都不可能分配在堆栈区,方法作为二进制代码是存储在内存的程序代码区,这个内存区域是不可写的。请查看我这篇笔记中的相关概念Objective-C中的Block

总结

实例方法和类方法有大多数的共性,比如都可以有一个或多个参数、都可以继承基类的方法、相同的声明规范等。唯一不同的就是类方法不能使用实例变量,所以导致它只适用于一些特殊的情况。

Category

如果我们想给一个已存在的、很复杂的类添加一个新的方法,应该怎么做?
想翻源码添加?骚年,你太天真,你如果看不到源码呢。即便我们可以看到源码,如果我们新增的逻辑也很复杂,这样就会扩大原始设计的规模,有可能会打乱整个设计的结构。
Category就是Objective-C提供的为我们解决这一问题的方法。它可以让我们动态的在已经存在的类中添加新的行为,即方法。对类进行扩展时不需要访问其源码,也不需要创建子类。

使用方法

Category的实现很简单,我们举例说明。

// Deck.h

#import <Foundation/Foundation.h>
#import "Card.h"

@interface Deck : NSObject

- (Card *)randomDrawCard;

@end

这是类Deck的声明文件,其中包含一个实例方法randomDrawCard,如果我们想在不修改原始类、不增加子类的情况下,为该类增加一个drawCardFromTop方法,只需要定义两个文件Deck+DrawCardFromTop.hDeck+DrawCardFromTop.m,在声明文件和实现文件中用()把Category的名称括起来即可,声明文件如下:

// Deck+DrawCardFromTop.h

#import "Deck.h"
#import "Card.h"

@interface Deck(DrawCardFromTop)

- (Card *)drawCardFromTop;

@end

实现文件如下:

// Deck+DrawCardFromTop.m

#import "Deck+DrawCardFromTop.h"
#import "Card.h"

@implementation Deck(DrawCardFromTop)

- (Card *)drawCardFromTop
{
    //TODO.....
}

@end

DrawCardFromTop是Category的名称。这里一般使用约定俗成的习惯,将声明文件和实现文件统一采用”原类名+Category名”的方式命名。
使用也非常简单,引入Category的声明文件,然后正常调用即可:

// main.m

#import "Deck+DrawCardFromTop.h"
#import "Card.h"

int main(int argc, char * argv[])
{

    Deck *deck = [[Deck alloc] init];
    Card *card = [deck drawCardFromTop];

    return 0;

}

使用场景

  • 需求变更在整个开发周期是司空见惯的事情,那么我们可能就需要对某个或某几个类中添加新的方法以满足需求。
  • 我们在团队协作开发时候,经常需要多个人来实现一个类中的不同方法,在这种情况下采用Category是一个较好的选择。
  • 当一些基础类库满足不了我们的需求时,我们希望能扩展基础类库,这时就需要Category。

需要注意的问题

  • Category可以访问原始类的实例变量,但不能添加变量,如果想添加变量,可以考虑通过继承创建子类。
  • Category可以重载原始类的方法,但不推荐这么做,这么做的后果是你再也不能访问原来的方法。如果确实要重载,正确的选择是创建子类。
  • 和普通接口有所区别的是,在分类的实现文件中可以不必实现所有声明的方法,只要你不去调用它。

总结

掌握并用好Category可以充分利用Objective-C的动态特性,编写出灵活简洁的代码。

Protocol

简单来说,Protocol不属于任何一个类,它只是一个方法列表,任何类都可以对其中声明的方法进行实现。这种设计模式一般称为代理模式(delegation)。你可以通过Protocol定义各种行为,在不同的场景采用不同的实现方式。在iOS和OS X开发中,Apple采用了大量的代理模式来实现MVC中View和Controller的解耦。

使用方法

Protocol有两种声明的方式:

  • 在单独的声明文件(.h文件)中声明。
  • 在某个类的声明的文件中声明。

以上两种方式视具体情况而定,但是在代码规范上都是一致的:

// HandleDeckDelegate.h

@protocol HandleDeckDelegate <NSObject>

@required
- (void)ShuffleDeck;

@optional
- (void)CuttingDeck;

@end

上述代码中有两个关键字,@required@optional,表示如果要实现这个协议,那么ShuffleDeck方法是必须要实现的,CuttingDeck则是可选的,如果不注明,那么方法默认是@required的,必须实现。

那么如何实现这个Protocol呢,很简单,创建一个普通的Objective-C类,如果Protocol使用单独的.h文件声明,那么在该类的.h声明文件中引入包含Protocol的.h文件,如果Protocol是声明在一个相关类中,那么就需要引入该类的.h文件。之后声明采用这个Protocol即可:

// Deck.h

#import <Foundation/Foundation.h>
#import "Card.h"
#import "HandleDeckDelegate.h"

@interface Deck : NSObject<HandleDeckDelegate>

- (Card *)randomDrawCard;

@end

用尖括号(\<…>)括起来的HandleDeckDelegate就是我们创建的Protocol。如果要采用多个Protocol,可以在尖括号内引入多个Protocol名称,并用逗号隔开即可。例如<HandleDeckDelegate,xxxDelegate>

// Deck.m

#import "Card.h"

@implementation Deck

- (Card *)drawCardFromTop
{
    //TODO.....
}

- (void)ShuffleDeck
{
    //TODO.....
}

@end

由于CuttingDeck方法是可选的,所以我们只实现了ShuffleDeck

使用场景

  • Objective-C里的Protocol和Java语言中的接口很类似,如果一些类之间没有继承关系,但是又具备某些相同的行为,则可以使用Protocol来描述它们的关系。
  • 不同的类,可以遵守同一个Protocol,在不同的场景下注入不同的实例,实现不同的功能。

需要注意的问题

  • 根据约定,框架中后缀为Delegate的都是Protocol,例如UIApplicationDelegateUIWebViewDelegate等。
  • Protocol本身是可以继承的,比如:
@protocol A
    -(void)methodA;
@end

@protocol B <A>
    -(void)methodB;
@end

如果你要实现B,那么methodA和methodB都需要实现。

  • Protocol是与任何类都无关的,任何类都可以实现定义好的Protocol,如果我们想知道某个类是否实现了某个Protocol,那么我们可以用conformsToProtocol方法进行判断:
[obj conformsToProtocol:@protocol(ProcessDataDelegate)]

总结

Protocol最常用的就是委托代理模式,Cocoa框架中大量采用了这种模式实现数据和UI的分离。例如UIView产生的所有事件,都是通过委托的方式交给Controller完成。

\

@property是什么

@Property是声明属性的语法,它可以快速方便的为实例变量创建存取器,并允许我们通过点语法使用存取器。

存取器(accessor):指用于获取和设置实例变量的方法。用于获取实例变量值的存取器是getter,用于设置实例变量值的存取器是setter

创建存取器

手工创建存取器

我们先看两段代码:

// Car.h

#import <Foundation/Foundation.h>

@interface Car : NSObject
{
    // 实例变量
    NSString *carName;
    NSString *carType;
}

// setter                                   
- (void)setCarName:(NSString *)newCarName; 

// getter
- (NSString *)carName;

// setter
- (void)setCarType:(NSString *)newCarType;

// getter
- (NSString *)carType;

@end  

上面的代码中carNamecarType就是Car的实例变量,并且可以看到分别对这两个实例变量声明了get/set方法,即存取器。

#import "Car.h"

@implementation Car

// setter
- (void)setCarName:(NSString *)newCarName
{
    carName = newCarName;
}

// getter
- (NSString *)carName
{
    return carName;
}

// setter
- (void)setCarType:(NSString *)newCarType
{
    carType = newCarType;
}

// getter
- (NSString *)carType
{
    return carType;
}

@end

上面代码是对实例变量存取器的实现。我们可以看到,存取器就是对实例变量进行赋值和取值。按照约定赋值方法以set开头,取值方法以实例变量名命名。
我们看看如何使用:

// main.m

#import "Car.h"

int main(int argc, char * argv[])
{
    @autoreleasepool {
        Car *car = [[Car alloc] init];
        [car setCarName:@"Jeep Cherokee"];
        [car setCarType:@"SUV"];
        NSLog(@"The car name is %@ and the type is %@",[car carName],[car carType]);      
    }
    return 0;
}

上面的代码中我们注意到,对象Car使用了消息语法,也就是使用方括号的语法给存取器发送消息。
返回结果为:

The car name is Jeep Cherokee and the type is SUV

使用@Property创建存取器

// Car.h

#import <Foundation/Foundation.h>

@interface Car : NSObject
{
    // 实例变量
    NSString *carName;
    NSString *carType;
}

@property(nonatomic,strong) NSString *carName;
@property(nonatomic,strong) NSString *carType;

@end

上面代码中,我们使用@property声明两个属性,名称与实例变量名称相同(让我们先忽略nonatomicstrong)。

// Car.m

#import "Car.h"

@implementation Car

@synthesize carName;
@synthesize carType;

@end

在.m文件中我们使用@synthesize自动生成这两个实例变量的存取器,并且隐藏了存取器,虽然我们看不到存取器,但它们确实是存在的。

// main.m

int main(int argc, char * argv[])
{
    @autoreleasepool {
        Car *car = [[Car alloc] init];
        car.carName = @"Jeep Compass";
        car.carType = @"SUV";
        NSLog(@"The car name is %@ and the type is %@",car.carName,car.carType); 
    }
    return 0;
}

在上面的代码中我们可以注意到,Car对象使用点语法给存取器发送消息,并且get与set的语法是相同的,所以这里的点语法可以根据语境判断我们是要赋值还是取值。

当然我们也依然可以使用消息语法来使用:

// main.m

int main(int argc, char * argv[])
{
    @autoreleasepool {
        Car *car = [[Car alloc] init];

        // 点语法
//        car.carName = @"Jeep Compass";
//        car.carType = @"SUV";
//        NSLog(@"The car name is %@ and the type is %@",car.carName,car.carType);

        // 消息语法
        [car setCarName:@"Jeep Compass"];
        [car setCarType:@"SUV"];
        NSLog(@"The car name is %@ and the type is %@",[car carName],[car carType]);       
    }
    return 0;
}

上面两段代码的执行结果都是:

The car name is Jeep Compass and the type is SUV

总结:@property等同于在.h文件中声明实例变量的get/set方法,@synthesize等同于在.m文件中实现实例变量的get/set方法。使用@propertysynthesize创建存取器要比手动声明两个存取方法(gettersetter)更简单。而且我们在使用属性时可以使用点语法赋值或取值,语法更简单,更符合面向对象编程。

\

不必单独声明示例变量

如果使用@Property,就不必单独声明实例变量了。因为在没有显示提供示例变量声明的前提下,系统会自动帮你生成实例变量。我们通过以下代码来说明:

// Car.h

#import <Foundation/Foundation.h>

@interface Car : NSObject

@property(nonatomic,strong) NSString *carName;
@property(nonatomic,strong) NSString *carType;

- (NSString *)carInfo;

@end

在.h文件中我们并没有声明实例变量,只是声明了carNamecarType两个属性,以及一个carInfo方法,返回值为NSString *

// Car.m

#import "Car.h"

@implementation Car

- (NSString *)carInfo
{
    return [NSString stringWithFormat:@"The car name is %@ and the type is %@",_carName,_carType];
}

@end

在.m文件中我们可以注意到,在carInfo方法中我们使用了_carName_carType实例变量,这就是当我们没有显示声明实例变量时,系统为我们自动生成的。命名规则是以_为前缀,加上属性名,即_propertyName

其实在.m文件中实际是存在@synthesize声明语句的,只是系统将其隐藏了:

@synthesize carName = _carName;
@synthesize carType = _carType;

那么如果我们不喜欢默认的实例变量命名方法,或者我们希望使用更有语义的名称,应该怎么做呢。其实很简单:

// Car.m

#import "Car.h"

@implementation Car

@synthesize carName = i_am_car_name;
@synthesize carType = i_am_car_type;

- (NSString *)carInfo
{
    return [NSString stringWithFormat:@"The car name is %@ and the type is %@",i_am_car_name,i_am_car_type];
}

@end

通过上述代码可以看到,我们只需要通过@synthesize来声明我们希望的实例变量名。

总结:如果我们希望使用默认的实例变量命名方式,那么我们在.m文件中就不需要使用@synthesize声明,系统会帮我们自动完成。如果我们希望自己命名实例变量命,那么我们就使用@synthesize显示声明我们希望的实例变量名。

@property的特性

@property还有一些关键字,它们都是有特殊作用的,比如上述代码中的nonatomicstrong

@property(nonatomic,strong) NSString *carName;
@property(nonatomic,strong) NSString *carType;

我把它们分为三类,分别是:原子性,存取器控制,内存管理。

原子性

  • atomic(默认):atomic意为操作是原子的,意味着只有一个线程访问实例变量。atomic是线程安全的,至少在当前的存取器上是安全的。它是一个默认的特性,但是很少使用,因为比较影响效率,这跟ARM平台和内部锁机制有关。
  • nonatomicnonatomicatomic刚好相反。表示非原子的,可以被多个线程访问。它的效率比atomic快。但不能保证在多线程环境下的安全性,在单线程和明确只有一个线程访问的情况下广泛使用。

存取器控制

  • readwrite(默认):readwrite是默认值,表示该属性同时拥有settergetter
  • readonlyreadonly表示只有getter没有setter

有时候为了语意更明确可能需要自定义访问器的名字:

@property (nonatomic, setter = mySetter:,getter = myGetter ) NSString *name;

最常见的是BOOL类型,比如标识View是否隐藏的属性hidden。可以这样声明:

@property (nonatomic,getter = isHidden ) BOOL hidden;

内存管理

@property有显示的内存管理策略。这使得我们只需要看一眼@property声明就明白它会怎样对待传入的值。

  • assign(默认):assign用于值类型,如intfloatdoubleNSIntegerCGFloat等表示单纯的复制。还包括不存在所有权关系的对象,比如常见的delegate。
@property(nonatomic) int running;
@property(nonatomic,assign) int running;

以上两段代码是相同的。

setter方法中,采用直接赋值来实现设值操作:

-(void)setRunning:(int)newRunning{  
    _running = newRunning;  
} 
  • retain:在setter方法中,需要对传入的对象进行引用计数加1的操作。
    简单来说,就是对传入的对象拥有所有权,只要对该对象拥有所有权,该对象就不会被释放。如下代码所示:
-(void)setName:(NSString*)_name{  
     //首先判断是否与旧对象一致,如果不一致进行赋值。  
     //因为如果是一个对象的话,进行if内的代码会造成一个极端的情况:当此name的retain为1时,使此次的set操作让实例name提前释放,而达不到赋值目的。  
     if ( name != _name){  
          [name release];  
          name = [_name retain];  
     }  
}
  • strongstrong是在IOS引入ARC的时候引入的关键字,是retain的一个可选的替代。表示实例变量对传入的对象要有所有权关系,即强引用。strong跟retain的意思相同并产生相同的代码,但是语意上更好更能体现对象的关系。
  • weak:在setter方法中,需要对传入的对象不进行引用计数加1的操作。
    简单来说,就是对传入的对象没有所有权,当该对象引用计数为0时,即该对象被释放后,用weak声明的实例变量指向nil,即实例变量的值为0。

    注:weak关键字是IOS5引入的,IOS5之前是不能使用该关键字的。delegate 和 Outlet 一般用weak来声明。

  • copy:与strong类似,但区别在于实例变量是对传入对象的副本拥有所有权,而非对象本身。

\

相关概念

在这篇笔记开始之前,我们需要对以下概念有所了解。

操作系统中的栈和堆

注:这里所说的堆和栈与数据结构中的堆和栈不是一回事。

我们先来看看一个由C/C++/OBJC编译的程序占用内存分布的结构:
内存分布结构

  • 栈区(stack):由系统自动分配,一般存放函数参数值、局部变量的值等。由编译器自动创建与释放。其操作方式类似于数据结构中的栈,即后进先出、先进后出的原则。

    例如:在函数中申明一个局部变量int b;系统自动在栈中为b开辟空间。

  • 堆区(heap):一般由程序员申请并指明大小,最终也由程序员释放。如果程序员不释放,程序结束时可能会由OS回收。对于堆区的管理是采用链表式管理的,操作系统有一个记录空闲内存地址的链表,当接收到程序分配内存的申请时,操作系统就会遍历该链表,遍历到一个记录的内存地址大于申请内存的链表节点,并将该节点从该链表中删除,然后将该节点记录的内存地址分配给程序。

    例如:在C中malloc函数
    char p1;
    p1 = (char
    )malloc(10);
    但是p1本身是在栈中的。

链表:是一种常见的基础数据结构,一般分为单向链表、双向链表、循环链表。以下为单向链表的结构图:
单向链表
单向链表是链表中最简单的一种,它包含两个区域,一个信息域和一个指针域。信息域保存或显示关于节点的信息,指针域储存下一个节点的地址。
上述的空闲内存地址链表的信息域保存的就是空闲内存的地址。

  • 全局区/静态区:顾名思义,全局变量和静态变量存储在这个区域。只不过初始化的全局变量和静态变量存储在一块,未初始化的全局变量和静态变量存储在一块。程序结束后由系统释放。
  • 文字常量区:这个区域主要存储字符串常量。程序结束后由系统释放。
  • 程序代码区:这个区域主要存放函数体的二进制代码。

下面举一个前辈写的例子:

//main.cpp
int a = 0; // 全局初始化区
char *p1; // 全局未初始化区
main {
    int b; // 栈
    char s[] = "abc"; // 栈
    char *p2; // 栈
    char *p3 = "123456"; // 123456\0在常量区,p3在栈上
    static int c =0; // 全局静态初始化区
    p1 = (char *)malloc(10);
    p2 = (char *)malloc(20); // 分配得来的10和20字节的区域就在堆区
    strcpy(p1, "123456"); // 123456\0在常量区,这个函数的作用是将"123456" 这串字符串复制一份放在p1申请的10个字节的堆区域中。
    // p3指向的"123456"与这里的"123456"可能会被编译器优化成一个地址。
}

strcpy函数
原型声明:extern char *strcpy(char* dest, const char *src);
功能:把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间。

结构体(Struct)

在C语言中,结构体(struct)指的是一种数据结构。结构体可以被声明为变量、指针或数组等,用以实现较复杂的数据结构。结构体同时也是一些元素的集合,这些元素称为结构体的成员(member),且这些成员可以为不同的类型,成员一般用名字访问。
我们来看看结构体的定义:

struct tag { member-list } variable-list;
  • struct:结构体关键字。
  • tag:结构体标签。
  • member-list:结构体成员列表。
  • variable-list:为结构体声明的变量列表。

在一般情况下,tagmember-listvariable-list这三部分至少要出现两个。以下为示例:

// 该结构体拥有3个成员,整型的a,字符型的b,双精度型的c
// 并且为该结构体声明了一个变量s1
// 该结构体没有标明其标签
struct{
    int a;
    char b;
    double c;
} s1;

// 该结构体拥有同样的三个成员
// 并且该结构体标明了标签EXAMPLE
// 该结构体没有声明变量
struct EXAMPLE{
    int a;
    char b;
    double c;
};

//用EXAMPLE标签的结构体,另外声明了变量t1、t2、t3
struct EXAMPLE t1, t2[20], *t3;

以上就是简单结构体的代码示例。结构体的成员可以包含其他结构体,也可以包含指向自己结构体类型的指针。结构体的变量也可以是指针。

下面我们来看看结构体成员的访问。结构体成员依据结构体变量类型的不同,一般有2种访问方式,一种为直接访问,一种为间接访问。直接访问应用于普通的结构体变量,间接访问应用于指向结构体变量的指针。直接访问使用结构体变量名.成员名,间接访问使用(*结构体指针名).成员名或者使用结构体指针名->成员名。相同的成员名称依靠不同的变量前缀区分。

struct EXAMPLE{
    int a;
    char b;
};

//声明结构体变量s1和指向结构体变量的指针s2
struct EXAMPLE s1, *s2;

//给变量s1和s2的成员赋值,注意s1.a和s2->a并不是同一成员
s1.a = 5;
s1.b = 6;
s2->a = 3;
s2->b = 4;

最后我们来看看结构体成员存储。在内存中,编译器按照成员列表顺序分别为每个结构体成员分配内存。如果想确认结构体占多少存储空间,则使用关键字sizeof,如果想得知结构体的某个特定成员在结构体的位置,则使用offsetof宏(定义于stddef.h)。

struct EXAMPLE{
    int a;
    char b;
};

//获得EXAMPLE类型结构体所占内存大小
int size_example = sizeof( struct EXAMPLE );

//获得成员b相对于EXAMPLE储存地址的偏移量
int offset_b = offsetof( struct EXAMPLE, b );

闭包(Closure)

闭包就是一个函数,或者一个指向函数的指针,加上这个函数执行的非局部变量。
说的通俗一点,就是闭包允许一个函数访问声明该函数运行上下文中的变量,甚至可以访问不同运行上文中的变量。
我们用脚本语言来看一下:

function funA(callback){
    alert(callback());
}

function funB(){
    var str = "Hello World"; // 函数funB的局部变量,函数funA的非局部变量
    funA(
        function(){
            return str;
        }
    );
}

通过上面的代码我们可以看出,按常规思维来说,变量str是函数funB的局部变量,作用域只在函数funB中,函数funA是无法访问到str的。但是上述代码示例中函数funA中的callback可以访问到str,这是为什么呢,因为闭包性。

block基础知识

block实际上就是Objective-C语言对闭包的实现。

block的原型及定义

我们来看看block的原型:

NSString * ( ^ myBlock )( int );

上面的代码声明了一个block(^)原型,名字叫做myBlock,包含一个int型的参数,返回值为NSString类型的指针。

下面来看看block的定义:

myBlock = ^( int paramA )
{
    return [ NSString stringWithFormat: @"Passed number: %i", paramA ];
};

上面的代码中,将一个函数体赋值给了myBlock变量,其接收一个名为paramA的参数,返回一个NSString对象。

注意:一定不要忘记block后面的分号。

定义好block后,就可以像使用标准函数一样使用它了:

myBlock(7);

由于block数据类型的语法会降低整个代码的阅读性,所以常使用typedef来定义block类型。例如,下面的代码创建了GetPersonEducationInfoGetPersonFamilyInfo两个新类型,这样我们就可以在下面的方法中使用更加有语义的数据类型。

// Person.h
#import <Foundation/Foundation.h>

// Define a new type for the block
typedef NSString * (^GetPersonEducationInfo)(NSString *);
typedef NSString * (^GetPersonFamilyInfo)(NSString *);

@interface Person : NSObject

- (NSString *)getPersonInfoWithEducation:(GetPersonEducationInfo)educationInfo
    andFamily:(GetPersonFamilyInfo)familyInfo;

@end

我们用一张大师文章里的图来总结一下block的结构:
block

将block作为参数传递

// .h
-(void) testBlock:( NSString * ( ^ )( int ) )myBlock;

// .m
-(void) testBlock:( NSString * ( ^ )( int ) )myBlock
{
    NSLog(@"Block returned: %@", myBlock(7) );
}

由于Objective-C是强制类型语言,所以作为函数参数的block也必须要指定返回值的类型,以及相关参数类型。

闭包性

上文说过,block实际是Objc对闭包的实现。
我们来看看下面代码:

#import <Cocoa/Cocoa.h>

void logBlock( int ( ^ theBlock )( void ) )
{
    NSLog( @"Closure var X: %i", theBlock() );
}

int main( void )
{
    NSAutoreleasePool * pool;
    int ( ^ myBlock )( void );
    int x;

    pool = [ [ NSAutoreleasePool alloc ] init ];
    x = 42;

    myBlock = ^( void )
    {
        return x;
    };

    logBlock( myBlock );

    [ pool release ];

    return EXIT_SUCCESS;
}

上面的代码在main函数中声明了一个整型,并赋值42,另外还声明了一个block,该block会将42返回。然后将block传递给logBlock函数,该函数会显示出返回的值42。即使是在函数logBlock中执行block,而block又声明在main函数中,但是block仍然可以访问到x变量,并将这个值返回。

注意:block同样可以访问全局变量,即使是static

block中变量的复制与修改

对于block外的变量引用,block默认是将其复制到其数据结构中来实现访问的,如下图:
copy variables
通过block进行闭包的变量是const的。也就是说不能在block中直接修改这些变量。来看看当block试着增加x的值时,会发生什么:

myBlock = ^( void )
{
    x++;

    return x;
};

编译器会报错,表明在block中变量x是只读的。
有时候确实需要在block中处理变量,怎么办?别着急,我们可以用__block关键字来声明变量,这样就可以在block中修改变量了。
基于之前的代码,给x变量添加__block关键字,如下:

__block int x;

对于用__block修饰的外部变量引用,block是复制其引用地址来实现访问的,如下图:
ref variables

3.编译器中的block

3.1 block的数据结构定义

我们通过大师文章中的一张图来说明:
block struct
上图这个结构是在栈中的结构,我们来看看对应的结构体定义:

struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};

struct Block_layout {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables. */
};

从上面代码看出,Block_layout就是对block结构体的定义:

  • isa指针:指向表明该block类型的类。
  • flags:按bit位表示一些block的附加信息,比如判断block类型、判断block引用计数、判断block是否需要执行辅助函数等。
  • reserved:保留变量,我的理解是表示block内部的变量数。
  • invoke:函数指针,指向具体的block实现的函数调用地址。
  • descriptor:block的附加描述信息,比如保留变量数、block的大小、进行copydispose的辅助函数指针。
  • variables:因为block有闭包性,所以可以访问block外部的局部变量。这些variables就是复制到结构体中的外部局部变量或变量的地址。

block的类型

block有几种不同的类型,每种类型都有对应的类,上述中isa指针就是指向这个类。这里列出常见的三种类型:

  • _NSConcreteGlobalBlock:全局的静态block,不会访问任何外部变量,不会涉及到任何拷贝,比如一个空的block。例如:
#include <stdio.h>

int main()
{
    ^{ printf("Hello, World!\n"); } ();
    return 0;
}
  • _NSConcreteStackBlock:保存在栈中的block,当函数返回时被销毁。例如:
#include <stdio.h>

int main()
{
    char a = 'A';
    ^{ printf("%c\n",a); } ();
    return 0;
}
  • _NSConcreteMallocBlock:保存在堆中的block,当引用计数为0时被销毁。该类型的block都是由_NSConcreteStackBlock类型的block从栈中复制到堆中形成的。例如下面代码中,在exampleB_addBlockToArray方法中的block还是_NSConcreteStackBlock类型的,在exampleB方法中就被复制到了堆中,成为_NSConcreteMallocBlock类型的block:
void exampleB_addBlockToArray(NSMutableArray *array) {
    char b = 'B';
    [array addObject:^{
            printf("%c\n", b);
    }];
}
 
void exampleB() {
    NSMutableArray *array = [NSMutableArray array];
    exampleB_addBlockToArray(array);
    void (^block)() = [array objectAtIndex:0];
    block();
}

总结一下:

  • _NSConcreteGlobalBlock类型的block要么是空block,要么是不访问任何外部变量的block。它既不在栈中,也不在堆中,我理解为它可能在内存的全局区。
  • _NSConcreteStackBlock类型的block有闭包行为,也就是有访问外部变量,并且该block只且只有有一次执行,因为栈中的空间是可重复使用的,所以当栈中的block执行一次之后就被清除出栈了,所以无法多次使用。
  • _NSConcreteMallocBlock类型的block有闭包行为,并且该block需要被多次执行。当需要多次执行时,就会把该block从栈中复制到堆中,供以多次执行。

编译器如何编译

我们通过一个简单的示例来说明:

#import <dispatch/dispatch.h>

typedef void(^BlockA)(void);

__attribute__((noinline))
void runBlockA(BlockA block) {
    block();
}

void doBlockA() {
    BlockA block = ^{
        // Empty block
    };
    runBlockA(block);
}

上面的代码定义了一个名为BlockA的block类型,该block在函数doBlockA中实现,并将其作为函数runBlockA的参数,最后在函数doBlockA中调用函数runBloackA

注意:如果block的创建和调用都在一个函数里面,那么优化器(optimiser)可能会对代码做优化处理,从而导致我们看不到编译器中的一些操作,所以用__attribute__((noinline))给函数runBlockA添加noinline,这样优化器就不会在doBlockA函数中对runBlockA的调用做内联优化处理。

我们来看看编译器做的工作内容:

#import <dispatch/dispatch.h>

__attribute__((noinline))
void runBlockA(struct Block_layout *block) {
    block->invoke();
}

void block_invoke(struct Block_layout *block) {
    // Empty block function
}

void doBlockA() {
    struct Block_descriptor descriptor;
    descriptor->reserved = 0;
    descriptor->size = 20;
    descriptor->copy = NULL;
    descriptor->dispose = NULL;

    struct Block_layout block;
    block->isa = _NSConcreteGlobalBlock;
    block->flags = 1342177280;
    block->reserved = 0;
    block->invoke = block_invoke;
    block->descriptor = descriptor;

    runBlockA(&block);
}

上面的代码结合block的数据结构定义,我们能很容易得理解编译器内部对block的工作内容。

copy()和dispose()

上文中提到,如果我们想要在以后继续使用某个block,就必须要对该block进行拷贝操作,即从栈空间复制到堆空间。所以拷贝操作就需要调用Block_copy()函数,block的descriptor中有一个copy()辅助函数,该函数在Block_copy()中执行,用于当block需要拷贝对象的时候,拷贝辅助函数会retain住已经拷贝的对象。

既然有有copy那么就应该有release,与Block_copy()对应的函数是Block_release(),它的作用不言而喻,就是释放我们不需要再使用的block,block的descriptor中有一个dispose()辅助函数,该函数在Block_release()中执行,负责做和copy()辅助函数相反的操作,例如释放掉所有在block中拷贝的变量等。

总结

以上内容是我学习各大师的文章后对自己学习情况的一个记录,其中有部分文字和代码示例是来自大师的文章,还有一些自己的理解,如有错误还请大家勘误。

参考链接:

以前建过个人网站,也用过第三方的博客系统,然后又回归到自建的个人博客,但总有不敬人意的地方。比如自建的博客涉及到购买的服务器的稳定性、流量成本、维护成本、数据的安全性、文本编辑器的舒适度等,第三方的博客系统又觉得局限性比较大、缺乏插件、觉得不牛逼等原因。总之人是很贪心的,总想找到一个既不用担心服务器稳定性、又不用担心流量成本、也不用担心数据安全性、而且还能方便的维护资源、并且还有丰富的插件的个人博客解决方案。于是外事问Google,经过一阵寻觅后发现大牛们的博客方案不正是我所需要的么,于是便有了上一篇的补脑笔记,把涉及到的知识大概整理了一下,准备开始搭建自己的个人学习笔记博客。今天这篇笔记将记录我使用Git+GitHub+Markdown+Jekyll搭建博客系统的过程。

注:以下过程均在OS X系统上操作,Win系统的童靴请勿效仿,但可借鉴。

GitHub

让人不再担心本地备份与远程协作,一切提交均有记录,均可追溯。

Git

让人不再担心写废,想到哪里,写到哪里。

由于OS X系统自带Git,所以不需要再安装Git,自带的Git版本为1.8.5.2。

Markdown

不再忧虑排版,专注于写作。

Markdown是我认为最好的写作利器没有之一。GitHub完美支持,个人写作使用的DayOne也完美支持,Win系统下也有MarkdownPad这种成熟的工具。

什么是Github Pages

Github Pages:Websites for you and your projects.

Github Pages 是面向用户、组织和项目开放的公共静态页面搭建托管服 务,站点可以被免费托管在 Github 上,你可以选择使用 Github Pages 默 认提供的域名 username.github.io 或者自定义域名来发布站点。Github Pages 支持自动利用 Jekyll 生成站点,也同样支持纯 HTML 文档,将你的 Jekyll 站点托管在 Github Pages 上是一个不错的选择。

通俗一点讲。你可以将你个人网站的html、css、js、image等按一定目录结构托管在github上,以index.html为入口(即个人网站首页),使用username.github.io就可以访问你的个人网站了。

再通俗一点讲。github为你提供了一台无限流量、稳定、的服务器。你将个人网站的资源以一定目录结构上传(托管)到github,该服务器的ip就是username.github.io。

上述两次提到目录结构,下面我解释一下这个目录结构。

什么是Jekyll

Jekyll 的核心其实是一个文本转换引擎。它的概念其实就是: 你用你最喜欢的标记语言来写文章,可以是 Markdown,也可以是 Textile,或者就是简单的 HTML, 然后 Jekyll 就会帮你套入一个或一系列的布局中。在整个过程中你可以设置URL路径, 你的文本在布局中的显示样式等等。这些都可以通过纯文本编辑来实现,最终生成的静态页面就是你的成品了。

如何使用Github Pages与Jekyll

Jekyll目录结构

上述多次提到的目录结构即Jekyll的目录结构。如下:

.   
|--_config.yml>  
|--_drafts  
    |--articles1.textile 
    |--articles2.md
|--_includes
    |--footer.html
    |--header.html
|--_layouts
    |--default.html
    |--post.html
|--_posts
    |--2014-06-17-articles1.textile
    |--2014-06-17-articles1.md
|--_site
|--index.html
|--other files
  • _config.yml:保存配置数据。
  • _drafts:存放未发布的文章。
  • _includes:存放页面片段,即页头(head.html)、页脚(footer.html)、导航(navigation.html)、评论(disqus_comments.html)等,这些资源通过标签添加到index.html中,从而形成一个完整的页面。
  • _layouts:存放模板文件。文章模板、关于页面模板、首页模板等。
  • _posts:存放文章的文件。并且文章文件名称要符合YEAR-MONTH-DAY-title.MARKUP格式。
  • _site:经过jekyll转换的页面。
  • index.html:网站首页。
  • other files:其他文件,存放css、js、image等。

Jekyll解析流程

  • 首先会加载_posts及文件夹下的所有文章,将其参数和文章内容组织保存在内存中,所有的文章的内容、参数都在site.posts对象(其他文件夹下的文章不会放入site.posts中)。
  • 其次加载_layouts文件夹下的所有模板。
  • 再次加载_includes文件夹下的所有需要被引入的内容。
  • 最后根据每一篇需要编译的文章选择的其参数定义的模板来创建一个模板,并将当前文章的内容、参数等进行扩展后放在page对象、content对象中,然后进行模板的编译,生成html文件,并按照一定规则放在_site文件夹下。也就是说在创建一篇文章时,其实所有文章的内容都已经被读取出来了,这也为文章相互之间的关联提供了可能。

在本地安装jekyll

注:这里默认安装环境已具备Ruby、RubyGems环境。

  • 安装jekyll:
$ sudo gem update —system
$ sudo gem install jekyll
  • 安装模板,默认的模板是Maruku,我们替换为RDiscount。
$ sudo gem install rdiscount

Maruku是纯ruby写的Markdown模板解释器。
RDiscount是C写的模板解释器。

为什么要替换为RDiscount呢,有心人对两者做了比较,优劣可见一斑。

Maruku: 08.424132s total time, 00.084241s average  
RDiscount: 00.082019s total time, 00.000820s average
  • 新建一个jekyll目录:
$ jekyll new blog
  • 进入到该目录下,你就能看到上述的目录结构:
$ cd blog

jekyll集成了一个开发用的服务器,可以让你使用浏览器在本地进行预览。启动server,访问地址为http://localhost:4000/:

$ jekyll serve

至此,一个简单的基于本机服务器的jekyll框架的个人网站就算搭建完毕,在浏览器中访问http://localhost:4000/,就可以看到index.html中的内容,一般在制作模板时多采在本地安装的方式,便于调试。更多配置信息请参见[Jekyll文档][1]。

结合Github Pages使用Jekyll

这篇笔记的主题不是如何在本机搭建个人网站,所以这种使用方式是重点。

由于Github Pages完美支持Jekyll,所以你只需要安照Jekyll的文件目录结构,托管在Github中即可,不需要在本机安装Jekyll,只需要关注于github,可以借鉴大师们设计的Jekyll模板,然后push或pull你的文章即可。

  • 注册GitHub账号,只需要一个邮箱和密码。GitHub官网
  • 创建一个Repository,命名格式为:username.github.io,这样就生成了你的User site。可参见GitHub Pages

注意:这里的username必须和你的账号名一致。

  • 不管用命令行还是用Finder,总之新建一个目录,我这里起名为GitRepo。
  • 进入GitRepo目录,键入git init命令,初始化一个git库。
cd /Users/JaceFu/GitRepo
  • 将刚才在Github中创建的Repo克隆到你本地的Git库中,即刚在本地创建的GitRepo目录中。
cd /Users/JaceFu/GitRepo
git clone https://github.com/username/username.github.io

在GitRepo文件中会看到名为username.github.io的文件,这就是你从Github中克隆的Repo文件。

  • Hello World,进入Repo目录中,创建一个HTML文件,名为index,内容为“Hello World”。
cd /Users/JaceFu/GitRepo/username.github.io
echo “Hello World” > index.html
  • 将创建的index.html文件push到github中
cd /Users/JaceFu/GitRepo/username.github.io
git add .
git commit -m “Hello World update”
git push
  • 在浏览器中访问http://username.github.io,你将会看到index.html文件中的内容,我们这里会显示“Hello World”。至此,基于Github Pages功能的个人站点就算搭建好了。

  • 在克隆到本地的Repo文件中,按照上述的Jekyll文件目录结构手动创建所需的文件资源,并上传。由于Github本身完美支持Jekyll,所以只要符合Jekyll的文件目录,Github就自动使用Jekyll解析形成页面。

至此,我们应该有了一定的理解,这里我再简单梳理一下:

  • Jekyll可以将我们使用markdown写的文章按照指定模板解析为html文件。
  • Github Pages可以充当我们的服务器,通过username.github.io可以访问到我们上传的html页面。
  • Github Pages完美支持Jekyll,所以不需要我们自己编写复杂的html页面,只要将Jekyll的目录结构上传至Github中,就可以通过username.github.io访问由Jekyll解析生成的html页面,从而形成了个人网站。

配置_config.yml文件

基本配置参见官方配置文档
不同的模板,在该文件中的配置项也不一样,因为我自己使用了大师设计的模板,配置了如下参数(部分):

  • title:网站名称。
  • description:网站说明。
  • logo:网站logo。
  • disqus_shortname:disqus标示符。
  • search:是否运行搜索。
  • url:网站中一些资源文件使用的url地址。
  • encoding:编码。
  • markdown:md解析模板。
  • timezone:时区。

编写博文

可以看一下_posts下的jekyll给的例子:


---
layout: post
title:  "Welcome to Jekyll!"
date:   2014-01-27 21:57:11
categories: jekyll update

---

You'll find this post in your `_posts` directory - edit this post and re-build (or run with the `-w` switch) to see your changes!
To add new posts, simply add a file in the `_posts` directory that follows the convention: YYYY-MM-DD-name-of-post.ext.

Jekyll also offers powerful support for code snippets:

{ % highlight ruby % } 
def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')

#=> prints 'Hi, Tom' to STDOUT.

{ % endhighlight % }

Check out the [Jekyll docs][jekyll] for more info on how to get the most out of Jekyll. File all bugs/feature requests at [Jekyll's GitHub repo][jekyll-gh].

[jekyll-gh]: https://github.com/mojombo/jekyll
[jekyll]:    http://jekyllrb.com

可以看到在博文的最上方有被两个—包裹起来的一段,这里就定义了文章的一些参数,更多参数在FrontMatter和Variables获取,简单的只需要关注几个就好:

  • title:文章的标题。
  • date:文章的日期。
  • categories:定义了文章所属的目录。
  • layout:文章所使用的模板名称。
  • tags:文章标签。

这里就写一个最简单的文章,只是用其中的两个参数:layout,title,如下:


---
layout: mylayout
title: hello-jekyll

---

Hello jekyll!

将这个写完的文章保存为 “年-月-日-标题.markdown”的名字形式,上传至Github中的_posts文件中,Jekyll会自动解析生成该文章的html页面。

注:文章的文件名不要使用中文,否则会出现Bug。

编写模板

如果想自己编写模板可以参见如何创建Jekyll模板
或者可以使用大师们设计好的模板。Jekyll模板锦集

个性域名

个人网站要有一个称心的域名,使用username.github.io实在不像话,所以我说一下如何配置个性域名。如何申请域名这里就不再累赘。

在Github中的User Site Repo根目录(即Github中Jekyll目录的根目录)下创建CNAME目录,内容为你的个性域名,格式为www.yourdomain.com即可。

然后在域名管理系统中解析域名,添加CNAME记录,服务器为username.github.io。等待一个多小时后,就可以使用自己的域名访问了。

结束

至此,使用Github Pages和Jekyll搭建个人网站的过程记录完毕。

Git

Git是一个分布式版本控制/软件配置管理软件,原是Linux内核开发者林纳斯·托瓦兹(Linus Torvalds)为更好的管理Linux内核开发而设计。

版本控制是维护工程蓝图的标准做法,能追踪工程蓝图从诞生到定案的过程。此外,版本控制也是一种软件工程技巧,借此能在软件开发的过程中,确保由不同人所编辑的同一程式档案都得到同步。

软件配置管理(Software Configuration Management),又称软件形态管理、或者软件建构管理,简称软件形管(SCM)。界定软件的组成项目,对每个项目的变更进行管控,并维护不同项目之间的版本关联,以使软件在开发过程中任一时间的内容都可以被追溯。

Git是用于Linux内核开发的版本控制工具。与CVS、Subversion一类的集中式版本控制工具不同,它采用了分布式版本控制的做法,不需要服务器端软件,就可以运作版本控制,使得源代码的发布和交流极其方便。

Git和其他版本控制(如CVS、SVN)有不少的差别,Git本身关心文件的整体性是否有改变,但多数的CVS和SVN系统则在乎文件内容的差异。因此Git更像一个文件系统,直接在本机上取得数据,不必连接到主机端获取数据。

GitHub

GitHub是一个共享虚拟主机服务,用于存放使用Git版本控制的软件代码和内容项目。它由Github公司的开发者使用Ruby on Rails编写而成。

共享虚拟主机是在一台虚拟主机上托管多个服务器的服务方式。

Ruby on Rails,简称Rails,是一个使用Ruby语言写的开源Web应用框架,它是严格按照MVC结构开发的。

GitHub同时提供付费账户和为开源项目提供的免费账户。除了允许个人和组织创建和访问代码库以外,它也提供了一些方便社会化软件开发的功能,包括允许用户跟踪其他用户、组织、软件库的动态,对软件代码的改动和 bug 提出评论等。GitHub也提供了图表功能,用于显示开发者们怎样在代码库上工作以及软件的开发活跃程度。

rbenv

Ruby常有不同的版本同时存在,目前OS X 10.9.3中的版本是2.0.0p451,目前最新的版本是2.1.1,但是有些开发者仍然使用1.8.x系列的版本,而且很多程序只针对特定的Ruby版本。所以对Ruby做版本管理是极为重要的。

Ruby是一种面向对象、命令式、函数式、动态的通用编程语言。

常用的几个Ruby版本管理工具有:rvm,rbenv,ry,rbfu。rvm 应该是最早出现、使用最多的,因为过于强大以至于违背了某个 Linux 软件开发原则,所以出现了很多轻便的替代者,其中来自 37signals 的 rbenv 就很受欢迎。ry 和 rbfu 看上去更轻便,不过使用不广泛。

Homebrew

Homebrew is the easiest and most flexible way to install the UNIX tools Apple didn’t include with OS X.

我们能够通过终端方便的使用它安装管理苹果没有自带的Unix相关工具软件。被誉为OS X 不可或缺的套件管理器。

RubyGems

RubyGems is a sophisticated package manager for Ruby.

RubyGems是一个方便而强大的Ruby程序包管理器,Ruby的第三方插件是用gem方式来管理,非常容易发布和共享,一个简单的命令就可以安装上第三方的扩展库。特点:能远程安装包,包之间依赖关系的管理,简单可靠的卸载,查询机制,能查询本地和远程服务器的包信息,能保持一个包的不同版本,基于Web的查看接口,能查看你安装的gem的信息。

Jekyll

Jekyll 是一个简单的博客形态的静态站点生产机器。它有一个模版目录,其中包含原始文本格式的文档,通过 Markdown (或者 Textile) 以及 Liquid 转化成一个完整的可发布的静态网站,你可以发布在任何你喜爱的服务器上。Jekyll 也可以运行在 GitHub Page 上,也就是说,你可以使用 GitHub 的服务来搭建你的项目页面、博客或者网站,而且是完全免费的。

Liquid

Liquid是一个模板制作引擎,通过简单的标记语言制作强大的html、css页面模板。