FORUM DARKERS

Linha de Comando - Manipulando argumentos
By Dark_Side

Hi,
Introdução
***********************************************
Você provavelmente já deve ter visto ou escutou alguém dizer que tal programa funciona em linha

de comando, ou até mesmo já utilizou programas com este método.
Um dos melhores exemplos que posso dar, são comandos básicos, tais como ping, netstat, telnet,

etc.
Todos estes aplicativos, utilizam linha de comando.

Veja a linha de comando abaixo:

ping 127.0.0.1 -t
O comando acima, irá pingar o endereço IP 127.0.0.1, continuamente.

A sua estrutura seria:
ping ARGUMENTO1 ARGUMENTO2
     127.0.0.1  -t
Resumidamente: Linha de comando, é uma linha em si, que contém argumentos com os quais o

programa foi executado.

Esta breve introdução é apenas um complemento para o tutorial que está a seguir.

Linha de comandos e argumentos - Linguagem C
***********************************************
Bem, veremos a seguir, como manipular os argumentos da linha de comando de um programa em C.

Veja:

#include <stdio.h>
#include <conio.h>
int main(int argn,char * args[]){
printf("Hi...");
getch();
return 0;
}
Inicialmente, você diria que o programa mostraria na tela: Hi....
Mas observe:

int main(int argn,char * args[])

Um programa simples, geralmente, inicia com a função MAIN, da seguinte maneira: int main() -

sem parâmetros.
Fica óbvio que, os parâmetros colocados na função que antecede esta, são necessários para o

manipulamento da linha de comando.

Veja:

argn => número de argumentos da linha de comando.
char * args[] => É declarada um array de string. Normalmente, um array de string possui

a seguinte sintaxe:

char * array[NUMERO_DE_ELEMENTOS]. Como não sabemos o número de argumentos recebidos pelo

programa, não definimos o número de elementos.

Acessando e validando argumentos.
***********************************************
Como já havia dito, a variável argn, guarda o número de argumentos da linha de comando.

Imagine um programa onde temos:

QuotePROGRAMA usuario senha

No caso, argn, teria o valor 3. Observe que o nome do executável(PROGRAMA), conta como

um argumento.

usuario, seria o argumento 1, e senha, o segundo argumento.

Considere:

#include <stdio.h>
#include <conio.h>
int main(int argn,char * args[]){

if(argn != 3) //Possui menos ou mais de 3 argumentos
puts("Numero de argumentos invalido");
else //Possui 3 argumentos exatos.
puts("OK");

getch();
return 0;
}
No exemplo acima, verificamos se a linha de comando contém 3 argumentos e mostra uma mensagem

para cada situação.

Bem, vimos como manipular o número de argumentos, veremos agora, como obter os argumentos

, em si.

Você deve saber que em um array, temos uma sequência de valores. E que em C, um valor de um

array pode ser acessado/definido da seguinte forma:
array[POSICAO]=VALOR, quando queremos definir um valor;
array[POSICAO], quando queremos retornar o valor.

Outros exemplos:

char string[5]="ABCD";
Sabemos que, string[0] = 'A', string[1] = 'B', string[2] = 'C',etc.


No caso, temos um array de caracteres. Os índices - POSIÇÃO de um item em um array -,

são zero-base, isto é, sua contagem começa do ZERO.

Voltando à array de strings:

char * args[] => Como se trata de um array, os items, correspodem aos argumentos da

linha de comando, portanto, no exemplo:

QuotePROGRAMA usuario senha

args[0] => argumento 0
args[1] => argumento 1
args[2] => argumento 2
O que equivale a:
args[0] => PROGRAMA
args[1] => usuario
args[2] => senha

Vejamos agora um exemplo completo:

#include <stdio.h>
#include <conio.h>
int main(int argn,char * args[])
{
if(argn !=3)
{
printf("Uso: \n %s <NOME> <SOBRENOME>",args[0]);
}
else
{
printf("Seu nome e: %s\n",args[1]);
printf("Seu sobrenome e: %s",args[2]);
}
getch();
return 0;
}
No exemplo acima, o programa verifica se temos 3 argumentos, que são: PROGRAMA nome sobrenome.
Se não temos esses argumentos, mostra o modo de uso. Lembre-se que estamos tratando de arrays

de strings, e por isso usamos %s na função printf. Se caso tivermos os argumentos,

