Como impedir que o prompt de comando seja fechado após a execução?

Meu problema é que, no Windows, há janelas da linha de comando que fecham imediatamente após a execução. Para resolver isso, quero que o comportamento padrão seja que a janela seja mantida aberta. Normalmente, esse comportamento pode ser evitado com três métodos que me vêm à mente:

1. Colocar uma pauselinha após programas em lote para solicitar ao usuário que pressione uma tecla antes de sair
2. Executando esses arquivos em lotes ou outras ferramentas de manipulação de linha de comando (até mesmo a inicialização, a reinicialização do serviço etc. com net start xyou algo semelhante) em cmd.exe(Iniciar - Executar - cmd.exe)
3. Executando estes programas com o cmd /kseguinte: cmd /k myprogram.bat

Mas existem outros casos em que o usuário:

1. Executa o programa pela primeira vez e não sabe que o programa fornecido será executado no Prompt de Comando (Windows Command Processor), por exemplo, ao executar um atalho no menu Iniciar (ou em outro lugar), OU
2. Acha um pouco desconfortável executar o cmd.exe o tempo todo e não tem tempo / oportunidade para reescrever o código desses comandos em todos os lugares para colocar uma pausa após eles ou evitar sair explicitamente.

Eu li um artigo sobre como alterar o comportamento padrão cmd.exeao abri-lo explicitamente, criando uma entrada de AutoRun e manipulando seu conteúdo nesses locais:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Command Processor\AutoRun
HKEY_CURRENT_USER\SOFTWARE\Microsoft\Command Processor\AutoRun

(Os itens de AutoRun são _String values_...)

Eu coloquei cmd /d /kcomo um valor para tentar, mas isso não mudou o comportamento dos itens mencionados acima ... Ele apenas mudou o comportamento da janela da linha de comando ao abri-la explicitamente (Start-Run- cmd.exe).

Então, como isso funciona? Você pode me dar alguma idéia para resolver este problema?

Eu tenho uma solução que só pode ser aplicada em .cmde .batarquivos:

Abra regedite vá para cada um dos seguintes:

[HKEY_CLASSES_ROOT\batfile\shell\open\command]
[HKEY_CLASSES_ROOT\cmdfile\shell\open\command] 

Agora altere o "Valor da chave padrão" para cmd.exe /k "%1" %*. Agora, toda janela de script em lote permanecerá aberta após sua execução.

Observe que isso é como usar cmd.exe /c cmd.exe /k program.bat, o que significa que outra instância do CMD será iniciada na pai. Não consegui encontrar como substituir o primeiro /cargumento.

Você também pode fazer isso com [exefile], mas agora ele mostrará uma caixa de console vazia se o executável tiver uma GUI.

Quote Microsoft :

Um console é fechado quando o último processo anexado a ele termina ou chama o FreeConsole.

Em outras palavras, a janela do console do Win32 sempre será fechada quando o último programa em execução dentro dela sair e você não poderá alterar isso.

(Para programas de MS-DOS de 16 bits, o Windows oferece a opção "Fechar na saída" na caixa de diálogo de propriedades, mas isso não é uma exceção ao comportamento acima: é o processo NTVDM que mantém a janela aberta. Além disso, essa opção é novamente por programa.)

Basta abrir um prompt de comando no local do seu arquivo em lotes e digitar manualmente o nome do arquivo em lotes para executá-lo nessa janela.

1. Navegue até a pasta em que seu executável reside
2.Shift-Clique com o botão direito do mouse e selecione "Janela de comando daqui"
3. digite o nome do executável e pressione enter
4. O processo deve ser executado, mas a janela deve permanecer aberta

cmd.exe /klhe dará problemas com algum lote. Se o lote exit 1(sem /B) seu console será fechado. Um truque é usar:

cmd.exe /k cmd /c ...

Para usar isso por padrão para todos os arquivos em lotes, defina HKEY_CLASSES_ROOT\cmdfile\shell\open\command\(default)e HKEY_CLASSES_ROOT\batfile\shell\open\command\(default)como "%windir%\system32\cmd.exe" /k "%windir%\system32\cmd" /c "%1" %*.

Acabei de encontrar uma solução idiota depois de ler grawitya resposta.

Meu caso de uso foi configurar um ambiente de console no trabalho, onde todas as soluções mais razoáveis ​​foram bloqueadas. Tudo que eu preciso é definir PATH e configurar alguns aliases de doskey e ser despejado no shell.

