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

Dicas e conselhos úteis com o AutoHotkey para os seus queridos companheiros
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

03 Apr 2018, 12:47

Seja bem-vindo :angel:

Este tópico tem o objetivo de apresentar uma série de tutoriais em português para os que querem aprender a programar o seu computador. O AutoHotkey é uma excelente ferramenta para aprendizagem de programação que permite que você, em pouco tempo, já esteja escrevendo seus programas e automatizando as tarefas do seu computador. Por esta razão, ele atende aos mais diversos tipos de usuários, podendo ser utilizado para fazer desde pequenas ações no computador até programas inteiros com dezenas de telas e conexão via banco de dados ou via web.

Apesar de já termos uma tradução dos tutoriais oficiais neste fórum, acredito que eles se apresentam de uma forma um tanto quanto resumida, e são mais indicados para quem quer iniciar de uma forma rápida o uso da ferramenta, sem se aprofundar nos conceitos. E como o assunto programação é bastante extenso, decidi escrever esta série com o objetivo de auxiliar quem está começando agora de uma forma mais aprofundada, para que fique mais fácil e mais rico este início na programação.

Portanto, se você já leu os tutoriais oficiais ou quer simplesmente se aprofundar ainda mais nos conceitos encontrados, sinta-se livre para ler estes tutoriais e solidificar seu aprendizado. Recomendo que leia os tutoriais do primeiro ao último, pois os conceitos aprendidos em um tutorial servirão aos tutoriais seguintes.

Um forte abraço.

Tutoriais desta Série

I . Básico de Scripts, Programação e Automação
:arrow: Neste primeiro tutorial você vai aprender o que é um script, bem como a forma básica de como este se organiza e como pode ser criado e editado por você. Além disso, será apresentado aos conceitos de programação e automação, que serão explicados através de analogias e outras ferramentas de linguagem que permitem um melhor entendimento.

II . Básico de Variáveis, Expressões e Comandos em AutoHotkey
:arrow: Neste segundo tutorial, você verá o que são variáveis, bem como as questões referentes aos diferentes tipos de dados e ainda iniciaremos um estudo dos comandos, que são uma das principais ferramentas que usamos para resolver os problemas através de programação no AutoHotkey.

III. Desenvolvimento de um Programa Funcional Básico em AutoHotkey
:arrow: No terceiro tutorial desta série, aproveitamos para consolidar nosso aprendizado com um exemplo prático de projeto em AutoHotkey. Para isso nós vamos projetar e escrever um programa gerador de relatórios, que servirá para o nosso usuário criar relatórios personalizados, com título escolhido por ele e data equivalente a data em que foram criados. Este tutorial cobrirá tudo isso passo a passo, de modo que fique mais fácil entender como funciona o desenvolvimento de sistemas, desde o planejamento até a execução. Também aproveitamos para introduzir algumas novas ferramentas que o AutoHotkey possui para auxiliar seus desenvolvedores na criação dos seus scripts, como as variáveis embutidas e outros comandos.

IV. Básico de Condicionais de Execução e Blocos de Códigos
:arrow: No quarto tutorial desta série, vamos falar sobre as Condicionais de Execução, que permitem que apenas uma parte do código do script seja executada se uma ou mais condições impostas por nós venha a ocorrer. Faremos isto apresentando o exemplo de um programa que pede uma senha e depois verifica se essa senha corresponde a uma que ele tinha guardada em seu código. Se o usuário acertar a senha, o programa exibe uma caixa de texto, mas se ele errar, nada será exibido. As condicionais de execução são fundamentais para implementarmos programas complexos, que precisam interagir com o usuário de várias formas e agir de formas diferentes em cada caso.

V. Básico de Funções e Labels
:arrow: O quinto tutorial de nossa série será destinado ao aprendizado de funções e labels (rótulos). Estas funcionalidades permitem que possamos criar códigos mais complexos de forma fácil e organizada, assim como programar ações separadas no script e também permitem que possamos usar facilmente códigos escritos por outras pessoas em nossos scripts. Praticamente todos os scripts maiores, com telas e controles, utilizam funções e/ou labels, então vale muito a pena conferir este assunto.

VI. Básico de Telas em AutoHotkey
:arrow: Neste sexto tutorial de nossa série, vamos aprender a criar telas (também chamadas de janelas) para os nosso programas em AutoHotkey. Aqui, você encontrará uma explicação do que são as telas, para que servem, como elas são feitas e ainda um exemplo passo a passo de criação de uma tela totalmente funcional em AutoHotkey, que implementa uma agenda de contatos. Se você deseja criar programas profissionais em AutoHotkey, vale muito a pena conferir este tutorial (mas somente após os outros!).

VII. Básico de Arquivos
:arrow: No sétimo tutorial desta série, veremos o que são os arquivos de computador. É comum hoje em dia que trabalhemos com computadores praticamente a vida toda sem nunca saber de verdade o que são esses arquivos. Como programadores, convém conhecer um pouco mais a fundo os arquivos de computador, de modo que possamos trabalhar com eles de forma avançada, coletando informações deles ou até mesmo elaborando nossos próprios arquivos. Se você está seguindo esta série e deseja conhecer mais sobre os arquivos de computador, não perca este tutorial!

Mais tutoriais em breve!
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

Re: Básico de variáveis, expressões e comandos em AutoHotkey

03 Apr 2018, 16:31

I. Tutorial Básico de Scripts, Programação e Automação

Olá :angel:

Este tutorial é o primeiro de uma série que tem por objetivo ensinar aos iniciantes do AutoHotkey como escrever seus próprios programas. O assunto aqui tratado será bem básico e teórico, portanto, se você já consegue escrever algum script qualquer, este tutorial servirá apenas para consolidar conceitos e tirar dúvidas. Do contrário, se você nunca escreveu nenhum script, este tutorial pode ser a melhor maneira para você iniciar neste novo mundo chamado programação.

Vamos lá? :thumbup:

1. Script: o que é isso?

Script.png
Script.png (4.22 KiB) Viewed 281 times


A grosso modo, um script é um arquivo de texto com comandos escritos linha a linha que permitem a um programador (você) dizer a um programa (o AutoHotkey) o que você quer que ele faça. Se você já tiver o AutoHotkey instalado em seu computador, criar um script é tão fácil quanto clicar com o botão direito do mouse na área de trabalho do Windows e selecionar Novo -> AutoHotkey Script. Você verá que um arquivo será adicionado à sua área de trabalho com um ícone de letra H. Depois, para abrir o arquivo em um editor de texto e começar a escrever nele, basta clicar encima dele com o botão direito do mouse e selecionar "Edit script". Além disso, quando o seu arquivo já contiver comandos escritos na linguagem do AutoHotkey, basta clicar duas vezes encima dele para que o AutoHotkey execute todos os comandos que você programou nele.

Uma segunda forma de criar um script é abrir o Bloco de Notas do Windows e salvar o arquivo com uma extensão .ahk. Para fazer isso, basta você clicar em Arquivo -> Salvar Como, selecionar o Tipo: Todos os Arquivos e colocar um nome qualquer seguido de .ahk no seu arquivo. Depois é só clicar em Salvar que o seu script será criado na posta onde salvou o arquivo.

Para facilitar ainda mais o entendimento, podemos pensar no script de programação através da analogia com o script de uma peça de teatro: o script diz o que será feito por cada ator e atriz, incluindo suas falas, organizadamente e de forma sequencial, de modo que a peça seja executada por toda a equipe em uma sincronia e planejamento previamente definidos pelo autor que escreveu a peça.

:arrow: Não se preocupe em decorar tudo o que está sendo dito neste tutorial. Efetua a leitura da leitura, mas dê mais ênfase apenas ao que for prático: Conforme o seu entendimento cresce, você pode rever os tópicos anteriores e as palavras aqui escritas ganharão novo significado :thumbup:

2. O Script: Como se escreve?

A forma de escrever o script é obedecendo a sua linguagem de programação. Uma linguagem de programação nada mais é do que um conjunto de normas de escrita e organização que permite que haja uma comunicação efetiva entre o programador e o software interpretador dos comandos (o AutoHotkey no nosso caso). A linguagem de programação é conhecida pelo software interpretador e deve ser aprendida pelo programador para que este possa escrever os comandos e entender o que vai acontecer.

Parece difícil? :crazy:

Não se preocupe, você não deve ter nenhum receio de aprender uma linagem de programação: essas linguagens são projetadas para serem extremamente simples e de fácil aprendizado. Além disso, seu aprendizado é gradual, o que significa que você já consegue fazer uso da linguagem desde o primeiro dia do aprendizado (é muito mais fácil aprender uma linguagem de programação do que aprender inglês ou qualquer outra língua falada :lol: )

:arrow: Se você seguir os tutoriais desta série, logo vai estar escrevendo seus primeiros scripts, lembrando que a maioria dos exemplos apresentados contém códigos que podem ser executados copiando e colando no seu script.

3. O Script: A importante sequência de execução dos comandos

O principal conceito aplicado à criação de um script é o conceito de ordem (ou tempo) de execução dos comandos. Podemos dizer a grosso modo que em um script com vários comandos escritos linha a linha, há sempre uma ordem de execução definida pela posição da linha, pois a linha de cima é geralmente executada antes da linha de baixo. Isto permite que possamos encadenar vários comandos, de modo que o programa os execute passo a passo, seguindo uma lógica definida pelo programador.

Assim, quando abrimos um script de AutoHotkey, a primeira linha do mesmo será onde vamos escrever o primeiro comando a ser executado. Da mesma forma, na segunda linha do script, colocaremos o segundo comando, que só será executado após o primeiro comando. Isto é o que permite, por exemplo, que solicitemos um número ao usuário do programa e depois apresentemos a ele o resultado de multiplicar aquele número por 10. Na primeira linha, escrevemos o comando que solicita o número. Na segunda, colocamos o comando que multiplica o número. E na terceira, finalmente, vai o comando que apresenta o resultado a ele.

Essa ordem é bem simples e racional, e é também necessária: Se tentarmos escrever a apresentação do resultado na primeira ou na segunda linha, o programa não terá o resultado ainda, pois ainda não se executou o comando da multiplicação do valor.

Tendo dito isto, vamos dar uma pausa da teoria. Que tal um pouco de prática agora? :thumbup:

4. O primeiro script

Preste atenção no código que apresentarei abaixo. Em um primeiro momento, você ainda não saberá o que ele faz, mas usando o que dissemos nos itens 1 e 2, você pode criar um novo script do AutoHotkey, editar ele, e depois colar este pedaço de código na janela de editor de texto que se abre, substituindo tudo o que estiver lá. Depois é só salvar e clicar duas vezes no script para executá-lo.

Code: [Select all] [Download] GeSHi © Codebox Plus

msgbox olá mundo!
msgbox este é o meu primeiro script de AutoHotkey
msgbox e com ele eu aprenderei o básico de programação


Conseguiu executar o código? Se você fez da forma correta, devem ter sido exibidas três caixa de texto, sendo que a primeira continha a mensagem "olá mundo!" e a segunda e terceira continham as mensagens das outras linhas. Você observou que estas linhas contém um comando cada uma e esses comandos foram executados na mesma ordem das linhas, da primeira até a terceira?

Veja também que cada linha na verdade é um comando chamado msgbox. Este comando é o comando que exibe uma caixa de texto no AutoHotkey. O que define que ele foi chamado (e não um outro comando qualquer) é o seu nome escrito no início da linha. Da mesma forma, após o nome do comando, temos três frases diferentes, uma em cada linha. Estas frases são exatamente o quê será exibido em cada caixa de texto, e você pode alterá-las e salvar o script para mudar as mensagens exibidas quando abrir o script de novo (mas mantenha o nome msgbox no inicio de cada linha, pois isso é necessário!).

:arrow: Manter o nome msgbox e em seguida escrever a mensagem que quer que seja exibida é uma regra simples que obedece à sintaxe (forma de escrever) do comando msgbox. Se você tentar colocar outro nome no início, o AutoHotkey provavelmente não entenderá o seu comando e vai apresentar um erro se você tentar executar o script (ele também lhe dirá em que linha estará o erro, para que você possa corrigir).

5. De forma básica: o que é Programação?

Agora que já temos uma ideia do que é um script e como ele funciona, vamos discutir um pouco o trabalho de programação. Programação é um processo. Através desse processo, criamos os programas, que são planejamentos de execução de instruções de forma organizada sequencialmente, com o objetivo de realizar um trabalho.

Simples não? :angel:

A isto segue-se o como se programa: A resolução de um problema complexo (do tipo "como criar um editor de texto parecido com o Word") é encontrada através da divisão do mesmo em várias tarefas simples e graduais, que serão resolvidas como passos individuais da tarefa maior.

Assim para nos tornarmos programadores, temos que simplesmente adquirir os meios de dividir uma tarefa complexa (que NÃO significa difícil, mas sim abstrata) em várias tarefas simples, que possam ser implementadas sequencialmente até que se cumpra a tarefa complexa.

Dessa forma, a resposta para uma pergunta do tipo como fazer um programa que nem o Excel? é simplesmente identificar os elementos menores que esse programa deve possuir, para então criarmos novas perguntas do tipo como crio um botão em uma janela?, que (essas sim) são prontamente respondidas pela implementação das ferramentas que temos disponíveis (E você sabia que o AutoHotkey tem um comando que cria um botão em uma janela? :thumbup: ).

:arrow: Coletar o conhecimento sobre as ferramentas disponíveis (ou seja, aprender os comandos) é o que vai permitir que você faça uma melhor divisão das tarefas complexas em tarefas simples e possa então implementá-las conforme o seu projeto.

6. E o que é Automação?

Ser uma ferramenta de automação é uma outra vantagem do AutoHotkey. Automação é fazer com que tarefas que antes eram executadas com o trabalho de um operador humano passem a ser executadas por uma máquina (ou software).

Assim, o AutoHotkey permite que programemos a automação de tarefas em ambiente windows. Isto pode ser feito de várias maneiras, através dos vários comandos de automação que o AutoHotkey possui, como o comando Click (que simula o clicar do mouse em um ponto qualquer da tela), o comando Send (que simula o envio de comandos do teclado para a janela ativa) e o comando Sleep (que simula uma pausa entre comandos).

Lembrando da importância da sequência de execução e de como definimos isso pela posição das linhas do script, é fácil perceber que que podemos usar esses três comandos acima para automatizar várias tarefas diferentes (Seria mais menos como esse exemplo: clicar em um arquivo, depois enviar um enter, depois dar uma pausa de 5 segundos, depois clicar na tela que se abriu, depois escrever alguma coisa... Cada ação dessas corresponderia a um comando escrito em uma linha do script).

7. Considerações finais

Se você seguiu este tutorial até aqui parabéns! :bravo:

Saiba que já aprendeu muito do que será necessário para criar os seus próprios scripts. Os próximos tutoriais dessa série serão focados em apresentar-lhe os outros princípios básicos necessários para iniciar a programação em AutoHotkey. Se tiver quaisquer dúvidas sobre o conteúdo deste tutorial, sinta-se livre para postar abaixo ou criar um tópico no fórum Eu Preciso de Ajuda.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

