کتابخانه‌ی استاندارد · پایه

ورودی خروجی io

خواندن از صفحه‌کلید، خواندن و نوشتن پرونده و نوشتن در خروجی خطا.

واردسازی ورودی خروجی
در این صفحه
  1. روال‌ها

بیشتر برنامه‌ها باید چیزی بخوانند و چیزی بنویسند. بسته‌ی ورودی خروجی ساده‌ترین راه‌ها را برای این کار دارد: یک خط از کاربر بخوانید، یک پرونده را یک‌جا بخوانید یا بنویسید، یا با یک پرونده‌ی باز تکه‌تکه کار کنید.

روال‌هایی که نام پرونده می‌گیرند (مثل خواندن پرونده) خودشان پرونده را باز می‌کنند و می‌بندند. روال‌هایی که پرونده* می‌گیرند با پرونده‌ای کار می‌کنند که خودتان با سیستم عامل.بازکردن باز کرده‌اید؛ یادتان باشد آن را با بستن ببندید.

اندازه‌ها در این بسته بر حسب بایت است، نه حرف. هر حرف فارسی در UTF-8 دو بایت جا می‌گیرد، پس اگر پرونده‌ی فارسی را تکه‌تکه می‌خوانید، ممکن است یک حرف وسط دو تکه نصف شود.

روال‌ها

بخوان Input

روال بخوان(): رشته
یک خط از ورودی استاندارد (معمولاً صفحه‌کلید) می‌خواند و بدون نویسه‌ی پایان خط برمی‌گرداند. همان کاری است که ورودی() می‌کند. نمونه‌ی زیر منتظر تایپ شماست، پس اینجا فقط ترجمه می‌شود و اجرا نمی‌شود.
io-Input.salam
واردسازی ورودی خروجی

روال ریشه:
    چاپ "نام شما چیست؟ "
    نام := ورودی خروجی.بخوان()
    سرچاپ "خوش آمدی،", نام
پایان

خواندن Read

روال خواندن(f: پرونده*، size: طبیعی۶۴): رشته
حداکثر size بایت از جای فعلی پرونده می‌خواند. اگر به پایان پرونده رسیده باشید، رشته‌ی تهی برمی‌گرداند.
io-Read.salam
واردسازی ورودی خروجی
واردسازی سیستم عامل

روال ریشه:
    ورودی خروجی.نوشتن پرونده("داده.txt"، "salam\ndonya\npayan\n")
    پ := سیستم عامل.بازکردن("داده.txt"، "rb")
    سرچاپ ورودی خروجی.خواندن خط(پ)
    سرچاپ ورودی خروجی.خواندن(پ، ۳ برگردان طبیعی۶۴)
    ورودی خروجی.جابجایی مکان نما(پ، ۰، ۰)
    چاپ ورودی خروجی.خواندن همه(پ)
    ورودی خروجی.بستن(پ)
پایان
خروجیsalam don salam donya payan

خواندن خط Readline

روال خواندن خط(f: پرونده*): رشته
یک خط از پرونده می‌خواند، بدون نویسه‌ی پایان خط. در پایان پرونده رشته‌ی تهی برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-Read.salam

نوشتن Write

روال نوشتن(f: پرونده*، data: رشته): صحیح
رشته را در پرونده‌ی باز می‌نویسد و تعداد بایت‌های نوشته‌شده را برمی‌گرداند.
io-Write.salam
واردسازی ورودی خروجی
واردسازی سیستم عامل

روال ریشه:
    پ := سیستم عامل.بازکردن("گزارش.txt"، "wb")
    ن := ورودی خروجی.نوشتن(پ، "گزارش امروز\n")
    ورودی خروجی.بستن(پ)
    سرچاپ "بایت‌های نوشته‌شده:", ن
    مبدأ := سیستم عامل.بازکردن("گزارش.txt"، "rb")
    مقصد := سیستم عامل.بازکردن("رونوشت.txt"، "wb")
    سرچاپ "رونوشت:", ورودی خروجی.کپی(مقصد، مبدأ), "بایت"
    ورودی خروجی.بستن(مبدأ)
    ورودی خروجی.بستن(مقصد)
    چاپ ورودی خروجی.خواندن پرونده("رونوشت.txt")
پایان
خروجیبایت‌های نوشته‌شده: 22 رونوشت: 22 بایت گزارش امروز

جابجایی مکان نما Seek

روال جابجایی مکان نما(f: پرونده*، offset: صحیح۶۴، whence: صحیح): صحیح
جای خواندن و نوشتن را در پرونده جابه‌جا می‌کند. offset فاصله بر حسب بایت است و whence می‌گوید از کجا شمرده شود: صفر یعنی از آغاز پرونده، یک یعنی از جای فعلی و دو یعنی از پایان پرونده. اگر موفق شود صفر برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-Read.salam

بستن Close

روال بستن(f: پرونده*)
پرونده را می‌بندد. هر پرونده‌ای که باز می‌کنید باید یک بار بسته شود؛ جای خوبی برایش دیرکن است.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-Read.salam

خواندن پرونده ReadFile