Minha solução (apenas testada no Win7) como adicionar cmdcomo a última linha no arquivo em lotes. Isso executa um prompt de comando aninhado que herda o ambiente de seu pai. Esse shell filho mantém o processo em lote aberto até você SAIR, quando o lote não possui processos filhos e também sai.

Em vez de usar PAUSE (prefiro CHOICE ou TIMEOUT a usar PAUSE quando necessário), você pode usar a solução aqui: 886848 / como fazer-janelas-arquivo-em lote-pausar-quando-clicar duas vezes .

Dessa forma, se você clicar em um arquivo em lotes ou em um link (atalho) no Windows Explorer, poderá fazer uma pausa no programa de arquivos em lotes antes de sair para poder visualizar a saída do programa e quaisquer mensagens de erro.

Usando CHOICE, você pode programar a capacidade de o usuário selecionar uma variedade de ações a serem executadas, e usar TIMEOUT pode deixar a janela fechar após um atraso de tempo (sem supervisão). Se você executar o arquivo em lotes de dentro de uma janela do prompt de comando, essas pausas podem ser irritantes.

A solução vinculada permitirá que você decida se deseja pular as pausas se o arquivo em lotes foi executado em uma janela do prompt de comando.

Você pode ler mais no link fornecido, mas o básico é que ele usa a variável de ambiente:

%cmdcmdline%

para determinar se o arquivo em lotes foi executado em uma janela de comando ou não.

Então, você o usa assim:

No ponto em que o arquivo em lotes será encerrado, você adiciona um código como este:

echo %cmdcmdline:"=-% | find /i "cmd /c --%~dpf0%-"
if %errorlevel% NEQ 0 goto :EOF
pause
goto :EOF

rem if %errorlevel% EQU 0 batch-file: %~dpf0 was executed from Windows Explorer, ...
rem if %errorlevel% NEQ 0 batch-file: %~dpf0 was executed from within a Command Prompt

A melhor maneira que encontrei para contornar isso é chamar seus arquivos em lote de outro arquivo em lote usando start.

portanto, se você normalmente executa um arquivo chamado go.bat, cria um segundo arquivo em lote chamado go2.bat

o conteúdo do go2.bat seria apenas

start go.bat

a primeira janela fecha imediatamente, mas a que está executando o seu go.bat permanece aberta

Isso funciona para a versão 5.00 do Editor do Registro do Windows.

[HKEY_CLASSES_ROOT\batfile\shell\open\command]
@="cmd.exe /k \"%1\" %*"

[HKEY_CLASSES_ROOT\cmdfile\shell\open\command]
@="cmd.exe /k \"%1\" %*"

Salve os cmds acima em um arquivo chamado algo como cmdbatfile-open.rege execute-o!

Suponha que você tenha dois arquivos em lote que deseja iniciar em sua própria instância e mantenha aberto se o executável sair. Vamos chamar esses dois lotes A.bate B.bat.

Agora, para simplificar, você pode ter um arquivo em lotes para iniciar os dois, vamos chamar assim launch_both.batcom o conteúdo:

start cmd /k "A.bat & cmd /c"
start cmd /k "B.bat & cmd /c"

Pode não funcionar como esperado se você chamar exitum dos dois arquivos em lote. Isso precisará ser testado.

Para usuários que usam o Windows 10, observe que nenhuma das respostas acima atualmente funciona para o Windows 10.

No Windows 10, se você tiver acesso ao script, precisará adicionar o seguinte código no final:

read

Esse código aguardará uma entrada antes de fechar.

Em resposta ao PSIXO rebaixado - "Esta resposta já foi abordada na pergunta. - Ro Yo Mi 20 de janeiro de 16 às 5:06" - NÃO, NÃO foi. As respostas anteriores foram: "pausa", que NÃO funcionou. A resposta do PSIXO foi: "& pause", que funciona. Analise com mais cuidado antes de fazer o downgrade. Eu executei isso em um prompt IDLE e funcionou:

    >>> os.system('dir ^ & pause')
    0
    >>> 

Por outro lado:

    >>> os.system('dir ^ pause')
    1
    >>>

NÃO funcionou (o prompt do cmd passou e, de fato, retornou um erro (1)). Agradeço ao PSIXO pela resposta que eu precisava. Henry.