综合编程——不同语言里回调函数的实现方式

ゝ一世哀愁。 2023-01-16 04:59 101阅读 0赞

这篇文章算是我用来水的内容，主要也是其他科普性质的文章我还在收集整理资料中，但是给自己定下了一周出一篇的任务，所以想了想这周要写点啥，那就不妨整理一下最近的工作，其中发现比较常用的一个技术，就是回调函数。

简单说一下回调函数，它是一种常用的异步处理方法，好比你去图书馆找管理员出借某一本书，但是管理员查询库房，以及登记出借信息是需要花一定的时间，而此时你无事可做，然后你看到了摆放在柜台一边的杂志，然后你就兴致勃勃的阅读起来，过了不知道多久的时间，管理员通知你找到了书，并且办理好了出借手续，你于是愉快的拿走了书走出图书馆。

回调函数就相当于这一过程的处理方法，在IO编程中通常特别常见。而且基本上大多数语言都提供了实现回调函数的方法，以方便程序员自己在需要的时候去使用。

我直接贴代码吧，如果你有什么不懂的，可以在下面留言，我看见后会回复的。

### 文章目录 ###

*  C/C++语言的实现
 *  Objective C语言的实现
 *  Kotlin语言的实现
 *  Swift语言的实现
 *  Java语言的实现
 *  C\#语言的实现
 *  Javascript语言的实现
 *  Python语言的实现

# C/C++语言的实现 #

#include <iostream>
    
    typedef void(*call1)();
    typedef int(*call2)(int);
    
    void foo(call1 fun, call2 fun2) { 
        fun();
        int returns = fun2(30);
        std::cout << "returns " << returns << std::endl;
    }
    
    void bar1() { 
        std::cout << "callback 1" << std::endl;
    }
    
    int bar2(int arg) { 
        std::cout << "callback 2 with arg " << arg << std::endl;
        return 100;
    }
    
    int main() { 
        foo(bar1, bar2);
    }

# Objective C语言的实现 #

首先，由于Objective C可以直接调用C/CPP的代码，所以其中一种回调的实现方式，可以用C/CPP的形式实现。只不过有些细节，稍微有点不太一样罢了。

//
    // main.m
    // test
    //
    // Created by Orlando Chen on 2021/4/24.
    //
    
    #import <Foundation/Foundation.h>
    #import "callback.h"
    #import <stdio.h>
    
    void bar1() { 
        printf("callback 1\n");
    }
    
    int bar2(int arg) { 
        printf("callback 2 with arg %d\n", arg);
        return 100;
    }
    
    int main(int argc, const char * argv[]) { 
        @autoreleasepool { 
            CallbackClass *base = [[CallbackClass alloc] init];
            [base foo:bar1 withAnother:bar2];
        }
        return 0;
    }

Callback.h和Callback.m文件分别如下：

#ifndef callback_h
    #define callback_h
    
    typedef void(*callback1)(void);
    typedef int(*callback2)(int);
    
    @interface CallbackClass : NSObject
    
    -(void) foo: (callback1)func1 withAnother:(callback2)func2;
    
    @end
    
    
    #endif /* callback_h */
    
    
    
    #import <Foundation/Foundation.h>
    #import "callback.h"
    
    @implementation CallbackClass
    
    -(void) useCallback: (callback1)func1 withAnother:(callback2)func2 { 
        func1();
        func2(100);
    };
    
    @end

此外还可以用闭包的形式实现

.h /
    typedef BOOL(^objcBlock)(int);
    
    @interface CallbackClass : NSObject
    
    -(void) useBlock: (objcBlock)block;
    
    @end
    
    
     .m /
    #import <Foundation/Foundation.h>
    #import "callback.h"
    
    @implementation CallbackClass
    
    -(void) useBlock: (objcBlock)block { 
        BOOL val = block(100);
        NSLog(@"result: %@", val?@"YES":@"No");
    };
    
    @end

