[function] 일반 영어로 콜백을 설명하는 방법? 다른 함수에서 하나의 함수를 호출하는 것과 다른 점은 무엇입니까?


Answers

나는이 죽은자를 간단하게 지키려고 노력할 것이다. "콜백"은 첫 번째 함수를 매개 변수로 사용하는 다른 함수에 의해 호출되는 함수입니다. 많은 경우, "콜백"은 무언가 가 발생할 때 호출되는 함수입니다. 프로그래머가 말하면 "이벤트"라고 할 수 있습니다.

이 시나리오를 생각해보십시오. 며칠 후에 패키지를 기대하고 있습니다. 패키지는 이웃 사람에게 선물입니다. 따라서 일단 패키지를 얻으면 이웃에게 가져 오기를 원합니다. 너는 마을을 벗어 났고, 그래서 너는 배우자를위한 지시를 남긴다.

패키지를 가져 가서 이웃 사람들에게 가져 오라고 말할 수 있습니다. 배우자가 컴퓨터처럼 어리석은 사람이라면 그들은 문 앞에 앉아서 패키지가 올 때까지 기다릴 것입니다. (아무런 일도하지 않아야합니다.) 그리고 나서 한 번 그들은 이웃에게 그것을 가져다 줄 것입니다. 그러나 더 좋은 방법이 있습니다. 귀하의 배우자에게 그들이 패키지를 한 번 받고 이웃 사람들에게 가져와야한다고 말하십시오. 그런 다음 패키지를받을 때까지 정상적으로 생활 할 수 있습니다.

이 예에서 패키지 수신은 "이벤트"이며이를 이웃에게 가져 오는 것은 "콜백"입니다. 귀하의 배우자는 패키지가 도착할 때만 패키지를 가져 오는 지침을 "실행"합니다. 훨씬 낫다!

이런 종류의 사고는 일상 생활에서는 분명하지만 컴퓨터에는 같은 종류의 상식이 없습니다. 프로그래머가 파일에 일반적으로 쓰는 방법을 고려하십시오.

fileObject = open(file)
# now that we have WAITED for the file to open, we can write to it
fileObject.write("We are writing to the file.")
# now we can continue doing the other, totally unrelated things our program does

여기서 우리는 파일을 쓰기 전에 파일을 열어 기다립니다. 이렇게하면 실행 흐름이 "차단"되고 프로그램에서 수행해야 할 다른 작업을 수행 할 수 없습니다! 대신이 작업을 수행 할 수 있다면 어떨까요?

# we pass writeToFile (A CALLBACK FUNCTION!) to the open function
fileObject = open(file, writeToFile)
# execution continues flowing -- we don't wait for the file to be opened
# ONCE the file is opened we write to it, but while we wait WE CAN DO OTHER THINGS!

우리는 몇 가지 언어와 프레임 워크로이 작업을 수행합니다. 그것은 꽤 멋지다! 이런 종류의 사고로 실제 연습을하려면 Node.js 를 확인하십시오.

Question

일반 영어로 콜백을 설명하는 방법? 호출 함수에서 일부 컨텍스트를 취하는 다른 함수에서 하나의 함수를 호출하는 것과 다른 점은 무엇입니까? 초능력 프로그래머에게 어떻게 그들의 힘을 설명 할 수 있습니까?




당신이 나에게 장기간에 걸친 작업을 해 줄 것이라고 가정 해 봅시다 : 당신이 만나는 처음 다섯 명의 독특한 사람들의 이름을 얻으십시오. 인구 밀도가 낮은 지역에 거주하는 경우 며칠이 걸릴 수 있습니다. 내가 뛰어 다니는 동안 당신은 손에 앉아서 정말로 관심이 없습니다. "목록을 얻었 으면 나를 전화해서 내게 다시 읽어주세요. 여기 숫자가 있습니다."

당신은 나에게 콜백 참조를주었습니다. 콜백 참조 (callback reference)는 추가 처리를 넘겨주기 위해 실행해야하는 함수입니다.

JavaScript에서는 다음과 같이 보일 수 있습니다.

var lottoNumbers = [];
var callback = function(theNames) {
  for (var i=0; i<theNames.length; i++) {
    lottoNumbers.push(theNames[i].length);
  }
};

db.executeQuery("SELECT name " +
                "FROM tblEveryOneInTheWholeWorld " +
                "ORDER BY proximity DESC " +
                "LIMIT 5", callback);

while (lottoNumbers.length < 5) {
  playGolf();
}
playLotto(lottoNumbers);