mostra-os na tela.

Lidando com outros tipos de argumentos
***********************************************
Muito bem, acima vimos que os argumentos, estavam TODOS, no formato de string. Se por acaso

fossemos apenas mostrar os argumentos, não haveriam problemas, mas caso fossemos armazenar os

argumentos em variáveis, sim.

QuotePROGRAMA

Se casos pegarmos o argumento IDADE como um valor numérico, se tentarmos gravá-lo em uma

variável do tipo inteiro por args[2], cometeríamos um erro, pois a args[2],

contém uma string, e não um valor numérico.

Para essas e outras situações, temos as funções auxiliares:
atof, atoi,atol. contidas no header stdlib.h.

Vejamos a seguir, quando e como usá-las.

1) Caso tenhamos que obter um argumento numérico
***********************************************
Neste caso, utilizamos a função atoi, que converte uma string em um inteiro.

Vamos tomar o exemplo anterior:

Quote#include
#include
#include
int x;
int main(int argn,char * args[])
{
if(argn !=3)
{
printf("Uso: \n %s ",args[0]);
}
else
{
x = atoi(args[2]);
printf("Seu nome e: %s\n",args[1]);
printf("Sua idade e: %d",x);
}
getch();
return 0;
}

Observe:

int x;
Declaramos a variável x, que receberá o valor.

x = atoi(args[2]);
Convertemos a string args[2] em inteiro e atribuimos o seu valor à variavel x.
A sintaxe, portanto é: variavel_int = atoi(string);

printf("Sua idade e: %d",x);
Como estamos tratando de um inteiro e não uma string, utilizamos %d, e não %s.

Caso tenhamos que obter um argumento float ou double
***********************************************

Quote#include
#include
#include
double x;
int main(int argn,char * args[])
{
if(argn !=3)
{
printf("Uso: \n %s ",args[0]);
}
else
{
x = atof(args[2]);
printf("Seu nome e: %s\n",args[1]);
printf("O numero e: %f",x);
}
getch();
return 0;
}

Note que alteramos apenas:

o tipo de variável;
double x;

a função:
x = atof(args[2]);

o modo de imprimir o valor:
printf("Seu nome e: %s\n",args[1]);
printf("O numero e: %f",x);

A sintaxe da função atof, é portanto:
variavel_double  = atof(string);

3) Caso tenhamos que obter um argumento long
***********************************************

Quote#include
#include
#include
long x;
int main(int argn,char * args[])
{
if(argn !=3)
{
printf("Uso: \n %s ",args[0]);
}
else
{
x = atol(args[2]);
printf("Seu nome e: %s\n",args[1]);
printf("O numero e: %ld",x);
}
getch();
return 0;
}

Novamente, alteramos as mesmas coisas: declaração, função e modo de imprimir.

4) Caso tenhamos que obter um argumento char
***********************************************
Você sabe que strings, são arrays de caracteres, certo? Uma vez em que estas são arrays, seus

elementos ou items, são os chars - caracteres.
Portanto, para obter um caractere de uma string contida em um array, usamos:

array[0][0]
Acima, obtemos o primeiro caractere da primeira string no array.

array[0][1]
Acima, obtemos o segundo caractere da primeira string no array.

array[1][0]
Acima, obtemos o primeiro caractere da segunda string no array.

array[1][1]
Acima, obtemos o segundo caractere da segunda string no array.

Nos exemplo citados, temos arrays BIDIMENSIONAIS, também chamados de MATRIZES.

Veja:

Quotearray[a] => Array unidimensional
array[a] => Array bidimensional ou matriz
array[a][c] => Array tridimensional
array[a][c][d] => Array multidemensional
array[a][c][d][e] => Array multidimensional
etc...

Bem, chegamos ao fim da primeira parte do tutorial. Abordarei na segunda parte, como manipular

argumentos em PERL.

Bye.

Linha de Comando - Manipulando argumentos - Parte 2
By Dark_Side

Retomando
***********************************************
Vimos o que é uma linha de comando, argumentos, e como manipulá-los, na linguagem C.
Veremos agora, como fazê-lo em PERL.

Linha de comando e argumentos - PERL
***********************************************
Em C, vimos que o número de argumentos e os argumentos em si, são armazenados, respectivamente, em uma variável do tipo int, e em um array de string.
Em Perl, isso não é diferente.
Veja:
$ARGC = @ARGV;
Acima, a variável ARGC, armazena o número de argumentos da linha de comando.
A variável ARGV, é um array de string, que armazena os argumentos.

