Git پیشرفته : دستوراتی برای قوی شدن

Git یک ابزار قدرتمند برای کنترل نسخه است و تا حدودی در این زمینه انحصار دارد. برای اکثر کارهای روزمره، Git به لطف تکرار دستوراتش می تواند ساده باشد. با این حال، موقعیت‌های زیادی وجود دارد که شما به چیزی بیش از اصول اولیه نیاز دارید. به این ترتیب، دستورات Git پیشرفته زیادی وجود دارد که می تواند مهارت های Git شما را به سطح بعدی برساند.

این همچنین شما را با مفاهیم مختلف Git آشنا می کند که معمولاً با آنها برخورد نمی کنید. به عنوان مثال، پنهان کردن به جای انجام تغییرات، تغییر پایه و افزودن فایل‌ها به منطقه مرحله‌بندی شما. هنگامی که آنها را یاد گرفتید، ممکن است متوجه شوید که ارزش بیشتری برای تیم خود دارید.

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

پیش نیازهای پیشنهادی

در حالی که ممکن است بتوانید اصول اولیه Git را انتخاب کنید و برخی از دستورات میانی مانند git delete را درک کنید، برای مدیریت دستورات پیشرفته به ابزار بیشتری در جعبه ابزار خود نیاز دارید.

نکاتی که ما در اینجا به اشتراک می گذاریم برای یک مبتدی برای Git مناسب نیست، بنابراین اگر کنترل نسخه، به طور کلی، برای شما جدید است، توصیه می کنیم قبل از اینکه بخواهید چیزهای بیشتری به کارنامه خود اضافه کنید، مدتی را با استفاده از دستورات اولیه به صورت روزانه اختصاص دهید.

به طور خلاصه، در اینجا یک لیست سریع از جنبه هایی است که باید درک کنید:

مفاهیم Core Git مانند commit ها، شاخه ها، درخواست های pull و موارد دیگر.
آشنایی با دستورات اولیه Git مانند git add، git merge، git commit و git push.
برای کارهای پیشرفته Git، باید بتوانید در ترمینال پیمایش کنید.
داشتن تجربه کار با Git در یک محیط تیمی مفید است، زیرا بسیاری از این دستورات می توانند تأثیر قابل توجهی بر روی یک پایگاه کد مشترک داشته باشند. به عنوان مثال، ممکن است شما فقط از برخی از این دستورات در موقعیت هایی که مسئولیت های خاصی دارید استفاده کنید. این بدان معنی است که شما باید مراقب باشید و درک درستی از زمانی که از این دستورات استفاده می کنید را باید داشته باشید.

گیت پیشرفته: 12 دستور پر قدرتی که می خواهید بدانید

بقیه این مقاله به 12 دستور مختلف پیشرفته Git می پردازد که شما را فراتر از اصول اولیه می برد و شما را به یک جادوگر Git تبدیل می کند. بیایید با یک دستور شروع کنیم که ممکن است بیشتر از بقیه از آن استفاده کنید.

1. Rebasing

اول از همه، rebasing یک دستور قدرتمند Git است که جایگزینی برای درخواست pull است. این به شما امکان می دهد تمام commit های جدیدی را که پس از واگرایی شاخه انجام می دهید به یک شاخه جدید بکشید و تغییرات را در نوک پایه قرار دهید. اگر بخواهید تغییرات را از شاخه دیگری بدون ایجاد یک commit ادغام به هر دلیلی بگنجانید، مفید خواهد بود.

یکی از موارد استفاده رایج برای rebasing زمانی است که روی شاخه ویژگی کار می‌کنید، و می‌خواهید بدون ایجاد یک ادغام، تغییرات را از شاخه اصلی وارد کنید. این کمک می کند تا تاریخچه پروژه خود را تمیز نگه دارید، اگرچه ممکن است اجرای آن بیشتر طول بکشد و ممکن است در طول ادغام خطاهای بیشتری مشاهده کنید.

برای تغییر پایه یک شاخه، از دستور git rebase استفاده کنید. در اینجا مثالی وجود دارد که در آن ما یک شاخه را به شاخه دیگر تغییر می دهیم:

git checkout foo-branch

git rebase main

همچنین می‌توانید commit‌هایی را که قرار است منتشر کنید فهرست کنید و به شما فرصتی بدهد تا آنها را از قبل ویرایش کنید. به این ترتیب، می توانید commit ها را squash کنید، پیام های commit را ویرایش کنید و موارد دیگر. شما می توانید از پرچم interactive-- یا i-- برای انجام "rebase تعاملی" استفاده کنید.

git rebase --interactive <other-branch-name>

وقتی صحبت از آن شد، squash کردن commit ها به یک واحد برای مرتب کردن تاریخچه commit یک مورد معمول استفاده برای rebasing است. این می تواند خواندن و درک تاریخچه commit شما را آسان تر کند.

برای انجام این کار در حین یک rebase، پرچمی را دنبال می‌کنید که تعداد commit‌هایی را که می‌خواهید squash کنید، دنبال می‌کنید، که commit‌ها را در یکی ترکیب می‌کند:

git rebase -i HEAD~3

با این کار یک پنجره interactive rebase باز می شود، بسیار شبیه به یک پنجره commit، که در آن می توانید commit هایی را که می خواهید squash کنید، انتخاب و ویرایش کنید.

شما یک لیست از commit ها در بالای صفحه و مجموعه ای از دستورات در پایین به همراه برخی اطلاعات مرتبط دیگر دارید. گزینه پیش‌فرض انتخاب یک commit است که آن را به عنوان موردی که می‌خواهید بدون تغییر استفاده کنید انتخاب می‌کند.

با این حال، بسیاری از دستورات دیگر وجود دارد که به شما کمک می کند تا یک rebase را هدایت کنید. به عنوان مثال، شما می توانید یک commit را بازنویسی کنید یا چندین commit را با هم squash کنید. برای ایجاد تغییرات و استفاده از دستورات، با ویرایشگر ترمینال خود کار خواهید کرد. پیش فرض اغلب Vim است، به این معنی که شما باید آن ویرایشگر را بشناسید.

مرحله آخر این است که تغییرات خود را ذخیره کنید، سپس آنها را به شاخه راه دور push کنید.

2. برگرداندن، بازنشانی، و Unstaging

Git در مورد بازگرداندن تغییرات بدنام است. به طور کلی این یک فرآیند دشوار است، با تمایل به خطا. با این حال، اگر تغییراتی را در دایرکتوری کاری یا ناحیه مرحله بندی خود ایجاد کنید که می خواهید لغو کنید، چند دستور Git وجود دارد که می تواند کمک کند.

در واقع، Git به شما راهنمایی می‌کند که چگونه یک فایل را در صورت اجرای یک وضعیت git از مرحله خارج کنید.

به این ترتیب، می توانید یک commit را از شاخه فعلی حذف کرده و به راحتی آن را به جای دیگری ارسال کنید:

git reset HEAD <commit>

این باعث می شود که شاخه شما یک commit به عقب برگردد، گویی که آخرین commit شناخته شده را حذف می کنید. حتی ممکن است یک مورد استفاده داشته باشید که بخواهید یک شاخه را به حالت اولیه خود بازنشانی کنید. در اینجا، می‌توانید با استفاده از تنظیم مجدد git - به عنوان مثال، مبدا/مقاله اصلی را در مقابل مبدا از راه دور بازنشانی کنید. با این حال، توجه داشته باشید که این تغییرات برای همیشه از بین خواهند رفت.

در حالی که دستور git checkout یکی از مواردی است که اغلب از آن استفاده می کنید و به عنوان اساسی در نظر گرفته می شود، می توانید از آن برای جداسازی فایل ها قبل از commit نیز استفاده کنید:

git checkout -- <filename>

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

همچنین می توانید از تغییرات git revert که در یک commit ایجاد می کنید استفاده کنید. با این حال، این تغییرات را به عقب برنمی‌گرداند، بلکه یک commit جدید بر اساس لغو تغییرات قبلی ایجاد می‌کند.

