La Réponse Courte (TL;DR)

"l'Arbre-ish" est un terme qui fait référence à un identificateur (comme spécifié dans le le Git révision de la documentation ) qui conduit finalement à un (sous) répertoire arbre (Git se réfère aux répertoires comme "arbres" et"objets arbre").

dans le cas de l'affiche originale, foo est un répertoire qu'il veut spécifier. La manière correcte de spécifiez un répertoire (sub)dans Git est d'utiliser ceci "l'arbre-ish" syntaxe (point n ° 15 de le Git révisions de la documentation ):

<rev>:<path> , p.ex. HEAD:README , :README , master:./README

suffixe : suivi d'un chemin nomme le blob ou l'arbre au chemin donné en l'objet arborescent nommé par la partie avant le colon.

Donc, en d'autres termes, master:foo est la syntaxe correcte, pas master/foo .

Autres "Arbre-ish" (en Plus de s'Engager à-ish)

Voici une liste complète des identificateurs commit-ish et tree-ish (de le Git Documentation des révisions , merci à LopSae pour l'avoir pointé out ):

----------------------------------------------------------------------
|    Commit-ish/Tree-ish    |                Examples
----------------------------------------------------------------------
|  1. <sha1>                | dae86e1950b1277e545cee180551750029cfe735
|  2. <describeOutput>      | v1.7.4.2-679-g3bee7fb
|  3. <refname>             | master, heads/master, refs/heads/master
|  4. <refname>@{<date>}    | master@{yesterday}, HEAD@{5 minutes ago}
|  5. <refname>@{<n>}       | master@{1}
|  6. @{<n>}                | @{1}
|  7. @{-<n>}               | @{-1}
|  8. <refname>@{upstream}  | master@{upstream}, @{u}
|  9. <rev>^                | HEAD^, v1.5.1^0
| 10. <rev>~<n>             | master~3
| 11. <rev>^{<type>}        | v0.99.8^{commit}
| 12. <rev>^{}              | v0.99.8^{}
| 13. <rev>^{/<text>}       | HEAD^{/fix nasty bug}
| 14. :/<text>              | :/fix nasty bug
----------------------------------------------------------------------
|       Tree-ish only       |                Examples
----------------------------------------------------------------------
| 15. <rev>:<path>          | HEAD:README, :README, master:./README
----------------------------------------------------------------------
|         Tree-ish?         |                Examples
----------------------------------------------------------------------
| 16. :<n>:<path>           | :0:README, :README
----------------------------------------------------------------------

les identificateurs #1-14 sont tous "commit-ish", parce qu'ils mènent tous à commits, mais parce que engage indique aussi les arborescences des répertoires, elles conduisent toutes finalement à (sous -) répertoire des objets de l'arborescence, et peut donc également être utilisé comme "l'arbre-ish".

#15 peut également être utilisé comme arbre-ish quand il se réfère à un sous-répertoire, mais il peut également être utilisée pour identifier des fichiers. Quand il se réfère à des fichiers, Je ne suis pas c'est sûr si c'est toujours considéré comme "arbre-ish", ou si c'est plutôt "blob-ish" (Git renvoie aux fichiers comme "blobs").

La Longue Réponse

à son niveau le plus bas niveau, Git garde la trace du code source en utilisant quatre les objets:

1. tags annotés, qui pointent pour commettre.
2. Commits, qui pointent vers l'arbre des répertoires racine de votre projet.
3. arbres, qui sont des répertoires et des sous-répertoires.
4. Blobs, qui sont des fichiers.

chacun de ces objets a son propre sha1 hash ID, depuis Linus Torvalds conçu Git comme un content - addressable système de fichiers, c'est à dire les fichiers peuvent être récupérés basé sur leur contenu (les ID sha1 sont générés à partir du contenu du fichier). Le Pro Git le livre donne cet exemple de diagramme :

de nombreuses commandes Git peuvent accepter des identificateurs spéciaux pour les commits et le répertoire (sub) arbres:

• "Commit-ish" sont les identificateurs qui conduisent finalement à un objet commit. Par exemple,

  tag -> commit

• "l'Arbre-ish" sont des identifiants qui conduisent finalement à l'arbre (c) du répertoire d'objets.

  tag -> commit -> project-root-directory

parce que les objets commit pointent toujours vers un objet directory tree (la racine répertoire de votre projet), tout identifiant qui est "commit-ish" est, par définition, aussi "arbre-ish". En d'autres termes, tout identificateur qui conduit à un commit object peut aussi être utilisé pour mener à un (sub)répertoire tree object .

mais puisque les objets de l'arborescence des répertoires ne pointent jamais vers commits dans le versioning de Git système, tous les identificateurs qui pointent vers une arborescence de répertoire (sub)ne peuvent pas être utilisé pour pointer vers un commit. En d'autres termes, l'ensemble des identificateurs "commit-ish" est une stricte sous-ensemble de l'ensemble de "l'arbre-ish" identificateurs.

comme expliqué dans la documentation ( merci à Trebor pour aider moi la trouvera ):

<tree>

indique le nom d'un objet arborescent.

<commit>

indique un nom d'objet commit.

<tree-ish>

indique un nom d'objet tree, commit ou tag. Commande qui prend un <tree-ish> argument veut finalement opérer sur un <tree> objet, mais automatiquement déréférence <commit> et <tag> objets de ce point à un <tree> .

<commit-ish>

indique un nom d'objet commit ou tag. Une commande qui prend un <commit-ish> argument veut finalement opérer sur un <commit> objet, mais automatiquement déréférence <tag> objets de ce point à un <commit> .

Le jeu de l'arbre-ish identifiants que ne peut être utilisé que s'engager à-ish sont

1. <rev>:<path> , qui mène directement aux arbres répertoires, pas de commit objet. Par exemple, HEAD:subdirectory .

2. Sha1 identificateurs de arborescence de répertoires objets.