它的调用形式如下：

int main(int argc, const char * argv[]) { 
        @autoreleasepool { 
            CallbackClass *base = [[CallbackClass alloc] init];
            
            [base useBlock:^BOOL(int param) { 
                NSLog(@"input number is %d", param);
                return TRUE;
            }];
        }
        return 0;
    }

如果选择不使用Xcode，而是直接用GCC编译代码的话，需要在命令行中使用 -framework 命令，导入最常用的Objective C代码的Foundation框架，然后-o编译指定的二进制可执行文件：

gcc -framework Foundation -o xxx xxx.m

# Kotlin语言的实现 #

Kotlin是谷歌现在主推的一种语言，与Java和JavaScript有很好的亲和性，在后端开发中也经常用到的一种技术，它的回调函数实现方式又是这样的。

fun foo(callback:(Int)->Unit) { 
    	callback(100)
    } 
    
    fun main() { 
        foo(){  input ->
            println("input: " + input)
        }
        
        val bar:(numb: Int)->Unit = {  arg->
            println("input: " + arg)
        }
        
        foo(bar)
    }

你会发现这里使用了闭包的概念，然后在Swift中，你也能看到类似的概念

# Swift语言的实现 #

因为是苹果主推的和Objective C并行的语言，所以在习惯上和Objective C有很多相似的地方，当然设计理念上，和它最相似的还是Kotlin语言。

typealias CodeClosure1 = () -> Void
    typealias CodeClosure2 = (_ arg1: String, _ arg2: String) -> Void
    
    func foo(arg1: CodeClosure1, arg2: CodeClosure2) { 
        arg1()
        arg2("input_1", "intput_2")
    }
    
    func bar1() { 
        print("callback1")
    }
    
    func bar2(_ arg1: String, _ arg2: String) { 
        print(arg1, arg2)
    }
    
    foo(arg1: bar1, arg2: bar2)

# Java语言的实现 #

Java实现回调，其实特别繁琐，主要是需要定义一个接口类，然后通过接口进行处理，大概是这么一个思路：

public abstract class CallbackInterface { 
        public abstract void foo();
    }
    
    
    public class Callback { 
        public void function(CallbackInterface callback) { 
            callback.foo();
        }
    }
    
    
    public class MainClass { 
        public static void main(String args[]) { 
            Callback callback = new Callback();
            callback.function(new CallbackInterface() { 
                @Override
                public void foo() { 
                    System.out.println("hello world!");
                }
            });
        }
    }

好像在 Java 8 以后新增了Lambda表达式后，可以用类似闭包的方式实现回调，我估计实现这个功能不是特别复杂，不过我本身已经差不多快10年没碰Java了，所以具体的我就不太清楚。

# C\#语言的实现 #

C\# 可以通过和Java类似的接口类实现回调，也可以通过delegate方法，实现回调的功能。

using System;
    
    
    namespace CallbackDelegate
    { 
        class Program
        { 
            public delegate void callback(string url);
    
            public static void foo(callback func)
            { 
                func("hello world");
            }
    
            static void Main(string[] args)
            { 
                // using anonymous delegate
                foo(delegate(string str) { 
                    Console.WriteLine(str);
                });
    
                // using lambda
                foo((str) => Console.WriteLine(str));;
            }
        }
    }

# Javascript语言的实现 #

Javascript 实在很方便，基本上就是两三行代码的事，它的实现过程如下：

function doSomething(callback){ 
        if(typeof callback == "function") callback();
     } 
    
    doSomething(function(){ 
        console.log("Hello World");
     });

# Python语言的实现 #

Python语言是我比较喜欢用的编程语言，它也有自己独特的回调函数实现方式，而且相对来说，它的实现方式非常简单：

def bar(params):
    	print(params)
    
    def foo(fun):
    	fun(100)
    
    foo(bar)

如果这篇文章帮到了你，点个赞再走～祝好运！