¿Cómo explicar las devoluciones de llamada en inglés sencillo? ¿En qué se diferencian de llamar a una función desde otra función?

Voy a tratar de mantener esto simple. Una "devolución de llamada" es cualquier función que es llamada por otra función que toma la primera función como parámetro. Muchas veces, un "callback" es una función que se llama cuando sucede algo. Ese algo puede ser llamado un "evento" en lenguaje programador.

Imagine este escenario: usted está esperando un paquete en un par de días. El paquete es un regalo para su vecino. Por lo tanto, una vez que usted consigue el paquete, usted quiere trajo a los vecinos. Usted está fuera de la ciudad, por lo que deja instrucciones para su cónyuge.

Puedes decirles que tomen el paquete y se lo traigan a los vecinos. Si su cónyuge era tan estúpido como una computadora, se sentaban en la puerta y esperaban el paquete hasta que llegara (SIN HACER NADA MÁS) y luego, una vez que llegó, lo llevaban a los vecinos. Pero hay una manera mejor. Dígale a su cónyuge que UNA vez que reciba el paquete, debe traerlo vecino. Entonces, pueden seguir la vida normalmente HASTA que reciban el paquete.

En nuestro ejemplo, la recepción del paquete es el "evento" y el traerlo a los vecinos es el "callback". Su cónyuge "ejecuta" sus instrucciones para traer el paquete solo cuando llegue el paquete. Mucho mejor!

Este tipo de pensamiento es obvio en la vida diaria, pero las computadoras no tienen el mismo tipo de sentido común. Considere cómo los programadores normalmente escriben a un archivo:

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

Aquí, esperamos a que se abra el archivo, antes de escribirlo. Esto "bloquea" el flujo de ejecución, y nuestro programa no puede hacer ninguna de las otras cosas que podría tener que hacer! Y si pudiéramos hacer esto en su lugar:

# 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!

Resulta que hacemos esto con algunos lenguajes y frameworks. ¡Es genial! Echa un vistazo al nodo .js para obtener alguna práctica real con este tipo de pensamiento.

¿Cómo explicar las devoluciones de llamada en inglés sencillo?

En inglés simple, una función de devolución de llamada es como un Worker que "llama" a su Manager cuando ha completado una Tarea .

¿En qué se diferencian de llamar a una función desde otra función tomando algún contexto de la función de llamada?

Es cierto que está llamando a una función desde otra función, pero la clave es que la devolución de llamada es tratado como un Objeto, por lo que puede cambiar qué Función llamar en función del estado del sistema (como el Patrón de Diseño de la Estrategia).

¿Cómo se puede explicar su poder a un programador novato?

El poder de las devoluciones de llamada se puede ver fácilmente en sitios web de estilo AJAX que necesitan extraer datos de un servidor. Descargar los nuevos datos puede llevar algún tiempo. Sin devoluciones de llamada, toda su interfaz de usuario se "congelaría" mientras descarga los nuevos datos, o tendría que actualice toda la página en lugar de solo parte de ella. Con una devolución de llamada, puede insertar una imagen "ahora cargando" y reemplazarla con los nuevos datos una vez que se cargue.

Algún código sin devolución de llamada:

function grabAndFreeze() {
    showNowLoading(true);
    var jsondata = getData('http://yourserver.com/data/messages.json');
    /* User Interface 'freezes' while getting data */
    processData(jsondata);
    showNowLoading(false);
    do_other_stuff(); // not called until data fully downloaded
}

function processData(jsondata) { // do something with the data
   var count = jsondata.results ? jsondata.results.length : 0;
   $('#counter_messages').text(['Fetched', count, 'new items'].join(' '));
   $('#results_messages').html(jsondata.results || '(no new messages)');
}

Con Devolución de llamada:

Aquí hay un ejemplo con una devolución de llamada, usando getJSON de jQuery:

function processDataCB(jsondata) { // callback: update UI with results
   showNowLoading(false);
   var count = jsondata.results ? jsondata.results.length : 0;
   $('#counter_messages').text(['Fetched', count, 'new items'].join(' '));
   $('#results_messages').html(jsondata.results || '(no new messages)');
}

function grabAndGo() { // and don't freeze
    showNowLoading(true);
    $('#results_messages').html(now_loading_image);
    $.getJSON("http://yourserver.com/data/messages.json", processDataCB);
    /* Call processDataCB when data is downloaded, no frozen User Interface! */
    do_other_stuff(); // called immediately
}

Con Cierre:

A menudo la devolución de llamada necesita acceder a state desde la función que llama usando un closure, que es como el Worker que necesita obtenga información del Administrador antes de que pueda completar su Tarea . Para crear closure, puede insertar la función para que vea los datos en el contexto de llamada:

/* Grab messages, chat users, etc by changing dtable. Run callback cb when done.*/
function grab(dtable, cb) { 
    if (null == dtable) { dtable = "messages"; }
    var uiElem = "_" + dtable;
    showNowLoading(true, dtable);
    $('#results' + uiElem).html(now_loading_image);
    $.getJSON("http://yourserver.com/user/"+dtable+".json", cb || function (jsondata) {
       // Using a closure: can "see" dtable argument and uiElem variables above.
       var count = jsondata.results ? jsondata.results.length : 0, 
           counterMsg = ['Fetched', count, 'new', dtable].join(' '),
           // no new chatters/messages/etc
           defaultResultsMsg = ['(no new ', dtable, ')'].join(''); 
       showNowLoading(false, dtable);
       $('#counter' + uiElem).text(counterMsg);
       $('#results'+ uiElem).html(jsondata.results || defaultResultsMsg);
    });
    /* User Interface calls cb when data is downloaded */

    do_other_stuff(); // called immediately
}

Uso:

// update results_chatters when chatters.json data is downloaded:
grab("chatters"); 
// update results_messages when messages.json data is downloaded
grab("messages"); 
// call myCallback(jsondata) when "history.json" data is loaded:
grab("history", myCallback); 

Cierre

Finalmente, aquí está una definición de closure de Douglas Crockford:

Las funciones se pueden definir dentro de otras funciones. La función interna tiene acceso a los vars y parámetros de la función externa. Si una referencia a un la función interna sobrevive (por ejemplo, como una función de devolución de llamada), los vars de la función externa también sobreviven.

Véase también:

• http://javascript.crockford.com/survey.html
• http://api.jquery.com/jQuery.when /
• http://api.jquery.com/jQuery.getJSON /
• http://github.com/josher19/jQuery-Parse

Me sorprende ver a tantas personas inteligentes que no enfatizan la realidad de que la palabra "callback" se ha usado de dos maneras inconsistentes.

Ambas formas implican la personalización de una función pasando funcionalidad adicional (una definición de función, anónima o nombrada) a una función existente. IE.

customizableFunc(customFunctionality)

Si la funcionalidad personalizada está simplemente conectada al bloque de código, ha personalizado la función, así.

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

Aunque este tipo de la funcionalidad inyectada a menudo se llama una" devolución de llamada", no hay nada contingente en ella. Un ejemplo muy obvio es el método forEach en el que se proporciona una función personalizada como un argumento que se aplicará a cada elemento en un array para modificar el array.

Pero esto es fundamentalmente distinto del uso de funciones "callback" para programación asíncrona, como en AJAX o node.js o simplemente en asignar funcionalidad a eventos de interacción del usuario (como clics del ratón). En este caso, la idea es esperar a que ocurra un evento contingente antes de ejecutar la funcionalidad personalizada. Esto es obvio en el caso de la interacción del usuario, pero también es importante en los procesos de e/s (entrada/salida) que pueden tomar tiempo, como la lectura de archivos desde el disco. Aquí es donde el término "callback" tiene el sentido más obvio. Una vez que se inicia un proceso de e/s (como pedir que se lea un archivo desde el disco o un servidor para devolver datos desde una solicitud http), un programa asíncrono no espera alrededor para que termine. Puede seguir adelante con cualquier tarea programada a continuación, y solo responder con la funcionalidad personalizada después de que se le haya notificado que el archivo de lectura o la solicitud http se ha completado (o que ha fallado) y que los datos están disponibles para la funcionalidad personalizada. Es como llamar a una empresa por teléfono y dejar tu número de "devolución de llamada", para que puedan llamarte cuando alguien esté disponible para responderte. Eso es mejor que esperar en la línea por quién sabe cuánto tiempo y no poder atender otros asuntos.

El uso asíncrono implica inherentemente algunos medios de escuchar el evento deseado (por ejemplo, la finalización del proceso de e/s) para que, cuando ocurra (y solo cuando ocurra), se ejecute la funcionalidad personalizada de "devolución de llamada". En el ejemplo obvio de AJAX, cuando los datos realmente llegan desde el servidor, se activa la función "callback" para usar esos datos para modificar el DOM y, por lo tanto, volver a dibujar la ventana del navegador hasta ese punto.

A recapitulación. Algunas personas usan la palabra "callback" para referirse a cualquier tipo de funcionalidad personalizada que se puede inyectar en una función existente como argumento. Pero, al menos para mí, el uso más apropiado de la palabra es donde la función "callback" inyectada se usa asincrónicamente to para ejecutarse solo cuando ocurre un evento del que está esperando ser notificado.

En términos de no programador, una devolución de llamada es un relleno del espacio en blanco en un programa.

Un elemento común en muchos formularios en papel es "Persona a quien llamar en caso de emergencia". Hay una línea en blanco allí. Escribes el nombre y el número de teléfono de alguien. Si se produce una emergencia, se llama a esa persona.

• Todos reciben el mismo formulario en blanco, pero
• Todos pueden escribir un número de contacto de emergencia diferente.

