آموزشهونو (Hono)

درس ۵ از ۳۳، برنامه‌نویسی و علوم کامپیوتر، حدود ۳۰ دقیقه خواندن

ساختن پروژه و اولین مسیر

جواب کوتاه

طبق سند رسمی هونو، برای راه‌اندازی روی Bun، اول Bun رو از سند رسمی خودش نصب می‌کنید؛ مثلا با `npm install -g bun`، اگه Node و npm رو دارید، و با `bun --version` بررسیش می‌کنید. بعد، با `bun create hono@latest my-app` یه پروژه می‌سازید و الگوی bun رو انتخاب می‌کنید؛ توی پوشه‌ی پروژه، `bun install` بسته‌ها رو نصب می‌کنه، و `bun run dev` سرور رو روشن می‌کنه. سند رسمی می‌گه بعد، نشانی `http://localhost:3000` رو توی مرورگر باز کنید. فایل اصلی، src/index.ts ـه، که یه app هونو می‌سازه، با app.get یه مسیر تعریف می‌کنه، و با export default app صادرش می‌کنه. از اینجا، با app.get و c.text یا c.json، مسیرهای خودتون رو اضافه می‌کنید و با مرورگر یا curl صداشون می‌زنید.

باز کردن یه باجه‌ی کوچیک

فرض کنید می‌خواید یه باجه‌ی کوچیک چای کنار خیابون باز کنید. اول باجه رو سر هم می‌کنید، یه تابلو بالاش می‌زنید، و یه پنجره باز می‌کنید. اولین مشتری که میاد و می‌گه «یه چای»، شما یه چای بهش می‌دید. همین؛ باجه باز شده. بعدا می‌تونید قهوه و کیک هم اضافه کنید؛ ولی اول، باید پنجره باز باشه و یه سفارش جواب بده.

این درس، همین باجه رو برای API ـتون می‌سازه: یه پروژه‌ی هونو روی Bun، که اولین درخواست رو جواب می‌ده. توی درس قبل دیدیم API و REST چیه؛ از این درس، کد واقعی می‌نویسیم. همه‌ی قدم‌ها از سند رسمی هونو و Bun ـه.

توی این درس چی کار می‌کنیم

قدم‌های این درس:

  1. Bun رو نصب و بررسی می‌کنیم.
  2. با یه فرمان، پروژه‌ی هونو می‌سازیم.
  3. سرور رو روشن می‌کنیم و اولین جواب رو توی مرورگر می‌بینیم.
  4. چند مسیر خودمون رو اضافه می‌کنیم: متن، JSON، و یه POST.
  5. با curl، از ترمینال، درخواست می‌فرستیم و جواب‌ها رو می‌خونیم.

فرض این درس اینه که VS Code و Node رو، از درس نصب ابزار مسیر تایپ‌اسکریپت، دارید. حدود نیم ساعت وقت بذارید.

Bun چیه

طبق سند رسمی هونو، Bun یه محیط اجرای جاوااسکریپته؛ نه Node.js، نه Deno؛ یه محیط دیگه. همون سند می‌گه Bun یه مترجم داخلی داره؛ پس می‌شه کد رو مستقیم با تایپ‌اسکریپت یا جاوااسکریپت خالی نوشت؛ و هونو، روی Bun هم کار می‌کنه.

یعنی برخلاف چیزی که توی مسیر تایپ‌اسکریپت با tsc دیدیم، اینجا لازم نیست اول فایل ts رو به js ترجمه کنید؛ Bun، خودش، فایل تایپ‌اسکریپت رو مستقیم اجرا می‌کنه. یادتون باشه، همون‌طور که اونجا گفتیم، این اجرای مستقیم، نوع‌ها رو بررسی نمی‌کنه؛ برای بررسی، هنوز ویرایشگر و tsc لازمه.

نصب Bun

سند رسمی هونو می‌گه برای نصب Bun، دستورهای سایت رسمی Bun رو دنبال کنید. طبق صفحه‌ی نصب Bun، چند راه هست. چون شما Node و npm رو از قبل دارید، ساده‌ترینش، همونیه که خود صفحه، زیر مدیرهای بسته، نوشته: npm install -g bun. این، Bun رو برای کل کامپیوتر نصب می‌کنه.

