Как написать свою собственную похищенную функцию с нуля

Автор оригинала: Shailesh Shekhawat.

Вступление

В этой статье вы узнаете, как написать свою собственную похищенную функцию с нуля.

ОБЩИНА помогает иметь дело с API на основе обратного вызова, сохраняя соответствующий код, соответствующий обещаниям.

Мы могли бы просто обернуть любую функцию с Новое обещание () И не беспокоиться об этом вообще. Но делая это, когда у нас много функций было бы избыточным.

Если вы понимаете обещания и обратные вызовы, то изучите о том, как написать обаятельные функции, должны быть легко. Так что давайте начнем.

Но вы когда-нибудь задавались вопросом, как похищает работы?

Обещания были введены в Стандарт Ecma-262, 6-е издание (ES6), который был опубликован в июне 2015 года.

Это было довольно совершенствование по обратным вызовам, как мы все знаем, насколько нечитаемым «обратным списком ада» может быть:)

Как разработчик Node.js, вы должны знать Какое обещание – и Как это работает внутренне , который также поможет вам в интервью JS. Не стесняйтесь просматривать их быстро перед чтением.

Почему нам нужно преобразовать обратные вызовы для обещаний?

С обратными вызовами, если вы хотите сделать что-то последовательно, вам придется указать Err Аргумент в каждом обратном вызове, который является избыточным. В обещаниях или Async-жду, вы можете просто добавить .catch метод или блок, который будет ловить любые ошибки, которые произошли в цепочке обещания
С обратными вызовами у вас нет контроля, когда он вызывается, в соответствии с каким контекстом, или сколько раз его называют, что может привести к утечкам памяти.
Используя обещания, мы контролируем эти факторы (особенно обработка ошибок), поэтому код более читабелен и поддерживается.

Как сделать обратные функции на основе обратного вызова возвращают обещание

Есть два способа сделать это:

Оберните функцию в другой функции, которая возвращает обещание. Затем он разрешается или отклоняет на основе аргументов обратного вызова.
ОБЩИНА – Мы создаем функцию Util/Helper похищать который преобразует все ошибки первые API на основе обратного вызова.

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

const getSumAsync = (num1, num2, callback) => {
 
  if (!num1 || !num2) {
    return callback(new Error("Missing arguments"), null);
  }
  return callback(null, num1 + num2);
}
getSumAsync(1, 1, (err, result) => {
  if (err){
    doSomethingWithError(err)
  }else {
    console.log(result) // 2
  }
})

Обернуть в обещание

Как вы можете видеть, getsumpromise Делегаты всю работу на оригинальную функцию gentumasync. предоставляя свой собственный обратный вызов, который переводится на обещание Решить/отклонить Отказ

Похищать

Когда нам нужно похищать многие функции, мы можем создать функцию помощника похищать Отказ

Что такое похищение?

Огьявление означает преобразование. Это преобразование функции, которая принимает обратный вызов в функцию, возвращающую обещание.

Использование Node.js Util.promisify () :

const { promisify } = require('util')
const getSumPromise = promisify(getSumAsync) // step 1
getSumPromise(1, 1) // step 2
.then(result => {
  console.log(result)
})
.catch(err =>{
  doSomethingWithError(err);
})

Так что это выглядит как волшебная функция, которая преобразует gentumasync в getsumpromise который имеет .then и .catch методы

Давайте напишем нашей собственной похитительной функции:

Если вы посмотрите на Шаг 1 В вышеуказанном коде похищать Функция принимает функцию в качестве аргумента, поэтому первое, что мы должны сделать, написать функцию, которая может сделать то же самое:

const getSumPromise = myPromisify(getSumAsync)
const myPromisify = (fn) => {}

После этого getsumpromise (1, 1) это функция вызова. Это означает, что наши вырывы должны вернуть другую функцию, которая может быть вызвана с теми же аргументами оригинальной функции:

const myPromisify = (fn) => {
 return (...args) => {
 }
}

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