Esto es clave. Usted no cambia el formulario (el código, por lo general, de otra persona). Sin embargo, puede completar los datos que faltan (su número).

Ejemplo 1:

Las devoluciones de llamada se utilizan como métodos personalizados, posiblemente para agregar/cambiar el comportamiento de un programa. Por ejemplo, tome un código C que realiza una función, pero no sabe cómo imprimir la salida. Todo lo que puede hacer es hacer una cuerda. Cuando intenta averiguar qué hacer con la cadena, ve una línea en blanco. Pero, el programador te dio el espacio en blanco para ¡escribe tu devolución de llamada!

En este ejemplo, no se utiliza un lápiz para rellenar un espacio en blanco en una hoja de papel, se utiliza la función set_print_callback(the_callback).

• La variable en blanco en el módulo / código es la línea en blanco,
• set_print_callback es el lápiz,
• y the_callback es su información que está rellenando.

Ahora ha rellenado esta línea en blanco en el programa. Siempre que necesite imprimir la salida, mirará esa línea en blanco, y seguirá las instrucciones allí (i. e. llame a la función que puso allí.) Prácticamente, esto permite la posibilidad de imprimir a la pantalla, a un archivo de registro, a una impresora, a través de una conexión de red, o cualquier combinación de los mismos. Has llenado el espacio en blanco con lo que quieres hacer.

Ejemplo 2:

Cuando le digan que necesita llamar a un número de emergencia, vaya y lea lo que está escrito en el formulario de papel, y luego llame al número que leyó. Si esa línea está en blanco no se hará nada.

Programación Gui funciona de la misma manera. Cuando se hace clic en un botón, el programa tiene que averiguar qué hacer a continuación. Va y busca la devolución de llamada. Esta devolución de llamada pasa a estar en un espacio en blanco etiquetado"Esto es lo que haces cuando se hace clic en Button1"

La mayoría de los IDE rellenarán automáticamente el espacio en blanco por usted (escriba el método básico) cuando se lo pida (por ejemplo, button1_clicked). Sin embargo, ese espacio en blanco puede tener cualquier método, por favor. Puedes llamar al método run_computations o butter_the_biscuits siempre y cuando pongas eso el nombre de callback en el espacio en blanco apropiado. Puede poner "555-555-1212" en el espacio en blanco del número de emergencia. No tiene mucho sentido, pero es permisible.

Nota final: ¿Esa línea en blanco que estás rellenando con la devolución de llamada? Se puede borrar y reescribir a voluntad. (si usted debe o no es otra cuestión, pero que es una parte de su poder)

Johny el programador necesita una grapadora, por lo que baja al departamento de suministros de oficina y pide una, después de llenar el formulario de solicitud puede quedarse allí y esperar a que el empleado vaya a buscar la grapadora en el almacén (como una llamada a la función de bloqueo) o hacer otra cosa mientras tanto.

Dado que esto generalmente toma tiempo, johny pone una nota junto con el formulario de solicitud pidiéndoles que lo llamen cuando la grapadora esté lista para recoger, para que mientras tanto pueda hacer otra cosa como dormir la siesta en su escritorio.

Siempre es mejor empezar con un ejemplo :).

Supongamos que tiene dos módulos A y B.

Desea que el módulo A sea notificado cuando ocurre algún evento/condición en el módulo B. Sin embargo, el módulo B no tiene idea acerca de su módulo A. Todo lo que sabe es una dirección a una función en particular (del módulo A) a través de un puntero de función que le proporciona el módulo A.

Así que todo lo que B tiene que hacer ahora, es "callback" en el módulo A cuando un evento/condición particular ocurre por usando el puntero de la función. A puede hacer más procesamiento dentro de la función de devolución de llamada.

*) Una clara ventaja aquí es que está abstrayendo todo sobre el módulo A del módulo B. El módulo B no tiene que preocuparse por quién / qué es el módulo A.

Imagine que necesita una función que devuelve 10 al cuadrado para escribir una función:

function tenSquared() {return 10*10;}

Más tarde necesitas 9 al cuadrado para escribir otra función:

function nineSquared() {return 9*9;}

Eventualmente reemplazará todos estos con una función genérica:

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

Exactamente el mismo pensamiento se aplica a las devoluciones de llamada. Usted tiene una función que hace algo y cuando se hace llamadas doA:

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

Más tarde, si desea que la misma función llame a doB, en lugar de eso, podría duplicar todo función:

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

O puede pasar una función de devolución de llamada como una variable y solo tiene que tener la función una vez:

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

Entonces solo tienes que llamar compute(doA) y compute(doB).

Más allá de simplificar el código, permite que el código asíncrono le haga saber que se ha completado llamando a su función arbitraria al completarse, similar a cuando llama a alguien por teléfono y deja un número de devolución de llamada.

Si se siente enfermo, vaya al médico. Te examina y determina que necesitas algún medicamento. Él prescribe algunos medicamentos y llama la receta a su farmacia local. Vete a casa. Más tarde, su farmacia llama para informarle que su receta está lista. Ve a recogerlo.