Veja o exemplo:
programa.pl valor1 valor2
No exemplo, a variável ARGC, contém o valor 2. Isso mesmo, 2. Vimos que em C, onde no mesmo programa, o número de argumentos, seria 3. Isso ocorre porque em C, o nome do programa conta como um argumento, o que não acontece em Perl.
Nessas condições, o caminho do programa pode ser obtido pela variável reservada: $0.

Portanto:

Quote$0 = caminho do programa
valor1 = argumento 0
valor2 = argumento 1

Veja um exemplo:
$ARGC = @ARGV;
if($ARGC !=2)
{
print "Numero invalido de argumentos!\n"; # Caso haja mais ou menos argumentos
}
else
{
print "OK\n"; # Caso haja 2 argumentos exatos.
}
system("pause");
exit;
Acima, verificamos se temos 2 argumentos, e executamos uma ação para cada situação.

Vejamos agora, como obter os argumentos.
Veja o exemplo:
$ARGC = @ARGV;
if($ARGC !=2)
{
print "uso: $0 valor1 valor2\n"; # Se não tivermos 2 argumentos exatos
}
else{
print "Valor1: $ARGV[0]\nValor2: $ARGV[1]\n"; # Se tivermos
}
system("pause");
exit
Observe:
print "Valor1: $ARGV[0]\nValor2: $ARGV[1]\n"
Assim como em PHP, quando em uma string delimitada por aspas duplas ("), escrevemos uma variável, esta é substituída na string pelo seu respectivo valor. Utilizando aspas simples ('), o valor retornado é exatamente, o que foi escrito.

Exemplo:

Quote$x = 1;
print "Valor: $x"; # Escreve Valor: 1

$x = 1;
print 'Valor: $x'; # Escreve Valor $x

Note que, como estamos retornando o valor de um array, utilizamos $ ao invés de @.

Outra maneira de mostrar os argumentos, seria utilizando a função printf, como fizemos em C.

printf("Valor1: %s\nValor2: $s\n",$ARGV[0],$ARGV[1]);
Lembre-se que os valores contidos no Array, são strings, por isso utilizamos %s.

Podemos simplesmente mostrar os valores dos argumentos ou gravá-los em variáveis.
Vimos que na linguagem C, utilizamos funções auxiliares para obter e converter os valores, isso pois nesta linguagem, devemos especificar o tipo de variável. Uma vez em que Perl, a declaração do tipo de variável não se faz necessária, podemos simplesmente atribuir diretamente às variáveis, o valor do argumento em questão.

Exemplo:
$ARGC = @ARGV;
if($ARGC !=2)
{
print "uso: $0 valor1 valor2\n";
}
else{
$valor1 = $ARGV[0];
$valor2 = $ARGV[1];
print"Valor1: $valor1\nValor2: $valor2\n";
}
system("pause");
exit
Bem, termino aqui a segunda parte do tutorial. Na terceira parte, abordarei argumentos em Visual Basic.

Carry on...
Bye.

Linha de Comando - Manipulando argumentos - Parte 3
By Dark_Side

Linha de comando e argumentos - Visual Basic 6.0
***********************************************
Vimos que em C e Perl, temos duas variáveis responsável pela captura do número de argumentos, e estes em si, respectivamente.
Em Visual Basic, não temos essas variáveis, temos apenas a função responsável pela captura da linha de comando (não incluindo o caminho do executável) em forma de string.

Exemplo:
programa valor1 valor2

Em C, teriámos:

Quoteargn = 3
args[0] = programa
args[1] = valor1
args[2] = valor2

Em Perl:

Quote$ARGC = 2;
$0 = programa
$ARGV[0] = valor1
$ARGV[1] = valor2

Em Visual Basic:

QuoteNão temos uma variável específica
Command() = valor1 valor2

Percebemos que em Visual Basic, os argumentos não são tratados em um Array, cabe a nós, fazê-lo.

Vejamos:
Dim args As Variant
Dim argn As Integer
Private Sub Form_Initialize()
args = Split(Command, " ")
argn = UBound(args) + 1
End Sub

Vamos analisar:
Dim args As Variant => Definimos a variável args, como variante.
Dim argn As Integer => Definimos a variável argn, como inteiro.

Private Sub Form_Initialize() => Inicialização do programa

args = Split(Command, " ") => O comando Split, separa em um
Array, elementos delimitados por um específico dad. No nosso caso, estamos delimitando o valor de retorno de Command() - que é uma função responsável por retornar em string, a linha de comando do aplicativo - pelos espaços (" "), que indicam o início de um argumento na linha de comando.

argn = UBound(args) + 1 => A função UBound(), retorna o último índice da array, no caso, o último argumento. Como em C e Perl, arrays em Visual Basic, são zero-based, por isso seus índices começam no zero. Adicionamos um ao valor obtido, para sabermos o número de argumentos.

Assim como em Perl, temos uma maneira específica de obter o caminho do aplicativo em Visual Basic, utilizamos a API do Windows.
Mostrarei uma maneira fácil de fazê-lo:
Veja:
Dim caminho As String
Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
End Sub
Dim caminho As String => Variável do tipo string
caminho = App.Path & "" & App.EXEName & ".exe" => A propriedade app.Path, retorna o diretório onde o arquivo se encontra, App.ExeName - o nome do executável sem extensão.
Note que:
 & => Utilizado para concatenar strings

Vejamos agora o exemplo completo:
Dim args As Variant
Dim argn As Integer
Dim caminho As String

Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
args = Split(Command, " ")
argn = UBound(args) + 1
End Sub

Retomando o exemplo inicial: programa valor1 valor2, teríamos:

Quotecaminho = programa
argn = número de argumentos
args(0) = valor1
args(1) = valor2

Exemplo 1:
Dim args As Variant
Dim argn As Integer
Dim caminho As String

Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
args = Split(Command, " ")
argn = UBound(args) + 1

If argn <> 2 Then 'Verifica se NÃO temos 2 argumentos
MsgBox "Número de argumentos inválido!" 'Caso afirmativo
Else
MsgBox "OK" 'Se tivermos 2 argumentos exatos.
End If
End Sub
Acima é a variação dos exemplos passados em Visual Basic.
Veremos agorar como obter e manipular os argumentos:

Exemplo 2:
Dim args As Variant
Dim argn As Integer
Dim caminho As String

Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
args = Split(Command, " ")
argn = UBound(args) + 1

If argn <> 2 Then 'Verifica se NÃO temos 2 argumentos
MsgBox "Número de argumentos inválido!" 'Caso afirmativo
Else
MsgBox "Caminho: " & caminho & vbCrLf & "Valor1: " & args(0) & vbCrLf & "Valor2: " & args(1)
End If
End Sub
Veja que:
» Utilizamos parênteses () e não colchetes [], para acessarmos os índices do array
» vbCrLF é uma constante que representa uma quebra de linha.

Assim como em Perl, em Visual Basic, não é necessário declarar variáveis, devido a isso, podemos simplesmente gravar o valor de um argumento diretamente atribuindo-o à variável.
Exemplo:

Dim args As Variant
Dim argn As Integer
Dim caminho As String

Private Sub Form_Initialize()
args = Split(Command, " ")
argn = UBound(args) + 1
caminho = App.Path & "" & App.EXEName & ".exe"

If argn <> 2 Then 'Verifica se NÃO temos 2 argumentos
MsgBox "Número de argumentos inválido!" 'Caso afirmativo
Else
valor1 = args(0)
valor2 = args(1)
MsgBox "Caminho: " & caminho & vbCrLf & "Valor1: " & valor1 & vbCrLf & "Valor2:" & valor2
End If
End Sub


Da maneira acima, o compilador se encube de declarar o tipo correto para as variáveis.
Mas é importante observar que nem todas as linguagens aceitam o uso de variáveis sem previamente declará-las, vimos isso em C, por exemplo.
Para não perder o custume veremos algumas ocasiões onde passamos o valor de argumentos à variáveis de tipos diferentes.

1) Caso tenhamos que obter um argumento numérico
***********************************************
Nessa ocasião, utilizamos a função CInt.

