iOS之Block基本使用

最新推荐文章于 2024-05-04 16:18:58 发布
最新推荐文章于 2024-05-04 16:18:58 发布
阅读量484 收藏 1
点赞数
分类专栏： iOS 文章标签： ios
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IOSSHAN/article/details/104694985
版权

来个大活，今天来写下Block
老方法，我们用WWW（what\why\how）进行学习block。

block是什么？

block其实是一段代码块，其作用是保存一段代码块，在真正调用block的时候，才执行block里面的代码。

在程序里面输入inlineBlock，就可以得到block的声明与定义形式：

/**
 等号前面是block的声明；
 等号后面是block的定义；
 returnType:block声明的返回类型
 blockName:block的名字
 parameterTypes:block声明的参数类型
 parameters:block定义的参数类型及参数值
 statements:block代码块
 */
returnType(^blockName)(parameterTypes) = ^(parameters) {
    statements
};//末尾的；不能省略
block的定义常见的有四种形式：
  1. 无参数，无返回值
  2. 无参数，有返回值
  3. 有参数，无返回值
  4. 有参数，有返回值

我们具体看一下四种常见的形式以及各个形式的类型都长什么样：

- (void)viewDidLoad {
    [super viewDidLoad];
    /**
     1.无参数，无返回值
     定义的时候，没有返回值可以不写()及里面的内容
     其block类型是：void(^)(void)
     */
    void(^block1)(void) = ^{
        NSLog(@"block1");
    };
    
    /**
     2.1无参数，有返回值
     其block类型是：int(^)(void)
     */
    int(^block21)(void) = ^int{
        NSLog(@"block21");
        return 21;
    };
    
    /**
     2.2无参数，有返回值
     定义的时候，返回值可以省略
     其block类型是：int(^)(void)
     */
    int(^block22)(void) = ^{
        NSLog(@"block22");
        return 22;
    };
    
    /**
     3.有参数，无返回值
     有参数的情况下，声明的参数类型必须写
     有参数的情况下，定义的参数类型和参数名必须写
     其block类型是：void(^)(int)
     */
    void(^block3)(int) = ^(int a){
        NSLog(@"block3---%d", a);
    };
    
    /**
     4.有参数，有返回值
     定义的时候，返回值int可以省略
     其block类型是：int(^)(int)
     */
    int(^block4)(int) = ^int(int a){
        NSLog(@"block4---%d", a);
        return 4;
    };
    
    /**block的调用*/
    block1();
    int a = block21();
    NSLog(@"%d", a);
    int b = block22();
    NSLog(@"%d", b);
    block3(3);
    NSLog(@"%d", block4(4));
}

运行结果：

2020-03-06 15:23:18.860990+0800 test001[3456:921319] block1
2020-03-06 15:23:18.861075+0800 test001[3456:921319] block21
2020-03-06 15:23:18.861100+0800 test001[3456:921319] 21
2020-03-06 15:23:18.861122+0800 test001[3456:921319] block22
2020-03-06 15:23:18.861141+0800 test001[3456:921319] 22
2020-03-06 15:23:18.861161+0800 test001[3456:921319] block3---3
2020-03-06 15:23:18.861190+0800 test001[3456:921319] block4---4
2020-03-06 15:23:18.861211+0800 test001[3456:921319] 4

通过以上代码，我们可以得出一下结论：

block在定义的时候，参数为空的时候，可以将定义里面的()以及内容都省略
block在定义的时候，参数不为空的时候，参数值和参数名都不可以省略
block在定义的时候，返回值不管有或者没有都可以省略

block的声明

在interface里面声明block的时候，有两种方法：

typedef void(^BLOCK2)(void);

@interface ViewController ()
/**在ARC下，strong和copy修饰block都可以*/

/**直接声明，按照block的声明样式写就可以*/
@property (strong, nonatomic) void(^block1)(void);

/**将BLOCK2进行定义类型，然后在定义变量block2*/
@property (strong, nonatomic) BLOCK2 block2;
@end
block使用场景-反向传值

我们知道，两个对象的传值有两种：正向传值和反向传值。
其中，正向传值可以直接将值赋值过去完成传值动作。
而反向传值，一般有三种方法：代理、block和通知，然后，我们介绍一下block的反向传值。

