بدء استخدام Bun API

من بين أدوات المطورين الأكثر إثارة مؤخرًا هو Bun، وهو مجموعة أدوات JavaScript سريعة بشكل لا يصدق وشاملة مصممة لتعزيز إنتاجية المطورين وأداء التطبيقات. Bun ليس مجرد بيئة تشغيل أخرى؛ إنه نظام بيئي متماسك يشمل بيئة تشغيل، ومجمّع، ومُشغّل اختبار، ومدير حزم، والمزيد، كل ذلك ضمن ملف تنفيذي أصلي واحد. سيرشدك هذا الدليل عبر أساسيات Bun، مع التركيز على مفاهيمه الأساسية وواجهات برمجة التطبيقات القوية.

💡

هل تريد أداة اختبار واجهات برمجة تطبيقات (API) رائعة تولّد توثيق API جميل؟

هل تريد منصة متكاملة وشاملة لفريق المطورين لديك للعمل معًا بأقصى إنتاجية؟

Apidog يلبي جميع متطلباتك، ويستبدل Postman بسعر أقل بكثير!

button

ما هو Bun؟

في جوهره، تم بناء Bun حول محرك تشغيل JavaScript عالي الأداء. على عكس Node.js، الذي يستخدم محرك V8 من Google، يستخدم Bun محرك JavaScriptCore (JSC) من Apple، وهو المحرك الذي يدعم Safari. هذا الاختيار، جنبًا إلى جنب مع تنفيذ Bun بلغة البرمجة Zig منخفضة المستوى، يساهم بشكل كبير في سرعته الملحوظة. غالبًا ما تُقاس أوقات بدء تشغيل تطبيقات Bun لتكون أسرع بكثير من تطبيقات Node.js المكافئة، أحيانًا بعامل أربعة أو أكثر. تمتد ميزة السرعة هذه إلى ما هو أبعد من مجرد البدء؛ فقد تم تحسين تطبيقات Bun الداخلية لواجهات برمجة التطبيقات المختلفة لتحقيق أقصى إنتاجية وأقل استخدام للذاكرة.

لكن طموح Bun يمتد إلى ما هو أبعد من مجرد كونه بيئة تشغيل أسرع. يهدف إلى أن يكون مجموعة أدوات شاملة، تعالج احتياجات المطورين الشائعة مباشرة:

الأدوات المدمجة: يعمل أمر bun نفسه كنقطة دخول للعديد من الوظائف. يقوم bun run بتنفيذ السكريبتات المحددة في package.json، ويدير bun install التبعيات (غالبًا أسرع بكثير من npm أو yarn)، ويقوم bun test بتشغيل الاختبارات باستخدام واجهة برمجة تطبيقات متوافقة مع Jest، ويقوم bun build بتجميع الكود للإنتاج، ويقوم bunx بتنفيذ الحزم دون تثبيتها صراحةً. هذا التكامل يبسط سير العمل عن طريق تقليل عدد أدوات التطوير المميزة المطلوبة.
دعم TypeScript وJSX الأصلي: إحدى الميزات البارزة في Bun هي دعمه الجاهز لملفات TypeScript (.ts، .tsx) وJSX (.jsx). يتضمن Bun مُحَوِّلًا مدمجًا عالي التحسين يتعامل مع أنواع الملفات هذه بسلاسة أثناء التنفيذ أو التجميع. هذا يلغي الحاجة إلى خطوات تجميع منفصلة تتضمن tsc أو Babel للعديد من سيناريوهات التطوير الشائعة، مما يبسط عملية الإعداد.
توافق نظام الوحدات: يحتضن Bun JavaScript الحديث مع دعم من الدرجة الأولى لوحدات ES (ESM). ومع ذلك، فإنه يدرك النظام البيئي الواسع الحالي المبني على CommonJS (CJS). يوفر Bun توافقًا قويًا لكلا نظامي الوحدات، مما يسمح للمطورين باستخدام import وrequire بشكل متبادل إلى حد كبير والاستفادة من ملايين حزم CJS الموجودة والمتاحة على npm.
الالتزام بواجهات برمجة تطبيقات الويب القياسية: مبدأ تصميم رئيسي هو تنفيذ واجهات برمجة تطبيقات الويب القياسية. وظائف وكائنات مثل fetch، Request، Response، Headers، WebSocket، وواجهة برمجة تطبيقات Streams (ReadableStream، WritableStream) مدمجة في النطاق العام لـ Bun. هذا يعزز قابلية نقل الكود بين بيئات Bun من جانب الخادم، والواجهات الأمامية للمتصفح، ومنصات الحوسبة الطرفية (edge computing)، مما يسمح للمطورين بإعادة استخدام واجهات برمجة التطبيقات المألوفة عبر سياقات مختلفة.
توافق Node.js: بينما يشق Bun طريقه الخاص بواجهات برمجة تطبيقات محسّنة ومعايير الويب، فإنه يهدف إلى درجة عالية من التوافق مع سطح واجهة برمجة تطبيقات Node.js. يتم تنفيذ العديد من وحدات Node.js المدمجة (node:fs، node:path، node:os، node:events، إلخ) والكائنات العامة (process، Buffer، __filename، __dirname) جزئيًا أو كليًا. الهدف هو السماح للعديد من مشاريع Node.js وحزم npm الموجودة بالعمل على Bun بأقل تعديل أو بدون تعديل، مما يضع Bun كـ "بديل مباشر" محتمل في العديد من الحالات.

