Crie um alias no Windows XP

Na escola, eu costumava ter um arquivo .login ao longo das linhas de

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

Gostaria de fazer esse tipo de coisa com minha caixa 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 mexer no registro ou executar um arquivo em lotes grande?

Minha razão original para perguntar isso foi que eu só precisava da linha de comando para um comando em uma pasta específica e queria poder acessar essa pasta rapidamente quando iniciei a linha de comando. Mas a resposta aceita para esta pergunta é tão boa que decidi perguntar sobre o problema original como uma pergunta separada: Altere para a pasta inicial padrão do prompt de comando do Windows .

Parece que poucas pessoas sabem disso, mas você pode usar a doskeyferramenta macro integrada, o único problema é que ela não é salva. Existem muitas maneiras de contornar isso.

uso:

doskey ls=dir

lsagora fará uma lista de diretórios exatamente como dirfaria.

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

doskey d=dir $*

Quanto à solução alternativa para fazê-los economizar:

• 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. Dê um nome curto como a.cmd , portanto, quando você abrir o cmd, poderá digitar a para carregar seus aliases.

Se digitar ae pressionar Enterparece muito trabalhoso, jogue isso no script AutoHotkey :

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

Carregando aliases automaticamente :

Você pode alterar todos os atalhos para cmd para apontar %SystemRoot%\system32\cmd.exe /K C:\path\to\aliases.cmd, substituindo C:\path\to\aliases.cmdpelo local do arquivo de aliases. Se você normalmente executá-lo na caixa de execução, pode:

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

É 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 o doskey, por exemplo, c: \ bin \ cmd_autoruns.cmd :

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

3. Crie e execute uma vez um arquivo em lotes (por exemplo, set_cmd_autorun.cmd ) que definirá a Autorunchave do Processador de Comando como nosso 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 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"

Minha resposta é semelhante à de vriolk

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, em um prompt do cmd, execute "cmd /?" para encontrar a chave do Registro a ser editada para a execução automática do cmd:

HKEY_LOCAL_MACHINE \ Software \ Microsoft \ Command Processor \ AutoRun
  e / ou
HKEY_CURRENT_USER \ Software \ Microsoft \ Command Processor \ AutoRun

usando o regedit, adicione o caminho do seu arquivo em lotes de macro ao valor AutoRun (adicione a chave AutoRun se não estiver lá):

c: \ winscripts \ autoexec.bat

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

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

@para %% e em (% PATHEXT%) do @para %% i em (% 1 %% e) do @se NÃO "%% ~ $ PATH: i" == "" eco %% ~ $ PATH: i

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

c:> onde está javaw
c: \ jdk \ bin \ javaw.exe

Você pode criar arquivos .cmd e colocá-los em algum lugar do seu% PATH% (como C: \ Windows). Para usar seu alias da web como 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 simples.

uma maneira muito rápida e suja de ter um atalho pronto, que não exige muita confusão - é criar um arquivo em lotes 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 ++ por meio de um alias, então 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 em qualquer shell do cmd, sem arquivos de execução automática e / ou excursões ao registro

O jeito que eu fiz 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 pelos scripts pobres, mas o uso é bastante bom, imo. Coloque-o em algum lugar do seu caminho, adicione .py ao seu PATHEXT e adicione c: \ aliases ao seu PATH também (ou altere-o, o que for adequado) e use:

alias <command> <action>

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

alias -p <command or part of>

Para exibir o que é algo.

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

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

edit2: Na verdade, algo parecido com isto, mas adicionar ao material 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.