اولین مخزن و commit

توی این درس یاد می‌گیری چرخه‌ی اصلی کار با Git را: هر فایل در یکی از سه جا زندگی می‌کند، پوشه‌ی کاری (working directory)، ناحیه‌ی آماده‌سازی (staging area) و مخزن (repository)؛ و با چهار دستور بین آن‌ها حرکت می‌کند: git init، git status، git add و git commit -m. می‌فهمی چرا commit دو مرحله دارد، فرق git add . و -A و -u چیست، یک پیام commit خوب چه شکلی است، و Git پشت پرده برای هر مرحله چه می‌سازد. تمرین: یک پروژه‌ی کوچک را در سه commit منطقی ذخیره کن.

مسئله: چرا commit دو مرحله دارد؟

فرض کن امروز سه فایل را عوض کرده‌ای: یکی برای رفع یک باگ و دو تا برای یک ویژگی جدید. اگر Git همه‌ی تغییرها را یک‌جا ذخیره کند، یک commit مبهم داری: «باگ و ویژگی با هم». فردا که بخواهی فقط ویژگی را برگردانی، باگ را هم از دست می‌دهی. راه‌حل Git یک مرحله‌ی واسط است: اول انتخاب می‌کنی کدام تغییرها در این commit باشند (staging)، بعد ثبتشان می‌کنی (commit).

تشبیه: سبد خرید و صندوق

git add مثل گذاشتن کالا در سبد خرید است و git commit مثل پرداخت در صندوق. می‌توانی هر چیزی را در سبد بگذاری یا برداری، و تا پرداخت نکرده‌ای هیچ‌چیز ثبت نشده. بعد از پرداخت، رسید (commit) با تاریخ و توضیح در دفتر (تاریخچه) می‌ماند. کالاهایی که در سبد نگذاشتی هم سر جایشان می‌مانند.

فایل‌ها از سه جا می‌گذرند: git add تغییر را از پوشه‌ی کاری به ناحیه‌ی آماده‌سازی می‌برد و git commit محتوای آن ناحیه را برای همیشه در مخزن (.git) ثبت می‌کند.

وضعیت هر فایل یکی از این چهار حالت است:

حالت	معنی	چطور می‌شوی
untracked	فایل تازه که Git هنوز نمی‌شناسد	فایل جدید می‌سازی
modified	فایلی که Git می‌شناسد و بعد از commit آخر عوض شده	ویرایش می‌کنی
staged	تغییر آماده‌ی ثبت در commit بعدی	`git add`
committed	تغییر در مخزن ثبت شده	`git commit`

مثال‌های عملی

نام و ایمیل از قبل تنظیم شده و شاخه‌ی پیش‌فرض main است (درس قبل). هر مثال از پوشه‌ی ~/gitlab/shop ادامه می‌دهد.

مثال ۱: شروع، `git init` و `git status`

mkdir -p ~/gitlab/shop && cd ~/gitlab/shop
git init
echo "--- مخزن تازه و خالی:"
git status
echo "--- یک فایل تازه می‌سازم:"
echo "<h1>فروشگاه من</h1>" > index.html
git status

Initialized empty Git repository in /home/ali/gitlab/shop/.git/
--- مخزن تازه و خالی:
On branch main

No commits yet

nothing to commit (create/copy files and use "git add" to track)
--- یک فایل تازه می‌سازم:
On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
  index.html

nothing added to commit but untracked files present (use "git add" to track)

git status مهم‌ترین دستور Git است؛ هر وقت مطمئن نیستی چه خبر است، آن را بزن. نام شاخه (On branch main)، وضعیت commit ها و فایل‌ها را می‌گوید، و راهنمایی بعدی را هم می‌دهد: index.html در بخش Untracked files است، یعنی Git هنوز نمی‌شناسدش.

مثال ۲: اولین commit، `add` و `commit`

cd ~/gitlab/shop
git add index.html
echo "--- بعد از add:"
git status
git commit -m "Add homepage"
echo "--- بعد از commit:"
git status
git log --oneline

--- بعد از add:
On branch main

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
  new file:   index.html

[main (root-commit) c700776] Add homepage
 1 file changed, 1 insertion(+)
 create mode 100644 index.html
