git-rev-parse - מקוון בענן

תָכְנִית:

שֵׁם

git-rev-parse-פרמטרים לבחירה ועיסוי

תַקצִיר

סילון rev-parse [ --אופציה ] ...

תיאור

פקודות רבות של Git פורצלן לוקחות תערובת של דגלים (כלומר פרמטרים שמתחילים בא
קורטוב -) ופרמטרים המיועדים לבסיס סילון רשימת סיבובים פקודה שהם משתמשים בהם באופן פנימי
ודגלים ופרמטרים עבור הפקודות האחרות שהם משתמשים במורד הזרם סילון רשימת סיבובים. זֶה
הפקודה משמשת כדי להבחין ביניהם.

אפשרויות

פעולה מצבים
כל אחת מהאפשרויות הללו חייבת להופיע תחילה בשורת הפקודה.

--parseopt
השתמש סילון rev-parse במצב ניתוח אפשרויות (ראה סעיף PARSEOPT להלן).

--ציטוט רבוע
השתמש סילון rev-parse במצב ציטוט מעטפת (ראה סעיף SQ-QUOTE להלן). בניגוד ל
האפשרות --sq למטה, מצב זה עושה רק ציטוט. שום דבר אחר לא נעשה כדי לפקד
קֶלֶט.

אפשרויות ל --parseopt
--שמור-מקף
משמעותי רק במצב --parseopt. אומר למנתח האפשרויות להדהד את הראשון --
נפגשו במקום לדלג עליו.

--עצור בלא אופציה
משמעותי רק במצב --parseopt. מאפשר למנתח האפשרויות לעצור בהתחלה
טיעון ללא אופציה. זה יכול לשמש כדי לנתח פקודות משנה שלוקחות אפשרויות
עצמם.

--תקוע-ארוך
משמעותי רק במצב --parseopt. פלט את האפשרויות בצורתן הארוכה אם
זמינים, ועם הטיעונים שלהם תקועים.

אפשרויות ל סינון
--סל"ד בלבד
אל תוציא דגלים ופרמטרים שלא מיועדים סילון רשימת סיבובים פקודה.

--ללא סיבובים
אל תוציא דגלים ופרמטרים המיועדים ל סילון רשימת סיבובים פקודה.

--דגלים
אל תוציא פרמטרים שאינם דגל.

--ללא דגלים
אל תוציא פרמטרים של דגל.

אפשרויות ל תְפוּקָה
--בְּרִירַת מֶחדָל
אם אין פרמטר שניתן על ידי המשתמש, השתמש במקום זאת.

--תחילית
תתנהג כאילו סילון rev-parse הופעל מה- ספריית משנה של העבודה
עֵץ. כל שמות קבצים יחסיים נפתרים כאילו הם מקבלים קידומת ב ויהיה
מודפס בצורה זו.

זה יכול לשמש כדי להמיר ארגומנטים לפקודה המופעלת בספריית משנה כך שהם
עדיין ניתן להשתמש לאחר המעבר לרמה העליונה של המאגר. לדוגמה:

prefix=$(git rev-parse --show-prefix)
cd "$(git rev-parse --show-toplevel)"
eval "set -- $(git rev-parse --sq --prefix "$prefix" "$@")"

--תאשר
ודא שדווקא פרמטר אחד מסופק, ושניתן להפוך אותו לפרמטר גולמי
SHA-20 של 1 בתים שניתן להשתמש בו כדי לגשת למסד הנתונים של האובייקטים. אם כן, שחרר אותו ל-
פלט סטנדרטי; אחרת, שגיאה.

אם אתה רוצה לוודא שהפלט באמת נותן שם לאובייקט באובייקט שלך
מסד נתונים ו/או יכול לשמש כסוג מסוים של אובייקט שאתה צריך, אתה יכול להוסיף את
^{type} אופרטור פילינג לפרמטר. לדוגמה, git rev-parse "$VAR^{commit}"
יוודא ש-$VAR שם לאובייקט קיים שהוא commit-ish (כלומר commit, או
תג מוער שמצביע על commit). כדי לוודא ש-$VAR שם קיים
אובייקט מכל סוג, ניתן להשתמש ב-git rev-parse "$VAR^{object}".

