Crie um alias no Windows XP

Question

De volta à escola, eu costumava ter um arquivo .login nos moldes de

alias ll = ls -l  
alias dir = ls -Fhl  
alias web = cd ~/public/public_www/development  

Eu gostaria de fazer esse tipo de coisa com minha caixa de XP aqui no trabalho, mas a maioria dos recursos que encontrei on-line parece bastante complicada e pesada. Existe uma maneira de fazer isso que não envolva mucking no registro ou executando um arquivo de lote grande?

Meu motivo original para perguntar isso é que eu só preciso da linha de comando para um comando em uma pasta específica, e queria poder chegar rapidamente a essa pasta quando eu iniciei a linha de comando. Mas a resposta aceita para essa pergunta é tão boa que decidi perguntar sobre o meu problema original como uma questão separada: Mude para a pasta de início padrão para o prompt de comando do Windows .

    

Answer 1

Poucas pessoas parecem saber disso, mas você pode usar a ferramenta de macro interna doskey , o único problema é que ela não salva. Existem muitas maneiras de contornar isso.

uso:

doskey ls=dir

ls fará agora uma listagem de diretórios como dir .

Se você quiser usar argumentos com os comandos, use esta sintaxe:

doskey d=dir $*

Quanto à solução alternativa para salvá-los:

• salve todos os aliases em um arquivo neste formato:

doskey ls=dir
doskey ..=cd ..

e coloque-o em um dos diretórios em seu caminho. Nomeie algo curto como a.cmd , então quando você abrir o cmd, você pode digitar a para carregar seus aliases.

Se digitar um a e pressionar Enter parece muito trabalho, coloque isso no seu AutoHotkey :

WinWaitActive, C:\WINDOWS\system32\cmd.exe
Send {a}{Enter}

Carregando aliases automaticamente :

Você pode alterar todos os atalhos para cmd para apontar para %SystemRoot%\system32\cmd.exe /K C:\path\to\aliases.cmd , substituindo C:\path\to\aliases.cmd pela localização de seu arquivo de aliases. Se você normalmente o executa a partir da caixa de execução, você pode:

• Renomeie o executável do cmd para o cmd2.exe, por exemplo, e substitua-o por um script ou outro executável que ative o comando acima (eu realmente não recomendaria esse método, pois muitos aplicativos dependem do cmd)
• Faça um script em lote e chame-o de cmda (cmd com aliases) por exemplo. Faça com que ele ative o comando acima e coloque esse script em algum lugar em seu caminho.

Answer 2

É simples como:

1. Crie um arquivo com aliases, por exemplo c: \ bin \ aliases :

   ls=dir /ONE $*
   cd=cd /d $*
   python=python -ic "" 
   ps=tasklist $*
   kill=taskkill /IM $*
   

2. Crie um arquivo com todas as coisas que você deseja executar quando o cmd.exe for iniciado, incluindo o carregamento dos aliases com doskey , e. c: \ bin \ cmd_autoruns.cmd :

   @echo off
   cls
   color 0A
   doskey /macrofile=c:\bin\aliases
   

3. Crie e execute uma vez um arquivo em lote (por exemplo, set_cmd_autorun.cmd ), que definirá a chave Autorun do Processador de comandos como cmd_autoruns.cmd :

   reg add "hkcu\software\microsoft\command processor" /v Autorun /t reg_sz /d c:\bin\cmd_autoruns.cmd
   

Como alternativa ao set_cmd_autorun.cmd , também é possível criar um arquivo .reg como o abaixo e depois mesclá-lo com um clique duplo:

REGEDIT4

[HKEY_CURRENT_USER\Software\Microsoft\Command Processor]
"CompletionChar"=dword:00000009
"DefaultColor"=dword:00000000
"EnableExtensions"=dword:00000001
"PathCompletionChar"=dword:00000009
"Autorun"="c:\bin\cmd_autoruns.cmd"

    

Answer 3

Minha resposta é semelhante à do vriolk

Eu criei um arquivo .bat que continha minhas macros (por exemplo, c: \ winscripts \ autoexec.bat):

@doskey whereis=c:\winscripts\whereis.cmd $*
@doskey ls=dir /b $*
@doskey l=dir /od/p/q/tw $*

e, em seguida, a partir de um prompt de cmd, correu "cmd /?" para encontrar a chave de registro para editar a autoria do cmd:

HKEY_LOCAL_MACHINE\Software\Microsoft\Command Processor\AutoRun
  and/or
HKEY_CURRENT_USER\Software\Microsoft\Command Processor\AutoRun

