iOS 中Block以及Blocks的使用,閉包方法調用

時間  2020-08-09
標籤 ios block 以及 blocks 使用 閉包 方法 調用 欄目 iOS 简体版
原文   原文鏈接

OC：php

-(void)dataWithUrl:(NSString*)string AndId:(NSInteger)id returnName:(void(^)(NSString*name))backname{
    
    
    NSString *name = [NSString stringWithFormat:@"%@,,%ld",string,id];
    
    backname(name);
    
    
}

//調用
 [self dataWithUrl:@"www" AndId:123456 returnName:^(NSString *name) {
    
        
        NSLog(@"%@",name);
        
    }];

Swift3.0html

 func datawith(string:String,id:NSInteger,completion: @escaping (_ result : [String]) -> ()) -> () {
     
    let str = string + String(id)
    
        completion([str])
    
    }


//調用
  datawith(string: "wwww", id: 18) { (result) in
            
            
            print(result)
            
        }

 

 

 

1、ios中block的使用ios

Block能夠幫助咱們組織獨立的代碼段，並提升複用性和可讀性。iOS4在UIKit中引入了該特徵。超過100個的Apple API都使用了Block，因此這是一個咱們必須開始熟悉的知識。sql


Block是什麼樣的？ 
你可使用^操做符來聲明一個Block變量，它表示一個Block的開始。api

  1. int num1 = 7;  
  2. int(^aBlock)(int) = ^(int num2) {  
  3.    return num1+nunm2;  
  4. };  

在如上代碼中咱們將Block聲明爲一個變量，因此能夠將它當作一個函數中使用：數組

  1. NSLog(@"%d", aBlock(49)); //adds 49 to 7 which gives us 56.  

咱們剛看過了將block當作變量的狀況，但一般狀況下咱們會之內聯的方式使用Block，好比在一個變量中。API要麼會使用Block在一個對象集合上執行某種操做，要麼將其做爲一個操做完成後的回調。併發

  1. NSComperator compareStringsBlock = ^(id stringA, id stringB) {  
  2. NSRange rangeS  = NSMakeRange (0, [stringA length]);  
  3.   return (stringA compare:stringB options:comparisonOptions range:rangeS locale:currentLocale];  
  4. };  
  5.  
  6. NSArray *compareSortArray  = [arrayOfStringDays sortArrayUsingComparator: compareStringsBlock]);  

Block具備將臨時函數體建立爲表達式的優點。Apple文檔中指出： 
Block是符合以下要求的匿名內聯的代碼集：ide

  • 和函數同樣具備一個指定類型的參數列表
  •  有一個能夠推導或聲明的返回值類型
  • 能夠從它被定義的詞義範圍中捕捉狀態
  • 能夠在須要的時候改變詞義範圍的狀態
  • 能夠和相同的詞義範圍中定義的其餘的Block共享更改的可能。
  • 能夠在詞義範圍（堆棧幀）被銷燬後繼續共享和修改該詞義範圍（堆棧幀）的狀態。

Block是一個自包含的小代碼段，封裝了用於遍歷（線性遍歷）或者回調，能夠併發執行的任務單元。函數


聲明和使用Block 
Apple文檔中介紹瞭如何將一個Block聲明爲變量，並將其做爲一個函數使用：oop

  1. int (^oneFrom)(int) = ^(int anInt) {  
  2.     return anInt - 1;  
  3. };  
  4. // 咱們建立了一個內聯塊^(int anInt)... ，其函數體和結果被傳到了另一個名爲OneFrom的Block。  
  5.  
  6. printf("1 from 10 is %d", oneFrom(10));  
  7. // 打印出： "1 from 10 is 9"  
  8. // 這個block函數（distanceTraveled）傳入3個float型參數，返回float值。   
  9.  
  10. float (^distanceTraveled) (float, float, float) =  
  11.  
  12.                           ^(float startingSpeed, float acceleration, float time) {  
  13.     float distance = (startingSpeed * time) + (0.5 * acceleration * time * time);  
  14.     return distance;  
  15. }; 


  你也能夠傳入一個Block做爲一個參數，而不要以如上的方式聲明它們，這樣就能夠在須要將block做爲參數的時候之內聯代碼的方式簡單地實現。

  1. NSArray *anArray = [NSArray arrayWithObjects: @"cat", @"dog",nil];  
  2. sortFunction(anArray, ^(string *a string *b){  
  3. if ( a == @"cat") return TRUE; }); 