-ש, -שקט
משמעותי רק במצב --verify. אל תוציא הודעת שגיאה אם ​​הארגומנט הראשון
אינו שם אובייקט חוקי; במקום זאת צא עם מצב שאינו אפס בשקט. SHA-1s עבור
שמות אובייקטים תקפים מודפסים ל-stdout עם הצלחה.

--מ"ר
בדרך כלל הפלט נעשה שורה אחת לכל דגל ופרמטר. אפשרות זו הופכת את הפלט ל-a
שורה בודדת, מצוטטת כהלכה לצריכה לפי מעטפת. שימושי כאשר אתה מצפה שלך
פרמטר שיכיל רווחים לבנים וקווים חדשים (למשל בעת שימוש ב-Pickaxe -S עם סילון
הבדל-*). בניגוד לאפשרות --sq-quote, קלט הפקודה עדיין מתפרש
כרגיל.

--לֹא
בעת הצגת שמות אובייקטים, הקדמת אותם ^ ופשט ^ קידומת משמות האובייקטים
שכבר יש להם אחד.

--abbrev-ref[=(מחמיר|רופף)]
שם קצר לא חד משמעי של שם האובייקט. האפשרות core.warnAmbiguousRefs היא
משמש לבחירת מצב קיצור קפדני.

--קצר, --קצר=מספר
במקום להוציא את ערכי SHA-1 המלאים של שמות אובייקטים נסה לקצר אותם ל
שם ייחודי קצר יותר. כאשר לא צוין אורך נעשה שימוש ב-7. האורך המינימלי הוא 4.

--סִמלִי
בדרך כלל שמות האובייקטים מופקים בצורת SHA-1 (עם אפשר ^ קידומת); זֶה
אפשרות הופכת אותם לפלט בצורה הקרובה ביותר לקלט המקורי ככל האפשר.

--סמלי-שם מלא
זה דומה ל--symbolic, אבל הוא משמיט קלט שאינם refs (כלומר ענף או
שמות תגים; או צורה מפורשת של "ראשים/מאסטר", כשתרצה בכך
תן שם לסניף "מאסטר" כאשר יש תג בשם למרבה הצער "מאסטר"), והצג
אותם בתור שמות מנוי מלאים (למשל "refs/heads/master").

אפשרויות ל אובייקטים
--את כל
הצג את כל השופטים שנמצאו ב-refs/.

--ענפים[=דפוס], --תגים[=דפוס], --שלטים[=דפוס]
הצג את כל הסניפים, התגים או ענפי המעקב מרחוק, בהתאמה (כלומר, נמצאו שו"פים
ב-refs/heads, refs/tags, או refs/remotes, בהתאמה).