تفاوت عمده در اینجا این است که دستور هیچ اشاره گر مرجعی را به commit جدید منتقل نمی کند، اما commit های قدیمی را حفظ می کند. این زمانی مفید است که می‌خواهید تغییرات را بدون حذف آن‌ها از تاریخچه commit خود لغو کنید.

دستور انتظار دریافت یک مرجع را دارد و بازگرداندن آخرین commit ساده است:

git revert HEAD

با این حال، شما دامنه بسیار بیشتری برای بازیابی و تغییر فایل ها و commit ها دارید. دو ورودی بعدی در این لیست از دستورات پیشرفته Git به آنها نگاه می کنند.

3. بازگرداندن فایل ها به حالت های پیش فرض

با Git، می توانید به راحتی یک فایل را با استفاده از یک دستور نسبتاً جدید به حالت پیش فرض بازگردانید: git restore. در واقع، در اکثر شرایط باید این را جایگزینی برای تنظیم مجدد git در نظر بگیرید، زیرا قدرت بسیار بیشتری را در زیر خود ارائه می دهد. برای مثال، می‌توانید با <git restore -staged <filename به همان نتیجه برسید که با git reset HEAD.

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

git restore <filename>

با این کار تغییرات از دایرکتوری کاری حذف می شود، گویی هیچ اتفاقی نیفتاده است. مانند <git checkout -- <filename، می‌خواهید مطمئن شوید که هیچ یک از تغییرات محلی را نمی‌خواهید، زیرا برای همیشه از بین خواهند رفت.

4. اصلاح commit

احتمالاً مواقع زیادی وجود خواهد داشت که شما یک commit را push می کنید و سپس متوجه می شوید که فراموش کرده اید چیز مهمی را وارد کنید. با Git، می توانید به راحتی commit را اصلاح کنید تا تغییرات از دست رفته را نیز در بر گیرد.

برای انجام این کار از یک فرآیند خاص پیروی می شود:

ابتدا تغییرات خود را در هر فایلی که برای پروژه نیاز دارید انجام دهید.
با استفاده از git add آنها را به صورت معمولی مرحله بندی کنید.
آن تغییرات را در ناحیه مرحله بندی با استفاده از دستور دیگری برای انجام commit مجدداً انجام دهید:

git commit --amend

این commit اصلی را با commit جدید با استفاده از منطقه مرحله‌بندی شما برای آن اصلاح می‌کند. به این ترتیب، مطمئن شوید که به نسخه قدیمی commit نیاز ندارید زیرا از بین می رود. همچنین توصیه می کنیم به دلایل مشابهی که در جاهای دیگر این پست به آن پرداخته ایم، از پرچم amend-- با commit های محلی به جای موارد راه دور استفاده کنید.

همچنین می توانید از git commit --amend برای ویرایش پیام commit فقط با دستور زیر استفاده کنید:

git commit --amend -m "New commit message"

5. Git Logging

استفاده از گزارش Git برای کمک به درک تاریخچه یک مخزن ارزشمند است. با این حال، ما دستور git log را به عنوان پیشرفته طبقه بندی نمی کنیم. در عوض، می‌توانید از گزینه‌های مختلفی برای فیلتر کردن خروجی بر اساس نیاز خود استفاده کنید:

git log

git log --decorate

git log --stat

به عنوان مثال، تزئین یک ورودی گزارش، نام‌های ref را برای تمام commit نشان داده شده چاپ می‌کند. گزینه stat-- درج ها و حذف ها را برای یک commit نمایش می دهد:

git log --author=<author-name>

git log --grep=<pattern-string>

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

git log --oneline --author=<author-name> --since=<date> feature-temp

این کار تمام commit با شاخه ویژگی temp- از یک نویسنده منفرد را از یک تاریخ مشخص جستجو می‌کند، سپس آن را با استفاده از ورودی‌های تک خطی چاپ می‌کند. توجه داشته باشید که پارامتر <date> همچنین می تواند یک رشته باشد:

--since=”Two weeks ago”

