Tutoriais Básicos de Programação em AutoHotkey!

Artigos, manuais, conselhos e dicas sobre programação em AutoHotkey

Moderator: Gio

User avatar
Gio
Posts: 1247
Joined: 30 Sep 2013, 10:54
Location: Brazil

Re: Tutoriais Básicos de Programação em AutoHotkey!

Post by Gio » 13 May 2019, 15:35

Boa tarde Ardente07.

Obrigado pelo feedback, e que bom que os tutoriais lhe foram úteis :thumbup:

A ideia destes tutoriais é servir como um ponto de partida para os falantes de língua portuguesa que quiserem aprender a programar usando o AutoHotkey. Assim, eles cobrem principalmente as ferramentas básicas da linguagem, ou seja, aquelas que quase invariavelmente vamos encontrar no caminho da nossa curva de aprendizagem. Nesse sentido, ainda há muito a ser aprendido por qualquer um que desejar se tornar um programador completo, mas uma vez que se aprenda o básico, o leque de possibilidades da programação vai se abrir muito e aí vai ficar mais complicado criar um tutorial e chamar de "básico de programação". Por isso, se você já dominou os assuntos aqui tratados e quiser aprender ainda mais, você poderá verificar os outros tutoriais que temos na seção tutoriais, ou então, caso o assunto em questão não tenha sido tratado ainda naquela seção, você também pode criar um tópico no fórum Ajuda e Suporte Geral. Assim, poderemos discutir outros assuntos conforme você for sentindo a necessidade de aprendê-los.

Para exemplificar, aqui vão alguns exemplos de assuntos que creio não serem adequados para uma série de tutoriais "básicos de programação", mas que podem ser discutidos sem problemas em outros tópicos ou outros tutoriais:

1. Automação de programas (excel, word, internet explorer)
2. Obtenção de dados a partir de páginas da web
3. Criação de jogos
4. Edição de imagens
5. Otimização de programas
6. Inteligência Artificial
7. Estilos de Telas
8. Bancos de Dados
9. Segurança da informação
10. Criação de programas para empresas específicas (criação de softwares para concessionárias, panificadoras, farmácias, mercearias, oficinas de veículos, escritórios de contabilidade, etc)

User avatar
RAFACN
Posts: 12
Joined: 20 May 2016, 10:06
Location: BRAZIL

Re: Tutoriais Básicos de Programação em AutoHotkey!

Post by RAFACN » 18 May 2019, 19:53

Programo com o Autohotkey já fazem alguns anos.. acho uma ferramenta espetacular. Agradeço a iniciativa de criar este tópico em português. Sempre foi algo que achei que faltava para os iniciantes na linguagem e até para quem já conhece há algum tempo, como material de consulta ou para solidificação dos conhecimentos adquiridos previamente. :clap:

User avatar
Gio
Posts: 1247
Joined: 30 Sep 2013, 10:54
Location: Brazil

Re: Tutoriais Básicos de Programação em AutoHotkey!

Post by Gio » 20 May 2019, 11:19

Obrigado pelo feedback RAFACN.

Temos por objetivo trazer para os fórums em português bastante conteúdo de qualidade e também formarmos uma comunidade saudável de programadores e usuários em geral. Se quiser contribuir, basta criar um tópico em qualquer seção sempre que sentir vontade de fazê-lo :thumbup:

Ahk_BR
Posts: 8
Joined: 22 Jan 2023, 01:47

Re: Tutoriais Básicos de Programação em AutoHotkey!

Post by Ahk_BR » 22 Jan 2023, 08:07

Show do bola GIO!
Hora de retribuir o que já aprendi e o que ainda vou aprender com teus escritos.
Seguem algumas traduções que fiz e que podem ajudar os interessados que aqui passarem.
Os textos estão formatados como .md (exporta pdf bacana com Typora, Obsidian, Pandoc, etc)
Abraço.

Ahk_BR
Posts: 8
Joined: 22 Jan 2023, 01:47

Re: Tutoriais Básicos de Programação em AutoHotkey!

Post by Ahk_BR » 22 Jan 2023, 08:09

# Conceitos e Convenções

Este documento cobre alguns conceitos e convenções gerais usados pelo AutoHotKey focando mais a explanação do que código. Do leitor não é requerido nenhum conhecimento anterior sobre scripts ou programação, mas ele deve estar preparado para aprender uma nova terminologia.

## Values (Valores)

Um valor (*value*) é simplesmente um pedaço de informação dentro do programa. Por exemplo, o nome de uma tecla para ser enviada ou um programa para ser executado, o número de vezes que uma *hotkey* foi pressionada, o título de uma janela a ser ativada, ou qualquer coisa que tehna um significado dentro do programa ou script.

O AutoHotKey suporta os seguintes tipos de valores:

- STRINGS (texto)
- NUMBERS (números inteiros e ponto-flutuante)
- OBJECTS

Outros conceitos relacionados:

- BOOLEAN
- NOTHING

### Strings (Texto)

Uma string é simplesmente texto. Cada string na realidade é uma sequência
ou cadeia de caracteres, mas pode ser tratada como uma entidade individual.
O tamanho ou cumprimento (*length*) de uma string é o número de caracteres nessa sequência, enquanto a posição (*position*) de um caractere em un string é meramente o número sequencial daquele caractere. Por convenção, no AutoHotKey o primeiro caractere está na posição 1.

**Numeric strings:** Uma string de dígitos (ou seja, uma string contendo apenas 0-9) é automaticamente interpretada como um número quando uma operação matemática ou comparação é realizada com ela. No AutoHotKey v1, comparações numéricas são realizadas se ambos os valores são numéricos ainda que ambos os valores sejam strings. No entanto, uma string entre aspas (*quoted string*) nunca é considerada valor numérico quando usada diretamente em uma expressão.

Exemplo 1:

```
a := "10" ; a é uma string contendo apenas dígitos
b := "20" ; b é uma string contendo apenas dígitos
c := a + b
msgbox % c
```

No exemplo acima, os valores de a e b foram interpretados como sendo numéricos na operação da terceira linha, e o valor de c é exibido na quarta linha como sendo 30.

Exemplo 2:

```
c := "10" + "20"
msgbox % c
```

Já no exemplo 2, a tentativa de operar uma soma matemática entre os valores que estão entre aspas resultará não 30, mas 1020. Ou seja, ocorrerá uma concatenação entre as duas strings que, aqui, são consideradas como puro texto, e não números como ocorreu no exemplo anterior.