Hay dos puntos a explicar, uno es cómo funciona una devolución de llamada (pasando una función que se puede llamar sin ningún conocimiento de su contexto), el otro para qué se utiliza (manejo de eventos asincrónicamente).

La analogía de esperar a que llegue un paquete que ha sido utilizada por otras respuestas es buena para explicar ambas. En un programa de computadora, le dirías a la computadora que espere un paquete. Normalmente, ahora se sentaría allí y esperaría (y no haría nada más) hasta que el paquete llega, posiblemente indefinidamente si nunca llega. Para los humanos, esto suena tonto, pero sin más medidas, esto es totalmente natural para una computadora.

Ahora la devolución de llamada sería la campana en su puerta principal. Usted proporciona al servicio de paquetería una forma de notificarle la llegada del paquete sin que ellos tengan que saber dónde (incluso si) se encuentra en la casa, o cómo funciona la campana. (Por ejemplo, algunas "campanas" en realidad envían una llamada telefónica.) Porque proporcionó una "función de devolución de llamada" que puede ser " llamado "en cualquier momento, fuera de contexto, ahora puede dejar de sentarse en el porche delantero y" manejar el evento " (de la llegada del paquete) cuando sea el momento.

Imagina que una amiga está saliendo de tu casa, y le dices "Llámame cuando llegues a casa para que sepa que has llegado a salvo"; eso es (literalmente) un call back. Eso es lo que es una función de devolución de llamada, independientemente del idioma. Usted quiere algún procedimiento para pasar el control de nuevo a usted cuando ha completado alguna tarea, por lo que le da una función para utilizar para llamar de nuevo a usted.

En Python, por ejemplo,

grabDBValue( (lambda x: passValueToGUIWindow(x) ))

grabDBValue se podría escribir para tomar solo un valor de una base de datos y luego dejar usted especifica qué hacer realmente con el valor, por lo que acepta una función. No sabes cuándo o si grabDBValue volverá, pero si/cuando lo hace, sabes lo que quieres que haga. Aquí, paso una función anónima (o lambda) que envía el valor a una ventana GUI. Podría cambiar fácilmente el comportamiento del programa haciendo esto:

grabDBValue( (lambda x: passToLogger(x) ))

Las devoluciones de llamada funcionan bien en lenguajes donde las funciones son valores de primera clase , al igual que los enteros habituales, cadenas de caracteres, booleanos, sucesivamente. En C, puede "pasar" una función pasando un puntero a ella y el llamante puede usar eso; en Java, el llamante pedirá una clase estática de un cierto tipo con un cierto nombre de método, ya que no hay funciones ("métodos", en realidad) fuera de las clases; y en la mayoría de los otros lenguajes dinámicos, solo puede pasar una función con sintaxis simple.

Protip:

En idiomas con ámbito léxico (como Scheme o Perl) se puede hacer un truco como esto:

my $var = 2;
my $val = someCallerBackFunction(sub callback { return $var * 3; });
# Perlistas note: I know the sub doesn't need a name, this is for illustration

$val en este caso será 6 porque la devolución de llamada tiene acceso a las variables declaradas en el entorno lexical donde fue definida. El alcance léxico y las devoluciones de llamada anónimas son una poderosa combinación que justifica un estudio adicional para el programador novato.

Tiene algún código que desea ejecutar. Normalmente, cuando lo llamas, estás esperando a que se termine antes de continuar (lo que puede hacer que tu aplicación se vuelva gris/produzca un tiempo de giro para un cursor).

Un método alternativo es ejecutar este código en paralelo y continuar con su propio trabajo. Pero, ¿qué pasa si su código original necesita hacer cosas diferentes dependiendo de la respuesta del código al que llamó? Bueno, en ese caso puede pasar el nombre / ubicación del código que desea es para llamar cuando está hecho. Esto es una "llamada de vuelta".

Código normal: Pedir información->Procesar Información->Tratar con los resultados del Procesamiento->Continuar haciendo otras cosas.

Con callbacks: Pedir información->Procesar Información->Continuar haciendo otras cosas. Y en algún momento posterior - > Tratar con los resultados del Procesamiento.

Sin callback ni otros recursos especiales de programación (como threading, y otros), un programa es exactamente una secuencia de instrucciones que se ejecutan secuencialmente una tras otra, e incluso con una especie de "comportamiento dinámico" determinado por ciertas condiciones, todos los escenarios posibles deben ser programados previamente.

Entonces, si necesitamos proporcionar un comportamiento dinámico real a un programa podemos usar callback. Con callback puede instruir por parámetros, un programa para llamar a otro programa que proporciona algunos parámetros previamente definidos y puede esperar algunos resultados ( este es el contrato o la firma de la operación), por lo que estos resultados pueden ser producidos/procesados por un programa de terceros que no se conocía previamente.

