SV中的回调（callback）明确了定义方法的规则，并且指定了一个方法用来回调已经定义的该方法；简而言之就是，被调用的方法就是回调方法（callback method），调用回调方法的方法称为回调勾（callback hook），回调方法一般是虚方法（dummy method），一般通过继承来进行覆盖重写.

我们来看回调方法是如何工作的：

 

在上面的图中，temp()方法就是回调勾，callback_1()和callback_2()方法是回调方法，也就是在用户调用temp()方法的时候，callback_1()和 callback_2()会自动调用；当然，用户也可以通过继承来覆盖回调方法；

在SV中最长用到的回调勾就是randomize()方法，它带有两个回调方法pre_randomize()和post_randomize()，这两个方法分别会在randomize()方法的前后执行.

UVM callback 

在UVM中，我们通过uvm_callback来派生出回调方法类，在这个类中可以定义多个回调方法，这些方法都是虚方法.如下：

class driver_callback extends uvm_callback;
   
  `uvm_component_utils(driver_callback)
   
  function new(string name, uvm_component parent);
    super.new(name);
  endfunction
   
  virtual task pre_drive; endtask//定义了两个虚方法作为回调方法
  virtual task post_drive; endtask
endclass

在上面的回调类driver_callback中定义了两个回调方法pre_drive和post_drive.

为了使用定义的回调类中的回调方法，首先要通过宏`uvm_register_cb在相应的组件中注册，然后再使用宏`uvm_do_callbacks 在组件的方法中调用回调方法，如下所示：

class driver extends uvm_component;
   
  `uvm_component_utils(driver)
  `uvm_register_cb(driver,driver_callback)//注册回调类
   
  function new(string name, uvm_component parent);
    super.new(name,parent);
  endfunction
   
  task run_phase(uvm_phase phase);
      `uvm_do_callbacks(driver,driver_callback,pre_drive());//调用类中的回调方法
       
      drive_pkt();
       
      `uvm_do_callbacks(driver,driver_callback,post_drive());
  endtask
   
  task drive_pkt();
    `uvm_info("DRIVER","Inside drive_pkt method",UVM_LOW);
  endtask
   
endclass

所以简单的test如下：

 

class environment extends uvm_env;
  driver driv;
  
  `uvm_component_utils(environment)
  
  function new(string name, uvm_component parent);
    super.new(name,parent);
  endfunction
  
  function void build_phase(uvm_phase phase);
    super.build_phase(phase);
    driv = driver::type_id::create("driv", this);
  endfunction
  
endclass

class basic_test extends uvm_test;
  environment env;
  
  `uvm_component_utils(basic_test)
  
  function new(string name = "basic_test", uvm_component parent=null);
    super.new(name,parent);
  endfunction
  
  function void build_phase(uvm_phase phase);
    super.build_phase(phase);
    env = environment::type_id::create("env", this);
  endfunction
endclass

//testbench
`include "driver_callback.sv"
`include "driver.sv"
`include "environment.sv"
`include "basic_test.sv"


program testbench_top;
  
  //---------------------------------------
  //calling test
  //---------------------------------------
  initial begin//{
    run_test();
  end //}
  
endprogram

这样我们就将回调方法加入到整个testbench中了，只不过上面的回调方法为空方法，什么操作也没有； 

还可以通过继承，覆盖上面定义的回调类中的回调方法，如下：

class user_callback extends driver_callback;
   
  `uvm_component_utils(user_callback)
   
  function new(string name, uvm_component parent);
    super.new(name,parent);
  endfunction
   
  task pre_drive;
    `uvm_info("USER_CALLBACK","Inside pre_drive method",UVM_LOW);
  endtask
   
  task post_drive;
    `uvm_info("USER_CALLBACK","Inside post_drive method",UVM_LOW);
  endtask
endclass

对于派生的回调类以及其中覆盖的回调方法，只需要通过调用add()方法将回调类添加到test中即可，如下：

 

class user_callback_test extends basic_test;
  user_callback callback_1;
   
  `uvm_component_utils(user_callback_test)
   
  function new(string name = "user_callback_test", uvm_component parent=null);
    super.new(name,parent);
  endfunction
   
  function void build_phase(uvm_phase phase);
    super.build_phase(phase);
    callback_1 = user_callback::type_id::create("callback_1", this);
     
    uvm_callbacks#(driver,driver_callback)::add(env.driv,callback_1);
  endfunction