這樣咱們就看到一個內聯的block代碼段佔據了最後一個參數（必須是參數列表的最後一個參數）的位置。Cocoa提供了不少使用Block的方法，這樣你就能夠傳入Block做爲方法的參數：

  1. NSArray *array = [NSArray arrayWithObjects: @"A", @"B", @"C",  nil];  
  2. NSSet *filterSet = [NSSet setWithObjects: @"A", @"Z", @"Q", nil];  
  3.  
  4. BOOL (^test)(id obj, NSUInteger idx, BOOL *stop); //Block declaration returns BOOL, params inc. id and BOOL  
  5. //body of block gets the block literal ^(id obj, NSUInteger idx, Bool *stop)... and the body logic   
  6. test = ^ (id obj, NSUInteger idx, BOOL *stop) {  
  7.     if (idx < 5) {  
  8.         if ([filterSet containsObject: obj]) {  
  9.             return YES;  
  10.         }  
  11.     }  
  12.     return NO;  
  13.  
  14. }; 

Apple提供的另一個例子是：

  1. __block BOOL found = NO;  
  2. NSSet *aSet = [NSSet setWithObjects: @"Alpha", @"Beta", @"Gamma", @"X", nil];  
  3. NSString *string = @"gamma";  
  4. //we provide below a way of how to enumerate, using our own compare logic  
  5. [aSet enumerateObjectsUsingBlock:^(id obj, BOOL *stop) {  
  6.     if ([obj localizedCaseInsensitiveCompare:string] == NSOrderedSame) {  
  7.         *stop = YES;  
  8.         found = YES;  
  9.     }  
  10. }]; 

As you can see, it takes a little while to have it sink in but once you get it, it's quite simple. I suggest looking at Apple's documentation, as well as looking at the referenced APIs to see how they are used. Practice makes perfect. 

 

原文出處：http://answers.oreilly.com/topic/2281-how-to-use-blocks-with-ios/

 

 

Block

 

Apple 在C, Objective-C, C++加上Block這個延申用法。目前只有Mac 10.6 和iOS 4有支援。Block是由一堆可執行的程式組成，也能夠稱作沒有名字的Function (Anonymous function)。若是是Mac 10.6 或 iOS 4.0 以前的平臺能夠利用 http://code.google.com/p/plblocks/ 這個project得以支援Block語法。
Apple有一個叫作GCD(Grand Central Dispach)的新功能，用在同步處理(concurrency)的環境下有更好的效率。Block語法產生的動機就是來自於GCD，用Block包好 一個工做量交給GCD，GCD有一個宏觀的視野能夠來分配CPU，GPU，Memory的來下最好的決定。

Block 簡介


Block其實行為和Function很像，最大的差別是在能夠存取同一個Scope的變數值。
Block 實體會長成這樣

^(傳入參數列 ) {行為主體 };


Block實體開頭是"^"，接著是由小括號所包起來的參數列(好比 int a, int b, float c)，行為的主體由大括號包起來，專有名詞叫作block literal。行為主體能夠用return回傳值，型別會被compiler自動辦識出來。若是沒有參數列要這樣寫(void)。
看個列子

^(int a) {return a*a;};

這是表明Block會回傳輸入值的平方值(int a 就是參數列，return a*a; 就是行為主體)。記得主體裡最後要加";"因為是敘述，而整個{}最後也要要加";"因為Block是個物件實體。
用法就是

int result = ^(int a) {return a*a ;} (5) ;

很怪吧。後面小括號裡的5 會被當成a的輸入值然後經由Block輸出5*5 = 25指定給result這個變數。
有沒有簡單一點的方法否則每次都要寫這麼長？有。接下來要介紹一個叫Block Pointer的東西來簡化我們的寫法。
Block Pointer是這樣宣告的

回傳值  (^名字 ) (參數列 );


直接來看一個列子

int (^ square) (int); 

// 有一個叫square的Block Pointer，其所指向的Block是有一個int 輸入和 int 輸出

square = ^(int a ) {return a*a ;}; // 將剛剛Block 實體指定給 square


使用Block Pointer的例子

int result = square(5); // 感覺上不就是funtion的用法嗎？

也能夠把Block Pointer當成參數傳給一個function，好比說

void myFuction( int (^mySquare) (int) ); // function 的宣告，

傳入一個有一個int輸入和int輸出的Block 型別的參數
呼叫這個myFunction的時候就是這樣呼叫