Esta técnica es la base del polimorfismo aplicado a programas, funciones, objetos y todas las demás unidades de código ejecutadas por computadoras.

El mundo humano utilizado como ejemplo para la devolución de llamada está bien explicado cuando usted está haciendo algún trabajo, supongamos que usted es un pintor ( aquí usted es el programa principal, que pinta) y llame a su cliente a veces para pedirle que apruebe el resultado de su trabajo, por lo que, él decide si la imagen es buena ( su cliente es el programa de terceros).

En el ejemplo anterior usted es un pintor y "delega" a otros el trabajo para aprobar el resultado, la imagen es el parámetro, y cada nuevo cliente (la "función") cambia el resultado de su trabajo decidir lo que quiere sobre la imagen (la decisión tomada por los clientes es el resultado devuelto de la "función callback").

Espero que esta explicación pueda ser útil.

Imaginemos que me ibas a dar una tarea potencialmente larga: obtener los nombres de las primeras cinco personas únicas que te encuentres. Esto podría llevar días si estoy en una zona escasamente poblada. No estás realmente interesado en sentarte en tus manos mientras corro por ahí así que dices, " Cuando tengas la lista, llámame a mi celular y léemela. Aquí está el número.".

Me has dado una referencia de devolución de llamada a una función que se supone que debo ejecutar para entregar más procesamiento.

En JavaScript podría verse algo como esto:

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);

Esto probablemente podría mejorarse de muchas maneras. Por ejemplo, podría proporcionar una segunda devolución de llamada: si termina tomando más de una hora, llame al teléfono rojo y dígale a la persona que responde que ha agotado el tiempo.

Las devoluciones de llamada se describen más fácilmente en términos del sistema telefónico. Una llamada de función es análoga a llamar a alguien por teléfono, hacerle una pregunta, obtener una respuesta y colgar; agregar una devolución de llamada cambia la analogía para que después de hacerle una pregunta, también le des tu nombre y número para que pueda devolverte la llamada con la respuesta. Paul Paul Jakubik , "Implementaciones de devolución de llamada en C++"

Una devolución de llamada es una función que será llamada por una segunda función. Esta segunda función no sabe de antemano a qué función llamará. Por lo tanto, la identidad de la función callback se almacena en algún lugar, o se pasa a la segunda función como parámetro. Esta "identidad", dependiendo del lenguaje de programación, puede ser la dirección de la llamada, o algún otro tipo de puntero, o podría ser el nombre de la función. El principal es el mismo, almacenamos o pasamos alguna información eso identifica inequívocamente la función.

Cuando llega el momento, la segunda función puede llamar a la devolución de llamada, suministrando parámetros dependiendo de las circunstancias en ese momento. Incluso podría elegir la devolución de llamada de un conjunto de posibles devoluciones de llamada. El lenguaje de programación debe proporcionar algún tipo de sintaxis para permitir que la segunda función llame a la devolución de llamada, conociendo su "identidad"."

Este mecanismo tiene muchos usos posibles. Con callbacks, el diseñador de una función puede deje que se personalice haciéndole llamar a cualquier devolución de llamada que se proporcione. Por ejemplo, una función de ordenación podría tomar una devolución de llamada como parámetro, y esta devolución de llamada podría ser una función para comparar dos elementos para decidir cuál viene primero.

Por cierto, dependiendo del lenguaje de programación, la palabra "function" en la discusión anterior podría ser reemplazada por "block," "closure," "lambda," etc.

Normalmente enviamos variables a funciones . Supongamos que tiene una tarea donde la variable necesita ser procesada antes de ser dada como argumento - puede usar callback .

function1(var1, var2) es la forma habitual .

¿Qué pasa si quiero que var2 se procese y luego se envíe como un argumento? function1(var1, function2(var2))

Este es un tipo de devolución de llamada - donde function2 ejecuta algún código y devuelve una variable a la función inicial .

Una explicación metafórica:

Tengo un paquete que quiero que se entregue a un amigo, y también quiero saber cuándo lo recibe mi amigo.

Así que llevo el paquete a la oficina de correos y les pido que lo entreguen. Si quiero saber cuándo mi amigo recibe el paquete, tengo dos opciones:

(a) Puedo esperar en la oficina de correos hasta que sea entregado.

(b) Recibiré un correo electrónico cuando se entregue.

La opción (b) es análoga a una devolución de llamada.

Para enseñar callbacks, primero tiene que enseñar el puntero. Una vez que los estudiantes entiendan la idea de puntero a una variable, la idea de callbacks será más fácil. Suponiendo que está utilizando C / C++, estos pasos se pueden seguir.