Когда вы звоните getsumpromise (1, 1) Вы на самом деле звоняте (... args) = > {} . В приведенном выше реализации возвращается обещание. Вот почему вы можете использовать getsumpromise (1, 1). Затем (..). поймать (..) .

Я надеюсь, что вы получили намек на то, что функция обертки (... args) => {} должен вернуть обещание.

Вернуть обещание

const myPromisify = (fn) => {
  return (...args) => {
    return new Promise((resolve, reject) => {
      
    })
  }
}

Теперь сложная часть – как решить, когда разрешать или отклонить Обещание. На самом деле, это будет решено оригиналом gentumasync Реализация функций – это позвонит оригинальной функции обратного вызова, и нам просто нужно определить ее. Затем на основе Err и Результат Мы будем Отклонить или решить обещание.

const myPromisify = (fn) => {
  return (...args) => {
    return new Promise((resolve, reject) => {
      function customCallback(err, result) {
       if (err) {
         reject(err)
       }else {
         resolve(result);
        }
      }
   })
  }
}

Наше args [] только состоит из аргументов, прошедших по getsumpromise (1, 1) Кроме функции обратного вызова. Так что вам нужно добавить CustomCallback (ERR, результат) к args [] Какая оригинальная функция gentumasync. Соответственно позвонит, так как мы отслеживаем результат в CustomCallback Отказ

Нажмите CustomdCallback для Args []

const myPromisify = (fn) => {
   return (...args) => {
     return new Promise((resolve, reject) => {
       function customCallback(err, result) {
         if (err) {
           reject(err)
         }else {
          resolve(result);
         }
        }
        args.push(customCallback)
        fn.call(this, ...args)
      })
  }
}

Как вы можете видеть, мы добавили fn.call (это, args) , что позвонит оригинальную функцию в том же контексте с аргументами getsumasync (1, 1, customcallback) . Тогда наша функция по вымиранию должна быть в состоянии Решить/отклонить соответственно.

Вышеуказанное реализация будет работать, когда исходная функция ожидает обратного вызова с двумя аргументами, (Err, результат) Отказ Это то, что мы встречаемся чаще всего. Тогда наш пользовательский обратный вызов находится в правильном формате и похищать Работает отлично подходит для такого случая.

Но что если оригинал FN ожидает обратного вызова с большим количеством аргументов как Обратный вызов (Err, Result1, Результат2, …) ?

Для того, чтобы сделать его совместимым с этим, нам нужно изменить наше MyPromisify Функция, которая будет расширенной версией.

const myPromisify = (fn) => {
   return (...args) => {
     return new Promise((resolve, reject) => {
       function customCallback(err, ...results) {
         if (err) {
           return reject(err)
         }
         return resolve(results.length === 1 ? results[0] : results) 
        }
        args.push(customCallback)
        fn.call(this, ...args)
      })
   }
}

Пример:

const getSumAsync = (num1, num2, callback) => {
 
  if (!num1 || !num2) {
    return callback(new Error("Missing dependencies"), null);
  }
  
  const sum = num1 + num2;
  const message = `Sum is ${sum}`
  return callback(null, sum, message);
}
const getSumPromise = myPromisify(getSumAsync)
getSumPromise(2, 3).then(arrayOfResults) // [6, 'Sum is 6']

Это все! Спасибо, что сделали это так далеко!

Я надеюсь, что вы сможете понять концепцию. Попробуйте перечитать это снова. Это немного кода, чтобы обернуть голову, но не слишком сложный. Дайте мне знать, если это было полезно?

Не забудьте поделиться с друзьями с друзьями, которые начинаются с Node.js или надо выровнять свои навыки Node.js.

Использованная литература:

https://nodejs.org/dist/latest-v8.x/docs/api/util.html#util_util_promisify_original

https://github.com/digitaldesignlabs/es6-promisify

Вы можете прочитать другие статьи, как это в 101node.io .

Оригинал: “https://www.freecodecamp.org/news/write-your-own-promisify-function-from-scratch/”