راه‌های دیگه‌ای هم هست که صفحه‌ی رسمی نوشته: روی مک و لینوکس، یه اسکریپت نصب؛ روی ویندوز، یه فرمان PowerShell؛ و چند مدیر بسته‌ی دیگه. طبق همون صفحه، Bun روی ویندوز، نسخه‌ی ۱۰ با به‌روزرسانی ۱۸۰۹ به بالا رو لازم داره؛ و روی لینوکس، بسته‌ی unzip برای نصب. هر کدوم رو که انتخاب کنید، فقط از صفحه‌ی رسمی کپی کنید.

بررسی نصب

طبق صفحه‌ی نصب Bun، برای اینکه مطمئن بشید نصب درست انجام شده، یه پنجره‌ی ترمینال تازه باز کنید و بنویسید bun --version. یه شماره‌ی نسخه می‌بینید؛ یعنی Bun آماده‌ست.

همون صفحه، یه گیر رایج رو هم می‌گه: اگه Bun رو نصب کردید ولی پیام «فرمان پیدا نشد» می‌بینید، ممکنه لازم باشه پوشه‌ی نصبش رو دستی به مسیر فرمان‌های سیستم اضافه کنید؛ و راهنمای این کار رو، برای هر سیستم‌عامل، داره. ولی اول، کار ساده‌تر رو امتحان کنید: VS Code رو ببندید و دوباره باز کنید؛ مثل همون کاری که برای Node کردیم.

یه نکته‌ی دیگه هم از همون صفحه: Bun، به شکل یه فایل اجرایی تنها و بی وابستگی منتشر می‌شه، و روی مک، لینوکس و ویندوز نصب می‌شه. یعنی نصبش، چیز دیگه‌ای روی کامپیوترتون عوض نمی‌کنه؛ و اگه یه روز نخواستیدش، پاک کردنش هم ساده‌ست.

ساختن پروژه

VS Code رو باز کنید، پوشه‌ای که می‌خواید پروژه توش ساخته بشه رو با Open Folder باز کنید، و از منوی View، ترمینال رو باز کنید. طبق سند رسمی هونو، برای Bun، بنویسید: bun create hono@latest my-app.

این فرمان، از الگوهای آماده‌ی هونو، یه پروژه‌ی تازه توی پوشه‌ی my-app می‌سازه. سند رسمی هونو، برای هر محیط اجرا، الگوی جدایی داره، و این فرمان ازتون می‌پرسه کدوم رو می‌خواید.

انتخاب الگو

طبق صفحه‌ی شروع سند رسمی، بعد از فرمان ساخت، ازتون پرسیده می‌شه کدوم الگو رو می‌خواید؛ با فهرستی از محیط‌ها، مثل aws-lambda، bun، deno، nodejs و چند تای دیگه. راهنمای Bun ـی سند رسمی می‌گه برای این کار، الگوی bun رو انتخاب کنید.

از فهرستی که توی ترمینال نشون داده می‌شه، bun رو انتخاب کنید. اگه سوال‌های دیگه‌ای پرسید، مثلا درباره‌ی نصب بسته‌ها یا مدیر بسته، گزینه‌ای که خودش پیشنهاد کرده رو قبول کنید؛ یا اگه مطمئن نبودید، Bun رو به‌عنوان مدیر بسته انتخاب کنید.

نصب بسته‌ها

طبق سند رسمی هونو، بعد از ساختن پروژه، به پوشه‌ی my-app برید و بسته‌ها رو نصب کنید. توی VS Code، یعنی: از منوی File، با Open Folder، پوشه‌ی my-app رو باز کنید، یه ترمینال تازه بگیرید، و بنویسید bun install.

Bun، بسته‌ها رو، مثل npm، توی پوشه‌ی node_modules نصب می‌کنه؛ و اسمشون، توی package.json هست. این کار معمولا خیلی سریعه؛ چند ثانیه. اگه ابزار ساخت، موقع ساختن پروژه، خودش بسته‌ها رو نصب کرده باشه، این فرمان فقط بررسی می‌کنه و زود تموم می‌شه.

پروژه چه شکلیه

توی Explorer، یه پروژه‌ی خیلی کوچیک می‌بینید: یه package.json، یه tsconfig.json، پوشه‌ی node_modules، و یه پوشه‌ی src با یه فایل: index.ts. همین. برخلاف نکست جی‌اس، اینجا ساختار پوشه‌ی خاصی تحمیل نشده؛ کل API، فعلا یه فایله.

