首先Swift语言中没有了Block内容，但是你可以通过调用OC文件使用，也可以使用Closure（闭包），实现Block或者Delegae同样反向传值或回调函数的效果，也可以解决函数指针的问题，两者有点类似，具体的使用方式，还需要大家进一步去研究，这里我只是简单实现一下闭包的效果，这个东西不太好理解，如果对Blocks比较熟的话，应该没问题

1.首先创建一个Swift项目，然后创建一个数组

let array1 = [22,33,99,88,44,11,55];

2.创建一个带有闭包结构的方法

写一个闭包方法，找到某一个范围内的数，当然这个方法也可以写在其他的类文件中，然后调用
    //------这个地方Closure类似于OC中的Blocks
    //func hasClosureMatch（方法名）(arr:[Int]（参数一：数组）, value:Int（参数二：数值）, closureE:(num:Int)->Bool（参数三：闭包方法）)-> Bool(返回类型)
    func hasClosureMatch1(arr:[Int], value:Int, closureE:(num:Int)->Bool) -> Bool{
        for item:Int in arr {
            //这里只是调用closureE闭包里的方法，将结果返回，不管如何实现
            //类似于OC中的Blocks，C当中的Function Pointer
            if (closureE(num: item))
            {
                return true;
            }
        }
        return false;
    }

3.调用闭包方法，找是否有比40大的数字
        let v1 = hasClosureMatch1(array1, value: 40) { (num) -> Bool in
            return num >= 40;
        }
        print("v1 此时的结果 is \(v1)");

4.我们可以看到，上面的方法是没有调用value这个参数的，所以有点多余，把方法改一下，用上value值

修改后的方法
    func hasClosureMatch2(arr:[Int], value:Int, closureE:(num:Int, value:Int)->Bool) -> Bool{
        for item:Int in arr {
            if (closureE(num: item,value: value))
            {
                return true;
            }
        }
        return false;
    }

然后使用脚本语言进行方法实现

//再写一个
        let v4 = hasClosureMatch2(array1, value: 30) {
            //这个地方，我们发现并没有写类型 (num, value) -> Bool in这句话，但是结果显示一样
            //这也是Swift运用了脚本语言的特性，$0表示num，$1表示value
            return $0 >= $1;
        }
        print("v4 此时的结果 is \(v4)");
        //通过方法的调用，我们可以知道闭包就是在两个对象之间相互通讯

//-------------这里记录了，解决闭包循环引用的问题
        /*
         如何解决闭包的循环引用, 同样有三种方式:
         1.使用weak修饰变量, 打破强引用, 因为使用weak修饰的变量有一次变成nil的机会
         2.使用[weak self] 修饰闭包原理跟__weak类似, 这样在闭包中使用self, 就是弱引用
         3.使用[unowned self ] 修饰闭包, 跟__unsafe_unretained类似, 不安全
         当闭包和捕获的实例总是互相引用时并且总是同时销毁时，将闭包内的捕获定义为无主引用。
         相反的，当捕获引用有时可能会是nil时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为nil。这使我们可以在闭包内检查它们是否存在。
         */
        //解决方式三: [unowned self]  跟 _unsafe_unretained 类似  不推荐使用
        loadData { [unowned self] (dataString) -> () in
            print("\(dataString) \(self.view)")
        }
    }
    
    func method2() {
        //解决方式二:  在swift中 有特殊的写法 ,跟OC __weak 相似  [weak self]
        loadData { [weak self] (dataString) -> () in
            
            //以后在闭包中中 使用self 都是若引用的
            print("\(dataString) \(self?.view)")
        }
    }
    func method1() {
        // 解决方式一: weak
        weak var weakSelf = self
        loadData { (dataString) -> () in
            print("\(dataString) \(weakSelf?.view)")
        }
    }

结果显示:

源码Demo：http://download.csdn.net/detail/hbblzjy/9620090

这里推荐一篇文章(两者进行了图片讲解，容易理解)：Swift与OC真正去理解Block解决循环引用的技巧