--- بعد از commit:
On branch main
nothing to commit, working tree clean
c700776 Add homepage

سه مرحله دیدی: بعد از add فایل زیر Changes to be committed (staged) رفت و Git حتی راه برگشت را نشان داد (git rm --cached، در درس‌های بعد git restore --staged). بعد از commit پوشه working tree clean است: همه‌چیز ثبت شده. و git log --oneline یک خط دارد: شناسه‌ی کوتاه + پیام.

مثال ۳: staging انتخابی، فقط بخشی از تغییرها

حالا دو تغییر نامرتبط می‌دهم: یک اصلاح در index.html و یک فایل کاملاً جدید cart.js. فقط اولی را commit می‌کنم:

cd ~/gitlab/shop
echo "<p>تخفیف ویژه!</p>" >> index.html
echo "console.log('cart')" > cart.js
echo "--- دو تغییر:"
git status -s
git add index.html
echo "--- فقط یکی در سبد است (ستون اول = staged، ستون دوم = پوشه‌ی کاری):"
git status -s
git commit -m "Add discount banner to homepage"
echo "--- cart.js هنوز دست‌نخورده و untracked:"
git status -s

--- دو تغییر:
 M index.html
?? cart.js
--- فقط یکی در سبد است (ستون اول = staged، ستون دوم = پوشه‌ی کاری):
M  index.html
?? cart.js
[main 06461b6] Add discount banner to homepage
 1 file changed, 1 insertion(+)
--- cart.js هنوز دست‌نخورده و untracked:
?? cart.js

خروجی کوتاه git status -s دو ستون دارد: ستون اول وضعیت staging و ستون دوم وضعیت پوشه‌ی کاری:

نشانه	معنی
`??`	untracked (فایل تازه)
`A`	تازه‌اضافه‌شده و staged
`M`	modified ولی staged نیست
`M`	modified و staged
`MM`	staged شده و بعد دوباره عوض شده (نسخه‌ی staged با نسخه‌ی کاری فرق دارد)
`D` / `D`	حذف‌شده (staged نشده / staged)

مثال ۴: `add .` و `add -A` و `add -u`

همه‌ی تغییرها را یک‌به‌یک اسم‌بردن خسته‌کننده است. این سه شکل رایج‌اند. اول سه نوع تغییر می‌سازم: یک فایل جدید، یک فایل ویرایش‌شده و یک فایل حذف‌شده:

cd ~/gitlab/shop
git add cart.js && git commit -qm "Add cart script"
echo "body { color: navy }" > style.css          # جدید
echo "<p>بروز شد</p>" >> index.html               # ویرایش
rm cart.js                                         # حذف
echo "--- سه نوع تغییر:"
git status -s
echo "--- git add -u (فقط فایل‌هایی که Git می‌شناسد: ویرایش و حذف، نه جدید):"
git add -u && git status -s
git restore --staged .
echo "--- git add -A (همه: جدید، ویرایش، حذف):"
git add -A && git status -s
git restore --staged .
echo "--- git add . (از پوشه‌ی فعلی به پایین؛ در Git مدرن مثل -A):"
git add . && git status -s

--- سه نوع تغییر:
 D cart.js
 M index.html
?? style.css
--- git add -u (فقط فایل‌هایی که Git می‌شناسد: ویرایش و حذف، نه جدید):
D  cart.js
M  index.html
?? style.css
--- git add -A (همه: جدید، ویرایش، حذف):
D  cart.js
M  index.html
A  style.css
--- git add . (از پوشه‌ی فعلی به پایین؛ در Git مدرن مثل -A):
D  cart.js
M  index.html
A  style.css

دستور	فایل جدید	ویرایش	حذف	توضیح
`git add فایل`	همان فایل	همان فایل	همان فایل	دقیق و امن
`git add -u`	✗	✓	✓	فقط فایل‌های «شناخته‌شده»
`git add -A`	✓	✓	✓	همه‌ی پروژه
`git add .`	✓	✓	✓	همه‌ی پوشه‌ی فعلی به پایین (در Git ۲ و بالاتر مثل `-A`، برای همان پوشه)