이것은 아마도 많은면에서 개선 될 수 있습니다. 예를 들어 두 번째 콜백을 제공 할 수 있습니다. 한 시간 이상 걸릴 경우 빨간색 전화를 걸어 시간 초과 결과를 응답자에게 알려줍니다.




“In computer programming, a callback is a reference to executable code, or a piece of executable code, that is passed as an argument to other code. This allows a lower-level software layer to call a subroutine (or function) defined in a higher-level layer.” - Wikipedia

Callback in C using Function Pointer

In C, callback is implemented using Function Pointer. Function Pointer - as the name suggests, is a pointer to a function.

For example, int (*ptrFunc) ();

Here, ptrFunc is a pointer to a function that takes no arguments and returns an integer. DO NOT forget to put in the parenthesis, otherwise the compiler will assume that ptrFunc is a normal function name, which takes nothing and returns a pointer to an integer.

Here is some code to demonstrate the function pointer.

#include<stdio.h>
int func(int, int);
int main(void)
{
    int result1,result2;
    /* declaring a pointer to a function which takes
       two int arguments and returns an integer as result */
    int (*ptrFunc)(int,int);

    /* assigning ptrFunc to func's address */                    
    ptrFunc=func;

    /* calling func() through explicit dereference */
    result1 = (*ptrFunc)(10,20);

    /* calling func() through implicit dereference */        
    result2 = ptrFunc(10,20);            
    printf("result1 = %d result2 = %d\n",result1,result2);
    return 0;
}

int func(int x, int y)
{
    return x+y;
}

Now let us try to understand the concept of Callback in C using function pointer.

The complete program has three files: callback.c, reg_callback.h and reg_callback.c.

/* callback.c */
#include<stdio.h>
#include"reg_callback.h"

/* callback function definition goes here */
void my_callback(void)
{
    printf("inside my_callback\n");
}

int main(void)
{
    /* initialize function pointer to
    my_callback */
    callback ptr_my_callback=my_callback;                        
    printf("This is a program demonstrating function callback\n");
    /* register our callback function */
    register_callback(ptr_my_callback);                          
    printf("back inside main program\n");
    return 0;
}

/* reg_callback.h */
typedef void (*callback)(void);
void register_callback(callback ptr_reg_callback);


/* reg_callback.c */
#include<stdio.h>
#include"reg_callback.h"

/* registration goes here */
void register_callback(callback ptr_reg_callback)
{
    printf("inside register_callback\n");
    /* calling our callback function my_callback */
    (*ptr_reg_callback)();                               
}

If we run this program, the output will be

This is a program demonstrating function callback inside register_callback inside my_callback back inside main program

The higher layer function calls a lower layer function as a normal call and the callback mechanism allows the lower layer function to call the higher layer function through a pointer to a callback function.

Callback in Java Using Interface

Java does not have the concept of function pointer It implements Callback mechanism through its Interface mechanism Here instead of a function pointer, we declare an Interface having a method which will be called when the callee finishes its task

Let me demonstrate it through an example:

The Callback Interface

public interface Callback
{
    public void notify(Result result);
}

The Caller or the Higher Level Class

public Class Caller implements Callback
{
Callee ce = new Callee(this); //pass self to the callee

//Other functionality
//Call the Asynctask
ce.doAsynctask();

public void notify(Result result){
//Got the result after the callee has finished the task
//Can do whatever i want with the result
}
}

The Callee or the lower layer function

public Class Callee {
Callback cb;
Callee(Callback cb){
this.cb = cb;
}

doAsynctask(){
//do the long running task
//get the result
cb.notify(result);//after the task is completed, notify the caller
}
}

Callback Using EventListener pattern

  • 목록 항목

This pattern is used to notify 0 to n numbers of Observers/Listeners that a particular task has finished

  • 목록 항목

The difference between Callback mechanism and EventListener/Observer mechanism is that in callback, the callee notifies the single caller, whereas in Eventlisener/Observer, the callee can notify anyone who is interested in that event (the notification may go to some other parts of the application which has not triggered the task)

Let me explain it through an example.

The Event Interface

public interface Events {

public void clickEvent();
public void longClickEvent();
}

Class Widget

package com.som_itsolutions.training.java.exampleeventlistener;

import java.util.ArrayList;
import java.util.Iterator;

public class Widget implements Events{