int (^mySqaure) (int) = ^(int a) {return a*a;};
// 先給好一個有實體的block pointer叫mySquare

 

myFunction( mySqaure ) ; //把mySquare這個block pointer給myFunction這個function

或是不用block pointer 直接給一個block 實體，就這樣寫

 myFunction(   ^(int a) {return a*a} ) ;

當成Objective-C method 的傳入值的話都是要把型別寫在變數前面然後加上小括號，因些應該就要這樣寫

-(void) objcMethod:(  int (^) (int) ) square; // square 變數的型別是 int (^) (int)

讀文至此是否是對Block有基本的認識？ 接下來我們要談談Block相關的行為和特點
首先是來看一下在Block裡面存取外部變數的方法

存取變數

1. 能夠讀取和Block pointer同一個scope的變數值：

{
int outA = 8;
int (^myPtr) (int) = ^(int a) {return outA+a;};
// block 裡面能夠讀同一個scope的outA的值
int result = myPtr(3); // result is 11
}

我們再來看一個頗有趣的例子

{
int outA = 8;
int (^myPtr) (int) = ^(int a) {return outA+a;};
// block 裡面能夠讀同一個scope的outA的值
outA = 5; // 在呼叫myPtr以前改變outA的值
int result = myPtr(3); // result 的值還是  11並不是  8
}

 事實上呢，myPtr在其主體用到outA這個變數值的時候是作了一個copy的動做把outA的值copy下來。因此之後outA即便換了新的值對於myPtr裡copy的值是沒有影響到的。
要注意的是，這個指的值是變數的值，若是這個變數的值是一個記憶體的位置，換句話說，這個變數是個pointer的話，它指到的值是能夠在block裡被改變的。

{
        NSMutableArray * mutableArray = [NSMutableArray arrayWithObjects:@"one",@"two",@"three",nil];
        int result = ^(int a) { [mutableArray removeLastObject];  return a*a;} (5);

        NSLog(@"test array %@", mutableArray);

}

本來mutableArray的值是{@"one",@"two",@"three"}在block裡被更改mutableArray所指向的物件後，mutableArray的值就會被成{@"one",@"two"}
2. 直接存取static 的變數 

{
static int outA = 8;
int (^myPtr) (int) = ^(int a) {return outA+a;};
// block 裡面能夠讀同一個scope的outA的值
outA = 5; // 在呼叫myPtr以前改變outA的值
int result = myPtr(3); // result 的值是  8，因為outA是個static 變數會直接反應其值
}

甚至能夠在block裡面直接改變outA的值好比這樣寫

{
static int outA = 8;
int (^myPtr) (int) = ^(int a) { outA= 5; return outA+a;};
// block 裡面改變outA的值
int result = myPtr(3); // result 的值是  8，因為outA是個static 變數會直接反應其值

}

3. Block Variable
在某個變數前面若是加上修飾字__block 的話(注意block前有兩個下底線)，這個變數又稱為block variable。那麼在block裡就能夠任意修改此變數值，變數值的改變也能夠知道。

{
    __block int num = 5;

    int (^myPtr) (int) = ^(int a) { return num++;};
    int (^myPtr2) (int) = ^(int a) { return num++;};
    int result = myPtr(0);
    result = myPtr2(0);
}

因為myPtr和myPtr2都有用到num這個block variable，最後result的值就會是7

生命週期和記憶體管理


因為block也是繼承自NSObject，因此其生命週期和記憶體的管理也就很是之重要。
block一開始都是被放到stack裡，換句話說其生命週期隨著method或function結束就會被回收，和通常變數的生命週期一樣。
關於記憶體的管理請遵循這幾個要點
1. block pointer的實體會在method或function結束後就會被清掉
2. 若是要保存block pointer的實體要用-copy指令，這樣block pointer就會被放到heap裡
    2.1 block 主體裡用到的block variable 也會被搬到heap 而有新的記憶體位置，且一並更新有用到這個block variable 的block都指到新的位置
    2.2 通常的variable值會被copy 
    2.3 若是主體裡用到的variable是object的話，此object會被retain, block release時也會被release
    2.4 __block variable 裡用到的object是不會被retain的

首先來看一下這個例子

typedef int (^MyBlock)(int);

MyBlock genBlock();

