Ci sono alcuni script che non funzionano correttamente se controllano le modifiche.

L'ho provato in questo modo:

VN=$(git describe --abbrev=7 HEAD 2>/dev/null)

git update-index -q --refresh
CHANGED=$(git diff-index --name-only HEAD --)
if [ ! -z $CHANGED ];
    then VN="$VN-mod"
fi

Esiste una sorta di controllo booleano se sono state apportate modifiche dall'ultimo commit o come posso davvero verificare se ci sono nuove modifiche nel mio repository locale?

Sto facendo tutto questo per uno script di creazione della versione (che ho trovato da qualche parte qui).

Quello che stai facendo funzionerà quasi: dovresti citare $CHANGEDnel caso in cui sia vuoto e -ztestare per vuoto, il che significa che non ci sono cambiamenti. Quello che intendevi era:

if [ -n "$CHANGED" ]; then
    VN="$VN-mod"
fi

Una citazione da Git GIT-VERSION-GEN:

git update-index -q --refresh
test -z "$(git diff-index --name-only HEAD --)" ||
VN="$VN-dirty"

Sembra che tu lo stia copiando, ma hai appena dimenticato quel dettaglio della citazione.

Certo, potresti anche fare questo:

if git diff-index --quiet HEAD --; then
    # No changes
else
    # Changes
fi

O se ti interessa solo il caso "qualcosa è cambiato":

if ! git diff-index --quiet HEAD --; then
    VN="$VN-mod"
fi

L'utilizzo --quietha il vantaggio che Git può interrompere l'elaborazione non appena incontra un singolo diff, quindi potrebbe non essere necessario controllare l'intero albero di lavoro.

Utilizzando git status:

cd /git/directory
if [[ `git status --porcelain` ]]; then
  # Changes
else
  # No changes
fi

Sebbene la risposta di Jefromi sia buona, sto pubblicando questo solo come riferimento.

Dal codice sorgente di Git c'è uno shscript che include quanto segue.

require_clean_work_tree () {
    git rev-parse --verify HEAD >/dev/null || exit 1
    git update-index -q --ignore-submodules --refresh
    err=0

    if ! git diff-files --quiet --ignore-submodules
    then
        echo >&2 "Cannot $1: You have unstaged changes."
        err=1
    fi

    if ! git diff-index --cached --quiet --ignore-submodules HEAD --
    then
        if [ $err = 0 ]
        then
            echo >&2 "Cannot $1: Your index contains uncommitted changes."
        else
            echo >&2 "Additionally, your index contains uncommitted changes."
        fi
        err=1
    fi

    if [ $err = 1 ]
    then
        test -n "$2" && echo >&2 "$2"
        exit 1
    fi
}

Ho avuto un problema simile, ma ho dovuto controllare anche i file aggiunti. Quindi ho fatto quanto segue:

cd /local/repo
RUN=0
git diff --no-ext-diff --quiet --exit-code || RUN=1
if [ $RUN = 0 ]; then
    RUN=`git ls-files --exclude-standard --others| wc -l`
fi

if [ $RUN = 0 ]; then
    exit 0
fi

git status È tuo amico

Passare alla directory Git per git statusfunzionare:

cd c:/path/to/.git

Impostare una variabile per impostare l'albero di lavoro in modo da non visualizzare l'errore "Questa operazione deve essere eseguita in un albero di lavoro":

WORKTREE=c:/path/to/worktree

Cattura il git status output in una variabile Bash

Utilizzare --porcelainquale garanzia di essere in un formato standard e analizzabile:

CHANGED=$(git --work-tree=${WORKTREE} status --porcelain)

Se -n (non null), abbiamo delle modifiche.

if [ -n "${CHANGED}" ]; then
  echo 'changed';

else
  echo 'not changed';
fi

Funziona anche questo:

if [ $(git status --porcelain | wc -l) -eq "0" ]; then
  echo "  🟢 Git repo is clean."
else
  echo "  🔴 Git repo dirty. Quit."
  exit 1
fi

Funziona bene. Elencherà anche i file interessati:

if git diff-index --name-status --exit-code HEAD;
then
    echo Git working copy is clean...;
else
    echo ;
    echo ERROR: Git working copy is dirty!;
    echo Commit your changes and try again.;
fi;

Ecco un bel set di funzioni di script Bash che controllano la presenza di un diff, lo stampano per l'utente e chiedono all'utente se vorrebbero eseguire il commit delle modifiche prima della distribuzione. È costruito per un'applicazione Heroku e Python, ma necessita di poche modifiche per qualsiasi altra applicazione.

commit(){
    echo "Please enter a commit message..."
    read msg
    git add . --all
    git commit -am $msg
}

check_commit(){
    echo ========== CHECKING FOR CHANGES ========
    changes=$(git diff)
    if [ -n "$changes" ]; then
        echo ""
        echo "*** CHANGES FOUND ***"
        echo "$changes"
        echo ""
        echo "You have uncomitted changes."
        echo "Would you like to commit them (y/n)?"
        read n
        case $n in
            "y") commit;;
            "n") echo "Changes will not be included...";;
            *) echo "invalid option";;
        esac
    else
        echo "... No changes found"
    fi
}

deploy(){
    check_commit
    echo ========== DEPLOYING TO HEROKU ========
    git push heroku master
    heroku run python manage.py syncdb
}

Puoi copiare da Gists su: https://gist.github.com/sshadmand/f33afe7c9071bb725105

La domanda del PO ha ormai più di 9 anni. Non so cosa abbia man git-statusdetto allora, ma ecco cosa dice ora:

--porcelain[=<version>]  
Give the output in an easy-to-parse format for scripts. This is similar to the 
short output, but will remain stable across Git versions and regardless of user 
configuration. See below for details.  

The version parameter is used to specify the format version. This is optional and 
defaults to the original version v1 format.  

Ciò suggerisce che l' --porcelainargomento è adatto per testare lo stato di un repository per le modifiche.

Ha scritto la domanda del PO: "Esiste una sorta di controllo booleano se sono state apportate modifiche dall'ultimo commit o come posso davvero verificare se sono state apportate nuove modifiche al mio repository locale?"

Non penso che bashabbia di per sé tipi di dati booleani , ma questo potrebbe essere abbastanza vicino:

[ -z "`git status --porcelain`" ] && echo "NULL-NO DIFFS" || echo "DIFFS EXIST"

Questo può essere rilanciato come if-then-elsemodulo per uno script o eseguito come è nella CLI mentre si trova nella cartella git repo . Altrimenti, utilizzare l' -Copzione con una specifica del percorso per il repository di interesse:

git -C ~/path/to/MyGitRepo status --porcelain 

Addendum:

1. Alcuni consigliano di utilizzare l' -u, --untracked-fileopzione per evitare di segnalare lo stato dei file che si desidera ignorare. Nota che questo ha uno sfortunato effetto collaterale : i file appena aggiunti non hanno nemmeno uno stato. L'opzione è utile in alcune situazioni , ma considerala attentamente prima dell'uso.

Ecco come lo faccio ...

CHANGES=`git status | grep "working directory clean"`
if [ ! CHANGES -eq "" ] then
    # do stuff here
else
    echo "You have uncommitted changes..."
fi

nano checker_git.sh

incolla questo

#!/bin/bash

echo "First arg: $1"

cd $1

bob="Already up-to-date."
echo $bob

echo $(git pull) > s.txt
cat s.txt
if [ "$(cat s.txt)" == "$bob" ]
then
echo "up"
else
echo "not up"

fi
rm -rf st.txt

correre sh checker_git.sh gitpath

Basato sul commento di @ storm_m2138 alla risposta di @ RyanMoon ( link ) Sto usando il seguente in Powershell.

function hasChanges($dir="."){ $null -ne (iex "git -C $dir status --porcelain --untracked-files=no") }

gci -Directory | ?{ hasChanges $_ } | %{ Write-Host "$_ has changes" }
gci -Directory | ?{ hasChanges $_ } | %{ iex "git -C $_ add -u"; iex "git -C $_ commit -m"Somemthing" }