• Primero muestre a sus estudiantes cómo usar y manipular variables usando punteros junto con los identificadores de variables normales.
• Luego enséñeles que hay cosas que solo se pueden hacer con punteros(como pasar una variable por referencia).
• Luego dígales cómo el código ejecutable o las funciones son como algunos otros datos(o variables) en la memoria. Por lo tanto, las funciones también tienen direcciones o punteros.
• Luego muéstrales cómo se puede llamar a las funciones con punteros de función y diles que se llaman callbacks.
• Ahora, la pregunta es, ¿por qué todos estos problemas para llamar a algunas funciones? ¿Cuál es el beneficio? Al igual que los punteros de datos, function pointer aka callbacks tiene algunas ventajas sobre el uso normal identificador.
• El primero es que los identificadores de funciones o los nombres de funciones no se pueden usar como datos normales. Es decir, no se puede hacer una estructura de datos con funciones (como una matriz o una lista vinculada de funciones). Pero con las devoluciones de llamada, puede hacer una matriz, una lista vinculada o usarlos con otros datos como en el diccionario de pares clave-valor o árboles, o cualquier otra cosa. Este es un beneficio poderoso. Y otros beneficios son en realidad hijos de éste.
• El uso más común de callbacks se ve en la programación del controlador de eventos. Donde se ejecutan una o más funciones basadas en alguna señal entrante. Con callbacks, se puede mantener un diccionario para mapear señales con callbacks. Entonces la resolución de la señal de entrada y la ejecución del código correspondiente se vuelven mucho más fáciles.
• El segundo uso de callbacks que viene a mi mente son funciones de orden superior. Las funciones que toman otras funciones como argumentos de entrada. Y para enviar funciones como argumentos, necesitamos callbacks. Un ejemplo puede ser una función que toman una matriz y una devolución de llamada. Luego realiza la devolución de llamada en cada uno de los elementos de la matriz y devuelve los resultados en otra matriz. Si pasamos a la función una devolución de llamada duplicada, obtenemos una matriz de valores duplicados. Si pasamos un callback cuadrado, obtenemos cuadrados. Para raíces cuadradas, simplemente envíe la devolución de llamada apropiada. Esto no se puede hacer con funciones normales.

Podría haber muchas más cosas. Involucre a los estudiantes y ellos descubrirán. Espero que esto ayude.

En inglés sencillo una devolución de llamada es una promesa. Joe, Jane, David y Samantha comparten un viaje al trabajo. Joe conduce hoy. Jane, David y Samantha tienen un par de opciones:

1. Revisa la ventana cada 5 minutos para ver si Joe está fuera
2. Sigan haciendo lo suyo hasta que Joe toque el timbre de la puerta.

Opción 1: Esto se parece más a un ejemplo de sondeo donde Jane estaría atrapada en un "bucle" comprobando si Joe está fuera. Jane no puede hacer nada más en la media tiempo.

Opción 2: Este es el ejemplo de devolución de llamada. Jane le dice a Joe que toque el timbre cuando esté afuera. Ella le da una "función" para tocar el timbre de la puerta. Joe no necesita saber cómo funciona el timbre de la puerta o dónde está, solo necesita llamar a esa función, es decir, tocar el timbre de la puerta cuando está allí.

Las devoluciones de llamada son impulsadas por "eventos". En este ejemplo el "evento" es la llegada de Joe. En Ajax, por ejemplo, los eventos pueden ser "éxito" o "fracaso" de la solicitud asíncrona y cada uno puede tener las mismas o diferentes devoluciones de llamada.

En términos de aplicaciones JavaScript y callbacks. También necesitamos entender los "cierres" y el contexto de la aplicación. A qué se refiere" esto " puede confundir fácilmente a los desarrolladores de JavaScript. En este ejemplo, dentro del método/callback "ring_the_door_bell()" de cada persona, puede haber otros métodos que cada persona necesita hacer en función de su rutina matutina ex. "turn_off_the_tv ()". Queremos que" esto "se refiera al objeto "Jane" o al objeto" David " para que cada uno puede configurar cualquier otra cosa que necesiten antes de que Joe los recoja. Aquí es donde configurar la devolución de llamada con Joe requiere parodiar el método para que" esto " se refiera al objeto correcto.

Espero que eso ayude!

Una devolución de llamada es un sobre sellado con dirección propia. Cuando llamas a una función, es como enviar una carta. Si desea que esa función llame a otra función, proporcione esa información en forma de referencia o dirección.

Creo que es una tarea bastante fácil de explicar.

Al principio, la devolución de llamada son solo funciones ordinarias.
Y el más es, que llamamos a esta función (vamos a llamarlo A) desde dentro de otra función (vamos a llamarlo B).

La magia de esto es que yo decido, que función debe ser llamada por la función de fuera B.

En el momento en que escribo la función B no se que función callback debe ser llamada. En el momento de llamar a la función B I también dile a esta función que llame a la función A. Eso es todo.

¿Qué es una Función de Devolución de Llamada?

La respuesta simple a esta primera pregunta es que una función de devolución de llamada es una función que se llama a través de un puntero de función. Si pasa el puntero (dirección) de una función como argumento a otra, cuando ese puntero se usa para llamar a la función a la que apunta, se dice que se realiza una llamada de vuelta.