/**
ViewController
*/
#import "ViewController.h"
#import "TestViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    TestViewController *testVc = [[TestViewController alloc] init];
    testVc.myBlock = ^(int value) {
        NSLog(@"value = %d", value);
    };
    
    [self presentViewController:testVc animated:YES completion:nil];
}

/**TestViewController*/
@interface TestViewController : UIViewController
@property (strong, nonatomic) void(^myBlock)(int value);
@end

#import "TestViewController.h"
@interface TestViewController ()
@end

@implementation TestViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor redColor];
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    if (self.myBlock) {
        self.myBlock(100);
    }
}
@end

两次点击后，打印如下：
2020-03-06 17:49:31.981064+0800 test001[3497:936661] value = 100

第一次点击屏幕，会呼出TestViewController，
第二次点击屏幕，会调用myBlock(100)，其实它是做了如下操作：

在TestViewController中myBlock(100);的调用等价于：
if (self.myBlock) {
        value = 100;
        ^(int value) {
            NSLog(@"value = %d", value);
        }();
    }
block在MRC下的内存存储地址

首先我们要明确一点的是，block其实是一个对象，那么，block这个对象，存储在什么区呢？
我们知道，内存分为五大区：
栈stack(系统) | 堆malloc、heap(手动) | 静态区(全局区) | 常量区 | 方法区(程序代码区)

block存储在哪个区呢？

这个，需要根据项目是MRC或者ARC做具体的判断。

在讲MRC或者ARC前，我们先了解一些基本知识点：

ARC管理原则：
只要一个对象没有被强指针引用，该对象就会被销毁。
默认局部变量对象都是使用强指针引用，并存放在堆里面。

MRC管理原则：
MRC没有strong、weak修饰指针，局部变量对象做基本数据类型处理，基本数据类型统一放在栈区。

MRC常用知识点:
MRC给属性赋值的时候，一定要用set方法，不能直接访问下划线成员属性。因为，在MRC下的set方法会做一些其他事情，而直接用_成员属性就不会做这些事情。

在MRC下，@property (retain, nonatomic) NSString *name;该句代码的set方法的实现转换为下面代码：
- (void)setName:(NSString *)name
{
    if (_name != name) {
        [_name release];
        _name = [name retain];
    }
}

首先，我们看下在MRC环境下block的存储位置
将Build Setting下的Objective-C Automatic Reference Counting设置为NO即是在MRC环境下
在这里插入图片描述

void(^block)(void) = ^{
    NSLog(@"调用了block");
};
NSLog(@"%@", block);
结果：<__NSGlobalBlock__: 0x1006a0080>

int a = 3;//局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSStackBlock__: 0x16f971328>

__block int a = 3;
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSStackBlock__: 0x16f935310>

static int a = 3;//static修饰局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSGlobalBlock__: 0x1008ec080>

int global = 5;
- (void)viewDidLoad {
    [super viewDidLoad];
    void(^block)(void) = ^{
        NSLog(@"调用了block, global = %d", global);
    };
    NSLog(@"%@", block);
}
结果:<__NSGlobalBlock__: 0x100934080>

static int global = 5;
- (void)viewDidLoad {
    [super viewDidLoad];
    void(^block)(void) = ^{
        NSLog(@"调用了block, global = %d", global);
    };
    NSLog(@"%@", block);
}
结果:<__NSGlobalBlock__: 0x100be8080>

__block int global = 5;//__block修饰全局变量，报错
总结：

在MRC下

  1. block本身是存储在全局区；
  2. 如果block引用了外部局部变量，或者引用了被__block修饰的外部局部变量，则存放在栈区。

被__block修饰的block还是局部变量；
被static修饰的局部变量，会延长生命周期，使得周期与整个应用程序有关; 只会分配一次内存；程序一运行，就会分配内存，而不是运行到那才分配。
被static修饰的全部变量，作用域会被修改，只能在当前文件下使用。

我们知道，在MRC中我们使用copy修饰block，能否使用retain修饰呢？

@interface ViewController ()
@property (retain, nonatomic) void(^block)(void);
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    int a = 3;
    void(^block)(void) = ^{
        NSLog(@"调用了block, a = %d", a);
    };
    self.block = block;
    NSLog(@"%@", self.block);
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    self.block();
}