Re: Básico de variáveis, expressões e comandos em AutoHotkey

03 Apr 2018, 18:43

Reservado.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

Re: Básico de variáveis, expressões e comandos em AutoHotkey

03 Apr 2018, 18:43

II. Tutorial Básico de Variáveis, Expressões e Comandos em AutoHotkey

Olá novamente :angel:

Decidi escrever este tutorial porque o uso das variáveis e das expressões em comandos confunde muito os iniciantes na programação no AutoHotkey, e isso pode fazer com que um script aparentemente normal não execute da forma planejada. Uma situação muito comum é quando o desenvolvedor escreve um comando e não coloca os símbolos de percentuais em um parâmetro (ou os coloca) e na verdade esse parâmetro não esperava (ou esperava) o uso desses percentuais. Como saber se um parâmetro requer percentuais ou não?

Ler este tutorial com certeza vai ajudar muito a quem deseja iniciar a programação em AutoHotkey.

Vamos lá? :thumbup:

1. Variáveis: o que são?

Image

A grosso modo, variáveis são repositórios de valores. Quando desejamos programar um trabalho a ser executado em um script e temos de lidar com valores que podem ser diferentes dependendo do que ocorra na execução do programa, precisamos de uma ou mais variáveis. Um exemplo bem básico é de um programa que pede a um usuário um número e o multiplica por 10, apresentando depois o resultado. Não sabemos que número o usuário vai escolher, então como programaremos isso?

Simples! vamos usar uma variável. Para facilitar nosso entendimento do que é a variável, vamos imaginar que a variável é como um endereço fixo na memória. A forma como esse conceito resolve nosso problema é a seguinte: primeiro programamos o colocar do número escolhido pelo usuário em um exato endereço e depois (em uma linha posterior) programamos a multiplicação do que estiver naquele exato endereço por 10.

Assim, se o usuário digitar 3, o programa coloca 3 naquela variável (que é como um endereço) e depois multiplica o que está naquela variável (ou seja, 3) por 10. Já se o usuário digitar 5, da mesma forma o sistema coloca 5 naquela variável e depois multiplica o que está naquela variável (ou seja, 5) por 10. É assim que o programa consegue trabalhar com qualquer valor que o usuário insira: basta usar uma variável.

A variável permite que você indique um trabalho para ser feito com determinados dados, independente dos valores desses dados, que podem até mudar em cada execução do programa (por isso chama-se variável).

Ficou mais fácil de entender? :)

Existem outras analogias do que é a variável: podemos pensar que é uma caixa onde podemos pedir a alguém que coloque alguma coisa para que saibamos depois onde estará e assim possamos indicar uma ação para fazer com o que estiver lá, podemos imaginar que é um espaço na nossa agenda onde podemos em algum momento marcar data e horário de modo que depois saibamos quando vai acontecer apenas consultando a agenda, e assim sucessivamente.

2. Tipos de Dados

Como qualquer linguagem de programação, o AutoHotkey as vezes precisa lidar com dados que têm um mesmo valor, mas que podem significar coisas diferentes. Um exemplo bem básico é o seguinte: suponha que tenha colocado em uma variável o seguinte valor: 2 + 2

Agora suponha que eu queira apresentar esse valor em uma tela para que o usuário possa ver. O dilema que temos aqui é o seguinte: será que o valor deve ser apresentado do jeito que eu escrevi (ou seja, 2 + 2) ou será que deve ser apresentado na forma de resultado (ou seja, 4)?

O AutoHotkey pode interpretar e trabalhar dados de duas formas simples: de forma matemática ou de forma literal. Sabendo disso, em cada situação onde esses dados serão usados, seja dentro de comandos ou na hora de colocar os valores nas variáveis, temos que ter em mente como queremos que esses valores sejam interpretados pelo AutoHotkey para que possamos escrever os valores da exata forma que queremos que eles sejam interpretados.

Vamos ver isso a seguir :thumbup:

3. Escrevendo variáveis com cada tipo de dados

Agora que sabemos que temos de tomar o cuidado de pensar na forma como os dados serão interpretados quando escrevemos seus valores, como faremos para identificar estas formas de interpretação ao escrever códigos de inserção de valores em variáveis? Simples: usaremos operadores (ou seja, símbolos do teclado) que vão forçar o AutoHotkey a interpretar os dados da forma que queremos.

O primeiro tipo de operadores que lida com a forma como os dados são interpretados são os operadores de inserção de dados em variáveis. Temos dois principais operadores nesse caso: o primeiro é o símbolo de igual (ou seja, =), que será usado para que a interpretação dos valores seja estritamente literal, e o segundo é o símbolo de dois pontos seguido do símbolo de igual (ou seja, :=), que será usado para que a interpretação seja matemática.

Veja no exemplos abaixo a sintaxe (a forma de escrever) que usamos para inserir valores em variáveis nos dois casos:

Primeiro caso (escrita literal):


Segundo caso (escrita matemática):

Code: [Select all] [Download] GeSHi © Codebox Plus

Var2 := 2 + 2


Primeiro indicamos o nome da variável. Os nomes de variáveis podem conter letras e números, mas não podem conter espaços e nem alguns símbolos.
Depois usamos um operador de inserção de dados. Você viu a diferença nos dois operadores usados nos dois casos acima? No caso da variável Var1 usamos o operador =, portanto estamos inserindo o valor 2+2 nela. Já no caso da variável Var2, usamos o operador :=, portanto estamos inserindo o valor 4 em Var2. Isto ocorre porque dissemos ao AutoHotkey que no segundo caso o valor 2 + 2 deve ser intepretado de forma matemática, o que faz com que ele primeiro resolva o 2 + 2 em simplesmente 4 e daí armazene este 4 na variável.

É bem lógico não? Agora vamos ver um último caso também importante :D

4. Escrevendo variáveis com os dois tipos de dados

Agora que já sabemos como escrever os valores nas variáveis de modo a controlar a forma como serão interpretados, imagine a seguinte situação: preciso escrever isto numa variável: João tem 2 + 2 maçãs.

Escrever de forma estritamente literal é fácil (embora não seja o que queiramos, já que o 2 + 2 vai continuar sendo 2 + 2):

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 = João tem 2 + 2 maçãs