همچنین، اگر می خواهید به جای یک شاخه، یک فایل خاص را جستجو کنید، می توانید اجرا کنید:

git log --oneline --author=bartonfink --since=”5 days ago” -- readme.rm

این مجموعه از مثال‌ها فقط سطح کارهایی را که می‌توانید با لاگ‌های خود انجام دهید، بررسی می‌کند، اما دامنه زیادی برای یافتن commit دقیق در آنها بر اساس معیارهای جستجوی شما وجود دارد.

6. Git Hooks

شما احتمالاً از ماکروها و سایر اسکریپت های خودکار برای کمک به اجرای کد در مواقعی استفاده می کنید. Git همچنین شامل این نوع عملکرد به صورت هوک است. این اسکریپت ها به طور خودکار در پاسخ به رویدادهای خاص مانند commit یا push اجرا می شوند. همچنین راه‌های زیادی برای استفاده از هوک ها برای اجرای قالب‌بندی کد، اجرای آزمایش‌ها و موارد دیگر وجود دارد.

دو نوع هوک وجود دارد: سمت کلاینت و سمت سرور:

قلاب های سمت کلاینت بر اساس اقدامات محلی مانند commit و ادغام فعال می شوند.
قلاب های سمت سرور به دلیل عملیات شبکه فعال می شوند. این ممکن است زمانی باشد که یک مخزن یک commit تحت push دریافت می کند، در میان بسیاری از نمونه های دیگر.

هنگامی که یک git init را اجرا می کنید، Git همیشه مخزن شما را با چندین هوک نمونه پر می کند. با این حال، برای استفاده از آنها باید پسوند sample. را حذف کنید.

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

ایجاد یک Git Hook

برای ایجاد یک قلاب Git، باید یک اسکریپت اجرایی در زیر شاخه git/.hooks بدون پسوند ایجاد کنید. تا زمانی که آن را به پوشه hooks اضافه کنید، همچنان اجرا خواهد شد.

شما می توانید از هر زبان برنامه نویسی که می خواهید استفاده کنید تا زمانی که بتواند به عنوان یک فایل اجرایی اجرا شود. ما Ruby یا Python را پیشنهاد می کنیم، اما می توانید از Bash، Perl و بسیاری دیگر استفاده کنید. تنها کاری که در اینجا باید انجام دهید این است که مسیر مترجم خود را از پیش فرض Bash تغییر دهید:

#!/usr/bin/env python

از اینجا می توانید کد خود را به صورت عادی بنویسید. به عنوان مثال، در اینجا یک اسکریپت آماده سازی commit در پایتون وجود دارد که از کاربر می خواهد پیام های commit خوبی بنویسد:

#!/usr/bin/env python

import sys, os

path_commit_msg = sys.argv[1]

with open(commit_msg_filepath, 'w') as f:

f.write("# You’ll need to provide a better commit message than that, buddy!")

در حالی که همیشه ضروری نیست، توصیه می کنیم <chmod +x .git/hooks/hook-name> را از خط فرمان اجرا کنید تا مطمئن شوید که می توانید آن را اجرا کنید.

در کل، هوک ها می توانند ابزار قدرتمندی برای خودکارسازی کارهای تکراری و اجرای بهترین شیوه ها در تیم شما باشند.

7. ارجاعات را commit کنید

در Git، شما commit را توسط هش رمزگذاری SHA-1 شناسایی می کنید. در حالی که می توان با هش کامل آنها به commit اشاره کرد، این ممکن است خسته کننده و مستعد خطا باشد:

bc7623b7a94ed3d8feaffaf7580df3eca4f5f5ca

در عوض، Git چندین راه برای ارجاع به commit ها با استفاده از نام های کوتاه تر و به یاد ماندنی تر ارائه می دهد. به عنوان مثال، می توانید از یک نام شاخه یا برچسب استفاده کنید. به عنوان مثال، شاخه ای به نام "develop" را در نظر بگیرید. در اینجا مثالی وجود دارد که در آن به آخرین commit در این شاخه اشاره می کنیم:

git diff develop..HEAD