این کوچیکی، عمدیه؛ همون «کوچیک و ساده» ـی که سند رسمی هونو ازش حرف می‌زد. وقتی پروژه بزرگ‌تر شد، خودتون تصمیم می‌گیرید مسیرها رو چطور به فایل‌های جدا تقسیم کنید؛ که ایستگاه دوم، توی درس گروه کردن مسیرها، یاد می‌ده.

فایل src/index.ts

فایل src/index.ts رو باز کنید. طبق راهنمای Bun ـی سند رسمی، چیزی شبیه این می‌بینید: import { Hono } from 'hono'، بعد const app = new Hono()، بعد app.get('/', (c) => c.text('Hello Bun!'))، و آخر export default app. سند می‌گه این، تقریبا همونیه که روی بسترهای دیگه هم می‌نویسید.

همون سه خطی که توی درس دوم، روی کاغذ، دیدیم؛ این بار، توی یه فایل واقعی. خط اول، هونو رو از بسته‌ی hono وارد می‌کنه. بقیه، همون app، مسیر و صادر کردن. متن الگوی شما ممکنه کمی فرق کنه، مثلا Hello Hono!؛ ولی شکلش همینه.

روشن کردن سرور

طبق سند رسمی، برای اجرا، بنویسید bun run dev. این، کار dev ـی package.json رو اجرا می‌کنه؛ که طبق همون سند، فایل src/index.ts رو با Bun، در حالت به‌روزرسانی داغ، اجرا می‌کنه. توی ترمینال، یه پیام کوتاه می‌بینید که سرور روشن شده.

تا وقتی این ترمینال باز و این فرمان در حال اجراست، API شما روی کامپیوترتون کار می‌کنه و منتظر درخواسته. برای خاموش کردنش، مثل همیشه، ترمینال رو ببندید.

اولین جواب

طبق سند رسمی، نشانی http://localhost:3000 رو توی مرورگر باز کنید. روی صفحه، فقط یه متن ساده می‌بینید: Hello Bun!، یا هر متنی که الگو نوشته. نه رنگی، نه دکمه‌ای؛ فقط متن. این، اولین جواب API شماست.

چی اتفاق افتاد؟ مرورگر، یه درخواست GET به نشانی / فرستاد؛ Bun، درخواست رو به تابع fetch ـی app داد؛ مسیریاب هونو، کنترل‌کننده‌ی app.get('/') رو پیدا کرد؛ کنترل‌کننده، با c.text، یه جواب ساخت؛ و جواب، با کد ۲۰۰، به مرورگر برگشت. همه‌ی چیزهایی که توی سه درس قبل گفتیم، توی یه چشم به هم زدن.

تغییر، بی خاموش کردن سرور

متن داخل c.text رو توی index.ts عوض کنید، مثلا به «سلام هونو»، و فایل رو ذخیره کنید. حالا صفحه‌ی مرورگر رو یه بار دوباره بارگذاری کنید؛ متن تازه رو می‌بینید. لازم نبود سرور رو خاموش و روشن کنید.

این، کار گزینه‌ی hot توی کار dev ـه، که سند رسمی، توی تنظیم پروژه‌ی موجود، نشونش داده: bun run --hot src/index.ts. Bun، با هر ذخیره، کد تازه رو بارگذاری می‌کنه. فرقش با به‌روز شدن فوری Vite اینه که اینجا، مرورگر رو خودتون دوباره بارگذاری می‌کنید؛ چون صفحه‌ای در کار نیست که خودش رو تازه کنه.

عوض کردن دریچه

سرور، روی دریچه‌ی ۳۰۰۰ کار می‌کنه. اگه پروژه‌ی نکست جی‌اس مسیر قبلی هم، که اون هم روی ۳۰۰۰ ـه، روشن باشه، این دو با هم برخورد می‌کنن. سند رسمی هونو، برای Bun، راه عوض کردن دریچه رو نشون می‌ده: به جای export default app، یه شیء صادر می‌کنید، با دو چیز: port، با شماره‌ی دلخواه، و fetch، که همون app.fetch ـه.

مثلا با port برابر ۳۰۰۱، API روی localhost:3001 می‌ره، و نکست جی‌اس روی ۳۰۰۰ می‌مونه. این، همون fetch ـیه که توی درس دوم گفتیم: Bun، فقط یه شیء با تابع fetch می‌خواد؛ و app.fetch، دقیقا همونه.