Mas escrever de forma matemática e ainda permitir que os números sejam trabalhados em um valor final vai requerer algo a mais, pois essa frase tem letras e palavras no meio, portanto não resolve imediatamente de forma matemática. O que fazemos então é usar outro operador que permite que unamos em qualquer caso uma frase literal e uma expressão matemática. O operador que vou apresentar para resolver o caso é o de aspas duplas (ou seja, "). Ele deve ser colocado no início e no fim de todas as frases estritamente literais que estiverem dentro de expressões matemáticas.

Code: [Select all] [Download] GeSHi © Codebox Plus

Var2 := "João tem " 2 + 2 "maçãs"


Pronto! Se você exibir o conteúdo da variável acima agora (e se você não sabe ainda não se preocupe, pois vamos tratar disso no item 7 :angel: ), vai ter como resultado de Var2 a frase joão tem 4 maçãs.

5. Variáveis dentro de expressões matemáticas e literais

Como dissemos no item 1 deste tutorial, as variáveis são muito importantes para escrevermos nossos scripts, pois elas nos permitem guardar valores e depois recuperá-los. Sendo assim, agora que já sabemos como escrever dados em variáveis de forma literal e de forma matemática, como fazemos para recuperar esses dados delas?

Para recuperar os valores que estiverem dentro de uma variável também precisamos lembrar se estamos escrevendo algo que será interpretado de forma matemática ou de forma literal. Dentro de uma expressão com interpretação matemática, recuperar valores de variáveis é tão simples quanto escrever o nome da variável em questão.

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 = João tem 
Var2 := 2 + 8 - 1
Var3 = maçãs
Var4 := Var1 Var2 Var3


No código acima, o resultado que será inserido em Var4 é João tem9maçãs. Como isso ocorreu? Veja que na linha 1 coloquei o valor João tem dentro da variável Var1 de forma literal, pois usei o operador =. Na linha 2, coloquei o resultado matemático de 2 + 8 - 1 dentro de Var2, pois o inseri de forma matemática usando :=. Na linha 3, coloquei o valor maçãs dentro de Var3 de forma literal, e na linha 4, juntei tudo simplesmente recuperando os valores que estavam em cada variável na sequência correta. Isso funcionou porque o operador da linha 4 é o operador matemático, logo, cada uma das variáveis nomeadas foram resolvidas automaticamente para apresentar os seus valores.

Agora vejamos um segundo caso. Como faço para fazer a mesma coisa (inserir os resultados de variáveis) em uma variável usando o operador literal? Bom, nesse caso, precisaremos usar o operador percentual (ou seja, %) que será colocado imediatamente antes e também imediatamente depois do nome de cada variável. Assim, um código equivalente ao de cima, mas usando operador literal para inserir dados na Var4 seria:

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 = João tem 
Var2 := 2 + 8 - 1
Var3 = maçãs
Var4 = %Var1% %Var2% %Var3%


Veja que o resultado foi o mesmo, mas agora temos espaços entre as variáveis. Isso é um bônus, mas não esqueça que também pode ser feito em uma expressão matemática usando as já descritas aspas duplas!

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 = João tem 
Var2 := 2 + 8 - 1
Var3 = maçãs
Var4 := Var1 " " Var2 " " Var3


6. Valores matemáticos e literais dentro de parâmetros de comandos

Uma das grandes vantagens do AutoHotkey é que ele possui uma série de comandos que automatizam tarefas do computador, como clicar em um lugar ou escrever um texto em um campo. Usar esses comandos requer uma noção básica da sintaxe deles e também os conhecimentos que você já adquiriu neste tutorial. Para entender a sintaxe dos comandos, pense o seguinte: o comando deve ser escrito colocando em uma nova linha do script colocando:

o nome dele, seguido de um espaço e depois do seu primeiro parâmetro, e depois seguido dos outros parâmetros separados por vírgula.

Ou seja, para o comando msgbox, que exibe uma caixa de texto, a forma de escrita é

msgbox parametro1, parametro2, parametro3, parametro4

Lembrando que o padrão depois disso continuará por quantos parâmetros tiver aquele comando (alguns comandos tem 1 parametro, outros 2, outros um número qualquer. Todos serão dispostos sequencialmente separados por vírgulas).

:arrow: Em cada página dos documentos de ajuda do AutoHotkey, você encontra em amarelo na parte superior a sintaxe e o nome dos parâmetros do comando. Os parâmetros que forem opcionais naquele comando (ou seja, que não são totalmente necessários) normalmente são os últimos e são apresentados entre colchetes (ou seja, entre [ e ]). Mas se por exemplo você quiser usar o quinto parâmetro e a partir do terceiro todos forem opcionais, não esqueça de colocar todas as vírgulas!

Exemplo de caixa de sintaxe (cada linha é uma sintaxe diferente que você pode usar):
Caixa de Sintaxe.png
Caixa de Sintaxe.png (2 KiB) Viewed 261 times


A descrição dos parâmetros é feita logo após a caixa de sintaxe, e as descrição são separadas pelo nome dos parâmetros correspondentes em verde.

A lista de páginas de ajuda de comandos pode ser conferida aqui.

Tendo dito isto, agora que você já entende um pouco sobre a sintaxe dos comandos, vamos falar sobre como escrever os parâmetros dos comandos. Cada parâmetro de cada comando pode esperar, a princípio, uma só dessas três hipóteses: que o valor nele escrito seja algo estritamente literal, ou que seja uma única variável, ou então que seja uma expressão matemática.

Estas três hipóteses tem que ser verificadas quando vamos escrever um parâmetro. Será que esse parâmetro espera uma variável? Ou será que espera um texto? ou será que espera uma expressão matemática? É exatamente essa resposta que vai definir como vamos escrever o valor daquele parâmetro.

De um modo geral, o arquivo de ajuda e o nome do parâmetro nos dizem quase de cara que tipo de valor escrever. A maioria dos parâmetros esperam um valor literal, e muitos deles esperam valores específicos (que você pode encontrar listados no arquivo de ajuda). Além disso, um parâmetro que se chame text ou Title ou qualquer palavra que remeta a uma frase obviamente vai esperar um valor literal. Já se o parâmetro se chamar OutPutVar, InPutVar ou qualquer outra coisa com Var no meio, ele deve esperar o nome de uma única variável e somente isso (sem percentuais nem nada). Por fim, se o nome do parâmetro for expression ou algo parecido, podemos subentender que devemos escrever os dados em forma de expressão matemática, onde por exemplo 2 + 2 será interpretado como 4 e qualquer palavra escrita será entendida como uma variável que deve ser resolvida para o valor que estiver guardado nela.

Muito conteúdo até aqui? Então vamos tirar as dúvidas na prática! :D

7. Exibindo valores: somatório do que foi discutido

Agora que já concluímos uma breve discussão acerca de variáveis, expressões, tipos de dados e sintaxe de comandos, podemos passar para a melhor parte: a prática. Como fazemos para exibir o resultado de José tem 20 + 5 - 4 maçãs e 16 + 2 são verdes. em uma caixa de texto?

Ora, é só fazer o que aprendemos! Primeiro vamos dividir a sentença em valores em literais e matemáticos. Depois, vamos estudar a sintaxe do comando msgbox para entender como ele quer que escrevamos os parâmetros. Por fim, vamos escrever isso de forma lógica e racional usando os operadores que aprendemos.

Após estudar a frase proposta, vemos que podemos dividir os valores em: literal José tem, seguido de matemático 20 + 5 - 4, seguido de literal maçãs e, seguido de matemático 16 + 2, seguido finalmente de literal são verdes..

Agora, estudamos a sintaxe do comando msgbox, dentro do arquivo de ajuda que você pode acessar aqui.

A caixa de sintaxe (a com fundo em amarelo) nos dá duas possibilidades:

Caixa de Sintaxe.png
Caixa de Sintaxe.png (2 KiB) Viewed 261 times


Logo, se olharmos a primeira sintaxe (ou seja, msgbox, text) esse comando só tem 1 parâmetro, e o nome dele é text. Assim, podemos perceber que esse parâmetro deve esperar um valor literal (pois seu nome é nada mais nada menos que texto em inglês).

Assim, escreveremos esse parâmetro usando o nosso conhecimentos sobre as formas de inserir valores em variáveis e também de como escrever quando a interpretação vai se dar de forma literal.

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 := 20 + 5 - 4
Var2 := 16 + 2
msgbox Jose tem %Var1% maçãs e %Var2% são verdes.


Se você executar o código acima, verá que a coisa saiu exatamente como deveria sair: o texto foi tratado como texto, os valores matemáticos foram resolvidos e as variáveis fizeram seu papel, trazendo os valores matemáticos resolvidos ao texto que inserimos no parâmetro de msgbox. Como fizemos a escrita do parâmetro na forma em que sua sintaxe esperava, o comando executou de forma correta e a caixa de texto foi exibida de forma correta.

Sucesso :dance:

8. Considerações finais

Se você seguiu este tutorial do inicio ao fim, deve estar bem mais preparado para começar a escrever comandos em AutoHotkey. Tudo que falta agora é estudar as páginas dos comandos e testá-los para aprender o que pode ser feito por eles. Parabéns pela dedicação e por escolher seguir o caminho da automação e da programação, este caminho com certeza lhe levará bem longe :bravo:

Para finalizar este tutorial, aqui vão algumas dicas:

1. A maioria dos parâmetros de comandos espera que você os escreva de forma literal, mas em muitos deles você pode forçar uma interpretação de expressão matemática. Para fazer isso, basta usar um único símbolo de percentual % seguido de um espaço. A partir daquele ponto, todos os parâmetros subsequentes serão interpretados como expressões matemáticas.
MsgBox % "Este texto precisa de aspas duplas, pois forçamos uma interpretação literal aqui. Veja o cálculo a seguir ser resolvido: " 2 + 13 - 1
2. Se você tentar executar um comando escrevendo um texto e o resultado que você escreveu "não aparecer", mas o comando executar normalmente é provável que o comando esteja esperando um valor matemático ou o nome de uma variável naquele parâmetro, pois se você escrever uma palavra ou texto, ele vai tentar resolver como variável e vai trabalhar considerando que você colocou um valor vazio (pois é o que estaria lá se fosse mesmo uma variável).
3. Se você escrever o nome de uma variável e o comando executar, mas o resultado "não aparecer", você pode tentar colocar os percentuais ao redor do nome da variável, pois é possível que o parâmetro esteja esperando um texto.
4. Não se esqueça que quaisquer dúvidas que você tiver com comandos que aparentam não estar funcionando podem ser perguntadas no nosso fórum Eu Preciso de Ajuda, onde a comunidade vai fazer o que puder para respondê-lo o mais rapidamente possível.

Um abraço e fiquem todos na paz :angel:
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

Re: Básico de variáveis, expressões e comandos em AutoHotkey

03 Apr 2018, 18:53

Reservado.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

Re: Básico de variáveis, expressões e comandos em AutoHotkey

03 Apr 2018, 18:54

III. Desenvolvimento de um Programa Funcional Básico em AutoHotkey

Bom dia :angel:

Neste terceiro tutorial desta série, aproveito para demonstrar passo a passo o funcionamento de um pequeno programa em autohotkey, de modo que possamos começar a nos habituar à forma de escrita dos scripts e assim nos seja mais fácil desenvolver nossos próprios scripts ou analisar os códigos que a comunidade já escreveu e que podemos utilizar também.

Ler este tutorial com certeza vai ajudar muito a quem deseja iniciar a programação em AutoHotkey.

Vamos lá? :thumbup:

1. Formando o projeto

Suponha que eu deseje fazer o seguinte. Quero criar um formatador de formulário de relatórios. Isso significa, basicamente, que eu quero que o script me ajude a criar relatórios customizados por mim e padronizados, de modo que a leitura desses relatórios seja clara e precisa, e que eles sempre tenham as informações que eu mais preciso colocadas adequadamente nos campos corretos.

Como fazer isso? :wtf:

Simples! :angel:

Vamos dividir esta tarefa em várias tarefas menores e depois vamos usar as ferramentas que o AutoHotkey possui para resolvê-las. É pensando assim que criaremos o nosso projeto.

:arrow: O primeiro passo é pensar nas partes que um formulário de relatório deve ter (ou normalmente tem) e usar cada uma delas como uma divisão do trabalho de criar o relatório. Para fazer isso cabe imaginar o formulário pronto (ou mais ou menos pronto) na nossa mente. Se tivermos dificuldade de fazer isso de imediato, podemos ir à internet e buscar imagens de formulários de relatórios para nos inspirar antes de formar a imagem do nosso próprio relatório, e podemos ainda desenhar em uma folha A4 a nossa ideia inicial de relatório só pra ver como fica. O importante é que tenhamos uma ideia inicial sólida, que podemos mudar conforme avançamos no desenvolvimento, mas que servirá de ponto de partida.

Pensando um pouco, vejo basicamente que um formulário de relatórios legal deve ser um arquivo que possa ser aberto pelo usuário e deve ter um título, deve ter a palavra relatório em letras maiúsculas, um número qualquer de linhas para se escrever, todas numeradas e com ponto e espaço, e ainda a data e campo de assinatura embaixo. Desejo que o sistema cuide de tudo o que puder para que o usuário só precise preencher as informações que forem necessárias.

2. Desenvolvendo o script

Agora que temos uma ideia do que queremos (criar o gerador de formulário de relatórios) e já conseguimos dividir a tarefa maior em várias tarefas menores:

TAREFAS:
  • 1. criar um arquivo de texto
  • 2. colocar título à escolha do usuário
  • 3. colocar a palavra relatório
  • 4. colocar linhas numeradas
  • 5. data e campo de assinatura


Os comados que vamos utilizar para a primeira versão desse projeto são os seguintes:

COMANDOS:
  • 1. Run: Este comando executa um programa ou roda um arquivo com o programa associado ao seu tipo. Também pode abrir páginas da web.
  • 2. Sleep: Este comando cria uma pausa entre a execução dos vários comandos do script.
  • 3. WinActivate: Este comando ativa (torna principal) uma janela aberta que você escolher.
  • 4. Send: Este comando envia sinais de teclas do teclado para a janela ativa.
  • 5 .Também utilizaremos outra funcionalidades do AutoHotkey: Variáveis embutidas. Essas variáveis já contém dados conhecidos e importantes para você usar sempre que precisar (exemplo: o dia de hoje).

Veja que de alguma forma a lista acima é muito próxima à lista de tarefas que elencamos. Isso porque a divisão em pequenas tarefas foi bem executada, o que nos permitiu tratar o problema complexo como vários probleminhas simples.

3. Escrevendo o script

Para escrever o script, tudo que temos que fazer é escrever as linhas na sequência da ordem de execução (de cima para baixo, a partir da primeira linha) colocando um comando por linha e escrevendo seus parâmetros adequadamente, de modo a cumprir cada tarefa sequencialmente. Por exemplo, para resolver a primeira tarefa (criar um arquivo de texto), vamos primeiramente usar o comando Run para abrir uma janela do Bloco de Notas.

Run, notepad.exe

Pronto, agora já podemos começar a escrever o nosso arquivo. Mas antes de escrever qualquer comando de enviar teclas, precisamos ter em mente que o programa não se abre instantâneamente. Por isso, precisamos programar uma pausa, que deve ser adequada ao tempo necessário para que tenhamos quase certeza de que o programa terminou de abrir.

Sleep, 5000 ; Assinalamos com este comando que queremos uma pausa de 5 segundos antes de continuar a execução do script (o número indicado se refere a milisegundos, por isso escrevermos 5000)

Na linha acima, colocamos comentários dentro do código[/b]. Fazemos isso colocando o ponto-e-vírgula [c];. Os comentários são úteis para organizar os códigos. Nada que for escrito após o ponto-e-vírgula em uma linha será executado pelo AutoHotkey (serve apenas como anotação do programador).

Em seguida programamos a ativação da janela que se abriu (se ela não estava ativa ainda por qualquer motivo, irá se ativar agora. Este passo não é totalmente necessário, mas aumenta a confiabilidade do nosso script (pois as vezes, um pop-up de outra janela acaba interferindo aqui).

WinActivate, ahk_class Notepad

No comando acima, veja que utilizamos uma opção de classe de janela para identificar a janela que queremos ativar. Esta opção pode ser encontrada no arquivo de ajuda do comando WinActivate. Ao invés de usar a classe de janela, também é possível usar o nome da janela (que normalmente é Sem título - Bloco de notas). Os parâmetros existem exatamente para que possamos ter várias opções, para que escolhamos a que melhor cabe ao caso.

Agora passamos a escrever os comandos que formatarão o relatório. O primeiro passo é o título do relatório. Como queremos que nosso relatório tenha vários título possíveis, vamos perguntar ao usuário qual titulo colocar em cada execução do script, e vamos utilizar o título que ele indicar escrever no relatório. Para fazer isso, primeiro coletamos o título, o que podemos fazer usando o comando InputBox. Esse comando cria uma caixa onde o usuário pode escrever uma mensagem, e depois salvar a mensagem escrita em uma variável que indicamos (lembre-se, como não sabemos o título antecipadamente, temos de usar uma variável).

InputBox, TITULO_ESCOLHIDO, Escolha de Título, Escreva uma título abaixo para o relatório:

Agora que já coletamos o título e o colocamos dentro da variável TITULO_ESCOLHIDO, podemos usá-lo para escrever no nosso programa. Mas antes, vamos ativar novamente a janela do Bloco de Notas, pois o usuário pode ter clicado em outras janelas antes de escrever o título.

WinActivate, ahk_class Notepad

Agora vamos escrever o comando que vai escrever o título. Este comando é o comando Send.

Send %TITULO_ESCOLHIDO%

Veja que o comanod Send espera um parâmetro do tipo literal. Assim, temos de colocar parêntesis imediatamente antes e depois do nome da variável, de modo a informar ao AutoHotkey que TITULO_ESCOLHIDO não é literalmente o que está escrito, mas sim, uma variável que deve ser transformada no valor que contiver naquele momento. Como fizemos com o que o usuário escrevesse um título e colocamos nessa variável na linha anterior, sabemos que o que estiver lá será na verdade o que o usuário quer que seja o título do relatório.

Ufa! Até aqui já fizemos bastante coisa não :thumbup:
Agora vamos unir os códigos!

Code: [Select all] [Download] GeSHi © Codebox Plus

Run, notepad.exe
Sleep, 5000
WinActivate, ahk_class Notepad
InputBox, TITULO_ESCOLHIDO, Escolha de Título, Escreva uma título abaixo para o relatório:
WinActivate, ahk_class Notepad
Send %TITULO_ESCOLHIDO%


Execute o bloco de códigos acima em um script do AutoHotkey e você verá como essa sequência de códigos se traduz em uma ordem racional de comandos que vai construindo aquilo que queremos fazer. É sempre bom ir executando o bloco conforme você vai escrevendo linha a linha, pois se você errar um único comando, vai ficar mais fácil de identificar qual foi. Isso é muito importante no início do aprendizado da linguagem.

bom, mas nosso relatório não é feito apenas de um título!

Conforme a nossa lista de tarefas, ainda precisamos colocar a palavra relatório, as linhas numeradas, a data e o local de assinatura. Faremos tudo isso tudo com sucessivas chamadas ao comando Send, que é o comando que envia os sinais de teclas. O código completo com os send ficaria como este:

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



Fizemos bastante coisa com o comando Send, mas não se preocupe, vamos explicar! :D

Primeiro execute o código para ver o que acontece. Veja que fizemos várias chamadas ao comando. Isso NÃO é necessário, mas ajuda na leitura do script organização. Quando escrevemos {Enter} dentro do parâmetro text do comando Send, fazemos com que o comando Send interprete que queremos que ele envie um enter (logo, criando uma nova linha no Bloco de Notas) e não simplesmente escreva Enter. Esta informação consta na página do arquivo de ajuda do comando Send, ela não foi inventada. Além disso, veja como escrevemos todos as informações respeitando a forma de escrita literal, que é a que esse parâmetro espera. Por isso, todas as variáveis foram escritas entre percentuais. Isso inclui as variáveis A_DD, A_MM, e A_YYYY que são variáveis embutidas do AutoHotkey que contém respectivamente o dia de hoje, o mês de hoje e o ano de hoje. "Hoje" nesse caso, refere-se ao dia da execução do script, e será coletado automaticamente do relógio do Windows no computador. Veja também que a lógica da escrita leva em consideração o que deve ser escrito primeiro e o que deve ser escrito depois. Primeiro vem o título, depois a palavra RELATÓRIO, depois dois sinais de tecla enter, depois as linhas separadas por enter, depois mais dois sinais de tecla enter, depois dia, mês e ano conforme o relógio do windows (obtidos pelas variáveis embutidas e separados por / para organização), e depois um enter, seguido de uma linha menor, seguido da palavra ASSINATURA.

Ufa! quanta coisa hein? Mas não se preocupe, veja que nosso projeto já está quase pronto :dance:

O que falta a seguir é salvar o arquivo. Temos maneiras de fazer isso com o AutoHotkey também, mas como este é um tutorial cujo objetivo é ensinar o passo-a-passo para fazer um script da forma correta, vamos seguir outro caminho agora. Faremos isso porque o script como construímos até aqui funciona, mas poderia ser melhor.

:arrow: Em programação, a otimização dos códigos é muito importante, e é por isso que é constante trabalho na atualização dos softwares que vemos ao nosso redor. A versão 1.01 funciona, mas a versão 1.02 normalmente vem com melhorias em relação à ela. Então vamos exercitar isso também e já vamos melhorar o nosso código aumentando nosso conhecimento a partir de agora! :thumbup:

4. Melhorando o script

Para iniciar nosso processo de melhoria do código, devemos análisá-lo e, usando o nosso conhecimento, tentar reescrever o código de forma a obter melhores resultados. Olhando pelo código antigo, podemos ver que escolhemos anteriormente uma forma pouco confiável de criar o nosso relatório. Se o usuário tentar operar o computador enquanto o nosso script executa, tudo vai virar uma bagunça. Não é assim que trabalhamos em programação: precisamos que os programas sejam altamente confiáveis. E para fazer isso, o importante é aprender que temos mais de um jeito de fazer alguma coisa, e usar as ferramentas certas é o que vai tornar nosso script melhor em relação a outro que faça a mesma coisa.

Assim, vamos aprender outro comando do AutoHotkey: o FileAppend. Este comando basicamente escreve um arquivo de texto para nós usando simplesmente dados como o endereço onde escrever (tipo c:/meu_arquivo), o nome do arquivo (como Relatório de TITULO_ESCOLHIDO) e ainda o texto que queremos que seja escrito no arquivo. Se usarmos esse comando, toda a escrita do arquivo ocorrerá independente do que o usuário estiver fazendo no computador, e não será interrompida por ela. Além disso, o arquivo já estará salvo quando o comando executar com sucesso.

Viu as vantagens? Se nós aprendermos pelo menos mais um comando ou funcionalidade do AutoHotkey por dia, logo estaremos capazes de fazer scripts de nível altamente profissional! :bravo:

Veja como fica o nosso script usando o FileAppend. Primeiro, vamos coletar do usuário o título do relatório, exatamente como fizemos antes.

InputBox, TITULO_ESCOLHIDO, Escolha de Título, Escreva uma título abaixo para o relatório:

Depois, vamos coletar do usuário o local onde salvar o arquivo. Faremos isso usando o comando FileSelectFile.

FileSelectFile, NOVO_ARQUIVO_RELATORIO, S8,, Salvar Novo Arquivo de Relatório, Arquivos de texto (*.txt)

Depois, podemos criar uma variável com todas as informações que queremos que sejam escritas.

Code: [Select all] [Download] GeSHi © Codebox Plus

TEXTO_A_ESCREVER = %TITULO_ESCOLHIDO%`nRELATÓRIO`n`n1. ______________________________________________________`n2. ______________________________________________________`n3. ______________________________________________________`n4. ______________________________________________________`n5. ______________________________________________________`n6. ______________________________________________________`n7. ______________________________________________________`n8. ______________________________________________________`n9. ______________________________________________________`n10. _____________________________________________________`n`n%A_DD%/%A_MM%/%A_YYYY%`n___________________________`nASSINATURA


Veja que no caso da sintaxe de escrita literal em variáveis (usamos =, portanto, indicamos a sintaxe literal), não usamos o {Enter} e sim `n. Estes dois símbolos é o que se traduzem em um enter neste caso. Também colocamos tudo junto, mas poderíamos criar várias variáveis se quiséssemos e depois unir elas.

Finalmente, chamamos o FileAppend para escrever nosso arquivo!

FileAppend, %TEXTO_A_ESCREVER%, %NOVO_ARQUIVO_RELATORIO%.txt

E depois, como nosso novo script opera de forma silenciosa, informamos ao usuário a conclusão da escrita do arquivo. O usuário poderá então encontrar o arquivo de relatório criado na pasta em que escolheu para salvá-lo.

MsgBox, Arquivo escrito com sucesso!

Tudo junto:

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, TITULO_ESCOLHIDO, Escolha de Título, Escreva uma título abaixo para o relatório:
FileSelectFile, NOVO_ARQUIVO_RELATORIO, S8,, Salvar Novo Arquivo de Relatório, Arquivos de texto (*.txt)
TEXTO_A_ESCREVER = %TITULO_ESCOLHIDO%`nRELATÓRIO`n`n1. ______________________________________________________`n2. ______________________________________________________`n3. ______________________________________________________`n4. ______________________________________________________`n5. ______________________________________________________`n6. ______________________________________________________`n7. ______________________________________________________`n8. ______________________________________________________`n9. ______________________________________________________`n10. _____________________________________________________`n`n%A_DD%/%A_MM%/%A_YYYY%`n___________________________`nASSINATURA
FileAppend, %TEXTO_A_ESCREVER%, %NOVO_ARQUIVO_RELATORIO%.txt
MsgBox, Arquivo escrito com sucesso!


Execute o código acima, escolha para salvar o arquivo na sua área de trabalho e depois veja o arquivo ser criado. Percebeu que tudo ocorreu de forma silenciosa e rápida, sem possibilidade de o usuário interromper a escrita sem querer? :dance:

Isto conclui nosso terceiro tutorial dessa série. Lembro que o objetivo é que estudemos a linguagem passo a passo, de forma mais aprofundada e explicada, por isso, vamos aprendendo novos comandos e ferramentas a cada momento, com o objetivo de aumentar nossa capacidade de criar scripts. Você viu que usamos variáveis embutidas neste tutorial? Elas são muito úteis e você pode encontrar uma lista das variáveis embutidas disponíveis aqui neste link.

Fiquem todos na paz e um forte abraço. Até o próximo tutorial :wave:

Gio.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

Re: Básico de variáveis, expressões e comandos em AutoHotkey

03 Apr 2018, 18:55

Reservado.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

03 Apr 2018, 18:57

IV. Tutorial Básico de Condicionais de Execução e Blocos de Códigos

Olá :thumbup:

Se você chegou até este quarto tutorial desta série, parabéns! saiba que você já viu e aprendeu bastante coisa sobre programação e sobre o AutoHotkey. Mas como dissemos anteriormente, não podemos nos esquecer que programação é um aprendizado contínuo, e se a cada dia agregarmos mais e mais conhecimento, a cada dia nos tornaremos melhores programadores.

Assim, neste quarto tutorial de nossa série, vamos nos ater às expressões condicionais e aos blocos de código. Você sabe o que eles são e para que servem?

1. Nem sempre devemos executar todo o código do script

Como vimos anteriormente, o AutoHotkey executa as linhas do nosso script uma a uma, da primeira até a última. Mas será que sempre vamos querer que isso ocorra? Vamos supor que você deseja escrever um programa, mas quer que esse programa só possa ser usado por uma determinada pessoa. Isso significa basicamente que queremos de alguma forma criar uma condição para executar esse programa, ou seja, uma parte do código só deve executar se o usuário for mesmo aquela pessoa. Afinal, não queremos que o programa abra todas as janelas e execute todo o código se ele tiver sido executado por um terceiro!

Como faremos isso?

Ora, a melhor maneira de garantir que o usuário que executou o script seja uma determinada pessoa é através de uma chave e/ou senha. Se você seguiu os tutoriais anteriores, deve ter percebido que já aprendemos a coletar informações do usuário através do comando InputBox. Então, o primeiro passo para implementar uma rotina de senha é coletar a senha do usuário. Mas e depois? Como fazemos para verificar se a senha coletada é a senha correta?

Para fazer isso, vamos criar uma expressão condicional. As expressões condicionais são expressões lógicas que se resolvem para um valor de Verdadeiro ou Falso. Se a condição que escrevemos nela for atendida pelos dados inseridos, ela vai retornar um Verdadeiro, e se não for, vai retornar um Falso.
No caso do AutoHotkey, podemos agregar blocos de códigos à expressões condicionais, de forma que estes só executem se aquela condicional resultar em verdadeiro.

E o que são esses blocos de códigos? São códigos escrito entre duas linhas de chaves, sendo uma abrindo { e a outra fechando }, de modo que o código fique separado, como se estivesse dentro dessas chaves. Esses blocos de códigos servem para, entre outras coisas, dizer quais comandos queremos (ou não queremos) que sejam executados em determinada situação.

Assim, os blocos normalmente se encontram ligados à uma expressão condicional ou a alguma outra funcionalidade que comanda a sua execução.

2. Escrevendo condicionais

A forma mais básica de escrevermos condicionais é utilizar a sintaxe If (Expression). If em inglês significa se, então podemos ler essa sintaxe como se esta expressão for verdadeira então execute...

Uma expressão desse tipo normalmente usa um operador lógico-matemático, que pode ser:

  • igual-a: =
  • maior-que: >
  • menor-que: <
  • maior-ou-igual-a: >=
  • menor-ou-igual-a <=

:arrow: É importante lembrar que não existe igual-ou-maior-que e nem igual-ou-menor-que, uma vez que estes são equivalentes para todos os efeitos aos dois últimos da lista acima (que existem!).

Assim, vamos ver como escrevemos uma expressão condicional usando tudo isto!

Code: [Select all] [Download] GeSHi © Codebox Plus

Var := 150
If (Var = 149)
{
msgbox, O valor da variável é 149!
}


O que fizemos no código acima foi o seguinte: Colocamos o valor 150 em uma variável. Depois, criamos uma expressão condicional que diz se o valor de Var for igual a 149 então.... E aí colocamos uma bloco de códigos logo após essa condicional contendo um MsgBox que diz "O valor da variável é 149!".

Ora, se você observou bem o que dissemos até aqui, já deve ter sacado que o bloco de códigos acima NÃO VAI EXECUTAR. Isso significa que essa MsgBox nunca vai aparecer se executarmos esse script. Podemos entender isso se pensarmos que a nossa condicional, após trabalhar o valor contido na variável, vai simplesmente dizer "Se 150 for igual a 149 então..." e isso é simplesmente falso. Uma forma de fazer com que essa condicional executasse seria trocar o valor da variável para 149, ou então, usamos o operador menor-que < ou o operador menor-ou-igual-a <=.

:arrow: Com as expressões condicionais, impomos condições para executar os blocos de códigos à elas atrelados, e essas condições são apresentadas através de expressões matemáticas com operadores lógicos (>, <, =, <=, >=).

É importante lembrar ainda que expressões condicionais usando esta sintaxe são expressões matemáticas para todos os efeitos, o que significa que podemos adicionar, subtrair, multiplicar, recuperar valores de variáves e somente o resultado final será comparado com os operadores lógicos.

Code: [Select all] [Download] GeSHi © Codebox Plus

If (10 + 8 = 9 + 9)
{
msgbox, Os resultados são equivalentes !
}


Veja que o código acima executa a MsgBox. Isso ocorreu porque 10 + 8 será trabalhado em 18, assim como 9 + 9 será trabalho em 18 antes que o operador lógico compare os lados da expressão. Neste caso, como os dois lados resultam no mesmo valor, que é 18, a condicional resulta em Verdadeiro, e o bloco de códigos a ela associado executa normalmente.

:arrow: Os operadores lógico-matemáticos possuem uma baixa ordem de precedência, o que significa que em uma mesma expressão, os operadores comuns serão avaliados primeiro, e somente depois será avaliada a expressão lógica. É isto que nos permite dizer que na condicional acima, a igualdade será avaliada depois da soma 9 + 9 (mesmo que esta esteja à direita daquela). A ordem de precedência dos operadores existe para que saibamos como uma expressão será avaliada e possamos programá-la tendo isso em mente. Se você se lembra das aulas de matemática, sabe que a multiplicação ocorre antes da soma, e o mesmo acontece com as expressões no AutoHotkey.

3. Resolvendo o problema da senha

Agora que já cobrimos a forma como a condicional If (Expression) trabalha, vamos usá-la para resolver o problema da senha, que apresentamos no início do tutorial.

Já vimos que para obter um valor do usuário, usaremos o comando InputBox. Então o que demos fazer a seguir?

Simples! Vamos criar uma condicional que compare o valor que o usuário inseriu (e que foi colocado na variável escolhida) para sabermos se ele é igual a uma senha qualquer que vamos criar. O script ficará conforme abaixo.

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If (Senha_Digitada = "Abacaxi")
{
MsgBox, Esta caixa de texto executou porque você inseriu a senha certa!
}


Execute o código acima algumas vezes. Ele pede uma senha. Se você digitar abacaxi, uma caixa de texto será exibida. Mas se você digitar outra coisa, o script simplesmente termina a execução. Tudo isso é feito graça à condicional de execução que criamos.

4. Aprofundando um pouco mais a lógica das condicionais

Acredito que neste ponto já deve ter ficado mais claro a forma como utilizamos as expressões condicionais. Mas veja o código abaixo. Temos duas caixas de texto. Você sabe dizer quais executam de acordo com a condicional?

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If (Senha_Digitada = "Abacaxi")
{
MsgBox, Esta caixa de texto executou porque você inseriu a senha certa!
}
MsgBox, Esta caixa executará independente do que aconteceu acima.


Somente o código que estiver dentro do bloco de códigos (ou seja, entre { e }) vai estar atrelado àquela condicional. Assim, a segunda MsgBox vai executar não importa se o usuário escreveu a senha certa ou não!

Podemos resolver isso colocando a segunda MsgBox dentro do bloco.

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If (Senha_Digitada = "Abacaxi")
{
MsgBox, Esta caixa de texto executou porque você inseriu a senha certa!
MsgBox, Agora sim esta caixa também será dependente do resultado da condicional.
}


Mas também podemos resolver de outras formas. Uma delas é simplesmente criar uma interrupção do script e colocá-la dentro do bloco de códigos. Assim, se o bloco for executado (ou seja, se a senha estiver errada), o script terminará e não executará o que estiver abaixo. Faremos isso usando o comando ExitApp, que termina o script em qualquer lugar que queiramos.


Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If (Senha_Digitada = "Abacaxi")
{
MsgBox, Esta caixa de texto executou porque você inseriu a senha certa!
ExitApp
}
MsgBox, Pela lógica do script, se o bloco acima executou, este código nunca chegará a executar, pois o script terminou assim que o ExitApp foi executado.


E há ainda outras formas de trabalharmos as condicionais aqui. Pelo caso acima, o nosso bloco executa se a senha inserida for Abacaxi. E como faríamos para fazer ele executar se a senha inserida NÃO for abacaxi?

Para isso podemos usar o operador ! (ou NOT), que basicamente significa que estamos perguntando com a nossa condicional se o resultado é Falso ao invés de perguntar se é verdadeiro. Podemos colocar o operador ! (ou NOT) junto ao operador lógico igual ou então junto à expressão inteira:

Junto ao operador lógico (igual):

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If (Senha_Digitada != "Abacaxi")
{
MsgBox, Esta caixa só aparece se você digitar a senha errada!
}


Ou Junto à expressão inteira:

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If (Senha_Digitada != "Abacaxi")
{
MsgBox, Esta caixa só aparece se você digitar a senha errada!
}


:arrow: IMPORTANTE: Embora neste caso negar a igualdade seja o mesmo que negar a expressão inteira, nem sempre funciona assim. Se tivermos mais de uma condicional dentro da expressão (vamos ver isso adiante), negar a expressão inteira pode ter outro resultado!

Outra possibilidade ainda de trabalharmos com a negativa das condições impostas é usarmos a expressões condicional Else. Else em inglês signfica "De outra forma", e basicamente é uma nova expressão condicional atrelada a uma primeira que opera caso a primeira não tenha executado. Assim, podemos escrever o seguinte código se desejarmos apresentar duas caixas (uma para quando a senha está correta, e outra para quando não está):

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If (Senha_Digitada = "Abacaxi")
{
MsgBox, Esta caixa de texto executou porque você inseriu a senha certa!
}
Else
{
MsgBox, Já esta caixa de texto executou porque você inseriu a senha errada!
}


Veja que no código acima, somente uma caixa será exibida em cada execução do script, pois o Else requer que o If não tenha executado. A vantagem do Else é que os dois casos possíveis (Verdadeiro ou Falso) são levado a blocos de códigos específico, ao invés de apenas um levar a um bloco e o outro levar a linha soltas.

:arrow: Um comando Else sempre se conecta ao If mais próximo acima dele.

Uma variante do comando Else sozinho é o comando Else If (Expression). Este comando forma uma segunda possibilidade, de modo que podemos ter uma segunda senha, por exemplo. Se a primeira condicional não executar, a segunda pode executar (ou não) baseado em uma nova condição. Desta forma, não se trata de uma negativa da primeira por si só, mas de uma segunda condição. Podemos usar o Else If (Expression) para impor quantas condições mais queiramos, e ainda podemos usar um Else no final para verificar nenhuma dessas condições foi atendidas.

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



Execute algumas vezes o código acima e estude-o. Você pode testar escrever Abacaxi, Goiaba, Laranja ou outra coisa qualquer e em cada uma dessas quatro situações, a caixa de texto será diferente!

5. Entendendo as Condicionais Compostas

Agora que já entendemos um pouco mais acerca das condicionais básicas e da negação das mesmas, vamos nos ater a outra possibilidade em relação às condionais: Condicionais Compostas.

Pode ser que dentro de uma condiciona If (Expression) queiramos impor mais uma condição. E pode ser ainda que essas condições precisem ser ambas atendidas, ou somente uma atendida. Podemos fazer isso com If (Expression), Else If (Expression) e Else, mas podemos também fazer somente com If (Expression). Isso pode ser feito usando os operadores & (ou AND) e [/c]|| (ou OR). O primeiro significa e e o segundo significa ou. Assim, veja o código abaixo.

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If ((Senha_Digitada = "Abacaxi") OR (Senha_Digitada = "Goiaba"))
{
MsgBox, Você escreveu Abacaxi ou Goiaba!
}


Perceba que como usamos o operador OR (que poderia se escrito como ||), a condicional externa agora entende que seu valor pode ser Verdadeiro se qualquer das duas condicionais internas forem verdadeiras. (Coloquei as duas condicionais internas entre parênteses internos, você percebeu?)

E o que acontece se tentar agora substituir no código acima o OR por AND?

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If ((Senha_Digitada = "Abacaxi") AND (Senha_Digitada = "Goiaba"))
{
MsgBox, Você escreveu Abacaxi ou Goiaba!
}


O código acima nunca poderá apresentar a MsgBox!

Isto ocorre porque o valor inserido não tem como ser Abacaxi e Goiaba ao mesmo tempo.

Mas veja que há situações onde duas condicionais podem ser verdadeiras ao mesmo tempo. O código abaixo executa a caixa de texto se o usuário inseriu a senha abacaxi e se o dia de hoje (do mês) for diferente de 01 (Usamos A_DD aqui, que é uma variável embutida. Você lembra dela? usamos ela no tutorial III).

Code: [Select all] [Download] GeSHi © Codebox Plus

InputBox, Senha_Digitada, Senha, Digite a senha correta abaixo:
If ((Senha_Digitada = "Abacaxi") AND !(A_DD = "01"))
{
MsgBox, Você escreveu Abacaxi e hoje não é o primeiro dia do mês!
}


:arrow: Você pode alterar o código acima para verificar outros dias do mês ou outras condições. Teste sempre as alterações e veja o que funciona e o que não funciona em cada caso. Se tiver dúvidas, não se esqueça que pode perguntar abaixo ou no fórum Eu Preciso de Ajuda! :thumbup:

:arrow: Podemos escrever uma condicional maior com quantas condicionais menores quisermos usanso AND e OR, mas é importante ter em mente que condicionais muito longas costumam dificultar nossa compreensão da lógica de execução. Prefira sempre deixar o seu código o mais simples possível e use as outras ferramentas diponíveis (Como o Else If (Expression) e o Else) para que tudo fique mais fácil de ler.


6. Comandos condicionais e outras condicionais em AutoHotkey

Além do If (Expression), o AutoHotkey possui alguns comandos condicionais e outras funcionalidade que operam condicionais de modo a facilitar ao programador. De uma maneira geral, todos possuem a palavra If seguida de outra palavra que indique o que será testado pela condicional. Um exemplo é o comando IfWinActive. Este comando verifica se (If) a janela (Win) alvo está ativa (Active). O código abaixo, por exemplo, só exibe uma caixa de texto se após 10 segundos do início da execução, uma janela do Bloco de Notas estiver ativa.

Code: [Select all] [Download] GeSHi © Codebox Plus

Sleep 10000
IfWinActive, ahk_class Notepad
{
MsgBox, Uma janela do Bloco de Notas está ativa!
}


Como este tutorial já está longo, não entraremos em detalhes sobre todos os comandos If. Se você desejar, não esqueça que pode procurar no índice de comandos do AutoHotkey por outros comandos que contenham If em seu nome se você quiser conhecer os outros comandos que implementam condicionais no AutoHotkey.


7. Ternário (operador de condicional dentro de expressões)

Como um adendo neste tutorial cabe destacar que é possível executar condicionais dentro de expressões matemáticas. Para isso, usamos o ternário ?:. Este operador normalmente dificulta bastante a leitura do script, mas tem a vantagem de reduzir a quantidade de caracteres escritos. Não recomendo seu uso para iniciantes do AutoHotkey, e mesmo aos avançados, somente se a vantagem de reduzir o tamanho do código for de grande valor. A forma de escrita do operador é conforme abaixo (lembrando que só pode ser usado dentro de expressões!)

Code: [Select all] [Download] GeSHi © Codebox Plus

Alguma_Variavel := ((3 = 3) ? (Var := "sim") : (var := "não"))
msgbox % var


O código acima faz o seguinte. Implementei a expressão de inserir valores de forma matemática na variável Alguma_Variavel somente para pode escrever o ternário, pois este necessita estar dentro de uma expressão matemática. Depois, escrevi o ternário que diz o seguinte: Se 3 for igual a 3, então Var terá o valor sim inserido nela, mas do contrário (ou seja, se 3 não for igual a 3), o valor inserido será não.

Veja que com o ternário, tudo foi escrito em uma linha só, que contém tanto uma forma de If quanto uma forma de Else. A sintaxe do ternário é esta:

(Condicional) ? (Expressão a executar se Verdadeiro) : (Expressão a executar se Falso)

:arrow: É costume colocar o ternário dentro de um novo nível de parêntesis para facilitar um pouco a leitura do mesmo. Portanto, o ternário vazio costuma ficar assim (() ? () : ()) e depois são adicionados os componentes das expressões em cada parêntesis interno.

É também comum, já que o ternário tem que estar dentro de uma expressão matemática, encontrar linhas de ternários que iniciam simplesmente com um forçar de expressão.

% () ? () : ()

8. Considerações Finais

E assim chegamos ao fim deste tutorial. Espero que tenham gostado, pois aprendemos muita coisa nele :thumbup:

Com os conhecimentos adquiridos nestes quatro tutoriais iniciais, saiba que você já é capaz de escrever vários programas em AutoHotkey. Para fazer isso, basta observar a sempre a ordem de execução dos comandos e as condicionais escritas, bem como o que cada comando faz (pois cada um é um pequeno passo da execução do programa).

:arrow: É importante destacar que é possível escrever condicionais sem blocos de execução, mas não recomendo isso. Se você escrever uma condicional sem um bloco de execução, a condicional vai operar somente sobre a linha subsequente do script. Isto pode diminuir o número de linhas escritas, mas diminui também a organização e facilidade de leitura do script. Quanto mais legível for o seu script, melhor será para você trabalhar com ele e mais fácil será para os outros lhe ajudarem a resolver algum problema que venha a surgir. Você percebeu que dentro dos blocos de códigos, escrevi os comandos dando alguns espaços antes do nome deles? Isto se chama indentação e facilita muito a leitura do script. Se o script tiver mais de um nível de blocos de execução (e scripts complexos normalmente tem), esta forma de organização das linhas ajudará muito na leitura do mesmo.

Fiquem todos na paz e sigamos em frente com a aprendizagem da programação! :thumbup:
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

09 Apr 2018, 11:15

Reservado.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

16 Apr 2018, 12:11

V. Tutorial Básico de Funções e Labels

Olá :angel:

Neste quinto tutorial, vamos investigar o conceito de função, e como as funções são implementadas no AutoHotkey para permitir ao programador escrever seus programas de forma mais fácil.

Vamos lá? :thumbup:

1. Função: o que é isso?

Quando falamos de função, estamos falando de um conceito matemático que foi adotado pelas linguagens de programação. Uma função é essencialmente uma fórmula matemática que pode realizar um mesmo trabalho conhecido por nós em diferentes valores que podemos inserir como parâmetros de um comando.

Um exemplo matemático de função é este: f(x) = 2x + 5

A função possui dois momentos distintos: Um no qual definimos ela (ou seja, criamos o seu corpo, escrevendo o trabalho que será feito), como por exemplo o f(x) = 2x + 5 e um segundo momento onde chamamos a função definindo valores para os seus parâmetros (que é onde pedimos que ela realize o trabalho que está programada para realizar), como por exemplo f(4), cujo resultado seria 13 (afinal, 2 x 4 + 5 = 13).

:arrow: No AutoHotkey, o conceito é bem parecido, mas a sintaxe do corpo de uma função é um pouco diferente da sintaxe matemática, e pode ser vista abaixo:

Code: [Select all] [Download] GeSHi © Codebox Plus

NomeDaFuncao(NomeDoParametro1, NomeDoParametro2)
{
; Aqui vão as linhas que trabalham os Parametros da função. São linhas de códigos normais, que podem ser comandos, outras funções e etc. Os parâmetros podem ser referidos nestas linhas como variáveis com os nome que colocamos acima.
Return ExpressãoMatemática ; Aqui vai uma expressão matemática que trará a resposta da função, ou seja, o resultado final da chamada.
}


O exemplo mais básico de função em AutoHotkey talvez seja uma função de soma, que na linguagem do AutoHotkey, pode ter sua definição escrita assim:

Code: [Select all] [Download] GeSHi © Codebox Plus

Soma(Numero1, Numero2)
{
Return Numero1 + Numero2
}


O código acima é o que chamamos uma definição de função (ou o corpo da função). Veja que Numero1 e Numero2 são duas variáveis, que definimos como sendo os parâmetros da nossa função. Isso significa basicamente que a função Soma é capaz de somar quaisquer dois números que lhe apresentemos. O corpo de uma função é normalmente colocado na parte de baixo do script, sempre depois do primeiro comando Return do script (o comando Return é o que limita uma seção de código, criando uma pausa ou retornando a ordem de execução das linhas do script para outra linha). A sintaxe do corpo da função pode ser descrita textualmente assim:

Primeiro vem o Nome da função (que segue as mesmas regras de nomenclatura de variáveis, ou seja, nada de espaços, e quase nenhum símbolo ou acento), seguido de parêntesis (onde se inserem os parâmetros da função, separados por vírgula e escritos na ordem em que a função será chamada), seguido de um bloco de códigos com as linhas de códigos que executaremos quando esta função for chamada.

Opcionalmente, neste bloco de códigos, teremos uma linha que se inicia com o comando Return. O comando Return quando dentro de uma função tem um segundo propósito além de delimitar o fim do corpo da função: Ele pode conter em seguida uma expressão cujo resultado será a resposta da função quando a chamarmos.

Assim, um exemplo de script completo com uma definição de função e três chamamentos distintos a ela pode ser visualizado abaixo.

Code: [Select all] [Download] GeSHi © Codebox Plus

Msgbox % Soma(3,9)
Msgbox % Soma(4, 13)
Msgbox % Soma(41, 18)
Return

Soma(Numero1, Numero2)
{
Return Numero1 + Numero2
}


Execute o código acima e veja o que acontece. Você viu que as MsgBox apresentaram o resultado da soma dos números que colocamos entre parêntesis? Isso ocorreu porquê a chamada à função retornou a soma dos números, graças a linha Return Numero1 + Numero2 no corpo da função.

:arrow: Importante ! O corpo da função deve sempre ser escrito em uma linha ABAIXO da linha de chamamento da função. Inverter esta ordem trará um erro ao executar o script. Também é muito importante que o corpo da função seja colocado depois de um comando Return do script, de modo que fique em uma seção de execução separada.

O chamamento de uma função faz com que a ordem de execução das linhas do script se altere: ela pula da linha de chamada para o corpo da função, executando-o com os parâmetros informados na chamada. Depois que todas as linhas do corpo da função são executadas (ou a execução encontra alguma linha de comando return), a ordem de execução pula de volta para a linha subsequente à linha da chamada e continua dali. Por isso é importante colocar o corpo das funções em separado (abaixo) do restante do script.

2. Funções: para que servem?

Se você entendeu o que fizemos no item 1, talvez esteja se perguntando: mas porquê não somar os números direto nas linhas de MsgBox? Bom, temos algumas razões para isso. A primeira razão é que este foi um exemplo básico. Normalmente, as função executam trabalhos que precisam de várias linhas de códigos. Com uma função, você pode escrever essas linhas apenas uma vez e fazer com que o conjunto delas seja chamado integralmente em cada chamada da função (cada chamada só toma 1 linha). Dessa forma, a função implementa o que chamamos de reutilização do código, e ajuda a organizar e desenvolver o script. Além disso, a função tem um nome que, via de convenção, é uma dica para o que aquela função faz. Isso permite, entre outras coisas, que um trabalho complexo (criar um Excel) seja dividido em trabalhos menores, mesmo que ainda sejam grandes demais para uma única linha de código (como CriarATelaDoprograma(), ou ainda AtualizarAsFormulasInseridas(), que são tarefas com várias linhas cada). Também vale a pena destacar que a facilidade de reutilização do código atribuída às funções permite que as funções sejam compartilhadas entre scripts e até mesmo entre desenvolvedores.

:arrow: Você sabia que os fórums do AutoHotkey têm uma sala com milhares de funções escritas por usuários, e que essas funções podem ser usadas por você para criar programas complexos de forma rápida e organizada? Esta sala pode ser conferida assim que você terminar este tutorial neste link. Também temos uma sala para funções desenvolvidas por usuários falantes de português, e embora tenha menos opções no momento, você poderá conferi-la neste outro link e até mesmo criar tópicos lá para compartilhar suas próprias funções conosco!

Vejamos um exemplo de função que utilizo regularmente para organizar meus códigos, reutilizá-los e ainda reduzir o número de linhas do script. Suponha que eu tenha um campo para o usuário digitar um número. Quero multiplicas este número por 30. No entanto, sei que como as convenções de escrita são diferentes aqui e nos Estados Unidos, este número pode acabar sendo escrito separado por vírgula, separado por ponto, pode ter ponto entre as unidades de milhares, ou ainda não ter ponto nenhum. O AutoHotkey trabalha com número no formato: sem pontos de milhares e com pontos nos decimais.

:arrow: Como fazer para deixar o AutoHotkey somar dois números que podem ter sido escrito tanto no formato americano quanto no formato brasileiro?

O código abaixo simplesmente não funciona!

Code: [Select all] [Download] GeSHi © Codebox Plus

MsgBox % 1.035,37 + 4002.32 ; Esta linha de soma NÃO FUNCIONA pois os números estão em desacordo com o formato adotado pelo AutoHotkey para números e decimais !


Mas não se preocupe. Para somarmos estes dois números só temos que primeiro trabalhá-los para o formato adequado, e faremos isso usando uma função!

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



Você percebeu que usamos aspas entre os valores? Isso ocorreu porque já que o AutoHotkey não os reconhece como números válidos ainda, tenho que tratá-los como texto. Já o resultado da função está no formato adequado e portanto pode ser somado diretamente. Esta função pode ser utilizada com várias situações que envolvam possíveis modelos de números brasileiros ou americanos e é muito útil. Se você precisar, pode copiá-la para usar em algum script seu.

O exemplo abaixo usa extensivamente a função acima e nele você poderá ver como usando a função estamos basicamente reutilizando as linhas de código escritas na função, de modo que não precisamos ficar copiando e colando as muitas linhas de comandos StringReplace e StringGetPos, pois apenas a chamada da função é repetida com os valores diferentes.

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



3. Funções embutidas no AutoHotkey

O conceito de função é tão útil que alguns "comandos" do AutoHotkey são escritos em forma de funções, que podem ser chamadas sem que escrevamos nós mesmos o corpo delas. É o que chamamos de funções embutidas. Algumas das vantagens dessas funções em relação aos comandos normais são as seguintes:

  • 1. Todos os parâmetros das funções são escritos em sintaxe de expressão matemática, assim não é preciso testar ou supor se o parâmetro espera outro tipo de escrita;
  • 2. As funções podem ser escritas dentro de expressões matemáticas, enquanto que os comandos tem que ser escritos em linhas próprias;
  • 3. As funções permitem chamadas dinâmicas, de modo que podem ser usadas, por exemplo, para obfuscar um script ou para criar uma única linha que chama funções diferentes baseando-se em alguma condicional de execução

Por este motivo, os desenvolvedores do AutoHotkey estão adicionando funções equivalentes à maioria dos comandos, e espera-se que a partir da versão 2.0 do AutoHotkey, a sintaxe dos comandos normais seja integralmente substituída pela sintaxe de funções.

:arrow: Você percebeu que a página de lista de comandos do arquivo de ajuda contém vários comandos terminados em parêntesis? Isso significa que estes comandos estão implementados na forma de funções.

Para exemplificar este item, vamos utilizar agora uma função embutida do AutoHotkey chamada SubStr(). Esta função permite que retiremos um pedaço de uma frase, determinando simplesmente a posição e o número de caracteres que vamos tirar de lá. Suponhamos que eu tenha por exemplo a frase "João comeu uma maçã verde que quase não cabia em sua mão". Esta frase é bastante longa. Se eu quisesse exibí-la em uma tela, poderia ter problemas. Talvez seja melhor cortá-la, exibindo apenas os primeiros 20 caracteres. Farei isso usando o comando Substr().

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 := "João comeu uma maçã verde que quase não cabia em sua mão"
MsgBox % SubStr(Var1, 1, 20)


Este tipo de ação pode parecer simples, mas é muito útil quando não sabemos os valores que estarão na variável, mas sabemos que só podemos (ou só queremos) trabalhar com uma parte deles.

4. Variáveis Locais, Globais e Super-Globais

Quando estamos programando funções em AutoHotkey, é importante entendermos que as variáveis dentro de funções são do tipo local por padrão. Isso significa que, via de regra, as funções não "enxergam" variáveis que estejam fora do seu corpo (ou seja, fora do bloco que contém a definição da função). Como exeplo, imagine que, por padrão, ainda que uma variável possua um valor definido na primeira linha do script, ela vai estar vazia dentro do corpo da função. Veja o código abaixo:

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 := "Abacaxi"
Funcao()
Return

Funcao()
{
MsgBox % "Eu gosto de " Var1
}


Se você executar o código acima, verá que a palavra abacaxi NÃO aparece na MsgBox. Isso ocorre porque dentro de uma função todas as variáveis são locais a princípio. Em outras palavras, se eu quisesse usar a variável Var1 nessa função, eu teria que criar um parâmetro e passá-la através dele, ou então definir novamente o seu valor dentro da própria função. O problema da primeira opção é que se estivermos trabalhando com muitas variáveis, vamos terminar com muitos parâmetros na função e o problema da segunda opção é que as duas variáveis seriam para todos os efeitos distintas, o que significa que uma alteração posterior em Var1 fora da função NÃO atualizaria o Var1 dentro da função.

Para resolver esse problema, podemos definir que as variáveis sejam globais ou super gobais.

Variáveis Globais são enxergadas dentro e fora de uma função. Para definir que uma variável é global, basta escrever o nome global seguido de espaço antes do nome da variável, logo no início do corpo da função.

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 := "Abacaxi"
Funcao()
Return

Funcao()
{
Global Var1
MsgBox % "Eu gosto de " Var1
}


Pronto! agora o código acima mostra a palavra abacaxi, e além disso, se a variável for alterada fora da função, também será alterada dentro da função.

Além disso, podemos definir que todas as variáveis de uma função sejam globais. Para fazer isso, basta escrever a palavra Global sozinha na primeira linha do corpo da função.

Code: [Select all] [Download] GeSHi © Codebox Plus

Var1 := "Abacaxi"
Funcao()
Return

Funcao()
{
Global
MsgBox % "Eu gosto de " Var1
}


No código acima, não precisei dizer que Var1 era global, pois como defini que todas as variáveis fossem globais nesta função, Var1 está automaticamente conectada com a Var1 externa, visto que é também global agora (como qualquer outra variável que existisse no script).

Outra opção que temos é criar variáveis super-globais. Este tipo de variável é uma variável externa que é acessível a todas as funções do script, independente de se declará-la global em cada função. É obtida declarando uma variável como global fora de qualquer corpo de função e logo no início do script.

Code: [Select all] [Download] GeSHi © Codebox Plus

Global Var1
Var1 := "Abacaxi"
Funcao()
Return

Funcao()
{
MsgBox % "Eu gosto de " Var1
}


:arrow: A razão das variáveis serem locais por padrão nas funções é que estas têm o propósito de serem reutilizadas em vários scripts, uma vez que executam trabalhos pré-definidos e indicados pelos seus nomes. Assim, um programador que cole uma função em seu script não precisa se preocupar em ter problemas com variáveis do seu programa sendo atualizadas pela função. Por falar nisso, você já começou a planejar como vai montar sua biblioteca de funções depois deste tutorial? :thumbup:

5. Outras possibilidades das funções em AutoHotkey

As funções em AutoHotkey possuem algumas opções que podem nos ajudar a escrever o código. A primeira é que os parâmetros das funções podem ser escritos com valores padrão. Isso significa que se o usuário quiser, pode mudar esses valores, mas se não quiser fazê-lo, ainda assim a função executará usando o valor padrão. Você percebeu que a função TrabalharFormato() que usei no item 2 possuía dois parâmetros, mas nós chamados elas várias vezes fornecendo apenas 1? Isso foi possível porque no corpo da função definimos que o parâmetro2 teria um valor padrão igual a 2.

Outra opção que utilizei na função TrabalharFormato() foi a opção ByRef no primeiro parâmetro. Esta opção permite que passemos à função o nome de uma variável (ao invés de passar os valores dela). Isto permite que a função trabalhe com aquela variável diretamente (pois do contrário, como os parâmetro tem sintaxe de expressão matemática, as variáveis seriam automaticamente resolvidas para os seus valores).

6. Labels

Assim como as funções, o AutoHotkey também implementa o conceito de labels (cuja tradução seria "rótulos"). As labels são porções de códigos que podem ser chamadas a qualquer momento e implementam uma versão mais baixo nível de reutilização do código que as funções. As labels podem ser utilizadas para organização do script e também são utilizadas na criação de controles de telas no AutoHotkey (botões, etc).

Para definir uma label basta escrever seu nome, sem espaços, seguido de dois pontos. Uma label promove um novo início da ordem de execução, de modo que uma vez chamada, a ordem de execução "pula" para a primeira linha da label e continua dali em diante. Se a ordem de execução encontrar uma linha com o comando Return, no entanto, a ordem de execução pulará de volta à linha subsequente ao chamamento da label e continuará dali em diante (exceto se a chamada ocorreu através de Goto, o que não se recomenda mais fazer).

Veja no script abaixo o funcionamento de uma label:

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



Veja que na linha 3, chamamos a label LabelABC através do comando Gosub. Por este motivo, a ordem de execução pula para a primeira linha da label e continua ali, até encontrar o Return. Quando isso acontece, a ordem de execução então pula novamente para a seção externa da label, voltando para a primeira linha subsequente ao chamamento da label. Você pode conferir isso executando o código acima e prestando atenção na ordem de exibição das MsgBox.

:arrow: O comando return também serve para delimitar o final da chamada "seção de auto-execução" do script. Esta seção é o que chamamos de "fora da label" no código acima. Ela é a seção normal do script, e se inicia na primeira linha do script. Quando colocamos um return, estamos definindo um fim para a nossa seção atual e se este comando estiver na seção de auto-execução, será o final dela também. O objetivo de definir o final dessa seção é a organização, uma vez que funções e labels são melhor organizadas se os seus corpos estiverem fora da seção de auto-execução. Por este motivo, coloque sempre os corpos das funções e labels abaixo do primeiro return do script, de modo a organizar estas seções em separado da seção principal do script. Isso vai permitir que você observe com maior clareza o fluxo da ordem de execução do script.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

17 Apr 2018, 11:04

Reservado.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

17 Apr 2018, 11:04

VI. Tutorial Básico de Telas em AutoHotkey

Oi :angel:

Agora que já aprendemos muitos conceitos necessários para criar programas mais complexos, vamos finalmente explorar neste nosso sexto tutorial o conceito de telas (ou janelas) do Windows. Você sabia que o AutoHotkey é capaz de criar telas detalhadas e lhe permite gerenciar as mesmas da forma que melhor convier ao seu projeto?

Vamos em Frente! :thumbup:

1. O que são as telas e para que servem

Quando pensamos em um programa windows, sempre nos vem à mente uma tela com botões, menus, imagens, icones e mais uma série de controles que nos permitem operar o software em questão. Já vimos, no entanto, no tutorial III, que nem todo programa possui uma tela, mas como programadores, podemos fazer com que nossos programas as tenham se quisermos.

A próposito, você sabe o que são as telas? As telas são uma interface gráfica entre o usuário e a máquina (e chamamos isto de GUI, que em inglês é Graphical User Interface). Isso significa basicamente que as telas são o que permite a comunicação do usuário com o programa de uma forma gráfica (ou seja, através de imagens). Antes desse tipo de tela, toda comunicação entre usuário e máquina (ou software) era feita através de códigos escritos (ou seja, comandos), de uma forma muito semelhante a como nós programamos os nossos scripts.

Com a implementação das telas, os computadores passaram a ser tão fáceis de usar que as pessoas comuns começaram a comprá-los para suas casas e usá-los para trabalho e lazer.

Assim, podemos dizer que as GUIs (ou seja, as telas) nos permitem criar ambientes intuitivos para que o usuários possam controlar os programas da forma como permitimos que eles os controlem, sem terem de fazer um curso específico para isso.

2. E como são criadas essas telas?

As telas que vemos comumente nos computadores e celulares são basicamente criadas pelo sistema operacional daquela máquina, através de comandos enviados à eles pelos programas. Em outras palavras, é o Windows quem cria as telas do AutoHotkey (e de qualquer outro programa que rode nele). No entanto, essas telas são criadas mediante comandos e especificações passadas pelo AutoHotkey, que é quem comunica quais botões, campos, imagens e etc. que a tela vai ter, e onde eles serão posicionados. Chamamos estes componentes da tela de Controles da tela.

:arrow: Então basicamente quando queremos criar uma tela, só temos que usar o comandos adequados para dizer ao AutoHotkey como criar cada um dos componentes da tela, e como configurá-los adequadamente para fazerem o que queremos que eles façam. O AutoHotkey cuidará então de levar esses comandos traduzidos ao Windows (o sistema operacional) para que as telas sejam criadas.

Vamos para a prática? :thumbup:

3. Pensando a primeira tela

Antes de criar a primeira tela, precisamos pensar no que essa tela vai conter. O que queremos que ela exiba ao usuário? Uma tabela? uma foto? um botão? O que queremos que o programa faça quando esse usuário apertar o botão? Convém primeiramente imaginar e até desenhar esta tela em um papel para entender como ficaria cada um dos controles na sua posição adequada.

Imagine que eu queria criar uma tela que funcione como uma agenda de contatos. Assim, ela deve ter uma tabela de nomes, um campo para o usuário escrever os nomes e um botão para o usuário adicionar o nome escrito na tabela. Desenhando a tela em um papel (ou no computador), eu imagino a seguinte disposição gráfica dos controles:

TELA DE NOMES.png
TELA DE NOMES.png (3.49 KiB) Viewed 87 times


Após olhar para o desenho um pouco, percebo que seria interessante colocar também o telefone desse contato (afinal, a tela tem que funcionar como agenda). Assim, desenho isso também.

TELA DE CONTATOS.png
TELA DE CONTATOS.png (3.82 KiB) Viewed 87 times


Agora vejo que está bom. Se ainda faltasse algo, bastava ir adicionando até que a tela esteja bem planejada. Toda tela tem que ser bem clara para o usuário e o mais intuitiva possível.

4. Criando a primeira tela

Agora que já tenho um projeto de tela completo, com todos os controles nas suas devidas posições, chegou a hora de programarmos a tela em si. No AutoHotkey o principal comando que gera os controles de tela é o comando GUI. Exibimos uma tela inicial ao chamarmos o comando GUI com o primeiro parâmetro Show, seguido de um parâmetro de opções com a altura e a largura da tela que queremos criar. A largura será um número de pixels que escreveremos no segundo parâmetro do comando GUI juntamente (e após) a letra h (h vem de height, que em inglês significa altura). Já a largura, será também um número de pixels que escreveremos também no segundo parâmetro, mas será colocada juntamente (e após) a letra w (w vem de width, que em inglês significa largura). Já no terceiro parâmetro do comando GUI, colocamos o nome (ou título) da tela.

Você pode ver tudo isso no código abaixo. Execute-o para criar uma tela em branco com 600 pixels de largura e 400 pixels de altura.

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, Show, w600 h400, Tela de Nomes


Tela em Branco.png
Tela em Branco.png (3.55 KiB) Viewed 83 times


Agora que já criamos uma tela vazia, devemos colocar os demais controles. Para fazer isso, só temos que seguir uma regra de ouro: todos os comandos de criação de controles serão escritos ANTES do comando Show.

Assim, para adicionar um botão, por exemplo, basta usar o comando GUI seguido do primeiro parâmetro Add e do segundo parâmetro Button.No terceiro parâmetro, escolhemos a posição e opcionalmente a altura e largura desse botão. Todas estas coordenadas são relativas à parte superior-esquerda da tela. Temos assim a coordenada X, que significa a posição horizontal e a coordenada Y, que significa a posição vertical. Assim, se eu colocar uma posição x de 50, o meu controle será posicionado a partir do 50º pixel da tela que eu criei. Já se eu colocar uma posição Y de 100, o meu controle será posicionado a partir do 100º pixel da tela que eu criei.

Se a minha tela tem 600 pixels de largura e eu quero colocar um controle no meio, parece óbvio que a posição x deve ser de 300 pixels. Mas se quisermos centralizar perfeitamente, temos que descontar ainda descontar a metade da largura do controle que vamos criar. Vou criar um botão com 60 pixels de largura, assim, calculo a metade disso e deduzo de 300. O resultado é uma posição X de 270 onde vou colocar o botão.

O mesmo procedimento pode ser feito com a posição Y para centralizar o botão, lembrando que agora a dimensão relevante é a altura (logo, 400 de altura para a tela e um valor à escolha para o botão). O meu botão terá 20 pixels de altura, logo, deduzo a metade da altura do botão da metade da altura total da tela e assim consigo centralizar o controle.

O quarto parâmetro do comando que cria o botão é o nome do botão, que no caso, será Salvar.

Você pode ver tudo isso no código abaixo.

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, Add, Button, x270 y190 w60 h20, Salvar
Gui, Show, w600 h400, Tela de Nomes


Execute o código acima para ver como a tela agora será criada com um botão centralizado.

Porém, vamos lembrar que conforme o nosso desenho, o botão não fica no centro. Na verdade, ele fica mais embaixo e na parte direita da tela. Para colocar o botão mais embaixo, basta aumentar o número do Y e para colocá-lo mais à direita, basta aumentar o número do X (o inverso também funciona para mandar o controle mais para a esquerda ou mais para cima).

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, Add, Button, x400 y260 w60 h20, Salvar
Gui, Show, w600 h400, Tela de Nomes


Tela com botao.png
Tela com botao.png (4.02 KiB) Viewed 83 times


Ok, já temos nosso botão na posição correta (ou próximo dela). Cabe agora criar o campo para o usuário escrever. Farei isso chamando novamente o comando GUI, seguido do parâmetro Add, seguido do parâmetro Edit e depois das coordenadas do controle.

Como quero que ele fique à esquerda do botão e na mesma altura, eu vou repetir a coordenada Y e vou diminuir a coordenada X. Devo lembrar ainda novamente que todos os controles devem ser criados ANTES do comando show.

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, Add, Edit, x280 y260 w100 h20
Gui, Add, Button, x400 y260 w60 h20, Salvar
Gui, Show, w600 h400, Tela de Nomes


Tela com campo.png
Tela com campo.png (4.01 KiB) Viewed 83 times


Quase bom! Agora vamos criar um texto para que o usuário saiba que o campo que criamos é para inserção do nome. O comando é novamente o GUI, seguido do parâmetro Add, seguido do parâmetro Text, seguido das coordenadas da posição do texto e finalmente seguido do parâmetro que contém o texto em si.

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, add, Text, x280 y240, Nome
Gui, Add, Edit, x280 y260 w100 h20
Gui, Add, Button, x400 y260 w60 h20, Salvar
Gui, Show, w600 h400, Tela de Nomes


Execute o código acima e veja como já criamos três controles e exibimos a nossa janela. Veja também que coloquei uma coordenada Y de 240 no texto. Isso foi feito para que ficasse somente um pouco acima do campo Edit, que está na posição Y260.

Agora vamos colocar outro campo para o usuário adicionar o telefone. Será basicamente a mesma coisa que já fizemos antes, um comando para adicionar um controle Edit e um comando para adicionar um controle de texto (com o nome do campo). Todos os controles devem ser criados antes do comando Show.

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, add, text, x280 y300, Telefone
Gui, add, Edit, x280 y320 w100 h20
Gui, add, Text, x280 y240, Nome
Gui, Add, Edit, x280 y260 w100 h20
Gui, Add, Button, x400 y260 w60 h20, Salvar
Gui, Show, w600 h400, Tela de Nomes


Quase tudo indo conforme o planejado. Agora vamos fazer o seguinte: quero colocar os controles mais ao centro. Isso significa basicamente que devo levar todos mais à esquerda. Se a posição X (que é horizontal) é contada de forma crescente da esquerda para a direita, então basta diminuir o número X em todos os controles para movê-los em conjunto para à esquerda. Vou diminuir a mesma quantidade para manter o alinhamento entre os controles!

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, add, text, x230 y300, Telefone
Gui, add, Edit, x230 y320 w100 h20
Gui, add, Text, x230 y240, Nome
Gui, Add, Edit, x230 y260 w100 h20
Gui, Add, Button, x350 y260 w60 h20, Salvar
Gui, Show, w600 h400, Tela de Nomes


Está ficando bom. Agora falta criar a tabela que ficará encima desses controles. Para fazer isso, vou usar o comando GUI, seguido do parâmetro Add, seguido do parâmetro ListView. O próximo parâmetro será o das coordenadas e depois, será uma lista separada pelo símbolo | (ou pipe) que conterá os nomes das colunas. Como temos duas colunas (nome e telefone) o código ficará assim:

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, add, ListView, x230 y100 h120 w180, Nome|Telefone
Gui, add, text, x230 y300, Telefone
Gui, add, Edit, x230 y320 w100 h20
Gui, add, Text, x230 y240, Nome
Gui, Add, Edit, x230 y260 w100 h20
Gui, Add, Button, x350 y260 w60 h20, Salvar
Gui, Show, w600 h400, Tela de Nomes


Tela com Tabela.png
Tela com Tabela.png (5.32 KiB) Viewed 83 times


Ok, já temos basicamente tudo que precisamos na nossa tela. Mas ainda faltam alguns ajustes (posições, tamanho, etc). O primeiro desses ajustes é o das colunas da ListView (a tabela que criamos). Para ajustá-la, usarei uma função embutida chamada Lv_ModifyCol(). Devo usar esta função APÓS criar a ListView (logo, numa linha seguinte). O primeiro parâmetro desta função é o número da coluna que quero modificar. Já o segundo parâmetro é o novo tamanho para aquela coluna.

Como o nome normalmente é maior que o telefone, e a nossa listview tem 180 pixels de largura (coordenada w), vou colocar 100 pixels de largura na coluna nome. Já a coluna telefone, pode ser um pouco menor. Vou colocá-la como tendo 70 pixels de largura (não vai ser 80, pois se eu colocar uma coluna muito próxima à largura total da listview, será criada uma barra para escorregar a visão da tabela).


Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, add, ListView, x230 y100 h120 w180, Nome|Telefone
Lv_ModifyCol(1, 100)
Lv_ModifyCol(2, 70)
Gui, add, text, x230 y300, Telefone
Gui, add, Edit, x230 y320 w100 h20
Gui, add, Text, x230 y240, Nome
Gui, Add, Edit, x230 y260 w100 h20
Gui, Add, Button, x350 y260 w60 h20, Salvar
Gui, Show, w600 h400, Tela de Nomes


Ok, com isso nossa tela está praticamente completa! Mas olhando bem, os controles ficaram bem folgados na tela. Acho melhor diminuir um pouco o tamanho da tela, mas para fazer isso tenho que ter em mente a posição dos controles!

Lembre-se sempre que a posição é um número crescente relativo ao pixel superior-esquerdo da tela. Tendo isso em mente, diminua o mesmo número do X de cada controle para que eles possam ficar todos mais à esquerda sem bagunçar suas distâncias. Da mesma forma, diminua o mesmo número do Y de cada controle para que eles possam ficar todos mais acima sem bagunçar as distâncias. No final, diminua a tela mudando no comando Show a largura e a altura.

Code: [Select all] [Download] GeSHi © Codebox Plus

Gui, add, ListView, x20 y20 h120 w180, Nome|Telefone
Lv_ModifyCol(1, 100)
Lv_ModifyCol(2, 70)
Gui, add, text, x20 y220, Telefone
Gui, add, Edit, x20 y240 w100 h20
Gui, add, Text, x20 y160, Nome
Gui, Add, Edit, x20 y180 w100 h20
Gui, Add, Button, x140 y180 w60 h20, Salvar
Gui, Show, w240 h300, Tela de Nome


tela final.png
tela final.png (4.23 KiB) Viewed 83 times


Ufa! agora sim! está pronta a tela! :bravo:

Tudo que falta agora é programar as ações que serão executadas quando os controles forem operados. Vamos lá?

5. Configurando as ações da primeira tela

Agora que já temos a tela criada, vamos passar para o passo seguinte: configurar as ações dos controles. No item anterior vimos uma dica muito importante sobre a ordem de execução dos comandos de criação de tela: todos os comandos de criação de controles são escritos antes do show.

Agora vamos ver outra máxima para nos ajudar com as ações: todos os comandos de ações dos controles escritos DEPOIS do show. Isso signfica que na linha em que escrevemos os controles, escreveremos apenas a chamada para essas ações, mas os códigos a serem executados virão depois do show.

Em primeiro lugar, vamos entender que todo comando (ou quase todo) pode ter associado a ele no parâmetro de opções (o mesmo parâmetro onde escrevemos as coordenadas) uma g-label. A g-label nada mais é doque o nome de uma label (vimos o que são labels no tutorial V) que indicamos para ser executada quando o controle for pressionado ou operador pelo usuário. Colocamos uma letra g antes do nome da label nas opções do controle (por isso chamamos de g-label), mas a label em si não tem essa letra g no nome.

Para exemplificar, vamos criar uma label simples que vai ser chamada quando clicarmos no botão salvar. Essa label vai inicialmente mostrar uma MsgBox (apenas para exemplo). Para configurar que o botão chame esta label, vamos nas opções dele e colocamos o nome dessa label precedido da letra g.

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



Execute o código acima e clique no botão Salvar. Uma caixa de mensagem aparece quando fazemos isso. Se você fechar e clicar de novo, aparecerá outra caixa com a mesma mensagem. Isso acontece porque a label é uma forma de reutilização do código, e é chamada sempre que apertamos o botão.

Muito bem! já conseguimos criar a g-label. E agora?

:arrow: Agora vamos configurá-la para fazer o que realmente queremos que ela faça!

Primeiro, precisamos pensar em que ações devem acontecer quando o usuário clicar em salvar. Ora, preciso que o que ele tiver escrito nos campos seja adicionado na tabela.

Para fazer isso, inicialmente precisamos definir variáveis atreladas aos controles dos campos. Faremos isso colocando uma v-variável nas opções daqueles controles. Da mesmoa forma que a g-label, a v-variável nada mais é do que o nome de uma variável que vai conter o conteúdo do campo (ou seja, o que o usuário digitar) precedida da letra v.

Outro ponto importante é que a v-variável não vai conter os dados automaticamente: Para que a v-variável seja atualizada com os dados do campo, nós precisamos chamar o comando Gui, Submit, Nohide. Isso existe para que possamos controlar quando as variáveis serão atualizadas. Para a maioria dos casos (e para o nosso caso), esse momento é precisamente o momento em que o usuário aperta o botão. Logo, vamos adicionar o comando Gui, Submit, Nohide no início da g-label do nosso botão!

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



Execute o código acima, escreva algo nos campos e depois clique em Salvar. Viu que a MsgBox exibiu o conteúdo digitado nos campos? Você pode até mesmo alterar e apertar salvar de novo, pois as v-Variáveis serão atualizadas com os dados dos campos sempre que o comando Gui, Submit, Nohide for chamado (e ele é chamado no início da g-label atribuída ao botão).

Para concluir o nosso código agora, basta programa a inserção dos dados na tabela (ou seja, no controle ListView). Para fazer isso, usamos a função embutida Lv_Add(). Esta função adiciona uma entrada à ListView padrão do script. Seu primeiro parâmetro é um parâmetro de opções, que deixaremos em branco. Já do segundo parâmetro em diante, colocamos os valores a serem adicionados nas colunas EM ORDEM, do primeiro ao último.

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



Pronto! agora sim nossa tela está completa e funcionando! :dance:

6. Criando múltiplas telas

Agora que já vimos todos os passos envolvidos na criação de uma tela, será muito fácil entender como criar múltiplas telas no AutoHotkey. O conceito básico é que a partir da segunda tela de um mesmo script, todos os comandos referentes a uma tela precisam ser numerados ou nomeadas com a tela correspondente. Comandos que sejam numerados com um 2 vão se referir somente à tela 2, e comandos numerados com um 5 vão se referir à tela 5. Os comandos referentes à primeira tela, no entanto, vão continuar sem numeração!

Assim, vamos criar um novo botão na tela que criamos antes. Este novo botão vai criar a nossa segunda tela. Veja como funciona a numeração de telas subsequentes aqui.

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



Tela 2.png
Tela 2.png (8.43 KiB) Viewed 83 times




7. Fechando telas

É costume pensar que quando o usuário clica no botão X que fica na parte superior direita da tela, a tela é fechada. No entanto, isso não é de todo verdade. O que acontece quando isso ocorre é que o programa recebe um sinal de fechamento de tela e deve decidir o que fazer com ele. Isso existe para que o programador possa configurar ações para ocorrerem antes do fechamento das telas. No AutoHotkey o comportamento padrão é que uma tela onde o usuário clicou no X seja escondida (mas não destruída), mas se existir uma label de nome GuiClose (ou 2GuiClose, 3GuiClose e etc, dependendo de qual tela foi fechada), ela não será escondida (muito menos destruída) e o sinal recebido pelo programa será usado para ativar esta label (de modo que o programador possa escrever na label exatamente o que quer que ocorra naquele momento).

O importante é saber que isso ocorre, para que como programadores não sejamos pegos de surpresa com erros "estranhos". Um exemplo é que se rodarmos uma rotina de criação de tela duas vezes (como fazemos no código do item 6 se clicarmos duas vezes no botão "tela 2") e essa rotina de criação de telas tiver variáveis associadas aos controles, teremos um erro, uma vez que cada variável só pode estar associada a um controle de tela. Assim, ao programar múltiplas telas, com uma delas abrindo as outras, temos de ter o cuidado de programar as labels de fechamento para que as janelas sejam devidamente destruídas quando usuário clicar no X (e também o que mais quisermos que ocorra antes disso, se for o caso).

Como exemplo de rotinas de fechamento, veja como atualizamos o último código do item 6 para exibir uma MsgBox e depois destruir a tela 2 da forma correta. Também coloquei uma label que encerra o programa se o usuário fechar a tela principal (você tinha percebido que isso não estava ocorrendo antes? :lol: )

Code: [Select all] [Expand] [Download] GeSHi © Codebox Plus



8. Considerações Finais

Se você seguiu este tutorial até o fim, deve ter aprendido bastante sobre como funcionam as telas do Windows e do AutoHotkey. Vale lembrar, no entanto, que o assunto é bem extenso, e temos um grande número de outras opções parar criamos nossas telas no AutoHotkey. Você sabia que podemos adicionar outros controle, como uma checkbox (uma caixa que pode ser marcada pelo usuário) e um DropDownList (um campo com valores predefinidos que o usuário seleciona com o mouse)?

Se tiver interesse em aprender mais sobre telas, e ver todas as opções disponíveis, basta verificar o arquivo de ajuda do AutoHotkey na seção GUI ou então na seção Gui Control types (estão em inglês).

Um forte abraço e boa programação! :thumbup:
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

17 Apr 2018, 17:36

Reservado.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

17 Apr 2018, 17:36

VII. Tutorial Básico de Arquivos

Olá mais uma vez :angel:

Parabéns por ter acompanhado esta série até aqui. Neste ponto, saiba que você já adquiriu uma boa noção dos principais elementos necessários para desenvolver um programa. Você sabia que os computadores possuem dois tipos de memória? E que os programas rodam em memória volátil? Isso significa que uma vez terminada a execução do programa, seja pela conclusão normal ou por uma interrupção abrupta, tudo que não foi salvo por ele será perdido. Mas há uma maneira de impedirmos a perda desses dados: salvando eles em arquivos, que são guardados em memória não-volátil (disco rígido). Agora que sabemos criar os programas, está na hora de investigarmos o que são os arquivos de computador, como eles são armazenados e identificados, quais são as suas características, como podemos desenvolver nossos próprios modelos de arquivos e como podemos usar os modelos de arquivos já existentes para guardar nossos dados de forma fácil e rápida.

Venha conosco :thumbup:

1. Arquivos de computador: o que são?

Quando ponderamos a respeito do que são os arquivos de computador, convém talvez lembrar um pouco dos objetos que os inspiraram. Trata-se dos "arquivos" do mundo real, ou seja, aqueles pesados "armários" de escritórios onde podemos abrir as gavetas e pendudar pastas com documentos diversos.

Image

Estes móveis de escritório que contém basicamente o que chamamos coletivamente de arquivos, e servem basicamente para que possamos guardar e classificar documentos diversos, que são individualmente cada qual um arquivo.

:arrow: Arquivar é basicamente armazenar de forma classificada, de modo que fique fácil e rápido encontrar cada documento individual pelo simples fato de que criamos um sistema de gavetas e pastas que implementam uma ordem de endereçamento conhecida por nós. Assim, podemos imaginar o escritório de um médico, por exemplo, onde pode haver em seus módel de arquivos uma gaveta chamada "pacientes", onde foi colocada uma pasta com o nome de cada cliente, e em cada pasta destas foram colocados os documentos daquele respectivo cliente. Assim, se quisermos encontrar o prontuário do cliente "joão", basta nos dirigirmos até aquele móvel, abrir a gaveta de "clientes", procurar pela pasta "joão" e dentro dela encontraremos o prontuário do cliente joão. Esta sistemática de armazenamento endereçado é praticamente a mesma que encontramos em um computador.

2. Arquivo de computador: o que é?

Quando falamos individualmente "arquivo" nos referimos normalmente a um documento armazenado. Este documento, no mundo real, seria um papel com dados escritos, que podem ser lidos e interpretados por uma ou mais pessoas, de forma a proverem informações para aquelas pessoas. É importante destacar que esses dados podem significar algo somente para elas: Se o documento estiver escrito em francês, por exemplo, somente alguém que saiba ler francês poderá tirar informações dali.

:arrow: A diferença entre dados e informações é que os dados não tem sentido por si só: eles precisam ser interpretados para gerar informações para alguém. Podemos dizer, assim, que as informações são dados que foram trabalhados de modo a obter algo útil. Para criar uma analogia com o mundo real, imagine que dados são como tijolos e que informações são como casas. Um serve apenas para construir alguma coisa, já o outro, adquire uma serventia nova: serve de morada. Da mesma forma, é possível construir algo completamente inútil com tijolos (dados inúteis), mas também é possível construir algo de extrema utilidade, como uma casa. Tudo depende da forma como estão dispostos estes dados e de como vamos interpretar essa disposição.

Assim, podemos dizer que um arquivo de computador, assim como um documento em papel, é um conjunto de dados armazenados e endereçados. No mundo da computação, isso significa basicamente que arquivos de computador são coleções de bits (0s e 1s), com início e fim, armazenadas de forma organizada e endereçada, no disco rígido do computador (memória não-volátil, ou seja, que não se apagada facilmente, como quando desligamos a máquina). Um exemplo hipótetico de arquivo poderia ser o que está abaixo:

011011110110110001100001001000000111000001110010011011110110011101110010011000010110110101100001011001000110111101110010

3. Arquivo de computador: como se interpretam os dados?

Agora veja de novo a sequência de bits apresentada no final do item acima por um momento. Se tentarmos tirar alguma informação dela sequência (ou seja, daquele arquivo), provavelmente falharemos. Isso ocorre porque não temos ainda os meios de interpretar estes dados. Estes meios nada mais são do que o conhecimento necessário para enxergar neles alguma informação útil. No mundo da computação, os responsáveis por deter este conhecimento são os programadores que desenvolveram os arquivos, e com isso estes são capazes de desenvolver programas que interpretam estes arquivos.

Assim, imagine que no arquivo acima, o programador que o desenvolveu tenha determinado que os dados deveriam ser interpretados assim: a cada byte (ou seja, a cada sequência de 8 bits, iniciando da esquerda) o valor numérico encontrado se refere a um caractere da tabela Windows-1252 (ANSI).

:arrow: De posse desse conhecimento, o que acontece se tertarmos traduzir os bits da mensagem?

Code: [Select all] [Download] GeSHi © Codebox Plus

01101111 01101100 01100001 00100000 01110000 01110010 01101111 01100111 01110010 01100001 01101101 01100001 01100100 01101111 01110010
111 108 97 32 112 114 111 103 114 97 109 97 100 111 114
o l a p r o g r a m a d o r


Veja que agora conseguimos uma informação! Aquela sequência de caracteres na verdade queria dizer a mensagem "olá programador".

:arrow: Os arquivos de computador são desenvolvidos de forma a facilitar a armazenagem de dados. Estes dados por sua vez, podem ser qualquer coisa, a depender apenas da forma como devem ser interpretados, o que significa que podem significar desde uma sequência de caracteres, até os valores das cores dos pixels de uma imagem, ou até mesmo às mudanças de frequência e amplitude em um sinal sonoro a ser emitido pelas caixas de som. Por isso podemos ter arquivos de texto, arquivos de imagem, arquivos de audio e outros tantos tipos de arquivos!

4. Arquivo de computador: como funciona o endereçamento?

Quando tentamos acessar arquivos de computador, normalmente abrimos as pastas e clicamos no arquivo à nossa escolha. Mas você já percebeu que se você entrar no windows explorer (o programa que se abre quando você abre qualquer pasta) e selecionar uma pasta qualquer e clicar na barra de endereço dela, aparecerá algo como C:\Arquivos de Programas\AutoHotkey ?

Esta sequência de nomes entrelaçados por barras que pendem para trás \ é o endereço daquela pasta que você está olhando. Se você entrar em uma pasta que esteja dentro dessa pasta e olhar novamente o endereço, verá que foi acrescido mais um nível ao endereço apresentado. Ficará algo como
C:\Arquivos de Programas\AutoHotkey\Compiler

É assim que são endereçadas as pastas dentro do computador: primeiro vem a letra da partição do disco, que pode ser C:, seguida de uma barra e depois da pasta principal acessada Arquivos de Programas (que se encontrar imediatamente dentro da pasta do disco C), seguida de uma nova barra e depois da pasta secundária acessada AutoHotkey (que se encontra imediatamente dentro da pasta anterior, ou seja, dentro de Arquivos de Programas), e depois esta sequência de barras e pastas vai se repetir para cada uma das subpastas que tivermos acessado no momento. E no fim, teremos os arquivos, que também têm um endereço que adiciona ao endereço da pasta, mas com uma singela diferença, a ser explicada abaixo.

:arrow: Todo arquivo tem um nome e uma extensão. Os nomes dos arquivos podem conter letras e números, e até alguns símbolos, salvo por barras (de modo a não atrapalhar o endereçamento) e outros símbolos específicos. No fim do nome do arquivo, tem um ponto e segue-se a ele uma quantidade de letras, que normalmente são 3. Esta sequência de letras após o ponto no final do nome do arquivo é o que chamados de extensão.

As extensões dos arquivos são usadas pelo windows para determinar que tipo de programa abre aquele arquivo. Assim, arquivos que são abertos pelo Microsoft Word, por exemplo, têm normalmente uma extensão .doc ou .docx. De forma semelhante, arquivos do Microsoft Excel possuem extensões próprias, que normalmente são .xls ou .xlsx. E arquivos de scripts do AutoHotkey têm uma extensão .ahk, e é assim que o seu computador sabe que quando você clicar para executar aquele arquivo, ele deverá ser rodado junto com o AutoHotkey.

Logo, o endereço completo do instalador do AutoHotkey, que é um arquivo, que fica dentro de uma pasta, que fica dentro de outra pasta, que fica no disco C é
C:\Arquivos de Programas\AutoHotkey\Installer.ahk

Se você colar este endereço na barra de endereços do Windows Explorer (o explorador de pastas que abre quando você abre qualquer pasta), vai ver que o instalador do AutoHotkey será executado imeditamente (caso o AutoHotkey esteja instalado no seu computador, e considerando que está na pasta padrão).

:arrow: Muitos comandos do AutoHotkey operam em arquivos do computador, por isso, você deverá escrever os endereços desses arquivos em algum dos parâmetros do comando. E agora você já sabe como fazê-lo :bravo:

5. Arquivo de computador: vale a pena desenvolver um novo tipo?

Primeiramente, cabe destacar que desenvolver um arquivo é algo raro hoje em dia. Já existem muitos tipos de arquivos que atendem a padrões amplamente difundidos, e normalmente, estes padrões foram definidos por times de programadores muito experientes que buscavam otimizar ao máximo as qualidades do arquivo.

Por isso, se você procurar uma imagem em seu computador, verá que normalmente ela vai estar em um arquivo de tipo .png, ou .bmp ou então .jpg. Isso ocorre porque estes formatos foram padronizados e todos foram desenvolvidos tendo em mente coisas como densidade de informação, facilidade de leitura, implementação de transparência, ou coisas do tipo. Se você quiser criar um programa que trabalhe com imagens, por exemplo, é muito importante que seu programa tenha meios de acessar as informações dos arquivos desses tipos, o que pode ser feito através de uma API ou outra biblioteca de códigos, ou, somente em último caso, estudando o padrão do arquivo e programando o acesso e interpretação dos bits.

Digo isto não para desencorajar, mas porque desenvolver um padrão novo é bastante trabalhoso e ainda fará com que somente o seu programa saiba interpretar aquele arquivo (um arquivo de imagem do seu programa com um padrão novo não seria exibido pelo Visualizador de Fotos do windows, por exemplo). Também cabe destacar que a maioria das linguagens de programação, incluindo o AutoHotkey, têm comandos, funções, e até códigos escritos por integrantes da comunidade que trabalham com tipos já desenvolvidos de arquivos. Isso facilita muito o desenvolvimento de programas que trabalhem com eles.

Tendo dito tudo isso, vale destacar finalmente que, embora não recomendado na maioria dos casos, é sim possível que as vantagens de criar um padrão novo superem as vantagens de usar um padrão existente. Uma das situações onde você pode querer isso é caso você realmente queira um alto nível de segurança nos dados dos arquivos. Quase todos os programas gestores de bancos de dados, por exemplo, tem arquivos de tipo único, que somente eles podem ler.

6. Arquivo de computador: como escrever um programa para trabalhar com os padrões existentes?

Se você desejar escrever um programa para trabalhar com arquivos de imagens, e quiser trabalhar com arquivos do .bmp, por exemplo, a primeira coisa fazer é consultar as bibliotecas de códigos já disponíveis que permitam trabalhar com estes arquivos de forma fácil. A comunidade do AutoHotkey possui em seus fórums varias funções e bibliotecas escritas por usuários programadores que se dedicaram para fazer sua vida mais fácil nesse sentido. Um exemplo é a biblioteca GDI+ escrita por Tic. Com essa biblioteca, você pode trabalhar com arquivos de imagens de forma mais fácil, sem precisar ter que abrir os padrões e ler os bytes um por um.

Se o padrão que você escolher não tiver ainda um código em AutoHotkey, você ainda pode verificar a existência de uma API do windows específica para tratamento daquele tipo de arquivo (APIs dos Windows podem ser acessadas por scripts de AutoHotkey através da função DllCall(), que será tratada em outro tutorial). Além disso, mesmo que não haja uma API do windows, também é possível que um programador que trabalhe com outra linguagem de programação tenha denvolvido uma Dll para tratamento daquele tipo de arquivo (DLLs podem ser escritas em várias linguagens de programação, como C++, e podem ser acessadas pelo AutoHotkey também).

:arrow: Na programação, a reutilização do código é muito importante e somente graças a ela podemos construir programas avançados nas linguagens de alto nível que levariam muito tempo para ser escritos em uma linguagem de baixo nível.

Se tudo isso falhar, ou se as ferramentas encontradas ainda não forem adequadas para o trabalho em questão, ou se quisermos mesmo, poderemos finalmente procurar documentos que elaborem sobre o padrão do arquivo. Estes documentos normalmente trazem detalhes sobre a estrutura do arquivo, dizendo de forma clara em quais bytes estão as informações que procuramos (tanto os endereços em relação ao byte inícial do arquivo quanto os chamados Offsets, que são os endereços em relação a outros bytes).

Podemos verificar o padrão do formato .bmp, por exemplo, que é um formato de arquivo de imagens muito difundido, juntamente com a sua estrutura até mesmo na página do padrão na wikipedia. Outros formatos com disponibilização do padrão grátis podem ser conferidos em sites especializados ou podemos ainda encontrar alguns formatos proprietários disponíveis para aquisição de algum meio através das companhias que os desenvolveram.

7. Arquivo de computador: se eu realmente quiser, como desenvolver um novo tipo?

Caso você queira realmente desenvolver um tipo novo de arquivo, vale a pena pensar primeiramente em que tipo de dados serão guardados no arquivo. Serão dados em forma de texto? ou será que serão dados de imagens? ou talvez serão dados de arquivos de audio? Ou ainda dados de modelos tridimensionais para jogos?

Se você quiser guardar dados em formato de texto, talvez valha a pena elaborar uma tabela de tradução dos bits em caracteres, parecida com a tabela Windows-1252 (ANSI). No entanto, se for um arquivo de imagem, convém pensar que cada sequência de bits pode significar os valores de cores dos pixels da imagem, ordenados da esquerda para a direita e depois de cima para baixo na imagem e ordenados da esquerda para a direita no arquivo, por exemplo. Já se for um arquivo de audio, podemos pensar que os bits devem conter informações sobre os tempos das alterações da frequência e da amplitude dos sinais, por exemplo.

Lembre-se disso: Os padrões se orientam sempre pelas posições em relação ao inicio e ao fim do arquivo. Assim, o byte que contém informações sobre o terceiro pixel de uma imagem, por exemplo, pode ser o terceiro byte do arquivo (ou pode ser o antepenúltimo). Também é importante saber que um mesmo arquivo pode conter mais de um tipo de dados. Isso é extremamente comum. Um arquivo de video, por exemplo, deve conter dados de imagens e de audio, por exemplo. Como isso é organizado?

Os arquivos podem conter metadados. Metadados são basicamente dados sobre dados. Assim, eu posso definir que o primeiro byte do arquivo conterá a posição inicial da sequência de bytes que contém dados de imagem, e que o segundo byte do arquivo contém a posição final. Da mesma forma, o terceiro byte pode conter a posição inicial da sequência de bytes que contém dados de audio, e o quarto byte do arquivo pode conter a posição final da sequência de dados de audio. Assim, um determinado arquivo pode ter a sequência de audio iniciada no 57º byte, enquanto que outro arquivo do mesmo tipo pode ter a sequência iniciada no 92º byte (ou mesmo no 374655º byte).

Assim, vale a pena desenhar a estrutura do seu arquivo em um documento que conterá o padrão dele. Assim, poderá consultar sempre que quiser, e se desejar (caso não queira segredo), poderá ainda publicá-lo.

8. Considerações finais

Ufa! Acredito que este tutorial foi bastante descritivo. Espero que tenha servido para dar uma visão geral muito boa sobre o que são os arquivos de computador. Se você ainda tiver alguma dúvida sobre o assunto, sinta-se livre para pergunta abaixo ou para usar o nosso fórum Eu Preciso de Ajuda.

Obirgado por ler mais este tutorial e até a próxima :thumbup:
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

Yesterday, 11:57

Reservado.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!
User avatar
Gio
Posts: 349
Joined: 30 Sep 2013, 10:54
Location: Brazil

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

Yesterday, 11:57

Reservado.
"What is suitable automation? Whatever saves your day for the greater matters."
Barcoder - Create QR Codes and other Barcodes using only Autohotkey !!

Return to “Tutoriais”

Who is online

Users browsing this forum: No registered users and 1 guest