این تفاوت بین آخرین commit (HEAD) در شاخه "develop" و commit فعلی را نشان می دهد.

همچنین می توانید به یک commit با توجه به موقعیت نسبی آن در تاریخچه commit اشاره کنید. به عنوان مثال، می توانید با استفاده از خلاصه HEAD~2 به دو commit قبل از commit فعلی مراجعه کنید:

git diff HEAD~2..HEAD

Git همچنین چندین راه دیگر را برای ارجاع به commit ها ارائه می دهد، مانند استفاده از نماد "@" برای اشاره به شاخه فعلی یا استفاده از نماد "^" برای اشاره به پرنت یک commit. با استفاده از این نمادهای کوتاه، می توانید در زمان صرفه جویی کنید و از اشتباهات هنگام کار با commit جلوگیری کنید.

8. پنهان کردن

در شرایط معمولی، فکر می‌کنید هیچ راهی برای ذخیره تغییراتی که در فایل‌ها ایجاد می‌کنید بدون انجام آن‌ها وجود ندارد. "Stashing" راهی برای انجام این کار به صورت موقت است. زمانی مفید است که باید شاخه‌ها را تغییر دهید یا روی کار دیگری کار کنید اما هنوز نمی‌خواهید تغییرات خود را انجام دهید.

به عنوان مثال، اگر برای کار بر روی چیزی متوسط ​​نیاز دارید شاخه ها را تغییر دهید، می توانید تغییرات را در شاخه فعلی پنهان کنید و دیگری را بررسی کنید. از آنجا، می توانید روی شاخه دیگر کار کنید، سپس آن تغییرات را commit و push کنید. سپس می توانید کار خود را در فورک اصلی بررسی و بازیابی کنید.

برای پنهان کردن تغییرات دو راه برای این کار وجود دارد:

git stash

این تغییرات شما را در یک ذخیره جدید ذخیره می‌کند و دایرکتوری کاری شما را به آخرین عهد HEAD (حالتی که قبل از ایجاد تغییرات جدید داشتید) برمی‌گرداند. شما می توانید تغییرات را با استفاده از git stash list فهرست کنید و با استفاده از git stash show، stash را بررسی کنید. دستور آخر همچنین می تواند هر فرمتی را که git diff قبول می کند بپذیرد.

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

git stash apply

با این کار آخرین تغییرات ذخیره شده در فهرست کاری شما اعمال می شود. با این حال، توجه داشته باشید که اگر فایل را بیش از حد تغییر دهید، همچنان می توانید با تداخل مواجه شوید. پس از همه، git stash یک راه حل موقت برای مشکل موجود است.

شما همچنین می توانید چندین ذخیره داشته باشید، و می توانید با استفاده از موارد زیر مشخص کنید که کدام ذخیره را اعمال کنید:

git stash apply stash@{n}

مکان نگهدار {n} یک عدد صحیح می گیرد و stash@{0} آخرین ذخیره را نشان می دهد. اسناد رسمی Git شامل چند نمونه دیگر از git stash است.

9. دو نیم کردن

ما شرط می‌بندیم که همه با یک باگ یا مشکل مواجه شده‌اند و نمی‌دانند از کجا شروع به جستجو کنند. در این شرایط، «bisect» می‌تواند به شما کمک کند تا به سرعت commit ی را که مشکل را معرفی کرده است شناسایی کنید.

به طور خلاصه، این دستور با جستجوی commit های شما، باگ ها را شناسایی می کند. به محض اینکه مرتکب متخلفانه شد، آن را به شما برمی گرداند. قدرت این دستور تمام دستورات فرعی است که می توانید استفاده کنید.

برای استفاده از bisecting، ابتدا باید دستور git bisect start را اجرا کنید. سپس Git شما را به اولین commit در تاریخچه پروژه خود می برد.

از اینجا، باید با استفاده از دستورات مربوطه، خوب یا بد بودن آن commit را مشخص کنید:

git bisect good

git bisect bad