من خلال الجمع بين هذه العناصر، يقدم Bun بديلاً مقنعًا لمطوري JavaScript وTypeScript الذين يبحثون عن الأداء والبساطة وتجربة تطوير حديثة.

كيفية تثبيت Bun

تم تصميم البدء باستخدام Bun ليكون سريعًا ومباشرًا عبر مختلف المنصات. الطريقة الأكثر شيوعًا لنظام macOS وLinux وWindows Subsystem for Linux (WSL) تستخدم أمر curl بسيط يتم تنفيذه في الطرفية الخاصة بك:

curl -fsSL https://bun.sh/install | bash

يقوم هذا الأمر بتنزيل سكريبت التثبيت وتمريره مباشرةً إلى bash. يتعامل السكريبت مع اكتشاف نظام التشغيل والبنية الخاصة بك، ويقوم بتنزيل الملف التنفيذي المناسب لـ Bun، وعادةً ما يقوم بتثبيته في ~/.bun/bin. كما يحاول تحديث ملف تكوين shell الخاص بك (مثل .zshrc أو .bashrc أو .bash_profile) لإضافة ~/.bun/bin إلى PATH النظام الخاص بك، مما يجعل أمر bun متاحًا عالميًا. قد تحتاج إلى إعادة تشغيل جلسة الطرفية الخاصة بك أو تشغيل ملف تكوين shell يدويًا (مثل source ~/.zshrc) لتصبح التغييرات سارية المفعول على الفور.

إذا واجهت مشاكل في الأذونات أو فضلت عدم التمرير مباشرةً إلى bash، يمكنك تنزيل السكريبت أولاً وفحصه قبل التشغيل:

curl -fsSL https://bun.sh/install -o install.sh
# Inspect install.sh if desired
bash install.sh

طرق تثبيت أخرى:

NPM: بينما يُقصد به في المقام الأول كأداة مستقلة، يمكنك أيضًا تثبيت Bun عالميًا عبر npm، وهو ما قد يكون مناسبًا في البيئات التي يوجد فيها Node.js وnpm بالفعل:

npm install -g bun

Docker: صور Bun Docker الرسمية متاحة على Docker Hub، مما يوفر بيئات معزولة مع Bun مثبت مسبقًا. هذه مفيدة لسير عمل التطوير والنشر في الحاويات. يمكنك العثور على صور متنوعة بناءً على توزيعات نظام تشغيل أساسية مختلفة (مثل Debian، Alpine) وعلامات تتوافق مع إصدارات Bun محددة.