结果:<__NSStackBlock__: 0x16fd6d328>
触摸点击崩溃，报EXC_BAD_INSTRUCTION错误

通过代码可以看出，如果使用retain修饰block，则self.block存放在栈区。栈是由系统自动控制，则在代码块{}执行完毕后，self.block将被回收，而在touchesBegan方法中还调用self.block，报野指针错误。
然后，我们看下使用copy修饰block:

@property (copy, nonatomic) void(^block)(void);

结果:<__NSMallocBlock__: 0x28237b2d0>
触摸点击打印:调用了block, a = 3

(其他代码与上面相同)

这是因为，使用copy修饰block，self.block存储在堆区，而堆内存区域是由程序员自己控制的，因此，在viewDidLoad方法执行完毕后，self.block的内存地址并没有被回收，因此在touchesBegan方法中调用self.block();没有问题。

总结：

在MRC下
block属性必须使用copy，而不能使用retain修饰

现在我们看一下在ARC环境下，block的一些知识点

void(^block)(void) = ^{
    NSLog(@"调用了block");
};
NSLog(@"%@", block);
结果：<__NSGlobalBlock__: 0x100b5c098>

int a = 3;//局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSMallocBlock__: 0x28343ea60>

__block int a = 3;
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSMallocBlock__: 0x2805b11d0>

static int a = 3;//static修饰局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSGlobalBlock__: 0x100f38098>

int global = 5;
- (void)viewDidLoad {
    [super viewDidLoad];
    void(^block)(void) = ^{
        NSLog(@"调用了block, global = %d", global);
    };
    NSLog(@"%@", block);
}
结果:<__NSGlobalBlock__: 0x100564098>

static int global = 5;
- (void)viewDidLoad {
    [super viewDidLoad];
    void(^block)(void) = ^{
        NSLog(@"调用了block, global = %d", global);
    };
    NSLog(@"%@", block);
}
结果:<__NSGlobalBlock__: 0x100b54098>

__block int global = 5;//__block修饰全局变量，报错
总结：

在ARC下

  1. block本身是存储在全局区；
  2. 如果block引用了外部局部变量，或者引用了被__block修饰的外部局部变量，则存放在堆区。

被__block修饰的block还是局部变量；
被static修饰的局部变量，改变局部变量的声明周期。

在ARC中使用copy修饰block

@interface ViewController ()
@property (copy, nonatomic) void(^block)(void);
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    int a = 3;
    void(^block)(void) = ^{
        NSLog(@"调用了block, a = %d", a);
    };
    self.block = block;
    NSLog(@"%@", self.block);
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    self.block();
}

结果:<__NSMallocBlock__: 0x28065c0f0>
触摸点击打印:调用了block, a = 3

在ARC中使用strong修饰block

@property (strong, nonatomic) void(^block)(void);

结果:<__NSMallocBlock__: 0x2802b5ef0>
触摸点击打印:调用了block, a = 3

在ARC中使用weak修饰block

@property (weak, nonatomic) void(^block)(void);

结果: <__NSMallocBlock__: 0x282cdb3c0>
触摸点击崩溃，报EXC_BAD_INSTRUCTION错误

在ARC中使用assign修饰block

@property (assign, nonatomic) void(^block)(void);

结果: <__NSMallocBlock__: 0x2823d3240>
触摸点击崩溃，报EXC_BAD_INSTRUCTION错误
总结：

在ARC下
block属性可以使用copy或者strong修饰，不能使用weak或者assign修饰
通过ARC管理机制我们知道，如果没有任何强指针引用，则对象会被清空。所以，用weak或者assign没有对block进行强指针引用，因此，在viewDidLoad方法执行完毕后，block就被清空，再次使用self.block会造成野指针错误。

在ARC下，string和block用copy还是strong?

其实两个都可以使用，但是还是建议使用strong。
string使用copy修饰，只是浅拷贝，并没有建立新的对象，所以，strong就可以满足。
block使用copy修饰，也没有新的对象创建，所以，strong就可以满足。
而，strong和copy不一样的地方在于，使用copy修饰的属性，在set方法中，会有一些列的copy操作，而strong并不需要，从性能上说，strong高一些。

Block的循环引用注意事项

