¿Cómo puedo escapar de los espacios en la línea de comandos de Windows sin usar comillas?

Casi todo funciona para mí, pero ¿has probado con la línea 5… escapando del espacio con el símbolo del cometa (^)

1 C:\Documents and Settings\user>cd ..

2 C:\Documents and Settings>cd ..

3 C:\>cd Documents and Settings

4 C:\Documents and Settings>cd..

5 C:\>cd Documents^ and^ Settings

6 C:\Documents and Settings>cd..

7 C:\>cd C:\documents and settings

8 C:\Documents and Settings>cd..

9 C:\>

O, por ejemplo, debajo de donde el cometa realmente hace toda la diferencia.

Parece que desde abajo el símbolo del cometa puede ser tu respuesta, mira la línea 3 abajo.

1 C:\>"c:\Documents and Settings\a.bat"
gaga

2 C:\>c:\Documents and Settings\a.bat
'c:\Documents' is not recognized as an internal or external command,
operable program or batch file.

3 C:\>c:\Documents^ and^ Settings\a.bat
gaga

C:\>

Descubrí que poner citas alrededor de una parte del lugar funciona. En tu caso:

SVN add C:\"Documents and Settings"\username\svn\*.*

Aunque esto utiliza comillas, lo importante es que los asteriscos están fuera de las comillas, por lo que siguen funcionando correctamente.

A pesar de las respuestas que dan la ilusión de que funciona, el hecho es que no se puede colar en los espacios en los argumentos habituales de cmd. Esto es fácil de probar:

1. Guarda “echo %1” como test.bat. Este archivo por lotes emitirá el primer argumento que nos pase el cmd.

2. Ahora, intenta ejecutar test.bat, estableciendo el valor de %1 a foo bar. (Observe que hay un espacio entre foo y bar.)

3. Prueba y error durante unos años y date cuenta de que no hay manera de hacerlo. La gente sugerirá escapar usando ^, pero test.bat foo^ bar no producirá foo bar.

Así que no hay forma de obtener la salida de foo bar, y lo más cercano que podemos conseguir es correr test.bat foo" "bar que produce foo" "bar, o correr test.bat "foo bar" que produce "foo bar".

Ahora, la razón por la que las otras respuestas aparecen funcionar es porque cd hace su propio análisis sintáctico adicional, desviándose del comportamiento de paso de argumentos habitual (el habitual %1, %2, %3 y etc. en los típicos archivos por lotes).

Por ejemplo, consideremos el peculiar comando:

cd c:\documents and settings \some folder with spaces

¿Por qué funciona? Esto se debe a que cd **se hace algo equivalente a unir los 7 argumentos habituales en uno lógico. Según las normas de paso de argumentos del cmd, vemos 7 argumentos:

1. c:\documents
2. and
3. settings
4. \some
5. folder
6. with
7. spaces

Es como si cd hubiera unido los 7 argumentos en uno solo lógico, haciendo algo parecido a array.join(" "), lo que produce el camino:

c:\documents and settings \some folder with spaces

Nota que este comportamiento es peculiar sólo para cd (y algunas otras funciones). No tiene nada que ver con el habitual paso de argumentos.

De hecho, cd tiene otra peculiaridad. ¿Recuerda que dijimos antes que no podíamos obtener la salida foo bar? La salida más cercana que podemos obtener es ejecutando:

test.bat foo" "bar

que produce foo" "bar, o:

test.bat "foo bar"

que produce "foo bar", o:

test.bat "foo "bar

que produce "foo "bar, o:

test.bat foo" bar"

que produce foo" bar", o:

test.bat "foo b"ar

que produce "foo b"ar, o:

test.bat fo"o bar"

que produce fo"o bar", o:

test.bat fo"o ba"r

que produce fo"o ba"r, o:

test.bat "fo"o" bar"

que produce "fo"o" bar", o:

test.bat "f""o""o"" ""b""a""r":

que produce "f""o""o"" ""b""a""r", o incluso:

test.bat """"f"""o""""o"" ""ba"""r"""""""""":

que produce """"f"""o""""o"" ""ba"""r"""""""""".

Todos los ejemplos anteriores tienen una similitud, que es que producirán foo bar después de recortar los caracteres de ". El autor de cd debe haberse dado cuenta de esto también… …si fuéramos a inferir del peculiar comportamiento de cd que ** recortará todo " que reciba** , permitiendo que todos estos comandos funcionen:

• cd c:\documents and settings

• cd "c:\documents and settings"

• cd "c:"\"documents and settings"

• cd c:\"documents" "and" "settings"

• cd c:\"docu"ments an"d set"tings"

• cd c:"\"docu"ments an"d set"ti"""ngs

• cd "c"":""\"docu"ments an"d set"ti"""ngs

• cd "c"":""\"do""cu"me"nts a"n""d set"ti"""ngs

• cd c"""":""""\"""d"""oc""""u"me"""""nt"s a"n""d set"""""""ti""""ngs

• &007

El nombre corto parece funcionar como una brisa.

“E:\Progra~1\Java\Eclipse\eclipse.exe” -vmargs -Xms1024m -Xmx2048m

Para aumentar la memoria.. ;)

Use el nombre corto de 8.3. Por ejemplo:

If exist c:\docume~1 goto :Ifoundthesucker

Para los que hablan de la sustitución de 8.3, tened en cuenta las dos cosas siguientes:

• 8.3 se puede configurar como desactivado (o activado) en NTFS, por lo que puede que no siempre exista.
• El nombre 8.3 de un archivo/carpeta puede cambiar sin previo aviso con sólo crear, renombrar o eliminar otras cosas de la misma carpeta.

Así que c:\docume~1 puede apuntar a:

• En ninguna parte (no es válido)
• La carpeta que quieres
• Otra carpeta
• Una carpeta variable a lo largo del tiempo

No es seguro, a menos que obtengas el nombre corto y lo uses en operaciones atómicas.

Aunque es muy poco común que cambien, es común que no existan.

Si quieres saber si 8.3 existe para una carpeta/archivo en particular, pruébalo con el parámetro /X en un comando dir, o encápsalo en un for para obtener sólo esa parte, etc.

Para más información sobre cómo habilitar/deshabilitar 8.3 en NTFS, consulta este artículo de soporte de Microsoft: https://support.microsoft.com/en-us/help/121007/how-to-disable-8-3-file-name-creation-on-ntfs-partitions

Siguiendo con el post de @Pang, y otros discutiendo los nombres cortos y las trampas, aquí está la manera de resolver dinámicamente un nombre largo a un nombre corto:

for %A in ("C:\Some\long path\which must exist\to be resolved") do @echo %~sA

Entonces, obviamente se puede usar el nombre corto en lugar de las citas circundantes.