(git restore --staged . فقط برای تمیزکاری بین آزمایش‌هاست؛ در درس «برگرداندن تغییرات» توضیح داده می‌شود.) قاعده‌ی خوب: بعد از هر git add با git status بنگر چه چیزی را در سبد گذاشته‌ای؛ add . بدون نگاه، راه ورود فایل‌های اضافه و حتی رمزها به مخزن است.

مثال ۵: `git commit -a`، پیام چندخطی و commit خالی

cd ~/gitlab/shop
# اول، آنچه در مثال قبل با add . آماده شد را ثبت می‌کنم
git commit -qm "Add stylesheet, remove cart script, update homepage"
echo "قیمت‌ها اضافه شد" >> index.html
echo "--- git commit -am: add روی فایل‌های شناخته‌شده + commit، در یک دستور:"
git commit -am "Update homepage prices"
echo "--- پیام چندخطی: دو بار -m (اولی عنوان، دومی توضیح):"
echo "پایان" >> index.html
git commit -am "Add footer note" -m "The footer tells visitors the page is a demo.
It was requested by the design team."
git log -1
echo "--- commit وقتی چیزی برای ثبت نیست:"
git commit -m "nothing here"

--- git commit -am: add روی فایل‌های شناخته‌شده + commit، در یک دستور:
[main e3dc989] Update homepage prices
 1 file changed, 1 insertion(+)
--- پیام چندخطی: دو بار -m (اولی عنوان، دومی توضیح):
[main 2f0f1ab] Add footer note
 1 file changed, 1 insertion(+)
commit 2f0f1ab46671b4df6b5ba72155e6c267a92c8473
Author: Ali <ali@example.com>
Date:   Sun Oct 4 08:10:26 2026 +0000

    Add footer note

    The footer tells visitors the page is a demo.
    It was requested by the design team.
--- commit وقتی چیزی برای ثبت نیست:
On branch main
nothing to commit, working tree clean

-a یعنی «همه‌ی فایل‌های شناخته‌شده‌ی ویرایش‌شده را خودت add کن»؛ فایل‌های جدید را نمی‌گیرد. دو بار -m یک عنوان و یک توضیح می‌سازد (با خط خالی بینشان). و commit بدون تغییر رد می‌شود: nothing to commit.

مثال ۶: یک commit خوب چه شکلی است؟

پیام‌های commit برای آدم‌ها نوشته می‌شوند (تو شش ماه بعد و همکارت). مقایسه کن دو تاریخچه را:

mkdir -p ~/gitlab/bad && cd ~/gitlab/bad && git init -q
for m in "fix" "asdf" "update" "changes" "final"; do echo "$m" >> f.txt; git add f.txt; git commit -qm "$m"; done
echo "--- تاریخچه‌ی بد (چه چیزی عوض شد؟ چرا؟):"
git log --oneline
mkdir -p ~/gitlab/good && cd ~/gitlab/good && git init -q
for m in "Fix crash when the cart is empty" "Add Persian font to the homepage" "Validate email on the signup form" "Bump dependency versions"; do echo "$m" >> f.txt; git add f.txt; git commit -qm "$m"; done
echo "--- تاریخچه‌ی خوب:"
git log --oneline

--- تاریخچه‌ی بد (چه چیزی عوض شد؟ چرا؟):
ed7e4be final
60b4f2f changes
e447e95 update
3db38cc asdf
af672a8 fix
--- تاریخچه‌ی خوب:
24a4332 Bump dependency versions
45eac2a Validate email on the signup form
b787b03 Add Persian font to the homepage
58b723e Fix crash when the cart is empty

قواعد یک پیام خوب:

قاعده	مثال خوب	مثال بد
عنوان کوتاه (حدود ۵۰ نویسه)، با فعل امری	`Add login form`	`added some stuff to the login thing that I was working on`
چه چیزی عوض شد، نه «چطور»	`Fix crash on empty cart`	`change line 42`
یک commit = یک تغییر منطقی	رفع باگ جدا، ویژگی جدا	`fix and add and refactor`
برای تغییر مهم، بعد از یک خط خالی چرا را بنویس	بدنه‌ی چندخطی	هیچ توضیحی
متن انگلیسی ساده برای پروژه‌های بین‌المللی (فارسی اگر تیمت فارسی است، ولی یک‌دست)		ترکیب بی‌قاعده