docker run --rm --init --ulimit memlock=-1:-1 oven/bun:latest bun --version

Windows: لا يزال دعم Windows الأصلي لـ Bun يعتبر تجريبيًا ولكنه قيد التطوير النشط. الطريقة الموصى بها لاستخدام Bun على Windows حاليًا هي عبر WSL. ومع ذلك، أصبحت إصدارات Windows المباشرة متاحة، وقد تتضمن عملية التثبيت تنزيل أرشيف .zip وإضافة موقع الملف التنفيذي يدويًا إلى PATH النظام. تحقق من وثائق Bun الرسمية للحالة الأحدث والتعليمات الخاصة بتثبيت Windows الأصلي.
Homebrew (macOS): إذا كنت تستخدم Homebrew على نظام macOS، يمكنك تثبيت Bun عبر التاب الخاص به:

brew tap oven-sh/bun
brew install bun

التحقق:

بمجرد التثبيت، افتح نافذة طرفية جديدة وتحقق من التثبيت عن طريق التحقق من الإصدار:

bun --version

يجب أن يُظهر هذا رقم الإصدار المثبت، مؤكدًا أن Bun جاهز للاستخدام. يمكنك أيضًا تشغيل bun --help لرؤية قائمة بالأوامر والخيارات المتاحة.

تشغيل Bun لأول مرة

دعنا نتعمق في كتابة وتشغيل برنامج بسيط باستخدام Bun. إحدى المهام الأكثر شيوعًا هي إنشاء خادم HTTP. يوفر Bun واجهة برمجة تطبيقات مدمجة وعالية التحسين لهذا الغرض: Bun.serve.

قم بإنشاء ملف جديد باسم server.js (أو server.ts، حيث يتعامل Bun مع كليهما):

// server.ts

// Bun.serve starts the HTTP server
const server = Bun.serve({
  // Specify the port to listen on.
  // Defaults to process.env.PORT || 3000
  port: 3000,

  // The 'fetch' function is the core request handler.
  // It receives a standard Request object and must return a Response object (or a Promise resolving to one).
  fetch(request: Request): Response {
    // Create a standard Web API Response object
    return new Response("Welcome to Bun!");
  },
});

// Log a message indicating the server is running
console.log(`Listening on http://localhost:${server.port}`);

يقوم هذا المقتطف البرمجي بما يلي:

يستدعي الدالة Bun.serve، وهي الدالة الأساسية لإنشاء خوادم HTTP في Bun.
يمرر كائن تكوين، يحدد المنفذ (port) (3000 في هذه الحالة).
الجزء الحاسم هو دالة fetch. يتم استدعاء هذه الدالة لكل طلب HTTP وارد. تتوافق مع نمط معالج حدث fetch في Service Worker، وتقبل كائن Request قياسيًا.
داخل fetch، نقوم بإنشاء وإرجاع كائن Response قياسي. هنا، نرجع ببساطة نصًا عاديًا "Welcome to Bun!".
أخيرًا، نسجل رسالة تأكيد في الطرفية، بما في ذلك المنفذ الفعلي الذي يستمع عليه الخادم (يمكن الوصول إليه عبر server.port).

لتشغيل هذا الخادم، افتح الطرفية في الدليل الذي حفظت فيه الملف ونفذ:

bun run server.ts

أو، إذا حفظته كـ server.js:

bun run server.js

سيقوم Bun بتنفيذ السكريبت. إذا استخدمت TypeScript (server.ts)، سيتعامل المُحَوِّل الداخلي لـ Bun مع التحويل إلى JavaScript أثناء التنفيذ. سترى رسالة "Listening on http://localhost:3000".

الآن، افتح متصفح الويب الخاص بك وانتقل إلى http://localhost:3000. يجب أن ترى النص "Welcome to Bun!" معروضًا.