int main(){
        MyBlock  outBlock = genBlock();
        int result = outBlock(5);

        NSLog(@"result is %d",[outBlock retainCount] ); // segmentation fault
        NSLog(@"result is %d",result  );

        return 0 ;
}
MyBlock genBlock() {
        int a = 3;
        MyBlock  inBlock = ^(int n) {
                return n*a;
        };
        return  inBlock ;
}

此程式由genBlock裡產生的block再指定給main function的outBlock變數，執行這個程式會獲得
Segmentation fault
(註：有時候把 genBlock裡的a 去掉就能夠跑出結果的情形，這是系統cache住記憶體，並不是inBlock真得一直存在，久了還是會被回收，千萬不要以為是對的寫法)
表示我們用到了不該用的記憶體，在這個例子的情況下是在genBlock裡的inBlock變數在return的時候就被回收了，outBlock無法有一個合法的記憶體位置-retainCount就沒意義了。
若是這個時候須要保留inBlock的值就要用-copy指令，將genBlock改爲

 MyBlock genBlock() {
        int a = 3;
        MyBlock inBlock = ^(int n) {
                return n*a;
        };
        return [inBlock copy]  ;
}

這樣[inBlock copy]的回傳值就會被放到heap，就能夠一直使用(記得要release)
執行結果是
result is 1
result is 15

再次提醒要記得release outBlock。
若是一回傳[inBlock copy]的值就再也不須要的時候能夠這樣寫

 MyBlock genBlock() {
        int a = 3;
        MyBlock inBlock = ^(int n) {
                return n*a;
        };
        return [[inBlock copy] autorelease] ;
}

-copy指令是為了要把block 從stack搬到heap，autorelease是為了平衝retainCount加到autorelease oop ，回傳之後等到事件結束就清掉。

接下來是block存取到的local variable是個物件的型別，然後作copy 指令時

MyBlock genBlock() {
        int a = 3;
        NSMutableString * myString = [NSMutableString string];
        MyBlock inBlock = ^(int n) {
                NSLog(@"retain count of string %d",[myString retainCount]);
                return n*a;
        };
        return [inBlock copy] ;
}

結果會印出
retain count of string 2
這個結果和上面2.3提到的一樣，local variable被retain了
那再來試試2.4，在local variable前面加上__block

MyBlock genBlock() {
        int a = 3;
        __block NSMutableString * myString = [NSMutableString string];
        MyBlock inBlock = ^(int n) {
                NSLog(@"retain count of string %d",[myString retainCount]);
                return n*a;
        };
        return [inBlock copy] ;
}

執行的結果就是會
retain count of string 1

Block Copying注意事項

若是在Class method裡面作copying block動做的話
1. 在Block裡若是有直接存取到self，則self會被retain
2. 在Block裡若是取存到instance variable (無論直接或是從accessor)，則self會被retain
3. 取存到local variable所擁有的object時，這個object會被retain

讓我們來看一個自訂的Class

@interface MyObject : NSObject {
        NSString * title;
        void (^myLog) (NSString * deco);
}

-(void) logName;
@end

@implementation MyObject
-(id) initWithTitle:(NSString * ) newTitle{
        if(self = [super init]){
                title = newTitle;
                myLog = [^(NSString * deco) { NSLog(@"%@%@%@",deco, title, deco );} copy];
        }
        return self;
}

-(void) logName{

 myLog(@"==");
}

-(void ) dealloc{

        [myLog release];
        [title release];
        [super dealloc];
}
@end

在main 裡使用以下

 MyObject * mObj = [[MyObject alloc] initWithTitle:@"Car"];
 NSLog(@"retainCount of MyObject is  %d",[mObj retainCount]  );
 [mObj logName];
其執行的結果為
retainCount of MyObject is  2
==Car==
因為在MyObject的建構子裡myLog這個block pointer用了title這個instance variable然後就會retain self也就是MyObject的物件。
盡量不要這樣寫，會形成retain cycle，改善的方法是把建構子改爲這樣

-(id) initWithTitle:(NSString * ) newTitle{
        if(self = [super init]){
                title = newTitle;
                myLog = [^(NSString * deco) { NSLog(@"%@%@%@",deco, newTitle, deco );} copy];
        }
        return self;
}

在Block主體裡用newTitle這個變數而不是title。這樣self就不會被retain了。
最後談一個小陷井
void (^myLog) (void); 
BOOL result ;
if(result)
    myLog = ^ {NSLog(@"YES");};

else
    myLog = ^ {NSLog(@"NO");};

myLog();