### Numbers (Números)

AutoHotkey suporta os seguintes formatos:

- Decimal integers (INTEIROS), como `123`, `00123` ou `-1`.
- Hexadecimal integers (HEXADECIMAIS), como `0x7B`, `0x007B` ou `-0x1`.
- Decimal floating-point numbers (FLOAT - ponto flutuante), como `3.14159`.

Números hexadecimais são reconhecidos pelo uso do prefixo `0x` ou `0X` (por exemplo, `0x001` ).

Números escritos com um ponto decimal são sempre considerados FLOAT, ainda que a sua parte fracional seja zero. Por exemplo, `42` e `42.0` são usualmente intercambiáveis, mas nem sempre. Notação científica também é reconhecida, mas somente se um ponto decimal estiver presente (e.g. `1.0e4` and `-2.1E-4`).

O separador decimal é sempre o ponto, ainda que as configurações de região do usuário especifique o uso da vírgula.

### Boolean (Booleano)

Um valor booleano (*boolean* value ou valor binário) pode ser ou VERDADEIRO (*true*) ou FALSO (*false*). Boolean values são usados para representar qualquer coisa que possua exatamente dois estados possíveis. Por exemplo, a verdade de uma expressão: ou uma expressão é verdadeira, ou é falsa.

Por exemplo, a expressão `(x <= y)` é *true* quando x for menor ou igual a y. Do contrário, ela é falsa.

Um valor booleano também poderia ser usado para representar outros estados binários, como ligado/desligado (*on* or *off*) , abaixo/acima (*down* or *up*), e assim por diante.

AutoHotkey não possui um tipo específico para o valor booleano, então ele usa o valor numérico `0` (inteiro zero) para representar false e `1` (inteiro um) para representar true.

As palavras `true` e `false` são variáveis internas especiais (*built-in variables*) contendo 1 e 0. Elas podem ser usadas para tornar o script mais legível.

### Nothing (Nada)

AutoHotkey não possui um valor que represente de modo especial estados como *nothing*, *null*, *nil* ou *undefined* (indefinido) a exemplo de outras linguagens. Ao invés, uma string vazia ou de tamanho zero ("") é usada para indicar tais estados.

Quando dizemos que uma variável ou parâmetro está em "branco" (*blank*) ou "vazia" (*empty*), geralmente estamos nos referindo a uma string de tamanho zero.

## Variáveis

Uma variável permite que você use um nome como um substituto para um valor. Uma variável permite que você use um nome para guardar um valor, valor que pode mudar repetidamente durante o tempo em que o seu programa é executado.

Por exemplo, uma hokey pode usar uma variável `tecla_contagem` para contar o número de vezes que ela é pressionada, e enviar uma letra diferente toda vez que `tecla_contagem` for múltiplo de três (ou seja, enviar uma letra diferente a cada três toques).

Mesmo uma variável que tenha sido assinalada um valor apenas uma vez no script pode ser útil. Por exemplo, uma variável `tituloNavegador` pode ser usada para fazer o seu código mais fácil de atualizar quando e se o seu navegador preferido mudar, ou se o título ou a classe da janela mudar devido a um uma atualização de software.

Uma variável pode ser pensada como sendo um contêiner ou uma gaveta de armário onde guardamos um valor. Por isso você geralmente encontrará na documentação do AutoHotKey referência ao valor da variável como sendo o conteúdo da variável.

Para uma variável `x := 42`, por exemplo, nós podemos dizer que a variável x possui o número 42 como valor ou podemos dizer que o valor de x é 42.

É importante notar, portanto, que a variável e o seu valor não são a mesma coisa.

### Variáveis não inicializadas

Inicializar uma variável é assinalar-lhe um valor inicial. Embora o programa inicialize automaticamente todas as variáveis (uma string vazia [""] sendo o valor padrão), é uma boa prática de programação inicializar as variáveis de um script antes dos seus usos. Dessa forma, qualquer um que ler o script pode ver as quais variáveis o script estará usando e quais os valores iniciais que se espera que elas tenham.

Usualmente é necessário em um script a inicialização de toda variável que quisermos utilizar para atribuirmos um número. Por exemplo, `x := x + 1` não funcionará se a x não houver sido atribuido qualquer valor antes dessa operação. Isso porque a variável x estará em branco, e uma string vazia (*empty string*) é considerada como não numérico. Embora haja alguns casos onde valores vazios são interpretados como sendo o número zero, é bom não confiar nisso.

Assim, no exemplo acima, o script deveria assinalar antes um valor inicial para x, como `x := 0`, antes de realizar a operação de somar 1 ao valor de x.

Você pode usar a diretiva #Warn para que o programa alerte toda vez que uma variável é utilizada pelo script sem ter sido antes inicializada.

### Built-in Variables (variáveis embutidas do AutoHotKey)

Um conjunto de variáveis úteis está embutido no

Ahk_BR
Posts: 8
Joined: 22 Jan 2023, 01:47

Re: Tutoriais Básicos de Programação em AutoHotkey!

Post by Ahk_BR » 22 Jan 2023, 08:16

# Usando o Programa

O AutoHotkey não faz nada por si só; ele precisa de um _script_ para dizer a ele o que fazer. Um *script* é simplesmente um arquivo de texto comum com a extensão `.ahk` contendo instruções para o programa, como um arquivo de configuração, porém muito mais poderoso. Um *script* pode ser bem simples, e executar uma única ação e sair, por exemplo. Mas a maioria dos *scripts* costuma conter algumas *hotkeys* (atalhos), e cada *hotkey* normalmente contém mais de uma instrução.

## Criando um Script

Os modos mais comuns de se criar um *script* AutoHotkey são:

- No Notepad, salve um arquivo com a extensão `.ahk`. Em alguns sistemas talvez seja necessário utilizar aspas (") no começo e no fim do nome do arquivo para assegurar que o editor não adicione uma outra extensão ao salvar (por exemplo, escrever "nomeDoArquivo.ahk" para assegurar que o editor não salve como nomeDoArquivo.ahk.txt).

Assegure-se de salvar seu arquivo com a codificação UTF-8 com BOM para poder utilizar caracteres UNICODE!

- No Explorer, dê um duplo click em um espaço vazio na janela/pasta que você quer salvar o *script* e selecione Novo -> AutoHotKey Script. Você pode então digitar um nome para o seu arquivo script (tomando cuidado para não apagar a extensão `.ahk` se ela estiver visível).

## Ícone da Barra de Tarefas

Por padrão, cada script adiciona seu próprio ícone na área de notificação da barra de tarefas (comumente conhecida como *tray*).

O ícone da barra de tarefa é o desenho de um "H" verde (![h](E:%5CProgramas%5CTypora%5CPICS%5Ch.PNG)) , e a cor muda para vermelho quando o script é pausado ou suspenso.

Dê um clique direito com o mouse no ícone do script para mostrar o menu contendo as seguintes opções:

- Open - Abre a janela de controle do script
- Help - Abre ajuda do AutoHotkey offline file.
- Window Spy - Utilitário para a detecção de cores, coordenadas, janelas e controles (auxilia na construção do nosso script).
- Reload This Script - Recarrega o script.
- Edit This Script - Editar o script.
- Suspend Hotkeys - Suspende/acorda as hotkeys.
- Pause Script - Pausa/continua o script.
- Exit - Sai e fecha o script.

Por padrão, duplo clique no ícone exibe a janela de controle do script (*script main window*).

## Main Window (janela de controle do script)

A janela de controle do script inicia escondida mas pode ser mostrada por meio do ícone da barra de tarefas. Sob o seu menu **View** você encontrará:

- Linhas de código recentemente executadas
- Variáveis e seus conteúdos
- Hotkeys e seus métodos
- Históricos das teclas digitadas e outras informações do script



## 1 - O Básico

Antes de começar nossa jornada, deixe-me dar algum conselho. Através deste tutorial você verá um monte de texto e um onte de código. Para uma aprendizagem ótima, é recomendado que você leia o texto e **experimente** o código. E então, estude o código. Você pode copiar e colar os exemplos, se quiser. Mas prefira sempre escrevê-los. Assim você fixará muito melhor o conteúdo. E se você se sentir confuso, tente ler mais uma vez o tópico em questão.

Aqui está um script bem básico contendo uma hotkey que escreve um texto usando o comando `Send` quando as teclas do atalho hotkey são pressionadas:

```
^j::
Send, Meu Primeiro Script
return
```

Nós aprofundaremos bem mais o entendimento do código acima. Até lá, veja a seguinte explicação:

- Primeira linha: `^j::` é a hotkey ou atalho. `^` significa Ctrl, `j` é a letra J. Tudo à esquerda do `::` são as teclas que você precisará pressionar para ativar a hotkey (no caso, `Ctrl` e `J`).
- Segunda linha: `Send, Meu Primeiro Script` é a instrução pela qual você manda (*Send*) os toques simulados do teclado (_keystrokes_). `Send` é o comando, e tudo o que está à direita da vírgula (,) será enviado pelo comando Send.
- Terceira linha: `return`. Este comando se tornará seu melhor amigo. Ele literalmente pára (*Stops*) a execução do código, impedindo-o de executar as linhas seguintes. Isto evitará muitos problemas quando você começar a ter bastante linhas de comando em seus scripts.

1. Execute o código.
2. Abra o notepad ou outro programa onde você pode escrever e pressione Ctrl + J.
3. Se tudo deu certo, você verá o computador escrever sozinho (é como se o programa simulasse alguém digitando o texto "Meu Primeiro Script" por você).



## 2 - Hotkeys & Hotstrings

O que é uma hotkey? Hotkey é uma tecla quente ao toque... Brincadeira. É uma tecla ou combinação de teclas que uma pessoa ao teclado pressiona para disparar algumas ações. Por exemplo:

```
^j::
Send, Olá mundo!
return
```

O que é uma hotstring? Hotstrings são usadas principalmente para expandir abreviações assim que você as digita (substituição automática). Por exemplo, execute o código abaixo e digite `pal` (após, pressione *Space*) em qualquer lugar que você desejar:

```
::pal::Palmeiras não tem mundial
```

A diferença entre os dois exemplos é que a hotkey será disparada quando você pressionar Ctrl + J , enquanto a hotstring converterá o texto que você escreveu ("pal") em "Palmeiras não tem mundial" assim que você pressionar o *Space*.

*"Então, como exatamente uma pessoa como eu crio uma hotkey?"* Boa pergunta. Uma hotkey é criada usando um par do sinal de dois pontos (*single pair of colons*). A tecla ou o combo de teclas precisa estar à **esquerda** do sinal `::`. Já os comandos e ações a serem disparados pelo atalho devem estar nas linhas debaixo, seguido pelo comando `return`.

```
Esc::
MsgBox, Escape!!!!
return
```

**Nota:** Existem exceções, mas elas tendem a causar confusão na maior parte das vezes. Por isso elas não serão tratadas neste tutorial, ao menos por enquanto.

Já uma hotstring tem um par do sinal de dois pontos (`::`) em cada lado do texto que você quer usar de gatilho para a ocorrência da substituição. E o texto que substituirá esse gatilho ou abreviação vai à **direita** do segundo par do sinal de dois pontos.

Hotstrings, como mencionado acima, também podem ser utilizadas pelo script para disparar ações de modo semelhante ao hotkey. Veja:

```
::pal::
MsgBox, Você digitou pal.
return
```

É bom saber que você pode ter muitas linhas de código para cada hotkey, hotstring, label (veremos mais à frente), e muitas outras coisas das quais ainda não falamos. O exemplo abaixo é apenas para ilustrar isso -- não execute, pois não faz muito sentido.

```
^j::
MsgBox, Wow!
MsgBox, Aqui jaz...
Run, notepad.exe
WinActivate, Untitled - Notepad
WinWaitActive, Untitled - Notepad
Send, 7 lines{!}{Enter}
SendInput, inside the CTRL{+}J hotkey.
return
```

### a. As Teclas e os seus símbolos misteriosos

Você deve estar pensando *"Como alguém espera que eu saiba que ^ significa Ctrl ?!"*. É uma boa questão. Para ajudar você a aprender o que `^` e outros símbolos significam, segue a tabela abaixo:

| Simbolo | Descrição |
| ------- | ------------------------------------------------------------ |
| **#** | Win (Windows logo key) |
| **!** | Alt |
| **^** | Control |
| **+** | Shift |
| **&** | Um "ampersand" pode ser usado entre duas teclas ou botões de mouse para a criação de uma hotkey do tipo combo. |

Você pode definir uma combinação de duas (e somente duas) teclas (exceto botões de joystick) usando o sinal `&` entre elas. No exemplo abaixo, você pode manter pressionada a tecla `Numpad0` e então pressionar `Numpad1` ou `Numpad2` para disparar uma das hotkeys:

```
Numpad0 & Numpad1::
MsgBox, Você pressionou Numpad1 enquanto mantinha pressionada Numpad0.
return

Numpad0 & Numpad2::
Run, notepad.exe
return
```

Mas agora você deve estar perguntando se hotstrings possuem algum modificador maneiro já que hotkeys possuem. Sim, eles possuem! Modificadores de hotstrings são colocados no meio do primeiro par de colons. Por exemplo:

```
:*:pal::Palmeiras não tem mundial
```

Experimente primeiro com e depois sem o sinal do asterisco (`*`) para ver qual a diferença.

### b. Restringindo hotkeys/hotstrings a determinada(s) janela(s)

Pode ser que você queira uma hotkey ou hotstring que funcione em apenas determinada janela. Ou, ao contrário, que ela não funcione em uma janela específica. Para fazer isso, você precisará utilizar um desses comandos estranhos com um # na frente deles:

```
#IfWinActive
#IfWinExist
```

Esses comandos especiais (tecnicamente chamados "diretivas") criam hotkeys e hotstrings sensíveis ao contexto. Veja o código abaixo:

```
#IfWinActive Sem título - Bloco de Notas
^Space::
MsgBox, Você pressionou CTRL+SPACE em um documento sem título no bloco de notas.
return
```

Nele, nós criamos uma hotkey na segunda linha, definida pelas teclas `ctrl`(^) + `space` . Ao pressionarmos essas teclas, deverá ser executada a instrução `msgbox` da terceira linha. E na quarta linha, nós temos o comando `return`, que informa ao programa que as ações do atalho chegaram ao fim. Até aqui, tudo igual aos exemplos anteriores.

A diferença é que, na primeira linha, nós informamos a seguinte diretiva: "Programa, olha só, a hotkey que eu vou criar a seguir é para funcionar apenas se eu estiver trabalhando com um bloco de notas novo, sem título ainda. Olhe para o título da janela ativa antes de acionar essa hotkey. Veja se o título da janela é *Sem título - Bloco de Notas* . Não quero bagunçar nenhum outro documento que possa estar aberto."

Para desligar a diretiva quando da criação das hotkeys e hotstrings subsequentes, especifique novamente uma *diretiva #IfWin* e deixe os seus parâmetros em branco. Exemplo, a quinta linha a seguir:

```
#IfWinActive Sem título - Bloco de Notas
!q::
MsgBox, Você pressionou ALT+Q em um documento sem título no bloco de notas.
return

#IfWinActive
!q::
MsgBox, Você pressionou ALT+Q em qualquer janela.
return
```

Quando diretivas #IfWin nunca são usadas em um script, todas as hotkeys e hotstrings são habilitadas para todas as janelas.

Além disso, tais diretivas são posicionais: elas afetam todas as hotkeys e hotstrings fisicamente abaixo delas no script. Essas e outras diretivas ainda serão abordadas neste tutorial.

### c. Múltiplos hotkeys/hotstrings por arquivo

Isso, por alguma razão, desnorteia a mente de algumas pessoas. Então vamos ser claros: o AutoHotKey possui a capacidade de executar quantas hotkeys e hotstrings *você quiser* em um único arquivo. Seja 1, ou 3253 (ou mais).

```
#i::
Run, https://www.google.com/
return

^p::
Run, notepad.exe
return

~j::
Send, ack
return

:*:acheiv::achiev
::achievment::achievement
::acquaintence::acquaintance
:*:adquir::acquir
::aquisition::acquisition
:*:agravat::aggravat
:*:allign::align
::ameria::America
```

O código acima é perfeitamente aceitável. Múltiplos hotkeys, múltiplos hotstrings. Tudo em um grande arquivo de script feliz!

### d. Exemplos

```
::pal::Palmeiras não tem mundial{!} ; Substitui "pal" por "Palmeiras não tem mundial!" assim que você pressionar space, tab ou enter.
```

```
:*:pal::Palmeiras não tem mundial{!} ; Substitui "pal" por "Palmeiras não tem mundial!" sem necessidade de se pressionar space, tab ou enter.
```

```
^n:: ; CTRL+N hotkey
Run, notepad.exe ; Abre o Bloco de Notas se CTRL+N for pressionado.
return ; Fim da hotkey. Não serão executadas linhas abaixo se houver.
```

```
^b:: ; CTRL+B hotkey
Send, ^c ; Copia o texto selecionado.
SendInput, [b]^v[/b] ; Cola o texto copiado com as tags [b] e [/b]. (b de bold-negrito)
return ; Fim da hotkey. Não serão executadas linhas abaixo se houver.
```



## 3 - Enviando Keystrokes (toques de teclado)

Então agora você decidiu que quer enviar toques de teclado para um programa qualquer. Você pode. Use o comando `Send`. Este comando literalmente envia sinais de toques de teclado simulando alguém escrevendo ou pressionando teclas.

Mas antes que avancemos nisso, devemos falar um pouco sobre alguns problemas comuns que as pessoas tem.

Assim como as hotkeys, o comando `Send` possui teclas especiais também. Muitas, aliás. Aqui estão os quatro símbolos mais comuns:

| Symbol | Description |
| ------ | ------------------------------------------------------------ |
| ! | Envia o pressionamento da tecla ALT. Por exemplo, `Send, isso é um text!o` enviaria as teclas "isso é um text" e então pressionaria ALT+O. **Nota**: `!O` produz um efeito diferente de `!o` em alguns programas. Isso porque `!O` pressiona Alt+Shift+O e `!o` pressiona Alt+O. Na dúvida, use a forma minúscula. |
| + | Envia o pressionamento da tecla SHIFT. Por exemplo, `Send, +abC` enviaria o texto "AbC", e `Send, !+a` enviaria o pressionamento das teclas Alt+Shift+A. |
| ^ | Envia o pressionamento da tecla CONTROL (Ctrl). Por exemplo, `Send, ^!a` enviaria o pressionamento das teclas Ctrl+Alt+A, e `Send, ^{Home}` enviaria Ctrl+Home. **Nota**: `^A` produz um efeito diferente em alguns programas em comparação a `^a`. Isso porque `^A` envia o pressionamento de Ctrl+Shift+A e `^a` envia Ctrl+A. Na dúvida, prefira usar a forma minúscula (caixa baixa). |
| # | Envia a tecla WIN (a tecla com a logo do Windows). Portanto, `Send #e` enviaria o pressionamento da tecla Win e então o pressionamento da tecla "e". |

Para enviar de modo literal os caracteres especiais acima, é preciso circundá-los com o sinal `{}`(*curly brackets*). Ao ver `{!}` o programa entende que se trata de "ponto de exclamação" e não "pressione a tecla ALT". Veja:

```
Send, isso é um text{!}o ; envia "isso é um text!o", literalmente.
```

Erro comum é pensar que todo caractere precisa ser circundado por brackets (`{}`) ao se usar o comando `Send`. Isto é FALSO. Você não deve circundar com brackets as letras comuns, os números ou mesmo alguns símbolos como o ponto (`.`) . Ainda, com os comandos `Sends` você pode mandar mais de uma letra, número ou símbolo de uma só vez. Não há, portanto, necessidade de mandar um monte de comandos `Send` enviando uma letra cada. Por exemplo:

```
Send, {a} ; ERRADO
Send, {b} ; ERRADO
Send, {c} ; ERRADO
Send, {a}{b}{c} ; ERRADO
Send, {abc} ; ERRADO
Send, abc ; CORRETO
```

Para manter pressionada ou soltar uma tecla, circunde o nome da tecla com *curly brackets* (`{}`) e então use a palavra UP ou DOWN. Por exemple:

```
Send, ^s ; Envia CTRL+S
Send, {Ctrl down}s{Ctrl up} ; Também envia CTRL+S, de outro modo
Send, {Ctrl down}c{Ctrl up} ; Envia CTRL+C
Send, {b down}{b up} ; Envia o pressionamento da tecla "b" e depois solta
Send, {Tab down}{Tab up} ; Envia o pressionamento da tecla TAB e depois solta
Send, {Up down} ; Envia o pressionamento da tecla UP (seta para cima).
Send, {Up up} ; Solta o pressionamento da tecla UP (se a tecla UP não estiver pressionada o comando não produz efeito).
```

Mas agora você está pensando *"Como eu posso tornar legíveis os meus comandos `Send` gigantes?"*. Fácil. Use o que denominamos `continuation section`. Simplesmente abra um parênteses em uma nova linha, então coloque seu conteúdo, e finalmente feche o parênteses.

```
Send,
(
Linha de texto 1
Linha de texto 2
Maças são frutas.
)
```

**Nota:** O comando `Send`possui diferentes formas. Cada uma possui características especiais próprias. Se uma forma de `Send` não atender suas necessidades, tente outra forma de `Send`. Simplesmente substitua o nome do comando `Send` por algum dos seguintes: `SendRaw` , `SendInput`, `SendPlay` e `SendEvent`.

### a. Games

**Importante:** muitos jogos, especialmente os modernos, possuem programa ou mecanismo para a detecção de trapaças. Coisas como GameGuard, Hackshield, PunkBuster and muitos outros. Enganar tais sistemas, além de ser uma violação à política das produtoras dos games e poder dar causa a um banimento do usuário, é algo complexo de se alcançar.

Se um jogo tiver sistema de prevenção a trapaça e seus hotkeys, hotstrings e comandos `Send` não funcionarem, você está sem sorte. Embora existam métodos que podem aumentar a chance de fazer funcionar em alguns jogos, não existe comando mágico. Então, tente **TUDO** antes de desistir.



## 4 - Executando Programas & Websites

Para abrir um programa como *mspaint.exe, calc.exe, script.ahk* ou mesmo uma pasta de arquivos, você pode usar o comando `Run`. Ele pode inclusive ser usado para abrir URLs como www.autohotkey.com. Se o seu computador estiver configurado para abrir o tipo de programa que você quer abrir, é simples:

```
; Abre um programa. Note que a maioria dos programas requer a informação do caminho completo para o executável a ser aberto:
Run, %A_ProgramFiles%\Some_Program\Program.exe

; Abre um site a partir do navegador padrão conforme configuração do sistema:
Run, https://www.autohotkey.com
```

Mais exemplos:

```
; Muitos programas não exigem a informação do caminho completo, como os programas pré-instalados do Windows:
Run, notepad.exe
Run, mspaint.exe

; Abre a pasta "Meus Documentos" usando a variável especial A_MyDocuments:
Run, %A_MyDocuments%

; Abre sites:
Run, https://www.autohotkey.com
Run, https://www.google.com
```



## 5 - Commands vs. Functions()

O AutoHotKey possui dois tipos principais de coisas usadas pelo programador para criar código: comandos e funções.

### Comandos

Você pode dizer o que é um comando olhando para a sua sintaxe (para a sua aparência). Comandos não usam parênteses em volta dos parâmetros como as funções fazem.

Um comando se pareceria com isso:

```
Comando, Parâmetro1, Parâmetro2, Parâmetro3
```

Ao usar comandos, você não pode encavalar outros comandos na mesma linha do comando anterior. Você não pode colocar comandos dentro dos parâmetros de outros comandos. Por exemplo:

```
MsgBox, Olá Run, notepad.exe ; ERRADO
MsgBox, Olá, Run, notepad.exe ; ERRADO

MsgBox, Olá ; CORRETO
Run, notepad.exe ; CORRETO
```

Comandos também diferem da função já que por padrão eles utilizam de uma sintaxe antiga (*legacy syntax*). Isso significa que você **precisa** utilizar o sinal de percentagem em volta de uma variável, a exemplo de `%Var%`. Por outro lado, texto e números não precisam ser delimitados com a utilização das aspas, a exemplo de `msgbox,,, Este é um texto qualquer`. Adicionalmente, você não pode fazer cálculos matemáticos dentro dos campos dos parâmetros dos comandos, diferentemente das funções.

Na realidade você pode fazer isso ao "forçar o uso de expressões" com o uso do sinal de percentual (`%`) como primeiro caractere no campo de um parâmetro. Por exemplo:

```
MsgBox, % "Este texto é o de número " 3+4 ; exibe Este texto é o de número 7
```

Note que, com isso, a coisa se inverte: o texto agora necessita ser circundado por aspas, e as variáveis agora não necessitam ser circundadas pelo sinal de percentagem. Este assunto é complexo e fonte de muita confusão, e será melhor aprofundado em outro momento.

### Funções

Como dito acima, funções são diferentes porque elas usam parênteses. Uma função típica se parece com isso:

```
Função(Parâmetro1, Parâmetro2, Parâmetro3)
```

Além disso,

1. Você pode fazer matemática dentro delas:

```
SubStr(37 * 12, 1, 2)
SubStr(A_Hour - 12, 2)
```

2. Variáveis não precisam ser circundadas por sinal de percentagem:

```
SubStr(A_Now, 7, 2)
```

3. Funções podem ser inseridas dentro de outras funções:

```
SubStr(A_Now, InStr(A_Now, "2021"))
```

4. Dentro das funções, os textos precisam ser delimitados com o uso de aspas:

```
SubStr("Eu estou codificando, isso é incrível!", 16)
```

Uma função usualmente retorna um valor diferente do que um comando retorna. Os comandos precisam de um parâmetro no qual definimos a variável que irá guardar o resultado, o valor de saída do comando (se houver). Essa é a famosa *OutputVar*, variável que na realidade pode ter qualquer nome...

Por exemplo,

`InputBox, OutputVar,, Digite seu nome:` é equivalente a

`InputBox, MinhaVariavel, , Digite seu nome: `

A diferença é que no primeiro caso seu nome ficará guardado na variável *OutputVar* e no segundo caso seu nome ficará guardado na variável *MinhaVariavel*.

A função, em comparação ao comando, é mais complexa quanto à forma de jogar para o script os resultados das suas operações. Ela conta com mais de um método para isso, e o mais comum é atribuir o resultado de uma função à uma variável de saída da seguinte maneira:

```
MinhaVar := SubStr("Eu estou codificando, incrível!", 16)
```

Esta não é a única maneira, mas é a mais comum. VocE está usando `MinhaVar` para guardar o valor de retorno da função que está à direita do operador `:= `.

Em resumo:

```
; Estes são comandos:
MsgBox, Isto é um texto qualquer.
StringReplace, Output, Input, AutoHotkey, AutoHotKey, All
SendInput, Isto é incrível{!}{!}{!}

; Estas são funções:
SubStr("Eu estou criptografando, incrível!", 16)
FileExist(VariavelContendoCaminho)
Output := SubStr("Eu estou descriptografando, incrível!", 16)
```

### a. Code blocks

Code blocks (blocos de código) são linhas de código delimitadas ou circundadas pelos *curly brackets* (`{` e `}`). Eles agrupam uma seção de código junto de modo que o AutoHotKey saiba que se trata de uma única grande família e que ela precisa ficar unida. Eles são mais usados com funções e com instruções de fluxo de controle (*control flow statements*) como `IF` e `LOOP`. **Sem eles, apenas a primeira linha do bloco seria chamada**.

No código seguinte, ambas as linhas serão executadas apenas se *MyVar* for igual a 5:

```
if (MyVar = 5)
{
MsgBox, MyVar é igual a %MyVar%!!
ExitApp
}
```

No código seguinte, a mensagem só é exibida se *MyVar* for igual a 5. No entanto, o script terminará sempre, mesmo que *MyVar* seja **diferente** que 5:

```
if (MyVar = 5)
MsgBox, MyVar é igual a %MyVar%!!
ExitApp
```

Isso está perfeitamente correto já que a instrução `IF` acima conta apenas com uma linha de código associada a ela. Abaixo, um código exatamente como o de cima, porém com uma puxada de indentação da terceira linha para que saibamos que ela está separada da instrução `IF`:

```
if (MyVar = 5)
MsgBox, MyVar é igual a %MyVar%!!
MsgBox, Nós já estamos fora da instrução IF agora.
```



## 6 - Variáveis

Variáveis são como pequenos *post-its* que guardam alguma informação. Elas podem ser usadas para guardarem texto, números, valores vindos das funções/comandos ou mesmo quardar equações matemáticas inteiras. Sem elas, programar e codificar seria muito mais entediante.

Variáveis podem ser declaradas (*assigned*) de algumas maneiras. Nós cobriremos as formas mais comuns. **MUITA ATENÇÃO É REQUERIDA NO USO DO SINAL IGUAL (`=`)**.

- *Legacy text assignment*

`MyVar = Texto`

Esta é a forma mais simples. Apenas digite seu texto e está feito.

- *Legacy variable assignment*

`MyVar = %MyVar2%`

Igual à forma anterior, mas você está atribuindo o valor de uma variável para uma outra variável.

- *Legacy mixed assignment*

`MyVar = %MyVar2% algum texto %MyVar3%.`

Uma combinação dos dois modos legados anteriores (*legacy assignments*).



- *Expression text assignment*

`MyVar := "Texto"`

Esta é uma **expression assignment**, devido ao `:` antes do `=`. Todo texto precisa ser delimitado por aspas.

- *Expression variable assignment*

`MyVar := MyVar2`

No modo *expressão*, variáveis não precisam do sinal de percentagem.

- *Expression number assignment*

`MyVar := 6 + 8 / 3 * 2 - Sqrt(9)`

Graças às *expressões*, podemos fazer matemática!

- *Expression mixed assignment*

`MyVar := "O valor de 5 + " MyVar2 " é igual a: " 5 + MyVar2`

Uma combinação das três *expression assignments* acima.

Sinal de igual (**=**) com um símbolo em frente como `:=` `+=` `-=` `.=` etc. são chamados **assignment operators** e sempre requerem uma *expressão* (*expression*).

### a. Quando usar o sinal de pertentual

Uma das dificuldades mais comuns com o AutoHotKey envolvendo variáveis é quando usar o sinal de percentual (%). Esperamos que isso ajude a clarear a confusão.

Quando usar sinal de percentagem:

- Quando você está usando comandos (veja acima), **exceto quando o parâmetro é *OutputVar* ou *InputVar***.
- Quando você está atribuindo um valor a uma variável usando o modo legado (um sinal de igual com nunhum símbolo em frente dele).

Quando **NÃO** usar sinal de percentagem:

- Em parâmetros que são variáveis *InputVar* e *OutpuVar*. Por exemplo: `StringLen, **OutputVar**, **InputVar**`

- No lado esquerdo de uma assinalação: `**Var** = 123abc`

- No lado esquerdo de uma instrução `IF` no modo legado (sem uso de parênteses): `if **Var1** < %Var2%`

- Qualquer lugar em expressões. Por exemplo:

```
if (Var1 != Var2)
Var1 := Var2 + 100
```

### b. Obtendo entrada do usuário

As vezes voce quer que o usuario escolha o valor das coisas. Há muitas maneiras de fazer isso, mas a maneira mais simples é o `INPUTBOX`. Aqui um simples exemplo de como perguntar ao usuario algumas questoes e fazer alguma coisa com o que foi informado:

```
InputBox, OutputVar, Questão 1, Qual é o seu primeiro nome?
if (OutputVar = "Bill")
MsgBox, Este é um nome incrível`, %OutputVar%.

InputBox, OutputVar2, Questão 2, Voce curte o AutoHotkey?
if (OutputVar2 = "sim")
MsgBox, Obrigado por responder %OutputVar2%`, %OutputVar%! Nós nos tornaremos grandes amigos.
else
MsgBox, %OutputVar%`, Oh. Isso me deixa triste.
```

### c. Outros Exemplos?

```
MsgBox, 4,, Voce gostaria de continuar?
IfMsgBox, No
return ; Se "Não", pára o código de prosseguir.
MsgBox, Voce pressionou SIM. ; Caso contrário, o usuário pressionou "Sim".
```



## 7 - Objetos

Objetos são um modo de organizar seus dados para um uso mais eficiente desses dados. Algumas vezes objetos sao referidos como *arrays*, mas é importante notar que toda *array* é um objeto. Nos chamamos diferente coisas de objetos dependendo do uso que estamos fazendo deles, mas todos os objetos são iguais.

Um objeto é basicamente uma colecao de variaveis. O nome das variaveis sao conhecidos por "Keys", e o conteudo das variaveis sao "Values".

Quando voce ouvir alguem chamando de objeto uma *array* ou uma *indexed array*, isso geralmente significa que todas as *keys* sao sequenciais de 1 para frente. Quando vocde ouvir alguem chamando de objeto uma *associative array*, isto significa que as *keys* sao ou strings (texto) ou numeros nao-sequenciais. Algumas vezes é um misto de ambos, e numeros sequenciais também!

**AVANCE PARA O ITEM c. TENTATIVA E ERRO**



There are no restrictions to what a key or value can be, and they can even be other arrays! When the values are arrays too, this is referred to as a *nested array*, and these will be explained later.

There are a number of reasons you might want to use an object for something. Some examples:

- You want to have a numbered list of things, such as a grocery list (this would be referred to as an indexed array)
- You want to represent a grid, perhaps for a board game (this would be done with nested objects)
- You have a list of things where each thing has a name, such as the characteristics of a fruit (this would be referred to as an associative array)

### a. Creating Objects

There are a few ways to create an object, and the most common ones are listed below:

- Bracket syntax

`MyObject := ["one", "two", "three", 17]S↓`This will start you off with what is sometimes called an "indexed array". An indexed array is an object representing a list of items, numbered 1 and up. In this example, the value `"one"` is stored in object key `1` (aka index 1), and the value `17` is stored in object key `4` (aka index 4).

- Brace syntax

`Banana := {"Color": "Yellow", "Taste": "Delicious", "Price": 3}S↓`This will let you start of by defining what is sometimes called an "associative array". An associative array is a collection of data where each item has a name. In this example, the value `"Yellow"` is stored in the object key `"Color"`. Also, the value `3` is stored in the object key `"Price"`.

- Array function

`MyObject := Array("one", "two", "three", 17)S↓`This is equivalent to the bracket syntax, but wrapped in a function.

- Object function

`Banana := Object("Color", "Yellow", "Taste", "Delicious", "Price", 3)S↓`This is equivalent to the brace syntax, but wrapped in a function.

It's important to remember that every one of these definitions all create the same thing (objects), just with different keys.

### b. Using Objects

There are many ways to use objects, including retrieving values, setting values, adding more values, and more.

#### To set values:

- Bracket notation

`Banana["Pickled"] := True *; This banana has been pickled. Eww.*S↓`Setting values in an object is as simple as setting the value of a variable. All you have to do is put your bracket notation on the left side of an expression assignment operator `:=`.

- Dot notation

`Banana.Consistency := "Mushy"S↓`The same as above but with the dot notation.

#### To retrieve values:

- Bracket notation

`Value := Banana["Color"]S↓`This allows you to use an expression as the key to get the value from your object. In this case, I used the simple expression `"Color"`, which is (unsurprisingly) the key `Color`. You will get a message box with the word "Yellow", because that is what we set the key `Color` to in the [previous section](mk:@MSITStore:E:\Programas\AutoHotKey\AutoHotkey.chm::/docs/Tutorial.htm#s71).

- Dot notation

`Value := Banana.ColorS↓`This only lets you use literal strings for the keys. You cannot use variables in your keys with dot notation.

#### To add new keys and values:

- Bracket notation

`MyObject["NewerKey"] := 3.1415S↓`To directly add a key and value, just set a key that doesn't exist yet.

- Dot notation

`MyObject.NewKey := "Shiny"S↓`The same as above but with the dot notation.

- InsertAt method

`MyObject.InsertAt(Index, Value1, Value2, Value3...)S↓`*Index* is any integer key. This will shift ALL higher integer keys up by the number of values which were inserted, even if there are gaps (for example, only keys 1 and 100 exist, and you insert a value at key 50, it will shift 100 up to 101).

- Push method

`MyObject.Push(Value1, Value2, Value3...)S↓`This "appends" the values to the end of the array *MyObject*. In other words, it inserts the values at the highest integer key plus one.

#### To remove keys and values:

- Blanking the value out

`Banana.Consistency := ""S↓`The simplest way to remove a value is to just blank it out. You can do this by setting it to `""`, also known as an *empty string*. This doesn't remove the key, but it will make the value appear identical to an unset value. It is possible to tell that the key still exists by using the [HasKey](mk:@MSITStore:E:\Programas\AutoHotKey\AutoHotkey.chm::/docs/objects/Object.htm#HasKey) method, and it will still come up in a [For](mk:@MSITStore:E:\Programas\AutoHotKey\AutoHotkey.chm::/docs/commands/For.htm) loop.

- Delete method

`RemovedValue := MyObject.Delete(AnyKey)S↓`This and the next methods below remove the key *and* the value. The previous value of `MyObject[AnyKey]` will be stored in *RemovedValue*.`NumberOfRemovedKeys := MyObject.Delete(FirstKey, LastKey)S↓`Allows you to remove a range of numbered/integer or string keys between *FirstKey* and *LastKey*. The value it gives will be the number of keys that were removed, which is useful if you have a gap between your keys (e.g. you specify keys 1 through four, but key number 2 doesn't exist, this will set *NumberOfRemovedKeys* to 3 as only three keys were there to be removed).

- Pop method

`MyObject.Pop()S↓`This removes the highest integer key, and returns the value. There are no keys higher than it to be affected.

- RemoveAt method

`RemovedValue := MyObject.RemoveAt(Index)S↓``NumberOfRemovedKeys := MyObject.RemoveAt(Index, Length)S↓`This removes all keys from *Index* to *Index + Length - 1* (inclusive). If *Length* is omitted it defaults to 1. After removing the keys it takes all higher numbered/integer keys and moves them down to fill the gap, so that if there was a value at *Index + Length* it will now be at *Index*. This is similar to how the InsertAt method with multiple specified values works.

## 8 - Other Helpful Goodies

We have reached the end of our journey, my good friend. I hope you have learned something. But before we go, here are some other things that I think you should know. Enjoy!

### a. The mysterious square brackets

Throughout the documentation, you will see these two symbols (`[` and `]`) surrounding code in the yellow syntax box at the top of almost all pages. Anything inside of these brackets are ***OPTIONAL\***. Meaning the stuff inside can be left out if you don't need them. When writing your code, it is very important to **NOT** type the square brackets in your code.

On the [ControlGetText](mk:@MSITStore:E:\Programas\AutoHotKey\AutoHotkey.chm::/docs/commands/ControlGetText.htm) page you will see this:

```
ControlGetText, OutputVar , Control, WinTitle, WinText, ExcludeTitle, ExcludeText
```

S

So you could simply do this if you wanted:

```
ControlGetText, OutputVar
```

S↓

Or add in some more details:

```
ControlGetText, OutputVar, Control, WinTitle
```

S↓

What if you wanted to use *ExcludeTitle* but not fill in *WinText* or *WinTitle*? Simple!

```
ControlGetText, OutputVar, Control,,, ExcludeTitle
```

S↓

Please note that you cannot IGNORE parameters, but you can leave them blank. If you were to ignore `WinTitle, WinText`, it would look like this and cause issues:

```
ControlGetText, OutputVar, Control, ExcludeTitle
```

S↓

### b. Finding your AHK version

Run this code to see your AHK version:

```
MsgBox, %A_AhkVersion%
```

S↓

Or look for "AutoHotkey Help File" or "AutoHotkey.chm" in the start menu or your installation directory.







### c. Tentativa e Erro

Tentativa e Erro é um meio muito comum e efetivo de aprender. Ao invés de pedir por ajuda em cada pequena coisa, às vezes gastar algum tempo sozinho (as vezes algumas horas por dia) e tentar conseguir alguma coisa para trabalhar irá ajudar você a aprender mais rápido. Se você tentar algo e isto deve resultar em erro, estude aquele erro. Então tente consertar seu código. Então tente novamente se você ainda tiver um erro. Modifique o seu código ainda mais. Continue tentando e falhando até que o seu código não falhe mais. Você aprenderá um monte por este caminho, lendo a documentação, lendo os erros, e aprendendo o que funciona e o que não funciona.

> Tente, falhe, tente, falhe, tente, tente, tente, falhe, falhe, falhe, CONSEGUIU!
> *Hickson, William E.*



### d. Indentação

Essa coisa (indentação) é muito importante! Seu código irá rodar perfeitamente bem sem ela, mas será uma grande dor de cabeça para você e para os outros ler o seu código. Códigos pequenos, de vinte e cinco linhas ou menos, provavelmente não terá problemas de leitura sem a indentação, mas logo logo ficará difícil. É melhor você aprender a fazer a indentação o quanto antes.

A indentação não influencia no resultado do programa, mas é melhor aprender para manter tudo consistente.

O que é indentação?, você pergunta. É simplesmente usar o espaçamento ou recuo inicial dos parágrafos/linhas para organizar seu código de modo que você possa ver o que pertence a quê. As pessoas usualmente usam três ou quatro espaços ou um TAB por nível.

Não "indentado":

```
if (carro = "velho")
{
MsgBox, O carro é realmente velho.
if (pneus = "careca")
{
MsgBox, Este carro não é seguro para dirigir.
return
}
else
{
MsgBox, Cuidado! Este carro velho é perigoso de dirigir.
}
}
else
{
MsgBox, Cara`, que carrão voce tem.
}
```

"Indentado":

```
if (carro = "velho")
{
MsgBox, O carro é realmente velho.
if (pneus = "careca")
{
MsgBox, Este carro não é seguro para dirigir.
return
}
else
{
MsgBox, Cuidado! Este carro velho é perigoso de dirigir.
}
}
else
{
MsgBox, Cara`, que carrão voce tem.
}
```



See Wikipedia's [Indentation style](https://en.wikipedia.org/wiki/Indentation_style) page for various styles and examples. Choose what you like or learn to indent how you think it's easiest to read.

### e. Asking for Help

Before you ask, try doing some research yourself or try to code it yourself. If that did not yield results that satisfy you, read below.

- Don't be afraid to ask for help, even the smartest people ask others for help.
- Don't be afraid to show what you tried, even if you think it's silly.
- Post anything you have tried.
- Pretend *everyone but you* is a doorknob and knows nothing. Give as much information as you can to educate us doorknobs at what you are trying to do. Help us help you.
- Be patient.
- Be polite.
- Be open.
- Be kind.
- Enjoy!

If you don't get an answer right away, wait at least 1 day (24 hours) before asking for more help. We love to help, but we also do this for free on our own time. We might be at work, sleeping, gaming, with family or just too busy to help.

And while you wait for help, you can try learning and doing it yourself. It's a good feeling, making something yourself without help.
Attachments

[The extension pdf has been deactivated and can no longer be displayed.]


Post Reply

Return to “Tutoriais”