لإيقاف الخادم، ارجع إلى الطرفية واضغط على Ctrl + C.

يوضح هذا المثال البسيط سهولة إعداد خادم أساسي وتشغيل الكود (بما في ذلك TypeScript) مباشرةً باستخدام Bun، مما يعرض طبيعته المتكاملة واعتماده على واجهات برمجة تطبيقات الويب القياسية مثل Request وResponse.

ما هو دعم TypeScript الأصلي في Bun؟

إحدى أهم مزايا Bun، خاصةً للمطورين الذين يستخدمون بالفعل أو يرغبون في اعتماد TypeScript، هي دعمه المباشر والجاهز من الدرجة الأولى. على عكس Node.js، حيث يتطلب تشغيل TypeScript عادةً التجميع المسبق باستخدام مُجمّع TypeScript (tsc) أو استخدام مُحمّلات/مسجلات مثل ts-node أو tsx، يتعامل Bun مع ذلك بشكل أصلي وشفاف.

كيف يعمل:

عندما تطلب من Bun تشغيل ملف .ts أو .tsx (مثل bun run myscript.ts)، فإنه يستدعي تلقائيًا مُحَوِّله الداخلي. هذا المُحَوِّل مكتوب بلغة برمجية أصلية (Zig) وهو سريع للغاية. وظيفته هي:

تجريد الأنواع: إزالة تعليقات نوع TypeScript، الواجهات، التعدادات، إلخ، حيث أنها ليست جزءًا من تنفيذ JavaScript القياسي.
تحويل الصيغة: تحويل الصيغة الخاصة بـ TypeScript (مثل بعض استخدامات enum أو صيغة المزيّنات القديمة إذا تم تكوينها) إلى ما يعادلها في JavaScript.
التعامل مع JSX: تحويل صيغة JSX (المستخدمة في ملفات .tsx و.jsx) إلى استدعاءات دوال JavaScript قياسية (عادةً React.createElement أو ما يعادله في وقت تشغيل JSX المكوّن).

الفائدة الرئيسية هي أن هذا يحدث أثناء التنفيذ مباشرةً أثناء عملية التنفيذ (bun run) أو التجميع (bun build). لا توجد خطوة بناء منفصلة وصريحة مطلوبة فقط لتشغيل كود TypeScript الخاص بك أثناء التطوير.

مثال:

ضع في اعتبارك ملف TypeScript هذا (greet.ts):

// greet.ts
interface User {
  name: string;
  id: number;
}

function greetUser(user: User): void {
  console.log(`Hello, ${user.name} (ID: ${user.id})!`);
}

const myUser: User = { name: "Bun Developer", id: 123 };

greetUser(myUser);

// You can even use modern features Bun supports
const message = `Bun version: ${Bun.version}`;
console.log(message);

يمكنك تشغيل هذا مباشرةً:

bun run greet.ts

سيقوم Bun بتحويله داخليًا وتنفيذ JavaScript الناتج، مما ينتج عنه إخراج مثل:

Hello, Bun Developer (ID: 123)!
Bun version: 1.x.y

دعم JSX:

بالمثل، إذا كان لديك ملف .tsx يحتوي على JSX:

// component.tsx

// Assuming you have JSX configured (Bun defaults often work with React)
function MyComponent({ name }: { name: string }) {
  return <div className="greeting">Hello, {name}!</div>;
}

// NOTE: Running this directly won't render HTML,
// it just shows the transpiled JS structure.
// You'd typically use this within a larger app or framework.
console.log("Simulating component creation (transpiled output structure):");
// The actual output depends on JSX transform settings,
// but it would be JavaScript objects/function calls.

تشغيل bun run component.tsx سيقوم بتنفيذ الملف، محولًا JSX إلى JavaScript.

التكوين (tsconfig.json):

يحترم Bun ملفات tsconfig.json لخيارات التكوين التي تؤثر على التحويل. بينما لا يقوم بإجراء فحص كامل للأنواع مثل tsc (يركز Bun على سرعة التنفيذ والتحويل)، فإنه يقرأ tsconfig.json لفهم الإعدادات مثل:

jsx: ("react-jsx"، "react"، إلخ) كيفية تحويل JSX.
jsxImportSource: الوحدة النمطية لاستيراد دوال المساعدة لـ JSX منها (مثل "react").
experimentalDecorators، emitDecoratorMetadata: دعم المزيّنات (decorators).
paths، baseUrl: تعيين مسار الوحدة النمطية للأسماء المستعارة للاستيراد المخصصة.
target، module: بينما يدير Bun التنفيذ، يمكن لهذه الإعدادات أحيانًا التأثير على تفاصيل تحويل طفيفة.
strict، strictNullChecks، إلخ: هذه تؤثر بشكل أساسي على فحص الأنواع (الذي لا يقوم به Bun أثناء run)، ولكن بعض سلوك إخراج JavaScript المرتبط قد يتأثر.

إذا لم يتم العثور على ملف tsconfig.json، يستخدم Bun إعدادات افتراضية معقولة.

هذا التكامل السلس يجعل بدء مشاريع TypeScript باستخدام Bun بسيطًا وسريعًا بشكل لا يصدق، مما يقلل من حاجز الدخول ويسرع دورات التطوير.

لنتحدث عن واجهات برمجة التطبيقات الخاصة بـ Bun

بينما يركز Bun بشكل كبير على التوافق مع واجهات برمجة تطبيقات الويب القياسية وNode.js، فإنه يقدم أيضًا مجموعته الخاصة من واجهات برمجة التطبيقات المدمجة والمحسّنة تحت الكائن العام Bun. غالبًا ما توفر واجهات برمجة التطبيقات هذه بدائل عالية الأداء أو أغلفة (wrappers) مريحة للمهام الشائعة التي تستفيد من قدرات Bun البرمجية الأصلية.

إليك لمحة عن بعض واجهات برمجة التطبيقات الرئيسية Bun.*:

Bun.serve({...}): كما هو موضح في دليل البدء السريع، هذا هو حجر الزاوية لبناء خوادم HTTP وWebSocket عالية الأداء. يقدم تكوينًا مبسطًا ويستخدم توقيع معالج fetch القياسي. (تمت تغطيته بالتفصيل لاحقًا).
Bun.file(path): ينشئ كائن BunFile، وهو مرجع كسول (lazy) لملف على القرص. يوفر طرقًا محسّنة للغاية لقراءة محتويات الملف بتنسيقات مختلفة (.text()، .json()، .arrayBuffer()، .stream()) فقط عند الحاجة. هذا غالبًا أسرع بكثير من ما يعادله في node:fs.
Bun.write(path, data): النظير لـ Bun.file، يستخدم لكتابة البيانات إلى الملفات بكفاءة. يقبل أنواعًا مختلفة من البيانات (السلاسل النصية، Blobs، Buffers، كائنات BunFile أخرى) ويقوم بعمليات كتابة ذرية (atomic writes) افتراضيًا.
Bun.build({...}): يوفر وصولًا برمجيًا إلى مجمّع Bun المدمج، والذي يتوافق مع واجهة برمجة تطبيقات esbuild. يسمح بتجميع JavaScript/TypeScript للمتصفحات أو بيئات التشغيل الأخرى مباشرةً من داخل سكريبتات Bun.
Bun.spawn({...}) / Bun.spawnSync({...}): تشغيل الأوامر الخارجية كعمليات فرعية (child processes)، على غرار child_process في Node.js. يوفر واجهات برمجة تطبيقات تدفق غير متزامنة (asynchronous streaming) وإصدارًا متزامنًا أبسط، محسّنًا للحمل الزائد المنخفض.
Bun.Transpiler({...}): وصول برمجي مباشر إلى مُحَوِّل Bun الداخلي السريع لتحويل TypeScript/JSX إلى JavaScript دون تجميع كامل.
Bun.password.hash(...) / Bun.password.verify(...): دوال آمنة وسهلة الاستخدام لتجزئة كلمات المرور والتحقق منها باستخدام خوارزميات قياسية صناعية مثل Argon2id (موصى به) وbcrypt. تتجنب الحاجة إلى مكتبات خارجية.
Bun.env: كائن يوفر الوصول إلى متغيرات البيئة، على غرار process.env، ولكنه قد يوفر وصولًا أسرع في بعض السيناريوهات.
Bun.version: سلسلة نصية تحتوي على إصدار Bun الحالي قيد التشغيل.
Bun.revision: سلسلة نصية تحتوي على تجزئة Git (Git commit hash) لإصدار Bun الحالي قيد التشغيل.
Bun.sleep(ms) / Bun.sleepSync(ms): دوال لإيقاف التنفيذ مؤقتًا لمدة محددة.
Bun.gc(): تشغيل عملية جمع القمامة (garbage collection) يدويًا (استخدمها باعتدال، بشكل أساسي لأغراض التصحيح/قياس الأداء).
Bun.resolveSync(specifier, parentPath) / Bun.resolve(specifier, parentPath): إجراء حل الوحدات النمطية (module resolution) بأسلوب Node.js برمجيًا للعثور على المسار المطلق لوحدة نمطية.