دو دلیل برای «فعل امری» (Add، Fix، Update): پیام را مثل یک دستور برای کد بخوان («این commit را اعمال کن تا… Add login form») و Git هم پیام‌هایی مثل Merge branch... و Revert ... را همین‌طور می‌نویسد.

مثال ۷: یک پروژه در سه commit منطقی

تمرین واقعی: یک صفحه‌ی کوچک را به سه گام تقسیم کن، هر گام یک commit با یک پیام مشخص (اسکلت، ظاهر، رفتار):

mkdir -p ~/gitlab/page && cd ~/gitlab/page && git init -q
cat > index.html <<'EOF'
<!doctype html>
<title>Page</title>
<h1 id="t">Hello</h1>
EOF
git add index.html && git commit -qm "Add page skeleton"
echo "h1 { color: teal; }" > style.css
git add style.css && git commit -qm "Add stylesheet"
echo "document.getElementById('t').textContent = 'Hello, Git!';" > app.js
git add app.js && git commit -qm "Add script that changes the title"
echo "--- سه commit با خلاصه‌ی فایل‌های هر کدام:"
git log --stat --format='%h %s'

--- سه commit با خلاصه‌ی فایل‌های هر کدام:
cce7d67 Add script that changes the title

 app.js | 1 +
 1 file changed, 1 insertion(+)
8934a76 Add stylesheet

 style.css | 1 +
 1 file changed, 1 insertion(+)
c0a7eab Add page skeleton

 index.html | 3 +++
 1 file changed, 3 insertions(+)

با --stat برای هر commit فهرست فایل‌های عوض‌شده و تعداد خط می‌آید (درس تاریخچه کامل‌تر توضیح می‌دهد). هر commit یک کار است؛ اگر فردا بخواهی script را برگردانی، فقط همان commit را برمی‌گردانی.

مثال ۸: حذف و تغییر نام فایل، `git rm` و `git mv`

وقتی فایلی را حذف یا جابه‌جا می‌کنی، Git باید بداند. دو دستور هم کار را انجام می‌دهند و هم staged می‌کنند:

cd ~/gitlab/page
git mv style.css main.css
git rm app.js
echo "--- وضعیت (R = renamed، D = deleted):"
git status -s
git commit -qm "Rename stylesheet and remove script"
git ls-files

rm 'app.js'
--- وضعیت (R = renamed، D = deleted):
D  app.js
R  style.css -> main.css
index.html
main.css

git mv معادل «mv + git add» و git rm معادل «rm + git add» است. (با دستور معمولی mv هم کار می‌کند؛ فقط بعدش باید git add -A بزنی تا Git بفهمد.) و git ls-files فهرست همه‌ی فایل‌هایی که Git دنبال می‌کند را می‌دهد.

پشت پرده: add چه می‌سازد؟ commit چه؟

ناحیه‌ی آماده‌سازی یک جای جادویی نیست؛ یک فایل است: .git/index. وقتی git add می‌زنی، Git محتوای فایل را (فشرده) در .git/objects می‌نویسد و در index ثبت می‌کند «این مسیر به این شیء اشاره می‌کند». وقتی commit می‌زنی، از روی index یک tree (عکس پوشه‌ها) و یک commit می‌سازد. ببین هر مرحله چند شیء می‌سازد:

mkdir -p ~/gitlab/peek && cd ~/gitlab/peek && git init -q
count() { find .git/objects -type f | wc -l; }
echo "اشیای مخزن تازه: $(count)"
echo "سلام" > hello.txt
git add hello.txt
echo "بعد از git add: $(count)   ← یک blob (محتوای فایل)"
git commit -qm "First"
echo "بعد از git commit: $(count)   ← یک tree و یک commit اضافه شد"
echo "--- index چه نگه می‌دارد؟ (حالت، شناسه‌ی blob، مسیر):"
git ls-files --stage
echo "--- محتوای همان blob:"
git cat-file -p $(git ls-files --stage | awk '{print $2}')