روال خواندن پرونده(path: رشته): رشته
همه‌ی محتوای یک پرونده را یک‌جا می‌خواند. اگر پرونده وجود نداشته باشد یا خواندنش ممکن نباشد، رشته‌ی تهی برمی‌گرداند.
io-ReadFile.salam
واردسازی ورودی خروجی

روال ریشه:
    مسیر := "یادداشت.txt"
    ورودی خروجی.نوشتن پرونده(مسیر، "خط نخست\n")
    ورودی خروجی.افزودن به پرونده(مسیر، "خط دوم\n")
    چاپ ورودی خروجی.خواندن پرونده(مسیر)
    سرچاپ ورودی خروجی.خواندن پرونده("پرونده‌ای که نیست.txt") == ""
پایان
خروجیخط نخست خط دوم true

نوشتن پرونده WriteFile

روال نوشتن پرونده(path: رشته، data: رشته): صحیح
پرونده را می‌سازد (یا اگر هست، محتوای قبلی‌اش را پاک می‌کند) و رشته را در آن می‌نویسد. تعداد بایت‌های نوشته‌شده را برمی‌گرداند و اگر نتواند پرونده را باز کند، منفی یک.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-ReadFile.salam

افزودن به پرونده AppendFile

روال افزودن به پرونده(path: رشته، data: رشته): صحیح
رشته را به انتهای پرونده اضافه می‌کند و به محتوای قبلی دست نمی‌زند. اگر پرونده نباشد، ساخته می‌شود. مثل نوشتن پرونده تعداد بایت‌ها یا منفی یک برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-ReadFile.salam

خط ها Lines

روال خط ها(path: رشته): وکتور<رشته>
پرونده را می‌خواند و خط‌هایش را در یک وکتور برمی‌گرداند. فاصله‌ها و خط خالیِ آخر پرونده حذف می‌شوند. وکتور را پس از کار با آزادکن رها کنید.
io-Lines.salam
واردسازی ورودی خروجی

روال ریشه:
    ناپایا خط‌ها := وکتور {} برگردان وکتور<رشته>
    دیرکن خط‌ها.آزادکن()
    خط‌ها.بیفزا("سیب")
    خط‌ها.بیفزا("انار")
    خط‌ها.بیفزا("انگور")
    بایت := ورودی خروجی.نوشتن خط ها("میوه‌ها.txt"، خط‌ها)
    سرچاپ "نوشته شد:", بایت, "بایت"
    خوانده := ورودی خروجی.خط ها("میوه‌ها.txt")
    دیرکن خوانده.آزادکن()
    هر (ش، م) در خوانده:
        سرچاپ ش + ۱, م
    پایان
پایان
خروجینوشته شد: 27 بایت 1 سیب 2 انار 3 انگور

نوشتن خطا EPrint

روال نوشتن خطا(s: رشته)
رشته را در خروجی خطا (stderr) می‌نویسد، بدون رفتن به خط بعد. پیام‌های خطا و هشدار جایشان اینجاست، نه در خروجی عادی برنامه.
io-EPrint.salam
واردسازی ورودی خروجی

روال ریشه:
    سرچاپ "این در خروجی عادی است"
    ورودی خروجی.نوشتن خطا("هشدار: ")
    ورودی خروجی.نوشتن خطا با خط جدید("این پیام در خروجی خطا می‌رود")
    چاپ "بدون خط تازه..."
    ورودی خروجی.تخلیه()
    سرچاپ ""
پایان
خروجیاین در خروجی عادی است هشدار: این پیام در خروجی خطا می‌رود بدون خط تازه...

نوشتن خطا با خط جدید EPrintln

روال نوشتن خطا با خط جدید(s: رشته)
مثل نوشتن خطا، ولی پس از پیام به خط بعد می‌رود.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-EPrint.salam

تخلیه Flush

روال تخلیه()
هر چه در حافظه‌ی میانی خروجی مانده، همین حالا نوشته می‌شود. وقتی با چاپ متنی بدون پایان خط نوشته‌اید و می‌خواهید کاربر فوراً آن را ببیند، به کار می‌آید.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-EPrint.salam

خواندن همه ReadAll

روال خواندن همه(f: پرونده*): رشته
همه‌ی آنچه از جای فعلی تا پایان پرونده مانده را می‌خواند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-Read.salam

کپی Copy

روال کپی(dst: پرونده*، src: پرونده*): صحیح۶۴
هر چه در پرونده‌ی src مانده را در پرونده‌ی dst می‌نویسد و تعداد بایت‌های رونوشت‌شده را برمی‌گرداند. برای پرونده‌های بزرگ مناسب است، چون همه‌ی پرونده را یک‌جا در حافظه نمی‌آورد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-Write.salam

نوشتن خط ها WriteLines

روال نوشتن خط ها(path: رشته، lines: وکتور<رشته>): صحیح
هر عضو وکتور را در یک خط پرونده می‌نویسد. پرونده اگر باشد از نو نوشته می‌شود. تعداد بایت‌ها یا منفی یک برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: io-Lines.salam