Callbacks vs Promises vs Async/Await — مقارنة معمّقة

const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('حدث خطأ:', err.message);
    return;
  }
  console.log(data);
});

const fs = require('fs/promises');

fs.readFile('file.txt', 'utf8')
  .then(data => console.log(data))
  .catch(err => console.error('حدث خطأ:', err.message));

const fs = require('fs/promises');

async function readFile() {
  try {
    const data = await fs.readFile('file.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error('حدث خطأ:', err.message);
  }
}

const promises = [fetch('/api/1'), fetch('/api/2'), fetch('/api/3')];
const results = await Promise.allSettled(promises);

for (const result of results) {
  if (result.status === 'fulfilled') {
    console.log('نجاح:', result.value);
  } else {
    console.log('فشل:', result.reason);
  }
}

const timeout = new Promise((_, reject) =>
  setTimeout(() => reject(new Error('انتهت المهلة')), 5000)
);

const data = await Promise.race([fetch('/api/data'), timeout]);

const mirrors = [
  fetch('https://mirror1.example.com/data'),
  fetch('https://mirror2.example.com/data'),
  fetch('https://mirror3.example.com/data'),
];

const firstSuccess = await Promise.any(mirrors);

async function* fetchPages(urls) {
  for (const url of urls) {
    const response = await fetch(url);
    yield response.json();
  }
}

const urls = ['/page/1', '/page/2', '/page/3'];
for await (const page of fetchPages(urls)) {
  console.log(page);
}

async function* paginateResults(apiUrl, pageSize = 10) {
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const response = await fetch(`${apiUrl}?page=${page}&size=${pageSize}`);
    const data = await response.json();
    yield data.items;

    hasMore = data.items.length === pageSize;
    page++;
  }
}

for await (const items of paginateResults('/api/users')) {
  for (const item of items) {
    console.log(item.name);
  }
}

const util = require('util');
const fs = require('fs');

const readFile = util.promisify(fs.readFile);
const writeFile = util.promisify(fs.writeFile);

async function copyFile(src, dest) {
  const data = await readFile(src);
  await writeFile(dest, data);
}

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

async function waterfall(tasks) {
  let result;
  for (const task of tasks) {
    result = await task(result);
  }
  return result;
}

const result = await waterfall([
  () => 1,
  (prev) => prev + 2,
  (prev) => prev * 3,
]);
// النتيجة: 9

async function parallel(tasks) {
  return Promise.all(tasks.map(task => task()));
}

const [user, posts, comments] = await parallel([
  () => fetch('/api/user'),
  () => fetch('/api/posts'),
  () => fetch('/api/comments'),
]);

async function series(tasks) {
  const results = [];
  for (const task of tasks) {
    results.push(await task());
  }
  return results;
}