block会对里面所有的外部变量对象进行强引用。

int a = 3;//局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
a = 4;
block();
结果：调用了block, a = 3

static int a = 3;//static修饰局部变量
结果：调用了block, a = 4

__block int a = 3;//__block修饰局部变量
结果：调用了block, a = 4

int a = 3;//全局变量
结果：调用了block, a = 4

static int a = 3;//static修饰全局变量
结果：调用了block, a = 4
总结
  1. block调用局部变量是值传递；
  2. 使用static或者__block修饰的局部变量是指针传递；
  3. 全局变量和使用static修饰的全局变量，block没有捕获全局变量，因此，在block内部可以修改全局变量

上面的总结第三点其实是不对的，为什么呢？

为什么是这样的结果呢？？？

想了解更多的小伙伴，可以看这两篇文章，为你答疑解惑。
iOS之Block本质(一)
iOS之Block本质(二)

block作为参数

block作为参数使用，在UIView的动画里面很常见，例如：

[UIView animateWithDuration:3.0 animations:^{   
}];

其方法是：
+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations

(void (^)(void))是一个参数为void，返回值为void的block类型，animations是block变量名。
可以看出，block作为参数时，使用 (block类型)block变量名 的形式定义。

我们什么时候让block作为参数使用呢？

这个可以想下，我们什么时候使用动画。
在3.0内，执行animations里面的内容，什么时候执行这个方法，是由UIView调用animateWithDuration方法决定的，至于里面要执行的什么动画，则是一个block，是一个代码块，是可以由程序员自己定义自己写的。

换言之，block代码块里面的内容是程序员保存的一端代码，写完并没有立马执行。什么时候执行呢？是由UIView调用animateWithDuration方法执行的。

举一个例子:

@interface Calculator : NSObject
@property (assign, nonatomic) int result;
//定义一个方法，参数类型是int(^)(int)，参数名是block
- (void)jisuan:(int(^)(int))block;
@end

@implementation Calculator
//方法的实现
- (void)jisuan:(int(^)(int result))block
{
    if (block) {
        //调用block，并将block调用的结果赋值给result
        _result = block(_result);
    }
}
@end

Calculator *calculator = [[Calculator alloc] init];
[calculator jisuan:^int(int result) {//block的参数名不可省略，block的返回值类型可以省略（第一个int）
    result += 5;
    result *= 2;
    return result;
}];

NSLog(@"%d", calculator.result);
结果：10

这个例子中，jisuan:方法里面的参数是一个block，当调用这个方法的时候，调用的block，执行block里面的代码。

block作为返回值

block作为返回值的经典代表就是Masonry三方框架，基本上整个框架都是使用的Block作为返回值。

拿一个简单的Masonry布局代码进行分析:

[thirdView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.left.right.equalTo(bottomView);
        make.top.equalTo(_secondView.mas_bottom);
        make.height.equalTo(@70);
}];

make.left.right.equalTo(bottomView);
代码中，从前往后执行，首先是make.left，该语法是一个get方法，自动寻找是否有left方法，并返回对象本身（类型MASConstraintMaker），make.left.right以及make.left.right.equalTo都是返回对象本身（类型MASConstraintMaker），则最后是(MASConstraintMaker类型)(bottomView)。其实iMASConstraintMaker类型是一个block类型，最后的调用是对该block进行了调用，参数是bottomView。

来个简单的block作为返回值的例子:

- (void)viewDidLoad {
    [super viewDidLoad];
    self.test();
}
- (void(^)(void))test{
    //方法一：定义一个变量名为block的blocke，并返回
    void(^block)(void) = ^{
        NSLog(@"调用test函数返回block");
    };
    return block;
    
    //方法二：直接返回一个block
    return ^{
        NSLog(@"调用test函数返回block");
    };
}

结果:调用test函数返回block

接下来，我们做一个简单的连续进行加法计算的例子

@interface Calculator : NSObject
@property (assign, nonatomic) int result;
//定义一个方法，返回值是其本身
- (Calculator *)jisuanAdd:(int)value;
@end

@implementation Calculator
//方法的实现
- (Calculator *)jisuanAdd:(int)value
{
    self.result += value;
    return self;
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    Calculator *calculator = [[Calculator alloc] init];
    [[[calculator jisuanAdd:2] jisuanAdd:5] jisuanAdd:3];
    NSLog(@"%d", calculator.result);
}