اگه Node رو ترجیح می‌دید

اگه به هر دلیلی نمی‌خواید Bun نصب کنید، سند رسمی هونو یه راهنمای جدا برای Node.js داره؛ با الگوی nodejs و یه وصل‌کننده‌ی مخصوص، چون Node، از قدیم، شیوه‌ی خودش رو برای سرور داشته. فرمان ساختش، با npm، اینه: npm create hono@latest my-app، و انتخاب الگوی nodejs.

همه‌ی کدهای این مسیر، یعنی مسیرها، میان‌افزارها و منطق برنامه، روی Node هم بی تغییر کار می‌کنن؛ فقط نقطه‌ی ورود، یعنی بالا و پایین فایل اصلی، فرق می‌کنه. همون «یه کد، چند محیط» ـی که سند رسمی بارها تکرار می‌کنه.

مسیر دوم خودتون

حالا، اولین مسیر خودتون. زیر app.get ـی موجود، بنویسید: app.get('/hello', (c) => c.text('سلام از مسیر دوم')). ذخیره کنید و localhost:3000/hello رو توی مرورگر باز کنید. متن تازه رو می‌بینید.

یه تمرین کوچیک: localhost:3000/hi رو باز کنید؛ مسیری که نساختید. جوابی می‌بینید که می‌گه پیدا نشد؛ با کد ۴۰۴. هونو، خودش، برای هر نشانی‌ای که با هیچ مسیری جور نیست، همین جواب رو می‌ده؛ و ایستگاه سوم، یاد می‌ده چطور با app.notFound، این جواب رو خودتون بسازید.

اولین جواب JSON

API ها، معمولا JSON جواب می‌دن. یه مسیر برای یه کتاب بسازید: app.get('/book', (c) => c.json({ title: 'شازده کوچولو', year: 1943 })). ذخیره کنید و localhost:3000/book رو باز کنید. مرورگر، یه JSON نشون می‌ده؛ بعضی مرورگرها، حتی مرتبش می‌کنن.

طبق سند رسمی Context، c.json، شیء رو به JSON تبدیل می‌کنه و نوع محتوا رو application/json می‌ذاره. یعنی هر برنامه‌ای که این مسیر رو صدا بزنه، می‌دونه با JSON طرفه. حالا یه مسیر برای فهرست بسازید، که یه آرایه از دو سه کتاب برگردونه؛ همون GET /books ـی درس قبل.

صدا زدن با curl

مرورگر، فقط درخواست GET می‌فرسته. برای بقیه‌ی روش‌ها، از curl استفاده می‌کنیم؛ یه ابزار خط فرمان رایگان، که روی بیشتر سیستم‌عامل‌های امروزی، از قبل نصبه. یه ترمینال دوم توی VS Code باز کنید، چون اولی، سرور رو اجرا می‌کنه، و بنویسید: curl http://localhost:3000/book. همون JSON رو، این بار توی ترمینال، می‌بینید.

برای دیدن کد وضعیت و سرآیندها، یه گزینه اضافه کنید: curl -i http://localhost:3000/book. حالا اول جواب، خط HTTP با کد ۲۰۰ رو می‌بینید، بعد سرآیندها، از جمله نوع محتوای application/json، و آخر، بدنه. همون جواب کاملی که توی درس قبل، تیکه‌به‌تیکه، توضیح دادیم؛ حالا جلوی چشم.

اولین POST

حالا یه مسیر POST. توی index.ts بنویسید: app.post('/books', async (c) => { const book = await c.req.json(); c.status(201); return c.json(book) }). این مسیر، بدنه‌ی JSON ـی درخواست رو می‌خونه، با c.status، که سند رسمی Context دقیقا با همین مثال ۲۰۱ نشونش داده، کد وضعیت رو «ساخته شد» می‌کنه، و همون کتاب رو برمی‌گردونه. فعلا هیچ جا ذخیره‌ش نمی‌کنه؛ ایستگاه داده، اونو به دیتابیس وصل می‌کنه.