تمثل واجهات برمجة التطبيقات هذه جهد Bun لتوفير حلول مدمجة ومحسّنة للمهام الشائعة في التطوير، مما يقلل الاعتماد على التبعيات الخارجية ويستفيد من سرعة نواته الأصلية.

واجهات برمجة تطبيقات الويب في Bun

اختيار تصميم أساسي في Bun هو التزامه القوي بتنفيذ واجهات برمجة تطبيقات الويب القياسية. حيثما توجد واجهة برمجة تطبيقات قياسية لمهمة معينة (خاصة للشبكات ومعالجة البيانات)، يفضل Bun تنفيذ هذا المعيار بدلاً من ابتكار واجهة برمجة تطبيقات خاصة أو الاعتماد فقط على اصطلاحات Node.js.

يقدم هذا النهج العديد من المزايا الهامة:

قابلية نقل الكود: يمكن غالبًا إعادة استخدام الكود المكتوب باستخدام واجهات برمجة تطبيقات الويب القياسية عبر بيئات JavaScript مختلفة – المتصفح، Node.js (الذي يعتمد أيضًا بشكل متزايد معايير الويب)، Deno، Cloudflare Workers، وBun – مع تعديلات أقل.
الألفة: يمكن للمطورين المألوفين بالفعل بواجهات برمجة تطبيقات المتصفح الاستفادة من تلك المعرفة عند العمل مع Bun، مما يقلل من منحنى التعلم.
مقاومة المستقبل: التوافق مع المعايير التي وضعتها هيئات مثل WHATWG وW3C يؤدي عمومًا إلى واجهات برمجة تطبيقات أكثر استقرارًا ودعمًا على نطاق واسع على المدى الطويل.
الأداء: تطبيقات Bun الأصلية لواجهات برمجة تطبيقات الويب هذه محسّنة للغاية لبيئة التشغيل الخاصة بها.

تشمل واجهات برمجة تطبيقات الويب القياسية الرئيسية التي تم تنفيذها في Bun ما يلي:

Fetch API:

fetch(): الدالة العامة لإجراء طلبات HTTP(S).
Request: يمثل طلب HTTP.
Response: يمثل استجابة HTTP.
Headers: يمثل رؤوس HTTP.

URL API:

URL: لتحليل ومعالجة عناوين URL.
URLSearchParams: للعمل مع معاملات استعلام URL.

Streams API:

ReadableStream: يمثل مصدر بيانات يمكن قراءته بشكل غير متزامن. يستخدم لأجسام الطلبات/الاستجابات، قراءة الملفات، إلخ.
WritableStream: يمثل وجهة للبيانات يمكن كتابتها بشكل غير متزامن. يستخدم لأجسام الطلبات، كتابة الملفات، إلخ.
TransformStream: دفق مزدوج يحول البيانات أثناء مرورها (مثل الضغط، الترميز).