usando o regedit, adicione o caminho para o arquivo de lote de macro ao valor AutoRun (adicione a chave AutoRun se ela não estiver lá):

c:\winscripts\autoexec.bat

agora sempre que você executar "cmd" no prompt "Executar", "Executar", este autoexec.bat também será executado e criará as macros doskey para você.

A propósito, whereis.cmd contém isto:

@for %%e in (%PATHEXT%) do @for %%i in (%1%%e) do @if NOT "%%~$PATH:i"=="" echo %%~$PATH:i

que pesquisa sua variável PATH para o termo que você fornece:

c:>whereis javaw
c:\jdk\bin\javaw.exe

    

Answer 4

Você pode criar arquivos .cmd e colocá-los em algum lugar em% PATH% (como C: \ Windows). Para usar seu alias da web como um exemplo:

@C:
@cd \inetpub\wwwroot

faria algo como:

M:\> web
C:\inetpub\wwwroot>

Não conheço nenhuma maneira de criar um arquivo de estilo .aliases plano.

    

Answer 5

uma maneira muito rápida e suja de ter um atalho pronto, que não requer muito barulho - é criar um arquivo em lote com o nome do alias, em um dos diretórios que fazem parte da variável de ambiente PATH . Por exemplo, eu queria chamar o Notepad ++ através de um alias, então eu criei o npp.bat em C: \ WINDOWS que continha o seguinte:

"c:\Program Files\Notepad++\notepad++.exe" %1 %2 %3 %4 %5

agora o comando npp pode ser usado a partir de qualquer shell cmd, sem arquivos de execução automática e / ou excursões ao registro

    

Answer 6

A maneira como fiz isso foi com um script python rápido:

import sys
import string
import os
import glob

def listAll():
        for infile in glob.glob("c:\aliases\*.bat"):
            fileName = infile
            fileName = fileName[len("c:\aliases\"):len(fileName)-4]
            fileContents = open("c:\aliases\" + fileName + ".bat", "r")
            fileContents.readline()
            fileContentString=fileContents.readline()
            fileName += " is aliased to "
            fileName += fileContentString[0:len(fileContentString)-3]
            print fileName

def listSome(which):
        for infile in glob.glob("c:\aliases\*.bat"):
            fileName = infile
            fileName = fileName[len("c:\aliases\"):len(fileName)-4]
            fileContents = open("c:\aliases\" + fileName + ".bat", "r")
            fileContents.readline()
            fileContentString=fileContents.readline()
            if fileName.find(which)==0:
                fileName += " is aliased to "
                fileName += fileContentString[0:len(fileContentString)-3]
                print fileName

if len(sys.argv)>1:
    if sys.argv[1]!="-p":
        file = open("c:\aliases\"+sys.argv[1]+".bat", "w")
        file.write("@ECHO OFF\n")
        counter=0
        totalInput=""
        counter=0
        for arg in sys.argv:
            if counter > 1:
                totalInput+= arg + " "
            counter+=1

        if totalInput.find(".exe")!=-1:
            file.write("\"")

        counter=0

        for arg in sys.argv:
            if counter > 1:
                file.write(arg)
                if sys.argv[1]==sys.argv[2]:
                    if counter==2:
                        file.write(".exe")
                temparg=str(arg)
                if temparg.find(".exe")!=-1:
                    file.write("\"")
                file.write(" ")
            counter+=1
        file.write("%*")

        print "Aliased " + sys.argv[1] + " to " + totalInput
    else:
        if len(sys.argv)>2:
            listSome(sys.argv[2])
        else:
            listAll()
else:
    listAll()

Desculpas pelo mau roteiro, mas o uso é muito bom, imo. Coloque-o em algum lugar em seu caminho, adicione .py ao seu PATHEXT e adicione c: \ aliases ao seu PATH também (ou altere-o, o que for adequado), e então use:

alias <command> <action>

para alias (Sim, não =, embora não seja difícil adicionar um .split lá), e:

alias -p <command or part of>

Para mostrar o que é algo.

Hackish, mas estupidamente útil. Há um script de unalias equivalente, mas tenho certeza que você pode resolver isso.

edit: Isto obviamente requer python, escrito na v26, mas provavelmente funcionará em qualquer coisa recente. Como antes, desculpe pela qualidade:)

edit2: Na verdade, algo assim, mas para adicionar ao doskey seria melhor. Você também pode adicionar comandos de inicialização ao cmd com a chave de registro de execução automática, para que seja muito mais limpo.