endclass


对于uvm_callbacks#(T, CB)::add(t,cb)方法，其几个参数的含义如下：

T：表示回调类所在的组件名；

CB：表示回调类的类名；

t：表示回调类所在的组件的实例名，也就是组件的对象名；

cb：表示回调类的实例名，也就是对象名；

 导入上面的模块，如下：

`include "driver_callback.sv"
`include "driver.sv"
`include "environment.sv"
`include "basic_test.sv"

`include "user_callback.sv"
`include "user_callback_test.sv"

program testbench_top;
  
  //---------------------------------------
  //calling test
  //---------------------------------------
  initial begin//{
    run_test();
  end //}
  
endprogram

运行结果为：



总结上面在UVM中使用回调的方法步骤：

（1） 由uvm_callback派生出一个回调类A，这个类中包含若干个回调方法，且这些方法都是空的；

（2）将回调类A在对应的组件中通过宏`uvm_register_cb在相应的组件中注册，然后再使用宏`uvm_do_callbacks 在组件的方法中调用回调方法；

（3）由A派生出回调类的子类B，在该类中对回调方法进行覆盖重写，可以用户自定义回调方法的操作；

（4）在test中将B实例化，并将实例化后的对象通过uvm_callbacks#(T, CB)::add(t,cb)方法添加到组件中，这就实现了回调方法的具体操作；

前言

今天有个小兄弟问到了回调函数，讲解了一番以后觉得不能白讲，得把这些东西记下来，虽然很基础。。。

介绍

首先从英文介绍开始

A callback is a function that is passed as an argument to another function and is executed after its parent function has completed.

这里只是js里的解释。

开始

字面上理解下来就是，回调就是一个函数的调用过程。那么就从理解这个调用过程开始吧。函数a有一个参数，这个参数是个函数b，当函数a执行完以后执行函数b。那么这个过程就叫回调。

其实中文也很好理解：回调，回调，就是回头调用的意思。函数a的事先干完，回头再调用函数b。

举个现实的例子：约会结束后你送你女朋友回家，离别时，你肯定会说：“到家了给我发条信息，我很担心你。”对不，然后你女朋友回家以后还真给你发了条信息。小伙子，你有戏了。

其实这就是一个回调的过程。你留了个函数b（要求女朋友给你发条信息）给你女朋友，然后你女朋友回家，回家的动作是函数a。她必须先回到家以后，函数a的内容执行完了，再执行函数b，然后你就收到一条信息了。

这里必须清楚一点：函数b是你以参数形式传给函数a的，那么函数b就叫回调函数。

 也许有人有疑问了:一定要以参数形式传过去吗，我不可以直接在函数a里面调用函数b吗？确实可以。求解中。

解惑:如果你直接在函数a里调用的话，那么这个回调函数就被限制死了。但是使用函数做参数就有下面的好处：当你a(b)的时候函数b就成了回调函数，而你还可以a(c)这个时候，函数c就成了回调函数。如果你写成了function a(){...;b();}就失去了变量的灵活性。

上一段代码大家可以跑一下：

function a(callback)
{   
    alert("我是parent函数a！");
    alert("调用回调函数");
    callback();
}
function b(){
alert("我是回调函数b");
  
}
function c(){
alert("我是回调函数c");
  
}
  
function test()
{
    a(b);
   a(c);
}

根据代码示例加深理解

问题：

现在有函数如下定义：

function A(a,callback){

....

}

function B(){

....

}

则可以有如下调用

A(a,B);来实现回调。

现在我希望传给B一个参数c，即实现类似于:  A(a,B(c)); 的效果，应该如何实现？

function A(a,callback){ 
var b=callback; 
alert(a+b); 
} 
function B(c){ 
return (-c); 
} 
A(4,B(3))

根据jquery的ajax请求常见的场景再去写一个示例：

我包装了jQuery的ajax方法：

function doAjax(u,param,callback){
      $.ajax({
            type:'POST',
            url:u,
            data:param,
            success:callback
      });
}
 
