Puis-je utiliser git diff sur des fichiers non suivis?

Est-il possible de demander à git diff d'inclure des fichiers non suivis dans sa sortie diff? Ou est mon meilleur pari pour ajouter les nouveaux fichiers que j'ai créés et les fichiers existants que j'ai édités et utiliser

git diff --cached

?

Avec les versions récentes de git, vous pouvez git add -Nle fichier (ou --intent-to-add), qui ajoute un blob de longueur nulle à l'index à cet emplacement. Le résultat est que votre fichier "non suivi" devient maintenant une modification pour ajouter tout le contenu à ce fichier de longueur nulle, et cela apparaît dans la sortie "git diff".

git diff

echo "this is a new file" > new.txt
git diff

git add -N new.txt
git diff
diff --git a/new.txt b/new.txt
index e69de29..3b2aed8 100644
--- a/new.txt
+++ b/new.txt
@@ -0,0 +1 @@
+this is a new file

Malheureusement, comme indiqué, vous ne pouvez pas tant git stashque vous avez un --intent-to-addfichier en attente comme celui-ci. Bien que si vous devez ranger, il vous suffit d'ajouter les nouveaux fichiers, puis de les ranger. Ou vous pouvez utiliser la solution de contournement d'émulation:

git update-index --add --cacheinfo \
100644 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 new.txt

(la création d'un alias est votre ami ici).

Je pense que vous pouvez comparer les fichiers de votre index et les fichiers non suivis en fournissant simplement le chemin d'accès aux deux fichiers.

git diff --no-index tracked_file untracked_file

Pour mon gitting interactif au jour le jour (où je diffère l'arborescence de travail contre la tête tout le temps, et j'aimerais avoir des fichiers non suivis inclus dans le diff), add -N/--intent-to-addest inutilisable, car il se casse git stash .

Voici donc mon git diffremplaçant. Ce n'est pas une solution particulièrement propre, mais comme je ne l'utilise que de manière interactive, je vais bien avec un hack:

d() {
    if test "$#" = 0; then
        (
            git diff --color
            git ls-files --others --exclude-standard |
                while read -r i; do git diff --color -- /dev/null "$i"; done
        ) | `git config --get core.pager`
    else
        git diff "$@"
    fi
}

Taper juste dinclura les fichiers non suivis dans le diff (ce qui m'importe dans mon flux de travail), et d args...se comportera comme d'habitude git diff.

Remarques:

• Nous utilisons ici le fait qu'il git diffs'agit uniquement de diffs individuels concaténés, il n'est donc pas possible de distinguer la dsortie d'un "vrai diff" - à l'exception du fait que tous les fichiers non suivis sont triés en dernier.
• Le seul problème avec cette fonction est que la sortie est colorisée même lorsqu'elle est redirigée; mais je ne peux pas être dérangé d'ajouter de la logique pour cela.
• Je n'ai trouvé aucun moyen d'obtenir des fichiers non suivis en assemblant simplement une liste d'arguments pour git diff. Si quelqu'un découvre comment faire cela, ou si une fonctionnalité est ajoutée gità un moment donné dans le futur, veuillez laisser une note ici!

Pas à 100% au point, mais si pour une raison quelconque vous ne voulez pas ajouter vos fichiers à l'index comme suggéré par la réponse acceptée, voici une autre option:

Si les fichiers ne sont pas suivis, le diff est évidemment le fichier entier, vous pouvez donc simplement les visualiser avec moins:

less $(git ls-files --others --exclude-standard)

Naviguez entre eux avec :net :ppour le suivant et le précédent.

Mise à jour à partir des commentaires: Si vous avez besoin d'un format de patch, vous pouvez également le combiner avec git diff:

git ls-files --others --exclude-standard | xargs -n 1 git --no-pager diff /dev/null | less

Vous pouvez également rediriger la sortie vers un fichier ou utiliser une autre commande diff dans ce cas.

git add -A
git diff HEAD

Générez le correctif si nécessaire, puis:

git reset HEAD

cela fonctionne pour moi:

git add my_file.txt
git diff --cached my_file.txt
git reset my_file.txt

La dernière étape est facultative, elle laissera le fichier dans l'état précédent (non suivi)

utile si vous créez également un patch:

  git diff --cached my_file.txt > my_file-patch.patch

Les changements fonctionnent lorsqu'ils sont intermédiaires et non intermédiaires avec cette commande. Les nouveaux fichiers fonctionnent lorsqu'ils sont organisés:

$ git diff HEAD

S'ils ne sont pas organisés, vous ne verrez que les différences de fichiers.

Pour un fichier:

git diff --no-index /dev/null new_file

Pour tous les nouveaux fichiers:

for next in $( git ls-files --others --exclude-standard ) ; do git --no-pager diff --no-index /dev/null $next; done;

Comme alias:

alias gdnew="for next in \$( git ls-files --others --exclude-standard ) ; do git --no-pager diff --no-index /dev/null \$next; done;"

Pour tous les fichiers modifiés et nouveaux combinés en une seule commande:

{ git --no-pager diff; gdnew }

généralement lorsque je travaille avec des équipes de sites distants, il est important pour moi d'avoir une connaissance préalable des changements effectués par d'autres équipes dans le même fichier, avant de suivre les étapes de git untrack -> staged -> commit pour cela j'ai écrit un script bash qui aidez-moi à éviter les conflits de fusion de résolution inutiles avec l'équipe distante ou créez une nouvelle branche locale et comparez et fusionnez sur la branche principale

#set -x 
branchname=`git branch | grep -F '*' |  awk '{print $2}'`
echo $branchname
git fetch origin ${branchname}
for file in `git status | grep "modified" | awk "{print $2}" `
do
echo "PLEASE CHECK OUT GIT DIFF FOR "$file 
git difftool FETCH_HEAD $file ;
done

dans le script ci-dessus, je récupère la branche principale distante (pas nécessaire sa branche principale) pour les FETCH_HEAD faire une liste de mon fichier modifié uniquement et comparer les fichiers modifiés à git difftool

ici de nombreux outils difft supportés par git, je configure 'Meld Diff Viewer' pour une bonne comparaison GUI.

En supposant que vous n'ayez pas de commits locaux,

git diff origin/master