🚀 Boost Workflow with these JS Snippets (2026): Essential Tools for Modern Developers

const retry = async (fn, options = {}) => {
  const { retries = 3, delay = 1000, backoff = 2, timeout } = options;
  
  for (let i = 0; i <= retries; i++) {
    try {
      if (timeout) {
        return await Promise.race([
          fn(),
          new Promise((_, reject) => 
            setTimeout(() => reject(new Error('Timeout')), timeout)
          )
        ]);
      }
      return await fn();
    } catch (err) {
      if (i === retries) throw err;
      await new Promise(resolve => 
        setTimeout(resolve, delay * Math.pow(backoff, i))
      );
    }
  }
};

// Usage
const data = await retry(
  () => fetch('https://api.example.com/unstable'),
  { retries: 5, delay: 500, backoff: 2, timeout: 10000 }
);

const batchProcess = async (items, fn, concurrency = 5) => {
  const results = [];
  const executing = [];
  
  for (const [index, item] of items.entries()) {
    const promise = fn(item, index).then(result => {
      results[index] = result;
      executing.splice(executing.indexOf(promise), 1);
    });
    
    results[index] = promise;
    executing.push(promise);
    
    if (executing.length >= concurrency) {
      await Promise.race(executing);
    }
  }
  
  await Promise.all(results);
  return results;
};

// Usage - process 100 API calls, max 10 concurrent
const urls = Array(100).fill(null).map((_, i) => 
  `https://api.example.com/item/${i}`
);

const data = await batchProcess(
  urls,
  url => fetch(url).then(r => r.json()),
  10
);

const dedupedFetch = (() => {
  const pending = new Map();
  
  return async (url, options = {}) => {
    const key = `${url}-${JSON.stringify(options)}`;
    
    if (pending.has(key)) return pending.get(key);
    
    const promise = fetch(url, options)
      .then(async res => {
        const data = await res.json();
        pending.delete(key);
        return data;
      })
      .catch(err => {
        pending.delete(key);
        throw err;
      });
    
    pending.set(key, promise);
    return promise;
  };
})();

const get = (obj, path, defaultValue = undefined) => {
  const keys = Array.isArray(path) ? path : path.split('.');
  let result = obj;
  
  for (const key of keys) {
    result = result?.[key];
    if (result === undefined) return defaultValue;
  }
  
  return result;
};

// Usage
const user = { profile: { name: 'John' } };

get(user, 'profile.name'); // 'John'
get(user, 'profile.email', 'N/A'); // 'N/A'
get(user, ['profile', 'settings', 'theme'], 'light'); // 'light'

const catchify = promise => 
  promise
    .then(data => [null, data])
    .catch(err => [err, null]);

// Usage
const [err, data] = await catchify(
  fetch('/api/data').then(r => r.json())
);

if (err) {
  console.error('API failed:', err);
  // Handle error...
} else {
  // Process data...
}