La función Callback es difícil de rastrear, pero a veces es muy útil. Especialmente cuando estás diseñando bibliotecas. Función de devolución de llamada es como pedirle a tu usuario que te dé un nombre de función, y llamarás a esa función bajo ciertas condiciones.

Por ejemplo, escribe un temporizador de devolución de llamada. Le permite especificar la duración y a qué función llamar, y la función será devuelta de llamada en consecuencia. "Ejecute myfunction() cada 10 segundos durante 5 veces"

O puede crear un directorio de funciones, pasando una lista de nombres de funciones y pedir a la biblioteca que devuelva la llamada en consecuencia. "Callback success () si tiene éxito, callback fail () si ha fallado."

Veamos un ejemplo de puntero de función simple

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

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

¿Cómo pasar un argumento a la función callback?

Observered that function pointer to implement callback takes in void *, which indicates that it can takes in any type of variable including structure. Por lo tanto, puede pasar varios argumentos por estructura.

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;   
}

Una devolución de llamada es un método que está programado para ejecutarse cuando se cumple una condición.

Un ejemplo de "mundo real" es una tienda de videojuegos local. Usted está esperando la vida media 3. En lugar de ir a la tienda todos los días para ver si está en, usted registra su correo electrónico en una lista para ser notificado cuando el juego está disponible. El correo electrónico se convierte en su "devolución de llamada" y la condición a cumplir es la disponibilidad del juego.

Un ejemplo de "programadores" es una página web donde desea realizar una acción cuando se hace clic en un botón. Registra un método de devolución de llamada para un botón y continúa haciendo otras tareas. Cuando / si el usuario hace clic en el botón, el navegador mirará la lista de devoluciones de llamada para ese evento y llamará a su método.

Una devolución de llamada es una forma de manejar eventos de forma asíncrona. Nunca se puede saber cuándo se ejecutará la devolución de llamada, o si se ejecutará en absoluto. La ventaja es que libera su programa y ciclos de CPU para realizar otras tareas mientras espera la respuesta.

Simple y llanamente: Una devolución de llamada es una función que le das a otra función, para que pueda llamarla.

Generalmente se llama cuando se completa alguna operación. Dado que crea la devolución de llamada antes de darla a la otra función, puede inicializarla con información de contexto desde el sitio de la llamada. Es por eso que se llama call*back* - la primera función vuelve a llamar al contexto desde donde fue llamada.

"En programación informática, una devolución de llamada es una referencia al código ejecutable, o una pieza de código ejecutable, que se pasa como un argumento a otro código. Esto permite que una capa de software de nivel inferior llame a una subrutina (o función) definida en una capa de nivel superior."- Wikipedia

Devolución de llamada en C usando el puntero de función

En C, la devolución de llamada se implementa utilizando el puntero de función. Puntero de función - como su nombre indica, es un puntero a una función.

Para ejemplo, int (*ptrFunc) ();

Aquí, ptrFunc es un puntero a una función que no toma argumentos y devuelve un entero. NO olvide poner el paréntesis, de lo contrario el compilador asumirá que ptrFunc es un nombre de función normal, que no toma nada y devuelve un puntero a un entero.

Aquí hay un código para demostrar el puntero de la función.

#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;
}

Ahora tratemos de entender el concepto de Devolución de llamada en C usando el puntero de función.

El el programa completo tiene tres archivos: callback.c, reg_callback.h y 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)();                               
}

Si ejecutamos este programa, la salida será

Este es un programa que demuestra la función de devolución de llamada dentro de register_callback dentro de my_callback volver dentro del programa principal

La función de capa superior llama a una función de capa inferior como una llamada normal y el mecanismo de devolución de llamada permite que la función de capa inferior llame a la función de capa superior a través de un puntero a una devolución de llamada función.

Callback en Java Usando Interfaz

Java no tiene el concepto de puntero de función Implementa el mecanismo de devolución de llamada a través de su mecanismo de interfaz Aquí, en lugar de un puntero de función, declaramos una Interfaz que tiene un método al que se llamará cuando el destinatario termine su tarea

Permítanme demostrarlo a través de un ejemplo:

La Interfaz de Devolución de llamada

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

El Llamante o el Nivel Superior Clase

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
}
}

El Destinatario o la función de capa inferior

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
}
}

Devolución de llamada Usando el patrón EventListener

• List item

Este patrón se usa para notificar de 0 a n números de Observadores/Oyentes que una tarea en particular ha terminado

• List item

La diferencia entre el mecanismo de devolución de llamada y el mecanismo EventListener / Observer es que en la devolución de llamada, el destinatario notifica al único llamante, mientras que en Eventlisener / Observer, el destinatario puede notificar a cualquier persona que esté interesada en ese evento (la notificación puede ir a algunas otras partes de la aplicación que no hayan activado la tarea)