سپس Git شما را به commit بعدی منتقل می‌کند تا «کیفیت» آن را آزمایش کند. توجه داشته باشید که می‌توانید «خوب» را با «قدیمی» و «بد» را با «جدید» جایگزین کنید تا مورد استفاده خاص شما مطابقت داشته باشد (اگرچه نمی‌توانید اصطلاحات را با هم ترکیب کنید. )

از اینجا، می توانید به علامت گذاری هر commit به عنوان خوب یا بد ادامه دهید تا زمانی که commitی را که اشکال را معرفی کرده است، پیدا کنید. با این حال، شما مجبور نیستید از طریق هر commit بگردید. می‌توانید شناسه‌های دقیق را برای کمک به محدود کردن و کوتاه کردن جستجوی خود مشخص کنید:

git bisect bad feature-test

در اینجا، این از یک نام شاخه استفاده می کند، اما می تواند یک ویرایش خاص با استفاده از یک عدد صحیح، یک مرجع هش و موارد دیگر باشد. صرف نظر از این، پس از شکار و یافتن اشکال، می توانید یکی از دستورات زیر را اجرا کنید تا به آخرین کد خود بازگردید:

git bisect reset

مانند تمام دستورات پیشرفته Git در این لیست، چیزهای بیشتری برای یادگیری وجود دارد، و خواندن اسناد Git در اینجا ضروری است.

10. مقایسه شاخه ها

ورودی entry ما در مورد ارجاعات commit در مورد استفاده از git diff صحبت می کند. اکنون زمان آن است که به این موضوع با جزئیات بیشتری نگاه کنیم. شما اغلب خود را با شاخه های متعددی خواهید دید که دارای تغییرات متفاوتی هستند. Git به شما امکان می دهد تفاوت های بین دو شاخه را با استفاده از دستور git diff مقایسه کنید. در واقع، می‌توانید از آن به روش‌های مختلف، اغلب همراه با دستورات دیگر، برای بررسی و تجزیه و تحلیل یک مخزن استفاده کنید.

دستور اصلی git diff خروجی با یک نمای کلی از تغییرات را در اختیار شما قرار می دهد. به نظر بسیار شبیه خروجی یک بررسی ادغام commit است.

با این حال، می‌توانید به شاخه‌های دقیق، هش‌ها و موارد دیگر دریل کنید. به عنوان مثال، برای مقایسه دو شاخه، دستور git diff branch1..branch2 را اجرا می کنید و جای نگهدارنده ها را جایگزین می کنید:

git diff feature-branch pre-prod

همچنین می توانید تفاوت های بین شاخه فعلی خود و شاخه دیگر را مقایسه کنید:

git diff HEAD..pre-prod

توجه داشته باشید که استفاده از دو نقطه در اینجا تفاوت بین دو نوک شاخه ها را برمی گرداند. در مقابل، سه نقطه تفاوت بین جد مشترک هر دو شاخه را برمی گرداند و از آن برای آزمایش استفاده می کند.

دقیقاً مانند git log، می‌توانید خروجی را پاکسازی کنید و آنچه را که برمی‌گرداند را اصلاح کنید. به عنوان مثال، git diff --name-only branch1..branch2 فقط بررسی می کند که کدام فایل ها متفاوت هستند و context را حذف می کند:

ممکن است متوجه شوید که تجزیه خروجی سخت است، به خصوص اگر «diff» طولانی باشد. در این موارد می توانید از گزینه color-words-- استفاده کنید.

به طور کلی، git diff می تواند به اندازه سایر دستورات قدرتمند باشد، به خصوص زمانی که گزینه های خاصی را فراخوانی می کنید و تفاوت هایی را که برمی گردانید را اصلاح می کنید.

11. اعمال Individual commit 

گاهی اوقات ممکن است بخواهید یک commit خاص را از شاخه ای به شاخه دیگر بدون ادغام دو شاخه اعمال کنید. Git به شما امکان می دهد این کار را با استفاده از git cherry-pick انجام دهید. باید با دقت از آن استفاده کنید، اما می توانید متوجه شوید که git cherry-pick می تواند در چند حالت به شما کمک کند.