结果:10

通过上面的例子，我们可以实现连续进行加法的计算，我们对例子进行改进，使其可以跟Masonry一样，进行链式编程。

@interface Calculator : NSObject
@property (assign, nonatomic) int result;
//定义一个方法，返回值是一个block，该block是一个参数为int，返回值为Calculator的类型
- (Calculator *(^)(int))jisuanAdd;
@end

@implementation Calculator
//方法的实现
- (Calculator *(^)(int))jisuanAdd
{
	//返回一个block
    return ^(int value){
        self.result += value;
        return self;
    };
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    Calculator *calculator = [[Calculator alloc] init];
    calculator.jisuanAdd(2).jisuanAdd(5).jisuanAdd(3);
    NSLog(@"%d", calculator.result);
}

结果:10
AsiaSun.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
iOS中使用block块的用法
whuizhou的专栏
07-02 1251
block块语法和c中的函数指针类似。
iOS高级理论： Block介绍和使用
长沙火山
02-25 2187
在 iOS 开发中，Block 是一种闭包（Closure）的概念，可以将一段代码块作为一个对象进行传递和存储，类似于函数指针。Block 可以捕获其定义时所在范围内的变量，并在需要的时候执行这段代码块。Block 的使用可以方便地实现回调、异步操作、事件处理等功能。
IOS 开发 - block 使用详解
最新发布
wyz670083956的博客
05-04 513
IOS 开发 - block 使用详解
iOS中的block详解
孤独流浪的博客
02-12 691
1.block的写法 returnType(^blockName)(parameterTypes) = ^(parameters) { statements }; returnType 返回值类型，可以为void，不能为空 blockName 名称 parameterTypes 参数类型，可以为void或空 parameters 形式参数，可以为void或空 ...
iOS中Block的用法，举例，解析与底层原理（这可能是最详细的Block解析）
weixin_34306446的博客
07-16 236
1. 前言 Block：带有自动变量（局部变量）的匿名函数。它是C语言的扩充功能。之所以是拓展，是因为C语言不允许存在这样匿名函数。 1.1 匿名函数 匿名函数是指不带函数名称函数。C语言中，函数是怎样的呢？类似这样： int func(int count); 调用的时候： int result = func(10); func就是它的函数名。也可以通过指...
ios Block详细用法
Eduora_meimei的专栏
04-07 1709
ios4.0系统已开始支持block，在编程过程中，blocks被Obj-C看成是对象，它封装了一段代码，这段代码可以在任何时候执行。Blocks可以作为函数参数或者函数的返回值，而其本身又可以带输入参数或返回值。它和传统的函数指针很类似，但是有区别：blocks是inline的，并且它对局部变量是只读的。 下面是理论部分： 　　1、block的定义 复制代码 1 // 声明和实现写在一起，就像变量的声明实现 int a = 10; 2 int (^aBlock)(int, int)
iOS中Block的回调使用和解析详解
01-20
本篇文章将深入讲解如何在iOS中使用Block进行回调，并通过一个具体的例子来阐述其工作原理和常见问题。 在iOS开发中，我们经常会遇到这样一个场景：从一个界面（如AViewController）跳转到另一个界面（如...
iOS Block 的使用, 包括传值, 基本用法
08-29
本篇文章将深入探讨iOS Block的基本用法以及如何传递值。 ### 1. Block的基本结构 Block 是一个对象，它可以捕获并存储在其定义时所在上下文中的变量值。Block的语法如下： ```objc ^(参数列表)返回值类型 { // ...
iOS Block使用教程
05-18
在iOS开发中，Block是一种强大的编程工具，它允许我们在代码中定义匿名函数或者闭包，使得函数能够作为参数传递，也可以直接在其他函数内部定义和使用。熟练掌握Block的使用对于提升iOS应用的代码质量、可读性和效率...
IOS Block的使用
05-11
在iOS开发中，Block是一种强大的、灵活的编程构造，它允许你将代码块封装起来并在需要的时候执行。...在实际项目中，Block常用于异步操作、遍历数组、事件处理等场景，是iOS开发者的必备技能之一。
ios block学习总结demo
02-21
Block是iOS和Mac OS开发中的一个...通过以上内容，我们对iOS开发中的Block有了全面的理解，掌握了它的基本用法、内存管理、与GCD的结合以及常见最佳实践。在实际项目中灵活运用Block，能显著提高代码的可读性和效率。
ios-Block的用法.zip
07-11
块（block）是添加到C、Objective-C和C 的语言级功能。它允许你创建不同的代码段，可以像传值一样传递给方法或函数。块是Objective-C对象，也就是说它们可以被添加到像NSArray和NSDictionary这样的集合中，其还具有从封闭范围捕获值的能力。源码github.com/pro648/BasicDemos-iOS/tree/master/Block 块是一个独立的代码片段，始终存在于另一个编程结构的范围内，如在一个方法的主体。块可以捕获块外变量的值，但外部对于块内发生的事情一无所知。详细介绍 github.com/pro648/tips/wiki/Block的用法 在块内不能直接修改局部变量的值，如需修改需用__block修饰局部变量。 源码地址： 详细介绍：
Block作为参数时的使用
a447780100的博客
01-21 306
Block作为参数使用，常见于各框架之中，比如在封装一个类时，当做什么事情由外界去决定，什么时候调用由自己的类决定时，这时候就需要将block作为参数使用。 下面我们模仿AFNetworking的manager，以自定义一个简单的工具类CalculatorManager为例： 1.CalculatorManager.h文件 #import <Foundation/Foundati...
记一个ios手机的css兼容性问题
木豪末的博客
10-20 1455
1.问题代码 .scroll-bar > span { display: inline-block;/*inline样式不能使用动画*/ animation: scroll 12s linear infinite; } .scroll-bar > span:after { position: absolute; left: 100%; content: attr(data-text); margin-left: 10%; } @keyframe
iOS Block语法 基础介绍1 浅谈(void(^MyBlock)()=^) oc block
王虎的博客
09-17 2702
以前我们知道的数据类型如Double,枚举,结构体,指针,OC数据类型,id,但是还有种数据类型,叫做Block.接下来我想介绍一下Block, 这种数据类型,Block是苹果官方推荐让我们使用的,为什么了,因为Block的运行效率特别高,特别好用,在iOS的开发中你会发现,到出都是Block,为什么这么多,最主要的一个原因就是他好用,运行效率高.
iOS底层 Block的本质与使用
Rey的技术博客
03-01 740
1、block的基本概念及使用 Block是一种特殊的数据结构，它可以保存一段代码，等到需要的时候进行调用执行这段代码，常用于GCD、动画、排序及各类回调。 Block变量的声明格式为: 返回值类型(^Block名字)(参数列表); //声明一个没有传参和返回值的block void(^myBlock1)(void) ; //声明一个有两个传参没有返回值的block 形参变量名称可以省略,只留有变量类型即可 void(^myBlock2)(NSString *name,int age); //声明
iOS block的概念及基本使用
weixin_45958328的博客
12-28 681
(2).block类型的变量中专门存储一段代码,这段代码可以有参数,可以有返回值.存储的代码段必须要指定代码是否有参数,是否有返回值.一旦指定,这个block就只能存储这样类型的代码,(1),block是一个数据类型,跟int double float一样都是数据类型.所以我们是可以创建一个block类型的变量.原理:写一段符合block要求的代码段,存储到block变量中。返回值类型 (^block变量的名称)(参数列表)1)block是一个数据类型,函数是一个函数。2)block可以作为函数的参数。
IOS中 Block简介与用法（一）
热门推荐
集结号
03-14 11万+
Block简介： Block的实际行为和Function很像，最大的差别是在可以存取同一个Scope的变量值。Block实体形式如下： ^(传入参数列){行为主体}; Block实体开头是“^”，接着是由小括号所包起来的参数列（比如 int a, int b, int c），行为主体由大括号包起来，专有名字叫做block literal。行为主体可以用return回传值，类型会被compil
iOS开发：深入理解Block编程
本文档主要介绍了iOS开发中的Block编程技术，包括Block的声明、创建、定义以及基本的使用规则。Block是Apple在Cocoa和Cocoa Touch框架中引入的一种强大的闭包机制，它允许开发者在代码中定义可重用的代码块，并能够...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值