برای امتحان، از ترمینال دوم، یه درخواست POST با curl بفرستید، با گزینه‌ی روش، سرآیند نوع محتوا، و بدنه‌ی JSON. جواب، همون JSON ـیه که فرستادید، با کد ۲۰۱. این، اولین بار بود که API شما ورودی گرفت؛ و یادتون باشه، هنوز هیچ بررسی‌ای روش نکرده. ایستگاه چهارم، اینو درست می‌کنه.

یه نگاه کوتاه: تست بی سرور

یادتون هست که توی درس دوم، از app.request گفتیم؟ تابعی که یه درخواست به app می‌فرسته، بی سرور واقعی. یعنی همین مسیر /book رو، توی یه فایل تست، می‌شه این‌طوری بررسی کرد: یه درخواست به /book، و بررسی اینکه کد وضعیت ۲۰۰ ـه و اسم کتاب درسته.

Bun، یه ابزار تست داخلی داره، که ایستگاه هفتم، با همین app.request، کامل نشونش می‌ده. از اون موقع، دیگه لازم نیست هر بار، دستی با curl امتحان کنید؛ با یه فرمان، همه‌ی مسیرها، در یه چشم به هم زدن، بررسی می‌شن.

کار dev، از نزدیک

طبق سند رسمی، اگه بخواید هونو رو به یه پروژه‌ی Bun ـی موجود اضافه کنید، فقط دو کار لازمه: نصب بسته‌ی hono با bun add hono، و اضافه کردن کار dev به package.json، با bun run --hot src/index.ts. سند می‌گه این کار، انتظار داره فایل اصلی، توی src/index.ts باشه.

یعنی کل جادوی الگو، همینه: یه بسته، یه کار، یه فایل. اگه package.json پروژه‌تون رو باز کنید، همین کار dev رو، با همین شکل، می‌بینید. دونستنش کمک می‌کنه اگه یه روز، فایل اصلی رو جای دیگه‌ای بردید، بدونید کجا رو هم باید عوض کنید.

فایل‌های ایستا

سند رسمی هونو، برای Bun، یه نکته‌ی دیگه هم داره: اگه بخواید فایل‌های ایستا، مثل یه عکس یا یه فایل متنی، رو از API بدید، از serveStatic ـی بسته‌ی @hono/bun استفاده کنید؛ که یه میان‌افزاره و یه پوشه رو به یه نشانی وصل می‌کنه.

برای یه API، این کم پیش میاد؛ چون API ها معمولا داده می‌دن، نه فایل. ولی خوبه بدونید هست؛ مثلا برای یه آیکون، یا یه صفحه‌ی کوچیک راهنما برای کسایی که API رو صدا می‌زنن. این، اولین میان‌افزاریه که توی این مسیر اسمش اومد؛ ایستگاه سوم، بقیه رو می‌بینه.

کار با دو ترمینال

از این درس به بعد، تقریبا همیشه دو ترمینال باز دارید: یکی که سرور توش اجرا می‌شه و پیام‌هاش رو نشون می‌ده، و یکی برای فرمان‌های دیگه، مثل curl یا نصب بسته. VS Code، توی پنل ترمینال، اجازه می‌ده چند ترمینال کنار هم داشته باشید، و بینشون جابه‌جا بشید.

یه عادت خوب: ترمینال سرور رو هیچ‌وقت برای فرمان‌های دیگه به کار نبرید؛ چون تا وقتی سرور روشنه، اون ترمینال مشغوله. و هر وقت یه درخواست زدید و جواب عجیب گرفتید، اول به ترمینال سرور نگاه کنید؛ خطاهای سمت سرور، اونجا چاپ می‌شن، نه توی جواب curl.

یه نگاه کوتاه: پارامتر نشانی

توی درس REST دیدیم که هر کتاب، یه نشانی مثل /books/42 داره. برای ساختن چنین مسیری، طبق سند رسمی مسیریابی هونو، توی نشانی، یه دونقطه و یه اسم می‌ذارید: /books/:id. حالا این مسیر، هم /books/42 رو می‌گیره، هم /books/7، و هر عدد دیگه‌ای.

توی کنترل‌کننده، با c.req.param و اسم پارامتر، مقدارش رو می‌خونید؛ مثلا id، که ۴۲ ـه. سند رسمی حتی نشون می‌ده که می‌شه همه‌ی پارامترها رو یه‌جا گرفت؛ مثلا برای مسیری مثل /posts/:id/comment/:comment_id. درس بعدی، کل مسیریابی هونو، از جمله همین پارامترها، رو کامل باز می‌کنه.