یک موقعیت زمانی است که شما شاخه های ویژگی قدیمی دارید که آنها را در اصلی یا تنه ادغام نمی کنید. می توانید از ترکیبی از دستورات (مانند git log) برای استخراج commit های قدیمی مرتبط و اعمال مجدد آنها در جای دیگر استفاده کنید.

از git log برای پیدا کردن مرجع یک commit استفاده کنید. از آنجا، مطمئن شوید که در شاخه ای هستید که می خواهید مرجعی را انتخاب کنید. به عنوان مثال، فرض کنید می‌خواهید commit xxxxxaaaaaa را در شاخه «trunk» انتخاب کنید. ابتدا شاخه خود را بررسی کنید.

git checkout trunk

… سپس commit خود را انتخاب کنید:

git cherry-pick xxxxxaaaaaa

پیام commit شما احتمالاً در بسیاری از مواقع قدیمی خواهد بود. برای حل این مشکل می توانید گزینه edit-- را به دستور منتقل کنید. این به شما امکان می دهد قبل از کاری یک پیام commit جدید ارائه دهید.

12. سوپرشارژ «git add» 

برای آخرین فرمان پیشرفته Git power، ما git add را به شما نشان می دهیم. نه، این یک اشتباه تایپی نیست. این دستور اساسی Git دارای قدرت شگفت انگیزی در زیر خود است.

به عنوان مثال، اگر متوجه شدید که در حال اضافه کردن فایل های Individual به قسمت مرحله بندی هستید، می توانید از موارد زیر استفاده کنید:

git add -p

گزینه p- به شما امکان می دهد تغییرات را به صورت تعاملی مرحله بندی کنید. می‌توانید تغییراتی را که در هر فایل ایجاد کرده‌اید مرور کنید، سپس انتخاب کنید که کدام یک را مرحله‌بندی کنید. این می تواند در زمان شما صرفه جویی زیادی کند و به شما کمک کند از ایجاد یک تغییر ناخواسته جلوگیری کنید.

در حالی که ممکن است بدانید که می‌توانید فایل‌های جداگانه را مرحله‌بندی کنید، می‌توانید یک فهرست را نیز مشخص کنید. به عنوان مثال، برای مرحله بندی تمام فایل ها در فهرست "ویژگی جدید":

git add new-feature

حتی ممکن است بخواهید بدون انجام کامل فرآیند، نتیجه یک git add را ببینید. شما یک گزینه برای آن دارید:

git add --dry-run

git add -n

وقتی این را اجرا می کنید، Git به شما نشان می دهد که آیا فایل ها را اضافه می کند یا نادیده می گیرد. در مورد فایل های نادیده گرفته شده صحبت می کنیم، در صورت تمایل می توانید آنها را به قسمت مرحله بندی اضافه کنید:

git add --force

git add -f

افزودن فایل‌ها به منطقه مرحله‌بندی می‌تواند پیچیده‌تر از یک سناریوی ساده باینری «افزودن یا اضافه نکنید» باشد. به این ترتیب، یکی از اصلی ترین دستورات Git می تواند احتمالات بیشماری را پوشش دهد.

نتیجه

هنگامی که دستورات اولیه Git را در جیب خود دارید، 80 درصد از آنچه را که برای انجام کارهای کنترل نسخه معمولی پروژه خود نیاز دارید در اختیار خواهید داشت. با این حال، 20 درصد نهایی جایی است که دستورات پیشرفته Git می توانند بدرخشند.

دستورات و تکنیک هایی مانند rebasing، bisecting، بازیابی فایل ها و موارد دیگر، همگی شما را به سرعت از حالت مبتدی خارج می کنند. علاوه بر این، می‌توانید ارزش بیشتری برای تیم و پروژه خود ارائه دهید، و می‌توانید به ساده‌سازی جریان‌های کاری، افزایش بهره‌وری و تأثیر بیشتر به عنوان یک توسعه‌دهنده کمک کنید.

آیا هر یک از این دستورات پیشرفته Git بخشی از کار روزانه شما خواهد شد؟ در بخش نظرات زیر به ما اطلاع دهید!