Permítanme explicarlo a través de un ejemplo.

La Interfaz del Evento

public interface Events {

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

Widget de clase

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);
    }
}

Botón de clase

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

Casilla de verificación de Clase

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;
}
}

Clase de actividad

Paquete com.som_itsolutions.formación.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();
    }   
}

Otra Clase

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...");
}
}

Clase principal

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);
}
}

Como puede ver en el código anterior, tenemos una interfaz llamada events que básicamente enumera todos los eventos que pueden suceder para nuestra aplicación. La clase Widget es la clase base para todos los componentes de la interfaz de usuario como Botón, Casilla de verificación. Estos componentes de interfaz de usuario son los objetos que realmente reciben los eventos del código del marco de trabajo. La clase Widget implementa la interfaz de eventos y también tiene dos interfaces anidadas: OnClickEventListener & OnLongClickEventListener

Estas dos interfaces son responsables de escuchar los eventos que pueden ocurrir en los componentes de interfaz de usuario derivados del Widget, como el Botón o la casilla de verificación. Así que si comparamos este ejemplo con el ejemplo anterior de devolución de llamada usando la interfaz Java, estas dos interfaces funcionan como la interfaz de devolución de llamada. Así que el código de nivel superior (Aquí Actividad) implementa estos dos interfaz. Y cada vez que ocurre un evento a un widget, el código de nivel superior (o el método de estas interfaces implementadas en el código de nivel superior, que es aquí Actividad) será llamado.

Ahora permítanme discutir la diferencia básica entre la devolución de llamada y el patrón Eventlistener. Como hemos mencionado que usando Callback, el Llamante puede notificar solo a una persona que llama. Pero en el caso del patrón EventListener, cualquier otra parte o clase de la Aplicación puede registrarse para los eventos que pueden aparece en el Botón o en la casilla de verificación. El ejemplo de este tipo de clase es la otra clase. Si ve el código de la OtherClass, encontrará que se ha registrado como un oyente para el ClickEvent que puede ocurrir en el Botón definido en la Actividad. Lo interesante es que, además de la Actividad ( el Llamante), esta otra clase también será notificada cada vez que se produzca el evento click en el Botón.

[editar]cuando tenemos dos funciones, es decir acogedor y functionB,si acogedor depende functionB.

Luego llamamos a functionB como una función de devolución de llamada .esto es ampliamente utilizado en el marco de la primavera.

Piense en un método como dar una tarea a un compañero de trabajo. Una tarea simple podría ser la siguiente:

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

Su compañero de trabajo diligentemente hace los cálculos y le da el siguiente resultado:

x = -6
y = -4

Pero su compañero de trabajo tiene un problema, no siempre entiende las notaciones, como ^, pero sí las entiende por su descripción. Tales como exponent. Cada vez que encuentra uno de estos se obtiene lo siguiente:

I don't understand "^"

Esto requiere que reescriba todo el conjunto de instrucciones de nuevo después de explicar lo que el personaje significa para su compañero de trabajo, y él no siempre recuerda entre preguntas. Y también tiene dificultades para recordar sus consejos, como just ask me. Sin embargo, siempre sigue sus instrucciones escritas lo mejor que puede.

Si piensa en una solución, simplemente agregue lo siguiente a todas sus instrucciones:

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

Ahora, cada vez que tiene un problema, te llama y te pregunta, en lugar de darte una mala respuesta y hacer que el proceso se reinicie.

Callbacks le permite insertar su propio código en otro bloque de código para ser ejecutado en otro momento, que modifica o agrega al comportamiento de ese otro bloque de código para satisfacer sus necesidades. Usted gana flexibilidad y personalización mientras es capaz de tener código más mantenible.

Menos codificar = más fácil de mantener y cambiar = menos tiempo = más valor de negocio = genialidad.

Por ejemplo, en javascript, usando el subrayado.js, puedes encontrar todos los elementos pares en una matriz así:

var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
=> [2, 4, 6]

Ejemplo cortesía de Underscore.js: http://documentcloud.github.com/underscore/#filter

Esto en términos de descargar una página web:

Su programa se ejecuta en un teléfono celular y está solicitando la página web http://www.google.com. Si escribe su programa sincrónicamente, la función que escribe para descargar los datos se ejecutará continuamente hasta que todos los datos se descarguen. Esto significa que su interfaz de usuario no se actualizará y básicamente aparecerá congelada. Si escribes tu programa usando callbacks, solicitas los datos y dices " ejecuta esta función cuando hayas terminado." Este permite que la interfaz de usuario siga permitiendo la interacción del usuario mientras el archivo se está descargando. Una vez que la página web ha terminado de descargarse, se llama a su función de resultado (devolución de llamada) y puede manejar los datos.

Básicamente, le permite solicitar algo y continuar ejecutando mientras espera el resultado. Una vez que el resultado vuelve a usted a través de una función de devolución de llamada, puede continuar la operación donde la dejó.