این سرور فقط مال خودتونه

سروری که الان روشن کردید، روی localhost ـه؛ یعنی فقط از روی همین کامپیوتر در دسترسه. هیچ‌کس دیگه، از اینترنت، نمی‌تونه API ـتون رو صدا بزنه؛ و این، برای یادگیری، دقیقا همون چیزیه که می‌خوایم. هر اشتباهی بکنید، فقط روی کامپیوتر خودتونه.

ایستگاه هفتم، یاد می‌ده چطور این API رو روی یه سرور واقعی ببرید، تا از بیرون هم در دسترس باشه. و درست پیش از اون، ایستگاه ششم، امنیت رو یاد می‌ده؛ چون لحظه‌ای که API روی اینترنت بره، هر کسی می‌تونه بهش درخواست بفرسته، و هر ورودی بررسی‌نشده، یه در باز می‌شه.

کی متن، کی JSON

توی این درس، هم c.text رو به کار بردیم، هم c.json. کدوم رو کی؟ قاعده‌ی ساده: اگه جواب برای خوندن یه آدمه و فقط یه پیام کوتاهه، مثل یه پیام سلام یا یه پیام سلامت سرور، متن کافیه. اگه جواب قراره یه برنامه‌ی دیگه بخونه، و داده‌ی ساختاریافته داره، همیشه JSON.

توی یه API واقعی، تقریبا همه‌ی جواب‌ها JSON ـن؛ حتی پیام‌های خطا. مثلا به جای یه متن «پیدا نشد»، یه JSON با یه کلید error و یه پیام. این‌طوری، برنامه‌ای که API رو صدا می‌زنه، همیشه می‌دونه جواب چه شکلی داره و چطور بخوندش. ایستگاه سوم، شکل یکسان خطاها رو یاد می‌ده.

سفر یه درخواست، از اول تا آخر

بیاید یه بار دیگه، دقیق، سفر یه درخواست curl به /book رو دنبال کنیم. curl، یه پیام HTTP با روش GET و نشانی /book می‌سازه و به دریچه‌ی ۳۰۰۰ ـی همین کامپیوتر می‌فرسته. Bun، که روی این دریچه منتظره، پیام رو می‌گیره، یه شیء Request استاندارد ازش می‌سازه، و تابع fetch ـی app رو باهاش صدا می‌زنه.

هونو، یه Context تازه می‌سازه، با مسیریابش، کنترل‌کننده‌ی app.get('/book') رو پیدا می‌کنه، و صداش می‌زنه. کنترل‌کننده، با c.json، یه Response استاندارد می‌سازه. Bun، این جواب رو به شکل یه پیام HTTP، با کد ۲۰۰ و سرآیندها و بدنه، به curl برمی‌گردونه؛ و curl، چاپش می‌کنه. همه‌ی این‌ها، توی کسری از ثانیه.

این پروژه، تا آخر مسیر

پروژه‌ی my-app ـی که امروز ساختید، تا آخر این مسیر همراهتونه. هر ایستگاه، یه چیز بهش اضافه می‌کنه: ایستگاه دوم، مسیرهای بیشتر و گروه‌بندی؛ سوم، میان‌افزار و مدیریت خطا؛ چهارم، بررسی ورودی؛ پنجم، دیتابیس؛ ششم، ورود و دسترسی؛ و هفتم، تست و انتشار.

تا آخر، یه فایل index.ts، به یه پروژه‌ی مرتب، با چند پوشه، تبدیل می‌شه. پس از همین حالا، با دقت باهاش کار کنید؛ و اگه با گیت آشنایید، از همین امروز، هر تغییر رو ثبت کنید. اگه نه، ایستگاه کد خوب مسیر تایپ‌اسکریپت، یه درس درباره‌ی گیت داره.

گیرهای رایج

چند گیر رایج روز اول:

  • فرمان bun پیدا نشد: VS Code رو ببندید و باز کنید؛ اگه نشد، راهنمای مسیر فرمان صفحه‌ی نصب Bun.
  • دریچه‌ی ۳۰۰۰ مشغوله: پروژه‌ی دیگه‌ای، مثل نکست جی‌اس، روشنه؛ خاموشش کنید یا دریچه رو عوض کنید.
  • تغییر دیده نشد: فایل رو ذخیره کردید؟ مرورگر رو دوباره بارگذاری کردید؟
  • curl جواب نداد: سرور توی ترمینال اول روشنه؟ curl رو توی ترمینال دوم زدید؟
  • POST با خطا برگشت: سرآیند نوع محتوای JSON رو فرستادید؟ JSON بدنه درسته؟