function showAlert(data){
     alert(data);
}
 


比如这样调用 doAjax("url","id=1",showAlert);

$.ajax 在success后,会返回一个data到showAlert中,显示出来 ,没有问题.

可是,当我想多传一个参数给showAlert时怎么写?

写成doAjax("server.php","id=12&type=1",showAlert("hi",data))、或者把上面的success:callback 写成success:callback(msg,data)显然都不行,如之奈何?

其实很简单，很多方法都定义了回调函数,回调函数也是函数,就是说不管怎么传，只需要是个函数类型即可。写法如下：

方式1，
doAjax(参数1,参数2,function(request,opts){
         callback(request,opts,agrs);
 });
function callback(request,opts,args){
               
};
方式2，
var args=N;
doAjax(参数1,参数2,function(request,opts){
       var X=N;
       回调函数代码块..
       和以上几乎一样，看个人编码方式选择。     
});

再看一个从父函数传递给回调函数的示例

function e(m,n,Callback){  
    var d = m+n;  
    alert("一个从父函数e 产生的参数将要被传递给回调函数 ，这个参数是:"+d);  
     
    //这里才写你想调用的函数---参数要正确  
    Callback(d);   
}  
function callback(data){  
        alert("我是回调函数，我的名字叫:callback ,我接收到来自父函数的参数，参数是:"+data);   
}
e(1,2,callback)  

最后

感谢各位的阅读，如有问题麻烦及时指正出来。

 

背景：

			updateData(callback) {
				// 表示如果传入了callback，那么就调用callback(),否则不调用
				callback && callback()
			}

含义：

callback && callback() 表示如果传入了 callback ，那么就调用callback() 回调函数，否则不调用，类似于如下代码：

				if(callback){
					callback()
				}

 

/**
     * kotlin文件中 Java类使用Java的callback
     */
    //第一种写法
    JavaManager().setJavaCallback(JavaCallback {
        println(it)
    })
    //第一种方法取别名
    JavaManager().setJavaCallback(JavaCallback { aaa ->
        println(aaa)
    })
    //第二种写法
    JavaManager().setJavaCallback(object : JavaCallback {
        override fun show(info: String?) {
            println(info)
        }
    })
    //第二种写法的简写
    JavaManager().setJavaCallback { info -> println(info) }
    //第二种写法的再简单写法
    JavaManager().setJavaCallback { it -> println(it) }
    JavaManager().setJavaCallback { println(it) }

    //第三种写法，第一种写法的，先声明java callback
    val callback = JavaCallback {
        println(it)
    }
    JavaManager().setJavaCallback(callback)

    //第四中写法，第二种写法的，先声明kt callback写法
    val callback2 = object : JavaCallback {
        override fun show(info: String?) {
            println(info)
        }
    }
    JavaManager().setJavaCallback(callback2)

    /**
     * kotlin文件中 Java类使用Kt的callback
     */
    JavaManager().setKtCallback(object :KTCallback{
        override fun show(name: String) {
            println(name)
        }
    })

    val ktCallback1 = object :KTCallback{
        override fun show(name: String) {
            println(name)
        }
    }
    JavaManager().setKtCallback(ktCallback1)

    /**
     * kotlin文件中kotlin使用kotlin 的callback
     */
    //写法1,kotlin中只能使用这种方式，先object ： XXXCallback
    KtManager().setKtCallback(object : KTCallback {
        override fun show(name: String) {

        }
    })

    //写法1 ，先声明kt的callback
    val callback1 = object : KTCallback {
        override fun show(name: String) {
            println(name)
        }
    }
    KtManager().setKtCallback(callback1)

    //kotlin不能像Java一样的写法，kotlin的callback一定是object：XXCallback
    /*KtManager().setCallback(KTCallback {

    })*/

    /**
     * kotlin使用java 的callback
     */
    KtManager().setJavaCallback(JavaCallback {
        println(it)
    })

    KtManager().setJavaCallback(object : JavaCallback {
        override fun show(info: String?) {
            println(info)
        }
    })
    KtManager().setJavaCallback(JavaCallback { it -> println(it) })
    KtManager().setJavaCallback(JavaCallback { println(it) })