אם ניתנת דפוס, יוצגו רק שוטים התואמים לכדור המעטפת הנתון. אם ה
דפוס אינו מכיל תו גלוב (?, * או [), הוא הופך לקידומת
התאם על ידי הוספה של /*.

--glob=דפוס
הצג את כל השומנים התואמים לתבנית כדורי המעטפת. אם התבנית לא מתחילה
עם refs/, זה מופיע אוטומטית מראש. אם התבנית אינה מכילה א
תו גלוב (?, * או [), הוא הופך להתאמת קידומת על ידי הוספה של /*.

--exclude=
אל תכלול התאמת שופטים שה--הכל, -הסניפים הבאים, -תייגים,
--רחוקים, או --glob אחרת ישקול. חזרות על אפשרות זו מצטברות
דפוסי אי הכללה עד --all, --ענפים, --tags, --remotes או --glob הבא
אפשרות (אפשרויות או ארגומנטים אחרים אינם מנקים דפוסים מצטברים).

הדפוסים הניתנים לא אמורים להתחיל עם refs/heads, refs/tags, או refs/remotes כאשר
מוחל על --ענפים, --תגים או --מרוחקים, בהתאמה, והם חייבים להתחיל עם
refs/ כאשר מוחל על --glob או --all. אם נגרר /* מיועד, יש לתת אותו
בִּמְפוּרָשׁ.

--לא משתמע לשתי פנים=
הצג כל אובייקט ששמו מתחיל בקידומת הנתונה. ה חייב להיות ב
באורך של לפחות 4 ספרות הקסדצימליות כדי למנוע רישום של כל אובייקט ואובייקט ב-
מאגר בטעות.

אפשרויות ל קבצים
--local-env-vars
רשום את משתני הסביבה GIT_* שהם מקומיים למאגר (למשל GIT_DIR או
GIT_WORK_TREE, אך לא GIT_EDITOR). רק שמות המשתנים רשומים, לא
ערכם, גם אם הם מוגדרים.

--git-dir
הצג $GIT_DIR אם הוגדר. אחרת הצג את הנתיב לספריית .git. הנתיב
מוצג, כאשר הוא יחסי, הוא יחסית לספריית העבודה הנוכחית.

אם $GIT_DIR לא מוגדר והספרייה הנוכחית לא מזוהה כשכבת ב-Git
מאגר או עץ עבודה הדפס הודעה ל-stderr וצא עם סטטוס שאינו אפס.

--git-common-dir
הצג $GIT_COMMON_DIR אם הוגדר, אחרת $GIT_DIR.

--is-inside-git-dir
כאשר ספריית העבודה הנוכחית נמצאת מתחת לספריית המאגר, הדפס "true",
אחרת "שקר".

--הוא-בתוך-עץ-עבודה
כאשר ספריית העבודה הנוכחית נמצאת בתוך עץ העבודה של המאגר הדפס
"נכון", אחרת "שקר".

--הוא-חשוף-מאגר
כאשר המאגר חשוף הדפס "נכון", אחרת "שקר".

--resolve-git-dir
תבדוק אם הוא מאגר חוקי או קובץ gitfile שמצביע על מאגר חוקי,
ולהדפיס את מיקום המאגר. אם הוא gitfile ואז נפתרה
הנתיב למאגר האמיתי מודפס.

--git-path
פתרון "$GIT_DIR/ ולוקח משתנים אחרים של העברת נתיב כגון
$GIT_OBJECT_DIRECTORY, $GIT_INDEX_FILE... בחשבון. לדוגמה, אם
$GIT_OBJECT_DIRECTORY מוגדר ל-/foo/bar ואז "git rev-parse --git-path objects/abc"
מחזירה /foo/bar/abc.

--show-cdup
כאשר הפקודה מופעלת מספריית משנה, הצג את הנתיב של הרמה העליונה
ספרייה ביחס לספרייה הנוכחית (בדרך כלל רצף של "../", או an
מחרוזת ריקה).

--הצג קידומת
כאשר הפקודה מופעלת מספריית משנה, הצג את הנתיב של הנוכחי
ספרייה ביחס לספרייה ברמה העליונה.

--הצג ברמה העליונה
הצג את הנתיב המוחלט של הספרייה ברמה העליונה.

---shared-index-path
הצג את הנתיב לקובץ האינדקס המשותף במצב אינדקס מפוצל, או ריק אם לא
מצב פיצול אינדקס.

אחר אפשרויות
--since=datestring, --after=datestring
נתח את מחרוזת התאריך והוציא את הפרמטר -max-age= התואם עבור סילון
רשימת סיבובים.

--until=מחרוזת תאריך, --before=מחרוזת תאריך
נתח את מחרוזת התאריך, ופלט את הפרמטר --min-age= המתאים עבור סילון
רשימת סיבובים.

...
דגלים ופרמטרים שיש לנתח.

מפרט סקירות

פרמטר גרסה בדרך כלל, אבל לא בהכרח, שם אובייקט commit. זה משתמש
מה שנקרא an מוּרחָב SHA-1 תחביר. להלן דרכים שונות לאיית שמות אובייקטים. ה
אלה הרשומים סמוך לסוף רשימה זו שמות עצים וכתמים הכלולים ב-commit.

למשל dae86e1950b1277e545cee180551750029cfe735, dae86e
שם אובייקט SHA-1 המלא (מחרוזת הקסדצימלית של 40 בתים), או מחרוזת משנה מובילה
הוא ייחודי בתוך המאגר. למשל dae86e1950b1277e545cee180551750029cfe735 ו
dae86e שמות שניהם לאותו אובייקט commit אם אין אובייקט אחר במאגר שלך
ששם האובייקט שלו מתחיל ב-dae86e.

למשל v1.7.4.2-679-g3bee7fb
פלט מ-git describe; כלומר התג הקרוב ביותר, אופציונלי ואחריו מקף ו-a
מספר התחייבויות, ואחריו מקף, א g, ושם אובייקט מקוצר.

למשל אב, ראשים / מאסטר, שופטים/ראשים/מאסטר
שם רשופט סמלי. לְמָשָׁל אב פירושו בדרך כלל אובייקט ה-commit שאליו מתייחס
שופטים/ראשים/מאסטר. אם במקרה יש לך את שניהם ראשים / מאסטר ו תגיות/מאסטר, אתה יכול
לומר במפורש ראשים / מאסטר להגיד ל-Git לאיזה מהם אתה מתכוון. כאשר מעורפל, א
מופרע על ידי לקיחת ההתאמה הראשונה בכללים הבאים:

1. אם $GIT_DIR/ קיים, לזה אתה מתכוון (בדרך כלל זה שימושי בלבד
ל ראש, FETCH_HEAD, ORIG_HEAD, MERGE_HEAD ו CHERRY_PICK_HEAD);

2. אחרת, שופטים/ אם הוא קיים;

3. אחרת, refs/tags/ אם הוא קיים;

4. אחרת, שופטים/ראשים/ אם הוא קיים;

5. אחרת, refs/remotes/ אם הוא קיים;

6. אחרת, refs/remotes/ /רֹאשׁ אם זה קיים.

ראש נותן שמות ל-commit שעליו ביססת את השינויים בעץ העבודה.
FETCH_HEAD מתעד את הסניף שהוצאת ממאגר מרוחק עם שלך
הזמנת אחזור git האחרונה. ORIG_HEAD נוצר על ידי פקודות שמזיזות את ראש
בצורה דרסטית, כדי לתעד את המיקום של ראש לפני הניתוח שלהם, אז
שאתה יכול בקלות לשנות את קצה הסניף בחזרה למצב לפני שהרצת
אותם. MERGE_HEAD רושם את ההתחייבויות שאתה ממזג לסניף שלך
כשאתה מפעיל git merge. CHERRY_PICK_HEAD רושם את ההתחייבות שאתה
קטיף דובדבנים כשאתה מפעיל git cherry-picking.

שימו לב שכל אחד מה שופטים/* המקרים לעיל עשויים לבוא מ- $GIT_DIR/refs
ספרייה או מה- $GIT_DIR/packed-refs קוֹבֶץ. בעוד שקידוד שם ה-ref הוא
לא צוין, UTF-8 מועדף מכיוון שעיבוד פלט מסוים עשוי להניח שמות ref
UTF-8.

@
@ לבד הוא קיצור דרך ראש.

@{ }למשל מאסטר@{אתמול}, HEAD@{5 דקות לִפנֵי}
שופט ואחריו הסיומת @ עם מפרט תאריך סגור בזוג פלטה
(לְמָשָׁל {אתמול}, {1 חודש 2 שבועות 3 ימים 1 שעה 1 שני לִפנֵי} or {1979-02-26
18:30:00}) מציין את הערך של ה-ref בנקודת זמן קודמת. סיומת זו עשויה
יש להשתמש רק מיד לאחר שם ר''פ ולר''פ חייב להיות יומן קיים
($GIT_DIR/logs/). שים לב שזה מחפש את המצב שלך מקומי ref בנתון
זְמַן; למשל, מה היה במקומך אב סניף בשבוע שעבר. אם אתה רוצה להסתכל
התחייבויות שנעשו בזמנים מסוימים, ראה --מאז ו --עד.

@{ }למשל מאסטר@{1}
שופט ואחריו הסיומת @ עם מפרט סידורי סגור בזוג פלטה
(לְמָשָׁל 1 {}, 15 {}) מציין את הערך הקודם של אותו ref. לדוגמה מאסטר@{1}
הוא הערך הקודם המיידי של אב בזמן מאסטר@{5} הוא הערך הקודם החמישי של
אב. ניתן להשתמש בסיומת זו רק מיד לאחר שם השופט ועל השופט
יש יומן קיים ($GIT_DIR/logs/).

@{ }למשל @{1}
אתה יכול להשתמש ב @ לבנות עם חלק ref ריק כדי להגיע לכניסת רילוג של ה
סניף נוכחי. לדוגמה, אם אתה בסניף blabla אז @{1} פירושו אותו דבר כמו
blabla@{1}.

@{- }למשל @{-1}
המבנה @{- } פירושו ה הסניף/התחייבות יצאה לפני הנוכחי
אחד.

@{בְּמַעֲלֶה הַזֶרֶם}למשל מאסטר@{upstream}, @{u}
הסיומת @{בְּמַעֲלֶה הַזֶרֶם} לשם סניף (טופס קצר @{u}) מתייחס ל
ענף שהענף שצוין על ידי branchname מוגדר לבנות עליו (configured
עם סניף. .מרחוק וסניף. .לְמַזֵג). ברירת המחדל של שם סניף חסר
הנוכחי.

@{לִדחוֹף}למשל מאסטר@{דחיפה}, @{לִדחוֹף}
הסיומת @{לִדחוֹף} מדווח על הסניף "לאן היינו דוחפים" אם git push היה פועל
בזמן שהסניף הוצא (או הנוכחי ראש אם לא צוין שם סניף).
מכיוון שיעד הדחיפה שלנו נמצא במאגר מרוחק, כמובן, אנו מדווחים על המקומי
ענף מעקב שמתאים לאותו ענף (כלומר, משהו ב refs/remotes/).

הנה דוגמה כדי להבהיר את זה:

$ git config push.default הנוכחי
$ git config remote.pushdefault myfork
$ git checkout -b mybranch origin/master

$ git rev-parse --symbolic-full-name @{upstream}
refs/remotes/origin/master

$ git rev-parse --symbolic-full-name @{push}
refs/remotes/myfork/mybranch

שימו לב בדוגמה שאנו מגדירים זרימת עבודה משולשת, שבה אנו מושכים מאחד
מיקום ודחוף לאחר. בזרימת עבודה לא משולשת, @{לִדחוֹף} הוא זהה
@{בְּמַעֲלֶה הַזֶרֶם}, ואין צורך בזה.

^למשל ראש ^, v1.5.1^0
סיומת ^ לפרמטר גרסה פירושו האב הראשון של אותו אובייקט commit. ^
פירושו ה ההורה (כלומר ^ שווה ^1). ככלל מיוחד,
^0 פירושו ההתחייבות עצמה ומשמשת כאשר הוא שם האובייקט של תג
אובייקט המתייחס לאובייקט commit.

~למשל מאסטר~3
סיומת ~ ל-Revision פרמטר פירושו אובייקט ה-commit שהוא ה- ה'
הדור הקדמון של אובייקט ה-commit הנקרא, עוקב רק אחר ההורים הראשונים. כְּלוֹמַר
~3 שווה ^^^ שווה ערך ל- ^1^1^1. ראה להלן עבור א
המחשה של השימוש בטופס זה.

^{ }למשל v0.99.8^{commit}
סיומת ^ ואחריו שם סוג אובייקט מוקף בצמד סוגריים פירושו הראה
האובייקט ב רקורסיבית עד לאובייקט מסוג נמצא או האובייקט
לא ניתן לבטל יותר (במקרה זה, barf). לדוגמה, אם הוא
מתחייב, ^{תחייב} מתאר את אובייקט ה-commit המתאים. באופן דומה, אם
הוא עץ עץ, ^{עץ} מתאר את אובייקט העץ המתאים. ^0 is
יד קצרה עבור ^{תחייב}.

rev^{אובייקט} ניתן להשתמש כדי לוודא לְהַאִיץ שם אובייקט שקיים, בלי
הדורש לְהַאִיץ להיות תג, וללא ניתוק לְהַאִיץ; כי תג הוא כבר an
אובייקט, אין צורך לפסול אותו אפילו פעם אחת כדי להגיע לאובייקט.

rev^{תג} ניתן להשתמש כדי להבטיח זאת לְהַאִיץ מזהה אובייקט תג קיים.

^{}למשל v0.99.8^{}
סיומת ^ ואחריו צמד סד ריק פירושו שהאובייקט יכול להיות תג, ו
יש להפנות את התג באופן רקורסיבי עד שנמצא אובייקט שאינו תג.

^{/ }למשל HEAD^{/תיקון מגעיל חרק}
סיומת ^ לפרמטר גרסה, ואחריו צמד סוגר שמכיל נורית טקסט
על ידי קו נטוי, זהה ל- :/לתקן מגעיל באג תחביר למטה פרט לכך שהוא מחזיר את
התחייבות ההתאמה הצעירה ביותר שניתן להגיע אליה מה- לפני ^.

:/למשל :/לתקן מגעיל באג
נקודתיים, ואחריו קו נטוי, ואחריו טקסט, נותנים שמות ל-commit שההודעה שלו.
מתאים לביטוי הרגולרי שצוין. שם זה מחזיר את ההתאמה הצעירה ביותר
commit שניתן להגיע אליו מכל שופט. אם הודעת ה-commit מתחילה ב-a ! אתה
צריך לחזור על זה; הרצף המיוחד :/!, ואחריו משהו אחר מאשר !, הוא
שמור לעת עתה. הביטוי הרגולרי יכול להתאים לכל חלק בהודעת ה-commit. ל
להתאים הודעות שמתחילות במחרוזת, אפשר להשתמש למשל :/^פו.

:למשל HEAD: README, :תקרא אותי, מאסטר:./README
סיומת : ואחריו נתיב שם את הכתם או העץ בנתיב הנתון בעץ-איש
אובייקט הנקרא על ידי החלק שלפני המעי הגס. :נָתִיב (עם חלק ריק לפני ה
colon) הוא מקרה מיוחד של התחביר המתואר הבא: תוכן שנרשם באינדקס
בנתיב הנתון. שביל שמתחיל ב ./ or ../ הוא יחסית לעבודה הנוכחית
מַדרִיך. הנתיב הנתון יומר להיות יחסי לשורש עץ העבודה
מַדרִיך. זה הכי שימושי כדי לטפל בגוש או עץ מ-commit או עץ זה
בעל מבנה עץ זהה לזה של עץ העבודה.

: :למשל :0: README, :תקרא אותי
נקודתיים, אופציונלית אחריו מספר שלב (0 עד 3) ונקודתיים, ואחריו א
נתיב, נותן שם לאובייקט כתם באינדקס בנתיב הנתון. מספר שלב חסר (ו
המעי הגס שאחריו) נותן שם לערך שלב 0. במהלך מיזוג, שלב 1 הוא
אב קדמון משותף, שלב 2 הוא הגרסה של ענף היעד (בדרך כלל הנוכחי
סניף), ושלב 3 הוא הגרסה מהסניף שמתמזג.

הנה איור מאת ג'ון לואלגר. שני צמתי ה-commit B ו-C הם הורים של commit
צומת א'. התחייבויות ההורים מסודרות משמאל לימין.

GHIJ
\/\/
DEF
\ | /\
\ | / |
\|/ |
לפני הספירה
\/
\/
A

A = = A^0
B = A^ = A^1 = A~1
C = A^2 = A^2
D = A^^ = A^1^1 = A~2
E = B^2 = A^^2
F = B^3 = A^^3
G = A^^^ = A^1^1^1 = A~3
H = D^2 = B^^2 = A^^^2 = A~2^2
I = F^ = B^3^ = A^^3^
J = F^2 = B^3^2 = A^^3^2

מפרט ריינג'ים

פקודות חוצות היסטוריה כמו git log פועלות על קבוצה של commits, לא רק על אחת
לְבַצֵעַ. לפקודות אלה, ציון גרסה אחת עם הסימון המתואר ב-
סעיף קודם פירושו קבוצת ההתחייבויות שניתן להגיע אליה מאותה התחייבות, לאחר ההתחייבות
שרשרת אבות.

כדי לא לכלול commits שניתן להגיע אליהם מ-commit, קידומת ^ נעשה שימוש בסימון. לְמָשָׁל ^r1 r2 אומר
מתחייבים שניתן להגיע אליהם מ r2 אך אל תכלול את אלה שניתן להגיע אליהם r1.

פעולת ההגדרה הזו מופיעה לעתים קרובות כל כך שיש קיצור שלה. כשיש לך שניים
מתחייב r1 ו r2 (שמו על פי התחביר שהוסבר ב-SPECIFYING REVISIONS לעיל),
אתה יכול לבקש התחייבויות שניתן להגיע אליהן מ-r2 למעט אלו שניתן להגיע אליהם
r1 מאת ^r1 r2 וניתן לכתוב אותו כ r1..r2.

סימון דומה r1...r2 נקרא הבדל סימטרי של r1 ו r2 ומוגדר כ
r1 r2 --לֹא $(git מיזוג-בסיס --את כל r1 r2). זה מכלול ההתחייבויות שניתן להגיע אליהם
מאחד מהם r1 or r2 אבל לא משניהם.

בשני הקיצורים האלה, אתה יכול להשמיט קצה אחד ולתת לו כברירת מחדל ל-HEAD. לדוגמה,
מָקוֹר.. הוא קיצור של מוצא..ראש ושואל "מה עשיתי מאז שהתפצלתי מה
ענף מקור?" באופן דומה, ..מָקוֹר הוא קיצור של HEAD..מקור ושואל "מה עשה
מוצא לעשות מאז שחילקתי מהם?" שים לב לזה .. היה אומר ראש..ראש שהוא ריק
טווח שניתן להגיע אליו ולא ניתן להגיע אליו מ-HEAD.

שני קיצורים נוספים למתן שם לסט שנוצר על ידי commit וההורה שלו commit
קיימים. ה r1^@ סימון פירושו כל ההורים של r1. r1^! כולל התחייבות r1 אבל לא כולל את כולם
של הוריו.

לסיכום:


כלול התחייבויות שניתן להגיע אליהן (כלומר אבותיהם של) .

^
אל תכלול התחייבויות שניתן להגיע אליהן (כלומר אבותיהם של) .

..
כלול התחייבויות שניתן להגיע אליהן אך אל תכלול את אלו שניתן להגיע אליהם
מ . מתי גם אוֹ מושמט, הוא כברירת מחדל ראש.

...
כלול התחייבויות שניתן להגיע אליהן משני הצדדים אוֹ אבל לא לכלול את אלה
נגישים משניהם. מתי גם אוֹ מושמט, הוא כברירת מחדל ראש.

^@למשל HEAD^@
סיומת ^ ואחריו סימן סימן זהה לרישום כל ההורים של
(כלומר, כלול כל דבר שניתן להגיע אליו מהוריו, אך לא את ההתחייבות עצמה).

^!למשל ראש ^!
סיומת ^ ואחריו סימן קריאה זהה למתן commit ולאחר מכן
כל הוריו עם קידומת ^ להוציא אותם (ואבותיהם).

הנה קומץ דוגמאות:

DGHD
DFGHIJDF
^GDHD
^DBEIJFB
B..CC
B...CGHDEBC
^DBCEIJFBC
CIJFC
C^@ IJF
ג^! ג
F^! DGHDF

PARSEOPT

במצב --parseopt, סילון rev-parse עוזר לאפשרויות עיסוי להביא לסקריפטים
אותם מתקנים יש ל-C. זה עובד כמנרמל אפשרות (למשל פיצול יחיד
מחליף ערכים מצטברים), קצת כמו getopt(1) עושה זאת.

זה לוקח על הקלט הסטנדרטי את מפרט האפשרויות לנתח ולהבין,
ומהדהד על הפלט הסטנדרטי מיתר מתאים sh(1) eval להחליף את
ויכוחים עם טיעונים מנורמלים. במקרה של שגיאה, הוא מוציא שימוש על השגיאה הסטנדרטית
זרם, ויוצא עם קוד 129.

הערה: הקפד לצטט את התוצאה בעת העברתה ל-eval. ראה למטה לדוגמא.

קֶלֶט פוּרמָט
סילון rev-parse --parseopt פורמט הקלט מבוסס על טקסט מלא. יש לו שני חלקים, מופרדים על ידי
שורה המכילה רק --. השורות לפני המפריד (צריך להיות אחד או יותר) הם
משמש לשימוש. השורות שאחרי המפריד מתארות את האפשרויות.

לכל שורת אפשרויות יש את הפורמט הזה:

* ? SP+ עזרה LF


הפורמט שלו הוא תו האופציה הקצר, ולאחר מכן שם האופציה הארוך מופרד ב-a
פסיק. שני החלקים אינם נדרשים, אם כי יש צורך לפחות אחד. עלול לא להכיל
כל אחד מה דמויות. h,help, dry-run ו-f הם דוגמאות ל-correct
.


הם של *, =, ? או!.

· השתמש ב-= אם האפשרות לוקחת ארגומנט.

· להשתמש ? להתכוון שהאופציה לוקחת ארגומנט אופציונלי. אתה כנראה רוצה
השתמש במצב --stuck-long כדי להיות מסוגל לנתח באופן חד משמעי את הארגומנט האופציונלי.

· השתמש ב-* כדי לומר שהאפשרות הזו לא צריכה להיות רשומה בשימוש שנוצר עבור
טיעון -h. זה מוצג עבור --help-all כפי שתועד ב gitcli(7).

· להשתמש ! כדי לא להפוך את האפשרות הארוכה השלילה המתאימה לזמינה.


, אם צוין, משמש כשם של הארגומנט בפלט העזרה, עבור
אפשרויות שלוקחות טיעונים. מסתיים על ידי הרווח הלבן הראשון. זה
נהוג להשתמש במקף כדי להפריד בין מילים ברמז ארגומנט רב מילים.

שאר הקו, לאחר הפשטת הרווחים, משמש כעזרה הקשורה אליו
האפשרות.

מתעלמים משורות ריקות, ושורות שאינן תואמות למפרט זה משמשות כאופציה
כותרות קבוצה (התחל את השורה עם רווח כדי ליצור שורות כאלה בכוונה).

דוגמה
OPTS_SPEC="\
פקודה כלשהי [אפשרויות] ...

פקודה כלשהי עושה פו ובר!
--
ח, עזור להראות את העזרה

foo איזו אפשרות נחמדה --foo
bar= אפשרות מגניבה --סרגל עם ארגומנט
baz=arg עוד אפשרות מגניבה --baz עם ארגומנט בשם
qux?path qux עשוי לקחת ארגומנט נתיב אבל יש לו משמעות בפני עצמה

כותרת קבוצת אפשרויות
ג? אפשרות C עם ארגומנט אופציונלי"

eval "$(echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)"

נוֹהָג טֶקסט
כאשר "$@" הוא -h או --help בדוגמה שלמעלה, טקסט השימוש הבא יוצג:

שימוש: פקודה כלשהי [אפשרויות] ...

פקודה כלשהי עושה פו ובר!

-ח, --עזרה להראות את העזרה
--foo אפשרות נחמדה --foo
--bar ... אפשרות מגניבה --bar עם ארגומנט
--באז עוד אפשרות מגניבה --baz עם ארגומנט בשם
--qux[= ] qux עשוי לקחת ארגומנט נתיב אבל יש לו משמעות בפני עצמה

כותרת קבוצת אפשרויות
-C[...] אפשרות C עם ארגומנט אופציונלי

SQ-QUOTE

במצב --sq-quote, סילון rev-parse מהדהד על הפלט הסטנדרטי קו בודד מתאים
sh(1) eval. קו זה נעשה על ידי נרמול הארגומנטים הבאים --sq-quote. שום דבר
מלבד ציטוט הטיעונים נעשה.

אם אתה רוצה שקלט הפקודה עדיין יתפרש כרגיל על ידי סילון rev-parse לפני
הפלט מצוטט במעטפת, עיין באפשרות --sq.

דוגמה
$ cat >your-git-script.sh <<\EOF
#!/ Bin / sh
args=$(git rev-parse --sq-quote "$@") # ציטוט ארגומנטים שסופקו על ידי המשתמש
command="git frotz -n24 $args" # והשתמש בו בתוך עבודת יד
# שורת פקודה
eval "$command"
EOF

$ sh your-git-script.sh "a b'c"

דוגמאות

· הדפס את שם האובייקט של ה-commit הנוכחי:

$ git rev-parse --verify HEAD

· הדפס את שם אובייקט ה-commit מהגרסה במשתנה מעטפת $REV:

$ git rev-parse --verify $REV^{commit}

פעולה זו תגרום לשגיאה אם ​​$REV ריק או לא גרסה חוקית.

· בדומה לעיל:

$ git rev-parse --default master --verify $REV

אבל אם $REV ריק, שם אובייקט ה-commit מהמאסטר יודפס.

GIT

חלק מ סילון(1) סוויטה

השתמש ב-git-rev-parse באינטרנט באמצעות שירותי onworks.net