    ArrayList<OnClickEventListener> mClickEventListener = new ArrayList<OnClickEventListener>(); 
    ArrayList<OnLongClickEventListener> mLongClickEventListener = new ArrayList<OnLongClickEventListener>();

    @Override
    public void clickEvent() {
        // TODO Auto-generated method stub
        Iterator<OnClickEventListener> it = mClickEventListener.iterator();
                while(it.hasNext()){
                    OnClickEventListener li = it.next();
                    li.onClick(this);
                }   
    }
    @Override
    public void longClickEvent() {
        // TODO Auto-generated method stub
        Iterator<OnLongClickEventListener> it = mLongClickEventListener.iterator();
        while(it.hasNext()){
            OnLongClickEventListener li = it.next();
            li.onLongClick(this);
        }

    }

    public interface OnClickEventListener
    {
        public void onClick (Widget source);
    }

    public interface OnLongClickEventListener
    {
        public void onLongClick (Widget source);
    }

    public void setOnClickEventListner(OnClickEventListener li){
        mClickEventListener.add(li);
    }
    public void setOnLongClickEventListner(OnLongClickEventListener li){
        mLongClickEventListener.add(li);
    }
}

Class Button

public class Button extends Widget{
private String mButtonText;
public Button (){
} 
public String getButtonText() {
return mButtonText;
}
public void setButtonText(String buttonText) {
this.mButtonText = buttonText;
}
}

Class Checkbox

public class CheckBox extends Widget{
private boolean checked;
public CheckBox() {
checked = false;
}
public boolean isChecked(){
return (checked == true);
}
public void setCheck(boolean checked){
this.checked = checked;
}
}

Activity Class

package com.som_itsolutions.training.java.exampleeventlistener;

public class Activity implements Widget.OnClickEventListener
{
    public Button mButton;
    public CheckBox mCheckBox;
    private static Activity mActivityHandler;
    public static Activity getActivityHandle(){
        return mActivityHandler;
    }
    public Activity ()
    {
        mActivityHandler = this;
        mButton = new Button();
        mButton.setOnClickEventListner(this);
        mCheckBox = new CheckBox();
        mCheckBox.setOnClickEventListner(this);
        } 
    public void onClick (Widget source)
    {
        if(source == mButton){
            mButton.setButtonText("Thank you for clicking me...");
            System.out.println(((Button) mButton).getButtonText());
        }
        if(source == mCheckBox){
            if(mCheckBox.isChecked()==false){
                mCheckBox.setCheck(true);
                System.out.println("The checkbox is checked...");
            }
            else{
                mCheckBox.setCheck(false);
                System.out.println("The checkbox is not checked...");
            }       
        }
    }
    public void doSomeWork(Widget source){
        source.clickEvent();
    }   
}

Other Class

public class OtherClass implements Widget.OnClickEventListener{
Button mButton;
public OtherClass(){
mButton = Activity.getActivityHandle().mButton;
mButton.setOnClickEventListner(this);//interested in the click event                        //of the button
}
@Override
public void onClick(Widget source) {
if(source == mButton){
System.out.println("Other Class has also received the event notification...");
}
}

Main Class

public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Activity a = new Activity();
OtherClass o = new OtherClass();
a.doSomeWork(a.mButton);
a.doSomeWork(a.mCheckBox);
}
}

As you can see from the above code, that we have an interface called events which basically lists all the events that may happen for our application. The Widget class is the base class for all the UI components like Button, Checkbox. These UI components are the objects that actually receive the events from the framework code. Widget class implements the Events interface and also it has two nested interfaces namely OnClickEventListener & OnLongClickEventListener

These two interfaces are responsible for listening to events that may occur on the Widget derived UI components like Button or Checkbox. So if we compare this example with the earlier Callback example using Java Interface, these two interfaces work as the Callback interface. So the higher level code (Here Activity) implements these two interfaces. And whenever an event occurs to a widget, the higher level code (or the method of these interfaces implemented in the higher level code, which is here Activity) will be called.

Now let me discuss the basic difference between Callback and Eventlistener pattern. As we have mentioned that using Callback, the Callee can notify only a single Caller. But in the case of EventListener pattern, any other part or class of the Application can register for the events that may occur on the Button or Checkbox. The example of this kind of class is the OtherClass. If you see the code of the OtherClass, you will find that it has registered itself as a listener to the ClickEvent that may occur in the Button defined in the Activity. Interesting part is that, besides the Activity ( the Caller), this OtherClass will also be notified whenever the click event occurs on the Button.