Encoding API:

TextEncoder: يقوم بترميز السلاسل النصية إلى Uint8Array (عادةً UTF-8).
TextDecoder: يقوم بفك ترميز Uint8Array إلى سلاسل نصية.

Blob API:

Blob: يمثل بيانات خام غير قابلة للتغيير، غالبًا ما تستخدم للكائنات الشبيهة بالملفات.
File: يوسع Blob لتمثيل الملفات، بما في ذلك البيانات الوصفية مثل الاسم وتاريخ آخر تعديل. (غالبًا ما يتم إنشاؤه عبر Bun.file().slice() أو من بيانات النموذج).

FormData API:

FormData: لبناء مجموعات من أزواج المفتاح/القيمة، غالبًا ما تستخدم لإرسال بيانات النموذج في طلبات fetch.

WebSocket API:

WebSocket: واجهة برمجة تطبيقات من جانب العميل لإنشاء اتصالات WebSocket. (تتم معالجة جانب الخادم ضمن Bun.serve).

المؤقتات (Timers):

setTimeout، setInterval، clearTimeout، clearInterval: دوال قياسية لجدولة تنفيذ الكود.

Console API:

console.log، console.error، console.warn، إلخ: دوال تسجيل قياسية.

Crypto API:

crypto.subtle: يوفر الوصول إلى البدائيات التشفيرية منخفضة المستوى (التجزئة، التوقيع، التشفير).
crypto.randomUUID(): يولد UUIDs من الإصدار 4.
crypto.getRandomValues(): يولد أرقامًا عشوائية قوية تشفيريًا.

Performance API:

performance.now(): يوفر طوابع زمنية عالية الدقة لقياسات الأداء.

من خلال توفير تطبيقات قوية وعالية الأداء لواجهات برمجة تطبيقات الويب الأساسية هذه، يضع Bun نفسه كبيئة تشغيل حديثة مناسبة تمامًا لبناء تطبيقات الويب وواجهات برمجة التطبيقات والتطبيقات الأخرى التي تركز على الشبكات باستخدام واجهات مألوفة وموحدة.

خادم HTTP في Bun، شرح مفصل

الطريقة الأساسية لإنشاء خوادم الويب في Bun هي عبر واجهة برمجة تطبيقات Bun.serve. تم تصميمها لتحقيق أداء استثنائي وسهولة الاستخدام، مع التكامل السلس مع واجهات برمجة تطبيقات الويب القياسية مثل Request وResponse وfetch.

المفاهيم الأساسية:

تأخذ دالة Bun.serve كائن تكوين وتعيد كائن Server. الجزء الأكثر أهمية في التكوين هو دالة fetch.

import { type Server } from "bun";

const server: Server = Bun.serve({
  port: 8080, // The port to listen on
  hostname: "0.0.0.0", // The network interface to bind to (0.0.0.0 for all)

  // fetch: The heart of the server - handles incoming requests
  async fetch(req: Request, server: Server): Promise<Response> {
    // req is a standard Web API Request object
    // server is a reference to the Server instance itself

    const url = new URL(req.url);

    // Basic Routing Example
    if (url.pathname === "/") {
      return new Response("Homepage");
    }
    if (url.pathname === "/about") {
      return new Response("About Us page");
    }
    if (url.pathname === "/greet" && req.method === "GET") {
        const name = url.searchParams.get("name") || "World";
        return new Response(`Hello, ${name}!`);
    }
     if (url.pathname === "/data" && req.method === "POST") {
        try {
            const data = await req.json(); // Read request body as JSON
            console.log("Received data:", data);
            return new Response(JSON.stringify({ received: data }), {
               headers: { 'Content-Type': 'application/json' }
            });
        } catch (e) {