اشیای مخزن تازه: 0
بعد از git add: 1   ← یک blob (محتوای فایل)
بعد از git commit: 3   ← یک tree و یک commit اضافه شد
--- index چه نگه می‌دارد؟ (حالت، شناسه‌ی blob، مسیر):
100644 0f4b5c292f605520c58ea19b77b4218d61f18138 0  hello.txt
--- محتوای همان blob:
سلام

سه شیء: blob (محتوای فایل)، tree (فهرست فایل‌ها و نام‌هایشان) و commit (اشاره به tree + پیام + نویسنده + commit قبلی). یک نتیجه‌ی مهم: Git محتوا را در لحظه‌ی add ذخیره می‌کند، نه commit. پس اگر بعد از add فایل را دوباره ویرایش کنی، آخرین ویرایش staged نیست (همان حالت MM). (جزئیات عمیق‌تر در درس «پشت پرده‌ی Git».)

جدول‌های مرجع

دستور	کار
`git init`	پوشه‌ی فعلی را مخزن کن
`git status` / `git status -s`	وضعیت کامل / خلاصه
`git add فایل…`	آماده‌کردن فایل‌های مشخص
`git add -u` / `-A` / `.`	آماده‌کردن شناخته‌شده‌ها / همه / پوشه‌ی فعلی
`git commit -m "پیام"`	ثبت با پیام
`git commit -am "پیام"`	add فایل‌های شناخته‌شده + commit
`git commit`	باز می‌شود ویرایشگر برای پیام
`git mv` / `git rm`	جابه‌جا / حذف فایل (و staged)
`git ls-files`	فایل‌های دنبال‌شده
`git log --oneline`	تاریخچه‌ی کوتاه

اشتباهات رایج

۱) commit قبل از add

mkdir -p ~/gitlab/mistake && cd ~/gitlab/mistake && git init -q
echo a > a.txt && git add a.txt && git commit -qm "Add a"
echo b >> a.txt
echo "--- بدون add:"
git commit -m "Change a"

--- بدون add:
On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
  modified:   a.txt

no changes added to commit (use "git add" and/or "git commit -a")

no changes added to commit: ویرایش کردی ولی در سبد نگذاشتی (فایل modified است نه staged). راه‌حل: git add a.txt یا git commit -am.

۲) غلط تایپی در اسم فایل

cd ~/gitlab/mistake
git add a.txxt 2>&1
git add --dry-run -A

fatal: pathspec 'a.txxt' did not match any files
add 'a.txt'

fatal: pathspec 'a.txxt' did not match any files: Git فایلی با این اسم نمی‌شناسد. با Tab اسم را کامل کن و با git status بررسی کن. (--dry-run نشان می‌دهد add چه چیزی را اضافه می‌کرد، بدون اینکه واقعاً بکند؛ برای add -A مطمئن‌شدن خوب است.)

۳) `git add .` و اضافه‌شدن فایل‌های اضافی

add . بدون نگاه، فایل‌هایی مثل node_modules/، لاگ‌ها، فایل‌های موقت و حتی .env (رمز) را هم به مخزن می‌برد. راه‌حل: همیشه قبل از commit git status را بخوان، و فایل‌هایی را که نباید وارد شوند در .gitignore بگذار (درس بعدی).

۴) مخزن داخل مخزن

اگر داخل یک پروژه‌ی Git دوباره git init بزنی (مثلاً در یک زیرپوشه)، Git با دیدن .git تو در تو هشدار می‌دهد:

mkdir -p ~/gitlab/outer && cd ~/gitlab/outer && git init -q
echo x > x.txt && git add x.txt && git commit -qm "Outer"
mkdir sub && cd sub && git init -q && echo y > y.txt && git add y.txt && git commit -qm "Inner"
cd ..
git add . 2>&1 | head -4

warning: adding embedded git repository: sub
hint: You've added another git repository inside your current repository.
hint: Clones of the outer repository will not contain the contents of
hint: the embedded repository and will not know how to obtain it.

adding embedded git repository: sub: Git پوشه‌ی داخلی را به‌عنوان یک مخزن جدا (نه فایل‌های عادی) ثبت می‌کند و تاریخچه‌اش را داخل مخزن بیرونی نمی‌آورد. این تقریباً هیچ‌وقت چیزی نیست که بخواهی. راه‌حل: یا زیرپوشه را جدا نگه دار، یا .git داخلی را پاک کن، یا از submodule استفاده کن (موضوع پیشرفته).