나는 너무 많은 지적인 사람들이 "콜백"이라는 단어가 두 가지 모순 된 방식으로 사용되었다는 사실을 강조하지 못하는 것을보고 깜짝 놀랐다.

두 가지 방법 모두 추가 기능 (익명 또는 명명 된 함수 정의)을 기존 함수에 전달하여 함수를 사용자 정의하는 작업입니다. 즉.

customizableFunc(customFunctionality)

사용자 정의 기능을 코드 블록에 간단하게 꽂으면 기능을 사용자 정의 할 수 있습니다.

    customizableFucn(customFunctionality) {
      var data = doSomthing();
      customFunctionality(data);
      ...
    }

이런 종류의 주입 기능이 종종 "콜백 (callback)"이라고 불리지 만, 그에 대한 우연한 것은 없습니다. 가장 명백한 예는 배열을 수정하기 위해 배열의 각 요소에 적용 할 인수로 사용자 지정 함수를 제공하는 forEach 메서드입니다.

그러나 이것은 AJAX 나 node.js와 같은 비동기 프로그래밍을 위한 "콜백 (callback)"기능을 사용하거나 단순히 마우스 클릭과 같은 사용자 상호 작용 이벤트에 기능을 할당하는 것과는 근본적으로 다릅니다. 이 경우 전체적인 아이디어는 사용자 지정 기능을 실행하기 전에 우발적 인 이벤트가 발생할 때까지 기다리는 것입니다. 이것은 사용자 상호 작용의 경우 분명하지만 디스크에서 파일을 읽는 것처럼 시간이 걸릴 수있는 I / O (입력 / 출력) 프로세스에서도 중요합니다. 여기서 "콜백"이라는 용어가 가장 분명한 의미를 갖습니다. 일단 I / O 프로세스가 시작되면 ( 비동기식 프로그램은 파일을 디스크 나 서버에서 읽어 와서 http 요청으로부터 데이터를 반환하도록 요구하는 것처럼) 비동기식 프로그램은 끝내기 위해 기다리지 않습니다. 다음에 예약 된 작업을 진행하고, 읽기 파일 또는 http 요청이 완료되었다는 (또는 실패한) 통보를 받고 사용자 지정 기능에서 데이터를 사용할 수있는 경우에만 사용자 지정 기능으로 응답 할 수 있습니다. 그것은 전화로 비즈니스를 호출하고 "콜백"번호를 남겨 두는 것과 같습니다. 따라서 누군가가 다시 연락 할 수있을 때 전화를 걸 수 있습니다. 얼마나 오랫동안 알고 있고 다른 업무에 참석할 수없는 사람들을위한 전화에 매달리는 것보다 낫습니다.

비동기 적 사용은 본질적으로 원하는 이벤트 (예 : I / O 프로세스의 완료)를 청취하는 수단을 필요로하므로 사용자 정의 콜백 기능이 실행될 때만 발생합니다. 분명한 AJAX 예제에서 데이터가 실제로 서버에서 도착하면 "콜백"함수가 트리거되어 해당 데이터를 사용하여 DOM을 수정하고 따라서 해당 범위까지 브라우저 창을 다시 그립니다.

요약하자면. 어떤 사람들은 "콜백 (callback)"이라는 단어를 사용하여 기존 기능에 인수로 주입 할 수있는 모든 종류의 사용자 지정 기능을 나타냅니다. 하지만 최소한 저에게 단어를 가장 적절히 사용하는 것은 주입 된 "콜백"기능이 비동기 적으로 사용되는 곳입니다. 통보 대기중인 이벤트가 발생할 때만 실행됩니다.




실행할 코드가 있습니다. 일반적으로 앱을 호출 할 때 앱을 계속하기 전에 끝내기를 기다리고 있습니다 (이로 인해 앱이 회색으로 바뀌거나 커서가 돌아갈 수 있습니다).

다른 방법은이 코드를 병렬로 실행하고 자신의 작업을 수행하는 것입니다. 하지만 원래 코드가 호출 한 코드의 응답에 따라 다른 작업을 수행해야하는 경우 어떻게해야할까요? 글쎄,이 경우 당신은 그것이 끝나면 당신이 전화를 원하는 코드의 이름 / 위치를 전달할 수 있습니다. 이것은 "콜백"입니다.

일반 코드 : 정보 요청 -> 프로세스 정보 -> 처리 결과 처리 -> 계속해서 다른 작업을 수행하십시오.

콜백 : 정보 요청 -> 프로세스 정보 -> 다른 일을 계속하십시오. 그리고 나중에 어떤 점에서 - 처리 결과를 다루십시오.




