A function that recursively calls itself and uses a promise for iteration

Question

A function that recursively calls itself and uses a promise for iteration

In my current setup, I have a function called emailIterator that reads messages from a stack and sends them one by one using an emailer. The process is done recursively by calling emailIterator with fewer messages each time as they are sent.


import { emailer } from 'pigeon';
 
interface MessageObject {
  email: string;
  recipientName: string;
  message: string;
}
 
interface ErrorFormat {
  error: any;
  messageAtError: MessageObject;
}
 
const data: MessageObject[] = [
  {
    email: '<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="ddbfb2bf9db9b2b0bcb4b3f3beb2b0">[email protected]</a>',
    recipientName: 'Bob',
    message: 'Lorem ipsum dolor sit amet mattis.',
  },
  {
    email: '<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="7c1615113c1813111d1512521f1311">[email protected]</a>',
    recipientName: 'Jim',
    message: 'Lorem ipsum dolor sit amet mattis.',
  },
];

const emailIterator = (messages: MessageObject[], cb: any): void => {
  if (messages.length === 0) {
    return cb(undefined, 'All messages sent');
  } else {
    const toSend = messages.pop();
 
    emailer(toSend)
      .then(() => {
        return emailIterator(messages, cb);
      })
      .catch((e) => {
        return cb({
          error: e,
          messageAtError: toSend,
        });
      });
  }
};

emailIterator(data, (err?: ErrorFormat, msg?: string) => {
  if (err) {
    console.log('There was an error with a message:', err.messageAtError);
    console.error(err.error);
    return;
  }
  console.log(msg);
});

I'm looking to convert this recursive solution into an iterative one. Here's my attempt so far. Does it handle errors efficiently? Can it be improved?


const emailIterator2 = async (messages: MessageObject[], cb: any): void => {
  for(let i = messages.length - 1; i >= 0; i--) {
    let toSend = messages[i]; 
    try {
      const result = await emailer(toSend); 
    } catch (e: ErrorFormat) {
      return cb({
        error: e, 
        messageAtError: toSend
      })
    }
    if(i === 0) {
      return cb(undefined, 'All messages sent')
    }
  }
}

javascript typescript recursion promise es6-promise

Answer 1

Answer №1

Implement the use of async..await within a for..of loop:

const emailIterator = async (messages: MessageObject[], cb: any): void => {
  let toSend
  try {
    for (const m of messages) {
      toSend = m
      await emailer(m)
    }
    cb(undefined, "All messages sent")
  }
  catch (e) {
    cb({ error: e, messageAtError: toSend })
  }
}

It is advised to avoid mixing callbacks with promises as it can be cumbersome. Consider converting emailIterator into a promise-based function:

const emailIterator = async (messages: MessageObject[]): Promise<string> => {
  let toSend
  try {
    for (const m of messages) {
      toSend = m
      await emailer(m)
    }
    return "All messages sent";
  }
  catch (e) {
    e.messageAtError = toSend;
    throw e;
  }
}

Take note of the unusual assignment of toSend so that it can be utilized in the catch block. An even better approach would be for the emailer function to handle errors properly -

async function emailer(message): Promise<void> {
  try {
    // ...
  }
  catch (e) {
    e.messageAtError(message);
    throw e;
  }
}

By following this pattern, emailIterator no longer needs to manage this concern. The functionality remains consistent, eliminating the need for explicit try..catch blocks and ensuring that errors propagate correctly. Additionally, TypeScript effortlessly deduces the return type of Promise<string> -

async function emailIterator(messages: MessageObject[]) {
  for (const m of messages)
    await emailer(m)
  return "All messages sent";
}

Answer 2

Implement the use of async..await within a for..of loop:

const emailIterator = async (messages: MessageObject[], cb: any): void => {
  let toSend
  try {
    for (const m of messages) {
      toSend = m
      await emailer(m)
    }
    cb(undefined, "All messages sent")
  }
  catch (e) {
    cb({ error: e, messageAtError: toSend })
  }
}

It is advised to avoid mixing callbacks with promises as it can be cumbersome. Consider converting emailIterator into a promise-based function:

const emailIterator = async (messages: MessageObject[]): Promise<string> => {
  let toSend
  try {
    for (const m of messages) {
      toSend = m
      await emailer(m)
    }
    return "All messages sent";
  }
  catch (e) {
    e.messageAtError = toSend;
    throw e;
  }
}

Take note of the unusual assignment of toSend so that it can be utilized in the catch block. An even better approach would be for the emailer function to handle errors properly -

async function emailer(message): Promise<void> {
  try {
    // ...
  }
  catch (e) {
    e.messageAtError(message);
    throw e;
  }
}

By following this pattern, emailIterator no longer needs to manage this concern. The functionality remains consistent, eliminating the need for explicit try..catch blocks and ensuring that errors propagate correctly. Additionally, TypeScript effortlessly deduces the return type of Promise<string> -

async function emailIterator(messages: MessageObject[]) {
  for (const m of messages)
    await emailer(m)
  return "All messages sent";
}

A function that recursively calls itself and uses a promise for iteration

Answer №1

Similar questions

The name 'Map' cannot be located. Is it necessary to alter your target library?

Transmitting chosen option using AJAX and JavaScript

The use of jQuery for fetching posts via ajax can lead to a crash in the browser

Unique TypeScript code snippets tailored for VSCode

Using ElectronJS requires the usage of the import keyword to load ES Modules

React App Creation: Issue with ESLint configuration in TypeScript environment

Issue with JSON parsing on non-Chrome web browsers

"Utilize Regular Expressions to conceal part of a text string with a

What sets apart npm correlation-id from uuid?

"Encountering issues with Firebase deployment related to function-builder and handle-builder while working with TypeScript

Transferring an Object from one AngularJS Controller to Another

Using remote: true with select_tag in Rails allows the select menu to dynamically

Is it feasible to use JQuery to automatically scroll a DIV with scrollbars to the very bottom?

Novice in AngularJS routing

React-Markdown is throwing an error that states: "ES Module must be imported in order to load

Issues with Line Chart in D3: Scaling and Zoom not functioning as expected due to ClipPath limitations

What could be causing NestJS/TypeORM to remove the attribute passed in during save operation?

Guide to retrieving and editing images from Appwrite using Vue

Tips for identifying the category of a hyperlink within my javascript code?

Rotate camera around item when dragged