۵) پیام‌های بی‌معنی

fix، update، asdf، final (مثال ۶). راه‌حل: پیام را برای خواننده‌ی شش ماه بعد بنویس: چه چیزی، و اگر ضروری است چرا.

تمرین

✎ تمرینآسان

یک مخزن تازه بساز، یک فایل بنویس و در هر مرحله git status -s را بزن تا ببینی فایل از ?? به A و بعد پاک می‌شود (committed).

دیدن جواب

mkdir -p ~/gitlab/ex1 && cd ~/gitlab/ex1 && git init -q
echo "یادداشت" > note.txt
echo "1) فایل تازه:";   git status -s
git add note.txt
echo "2) بعد از add:";  git status -s
git commit -qm "Add note"
echo "3) بعد از commit:"; git status -s; echo "(خالی = همه‌چیز ثبت شده)"

1) فایل تازه:
?? note.txt
2) بعد از add:
A  note.txt
3) بعد از commit:
(خالی = همه‌چیز ثبت شده)

✎ تمرینمتوسط

تمرین اصلی: یک پروژه‌ی کوچک (مثلاً یک ماشین‌حساب) را در سه commit منطقی ذخیره کن: (۱) فایل اصلی با تابع جمع، (۲) تابع ضرب، (۳) یک README.md. پیام‌ها را خوب بنویس و با git log --stat تأیید کن هر commit فقط کار خودش را دارد.

دیدن جواب

mkdir -p ~/gitlab/calc && cd ~/gitlab/calc && git init -q
printf 'def add(a, b):\n    return a + b\n' > calc.py
git add calc.py && git commit -qm "Add add() function"
printf '\ndef mul(a, b):\n    return a * b\n' >> calc.py
git commit -aqm "Add mul() function"
printf '# calc\nA tiny calculator.\n' > README.md
git add README.md && git commit -qm "Add README"
git log --stat --format='--- %h %s'

--- ce80fba Add README

 README.md | 2 ++
 1 file changed, 2 insertions(+)
--- 4ca3ddf Add mul() function

 calc.py | 3 +++
 1 file changed, 3 insertions(+)
--- 8d12b86 Add add() function

 calc.py | 2 ++
 1 file changed, 2 insertions(+)

✎ تمرینسخت

دو تغییر نامرتبط را داخل یک فایل بده (یکی در خط ۲ و یکی در خط ۱۸) ولی آن‌ها را در دو commit جدا ثبت کن. (راهنما: git add -p تغییرها را تکه‌تکه (hunk) نشان می‌دهد و می‌پرسد کدام را آماده کنم؛ برای اسکریپت، جواب‌ها را با printf می‌دهم.)

دیدن جواب

mkdir -p ~/gitlab/ex3 && cd ~/gitlab/ex3 && git init -q
seq 1 20 > list.txt
git add list.txt && git commit -qm "Add list"
sed -i '2s/.*/two (fixed typo)/' list.txt
sed -i '18s/.*/eighteen (new feature)/' list.txt
echo "--- git add -p: اولی را بپذیر (y)، دومی را رد کن (n):"
printf 'y\nn\n' | git add -p list.txt
echo "--- الان:"
git status -s
git commit -qm "Fix typo on line 2"
git commit -aqm "Add new feature on line 18"
git log --oneline
echo "--- هر commit فقط یک تغییر دارد:"
git show --format='%s' --stat HEAD~1 | head -4

--- git add -p: اولی را بپذیر (y)، دومی را رد کن (n):
diff --git a/list.txt b/list.txt
index 0ff3bbb..196ed57 100644
--- a/list.txt
+++ b/list.txt
@@ -1,5 +1,5 @@
 1
-2
+two (fixed typo)
 3
 4
 5
(1/2) Stage this hunk [y,n,q,a,d,j,J,g,/,e,?]? @@ -15,6 +15,6 @@
 15
 16
 17
-18
+eighteen (new feature)
 19
 20
(2/2) Stage this hunk [y,n,q,a,d,K,g,/,e,?]?
--- الان:
MM list.txt
aad1048 Add new feature on line 18
ec6b209 Fix typo on line 2
0f7b8a1 Add list
--- هر commit فقط یک تغییر دارد:
Fix typo on line 2

 list.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

