NodeJs обратный вызов простого примера

Ответ 1

var myCallback = function(data) {
  console.log('got data: '+data);
};

var usingItNow = function(callback) {
  callback('get it?');
};

Теперь откройте node или консоль браузера и вставьте указанные выше определения.

Наконец, используйте его в следующей строке:

usingItNow(myCallback);

В отношении условных обозначений Node -Style

Коста спросил, как это будет выглядеть, если мы будем соблюдать соглашения об обратном вызове node.

В этом соглашении обратный вызов должен ожидать получить хотя бы один аргумент, первый аргумент, как ошибку. При желании мы будем иметь один или несколько дополнительных аргументов, в зависимости от контекста. В этом случае контекст является нашим приведенным выше примером.

Здесь я переписываю наш пример в этом соглашении.

var myCallback = function(err, data) {
  if (err) throw err; // Check for the error and throw if it exists.
  console.log('got data: '+data); // Otherwise proceed as usual.
};

var usingItNow = function(callback) {
  callback(null, 'get it?'); // I dont want to throw an error, so I pass null for the error argument
};

Если мы хотим симулировать случай ошибки, мы можем определить usingItNow как это

var usingItNow = function(callback) {
  var myError = new Error('My custom error!');
  callback(myError, 'get it?'); // I send my error as the first argument.
};

Конечное использование в точности совпадает с предыдущим:

usingItNow(myCallback);

Единственная разница в поведении зависит от того, какая версия usingItNow вы определили: ту, которая передает "правдивое значение" (объект "Ошибка" ) для обратного вызова для первого аргумента или того, который передает это значение null для аргумента ошибки.

Ответ 2

Функция обратного вызова - это просто функция, которую вы передаете в другую функцию, чтобы функция могла вызвать ее позже. Это обычно наблюдается в асинхронном API; вызов API немедленно возвращается, потому что он асинхронен, поэтому вы передаете ему функцию, которую API может вызвать, когда она выполнит свою асинхронную задачу.

Простейшим примером, о котором я могу думать в JavaScript, является функция setTimeout(). Это глобальная функция, которая принимает два аргумента. Первый аргумент - это функция обратного вызова, а второй аргумент - задержка в миллисекундах. Функция предназначена для ожидания соответствующего количества времени, а затем вызывает функцию обратного вызова.

setTimeout(function () {
  console.log("10 seconds later...");
}, 10000);

Возможно, вы уже видели вышеуказанный код, но просто не понимали, что функция, которую вы проходили, называлась функцией обратного вызова. Мы могли бы переписать код выше, чтобы сделать его более очевидным.

var callback = function () {
  console.log("10 seconds later...");
};
setTimeout(callback, 10000);

Обратные вызовы используются повсюду в Node, потому что Node построен с нуля, чтобы быть асинхронным во всем, что он делает. Даже при разговоре с файловой системой. Поэтому тонна внутренних API Node принимает функции обратного вызова как аргументы, а не возвращает данные, которые вы можете назначить переменной. Вместо этого он будет вызывать вашу функцию обратного вызова, передавая нужные вам данные в качестве аргумента. Например, вы можете использовать библиотеку Node fs для чтения файла. Модуль fs предоставляет две уникальные функции API: readFile и readFileSync.

Функция readFile является асинхронной, а readFileSync явно не является. Вы можете видеть, что они намереваются использовать асинхронные вызовы, когда это возможно, поскольку они называли их readFile и readFileSync вместо readFile и readFileAsync. Ниже приведен пример использования обеих функций.

Синхронный:

var data = fs.readFileSync('test.txt');
console.log(data);

Приведенный выше код блокирует выполнение потока до тех пор, пока все содержимое test.txt не будет считано в памяти и не будет сохранено в переменной data. В Node это обычно считается плохой практикой. Иногда бывает полезно, например, при написании быстрого небольшого script сделать что-то простое, но утомительное, и вам не все равно, что вы можете сохранить каждую наносекунду времени.

Асинхронный (с обратным вызовом):

var callback = function (err, data) {
  if (err) return console.error(err);
  console.log(data);
};
fs.readFile('test.txt', callback);

Сначала мы создаем функцию обратного вызова, которая принимает два аргумента err и data. Одна из проблем с асинхронными функциями состоит в том, что становится сложнее ловить ошибки, поэтому многие API обратного вызова обращаются к ошибкам в качестве первого аргумента функции обратного вызова. Лучше всего проверить, имеет ли значение err значение, прежде чем делать что-либо еще. Если это так, прекратите выполнение обратного вызова и запишите ошибку.

Синхронные вызовы имеют преимущество при наличии исключений, потому что вы можете просто поймать их с помощью блока try/catch.

try {
  var data = fs.readFileSync('test.txt');
  console.log(data);
} catch (err) {
  console.error(err);
}

В асинхронных функциях это не работает. Вызов API немедленно возвращается, поэтому нечего улавливать с помощью try/catch. Правильные асинхронные API-интерфейсы, которые используют обратные вызовы, всегда будут ловить собственные ошибки, а затем передавать эти ошибки в обратный вызов, где вы можете обрабатывать его по своему усмотрению.

В дополнение к обратным вызовам, однако, существует еще один популярный стиль API, который обычно используется под названием обещание. Если вы хотите прочитать о них, вы можете прочитать всю запись в блоге, которую я написал на основе этого ответа здесь.

Ответ 3

Вот пример копирования текстового файла с fs.readFile и fs.writeFile:

var fs = require('fs');

var copyFile = function(source, destination, next) {
  // we should read source file first
  fs.readFile(source, function(err, data) {
    if (err) return next(err); // error occurred
    // now we can write data to destination file
    fs.writeFile(destination, data, next);
  });
};

И что пример использования функции copyFile:

copyFile('foo.txt', 'bar.txt', function(err) {
  if (err) {
    // either fs.readFile or fs.writeFile returned an error
    console.log(err.stack || err);
  } else {
    console.log('Success!');
  }
});

Общий шаблон node.js предполагает, что первым аргументом функции обратного вызова является ошибка. Вы должны использовать этот шаблон, потому что все модули потока управления полагаются на него:

next(new Error('I cannot do it!')); // error

next(null, results); // no error occurred, return result

Ответ 4

Попробуйте этот пример так просто, как вы можете прочитать, просто скопируйте save newfile.js do node newfile для запуска приложения.

function myNew(next){
    console.log("Im the one who initates callback");
    next("nope", "success");
}


myNew(function(err, res){
    console.log("I got back from callback",err, res);
});

Ответ 5

мы создаем простую функцию как

callBackFunction (data, function ( err, response ){
     console.log(response)
}) 

// callbackfunction 
function callBackFuntion (data, callback){
    //write your logic and return your result as
callback("",result) //if not error
callback(error, "") //if error
}

Ответ 6

const fs = require('fs');

fs.stat('input.txt', function (err, stats) {
    if(err){
        console.log(err);
    } else {
        console.log(stats);
        console.log('Completed Reading File');
    }
});

'fs' - это модуль узла, который помогает вам читать файл. Функция обратного вызова гарантирует, что ваш файл с именем 'input.txt' полностью прочитан, прежде чем он будет выполнен. Функция fs.stat() предназначена для получения информации о файле, такой как размер файла, дата создания и дата изменения.

Ответ 7

callback - это функция, переданная в качестве параметра в функцию Higher Order Function (википедия). Простая реализация обратного вызова:

const func = callback => callback('Hello World!');

Чтобы вызвать функцию, просто передайте другую функцию в качестве аргумента определенной функции.

func(string => console.log(string));