Suponiendo que tengo un archivo de texto
alex
bob
matrix
will be removed
git repo
y lo he actualizado para que sea
alex
new line here
another new line
bob
matrix
git
Aquí, agregué el número de línea (2,3) y el número de línea actualizado (6)
¿Cómo puedo obtener la información de estos números de línea usando git diff o cualquier otro comando git?
Respuestas:
git diff --stat le mostrará el resultado que obtiene cuando comete cosas, que es a la que se refiere, supongo.
git diff --stat
Para mostrar exactamente los números de línea que se han cambiado, puede usar
git blame -p <file> | grep "Not Committed Yet"
Y la línea cambiada será el último número antes del paréntesis final en el resultado. Sin embargo, no es una solución limpia :(
Aquí hay una función bash para calcular los números de línea resultantes de una diferencia:
diff-lines() {
local path=
local line=
while read; do
esc=$'\033'
if [[ $REPLY =~ ---\ (a/)?.* ]]; then
continue
elif [[ $REPLY =~ \+\+\+\ (b/)?([^[:blank:]$esc]+).* ]]; then
path=${BASH_REMATCH[2]}
elif [[ $REPLY =~ @@\ -[0-9]+(,[0-9]+)?\ \+([0-9]+)(,[0-9]+)?\ @@.* ]]; then
line=${BASH_REMATCH[2]}
elif [[ $REPLY =~ ^($esc\[[0-9;]+m)*([\ +-]) ]]; then
echo "$path:$line:$REPLY"
if [[ ${BASH_REMATCH[2]} != - ]]; then
((line++))
fi
fi
done
}
Puede producir resultados como:
$ git diff | diff-lines
http-fetch.c:1: #include "cache.h"
http-fetch.c:2: #include "walker.h"
http-fetch.c:3:
http-fetch.c:4:-int cmd_http_fetch(int argc, const char **argv, const char *prefix)
http-fetch.c:4:+int main(int argc, const char **argv)
http-fetch.c:5: {
http-fetch.c:6:+ const char *prefix;
http-fetch.c:7: struct walker *walker;
http-fetch.c:8: int commits_on_stdin = 0;
http-fetch.c:9: int commits;
http-fetch.c:19: int get_verbosely = 0;
http-fetch.c:20: int get_recover = 0;
http-fetch.c:21:
http-fetch.c:22:+ prefix = setup_git_directory();
http-fetch.c:23:+
http-fetch.c:24: git_config(git_default_config, NULL);
http-fetch.c:25:
http-fetch.c:26: while (arg < argc && argv[arg][0] == '-') {
fetch.h:1: #include "config.h"
fetch.h:2: #include "http.h"
fetch.h:3:
fetch.h:4:-int cmd_http_fetch(int argc, const char **argv, const char *prefix);
fetch.h:4:+int main(int argc, const char **argv);
fetch.h:5:
fetch.h:6: void start_fetch(const char* uri);
fetch.h:7: bool fetch_succeeded(int status_code);
de una diferencia como esta:
$ git diff
diff --git a/builtin-http-fetch.c b/http-fetch.c
similarity index 95%
rename from builtin-http-fetch.c
rename to http-fetch.c
index f3e63d7..e8f44ba 100644
--- a/builtin-http-fetch.c
+++ b/http-fetch.c
@@ -1,8 +1,9 @@
#include "cache.h"
#include "walker.h"
-int cmd_http_fetch(int argc, const char **argv, const char *prefix)
+int main(int argc, const char **argv)
{
+ const char *prefix;
struct walker *walker;
int commits_on_stdin = 0;
int commits;
@@ -18,6 +19,8 @@ int cmd_http_fetch(int argc, const char **argv, const char *prefix)
int get_verbosely = 0;
int get_recover = 0;
+ prefix = setup_git_directory();
+
git_config(git_default_config, NULL);
while (arg < argc && argv[arg][0] == '-') {
diff --git a/fetch.h b/fetch.h
index 5fd3e65..d43e0ca 100644
--- a/fetch.h
+++ b/fetch.h
@@ -1,7 +1,7 @@
#include "config.h"
#include "http.h"
-int cmd_http_fetch(int argc, const char **argv, const char *prefix);
+int main(int argc, const char **argv);
void start_fetch(const char* uri);
bool fetch_succeeded(int status_code);
Si solo desea mostrar líneas agregadas / eliminadas / modificadas, y no el contexto circundante, puede pasar -U0a git diff:
$ git diff -U0 | diff-lines
http-fetch.c:4:-int cmd_http_fetch(int argc, const char **argv, const char *prefix)
http-fetch.c:4:+int main(int argc, const char **argv)
http-fetch.c:6:+ const char *prefix;
http-fetch.c:22:+ prefix = setup_git_directory();
http-fetch.c:23:+
fetch.h:4:-int cmd_http_fetch(int argc, const char **argv, const char *prefix);
fetch.h:4:+int main(int argc, const char **argv);
Es robusto contra los códigos de color ANSI, por lo que puede pasar --color=alwaysa git diff para obtener la codificación de color habitual para las líneas agregadas / eliminadas.
La salida se puede grep fácilmente:
$ git diff -U0 | diff-lines | grep 'main'
http-fetch.c:4:+int main(int argc, const char **argv)
fetch.h:4:+int main(int argc, const char **argv);
En tu caso git diff -U0daría:
$ git diff -U0 | diff-lines
test.txt:2:+new line here
test.txt:3:+another new line
test.txt:6:-will be removed
test.txt:6:-git repo
test.txt:6:+git
Si solo desea los números de línea, cambie echo "$path:$line:$REPLY"a just echo "$line"y canalice la salida uniq.
git diff --colorno se transmiten. ¿O cree que sería mejor simplemente agregar los escapes de color al retorno de esta función?
git diff --color | diff-linesahora funciona como se esperaba :)
zsh: parse error near `]+m'Alguna idea? El error proviene de esta línea:elif [[ $REPLY =~ ^($esc\[[0-9;]+m)*([\ +-]) ]]; then
Utilizo la --unified=0opción de git diff.
Por ejemplo, git diff --unified=0 commit1 commit2genera el diff:
Debido a la --unified=0opción, la salida diff muestra 0 líneas de contexto; en otras palabras, muestra exactamente las líneas cambiadas .
Ahora, puede identificar las líneas que comienzan con '@@' y analizarlas según el patrón:
@@ -startline1,count1 +startline2,count2 @@
Volviendo al ejemplo anterior, para el archivo WildcardBinding.java, comience desde la línea 910, se eliminan 0 líneas. Comience desde la línea 911, se agregan 4 líneas.
@@ -910,10,+911,15@@
Tuve este mismo problema, así que escribí un script gawk que cambia la salida de git diff para anteponer el número de línea para cada línea. A veces lo encuentro útil cuando necesito diferenciar el árbol de trabajo, aunque no se limita a eso. ¿Quizás sea útil para alguien aquí?
$ git diff HEAD~1 |showlinenum.awk
diff --git a/doc.txt b/doc.txt
index fae6176..6ca8c26 100644
--- a/doc.txt
+++ b/doc.txt
@@ -1,3 +1,3 @@
1: red
2: blue
:-green
3:+yellow
Puede descargarlo desde aquí:
https://github.com/jay/showlinenum
git diffn para hacer esto también, y retiene completamente los colores de la terminal y muestra los números de línea tanto del archivo antiguo a la izquierda como del nuevo archivo a la derecha.
Números de línea de todas las líneas no comprometidas (agregadas / modificadas):
git blame <file> | grep -n '^0\{8\} ' | cut -f1 -d:
Salida de ejemplo:
1
2
8
12
13
14
Configure una herramienta de diferenciación externa que le mostrará los números de línea. Por ejemplo, esto es lo que tengo en mi configuración global de git:
diff.guitool=kdiff3
difftool.kdiff3.path=c:/Program Files (x86)/KDiff3/kdiff3.exe
difftool.kdiff3.cmd="c:/Program Files (x86)/KDiff3/kdiff3.exe" "$LOCAL" "$REMOTE"
Consulte esta respuesta para obtener más detalles: https://stackoverflow.com/q/949242/526535
Aquí hay una función de bash que improvisé:
echo ${f}:
for n in $(git --no-pager blame --line-porcelain $1 |
awk '/author Not Committed Yet/{if (a && a !~ /author Not Committed Yet/) print a} {a=$0}' |
awk '{print $3}') ; do
if (( prev_line > -1 )) ; then
if (( "$n" > (prev_line + 1) )) ; then
if (( (prev_line - range_start) > 1 )) ; then
echo -n "$range_start-$prev_line,"
else
echo -n "$range_start,$prev_line,"
fi
range_start=$n
fi
else
range_start=$n
fi
prev_line=$n
done
if (( "$range_start" != "$prev_line" )) ; then
echo "$range_start-$prev_line"
else
echo "$range_start"
fi
Y termina luciendo así:
views.py:
403,404,533-538,546-548,550-552,554-559,565-567,580-582
Este es probablemente un recuento bastante preciso de líneas cambiadas:
git diff --word-diff <commit> |egrep '(?:\[-)|(?:\{\+)' |wc -l
Además, aquí hay una solución para los números de línea en su diff: https://github.com/jay/showlinenum
Puede usar git diffjunto con el shortstatparámetro para mostrar simplemente el número de líneas cambiadas.
Para el número de líneas cambiado (en un archivo que ya está en el repositorio) desde su última confirmación
git diff HEAD --shortstat
Producirá algo similar a
1 file changed, 4 insertions(+)
Estaba buscando una forma de generar solo las líneas cambiadas para cada archivo usando git diff. Mi idea era enviar esta salida a un linter para la verificación de tipos. Esto es lo que me ayudó
Aquí hay algo de copia de Python para obtener los números de línea de las líneas modificadas / eliminadas, en caso de que se encuentre con esta pregunta buscando eso.
Debería ser bastante fácil modificarlo en algo que también obtenga los números de línea modificados y agregados.
Solo lo he probado en Windows, pero también debería ser multiplataforma.
import re
import subprocess
def main(file1: str, file2: str):
diff = get_git_diff(file1, file2)
print(edited_lines(diff))
def edited_lines(git_diff: str):
ans = []
diff_lines = git_diff.split("\n")
found_first = False
# adjust for added lines
adjust = 0
# how many lines since the start
count = 0
for line in diff_lines:
if found_first:
count += 1
if line.startswith('-'):
# minus one because count is 1 when we're looking at the start line
ans.append(start + count - adjust - 1)
continue
if line.startswith('+'):
adjust += 1
continue
# get the start line
match = re.fullmatch(r'@@ \-(\d+),\d+ \+\d+,\d+ @@', line)
if match:
start = int(match.group(1))
count = 0
adjust = 0
found_first = True
return ans
def get_git_diff(file1: str, file2: str):
try:
diff_process: subprocess.CompletedProcess = subprocess.run(['git', 'diff', '--no-index', '-u', file1, file2], shell=True, check=True, stdout=subprocess.PIPE)
ans = diff_process.stdout
# git may exit with 1 even though it worked
except subprocess.CalledProcessError as e:
if e.stdout and e.stderr is None:
ans = e.stdout
else:
raise
# remove carriage at the end of lines from Windows
ans = ans.decode()
ans.replace('\r', '')
return ans
if __name__ == "__main__":
main("file1.txt", "file2.txt")