آزمونک

⚡ بررسی سریع

بعد از ویرایش یک فایل و زدن git add و سپس ویرایش دوباره‌ی همان فایل، git status -s چه نشان می‌دهد؟

جواب درست: MM (نسخه‌ی staged و نسخه‌ی کاری فرق دارند) — add محتوای آن لحظه را ذخیره می‌کند. ویرایش بعدی فقط در پوشه‌ی کاری است، پس فایل هم staged است و هم modified: MM. برای ثبت آخرین ویرایش باید دوباره add کنی.

؟ آزمونک

ترتیب درست مسیر یک تغییر؟
git add -u چه فایل‌هایی را آماده می‌کند؟
کدام پیام commit بهتر است؟
git commit -am "پیام" چه می‌کند؟
Git محتوای فایل را در کدام لحظه در .git/objects می‌نویسد؟

جمع‌بندی

سه ناحیه: working directory ← git add ← staging area (.git/index) ← git commit ← repository. چهار حالت فایل: untracked، modified، staged، committed.
git status را زیاد بزن؛ git status -s خلاصه است (??، A ، M، M ، MM).
git add فایل دقیق است؛ -u فقط شناخته‌شده‌ها، -A و . همه. قبل از commit ببین چه چیزی در سبد است. git commit -am فقط فایل‌های شناخته‌شده را add می‌کند.
یک commit = یک تغییر منطقی. پیام: عنوان کوتاه با فعل امری، و در صورت نیاز بدنه‌ی «چرا».
git mv و git rm جابه‌جایی و حذف را هم staged می‌کنند؛ git ls-files فایل‌های دنبال‌شده را نشان می‌دهد.
پشت پرده: add یک blob می‌سازد و در index ثبت می‌کند؛ commit یک tree و یک commit می‌سازد.
مخزن داخل مخزن، add . بی‌نگاه و پیام‌های بی‌معنی شایع‌ترین اشتباه‌های اول کارند.

برگه‌ی تقلب این درس

دستور	کاری که می‌کند
`git init`	پوشه را مخزن کن
`git status / git status -s`	وضعیت کامل / خلاصه
`git add فایل`	آماده‌کردن یک فایل
`git add -A`	آماده‌کردن همه (جدید، ویرایش، حذف)
`git add -u`	فقط فایل‌های شناخته‌شده
`git add -p`	انتخاب تغییرها تکه‌تکه
`git commit -m "پیام"`	ثبت با پیام
`git commit -am "پیام"`	add شناخته‌شده‌ها + commit
`git mv قدیم جدید / git rm فایل`	تغییر نام / حذف و staged
`git ls-files`	فایل‌های دنبال‌شده

اولین مخزن و commit

مسئله: چرا commit دو مرحله دارد؟

تشبیه: سبد خرید و صندوق

مثال‌های عملی

مثال ۱: شروع، git init و git status

مثال ۲: اولین commit، add و commit

مثال ۳: staging انتخابی، فقط بخشی از تغییرها

مثال ۴: add . و add -A و add -u

مثال ۵: git commit -a، پیام چندخطی و commit خالی

مثال ۶: یک commit خوب چه شکلی است؟

مثال ۷: یک پروژه در سه commit منطقی

مثال ۸: حذف و تغییر نام فایل، git rm و git mv

پشت پرده: add چه می‌سازد؟ commit چه؟

جدول‌های مرجع

اشتباهات رایج

۱) commit قبل از add

۲) غلط تایپی در اسم فایل

۳) git add . و اضافه‌شدن فایل‌های اضافی

۴) مخزن داخل مخزن

۵) پیام‌های بی‌معنی

تمرین

آزمونک

جمع‌بندی

مثال ۱: شروع، `git init` و `git status`

مثال ۲: اولین commit، `add` و `commit`

مثال ۴: `add .` و `add -A` و `add -u`

مثال ۵: `git commit -a`، پیام چندخطی و commit خالی

مثال ۸: حذف و تغییر نام فایل، `git rm` و `git mv`

۳) `git add .` و اضافه‌شدن فایل‌های اضافی