Como posso escapar de espaços na linha de comando no Windows sem usar aspas?

Quase tudo funciona para mim, mas talvez tenha tentado a linha 5… escapar do espaço com um símbolo de carpete (^)

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:\>

Ou, por exemplo, abaixo onde a carpete realmente faz toda a diferença.

Parece que o símbolo da carpete pode ser a sua resposta, ver linha 3 abaixo.

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:\>

Descobri que colocar citações em torno de apenas uma parte do local funciona. No seu caso:

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

Embora isto utilize aspas, o importante é notar que os asteriscos são fora as aspas, pelo que continuam a funcionar correctamente.

Apesar das respostas darem a ilusão de que funciona, o facto é que não se pode esgueirar em espaços para os habituais argumentos cmd. Isto é fácil de provar:

1. Guarde “echo %1” como test.bat. Este ficheiro de lote irá produzir o primeiro argumento que o cmd nos passa.

2. Agora, tente executar test.bat, definindo o valor de %1 para foo bar. (Note que existe um valor de espaço entre foo e bar.)

3. Tentativa e erro durante alguns anos e percebe que não há forma de o fazer*. As pessoas vão sugerir que se escape usando ^, no entanto test.bat foo^ bar não produzirá foo bar.

Portanto, não há maneira de obter a produção foo bar, e o mais próximo que podemos obter é correr test.bat foo" "bar que produz foo" "bar, ou correr test.bat "foo bar" que produz "foo bar".

Agora, a razão pela qual as outras respostas appear a trabalhar é porque o cd faz ** é próprio**, divergindo do comportamento de passar o argumento habitual (os %1, %2, %3 e etc em ficheiros batch típicos).

Por exemplo, considere o comando peculiar:

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

Porque é que funciona? Isto deve-se ao facto de cd seu próprio fazer algo equivalente a juntar os 7 usuais argumentos num único lógico. De acordo com as normas de passagem de argumentos cmd, vemos 7 argumentos:

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

É como se cd tivesse juntado todos os 7 argumentos num único lógico, fazendo algo semelhante a array.join(" "), que produz o caminho:

c:\documents and settings \some folder with spaces

Note-se que este comportamento é peculiar a cd apenas (e algumas outras funções). Não tem nada a ver com a habitual passagem de argumentos.

De facto, cd tem outra peculiaridade. Lembra-se de termos dito acima que não conseguíamos obter o resultado foo bar? A produção mais próxima que conseguimos obter é executando:

test.bat foo" "bar

que produz foo" "bar, ou:

test.bat "foo bar"

que produz "foo bar", ou:

test.bat "foo "bar

que produz "foo "bar, ou:

test.bat foo" bar"

que produz foo" bar", ou:

test.bat "foo b"ar

que produz "foo b"ar, ou:

test.bat fo"o bar"

que produz fo"o bar", ou:

test.bat fo"o ba"r

que produz fo"o ba"r, ou:

test.bat "fo"o" bar"

que produz "fo"o" bar", ou:

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

que produz "f""o""o"" ""b""a""r", ou ainda:

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

que produz """"f"""o""""o"" ""ba"""r"""""""""".

Todos os exemplos acima têm uma semelhança, que é que eles vão produzir foo bar depois de apararmos os " chars. O autor de cd também deve ter percebido isto… se quiséssemos inferir a partir do comportamento peculiar de cd que dispõe todos os " que recebe , permitindo que todos estes comandos funcionem:

• 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

O nome do ficheiro curto parece funcionar como uma brisa.

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

Para aumentar a memória… ;)

Utilize o 8.3 nome do ficheiro curto. Por exemplo:

If exist c:\docume~1 goto :Ifoundthesucker

Para quem fala em substituição do 8.3, por favor note as duas coisas seguintes:

• O 8.3 pode ser definido para desactivado (ou activado) no NTFS, pelo que pode nem sempre existir.

• O nome do 8.3 de um ficheiro/pasta pode ser alterado sem aviso prévio apenas através da criação, renomeação ou eliminação de outras coisas na mesma pasta.

• Assim c:\docume~1 pode apontar para:

• Em lado nenhum (ser inválido)

• A pasta que pretende

• Outra pasta

• Uma pasta variável ao longo do tempo

Não é seguro, a menos que obtenha o nome curto e o utilize em operações atómicas.

Embora seja muito raro que mudem, é comum que não existam.

Se quiser saber se o 8.3 existe para uma determinada pasta/arquivo, teste-o com o parâmetro /X num comando dir, ou encapsule-o num for para obter apenas essa parte, etc.

Para mais informações sobre como activar/desactivar o 8.3 em NTFS, veja este artigo de suporte da Microsoft: https://support.microsoft.com/en-us/help/121007/how-to-disable-8-3-file-name-creation-on-ntfs-partitions

Seguindo o post de @Pang, e outros discutindo nomes curtos e as armadilhas, eis a maneira de resolver dinamicamente um nome longo para um nome curto:

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

Então, obviamente, você pode usar o nome curto em vez de citações circundantes.