這樣極可能就會當掉了，因為myLog 實體在if 或是else結束後就被清掉了。要記得。
要用copy來解決這個問題，但要記得release。

來自:http://www.cnblogs.com/pengyingh/articles/2343087.html

 

2、blocks的簡單學習

Ios4已經直接支持blocks，頗有必要學習一下。

在ios，blocks是對象，它封裝了一段代碼，這段代碼能夠在任什麼時候候執行。Blocks能夠做爲函數參數或者函數的返回值，而其自己又能夠帶輸入參數或返回值。它和傳統的函數指針很相似，可是有區別：blocks是inline的，而且它對局部變量是隻讀的。

Blocks的定義：

  int (^Multiply)(int, int) = ^(int num1, int num2) {return num1 * num2;};

定義了一個Multiply的blocks對象，它帶有兩個int參數，返回int。等式右邊就是blocks的具體實現，注意｛｝blocks體裏的；。

Blocks能夠訪問局部變量，可是不能修改。

int multiplier = 7;
int (^myBlock)(int) = ^(int num) {
     multiplier ++;//編譯報錯
     return num * multiplier;
};

 

若是要修改就要加關鍵字：__block

__block int multiplier = 7;
int (^myBlock)(int) = ^(int num) {
    multiplier ++;//這樣就能夠了
    return num * multiplier;
};

做爲函數的參數，blocks某種意義上替代了回調函數或者delegate。當函數調用了，假設某個事件觸發，這時blocks裏的內容就會運行。這樣有利於代碼的整合和閱讀，你不須要處處去實現委託方法了。

系統API中已經有不少支持blocks參數了

  • Completion handlers
  • Notification handlers
  • Error handlers
  • Enumeration
  • View animation and transitions
  • Sorting

例如：

[UIView animateWithDuration:(NSTimeInterval)duration animations:(void (^)())animations]

集合體中也能夠運用blocks。枚舉一個數組時咱們一般：

for (id obj in Array);

如今，

複製代碼 
NSString *area = @"Europe";
NSArray *timeZoneNames = [NSTimeZone knownTimeZoneNames];
NSMutableArray *areaArray = [NSMutableArray arrayWithCapacity:1];
NSIndexSet *areaIndexes = [timeZoneNames         indexesOfObjectsWithOptions:NSEnumerationConcurrent 
     passingTest:^(id obj, NSUInteger idx, BOOL *stop) {
     NSString  *tmpStr = (NSString *)obj;
     return [tmpStr hasPrefix:area];}];
 NSArray *tmpArray = [timeZoneNames objectsAtIndexes:areaIndexes];
[tmpArray enumerateObjectsWithOptions:NSEnumerationConcurrent|NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
[areaArray addObject:[obj substringFromIndex:[area length]+1]]; }];
NSLog(@"Cities in %@ time zone:%@", area, areaArray);
複製代碼

在blocks中obj就是數組中的每一個成員，咱們就能夠在blocks內對每一個對象進行處理。再好比：

NSMutableArray *mArray = [NSMutableArray arrayWithObjects:@"a",@"b",@"abc",nil];
NSMutableArray *mArrayCount = [NSMutableArray arrayWithCapacity:1];
[mArray enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock: ^(id obj,NSUInteger idx, BOOL *stop){
[mArrayCount addObject:[NSNumber numberWithInt:[obj length]]];}];
NSLog(@"%@",mArrayCount);

你會發現，這樣寫代碼更容易讀懂。

最後，看一個排序的例子：

複製代碼 
    NSArray *stringsArray = [NSArray arrayWithObjects:
                             @"string 1",
                             @"String 21",
                             @"string 12",
                             @"String 11",
                             @"String 02", nil];
    static NSStringCompareOptions comparisonOptions = NSCaseInsensitiveSearch | NSNumericSearch |
    NSWidthInsensitiveSearch | NSForcedOrderingSearch;
    NSLocale *currentLocale = [NSLocale currentLocale];
    NSComparator finderSort = ^(id string1, id string2) {
    NSRange string1Range = NSMakeRange(0, [string1 length]);
    return [string1 compare:string2 options:comparisonOptions range:string1Range locale:currentLocale];
    };
    NSLog(@"finderSort: %@", [stringsArray sortedArrayUsingComparator:finderSort]);
複製代碼

結果：finderSort: (

    "string 1",

    "String 02",

    "String 11",

    "string 12",

    "String 21"

)

原文出自http://www.cnblogs.com/scorpiozj/articles/1941006.html

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程