Dim args As Variant
Dim argn As Integer
Dim caminho As String
Dim valor1 As Integer 'Variável do tipo inteiro

Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
args = Split(Command, " ")
argn = UBound(args) + 1

If argn <> 1 Then 'Verifica se NÃO temos 1 argumento
MsgBox "Número de argumentos inválido!" 'Caso afirmativo
Else
valor1 = CInt(args(0))
MsgBox "Valor1: " & valor1
End If
End Sub



Dim valor1 As Integer  =>Variável do tipo inteiro
valor1 = CInt(args(0)) => Converte o valor do argumento para inteiro, e o atribui à variável


2) Caso tenhamos que obter um argumento float
***********************************************
Desta vez, utilizamos a função CSng.

Dim args As Variant
Dim argn As Integer
Dim caminho As String
Dim valor1 As Single 'Single equivale a Float em VB.

Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
args = Split(Command, " ")
argn = UBound(args) + 1

If argn <> 1 Then 'Verifica se NÃO temos 1 argumento
MsgBox "Número de argumentos inválido!" 'Caso afirmativo
Else
valor1 = CSng(args(0))
MsgBox "Valor1: " & valor1
End If
End Sub

Dim valor1 As Integer  =>Variável do tipo single
valor1 = CSng(args(0)) => Converte o valor do argumento para float(single), e o atribui à variável.