جواب کوتاه

اگه کسی پرسید «پروژه‌ی هونو رو چطور راه بندازم»:

Bun رو از سند رسمی نصب کنید؛ با bun create hono@latest my-app و الگوی bun، پروژه بسازید؛ توی پوشه، bun install و bun run dev؛ و http://localhost:3000 رو باز کنید. مسیرها توی src/index.ts ـن؛ با app.get و c.text یا c.json، مسیر تازه می‌سازید.

چند باور رایج

  • «برای اجرای تایپ‌اسکریپت روی Bun، اول باید با tsc ترجمه کرد.» Bun مستقیم اجرا می‌کنه؛ بررسی نوع، جدا.
  • «API باید یه صفحه‌ی قشنگ نشون بده.» متن و JSON، کافیه.
  • «مرورگر هر نوع درخواستی می‌فرسته.» با نشانی، فقط GET؛ بقیه با curl.
  • «هونو فقط روی Bun کار می‌کنه.» الگوی nodejs هم هست.
  • «با هر تغییر، باید سرور رو خاموش و روشن کرد.» با hot، خودش تازه می‌شه.

یه مثال

آرش، اولین API ـش رو با همین درس ساخت و خیلی ذوق کرد که Hello Bun! رو توی مرورگر دید. بعد مسیر /book رو اضافه کرد؛ ولی هر چی مرورگر رو بارگذاری می‌کرد، پیام «پیدا نشد» می‌گرفت. ده دقیقه بعد فهمید فایل رو ذخیره نکرده بوده؛ و نوار بالای زبونه‌ی فایل، یه نقطه داشت که می‌گفت تغییرها ذخیره نشده.

روز بعد، می‌خواست POST رو امتحان کنه و توی مرورگر، نشانی /books رو باز کرد؛ و چون مرورگر GET فرستاد، باز «پیدا نشد» گرفت؛ چون فقط POST تعریف کرده بود. همون‌جا فهمید چرا curl لازمه. دو اشتباه کوچیک، که هر کدوم، یه درس بزرگ‌تر رو جا انداخت: روش، بخشی از مسیره.

تمرین امروز

امروز، باجه‌تون رو باز کنید.

  1. Bun رو نصب کنید و با bun --version بررسیش کنید.
  2. پروژه‌ی my-app رو با الگوی bun بسازید، bun install و bun run dev رو بزنید.
  3. سه مسیر بسازید: /hello با متن، /book با JSON یه کتاب، و /books با JSON یه فهرست.
  4. با curl -i، هر سه رو صدا بزنید و کد وضعیت و نوع محتوا رو بخونید.
  5. مسیر POST /books رو بسازید و با curl، یه کتاب بفرستید؛ کد ۲۰۱ رو ببینید.

درس بعدی، مسیریابی هونو رو کامل باز می‌کنه: مسیریابی در هونو.

جمع‌بندی. آنچه از این درس با خودتان می‌برید.

  • نصب Bun از سند رسمی؛ بررسی با bun --version.
  • ساختن پروژه: bun create hono@latest my-app، با الگوی bun.
  • bun install، بعد bun run dev، و نشانی http://localhost:3000.
  • فایل اصلی: src/index.ts؛ app، مسیرها و export default app.
  • مسیر تازه با app.get و c.json؛ امتحان با مرورگر و curl.

خودتون رو بسنجید

۱۵ پرسش، هر بار تازه از میان ۳۰ پرسش این درس. آخرش فقط کارنامه رو می‌بینید: چند تا درست، چند تا نادرست.

خودتون رو بسنجید

۱۵ پرسش

  • هر بار پرسش‌ها و ترتیب گزینه‌ها عوض می‌شه.
  • تا آخر نمی‌گیم کدوم جواب درست بوده؛ می‌تونید برگردید و جوابتون رو عوض کنید.
  • آخرش کارنامه می‌گیرید: چند تا درست، چند تا نادرست.
  • اگه وسطش بستید، دوباره که باز کنید از همون‌جا ادامه می‌دید.

فصل‌های این درس

درس بعد