¿Por qué Git trata este archivo de texto como un archivo binario?

Me pregunto por qué git me dice esto :?

$ git diff MyFile.txt
diff --git a/MyFile.txt b/MyFile.txt
index d41a4f3..15dcfa2 100644
Binary files a/MyFile.txt and b/MyFile.txt differ

¿No son archivos de texto?

He comprobado los atributos .gitattributes y está vacío. ¿Por qué recibo este mensaje? Ya no puedo obtener diferencias como solía hacerlo

ADICIONAL:

He notado que hay un @en los permisos de archivo, ¿qué es esto? Podría ser ésta la razón?

$ls -all
drwxr-xr-x   5 nacho4d  staff    170 28 Jul 17:07 .
drwxr-xr-x  16 nacho4d  staff    544 28 Jul 16:39 ..
-rw-r--r--@  1 nacho4d  staff   6148 28 Jul 16:15 .DS_Store
-rw-r--r--@  1 nacho4d  staff    746 28 Jul 17:07 MyFile.txt
-rw-r--r--   1 nacho4d  staff  22538  5 Apr 16:18 OtherFile.txt

Simplemente significa que cuando git inspecciona el contenido real del archivo (no sabe que ninguna extensión dada no es un archivo binario; puede usar el archivo de atributos si desea decirlo explícitamente; vea las páginas del manual).

Después de inspeccionar el contenido del archivo, ha visto cosas que no están en caracteres ascii básicos. Siendo UTF16, espero que tenga caracteres 'divertidos', por lo que cree que es binario.

Hay formas de decirle a git si tiene internacionalización (i18n) o formatos de caracteres extendidos para el archivo. No estoy suficientemente informado sobre el método exacto para configurar eso: es posible que necesite RT [Completo] M ;-)

Editar: una búsqueda rápida de SO encontró can-i-make-git-Recognize-a-utf-16-file-as-text que debería darle algunas pistas.

Si no ha establecido el tipo de archivo, Git intenta determinarlo automáticamente y un archivo con líneas realmente largas y quizás algunos caracteres anchos (por ejemplo, Unicode) se trata como binario. Con el archivo .gitattributes puede definir cómo Git interpreta el archivo. Establecer la diferencia atributo manualmente le permite a Git interpretar el contenido del archivo como texto y hará un diff habitual.

Simplemente agregue un atributo .gitattributes a su carpeta raíz del repositorio y establezca el atributo diff en las rutas o archivos. Aquí hay un ejemplo:

src/Acme/DemoBundle/Resources/public/js/i18n/* diff
doc/Help/NothingToSay.yml                      diff
*.css                                          diff

Si desea verificar si hay atributos establecidos en un archivo, puede hacerlo con la ayuda de git check-attr

git check-attr --all -- src/my_file.txt

Otra buena referencia sobre los atributos de Git se puede encontrar aquí .

Estaba teniendo este problema donde Git GUI y SourceTree trataban los archivos Java / JS como binarios y, por lo tanto, no podían ver la diferencia

Crear un archivo llamado "atributos" en la carpeta .git \ info con el siguiente contenido resolvió el problema

*.java diff
*.js diff
*.pl diff
*.txt diff
*.ts diff
*.html diff

Si desea realizar este cambio para todos los repositorios, puede agregar el archivo de atributos en la siguiente ubicación $ HOME / .config / git / atributos

Git incluso determinará que es binario si tiene una línea súper larga en su archivo de texto. Rompí una cadena larga, convirtiéndola en varias líneas de código fuente, y de repente el archivo pasó de ser 'binario' a un archivo de texto que pude ver (en SmartGit).

Por lo tanto, no siga escribiendo demasiado a la derecha sin presionar 'Enter' en su editor; de lo contrario, Git pensará que ha creado un archivo binario.

Tuve el mismo problema después de editar uno de mis archivos en un nuevo editor. Resulta que el nuevo editor utilizó una codificación diferente (Unicode) que mi antiguo editor (UTF-8). Así que simplemente le dije a mi nuevo editor que guardara mis archivos con UTF-8 y luego git mostró mis cambios nuevamente y no lo vi como un archivo binario.

Creo que el problema era simplemente que git no sabe cómo comparar archivos de diferentes tipos de codificación. Por lo tanto, el tipo de codificación que usa realmente no importa, siempre que permanezca consistente.

No lo probé, pero estoy seguro de que si hubiera confirmado mi archivo con la nueva codificación Unicode, la próxima vez que realice cambios en ese archivo habría mostrado los cambios correctamente y no lo habría detectado como binario, ya que entonces habría estado comparando dos archivos codificados Unicode, y no un archivo UTF-8 con un archivo Unicode.

Puede usar una aplicación como Notepad ++ para ver y cambiar fácilmente el tipo de codificación de un archivo de texto; Abra el archivo en Notepad ++ y use el menú Codificación en la barra de herramientas.

He tenido el mismo problema Encontré el hilo cuando busco solución en google, aún no encuentro ninguna pista. Pero creo que encontré la razón después de estudiar, el siguiente ejemplo explicará claramente mi pista.

    echo "new text" > new.txt
    git add new.txt
    git commit -m "dummy"

por ahora, el archivo new.txt se considera como un archivo de texto.

    echo -e "newer text\000" > new.txt
    git diff

obtendrás este resultado

diff --git a/new.txt b/new.txt
index fa49b07..410428c 100644
Binary files a/new.txt and b/new.txt differ

y prueba esto

git diff -a

llegarás abajo

    diff --git a/new.txt b/new.txt
    index fa49b07..9664e3f 100644
    --- a/new.txt
    +++ b/new.txt
    @@ -1 +1 @@
    -new file
    +newer text^@

Tuvimos este caso en el que un archivo .html se veía como binario cada vez que intentábamos hacer cambios en él. Muy frío para no ver diferencias. Para ser honesto, no verifiqué todas las soluciones aquí, pero lo que funcionó para nosotros fue lo siguiente:

1. Eliminó el archivo (en realidad lo movió a mi escritorio) y confirmó el git deletion . Git diceDeleted file with mode 100644 (Regular) Binary file differs
2. Vuelva a agregar el archivo (en realidad lo movió de mi escritorio al proyecto). Git dice que New file with mode 100644 (Regular) 1 chunk, 135 insertions, 0 deletionsel archivo ahora se agrega como un archivo de texto normal

De ahora en adelante, cualquier cambio que hice en el archivo se ve como una diferencia de texto normal. También podría aplastar estas confirmaciones (1, 2 y 3 son el cambio real que realiza), pero prefiero poder ver en el futuro lo que hice. El aplastamiento 1 y 2 mostrará un cambio binario.

Según esta útil respuesta , puede preguntarle directamente a Git por qué trata un archivo de una manera particular:

cd directory/of/interest
file *

Produce resultados útiles como este:

$ file *
CR6Series_stats resaved.dat: ASCII text, with very long lines, with CRLF line terminators
CR6Series_stats utf8.dat:    UTF-8 Unicode (with BOM) text, with very long lines, with CRLF line terminators
CR6Series_stats.dat:         ASCII text, with very long lines, with CRLF line terminators
readme.md:                   ASCII text, with CRLF line terminators

Esto también es causado (al menos en Windows) por archivos de texto que tienen UTF-8 con codificación BOM . Cambiar la codificación a UTF-8 normal hizo que Git viera el archivo como tipo = texto

Tuve una instancia donde .gitignorecontenía una \rsecuencia doble (retorno de carro) por propósito.

Ese archivo fue identificado como binario por git. Agregar un .gitattributesarchivo ayudó.

# .gitattributes file
.gitignore diff

Si git check-attr --all -- src/my_file.txtindica que su archivo está marcado como binario y no lo ha configurado como binario .gitattributes, verifíquelo /.git/info/attributes.

Cambie Aux.js a otro nombre, como Sig.js.

El árbol fuente todavía lo muestra como un archivo binario, pero puede organizarlo (agregarlo) y confirmar.

Tuve un problema similar al pegar un texto de un mensaje binario de Kafka, que insertó caracteres no visibles y causó que git pensara que el archivo es binario.

Encontré los caracteres ofensivos buscando en el archivo usando expresiones regulares [^ -~\n\r\t]+.

• [ emparejar personajes en este conjunto
• ^ coincide con los personajes que no están en este conjunto
• -~ coincide con todos los caracteres desde '' (espacio) hasta '~'
• \n nueva línea
• \r retorno de carro
• \t lengüeta
• ] conjunto cerrado
• + coincidir con uno o más de estos personajes

Acabo de pasar varias horas revisando todo en esta lista tratando de averiguar por qué uno de los proyectos de prueba en mi solución no agregaba ninguna prueba al explorador.

Resultó en mi caso que de alguna manera (probablemente debido a una fusión pobre de git en alguna parte) que VS había perdido por completo una referencia al proyecto. Todavía estaba en construcción, pero noté que solo construía las dependencias.

Luego noté que no se mostraba en la lista de dependencias en sí, así que eliminé y volví a agregar el proyecto de prueba y todas mis pruebas aparecieron finalmente.