Think of a method as giving a task to a coworker. A simple task might be the following:

Solve these equations:
x + 2 = y
2 * x = 3 * y

Your coworker diligently does the math and gives you the following result:

x = -6
y = -4

But your coworker has a problem, he doesn't always understand notations, such as ^ , but he does understand them by their description. Such as exponent . Everytime he finds one of these you get back the following:

I don't understand "^"

This requires you to rewrite your entire instruction set again after explaining what the character means to your coworker, and he doesn't always remember in between questions. And he has difficulty remembering your tips as well, such as just ask me. He always follows your written directions as best he can however.

You think of a solution, you just add the following to all of your instructions:

If you have any questions about symbols, call me at extension 1234 and I will tell you its name.

Now whenever he has a problem he calls you and asks, rather than giving you a bad response and making the process restart.




In plain english a callback is a promise. Joe, Jane, David and Samantha share a carpool to work. Joe is driving today. Jane, David and Samantha have a couple of options:

  1. Check the window every 5 minutes to see if Joe is out
  2. Keep doing their thing until Joe rings the door bell.

Option 1: This is more like a polling example where Jane would be stuck in a "loop" checking if Joe is outside. Jane can't do anything else in the mean time.

Option 2: This is the callback example. Jane tells Joe to ring her doorbell when he's outside. She gives him a "function" to ring the door bell. Joe does not need to know how the door bell works or where it is, he just needs to call that function ie ring the door bell when he's there.

Callbacks are driven by "events". In this example the "event" is Joe's arrival. In Ajax for example events can be "success" or "failure" of the asynchronous request and each can have the same or different callbacks.

In terms of JavaScript applications and callbacks. We also need to understand "closures" and application context. What "this" refers to can easily confuse JavaScript developers. In this example within each person's "ring_the_door_bell()" method/callback there might be some other methods that each person need to do based on their morning routine ex. "turn_off_the_tv()". We would want "this" to refer to the "Jane" object or the "David" object so that each can setup whatever else they need done before Joe picks them up. This is where setting up the callback with Joe requires parodying the method so that "this" refers to the right object.

희망이 도움이됩니다!




What Is a Callback Function?

The simple answer to this first question is that a callback function is a function that is called through a function pointer. If you pass the pointer (address) of a function as an argument to another, when that pointer is used to call the function it points to it is said that a call back is made.

Callback function is hard to trace, but sometimes it is very useful. Especially when you are designing libraries. Callback function is like asking your user to gives you a function name, and you will call that function under certain condition.

For example, you write a callback timer. It allows you to specified the duration and what function to call, and the function will be callback accordingly. “Run myfunction() every 10 seconds for 5 times”

Or you can create a function directory, passing a list of function name and ask the library to callback accordingly. “Callback success() if success, callback fail() if failed.”

Lets look at a simple function pointer example

void cbfunc()
{
     printf("called");
}

 int main ()
 {
                   /* function pointer */ 
      void (*callback)(void); 
                   /* point to your callback function */ 
      callback=(void *)cbfunc; 
                   /* perform callback */
      callback();
      return 0; 
}

How to pass argument to callback function?

Observered that function pointer to implement callback takes in void *, which indicates that it can takes in any type of variable including structure. Therefore you can pass in multiple arguments by structure.

typedef struct myst
{
     int a;
     char b[10];
}myst;

void cbfunc(myst *mt) 
{
     fprintf(stdout,"called %d %s.",mt->a,mt->b); 
}

int main() 
{
       /* func pointer */
    void (*callback)(void *);       //param
     myst m;
     m.a=10;
     strcpy(m.b,"123");       
     callback = (void*)cbfunc;    /* point to callback function */
     callback(&m);                /* perform callback and pass in the param */
     return 0;   
}



콜백은 전화 시스템 측면에서 가장 쉽게 설명됩니다. 함수 호출은 누군가를 전화로 호출하고, 질문을하고, 답을 얻고, 전화를 끊는 것과 유사합니다. 콜백을 추가하면 비유가 변경되므로 질문을 한 후에도 이름과 번호를 알려줌으로써 응답 할 수 있습니다. - Paul Jakubik, "C ++의 콜백 구현"




This of it in terms of downloading a webpage:

Your program runs on a cellphone and is requesting the webpage http://www.google.com . If you write your program synchronously, the function you write to download the data will be running continuously until all the data is download. This means your UI will not refresh and will basically appear frozen. If you write your program using callbacks, you request the data and say "execute this function when you've finished." This allows the UI to still allow user interaction while the file is downloading. Once the webpage has finished downloading, your result function (callback) is called and you can handle the data.

Basically, it allows you to request something and continue executing while waiting for the result. Once the result comes back to you via a callback function, you can pick up the operation where it left off.




설명 할 두 가지 점이 있습니다. 하나는 콜백이 작동하는 방법 (컨텍스트에 대한 지식 없이도 호출 할 수있는 함수를 전달하는 방법)이고 다른 하나는 이벤트를 비동기 적으로 처리하는 방법입니다.

소포가 도착할 때까지 기다리는 비유는 다른 대답에 사용되었습니다. 둘 다 설명하는 것이 좋습니다. 컴퓨터 프로그램에서 소포를 기대하도록 컴퓨터에 지시합니다. 보통, 그것은 도착할 때까지 소포가 도착할 때까지 지금 거기 앉아서 기다릴 것입니다 (그리고 아무 것도하지 않습니다). 인간에게는 이것은 어리석은 것처럼 들리지만, 더 이상의 조치가 없으면 이것은 컴퓨터에 전적으로 자연스러운 일입니다.

이제 콜백은 현관 문에 종이 될 것입니다. 귀하는 소포 서비스를 제공하여 소포 도착 사실을 통보 할 수 있습니다. 소지자가 집에 어디에 있더라도 (또는 심지어 종소리가 어떻게 작동하는지) 알 필요도 없습니다. (예를 들어, 일부 "종"은 실제로 전화를 겁니다.) 언제든지 컨텍스트에서 "호출"할 수있는 "콜백 기능"을 제공 했으므로 이제 현관에 앉아서 멈출 수 있습니다. 이벤트 "(소포 도착) 시간이 될 때마다.




함수를 작성하기 위해 10 제곱을 반환하는 함수가 필요하다고 상상해보십시오.

function tenSquared() {return 10*10;}

나중에 다른 함수를 작성할 수 있도록 9 제곱이 필요합니다.

function nineSquared() {return 9*9;}

결국이 모든 것을 일반 함수로 바꿉니다.

function square(x) {return x*x;}

콜백에도 똑같은 생각이 적용됩니다. 당신은 무언가를하고 doA를 호출 할 수있는 함수를 가지고 있습니다 :

function computeA(){
    ...
    doA(result);
}

나중에 똑같은 함수가 doB를 호출하기를 원한다. 대신에 전체 함수를 복사 할 수있다.

function computeB(){
    ...
    doB(result);
}

또는 콜백 함수를 변수로 전달할 수 있으며 함수를 한 번만 가져야합니다.

function compute(callback){
    ...
    callback(result);
}

그런 다음 compute (doA) 및 compute (doB)를 호출하면됩니다.

코드 단순화 이외에도 비동기 코드를 사용하면 완료되면 임의의 함수를 호출하여 완료되었음을 알 수 있습니다. 전화에서 다른 사람에게 전화를 걸고 콜백 번호를 남길 때와 비슷합니다.




프로그래머가 스테이플러를 필요로하기 때문에 사무용품 공급 부서로 가서 요청 양식을 작성한 후 사무소에 서서 사무원이 스테이플러의 창고를 둘러 볼 때까지 기다릴 수 있습니다 (예 : 블로킹 기능 호출 ) 아니면 다른 일을하십시오.

일반적으로 시간이 걸리므로 조이는 요청 양식과 함께 스테이플러가 픽업 준비가되면 전화를 요구하는 메모를 남기므로 책상 위에 낮잠을자는 것과 같은 다른 일을 할 수 있습니다.




Plain and simple: A callback is a function that you give to another function, so that it can call it.

Usually it is called when some operation is completed. Since you create the callback before giving it to the other function, you can initialize it with context information from the call site. That is why it is named a call*back* - the first function calls back into the context from where it was called.




은유 적 설명 :

나는 친구에게 배달되기를 원하는 소포를 가지고 있으며, 내 친구가 그것을 언제 받는지 알고 싶다.

그래서 나는 소포를 우체국에 가져 가서 배달하도록 요청합니다. 친구가 소포를받을 때를 알고 싶다면 두 가지 옵션이 있습니다.

(a) 배달 될 때까지 우체국에서 기다릴 수 있습니다.

(b) 배달 될 때 나는 이메일을받을 것이다.

옵션 (b)는 콜백과 유사합니다.






Related