3) Caso tenhamos que obter um argumento double
***********************************************
Utilizamos a função CDbl.


Dim args As Variant
Dim argn As Integer
Dim caminho As String
Dim valor1 As Double

Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
args = Split(Command, " ")
argn = UBound(args) + 1

If argn <> 1 Then 'Verifica se NÃO temos 1 argumento
MsgBox "Número de argumentos inválido!" 'Caso afirmativo
Else
valor1 = CDbl(args(0))
MsgBox "Valor1: " & valor1
End If
End Sub

Dim valor1 As Integer  =>Variável do tipo double
valor1 = CDbl(args(0)) => Converte o valor do argumento para double, e o atribui à variável.


4) Caso tenhamos que obter um argumento long
***********************************************
Utilizamos a função CLng.

Dim args As Variant
Dim argn As Integer
Dim caminho As String
Dim valor1 As Long

Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
args = Split(Command, " ")
argn = UBound(args) + 1

If argn <> 1 Then 'Verifica se NÃO temos 1 argumento
MsgBox "Número de argumentos inválido!" 'Caso afirmativo
Else
valor1 = CLng(args(0))
MsgBox "Valor1: " & valor1
End If
End Sub


Dim valor1 As Integer  =>Variável do tipo long
valor1 = CLng(args(0)) => Converte o valor do argumento para long, e o atribui à variável.

5) Caso tenhamos que obter um argumento char
***********************************************
Não temos uma função específica para isso, pois até a versão 6.0 do programa, variáveis do tipo char, são tratadas como do tipo string.
Pode-se usar então, a função MID() - que retorna um trecho de uma string.

Dim args As Variant
Dim argn As Integer
Dim caminho As String
Dim valor1 As String

Private Sub Form_Initialize()
caminho = App.Path & "" & App.EXEName & ".exe"
args = Split(Command, " ")
argn = UBound(args) + 1

If argn <> 1 Then 'Verifica se NÃO temos 1 argumento
MsgBox "Número de argumentos inválido!" 'Caso afirmativo
Else
valor1 = Mid(args(0), 1, 1)
MsgBox "Valor1: " & valor1
End If
End Sub

Dim valor1 As String  =>Variável do tipo string
valor1 = Mid(args(0),1,1) => Retorna o primeiro caractere da string e atribui-o à variável.

A função MID() - retorna um treco da string.
A sintaxe do comando MID é:
Mid(string,INICIO,FIM);
Onde:
string => String que queremos manipular, no nosso caso: args(0)
INICIO => Posição inicial, começa do 1.
FIM => Tamanho da string.

Exemplo:
var1 = "123456"  => A string acima possui 6 caracteres.
Mid(var1,2,3) => Retorna os caracters entre a posição 2 e os restantes, até que a string tenha o tamanho igual a 3.

Teriámos então: "234"

Outro exemplo:
var1 = "ABCDEFG"
Mid(var1,4,4)

Teríamos: "DEFG"
Bem, termino aqui outra parte do tutorial. Espero continuar postando-o em linguagens diferentes.
Bye.

Parabéns, vc é ótimo para fazer tutos, parabéns mesmo

Pôh Dark_Side,  parabéns....


Continue postando tutoriais assim... e o Darkers vai te agradecer !!

vlw!

nossa cara bem loko o tuto
vlw

Very Good!!! Ponto Positivo...