Estruturas de Controle
Estruturas de controle permitem controlar a seqüência das ações lógicas de um programa. Basicamente, existem dois tipos de estruturas de controle: estruturas de repetição e estruturas de decisão. A estrutura de repetição permite que um bloco de instruções seja executado repetidamente uma quantidade controlada de vezes. A estrutura de decisão permite executar um entre dois ou mais blocos de instruções. Neste capítulo estudaremos em detalhe as instruções do C que permitem implementar estas estruturas.
5.1 Condição de controle
Em todas as estruturas, existe pelo menos uma expressão que faz o controle de qual bloco de instruções será executado ou quantas vezes ele será executado: é o que chamamos de condição de controle. Uma condição de controle é uma expressão lógica ou aritmética cujo resultado pode ser considerado verdadeiro ou falso. Conforme vimos na seção 3.5, a linguagem C não possui, entretanto, variáveis ou constantes lógicas, possui somente expressões numéricas, assim quando uma expressão numérica se encontra em uma condição de controle, ela será considerada falsa se seu valor for igual a zero, e verdadeira se seu valor for diferente de zero. Exemplo: Observe nas condições abaixo, seu valor numérico e seu significado lógico. Considere as variáveis int i = 0, j = 3;
condição valor numérico significado lógico
(i == 0) 1 verdadeiro
(i > j) 0 falso
(i) 0 falso
(j) 3 verdadeiro
Este fato deve ficar claro pois, nas estruturas que estudaremos neste capítulo, quando for dito que uma condição é falsa ou verdadeira quer se dizer que seu valor e igual a zero ou diferente de zero.
5.2 Estrutura do...while
Esta é uma estrutura básica de repetição condicional. Permite a execução de um bloco de instruções repetidamente. Sua sintaxe é a seguinte:
Sintaxe:
do{
bloco
}while(condição);
onde: condição é uma expressão lógica ou numérica.
bloco é um conjunto de instruções.
Esta estrutura faz com que o bloco de instruções seja executado pelo menos uma vez. Após a execução do bloco, a condição é avaliada. Se a condição é verdadeira o bloco é executado outra vez, caso contrário a repetição é terminada. Ofluxograma desta estrutura é mostrada na figura 5.1:
Figura 5.1: Fluxograma da estrutura do...while.
Exemplo: No trecho abaixo, a leitura de um número é feita dentro de um laço de repetição condicional. A leitura é repetida caso o número lido seja negativo.
do{
puts("Digite um número positivo:");
scanf("%f",&num);
}while(num <= 0.0);
Programa exemplo: No arquivo e0501.cpp existe um programa que calcula o fatorial de um número. Este programa ilustra o uso da estrutura do...while.
5.3 Estrutura while
A estrutura de repetição condicional while é semelhante a estrutura do...while. Sua sintaxe é a seguinte:
Sintaxe:
while(condição){
bloco
}
onde: condição é uma expressão lógica ou numérica.
bloco é um conjunto de instruções.
Esta estrutura faz com que a condição seja avaliada em primeiro lugar. Se a condição é verdadeira o bloco é executado uma vez e a condição é avaliada novamente. Caso a condição seja falsa a repetição é terminada sem a execução do bloco. Observe que nesta estrutura, ao contrário da estrutura do...while, o bloco de instruções pode não ser executado nenhuma vez, basta que a condição seja inicialmente falsa. O fluxograma desta estrutura é mostrada na figura 5.2:
Figura 5.2: Fluxograma da estrutura while.
Exemplo: No trecho abaixo, calcula-se a precisão (e) do processador aritmético do PC. A variável eps tem seu valor dividido por 2 enquanto o processador conseguir distinguir entre 1 e 1+e. Após a execução do laço, o valor de eps contém a precisão da máquina.
eps = 1.0;
while(1.0 + eps > 1.0){
eps /= 2.0;
}
Programa exemplo: No arquivo e0502.cpp existe um programa que calcula a raiz quadrada de um número real positivo usando o método de Newton. Este programa ilustra o uso da estrutura while.
5.4 Estrutura for
A estrutura for é muito semelhante as estruturas de repetição vistas anteriormente, entretanto costuma ser utilizada quando se quer um número determinado de ciclos. A contagem dos ciclos é feita por uma variável chamada de contador. A estrutura for é, as vezes, chamada de estrutura de repetição com contador. Sua sintaxe é a seguinte:
Sintaxe:
for(inicialização; condição; incremento){
bloco
}
onde: inicialização é uma expressão de inicialização do contador.
condição é uma expressão lógica de controle de repetição.
incremento é uma expressão de incremento do contador.
bloco é um conjunto de instruções a ser executado.
Esta estrutura executa um número determinado de repetições usando um contador de iterações. O contador é inicializado na expressão de inicialização antes da primeira iteração. Por exemplo: i = 0; ou cont = 20;. Então o bloco é executado e depois de cada iteração, o contador é incrementado de acordo com a expressão de incremento. Por exemplo: i++ ou cont -= 2. Então a expressão de condição é avaliada: se a condição for verdadeira, o bloco é executado novamente e o ciclo recomeça, se a condição é falsa termina-se o laço. Esta condição é, em geral, uma expressão lógica que determina o ultimo valor do contador. Por exemplo: i <= 100 ou cont > 0.
Exemplo: No trecho abaixo, o contador i é inicializado com o valor 1. O bloco é repetido enquanto a condição i <= 10 for verdadeira. O contador é incrementado com a instrução i++. Esta estrutura, deste modo, imprime os números 1, 2, ..., 9, 10.
for(i=1; i<=10; i++){
printf(" %d",i);
}
É interessante notar que a mesma estrutura lógica pode ser implementada usando as estruturas for ou do...while:
Exemplo: As seguintes instruções são plenamente equivalentes:
i = 0; for(i = 0; i <= 100; i++){
do{ bloco
bloco }
i++;
}while(i <= 100);
Podem existir mais de uma expressão de inicialização e de incremento na estrutura for. Estas expressões devem ser separadas por vírgula (,). Mas não pode haver mais de uma expressão de condição. Por exemplo: for(i=0, j=10; i<10; i++, j--){...}
Programa exemplo: No arquivo e0503.cpp existe um programa que calcula a amplitude de um conjunto de valores. Este programa exemplifica o uso da estrutura for...
Vota este artigo
Entrada de caracter individual: getchar()
Biblioteca: stdio.h
Declaração: int getchar(void);
Propósito: A função getchar() (get character) lê um caracter individual da entrada padrão (em geral, o teclado). Se ocorrer um erro ou uma condição de 'fim-de-arquivo' durante a leitura, a função retorna o valor da constante simbólica EOF (end of file)definida na biblioteca stdio.h. Esta função permite uma forma eficiente de detecção de finais de arquivos.Esta função é dita line buffered, isto é, não retorna valores até que o caracter de controle line feed (n) seja lido. Este caracter, normalmente, é enviado pelo teclado quando a tecla [enter] é pressionada. Se forem digitados vários caracteres, estes ficarão armazenados no buffer de entrada até que a tecla [enter] seja pressionada. Então, cada chamada da função getchar() lerá um caracter armazenado no buffer.
4.4 Saída de caracter individual: putchar()
Biblioteca: stdio.h
Declaração: int putchar(int c);
Propósito: Esta função putchar() (put character) imprime um caracter individual c na saída padrão (em geral o monitor de vídeo).
Programa Exemplo: O programa e0403.cpp mostra o uso das funções getchar() e putchar() em um programa que lê caracteres do teclado e os reimprime convertidos para maiúsculos.
4.5 Leitura de teclado: getch(), getche()
Biblioteca: conio.h
Declaração: int getch(void);
int getche(void);
Propósito: Estas funções fazem a leitura dos códigos de teclado. Estes códigos podem representar tecla s de caracteres (A, y, *, 8, etc.), teclas de comandos ( [enter], [delete], [Page Up], [F1], etc.) ou combinação de teclas ([Alt] + [A], [Shift] + [F1], [Ctrl] + [Page Down], etc.).Ao ser executada, a função getch() (get character) aguarda que uma tecla (ou combinação de teclas) seja pressionada, recebe do teclado o código correspondente e retorna este valor. A função getche()(get character and echoe) também escreve na tela, quando possível, o caracter correspondente.
Código ASCII: ao ser pressionada uma tecla correspondente a um caracter ASCII, o teclado envia um código ao 'buffer' de entrada do computador e este código é lido. Por exemplo, se a tecla A for pressionada o código 65 será armazenado no buffer e lido pela função.
Código Especial: ao serem pressionadas certas teclas (ou combinação de teclas) que não correspondem a um caracter ASCII, o teclado envia ao 'buffer' do computador dois códigos, sendo o primeiro sempre 0. Por exemplo, se a tecla [F1] for pressionada os valores 0 e 59 serão armazenados e a função deve ser chamada duas vezes para ler os dois códigos.
Programa exemplo: O arquivo e0404.cpp mostra um programa para a leitura de teclado. Este programa usa a função getch() para reconhecer teclas e combinação de teclas.
Programa exemplo: O arquivo e0405.cpp mostra um programa para a leitura de teclado usando a função getche().
4.6 Escrita formatada em cores: cprintf()
Biblioteca: conio.h
Declaração: int cprintf (const char* st_contr [, lista_arg]);
Propósito: Esta função cprintf() (color print formated) permite a saída de dados numéricos, caracteres e strings usando cores. O uso da função cprintf()é semelhante a printf()porém permite que a saída seja a cores. Para que a saída seja colorida é necessário definir as cores de fundo e de letra para a impressão antes do uso da função.
Cores (Modo Texto)
Cor Constante Valor Fundo Letra
Preto BLACK 0 ok ok
Azul BLUE 1 ok ok
Verde GREEN 2 ok ok
Cian CYAN 3 ok ok
Vermelho RED 4 ok ok
Magenta MAGENTA 5 ok ok
Marrom BROWN 6 ok ok
Cinza Claro LIGHTGRAY 7 ok ok
Cinza Escuro DARKGRAY 8 -- ok
Azul Claro LIGHTBLUE 9 -- ok
Verde Claro LIGHTGREEN 10 -- ok
Cian Claro LIGHTCYAN 11 -- ok
Vermelho Claro LIGHTRED 12 -- ok
Magenta Claro LIGHTMAGENTA 13 -- ok
Amarelo YELLOW 14 -- ok
Branco WHITE 15 -- ok
Piscante BLINK 128 -- ok
Estas definições são feitas pelas funções texcolor() e textbackground() cuja sintaxe é:
textcolor(cor_de_letra);
textbackground(cor_de_fundo);
onde cor_de_letra e cor_de_fundo são números inteiros referentes as cores da palheta padrão (16 cores, modo texto). Estes valores de cor são representadas por constantes simbólicas definidas na biblioteca conio.h. Para se usar uma letra piscante deve-se adicionar o valor 128 ao valor da cor de letra. Alguns valores de cor não podem ser usados como cor de fundo. A relação acima mostra as cores, suas constantes simbólicas e onde podem ser usadas: Exemplo: O trecho de programa abaixo imprime uma mensagem de alerta em amarelo piscante sobre fundo vermelho.
#include <conio.h>
...
textbackground(RED);
textcolor(YELLOW + BLINK);
cprintif(“ Alerta: Vírus Detectado! ”);
...
Programa Exemplo: O programa do arquivo e0406.cpp mostra todas as combinações possíveis de impressão colorida em modo texto.
4.7 Saída sonora: sound(), delay(), nosound()
Biblioteca: dos.h
Declarações: void sound(unsigned freq);
void delay(unsigned tempo);
void nosound(void);
Propósito: A função sound() ativa o alto-falante do PC com uma freqüência freq (Hz). A função delay() realiza uma pausa (aguarda intervalo de tempo) de duração tempo (milisegundos). A função nosound() desativa o alto-falante.
Programa Exemplo: O uso destas funções é muito simples mas produz resultados interessantes. No arquivo e0407.cpp temos um exemplo do uso de sons em programas.
4.8 Limpeza de tela: clrscr(), clreol()
Biblioteca: conio.h
Declarações: void clrscr(void);
void clreol(void);
Propósito: A função clrscr() (clear screen) limpa a janela de tela e posiciona o cursor na primeira linha e primeira coluna da janela (canto superior esquerdo da janela). A função clreol() (clear to end of line) limpa uma linha desde a posição do cursor até o final da linha mas não modifica a posição do cursor. Ambas funções preenchem a tela com a cor de fundo definida pela função textbacground().
4.9 Posicionamento do cursor: gotoxy()
Biblioteca: conio.h
Declarações: void gotoxy(int pos_x, int pos_y);
Propósito: Em modo texto padrão, a tela é dividida em uma janela de 25 linhas e 80 colunas. A função gotoxy() permite posicionarmos o cursor em qualquer posição (pos_x,pos_y) da tela. Sendo que a posição (1,1) corresponde ao canto superior esquerdo da tela e a posição (80,25) corresponde ao canto inferior direito. Como as funções printf() e cprintf() escrevem a partir da posição do cursor, podemos escrever em qualquer posição da tela.
4.10 Redimencionamento de janela: window()
Biblioteca: conio.h
Declarações: void window(int esq, int sup, int dir, int inf);
Propósito: Esta função permite redefinir a janela de texto. As coordenadas esq e sup definem o canto superior esquerdo da nova janela, enquanto as coordenadas inf e dir definem o canto inferior direito da nova janela. Para reativar a janela padrão escreve-se a instrução window(1,1,80,25). Quando uma janela é definida, o texto que ficar fora da janela fica congelado até que se redefina a janela original.
4.11 Monitoração de teclado: kbhit()
Biblioteca: conio.h
Declarações: int kbhit(void);
Propósito: Esta função (keyboard hitting) permite verificar se uma tecla foi pressionada ou não. Esta função verifica se existe algum código no buffer de teclado. Se houver algum valor, ela retorna um número não nulo e o valor armazenado no buffer pode ser lido com as funções getch() ou getche(). Caso nenhuma tecla seja pressionada a função retorna 0. Observe que, ao contrário de getch(), esta função não aguarda que uma tecla seja pressionada.
Programa Exemplo: O arquivo e0408.cpp contém um programa para exemplificar o uso das funções clrscr(), clreol(), gotoxy(), window(), kbhit().
Vota este artigo
Entrada e Saída
Para que um programa torne-se minimamente funcional é preciso que ele receba dados do meio externo (teclado, mouse, portas de comunicação, drives de disco, etc.) e emita o resultado de seu processamento de volta para o meio externo (monitor, impressora, alto-falante, portas de comunicação, drives de disco, etc.). De outro modo: um programa deve trocar informações com o meio externo. Em C, existem muitas funções pré-definidas que tratam desta troca de informações. São as funções de entrada e saída do C. Nos exemplos mostrados nos capítulos anteriores foram vistas algumas funções de entrada (scanf(), getch()) e algumas funções de saída (printf()). Neste capítulo veremos, em detalhe, estas e outras funções de modo a permitir escrever um programa completo em C. Mostraremos, nas duas seções iniciais as mais importantes funções de entrada e saída de dados em C: as funções printf() e scanf(). A partir do estudo destas funções é possível escrever um programa propriamente dito com entrada, processamento e saída de dados.
4.1 Saída formatada: printf()
Biblioteca: stdio.h
Declaração: int printf (const char* st_contr [, lista_arg]);
Propósito: A função printf() (print formated) imprime dados da lista de argumentos lista_arg formatados de acordo com a string de controle st_contr. Esta função retorna um valor inteiro representando o número de caracteres impressos.
Esta função imprime dados numéricos, caracteres e strings. Esta função é dita de saída formatada pois os dados de saída podem ser formatados (alinhados, com número de dígitos variáveis, etc.).
Sintaxe: A string de controle é uma máscara que especifica (formata) o que será impresso e de que maneira será impresso.
Exemplo: Observe no exemplo abaixo as instruções de saída formatada e os respectivos resultados.
Instrução Saída
printf(“Ola’, Mundo!“); Ola’, Mundo!
printf(“linha 1 nlinha 2 “); linha 1
linha 2
Observe que na primeira instrução, a saída é exatamente igual a string de controle. Já na segunda instrução a impressão se deu em duas linhas. Isto se deve ao n que representa o código ASCII para quebra de linha (veja seção 2.1.3).
Nesta mascara é possível reservar espaço para o valor de alguma variável usando especificadores de formato. Um especificador de formato marca o lugar e o formato de impressão das variáveis contidas na lista variáveis. Deve haver um especificador de formato para cada variável a ser impressa. Todos os especificadores de formato começam com um %. Exemplo: Observe no exemplo abaixo as instruções de saída formatada e os respectivos resultados. Admita que idade seja uma variável int contendo o valor 29 e que tot e din sejam variáveis float cujo valores são, respectivamente, 12.3 e 15.0.
Instrução:
printf(“Tenho %d anos de vida”,idade);
Saída:
Tenho 29 anos de vida
Instrução:
printf(“Total: %f.2 nDinheiro: %f.2 nTroco: %f.2“,tot,din,din-tot);
Saída:
Total: 12.30
Dinheiro: 15.00
Troco: 2.70
Depois do sinal %, seguem-se alguns modificadores, cuja sintaxe é a seguinte:
% [flag] [tamanho] [.precisão] tipo
[flag] justificação de saída: (Opcional)
- justificação à esquerda.
+ conversão de sinal (saída sempre com sinal: + ou -)
<espaço> conversão de sinal (saídas negativas com sinal, positivas sem sinal)
[tamanho] especificação de tamanho (Opcional)
n pelo menos n dígitos serão impressos (dígitos faltantes serão completados por brancos).
0n pelo menos n dígitos serão impressos (dígitos faltantes serão completados por zeros).
[.precisão] especificador de precisão, dígitos a direita do ponto decimal. (Opcional)
(nada) padrão: 6 dígitos para reais.
.0 nenhum digito decimal.
.n são impressos n dígitos decimais.
Tipo caracter de conversão de tipo (Requerido)
d inteiro decimal
o inteiro octal
x inteiro hexadecimal
f ponto flutuante: [-]dddd.dddd.
e ponto flutuante com expoente: [-]d.dddde[+/-]ddd
c caracter simples
s string
Programa Exemplo: O arquivo e0401.cpp contém um programa que ilustra o uso da função printf() usando várias combinações de strings de controle e especificadores de formato. Execute o programa passo-a-passo e verifique a saída dos dados.
4.2 Leitura formatada: scanf()
Biblioteca: stdio.h
Declaração: int scanf(const char* st_contr [, end_var, ...]);
Propósito: A função scanf() (scan formated) permite a entrada de dados numéricos, caracteres e 'strings' e sua respectiva atribuição a variáveis cujos endereços são end_var. Esta função é dita de entrada formatada pois os dados de entrada são formatados pela string de controle st_contr. a um determinado tipo de variável (int, float, char, ...). Sintaxe: O uso da função scanf() é semelhante ao da função printf(). A função lê da entrada padrão (em geral, teclado) uma lista de valores que serão formatados pela string de controle e armazenados nos endereços das variáveis da lista. A string de controle é formada por um conjunto de especificadores de formato, cuja sintaxe é a seguinte:
% [*] [tamanho] tipo
* indicador de supressão (Opcional)
<presente> Se o indicador de supressão estiver presente o campo não é lido. Este supressor é útil quando não queremos ler um campo de dado armazenado em arquivo.
<ausente> O campo é lido normalmente.
Tamanho especificador de tamanho(Opcional)
n Especifica n como o numero máximo de caracteres para leitura do campo.
<ausente> Campo de qualquer tamanho.
Tipo define o tipo de dado a ser lido (Requerido)
d inteiro decimal (int)
f ponto flutuante (float)
o inteiro octal (int)
x inteiro hexadecimal (int)
i inteiro decimal de qualquer formato(int)
u inteiro decimal sem sinal (unsigned int)
s string (char*)
c caracter (char)
A lista de variáveis é o conjunto de (endereços) de variáveis para os quais serão passados os dados lidos. Variáveis simples devem ser precedidos pelo caracter &. Veja mais sobre endereços na seção ?.? Variáveis string e vetores não são precedidos pelo caracter &. Veja mais sobre strings e vetores na seção ?.?
Programa exemplo: O arquivo e0402.cpp contém um programa que ilustra o uso da função scanf() na leitura de dados. Execute o programa passo-a-passo e verifique como os especificadores de formato agem sobre os dados digitados.
Vota este artigo
Cont... Operador Condicional
Calcula o valor absoluto do inteiro i e do real d, respectivamente.
double sin(double arco);
double cos(double arco);
double tan(double arco);
double asin(double arco);
double acos(double arco);
double atan(double arco);
Funções trigonometricas do ângulo arco, em radianos.
double ceil(double num);
double floor(double num);
Funcoes de arredondamento para inteiro.
ceil() arredonda para cima. Ex. ceil(3.2) == 3.0;
floor() arredonda para baixo. Ex. floor(3.2) == 4.0;
double log(double num);
double log10(double num);
Funcoes logaritmicas: log() é logaritmo natural (base e), log10() é logaritmo decimal (base 10).
double pow(double base, double exp);
Potenciacao: pow(3.2,5.6) = 3.25.6.
double sqrt(double num);
Raiz quadrada: sqrt(9.0) = 3.0.
Biblioteca stdlib.h
int random(int num);
Gera um número inteiro aleatório entre 0 e num - 1.
Programa Exemplo: O arquivo e0307.cpp traz um programa para visualizar alguns aspectos relacionados com funções de biblioteca. Execute o programa passo-a-passo e observe o valor das variáveis.
3.8 Precedência entre os operadores do C
A tabela 3.1 mostra a ordem de precedência de todos os operadores estudados neste capítulo. Os operadores de maior precedência são os parênteses e as chamadas de funções. Os operadores de menor precedência são os o operadores de atribuição.
Categoria Operadores Prioridade
parênteses ( ) interno ® externo
função nome() E ® D
incremental, lógico ++ -- ! E ¬ D
aritmético * / % E ® D
aritmético + - E ® D
relacional < > <= >= E ® D
relacional == != E ® D
lógico && E ® D
lógico || E ® D
condicional ?: E ¬ D
atribuição = += -= *= /= %= E ¬ D
Tabela 3.1: Precedência dos operadores. Maior precedência no topo, menor precedência na base.
Vota este artigo
Operador Condicional
O operador condicional (?:) é usado em expressões condicionais. Uma expressão condicional pode ter dois valores diferentes dependendo de uma condição de controle.
Sintaxe: A sintaxe de uma expressão condicional é:
condição ? expressão_1 : expressão_2
onde expressão_1 e expressão_2 são duas expressões quaisquer, e condição é uma expressão lógica que será avaliada primeiro. Se o valor de condição for 1, isto é, verdadeiro, então a expressão condicional assumirá o valor de expressão_1. Caso contrario assumirá o valor de expressão_2. Uma expressão condicional é equivalente a uma estrutura de decisão simples:
se condição
então expressao_1
senão expressao_2
fim se
Exemplo: Observe as expressões condicionais abaixo e verifique o resultado de sua avaliação. Admita que i, j e k são variáveis tipo int com valores 1, 2 e 3, respectivamente.
Expressão Valor
i ? j : k 2
j > i ? ++k : --k 4
k == i && k != j ? i + j : i - j -1
i > k ? i : k 3
O operador condicional tem baixa precedência, precedendo, apenas, aos operadores de atribuição. Veja a tabela 3.1.
Programa Exemplo: O arquivo e0306.cpp traz um programa para visualizar alguns aspectos relacionados com o operador condicional. Execute o programa passo-a-passo e observe o valor das variáveis.
3.7 Funções de biblioteca
Uma função é um sub-programa (também chamado de rotina). Esta função recebe informações, as processa e retorna outra informação. Por exemplo, podemos ter uma função que receba um valor numérico, calcule seu logaritmo decimal e retorne o valor obtido. Existem dois tipos de funções: funções de biblioteca e funções de usuário. Funções de biblioteca são funções escritas pelos fabricantes do compilador e já estão pré-compiladas, isto é, já estão escritas em código de máquina. Funções de usuário são funções escritas pelo programador. Nesta seção trataremos somente das funções de biblioteca, funções de usuário serão vistas no capítulo ?.
3.7.1 O uso de funções
Antes de usar uma função é preciso saber como a função esta declarada, isto é, quais são os parâmetros que a função recebe e quais são os para metros que a função retorna. Estas informações estão contidas no manual do usuário do compilador ou em sua documentação on-line.
Sintaxe: A sintaxe de declaração de uma função é:
tipo_ret nome(tipo_1, tipo_2, ...)
onde nome é o nome da função, tipo_1, tipo_2, ... são os tipos (e quantidade) de parâmetros de entrada da função e tipo_ret é o tipo de dado de retorno da função. Além dos tipos usuais vistos na seção 2.3, existe ainda o tipo void (vazio, em inglês) que significa que aquele parâmetro é inexistente.
Exemplo: A função cos() da biblioteca math.h é declarada como:
double cos(double);
Isto significa que a função tem um parâmetro de entrada e um parâmetro de saída, ambos são do tipo double.
Exemplo: A função getch() da biblioteca conio.h é declarada como:
int getch(void);
Isto significa que a função não tem parâmetros de entrada e tem um parâmetro int de saída.
Para podermos usar um função de biblioteca devemos incluir a biblioteca na compilação do programa. Esta inclusão é feita com o uso da diretiva #include colocada antes do programa principal, como visto na secao 2.4.2.
Exemplo: Assim podemos usar a função no seguinte trecho de programa:
#include <math.h> // inclusão de biblioteca
void main(){ // inicio do programa principal
double h = 5.0; // hipotenusa
double co; // cateto oposto
double alfa = M_PI_4; // angulo: p/4
co = h * cos(alfa); // calculo: uso da funcao cos()
} // fim do programa
As funções tem alta precedência, sendo mais baixa apenas que os parênteses. A tabela 3.1 mostra as precedências de todos os operadores estudados neste capítulo.
3.7.2 As bibliotecas disponíveis e algumas funções interessantes
A seguir segue uma lista de todas as bibliotecas disponíveis no compilador Turbo C++ 3.0 Borland: Ao longo do texto veremos o uso de muitas funções cobrindo uma boa parte destas bibliotecas, porém o leitor que desejar tornar-se "fluente" na linguagem C pode (e deve) estudá-las com profundidade.
alloc.h assert.h bcd.h bios.h complex.h
conio.h ctype.h dir.h dirent.h dos.h
errno.h fcntl.h float.h fstream.h generic.h
graphics.h io.h iomanip.h iostream.h limits.h
locale.h malloc.h math.h mem.h process.h
setjmp.h share.h signal.h stdarg.h stddef.h
stdio.h stdiostr.h stdlib.h stream.h string.h
strstrea.h sysstat.h systimeb.h systypes.h time.h
values.h
Vejamos algumas funcoes disponiveis nas bibliotecas C.
Biblioteca math.h
int abs(int i);
double fabs(double d);
Vota este artigo
Operadores Incrementais Em programação existem instruções muito comuns chamadas de incremento e decremento. Uma instrução de incremento adiciona uma unidade ao conteúdo de uma variável. Uma instrução de decremento subtrai uma unidade do conteúdo de uma variável. Existem, em C, operadores específicos para realizar as operações de incremento (++) e decremento (--). Eles são genericamente chamados de operadores incrementais. Sintaxe: A sintaxe dos operadores incrementais é a seguinte: instrução equivalente ++ var var = var + 1 var ++ var = var + 1 -- var var = var - 1 var -- var = var - 1 onde var é o nome da variável da qual se quer incrementar ou decrementar um unidade. Observe que existe duas sintaxes possíveis para os operadores: pode-se colocar o operador à esquerda ou á direita da variável. Nos dois casos o valor da variável será incrementado (ou decrementado) de uma unidade. Porém se o operador for colocado á esquerda da variável, o valor da variável será incrementado (ou decrementado) antes que a variável seja usada em alguma outra operação. Caso o operador seja colocado à direita da variável, o valor da variável será incrementado (ou decrementado) depois que a variável for usada em alguma outra operação. Exemplo: Observe o fragmento de código abaixo e note o valor que as variáveis recebem após a execução da instrução: valor das variáveis int a, b, c, i = 3; // a: ? b: ? c: ? i: 3 a = i++; // a: 3 b: ? c: ? i: 4 b = ++i; // a: 3 b: 5 c: ? i: 5 c = --i; // a: 3 b: 5 c: 4 i: 4 Os operadores incrementais são bastante usados para o controle de laços de repetição, que serão vistos na seção ??. É importante que se conheça exatamente o efeito sutil da colocação do operador, pois isto pode enganar o programador inexperiente. Os operadores incrementais tem a mais alta precedência entre todos, sendo superados apenas pelos parênteses que tem precedência ainda maior. Veja a tabela 3.1. Programa Exemplo: O arquivo e0304.cpp traz um programa para visualizar alguns aspectos relacionados com os operadores incrementais. Execute o programa passo-a-passo e observe o valor das variáveis. 3.5 Operadores Relacionais e Lógicos A chave para a flexibilidade de um algoritmo é a tomada de decisões através da avaliação de condições de controle. Uma condições de controle é uma expressão lógica que é avaliadas como verdadeira ou falsa. Uma expressão lógica é construída com operadores relacionais e lógicos. 3.5.1 Operadores relacionais Operadores relacionais verificam a relação de magnitude e igualdade entre dois valores. São seis os operadores relacionais em C: Operador Significado > maior que < menor que >= maior ou igual a (não menor que) <= menor ou igual a (não maior que) == igual a != não igual a (diferente de) Sintaxe: A sintaxe das expressões lógicas é: expressão_1 operador expressão_2 onde expressão_1 e expressão_2 são duas expressões numéricas quaisquer, e operador é um dos operadores relacionais.Ao contrário de outras linguagens, em C não existem tipos lógicos, portanto o resultado de uma expressão lógica é um valor numérico: uma expressão avaliada verdadeira recebe o valor 1, uma expressão lógica avaliada falsa recebe o valor 0.Se os operandos forem de tipos diferentes haverá uma conversão de tipo antes da avaliação da expressão. Esta conversão de tipo é feita de acordo com a regra mostrada na seção 3.2.2. Exemplo: Observe as expressões lógicas abaixo e verifique o resultado de sua avaliação. Admita que i e j são variáveis int cujos valores são 5 e -3, respectivamente. As variáveis r e s são float com valores 7.3 e 1.7, respectivamente. Expressão Valor i == 7 0 r != s 1 i > r 0 6 >= i 1 i < j 0 s <= 5.9 1 Os operadores relacionais de igualdade (== e !=) tem precedência menor que os de magnitude (>, <, >= e <=). Estes, por sua vez, tem precedência menor que os operadores aritméticos. Operadores relacionais de mesma precedência são avaliados da esquerda para a direita. Veja a tabela 3.1. Exemplo: Observe as expressões lógicas abaixo e verifique o resultado de sua avaliação. Admita que m e n são variáveis tipo int com valores 4 e 1, respectivamente. Expressão Valor Ordem de Operação m + n == 5 1 + == m != 2 * n > m 1 * > != 6 >= n < 3 - m 0 - >= < m == n <= m > m 0 <= > != 3.5.2 Operadores lógicos São três os operadores lógicos de C: &&, || e !. Estes operadores tem a mesma significação dos operadores lógicos Booleanos AND, OR e NOT. Sintaxe: A sintaxe de uso dos operadores lógicos: expr_1 && expr_2 expr_1 || expr_2 !expr onde expr_1 , expr_2 e expr são expressões quaisquer. Observe que os operadores lógicos atuam sobre expressões de quaisquer valores. Para estes operadores todo valor numérico diferente de 0 é considerado 1. Exemplo: A seguir é mostrado o valor lógico de uma expressão qualquer: Expressão Valor lógico 0 0 1 1 1.0 1 0.4 1 -5.2 1 onde expr_1 , expr_2 e expr são expressões quaisquer. O resultado da operação lógica && será 1 somente se os dois operandos forem 1, caso contrário o resultado é 0. O resultado da operação lógica || será 0 somente se os dois operandos forem 0, caso contrário o resultado é 1. O resultado da operação lógica ! será 0 se o operandos for 1, e 1 se o operando for 0. Abaixo mostra-se o resultado das possíveis combinações entre os operandos para cada operador lógico: Operador &&: op_1 op_2 Res op_1 && op_2 1 1 1 1 0 0 0 1 0 0 0 0 Operador ||: op_1 op_2 Res op_1 || op_2 1 1 1 1 0 1 0 1 1 0 0 0 Operador !: op Res !op 1 0 0 1 O Operador && tem precedência sobre o operador ||. Estes dois têm precedência menor que os operadores relacionais. O operador ! tem a mesma precedência que os operadores incrementais. Veja a tabela 3.1. Exemplo: Observe as expressões lógicas abaixo e verifique o resultado de sua avaliação. Admita que a, b e c são variáveis tipo int com valores 0, 1 e 2, respectivamente. Expressão Valor Ordem de Operação a && b 0 c > b || a < c 1 > < || a + b && !c - b 1 ! + - && !b && c || a 0 ! && || Programa Exemplo: O arquivo e0305.cpp traz um programa para visualizar alguns aspectos relacionados com os operadores lógicos e relacionais. Execute o programa passo-a-passo e observe o valor das variáveis.
Vota este artigo
Restrições de operandos
Os operandos dos operadores aritméticos devem ser constantes numéricas ou identificadores de variáveis numéricas. Os operadores +, -, *, / podem operar números de todos os tipos (inteiros ou reais) porém o operador % somente aceita operandos inteiros.
Exemplo: Expressões válidas
Expressão Valor
6.4 + 2.1 8.5
7 - 2 5
2.0 * 2.0 4.0
6 / 3 2
47 % 2 1
Uma restrição ao operador de divisão (/) é que o denominador deve ser diferente de zero. Se alguma operação de divisão por zero for realizada o correra um erro de execução do programa (run-time error), o programa será abortado e a mensagem divide error será exibida.
Exemplo: A expressão abaixo é inválida pois o primeiro operando não é um numero inteiro.
Expressão Valor
6.4 % 3 invalido!
Podemos contornar o problema do operador inteiro da operação modulo usando o artifício da conversão de tipo (casting) mostrada na seção 2.3.4:
Exemplo: Observe o trecho de programa abaixo:
int num;
float valor = 13.0;
num = valor % 2; // inválido!
num = (int)valor % 2; // válido!
Observe que usamos a conversão de tipo para que o dado armazenado em valor fosse transformado no tipo int assim a operação módulo pode ser efetuada.
3.2.2 Conversão de tipo.
O resultado de uma operação aritmética depende dos tipos dos operandos. Se os operandos são do mesmo tipo o resultado será do mesmo tipo. Se os operando forem de tipos diferentes então haverá uma conversão de tipo tal que o tipo que ocupa menos espaço de memória será convertido para o tipo que ocupa mais espaço de memória e o resultado será deste tipo. Em geral:
char ® int ® float ® double
Esta é uma regra geral, alguns compiladores podem ter outras regras de conversão.
Exemplo: Observe as conversões de tipo abaixo:
Expressão Valor Conversão
6 + 2.0 8.0 int ® float
7.000000 - 2.0000000000000 5.000000000000000 float ® double
2 * 3.000000000000000 6.000000000000000 int ® double
Observe que estas conversões podem gerar resultados surpreendentes para o programador desatento.
Exemplo: Observe as expressões abaixo. Assuma que as variáveis num_i, num_f, den_i e den_f são inicializadas como:
int num_i = 7 , den_i = 2 ;
float num_f = 7.0, den_f = 2.0;
Expressão Valor Operandos Resultado
num_f / den_f 3.5 float / float float
num_f / den_i 3.5 float / int float
num_i / den_f 3.5 int / float float
num_i / den_i 3 int / int int
Observe que no exemplo acima o valor da última expressão é 3 e não 3.5. Isto ocorre porque como os dois operandos são tipo int o resultado e convertido para o tipo int e ocorre o truncamento. O truncamento da divisão inteira é feito de modo a obter o menor valor absoluto. Em C caracteres são armazenados na memória como números inteiros e por isso operações aritméticas são permitidas com tipos char. Os valores usados são os correspondentes da tabela ASCII.
Exemplo: Observe as expressões abaixo:
Expressão Valor Conversão
’A’ + 1 ’B’ 65 + 1 ® 66
’A’ + ’B’ ’â’ 65 + 66 ® 131
’A’ + 32 ’a’ 65 + 32 ® 97
3.2.4 Precedência de operadores.
Quando mais de um operador se encontram em uma expressão aritmética as operações são efetuadas uma de cada vez respeitando algumas regras de precedência: Estas regras de precedência são as mesmas da matemática elementar.
Os operadores de multiplicação (*), divisão (/) e módulo (%) tem precedência sobre os operadores de adição (+) e subtração (-). Entre operadores de mesma precedência as operações são efetuadas da esquerda para a direita. Veja a tabela 3.1.Exemplo: Observe, nas expressões abaixo, o seu valor e a ordem das operações efetuadas:
Expressão Valor Ordem
1 + 2 - 3 0 + -
24 - 3 * 5 9 * -
4 - 2 * 6 / 4 + 1 2 * / - +
6 / 2 + 11 % 3 * 4 11 / % * +
A ordem de precedência dos operadores pode ser quebrada usando-se parênteses: ( ). Os parênteses são, na verdade, operadores de mais alta precedência e são executados primeiro. Parênteses internos são executados primeiro que parênteses externos.Exemplo: Observe, nas expressões abaixo, o seu valor e a ordem das operações efetuadas:
Expressão Valor Ordem
1 + (2 - 3) 0 - +
(24 - 3) * 5 105 - *
(4 - 2 * 6) / 4 + 1 -1 * - / +
6 / ((2 + 11) % 3) * 4 24 + % / *
Observe que os operadores e os operandos deste exemplo são os mesmos do exemplo anterior. Os valores, porém, são diferentes pois a ordem de execução das operações foi modificada pelo uso dos parênteses.Programa Exemplo: O arquivo e0302.cpp traz um programa para visualizar alguns aspectos relacionados com os operadores aritméticos. Execute o programa passo-a-passo e observe o valor das variáveis.
3.3 Operadores de Atribuição Aritmética
Muitas vezes queremos alterar o valor de uma variável realizando alguma operação aritmética com ela. Como por exemplo: i = i + 1 ou val = val * 2. Embora seja perfeitamente possível escrever estas instruções, foi desenvolvido na linguagem C uma instruções otimizadas com o uso de operadores ditos operadores de atribuição aritmética. Os símbolos usado são (+=, -=, *=, /= , %=). Deste modo as instruções acima podem ser rescritas como: i += 1 e val *= 2, respectivamente.
Sintaxe: A sintaxe da atribuição aritmética é a seguinte:
var += exp;
var -= exp;
var *= exp;
var /= exp;
var %= exp;
onde var é o identificador da variável e exp é uma expressão válida. Estas instruções são equivalentes as seguintes:
var = var + exp;
var = var - exp;
var = var * exp;
var = var / exp;
var = var % exp;
Exemplo: Observe as atribuições aritméticas abaixo e suas instruções equivalentes:
Atribuição aritmética Instrução equivalente
i += 1; i = i + 1;
j -= val; j = j - val;
num *= 1 + k; num = num * (1 + k);
troco /= 10; troco = troco / 10;
resto %= 2; resto = resto % 2;
O operador de atribuição aritmética tem precedência menor que os outros operadores até aqui discutidos. Veja a tabela 3.1.Programa Exemplo: O arquivo e0303.cpp traz um programa para visualizar alguns aspectos relacionados com os operadores de atribuição aritmética. Execute o programa passo-a-passo e observe o valor das variáveis.
Vota este artigo
Operadores, Expressões e Funções
Um programa tem como característica fundamental a capacidade de processar dados. Processar dados significa realizar operações com estes dados. As operações a serem realizadas com os dados podem ser determinadas por operadores ou funções. Os operadores podem ser de atribuição, aritméticos, de atribuição aritmética, incrementais, relacionais, lógicos e condicionais.
Exemplo: o símbolo + é um operador que representa a operação aritmética de adição. O identificador sqrt() é uma função que representa a operação de extrair a raiz quadrada de um número. Uma expressão é um arranjo de operadores e operandos. A cada expressão válida é atribuído um valor numérico.Exemplo: 4 + 6 é uma expressão cujo valor é 10. A expressão sqrt(9.0) tem valor 3.0.
3.1 Operador de Atribuição
A operação de atribuição é a operação mais simples do C. Consiste de atribuir valor de uma expressão a uma variável.
Sintaxe: A sintaxe da operação de atribuição é a seguinte:
identificador = expressão;
onde identificador é o nome de uma variável e expressão é uma expressão válida (ou outro identificador).
Exemplo: A seguir são mostradas algumas atribuições válidas:
a = 1;
delta = b * b - 4. * a * c;
i = j;
Observe que o símbolo de atribuição ( = ) não tem o mesmo significado que o usual da matemática que representa a igualdade de valores. Este símbolo, em C, representa a atribuição do valor calculado em expressão a variável identificador. Em pseudo-linguagem o operador de atribuição é representado como ¬. Também não se pode confundir o operador de atribuição ( = ) com o operador relacional de igualdade ( == ) que será visto na seção 3.5.1.
Observe-se também que o operando esquerdo deve ser um identificador de variável, isto é, não pode ser uma constante ou expressão.
Exemplo: A seguir são mostradas algumas atribuições inválidas:
1 = a; // constante!
b + 1 = a; // expressão!
3.1.1 Conversão de tipo.
Se os dois operandos de uma atribuição não são do mesmo tipo, o valor da expressão ou operador da direita será convertido para o tipo do identificador da esquerda.
Exemplo: Algumas atribuições com conversão de tipo:
int i;
float r;
i = 5; // valor de i: 5
r = i ; // valor de r: 5.0
A variável i foi inicializada com o valor 5. Ao final da terceira instrução, r recebe o valor 5.0.Nestas conversões podem ocorrer alterações dos valores convertidos se o operando da esquerda for de um tipo que utilize menor numero de bytes que o operando da direita.
Exemplo: Algumas atribuições com conversão de tipo e perda de informação:
int i;
float r = 654.321;
i = r; // truncamento!
Após a execução deste trecho de programa o valor da variável i será 654 pois seu valor foi truncado durante a conversão.Pode-se dizer que as conversões potencialmente perigosas (onde há possibilidade de perda de informação) são:
char ¬ int ¬ float ¬ double
Observe que o compilador C ao encontrar esta operação não gera nenhum aviso de atenção para o programador. Assim este detalhe pode gerar um erro de programação (bug) que passe desapercebido ao programador inexperiente. É possível dizer que a linguagem C possui tipos “macios” (soft types) pois a operação com variáveis de tipos diferentes é perfeitamente possível. Esta característica do C se contrapõe a algumas linguagens em que isto não é possível (Fortran, por exemplo). Estas linguagens possuem tipos “duros” (hard types).
3.1.2 Limites do intervalo do tipo de dado.
Também é importante observar que os tipos em C tem intervalos bem definidos e os resultados das operações devem respeitar estes intervalos. Se a uma variável for atribuído um valor que esteja fora dos seus limites então este valor será alterado.
Exemplo: Observe as expressões abaixo, assuma que i seja uma variável do tipo int.
i = 4999; // o valor de i e’ 4999
i = 4999 + 1; // o valor de i e’ 5000
i = 5000 + 30000; // o valor de i e’ -30536
O valor de 35000 ultrapassou o limite superior do tipo int (32767).
É importante observar que em C, ao contrário de outras linguagens, a ultrapassagem do limite de um tipo não é interpretado como erro. Isto pode acarretar resultados inesperados para o programador desatento.
3.1.3 Atribuição múltipla.
E possível atribuir um valor a muitas variáveis em uma única instrução. A esta operação dá-se o nome de atribuição múltipla.
Sintaxe: A sintaxe da atribuição múltipla é seguinte:
var_1 = [var_2 = ... ] expressão;
onde var_1, var_2, ... são os identificadores de variáveis e expressão é uma expressão válida.Observe que na atribuição múltipla as operações ocorrem da direita para a esquerda, isto é, inicialmente o valor de expressão é atribuído a var_2 e depois o valor de var_2 é atribuído a var_1. Deve-se tomar cuidado com as conversões de tipo e limites de intervalo para atribuições de tipos diferentes.
Exemplo: Observe a instrução de atribuição múltipla abaixo: as variáveis inteiras i, j e k são todas inicializadas com o valor 1. E as variáveis de dupla precisão max e min são inicializadas com o valor 0.0:
int i, j, k;
double max, min;
i = j = k = 1;
max = min = 0.0;
Programa Exemplo: O arquivo e0301.cpp traz um programa para visualizar alguns aspectos relacionados com o operador de atribuição. Execute o programa passo-a-passo e observe o valor das variáveis.
3.2 Operadores Aritméticos
Existem cinco operadores aritméticos em C. Cada operador aritméticos está relacionado ao uma operação aritmética elementar: adição, subtração, multiplicação e divisão. Existe ainda um operador (%) chamado operador de módulo cujo significado é o resto da divisão inteira. Os símbolos dos operadores aritméticos são:
Operador Operação
+ adição.
- subtração.
* multiplicação
/ divisão
% módulo (resto da divisão inteira)
Sintaxe: A sintaxe de uma expressão aritmética é:
operando operador operando
onde operador é um dos caracteres mostrados acima e operando é uma constante ou um identificador de variável.
Exemplo: Algumas expressões aritméticas:
1+2 a-4.0 b*c valor_1/taxa num%2
Não existe em C, como existe em outras linguagens, um operador específico para a operação de potenciação (ab). Existe, porém, uma função de biblioteca (pow()) que realiza esta operação. Veja a seção 3.7 adiante. Embora as operações do C sejam semelhantes as operações aritméticas usuais da matemática, alguns detalhes são específicos da linguagem, e devem ser observados.
Vota este artigo
Constantes Simbólicas
No exemplo acima a variável valor foi declarada inicialmente como sendo do tipo float recebendo o valor inicial 13.0. Logo em seguida o conteúdo de valor é convertido para o tipo int para realizar a operação módulo (%) com o inteiro 2. Aqui a conversão é necessária pois a operação módulo somente pode ser feita com inteiros. É importante salientar que a conversão de tipo é feita com o dado armazenado em uma variável mas a variável continua tendo o seu tipo original. No exemplo acima a variável valor e os dados nela armazenados continuam sendo do tipo float após a conversão.
Veremos na seção 3.1 uma explicação mais detalhada do uso da conversão de tipos.
2.4 Constantes Simbólicas
Muitas vezes identificamos uma constante numérica por um símbolo: Pi = 3,14159 por exemplo. Podemos definir um nome simbólico para esta constante, isto é, podemos definir uma constante simbólica que represente valor.
2.4.1 Constantes definidas pelo programador
O programador pode definir constantes simbólicas em qualquer programa.Sintaxe: A sintaxe da instrução de definição de uma constante simbólica é:
#define nome valor
Onde #define é uma diretiva de compilação que diz ao compilador para trocar as ocorrências do texto nome por valor. Observe que não há ; no final da instrução pois trata-se de um comando para o compilador e não para o processador. A instrução #define deve ser escrita antes da instrução de declaração da rotina principal.
Exemplo: a seguir definimos algumas constantes simbólicas.
#define PI 3.14159
#define ON 1
#define OFF 0
#define ENDERECO 0x378
void main(){
...
No exemplo acima, definimos PI como 3.14159. Isto significa que todas as ocorrências do texto PI será trocado por 3.14159. Assim se escrevemos uma instrução:
área = PI * raio * raio;
o compilador vai interpretar esta instrução como se fosse escrita assim:
área = 3.14159 * raio * raio;
Poderíamos escrever estas instruções assim:
float pi = 3.14159;
área = pi * área * área;
porém este tipo de instrução tem duas desvantagens: Primeiro, reserva 4 bytes de memória desnecessariamente. Segundo, esta instrução é executada mais lentamente pois o processador precisa acessar a memória para verificar qual é o valor de pi. Observe também que no exemplo definimos os nomes simbólicos com letras maiúsculas. Isto não é necessário, podemos perfeitamente definir nomes simbólicos usando letras minúsculas, porém faz parte do jargão dos programadores C usar letras maiúsculas para definir constantes simbólicas.
O uso da diretiva #define não se restringe apenas ao apresentado acima, podemos usá-la para definir macro instruções. Não veremos o uso de macros neste texto, procure mais detalhes na bibliografia recomendada.
2.4.2 Constantes pré-definidas
Em alguns compiladores C, algumas constantes simbólicas já estão pré-definidas. Estas constantes em geral definam alguns valores matemáticos (p, p/2, e, etc.), limites de tipos etc. A seguir segue uma tabela contendo algumas (existem muitas outras) constantes simbólicas pré-definidas no compilador Turbo C++ da Borland.
Biblioteca Constante Valor Significado
math.h M_PI 3.14159... p
math.h M_PI_2 1.57079... p/2
math.h M_PI_4 0,78539... p/4
math.h M_1_PI 0,31830... 1/p
math.h M_SQRT2 1,41421... Ö2
conio.h BLACK 0 valor da cor (preto)
conio.h BLUE 1 valor da cor (azul)
conio.h GREEN 2 valor da cor (verde)
conio.h CYAN 3 valor da cor (cyan)
conio.h RED 4 valor da cor (vermelho)
conio.h MAGENTA 5 valor da cor (magenta)
limits.h INT_MAX 32767 limite superior do tipo int
limits.h INT_MIN -32768 limite inferior do tipo int
Cada uma das constantes acima esta definida em uma biblioteca. Uma biblioteca, em C, é um arquivo pré-compilado chamado arquivo header (cabeçalho, em inglês). Em cada biblioteca estão agrupadas constantes e funções semelhantes (veja seção 3.7.2). Por exemplo, constantes e funções matemáticas estão guardadas na biblioteca math.h (mathematical functions), constantes e funções de manipulação teclado e monitor estão guardadas na biblioteca conio.h (console input and output). Para que se possa usar a constante simbólica em um programa é preciso incluir a biblioteca na compilação do programa.
Sintaxe: A sintaxe de inclusão de bibliotecas é a seguinte:
#include <nome_bib>
onde nome_bib é o nome da biblioteca que se deseja incluir. Esta instrução deve ser escrita antes do programa principal.
Exemplo: O programa abaixo usa a constante predefinida M_PI para calcular a área de um disco circular.
#include <math.h>
void main(){
float area, raio = 5.0;
área = M_PI * raio * raio;
}
Vota este artigo
O que vai para o servidor
Talvez muitos de vocês tenham tentado entender o que está programado no MAGIC.TXT e não
tenha conseguido.Realmente tentar "ler" um programa em PERL não é coisa fácil,
principalmente quando desenvolvido por experts que usam vários "truques" da linguagem.
Vamos procurar mostrar nesta aula final aquilo que é o mais importante naquele programa
que é como é feita a "leitura" do que é enviado pelo usuários de uma página com FORM TAGS
para o programa que roda no servidor. Se você tiver numa página as FORM TAGS
preenchidas seguintes:
Nome:
Endereço:
Caso os "names" dos controls de input sejam: nome e end, o que
será enviado para o servidor após a ? será:
nome=Maria+Pia&end=Rua+Alfa%2C57
O signo & separa cada dupla.
O signo + aparece no lugar de espaço/branco
O mais dificil de entender é aquele %2C. Vamos explicar.
Em ASCII cada caractere pode ser representado por um número decimal. O "caractere"
vírgula por exemplo é representado por: 44 Um número decimal pode ser convertido
para a "base" hexadecimal (recorde seus princípios básicos de computação...).
O decimal 44, por exemplo, será em hexadecimal:2C. O CGI transmite
determinados caracteres (vírgula é um deles) por um número que
é o hexadecimal correspondente ao número que o representa em ASCII.
Para mostrar que está fazendo isto, coloca antes do número o sinal %.
Por isto é que nossa simples vírgula separando Rua Alfa de 57 aparece na transmissão como %2C. Graças a Deus existe uma maneira de
se substituir esta representação pelo caractere própriamente dito. Se tivermos numa variável:
$carac=%2C
podemos colocar propriamente o sinal de vírgula na variável usando:
$carac=~s/%(..)/pack("c",hex($1)/
Como você deve se lembrar das aulas 12 e 13
s/%(..)/XXX/ge
substituiria os conjuntos de "% mais os dois dígitos seguintes" por XXX. O uso
de ge faz com isto aconteça em todas as ocorrências deste conjunto.
No caso do que é transmitido pelo CGI visto acima, usando
s/%(..)/pack("c",hex($1)/
conseguimos que o conjunto %2C seja substituido pela transformação do que
vem depois de % de hexadecimal (2C) para decimal (44) e depois por sua
representação como caractere ASCII não-numérica: a dita cuja vírgula.
Como vocês veem temos que fazer várias transformações para colocar o que
é recebido pelo programa que está no servidor em condições de ser usado.
Para entender as linhas de programação que fazem estas transformaçõpes
recomendamos que você releia com cuidado as aulas 12, 13 e aquela sobre
arrays (a aula 10) e a que fala sobre split (aula 15) e a que fala sobre loops
for (aula 11) - enfim: você tem que ter estudado direito o curso.... Na aula
10 comentamos sobre os arrays associativos e dissemos que o que é enviado
para o servidor vem num item de um array associativo %ENV e que pode ser lido com:
$ENV{"QUERY_STRING"}
Isto no caso de usarmos GET (e não POST) , o que é uma das premissas em
todos os cursos aqui da DMU.(Você ainda se lembra do que é GET? Isso foi
comentado na aula 3). O GET tem umas limitações mas é mais fácil de usar.
O conjunto de linhas de código que colocamos num programa caso não
queiramos usar o MAGIC.TXT, será:
$temp=$ENV{"QUERY_STRING"};
@pares=split(/&/,$temp);# faz split criando array com duplas
for($i=0;$i<=$#pares;$i++){
($chave,$valor)=split(/=/,$pares[$i]);# começa a criar array associativo
$valor=~tr/+/ /;#substitui caractere + por branco
$valor=~s/%(..)/pack("c",hex($1))/ge;
$campos{$chave}=$valor;
Vota este artigo
Gravando registros com campos
Esta aula vai ser comprida mas vai valer à pena.
Juntando então tudo que aprendemos nesse curso vamos primeiro criar uma aplicação que grava registros em um arquivo a partir da entrada, pelo usuário, de dados em vários campos.
Colocamos de propósito dois campos numéricos sendo um com decimais que vão ser entrados USANDO O SEPARADOR BRASILEIRO que é a virgula.
O primeiro programa da aplicação, em HTML,(vamos chamá-lo de prog7.html) coloca os controls para serem preenchidos e pode ser visto no hipertexto.
O segundo programa, em PERL,(vamos chamá-lo de prog7.pl) pode ser visto e analisado nesse outro hipertexto.
Repare na conversão da vírgula para ponto, na criação do array e no join.
Lembre-se que os campos são separados por dois-pontos, dentro da linha/registro.
Copie esses dois programas em seu site (lembrando-se de transferir o programa PERL como ASCII) e teste entrando com registros.
Você pode experimentar nosso programa aí embaixo entrando com um registro também. Para uniformizar nossa saída entre com um código com quatro dígitos alfanuméricos e preço e quantidade não muito grandes.No próximo bloco você vai poder ver o arquivo com seu registro entrado e depois fazer uma pesquisa randômica a partir do código que você entrou. (Se, por acaso, o código que você criar já existir, seu registro não aparece na pesquisa randômica. Assim, para evitar isto,dê uma olhada no arquivo antes, clicando aqui. E volte para cá, claro, com BACK).
E olha a entrada de dados aí embaixo:
Código:
Nome:
Preço (XX,XX):
Quantidade:
Vamos ver então como fazemos uma aplicação que lê esse arquivo e o apresenta para o usuário.
Vamos colocar no programa mais um campo chamado TOTAL, que vai ser criado só no relatório projetado, e que é o produto do PREÇO pela QUANTIDADE.Isso mostra como podemos operar com os campos do arquivo para gerar as mais diversas saídas.
O programa (podemos chamá-lo de prog8.pl) para você estudar bem e depois testar no seu site aparece aqui no hipertexto.
Repare o uso do split, a criação dos campos como variáveis a partir do array e a edição dos campos com vírgula.
A próxima aplicação mostra como se faz a busca e projeção de um registro a partir de sua chave, entrada pelo ususário.
Na realidade não é bem uma pesquisa randômica mas uma simulação disso.
O que temos é uma leitura seqüencial com teste para cada registro lido.
É claro que esta pesquisa tem uma performance ruim se o arquivo for muito grande.Mas se você não pode usar servidores SQL, é uma saída...
A aplicação tem dois programas.O primeiro em HTML (prog9.html) para a entrada do código do produto e disparo do segundo programa.Veja no hipertexto.
O segundo, em PERL (prog9.pl), pode ser estudado e copiado para seu site a partir deste outro hipertexto.
Repare como foi feito o teste em cada registro para ver se seus dígitos iniciais coincidiam com o código entrado pelo usuário.
Você pode testar nosso programa, entrando com um código válido aí embaixo (pode ser o do registro que você criou).Não criamos consistência de códigos inexistentes nem nada, para simplificar. Mas poderia ser feito.
Entre com o código do produto:
Vota este artigo
Join
As duas operacões que vamos aprender nesse capítulo são fundamentais para se trabalhar com arquivos no PERL e na Internet.
A primeira delas chama-se JOIN e serve para, tendo um array com vários elementos, montarmos uma variável em que estes elementos são "juntados" com um dado caractere entre eles (normalmente se usa dois-pontos). Assim, por exemplo:
@areg = ("aa","bb","cc");
$reg = join(":",@areg);
Em $reg teremos aa:bb:cc
Se você rever atrás, vai ver que um registro de arquivo em PERL é assim, por exemplo:
0001:José Silva:Rua C,36:01307-001:São Paulo:SP
onde temos os campos:Código do cliente, Nome, Endereço, CEP, Cidade e UF.
Você tem que se lembrar que isso não é SQL. Como dissemos naquela aula os campos em arquivos PERL não têm nome nem tipo. Terão de ser trabalhados pela sua posição na linha/registro do arquivo.
Repare que com o JOIN podemos, tendo um array com os valores de campos entrados numa página da Internet (vamos ver isso na prática no próximo capítulo), montar um registro de arquivo.
Já o operador SPLIT faz o contrário do JOIN. Ele pega um string com um separador se repetindo (dois-pontos no caso de registros) entre substrings e monta um array em que cada elemento é um destes substrings. Veja para entender:
$reg2 = "mn:op:qr";
@areg2 = split(/:/,$reg2);
Teremos em @areg2 os elementos (mn,op,qr).
Em outro capítulo a gente viu como trabalhar com arrays. Você deve estar lembrado que podemos captar um elemento do array indexando assim:
$campotal = $areg2[1];
Na variável campotal teríamos o valor op (lembrando que a indexação começa com ZERO e que você tem que usar o símbolo $ no nome do array).
É assim que poderemos ler uma linha/registro de um arquivo e montar os diversos campos, com os quais poderemos operar num programa.
Era mais ou menos assim que trabalhávamos na década de 60.Ô saudade!
É o que vamos ver mais em detalhes na próxima aula, a mais importante do curso!
Vota este artigo
Formatação do Print
Para termos uma saída, impressa ou gravada, formatada, usamos printf .
A fórmula é:
printf "formatação",variável;
No lugar de formatação temos:
• % ns - para termos n caracteres (teremos brancos à esquerda para completar o string).
• % nd - para editarmos um número inteiro formatado com n dígitos (também teremos brancos à esquerda).
• % m.nf - para termos números com decimais formatados com m dígitos NO TOTAL (incluindo o ponto) sendo n dígitos na parte decimal.
Exemplos:
$x = "abcd";
printf "%8s",$x;
Serão printados: quatro brancos mais abcd (bbbbabcd).
Com números:
$y = 29.40;
printf "%8.3f",$y;
Serão printados dois brancos e o número com TRÊS decimais (zero à direita) - bb29.400
IMPORTANTE: Não se esqueça de que a formatação aparece entre aspas!
Pelo visto no capítulo anterior você poderia pensar que, para transformar um número com o separador ponto em um string semelhante com o separador vírgula bastaria fazer:
$x = 8.69;
$x=~s/./,/;
Lêdo engano, como diria Machado de Assis.
O resultado seria:
,.68999999 etc.
Isso porque:
1. Você não se lembra mas o ponto é um caractere curinga nesse negócio de "achar e trocar". Então, na realidade mandamos o PERL substituir o primeiro "qualquer caractere" por uma vírgula. Foi o que ele fez substituindo o 8 por uma vírgula.
2. Depois, quando operamos com decimais, se não editamos o resultado, o PERL considera uma precisão de 18 casas decimais - donde: SEMPRE EDITE RESULTADOS DE OPERAÇÕES COM NÚMEROS!
No caso em que não queiramos printar diretamente mas jogar numa variável um número com decimais editado "brasileiramente" existe a função: sprintf que usa aquelas mesmas fórmulas de formatação do printf.
Para resolver o problema de substituir O PONTO e não haver confusão com caractere curinga temos de simbolizar o nosso ponto por: . (barra invertida-ponto).
Assim, para colocarmos numa variável $xbras aquele $x com o separador brasileiro teríamos que fazer:
$xbras = sprintf("%4.2f",$x);
$xbras=~s/./,/;
Então teríamos em $xbras: 8,69
É meio complicado mesmo, mas funciona!
DICA: Arquive sempre os valores numéricos contendo decimais (preço, por exemplo) com o separador americano.Converta na entrada e desconverta na saída.
Vota este artigo
Encontra e Troca
Se você ainda não desistiu de estudar PERL depois do que viu na última aula, parabéns! Vamos continuar... Vimos no último capítulo uma forma de encontrar (ou não) um substring (molde) em um string. A linguagem PERL tem uma maneira de, encontrando um molde, substituí-lo por outro substring. É assim: $x ="a+cdefde";
$x=~s/de/mn/;
Isso fará com que em $x tenhamos: a+cmnfde. Se quizermos manter o valor em $x temos que primeiro igualá-lo a outra variável e fazer a operação com ela. Essa operação de substituição só acontece na primeira ocorrência do molde. Para a substituição em todas as ocorrências temos que colocar um ge depois da última barra: $x=~s/de/mn/ge;
Essas trocas valem para todo tipo de encontro de moldes que vimos no último capítulo, inclusive aqueles que usam (.) e 1 para criar uma memória dos caracteres. Assim: $x=~s/d(.)f/x1y/;
fará com que tenhamos: a+cxeyde. Nos casos em que queremos a troca de um caractere só, podemos usar: $x=~tr/f/x/;
Este uso é requerido nos casos em que queremos trocar um caractere do tipo + por branco $x=~tr/+/ /;
Nestes casos o s/// não funciona. Uma utilização interessante dessa técnica de substituição é para trocar o separador brasileiro vírgula em entradas numéricas com decimais, para o separador americano ponto que é o único válido em operações matemáticas no PERL. Lembre-se que, quando um usuário digita um número (preço, por exemplo) num control de um form, a sua entrada é um string.Temos, por exemplo então: $z = "29,40";
$z=~s/,/./;
para em $z termos o string 29.40 que será transformado automáticamente em número se executarmos uma operação matemática com ele (característica do PERL que já foi comentada).
Para termos a operação inversa, isto é, tendo um número separado por ponto e o passarmos para um string com o separador vírgula a coisa é mais complicada e vamos ver no próximo capítulo.
Diferentemente do "encontra e troca" que vimos aí em cima, podemos provocar a substituição de um substring dentro de um string indicando o início e tamanho do substring, usando a função substr. Veja:
$v = "abcdef";
substr($v,2,3)="xxxx";
O primeiro número indica o dígito inicial do substring (a origem é ZERO!).
O segundo número indica a quantidade de dígitos. Como aparece no exemplo, podemos substituir um substring por outro de tamanho diferente.No caso teremos em $v: abxxxxf.
Se usarmos ="" o substring é substituido por nada (não é branco, no caso), donde será extraído.
Vota este artigo
Substring em String
A linguagem PERL tem uma série de artifícios para testar se um string contém determinado substring ou outras coisas. Este tipo de teste não é muito comum em outras linguagens e deixa meio confusos os programadores tradicionais (coboleiros etc.)
Nos vários exemplos desse capítulo testaremos um string (vamos chamá-lo de BÁSICO) assim composto:
$x = "xaxbcdeee78nfg";
e os testes deverão dar sempre positivos, retornando true.
Para, por exemplo, verificar se nesse string (em $x) existe o substring "cd" usamos a fórmula:
$y = ($x=~/cd/);
Repare que o substring NÃO aparece entre aspas.
Caso exista (e existe!), em $y teremos true ou 1. Caso contrário teremos false ou undef.
Um print de true normalmente mostra: 1 e o de undef não aparece.
Digamos que queiramos saber se existe (no nosso string) um "b" seguido de dois caracteres QUAISQUER e depois um "e". Fazemos:
$y = ($x=~/b..e/);
Para cada caractere curinga temos que colocar um ponto. Podemos explicitar a quantidade com um número dentro de chaves:
$y = ($x=~/b.{2}e/);
E, para saber se existe UM DOS VÁRIOS caracteres: b ou h ou i:
$y = ($x=~/[bhi]/);
Nosso string básico não contém nem h nem i mas contém b. Donde em $y teremos true ou 1.
Para testar a existência de QUALQUER algarismo:
$y = ($x=~/d/);
repare que isso não é um teste para ver se $y é um número. Mas caso $x fosse um número o teste também daria positivo.
Para verificar se contém um escape (n, por exemplo) ou um branco no meio do string temos:
$y = ($x=~/s/);
Vamos chamar de molde aquilo que queremos testar se existe dentro do string.
Para verificar se o molde aparece uma determinada quantidade de vezes, contígüamente, temos três expressões:
1. para menos que tantas vezes (inclusive) temos:
$y = ($x=~/e{3}/);
verificando, tendo como molde o caractere e (poderia ser um substring), para 3 vezes ou menos.
2. para mais que tantas vezes (inclusive):
$y = ($x=~/e{2,}/);
para duas ou mais vezes.
3. no intervalo (inclusive extremos):
$y = ($x=~/e{2,5}/);
para entre 2 e 5 vezes.
Como no nosso string básico temos: eee, todos estes testes dariam positivo.
Essa é complicada! Podemos querer saber se um caractere (que não sabemos qual é) que há numa primeira posição se repete em uma outra posição.
Digamos que, no nosso string básico (olha ele aqui de novo):
$x = "xaxbcdeee78nfg";
não sabemos que na primeira posição tem um x mas queremos saber se na primeira posição temos o mesmo caractere que na terceira. Definimos o PRIMEIRO DESCONHECIDO com (.) e o IGUAL AO PRIMEIRO DESCONHECIDO COM 1. Veja só a sopa de letrinhas:
$y = ($x=~/(.)a1bcdeee78nfg/);
Como na primeira e na terceira posições temos o mesmo caractere, em $y teríamos true.
Não podemos ter o 1 numa posição seguida de algarismos.
Para testar outros pares temos que usar 2, 3 etc. sempre com (.) para o primeiro do par.
Se os pares não têm só um caractere usamos (.*) no primeiro molde da dupla.
Se queremos testar se o string básico contém, por exemplo o substring ax ou cd fazemos:
$y = ($x=~/ax|cd/);
No caso de apenas um caractere no molde veja o item 5.
Se você já está de saco cheio desses hierogrifos não se desespere e guarde com todo carinho o que vamos ensinar agora.
Isso vai ser muito usado no caso de pesquisa em arquivo, quando é dada a chave de um registro (essa chave é colocada nas primeiras posições do dito cujo registro).
O teste é para ver se o string COMEÇA com um determinado substring.
Digamos que queremos saber se $y começa com xaxb. Temos:
$y = ($x=~/^xaxb/);
Vamos fazer mais para frente um exercício importante usando esse truque.
E, para testar um substring no fim de um string temos:
$y = ($x=~/fg$/);
Espero que você esteja atento e tenha reparado no sinal de $ no fim do molde.
Estes testes todos que vimos levam em consideração se os caracteres estão em maiúscula ou minúscula. Para isso ser ignorado coloque depois da segunda barra a letra: i. Assim:
$y = ($x=~/^xaxb/i);
É válido que o molde seja o conteúdo de uma variável.Por exemplo:
$m = "cd";
$y = ($x=~/$m/);
Como em $x temos cd em $y teremos: true.
Vota este artigo
If/Else
Para executar algo condicionalmente o PERL tem a expressão:
if (verdadeiro)
{
faz-tal-coisa;
faz-tal-coisa;
}
Para uma expressão ser verdadeira NÃO pode retornar ZERO ou VAZIO
(Undef). Qualquer
outro valor é válido como
true. Zero ou Undef equivalem a:false. O valor equivalente
a true normalmente é: 1.
Podemos juntar duas ou mais condições usando os símbolos:
&& and lógico
|| or lógico
Para um desvio alternativo temos:
if (verdadeiro)
{
faz-tal-coisa1;
faz-tal-coisa2;
}
else
{
faz-tal-coisa3;
faz-tal-coisa4;
}
Podemos ter várias opções:
if (verdadeiro1)
{
faz-tal-coisa1;
faz-tal-coisa2;
}
elseif (verdadeiro2)
{
faz-tal-coisa3;
faz-tal-coisa4;
}
else
{
faz-tal-coisa5;
}
Para fazer determinadas coisas exceto se uma opção for verdadeira temos:
unless (verdadeiro)
{
faz-tal-coisa;
}
Para repetir determinadas coisas enquanto um teste for verdadeiro:
while(verdadeiro)
{
faz-tal-coisa;
}
Para o loop ser feito até que um teste retorne verdadeiro:
until(verdadeiro)
{
faz-tal-coisa;
}
Um caso muito comum de loop é quando temos uma
variável que vai sendo incrementada e
testamos se ela chegou a um limite. O PERL tem a expressão:
for(assinalamento-inicial; teste; incremento)
{
faz-tal-coisa;
}
Veja um exemplo simples, para listar números de 0 até 5:
for($i=0;$i<=5;$i=$i+1)
{
print "$i n";
}
Podemos usar: $i++ no lugar de: $i = $i + 1 , para alegria do pessoal do C++.
Uma outra construção interessante é com foreach.
Repetimos várias linhas
de código, substituindo uma determinada variável
($x, por exemplo) pelos valores de uma lista. Assim:
foreach $x (1,2,3,4)
{
$y = 4*$x;
print "$y n";
}
listaria os números: 4,8,12,16.
No lugar da lista poderíamos usar um array.
Vota este artigo
Conceitos Iniciais
Um array é um conjunto ordenado de valores.
Quando tem uma só dimensão (que é o que vamos ver nesse capítulo)
podemos chamar um array de vetor.
Podemos misturar em um array números e strings ums vez
que para o PERL todos são igualmente variáveis escalares.
O nome de um array é sempre precedido de @.
Criamos um array assim:
@conj = (25, 14, 37);
Para acessar um elemento do array usamos o sinal $ antes do nome do array
e a indexação
é feita a partir de ZERO.
Assim:
$conj[1] seria 14.
Podemos ter um novo array constituido de elementos de outro array:
@arr = @conj[0,2]; teria os valores 25 e 37.
Se assinalarmos um array para uma variável essa vai conter a quantidade
de elementos do array.Em:
$qtd = @arr; teríamos 2 na variável $qtd.
O índice do último elemento de um array é designado assim, por exemplo:
$#conj teria 2 (lembre-se que a origem é ZERO!).
Para acrescentar um elemento no fim de um array temos o operador push().
Ele tem dois argumentos: o primeiro é o nome do array e o segundo é o valor
a ser acrescentado.Por exemplo:
push(@conj,88);
Para tirar um elemento no fim de um array temos um operador
chamado pop() que funciona como uma função
com retorno
ois tira o elemento e o retorna. Assim, podemos fazer:
$ult = pop(@conj);
Em $ult teríamos o último elemento de @conj.
Para acrescentar um elemento no início de um array temos o operador
unshift()
e para tirar temos: shift().
Podemos classificar ascendentemente um array com strings usando
sort()
que retorna um novo array classificado mas não altera o original. Vamos ver
mais a frente como classificamos um array com números.
Existe um operador reverse() que retorna os elementos na ordem inversa,
o que pode ser usado após o sort(), para uma classificação descendente.
Na criação de um array, se colocarmos dois valores separados por
dois pontos (não dois-pontos) teremos no array elementos que
começarão pelo valor da esquerda e terão incremento de
uma unidade até chegar ao valor mais próximo do elemento
da direita. Assim:
@cj1 = (1 .. 4) será: (1, 2, 3, 4)
@cj2 = (3.4 .. 6.3) será: (3.4, 4.4, 5.4)
Em PERL temos um outro tipo de array que é muito usado nas
operações com CGI.
Chama-se array associativo.
Em outras linguagens (Java, por exemplo) temos coisa semelhante e
chamamos de hashtable. Enfim, o que temos é
uma tabela com duas colunas sendo que podemos achar
um valor da segunda coluna se dermos a chave ou melhor
dizendo, o valor equivalente da primeira coluna.Qualquer coisa assim:
001 Bola
002 Boneca
003 Trem
Para criarmos um array associativo existem muitas maneiras.
Vamos mostrar uma que talvez não seja a mais simples
mas que vai nos ajudar a compreender certas coisas
no futuro (tenha confiança...) Para criarmos um array
associativo chamado campos com os dados aí de cima
escreveríamos no programa PERL:
($chave,$valor)=("001","Bola");
$campos{$chave}=$valor;
($chave,$valor)=("002","Boneca");
$campos{$chave}=$valor;
($chave,$valor)=("003","Trem");
$campos{$chave}=$valor;
Repare (isto é importante) que às vezes temos parênteses e às vezes
temos chaves - { }.
Se quizermos "achar" o valor "Boneca" e imprimí-lo bastaria usar:
print $campos{"002"};
Seria impresso:Boneca.
A maneira "clássica" de criar esse array associativo seria:
%campos=("001","Bola","002","Boneca","003","Trem");
Um array associativo importante no CGI é o %ENV que tem como
uma de suas chaves QUERY_STRING.
Correspondendo a esta chave temos como valor, tudo que
é enviado depois da ? numa chamada a um programa PERL
usando CGI.
Vota este artigo
Operaçôes Numéricas
Os operadores numéricos do PERL são os comuns na maioria das liguagens:
+ soma
- subtração
* multiplicação
/ divisão
Para a exponenciação temos: ** . Por exemplo:
4**2
seria 16.
Para achar o resto de uma divisão temos: %. Por exemplo:
9%2
seria 1.
Os operadores duplos, comuns no C++, são válidos no PERL. Use se você estiver acostumados com eles (++, +=,-- etc.)
Você já deve estar cansado de saber isso mas vamos repetir.Para assinalamento no PERL temos o sinal =.
Isso não é equivalente a um sinal de igual da matemática. A expressão:
$x = $x + 2;
faria qualquer matemático ficar arrepiado (cortaríamos $x dos dois lados e teríamos que 2=0!).
Não confunda também assinalamento com o operador lógico que faz o teste de igualdade. No PERL temos DOIS operadores para este teste lógico.Tome cuidado com isso!
Para teste com numéricos o operador é:
==
Veja então:
$x = 5;
$y = 5;
$ret = ($x == $y);
No caso, em $ret teremos true. Que é o retorno da operação lógica.
Para teste de igualdade entre strings o operador lógico é: eq. Assim teríamos:
$a = "ABC";
$b = "DEF";
$r = ($a eq $b);
O retorno, no caso seria false
Para testes de desigualdade temos também DOIS operadores:
!=
ne
Sendo o primeiro para testes entre numéricos e o segundo para testes entre strings. Como já dissemos: não confunda!
Para comparações de tamanho entre numéricos temos os tradicionais:
<
>
<=
>=
A concatenação entre strings é feita com o operador ponto. Assim:
$s = "BOM"." "."DIA";
faria com que em $s tivéssemos: BOM DIA (concatenados com um espaço).
As conversões entre numéricos e strings no PERL é feita automáticamente. Podemos escrever:
print "TOTAL = ".(4*5);
E teremos impresso o string: TOTAL = 20.
A definição de precedências no PERL é feita com parênteses, como na maioria das linguagens.
Podemos colocar assinalamentos entre parênteses como em:
$b = 7 + ($a = 5);
Essa operação vai fazer com que a variável $a fique com o valor 5 e a variável $b fique com 12.
Evite, no entanto, essas linhas de códigos em que várias operações são feitas ao mesmo tempo. É verdade que isso faz com que alguns programadores se sintam um gênio. Às vezes isso realmente melhora a performance do programa. Mas o que acontece é que você não está escrevendo seus programas apenas para a máquina. Você também está escrevendo para o programador que vai ter que dar manutenção no seu programa amanhã. Assim sendo escreva de maneira que ele entenda facilmente a seqüência das operações.
Não tente demonstrar que você é um gênio. Se você realmente for um não precisa mostrar. Minha avó, lá em Minas, sempre dizia:"Quem é realmente bom pode ser humilde..."
Vota este artigo
Variáveis Escalares
Agora que você já aprendeu a fazer algumas coisas muito úteis com a linguagem PERL, vamos começar realmente a estudá-la em detalhes,calmamente, em pequenas doses. Assim, você não só vai entender melhor o que aprendeu a fazer, como vai ter condições de escrever programas muito mais sofisticados que vão, por exemplo, criar campos em registros de arquivos, fazer leitura direta de um dado registro etc.
O primeiro conceito a aprender em PERL é o de variável escalar.
Na maioria das linguagens, quando se define uma variável é preciso, além de seu nome dizer que tipo de conteúdo (string, número etc.) ela vai ter. No PERL isso não é necessário. Você cria uma variável já definindo para ela um conteúdo inicial. E o tipo desse conteúdo vai definir o tipo da variável.
Assim, se criarmos:
$var1 = "TESTE";
a variável var1 vai ser do tipo string.
Repare que todo nome de variável deve começar com o símbolo: $.
Nas operações numéricas a variáveis usarão sempre como separador de decimais (caso tenham decimais,claro) o símbolo ponto e não vírgula como é costume no Brasil.
Assim, podemos criar uma variável numérica assim:
$varn = 35.78;
Em arquivos devemos também sempre ter os valores de campos numéricos com decimais com esse separador. Logo, se a entrada de dados for feita com o separador vírgula, será preciso fazer uma substituição do símbolo (o que vamos aprender mais tarde).
Quando um valor numérico com decimais é projetado na tela, tem que ser feita a substituição inversa.
Só como curiosidade, fique sabendo que o PERL considera toda variável numérica como float point o que é uma decisão de arquitetura de linguagem discutível.
Não comece uma variável numérica com zero pois o PERL reserva isso para definir números na base octal. Assim, se definirmos:
$varo = 0377
teremos em $varo o octal 0377 que equivale ao decimal 255. (Quem estudou ciências da computação deve se lembrar dessas coisas. O prefixo 0X serve para hexadecimais: 0XFF, por exemplo é também 255).
Quando vamos imprimir (ou gravar) um string ou uma variável que é um string e queremos que depois dele impresso (ou gravado) se passe para a linha seguinte usamos o símbolo:
n
que deverá se colocado dentro das aspas assim:
"TESTEn"
ou assim:
"$var1n"
A variável será substituída pelo seu valor apesar de estar entre aspas, o que não aconteceria em outras linguagens.
É possível se circunscrever um string com apóstrofos no lugar de aspas. Isso, no entanto provoca que essas conversões não ocorram às vezes. Como toda linguagem, o PERL tem algumas atitudes estranhas, às vezes...
Vota este artigo
Um Read Next Estranho
É muito comum nas linguagens de programação termos um comando chamado READNEXT (ou qualquer coisa assim) que serve para ler o próximo registro de um arquivo. Normalmente se cria um LOOP de leitura (com WHILE) que se encerra quando é retornado o valor EOF.
No PERL temos também o loop WHILE (vamos estudar isso mais em detalhes depois)que é montado assim:
while(verdadeiro)
{
faz tal coisa ;
}
Uma expressão dentro do parênteses tem que retornar TRUE para que o loop continue.
Repare que não se coloca ponto-e-vírgula no fim do bloco.
O PERL, por outro lado, não tem bem um comando READNEXT. O equivalente é a colocação do FILEHANDLE definido para o arquivo, entre sinais de menor-do-que e maior-do-que.Se o filehandle definido para um arquivo é, por exemplo:FHX, a linha de código para ler o próximo registro e jogar numa variável que podemos chamar de : $reg seria:
$reg=<FHX>;
Quando o arquivo termina, é jogado em $reg um valor equivalente a FALSE.
Assim, podemos montar um loop de leitura com o $reg dentro do teste do WHILE. Isso dá uma seqüência de linhas de código como as abaixo:
$reg=" ";
while($reg)
{
$reg=<FHX>;
print $reg;
}
Primeiro definimos uma variável $reg (com branco).
Depois montamos o loop e cada registro lido é printado.
Uma coisa que é bom ressaltar é que o nome do filehandle para um arquivo não é algo fixo. Ele pode ser definido com nomes diferentes em cada programa.
Um programa bem simples para ler o arquivo arq2.txt que criamos no capítulo anterior seria como o que pode ser visto em hipertexto
Como o programa é muito simples NÃO precisamos acrescentar o MAGIC.TXT (Até poderia ser usado para criar o header e o início e fim do HTML).
Repare que depois de printar cada linha, colocamos uma tag <P> para passar para outra linha na "impressão" da página on-the-fly.
Vamos chamar esse programa de prog5.pl e você pode criá-lo e executá-lo para ler SEU arquivo criado pelo prog4.
Nesse caso não temos um prog5.html.Você pode disparar o programa chamando-o diretamente ou de qualquer página através de um <A HREF etc.
Você pode criar um botão com uma FORM TAG também.
IMPORTANTE:Se você quiser brincar de gravar com o prog4 e ler com o prog5 , várias vezes; tem que dar RELOAD no browser para evitar a cópia do cache que não muda!
Em princípio tudo que pode ser feito com uma página normal da Internet pode ser feito numa página construída on-the-fly.
Na prática porém isso nem sempre acontece e, na maioria dos casos é difícil detectar por que. Assim mesmo tente sempre montar páginas de boa qualidade gráfica mesmo usando dados de arquivo no meio da página.
Vamos fazer então o mesmo exercício de leitura do programa anterior só que colocando os registros dentro de uma tabela (table) do HTML. Copie o programa (prog6.pl) deste hipertexto.
Se você não entendeu bem como se faz para definir tabelas, estude HTML...
Você pode executar o programa demo com nosso arquivo clicando aqui:
DISPARA PROGRAMA
Vota este artigo
Filehandle
O segredo de toda da gravação e leitura de registros com PERL está numa coisa chamada FILEHANDLE.
Podemos considerar um filehandle como sendo uma porta virtual que abrimos para um arquivo.Depois de aberta a porta podemos entrar e sair por ela: podemos gravar e ler registros no arquivo.
Acontece porém que uma porta aberta para gravar é diferente de uma porta aberta para ler.Temos que ter um filehandle para ler registros e um filehandle para gravar. Na realidade a coisa é mais complicada ainda. Podemos fazer três coisas com relação a trabalho com um arquivo em PERL:
• ler registros
• gravar registros no fim do arquivo
• apagar todo o arquivo e gravar novos registros.
Para cada situação dessas temos que criar um filehandle de forma diferente.Vamos ver:
1. Para ler registros criamos um filehandle com a seguinte linha de comando:
open(FILEHANDLE,"<path do arquivo");
Repare no sinal de menor-do-que ou flexa-para-a-esquerda antes do path mas DENTRO DAS ASPAS.
Um filehandle pode ter qualquer nome.
No provedor HIWAY um arquivo ARQ.TXT numa pasta PUBLIC, num site, tem o path:../PUBLIC/ARQ.TXT. Verifique com seu provedor como se designa paths de arquivos no seu caso.
2. Para gravar registros no fim de um arquivo criamos o filehandle assim:
open(FILEHANDLE,">>path do arquivo");
Caso o arquivo não exista, ele é criado.
3. para APAGAR TODO O ARQUIVO e gravar novos registros temos:
open(FILEHANDLE,">path do arquivo");
Reparem que a diferença dos dois últimos casos é a quantidade de sinais menor-do-que ou flexa-para-a-direita. CUIDADO para não confundir e perder todo um arquivo!
Você pode achar estranha essa história de apagar arquivo e regravar, mas se leu atentamente o último capítulo entende porque. É que não se consegue fazer update facilmente em PERL e é possível (se seu arquivo for muito pequeno) usar o truque de se ler TODO o arquivo para um array-matriz; atualizar a linha e depois REGRAVAR TODO O ARQUIVO.
Para gravar um registro ou uma linha num arquivo, depois de criar o filehandle com OPEN, é só dar um comando print junto com o filehandle de gravação do arquivo e o string a ser gravado.
SEMPRE SE GRAVA TODO O REGISTRO, como vimos no capítulo anterior. Por exemplo, para gravar o string: "XXXXX" num arquivo chamado arq1.txt teremos duas linhas de código:
open(fha1,">>../public/arq1.txt");
print fha1 "XXXXXn";
No caso o filehandle se chamou:fha1.E definimos a gravação como apêndice.
Repare que colocamos o "scape" de linha seguinte (n) depois do string para que o próximo registro seja gravado na linha seguinte. Essas gravações se assemelham a impressões, na realidade. Estamos "printando" no arquivo.
Poderíamos fazer um exercício simplíssimo de gravação de dois registros via Internet em que uma resposta é enviada "on-the-fly" para quem disparou o programa.Você pode ver isso nesse hipertexto. Não precisa fazer esse exercício (que chamamos de prog3.pl só para referência) na prática mas aprenda bem a idéia.
Repare porém a linha de comando:
close (FILEHANDLE);
colocada depois que encerramos a gravação dos registros. Para fechar a porta...
Vamos fazer um exercício simples mas mais sofisticado que o anterior. Vamos misturar o prog2.pl com o prog3.pl.Veja como fica,no hipertexto o que podemos chamar de prog4.pl.
É claro que você tem que ter a página que dispara o programa que é semelhante ao prog2.html só mudando o nome do programa. Veja no hipertexto o que podemos chamar de prog4.html.
Você tem que adaptá-los as suas referências e transportá-los para o seu site (O programa, para o diretório executável (CGI-BIN?) no modo ASCII).
NÃO SE ESQUEÇA DE ACRESCENTAR O ARQUIVO MAGIC.TXT NO FINAL!!!!!
Pode. no entanto executar o nosso, deixando seu nome no livro de "chamada" do nosso curso (não vale assinar por outro).
Vamos mostrar no próximo capítulo como lemos esse e outros arquivos e projetamos na Internet, on-the-fly. Olha o programa rodando aí em baixo:
Entre com seu nome:
PS: Pode entrar com seu nome certo. Não vamos enviar propaganda para seu e-mail nem nada (As "bonecas" e apavorados podem entrar com o "nome de guerra").
OUTRO PS: Uma coisa importante de lembrar é que o UNIX é sensível a
maiúsculas e minúsculas.
Tome cuidado com isso que pode gerar muitos erros.
Vota este artigo
Váriáveis
VBScript são iniciados com base zero, assim este array realmente
contém 11 elementos. Você referencia cada dado de um elemento de array usando um índice. Começando com o zero e finalizando em 10, os dados podem ser atribuidos aos elementos de um array como se segue:
A(0) = 256
A(1) = 324
A(2) = 100
. . .
A(10) = 55
Os dados podem ser recuperados de qualquer elemento usando um índice dentro do elemento de array. Por exemplo:
. . .
SomeVariable = A(8)
. . .
Arrays não são limitados para uma única dimensão. Você pode ter 60 dimensões, embora a maioria das pessoas não compreendem mais que três ou quatro dimensões. Dimensões múltiplas são declaradas com números relativos a sua dimensão, separados por vírgula entre parêntesis. No seguinte exemplo, a variável MyTable possui duas dimensões consistindo de 6 filas e 11 colunas:
Dim MyTable(5, 10) Em um array de duas dimensões, o primeiro número será sempre o número de linhas; e o segundo número, o número de colunas. Você pode também declarar um array cujo tamanho é alterado durante o processamento do script. Este array é chamado de array dinâmico. O array é inicialmente declarado dentro de um procedimento usando a declaração Dim ou ReDim. Entretanto, para um array dinâmico, nenhum tamanho ou dimensão é colocado no interior dos parêntesis. Por exemplo:
Dim MyArray()
ReDim AnotherArray()
Para usar um array dinâmico, você deve subseqüentemente usar a declaração ReDim para determinar o número de dimensões e o
tamanho de cada dimensão. No seguinte exemplo, ReDim atribue 25 ao tamanho inicial do array dinâmico. Com a declaração ReDim é feito um redimencionamento do array para 30, usando a palavra-chave Preserve para preservar o conteúdo do array.
ReDim MyArray(25)
. . .
ReDim Preserve MyArray(30)
Não há limite para o número de vezes que você pode redimensionar um array dinâmico, mas você deve saber que se o array for
Vota este artigo
Operadores do VBScript
Símbolo
Descrição
Símbolo
Exponenciação (^)
Igualdade (=)
Negação
Lógica
Not
Negação do Unary (-)
Desigualdade (<>)
Conjunção
Lógica
And
Multiplicação (*)
Menor que (<)
Disjunction
Lógico
Or
Divisão (/)
Maior que (>)
Exclusão
Lógica
Xor
Divisão Inteira ()
Menor que Ou igual a (<=)
Equivalencia
Lógica
Eqv
Aritmética de Módulo
Mod
Maior que ou Igual a (>=)
Implicação
Lógica
Imp
Adição (+)
Equivalencia de Objeto
Is
Subtração (-)
Concatenação de String (&)
Quando ocorrer a multiplicação e a divisão juntamente em uma
expressão, cada operação é avaliada da esquerda para direita.
Igualmente, quando ocorre a adição e a subtração juntamente em uma expressão, cada operação é avaliada em ordem da esquerda para direita. O operador de concatenação de string (&) não é um operador aritmético, mas por convenção tornou-se e na ordem de resolução, ele está acima de todos os operadores de comparação. O operador Is é um operador de comparação de objetos. Ele não compara objetos ou seus valores; ele apenas checa e determina se duas referências de objeto, referem-se ao mesmo objeto.
Vota este artigo
O que é uma Constante?
redimensionado com uma dimensão menor que a anterior, o conteúdo dos elementos eliminados serão perdidos.
O que é uma Constante? Uma constante é um nome significativo que é recebe um valor númerico ou caracter. O VBScript define um número de constantes intrínsecas. Você pode obter informação sobre essas constantes intrínsecas na Referência da Linguagem VBScript.
Criando Constantes Você pode criar constantes definidas pelo usuário no VBScript usando a declaração Const. Usando a declaração Const, você pode criar constantes strings ou numéricas com nomes significativos que designam seus valores literais. Por exemplo:
Const MinhaString = "Isto é meu minha cadeia de caracter."
Const MinhaIdade = 49
Note que a string literal é cercada entre aspas ou marcas de citação (" "). As aspas são caminho óbvio para diferenciar valores de string de valores numéricos. Datas e valores do tempo são representados tendo o sinal (#) cercando o valor. Por Exemplo:
Const MeuAniversario = #23-8-76#.Você pode desejar adotar um esquema específico para diferenciar constantes de variáveis. Este
procedimento evita durante a execução do script, ocorrer um engano e usar constantes como variáveis e vice-versa. Por exemplo, você pôde usar prefixos "vb" ou "con" nos nomes de suas constantes, ou criar sua própria nomeclatura. Diferenciando constantes de variáveis, você elimina a possibilidade de ocorrer
um erro ao desenvolver scripts mais complexos.
Operadores do VBScript
O VBScript tem uma série de operadores, incluindo operadores de
aritmética, operadores de comparação, operadores de concatenação, e , operadores lógicos.
Precedência do Operador
Quando várias operações ocorrem em uma expressão, cada parte é avaliada e resolvida em uma ordem predeterminada chamada
precedência do operador. Você pode usar parêntesis para alterar a ordem de precedência e forçar a avaliação de algumas partes de uma expressão. Operações dentro de parêntesis são sempre resolvidas primeiro independendo da ordem de resolução dos operadores. Dentro dos parêntesis, entretanto, a ordem de resolução dos operadores é mantida. Quando expressões contêm operadores de mais de uma categoria, os operadores aritméticos são avaliados primeiros, depois os operadores de comparação, e os operadores lógicos são avaliados por último. Todos os operadores de comparação tem precedências iguais; estes,
são avaliados da esquerda-para-direita. Os operadores Lógicos e de Aritmética são avaliados na seguinte ordem.
Aritmética
Comparação
Lógico
Descrição
Símbolo
Descrição</P< font>
Vota este artigo
Abrindo Novas Janelas Continuação
•toolbar - Cria uma barra de ferramentas tipo "Back", "Forward", etc.
•location - Abre a barra de location do browse
•directories - Abre a barra de ferramentas tipo "What's New", "Handbook", etc.
•status - Abre uma barra de status no rodapé da janela
•scrollbars - Abre barras de rolamento vertical e horizontal
•menubar - Cria uma barra de menu tipo "File", "Edit", etc.
•resizable - Permite ao usuário redimencionar a janela
•width - Especifica a largura da janela, em pixels
•height - Especifica a altura da janela, em pixels
Todas as opções (exceto width e height) são boleanas e podem ser setadas de duas formas. Exemplo: "toolbar" ou "toolbar=1") são a mesma coisa. Se nada for especificado, entende-se que todas as opções estão ligadas; Caso seja especificada qualquer opção, será entendido que estão ligadas apenas as opções informadas.
As opções devem ser informadas separadas por vírgula, sem espaço entre elas.
Abrindo um Documento
Para abrir um documento dentro da janela, deve ser utilizado o seguinte método:
Variavel.document.open()
Onde "Variavel" é o nome da variável associada ao método window.open
Escrevendo no Documento
Para escrever a tela no documento, deve ser utilizado o seguinte método:
Variavel.document.write ("Comandos html, Comandos JavaScript, Textos, etc.")
Fechando a Janela
Para fechar a janela, utilize o seguinte método:
Variavel.document.write ("window.close()")
Fechando o Documento
Para fechar o documento, utilize o seguinte método:
Variavel.document.close ()
A seguir, apresentamos um exemplo no qual estamos abrindo um documento onde o usuário escolherá uma opção (Elógica ou Recife) e dará um Click em um botão (Nova Janela). Neste momento será aberta uma nova janela que conterá a foto escolhida pelo usuário e um botão que,
ao receber o Click, fechará a janela.
Normalmente, qualquer href ou src dentro de uma página, por padrão, acessa o arquivo ou a imagem no mesmo diretório onde está a página atual, a menos que seja especificado um novo caminho (Path).
Vota este artigo
Final do Exemplo e Abrindo Novas Janelas
<form name="DataHora">
Data : <input type=text size=10 maxlength=10 name="Data">
Hora : <input type=text size=10 maxlength=10 name="Hora">
<input type=radio name="Botao" value="Para Relogio" checked
onclick="clearTimeout(ContrRelogio)">Desativa
<input type=radio name="Botao" value="Ativa Relogio"
onclick="ContrRelogio = setTimeout('Hoje()', 1000)">Ativa
</form>
ABRINDO NOVAS JANELAS
Neste capítulo mostraremos como podem ser abertas novas janelas sobre uma janela contendo o documento principal.
É importante não confundir esta forma de abrir janelas com a divisão da tela em várias partes, ou mesmo com a chamada de outras páginas. Para que não existam dúvidas, explicaremos um pouco sobre estes dois outros métodos.
A divisão de uma tela em várias janelas contendo documentos diferentes é feita através do objeto FRAME do Html. Neste caso, a tela inteira é considerada como um FrameSet e cada parte em que ela for dividida é considerada como um Frame. Cada Frame é definido dentro do FrameSet através da especificação dos parâmetros: % da tela na vertical (cols), % da tela na horizontal (rows) e nome de cada frame. Uma vez criado o FrameSet poderemos abrir documentos distintos em cada Frame. Para fazer isto, acrescente ao link do documento a diretiva target=nome do frame.
Ex.
<href="Eventos.htm" target="Principal">
Isto fará com que o arquivo html Eventos.htm seja aberto dentro do frame de nome Principal
A simples chamade de outras telas (documentos) é feita através do link para o documento desejado.
Ex.
<href="Eventos.htm" >
Isto fará com que o arquivo html Eventos.htm seja aberto em substituição a tela existente.
Bem, voltemos ao nosso caso que é a abertura de janelas sobre um documento. Isto é feito através de comandos JavaScript, que permitem: Abrir uma janela, Abrir um documento dentro desta janela, Escrever o conteúdo da janela, Fechar a janela e Fechar o documento.
Abrindo a Janela
A sintaxe geral deste método é a seguinte:
Variavel = window.open ("Url", "Nome da janela", "Opções")
Onde:
Variavel - Nome que será atribuido como propriedade da janela.
Url - Endereço Internet onde a janela será aberta. Normalmente voce estará utilizando a sua
própria Url, neste caso, preencha com "".
Nome da Janela - É o nome que aparecerá no top da janela (Título)
Opções - São as opções que definem as características da janela, quais sejam:
Vota este artigo
Usando Timer e Date
DadosOk = true
} </script>
<form name="TstFocus" method="POST"> <p>
Informe o seu Nome <input type=text size=30 maxlength=30 name="Nome"> </p><p> Informe o mês desejado <input type=text size=2 maxlength=2 name="Mes"></p>
<p> Informe o ano desejado <input type=text size=4 maxlength=4 name="Ano" > </p>
<p> <input type=button name="Testa" value="Testar Validade"
onclick="Criticar() if (DadosOk)
{alert ('Todos os Dados estão Corretos') } "> /
</p> </form>
USANDO TIMER e DATE
É um método que permite a programação para que uma determinada ação só ocorra após o transcurso de um determinado tempo.
Variável = setTimeout ("ação", tempo)
Onde:
Variável é uma variável apenas para controle do timer
ação é a ação que se quer realizar.
tempo é o tempo de espera para que a ação ocorra, em milisegundos.
Obs:
É importante observar que a ação só ocorrerá uma vez. Para que a ação volte a ocorrer, será necessário repetir o comando dentro da ação, obtendo-se, assim, um LOOP.
Para interromper um LOOP, provocado pela forma acima, deve-se utilizar o seguinte método:
clearTimeout (Variável)
Onde:
Variável é o nome da variável de controle do timer.
Abaixo encontra-se um exemplo de um formulário que apresenta a data e hora atual, atualizando os dados a cada um segundo, tendo dois botões de rádio que tem a função de ativar e desativar a atualização dos dados. Apresenta também, fora do formulário, a data contendo dia e mês por extenso.
Vota este artigo
Exemplo
<script>
function Hoje() {
ContrRelogio = setTimeout ("Hoje()", 1000)
Hr = new Date()
dd = Hr.getDate()
mm = Hr.getMonth() + 1
aa = Hr.getYear()
hh = Hr.getHours()
min = Hr.getMinutes()
seg = Hr.getSeconds()
DataAtual = ((dd < 10) ? "0" + dd + "/" : dd + "/")
DataAtual += ((mm < 10) ? "0" + mm + "/" + aa : mm + "/" + aa)
HoraAtual = ((hh < 10) ? "0" + hh + ":" : hh + ":")
HoraAtual += ((min < 10) ? "0" + min + ":" : min + ":")
HoraAtual += ((seg < 10) ? "0" + seg : seg)
document.DataHora.Data.value=DataAtual
document.DataHora.Hora.value=HoraAtual
}
//
function CriaArray (n) {
this.length = n }
//
NomeDia = new CriaArray(7)
NomeDia[0] = "Domingo"
NomeDia[1] = "Segunda"
NomeDia[2] = "Terça"
NomeDia[3] = "Quarta"
NomeDia[4] = "Quinta"
NomeDia[5] = "Sexta"
NomeDia[6] = "Sábado"
//
NomeMes = new CriaArray(12)
NomeMes[0] = "Janeiro"
NomeMes[1] = "Fevereiro"
NomeMes[2] = "Março"
NomeMes[3] = "Abril"
NomeMes[4] = "Maio"
NomeMes[5] = "Junho"
NomeMes[6] = "Julho"
NomeMes[7] = "Agosto"
NomeMes[8] = "Setembro"
NomeMes[9] = "Outubro"
NomeMes[10] = "Novembro"
NomeMes[11] = "Dezembro"
//
Data1 = new Date()
dia = Data1.getDate()
dias = Data1.getDay()
mes = Data1.getMonth()
ano = Data1.getYear()
document.write ("Recife, " + NomeDia[dias] + " " + dia + " de " +
NomeMes[mes] + " de " + (ano + 1900 ) )
</script>
Vota este artigo
Outro Exemplo
Ex.
<body onload="document.TstFocus.Nome.focus()">
<script>
DdosOk = true
function Criticar() {
DadosOk = false
DataAtual = new Date()
MesAtual = DataAtual.getMonth() + 1
AnoAtual = DataAtual.getYear() + 1900
Nome = document.TstFocus.Nome.value
Mes = parseInt(document.TstFocus.Mes.value)
Ano = parseInt (document.TstFocus.Ano.value)
//
if (Ano < 1900)
{Ano = Ano + 1900 }
if (Nome == "")
{ alert ("Informe o seu Nome, Não deixe em branco")
document.TstFocus.Nome.focus()
return }
if (Mes < 1 || Mes > 12)
{ alert ("O Mês informado não é válido, informe corretamente") document.TstFocus.Mes.focus()
document.TstFocus.Mes.select()
return }
if (Ano == AnoAtual && Mes > MesAtual)
{ alert ("O período informado é superior a data atual")
document.TstFocus.Mes.focus()
document.TstFocus.Mes.select()
return }
if (Ano < 1996 || Ano > AnoAtual)
{ alert ("O Ano informado não é válido, informe corretamente") document.TstFocus.Ano.focus()
document.TstFocus.Ano.select()
return }
DadosOk = true
}
</script>
<form name="TstFocus" method="POST">
<p>
Informe o seu Nome <input type=text size=30 maxlength=30 name="Nome">
</p>
<p> Informe o mês desejado <input type=text size=2 maxlength=2 name="Mes">
</p>
<p> Informe o ano desejado <input type=text size=4 maxlength=4 name="Ano" >
</p>
<p> <input type=button name="Testa" value="Testar Validade"
onclick="Criticar()
if (DadosOk)
{alert ('Todos os Dados estão Corretos') } ">
</p>
</form>
Vota este artigo
Mais exemplos 1,2,3,4,5
Exemplo 1
Caso seja omitido, será enviado o valor default "on" .
Esta propriedade também serve para ativar comandos lógicos, testando-se a condição
de "checked".
checked : Especifica que o objeto inicialmente estará ligado
O único evento associado a este objeto é onclick.
Ex:
No exemplo abaixo, criaremos um objeto input.text e três objetos checkbox. O primeiro checkbox, quando ativado, transformará o texto em caracteres minúsculos. O segundo checkbox, quando ativado, transformará o texto em caracteres maiúsculos. O terceiro checkbox, quando ativado, dará um aviso do conteúdo que será recebido pelo "server" caso o formulário seja submetido para este.
<SCRIPT>
function AltMaiusc () {
document.TCheck.Muda.value = document.TCheck.Muda.value.toUpperCase() document.TCheck.Opt1.checked = false
}
function AltMinusc () {
document.TCheck.Muda.value = document.TCheck.Muda.value.toLowerCase() document.TCheck.Opt2.checked = false
}
</SCRIPT>
<p>
<form name="TCheck">
Muda Case <input type=text size=20 maxlength=20 name="Muda"> </p>
<p>
Minusculo<input type=checkbox name="Opt1" value="1" checked
onclick="if (this.checked)
{ AltMinusc() } ">
Maiusculo<input type=checkbox name="Opt2" value="2"
onclick="if (this.checked)
{ AltMaiusc() } ">
Demo valor<input type=checkbox name="Opt3"
onclick="if (Opt3.checked)
{alert ('Server recebera = ' + Opt3.value) } ">
</p>
</form>
Existe ainda uma outra forma de manipular este objeto, em forma de array, que é a seguinte: form.elements[index].propriedade. Esta não é uma boa forma porque o index é único dentro de um formulário, exigindo muito cuidado quando se acrescenta ou se deleta um objeto, pois, neste caso, haverá um natural deslocamento do index, podendo comprometer a lógica.
Objeto Input RADIO
São objetos que permitem ao usuário a escolha de apenas uma alternativa, diante de uma série de opções.
Suas principais propriedades são: name, value e checked.
name : Especifica o nome do objeto. Para caracterizar uma mesma série de opções, todos os objetos desta série têm que ter o mesmo "name".
Mais exemplos 2
value : Especifica o valor que será enviado ao "server" se o objeto estiver ligado (checked). Caso seja omitido, será enviado o valor default "on" . Esta propriedade também serve para
ativar comandos lógicos, testando-se a condição de "checked".
checked : Especifica que o objeto inicialmente estará ligado
Para utilização deste objeto é importante o conhecimento de outras propriedades associadas:
Objeto.length : Retorna a quantidade de opções existentes na lista
Objeto.[index].value : retorna o texto (value) associado a cada opção
Objeto.[index].checked : retorna verdadeiro ou falso
O único evento associado a este objeto é onclick.
Ex. No exemplo abaixo temos dois set's de objetos radio. O primeiro tem o objetivo de mudar a cor de fundo do documento atual. O segundo tem o objetivo levar informações ao "server".
<p>Radio</p>
<p> <input type=radio name="Rad" value="1"
onclick="document.bgColor='green'"> Fundo Verde
<input type=radio name="Rad" value="2" onclick="document.bgColor='blueviolet'"> Fundo Violeta
<input type=radio name="Rad" value="3"
onclick="document.bgColor='#FFFF00'"> Fundo Amarelo
</p>
Objeto Input BUTTON
Este objeto tem por finalidade criar um botão ao qual se possa atrelar operações lógicas, a serem executadas quando o mesmo receber um click.
Suas propriedades são: name e value.
name : Especifica o nome do objeto.
value : Especifica o nome que aparecerá sobre o botão
O único evento associado a este objeto é onclick.
Ex.
<p>
<form method="POST" name="TstButton">
Digite um Texto <input type=text size=30 maxlength=30 name="Teste" value="">
</p><p>
Click no Botao <input type=button name="Bteste" value="Botao de teste"
onclick="alert ('Voce digitou: ' + TstButton.Teste.value)">
</p>
</form>
Objeto Input RESET
Este objeto é um botão que tem por finalidade, única, limpar os campos digitados pelo usuário, restaurando o conteúdo do formulário para os valores iniciais.
É recomendável a utilização deste objeto, para facilitar o usuário a limpar suas informações, uma vez que a utilização da opção "reload" do "browser" (que seria uma forma) não perde as infromações digitadas.
Suas propriedades são: name e value.
name : Especifica o nome do objeto.
value : Especifica o nome que aparecerá sobre o botão
O único evento associado a este objeto é onclick
Mais exemplos 3
Ex.
<p>
<form method="POST" name="TesteRes">
Digite um Texto<input type=text size=10 maxlength=20 name="Teste" value="">
Apague o Texto <input type=reset name="Bres" value="Reset">
</form>
</p>
Objeto Input SUBMIT
Este objeto é um botão que tem por finalidade submeter (enviar) o conteúdo dos objetos do formulário ao "server". O formulário será submetido à URL especificada na propriedade "action" do formulário.
Suas propriedades são: name e value.
name : Especifica o nome do objeto.
value : Especifica o nome que aparecerá sobre o botão
O único evento associado a este objeto é onclick. Embora se possa atrelar lógica a este evento, não se pode evitar que o formulário seja submetido, portanto, não é aconselhavel o seu uso. Mais seguro e mais útil é a utilização da propriedade onSubmit do formulário. Este permite que se atrele lógica e decida-se pela submissão ou não.
Ex.
<script>
function TestaVal() {
if (document.TesteSub.Teste.value == "") {
alert ("Campo nao Preenchido...Form nao Submetido")
return false }
else {
alert ("Tudo Ok....Form Submetido")
return true } }
</script>
<p>
<form method="POST" name="TesteSub"
onSubmit="return TestaVal()"
action="http://10.0.5.2/scripts/isapielo.dll/vbloja.loja.action">
Digite um Texto <input type=text size=10 maxlength=10 name="Teste" value="">
Botao Submit <input type=submit name="Bsub" value="Manda p/Server">
</p>
</form>
No exemplo acima, o formulário está sendo submetido a URL "10.0.5.2" (que é o endereço IP
de um "Server"). Este servidor está rodando o "Microsoft Internet Information Server". Estamos
enviando os dados a um "OLE", que está no subdiretório "scripts", chamado "isapielo.dll", que tem
por objetivo fazer a conecção com aplicações escritas em VB. A aplicação VB que está sendo
chamada, é um OLE de nome "vbloja" no qual estamos acionando a classe "loja" e o método
"action".
A aplicação VB, deste exemplo, fará apenas a devolução dos dados recebidos pelo Server.
Objeto TEXTAREA
Mais exemplos 4
É um objeto para entrada de dados em um campo de múltiplas linhas. Suas principais propriedades são: name, rows e cols.
name : Especifica o nome do objeto
rows : Especifica a quantidade de linhas que aparecerão na tela
cols : Especifica a quantidade de caracteres que aparecerão em cada linha
value : Acessa o conteúdo do campo via programação.
Os eventos associados a este objeto são: onchange, onblur, onfocus e onselect.
Ex:
<form name="TesteTextarea">
<p>
Texto de Múltiplas Linhas <textarea name="MultText" rows=2 cols=40>
Primeira linha do texto inicial
segunda linha do texto inicial
</textarea>
</p>
Objeto SELECT
É um objeto para entrada de opções, onde o usuário, a partir de uma lista de alternativas, seleciona uma ou mais opções.
Suas principais propriedades são: name, size, value e multiple.
name : Especifica o nome do objeto
size : Especifica a quantidade de opções que aparecerão na tela simultaneamente
value : Associa um valor ou string para cada opção (opcional)
multiple : Especifica a condição de múltipla escolha (usando-se a tecla Ctrl)
Para utilização deste objeto é importante o conhecimento de outras propriedades associadas:
Objeto.length : Retorna a quantidade de opções existentes na lista
Objeto.selectedindex : Retorna o "index" do objeto selecionado (primeiro = 0) Objeto.options[index].text : retorna o texto externo associado a cada opção Objeto.options[index].value : retorna o texto interno (value) associado a cada opção Objeto.options[index].selected : retorna verdadeiro ou falso
Os eventos associados a este objeto são: onchange, onblur e onfocus.
Ex1:
Neste exemplo é importante observar os seguintes aspectos:
a) A lista permite apenas uma seleção
b) A quarta opção aparecerá inicialmente selecionada (propriedade "selected")
c) Não utilizamos a propriedade "value". Assim, a propriedade "text" e a propriedade "value"
passam a ter o mesmo valor, ou seja, o valor externo que aparece na tela.
<script>
function Verselect(Campo) {
Icombo = Campo.selectedIndex
alert ("Voce escolheu " + Campo.options[Icombo].text) }
</script>
<p>
Objeto Select <select name="Combo1" size=1 onchange="Verselect(Combo1)">
<option>Opcao 1
<option>Opcao 2
<option>Opcao 3
<option selected>Opcao 4 (recomendada)
<option>Opcao 5
<option>Opcao 6
</select>
</p>
Mais exemplos 5
Ex2:
Neste exemplo é importante observar os seguintes aspectos:
a) A lista permite múltiplas seleções
b) Utilizamos a propriedade "value". Assim as propriedades "text" e "value"
têm valores diferentes: text retornará Escolha 1 a Escolha 4 e value
retornará List1 a List4.
c) O parâmetro passado, quando da ocorrência do evento onblur, foi this.
Esta diretiva significa que estamos passando este objeto.
<script>
function Vermult(Lista) {
var opcoes = ""
for (i = 0 ; i < Lista.length ; i++) {
if (Lista.options[i].selected) {
opcoes += (Lista.options[i].value + ", ") }
}
alert ("As opcoes escolhidas foram : " + opcoes) }
</script>
<p>
Objeto Select2 <select name="Combo2" size=4 multiple onblur="Vermult(this)">
<option value="List1">Escolha 1 </option>
<option value="List2">Escolha 2 </option>
<option value="List3">Escolha 3 </option>
<option value="List4">Escolha 4 </option>
</select>
</p>
Focando um Objeto
Este método permite que o cursor seja ativado em um determinado objeto (focado). Isso pode ser feito na carga do documento, a partir da ocorrência de um evento ou mesmo dentro de uma função.
Observe que até agora o usuário tinha que dar um "Click" para focar o objeto desejado.
De forma semelhante existe o método "Select". Este método marca o conteúdo do objeto com uma tarja roxa, permitindo ao usuário, em caso de substituição do conteúdo do campo, não ter que deletar o conteúdo anterior, pois, com este método, a deleção se dá de forma automática quando da digitação do novo conteúdo.
Os métodos "Focus" e "Select" podem ser utilizados nos seguintes objetos:
password, select, text e textarea
No exemplo abaixo, utilizaremos o evento onload para setar o focus para o primeiro objeto do formulário e os métodos focus e select para, na rotina de crítica dos dados, focar o objeto que contiver erro de preenchimento.
.
Vota este artigo
Exemplos
Ex:
<form name="TText">
<p>Entrada de Texto <input type=text size=20 maxlength=30 name="CxTexto" value="" onchange="alert ('Voce digitou ' + CxTexto.value)">
</p>
</form>
Objeto Input PASSWORD
É o objeto para entrada de Senhas de acesso (password). Os dados digitados neste objeto são criptografados e, só são interpretados (vistos) pelo "server", por razões de segurança.
Suas principais propriedades são: type, size, maxlength, name e value.
type=password : Especifica um campo para entrada de senha. Os dados digitados são substituidos (na tela) por "*".
size : Especifica o tamanho do campo na tela.
maxlength : Especifica a quantidade máxima de caracteres permitidos.
name : Especifica o nome do objeto
value : Armazena o conteúdo digitado no campo.
Os eventos associados a este objeto são: onchange, onblur, onfocus e onselect.
Ex:
<form name="TPassword">
<p>Entrada de Senha<input type=password size=10 maxlength=10 name="Senha" value="">
</p>
</form>
Objeto Input HIDDEN
É um objeto semelhante ao input text, porém, invisível para o usuário. Este objeto deve ser utilizado para passar informações ao "server" (quando o formulário for submetido) sem que o usuário tome conhecimento. Suas propriedades são: name e value.
name : Especifica o nome do objeto.
value : Armazena o conteúdo do objeto
Ex:
<form name="THidden">
<input type=hidden size=20 maxlength=30 name="HdTexto" value="" >
</form>
</p>
Objeto Input CHECKBOX
São objetos que permitem ao usuário ligar ou desligar uma determinada opção.
Suas principais propriedades são: name, value e checked.
name : Especifica o nome do objeto
value : Especifica o valor que será enviado ao "server" se o objeto estiver ligado (checked).
Vota este artigo
Interagindo com o usuário
DataToda = new Date()
DiaHoje = DataToda.getDay()
Para obter o dia da semana alfa,
teremos que construir uma tabela com os dias da semana e
utilizar a variável DiaHoje como indexador.
function CriaTab (n) {
this.length = n
for (var x = 1 ; x<= n ; x++)
{ this[x] = "" } }
NomeDia = new CriaTab(7)
NomeDia[0] = "Domingo"
NomeDia[1] = "Segunda"
NomeDia [2] = "Terça"
NomeDia[3] = "Quarta"
NomeDia[4] = "Quinta"
NomeDia[5] = "Sexta"
NomeDia[6] = "Sábado"
DiaSemana = NomeDia[DiaHoje]
Para criar uma variável tipo Date com o conteúdo informado pela aplicação, existe o método
set. Assim, temos os seguintes métodos: setDate, setDay, setMonth, setYear, setHours, setMinutes e setSeconds.
Seguindo o exemplo acima, para mudar o mês para novembro, teríamos:
DataToda.setMonth(10)
Exemplos adicionais serão encontrados no capítulo "Usando Timer e Date
INTERAGINDO COM O USUÁRIO
A interação com o usuário se dá através de objetos para entrada de dados (textos), marcação de opções (radio, checkbox e combo), botões e link's para outras páginas.
Conceitualmente, os objetos são divididos em: Input, Textarea e Select.
O objeto Input divide-se (propriedade Type) em:
•Password •Text •Hidden •Checkbox •Radio •Button •Reset •Submit
A construção destes objetos é feita pela linguagem HTML (HiperText Mark-up Language). Portanto, é aconselhável que sejam criados utilizando-se ferramentas de geração de páginas HTML, como o HotDog ou, mais recomendado, FrontPage.
Objeto Input TEXT
É o principal objeto para entrada de dados.
Suas principais propriedades são: type, size, maxlength, name e value.
type=text : Especifica um campo para entrada de dados normal
size : Especifica o tamanho do campo na tela.
maxlength : Especifica a quantidade máxima de caracteres permitidos.
name : Especifica o nome do objeto
value : Armazena o conteúdo do campo.
Os eventos associados a este objeto são: onchange, onblur, onfocus e onselect
Vota este artigo
MANIPULANDO STRING's
O JavaScript é bastante poderoso no manuseio de String´s, fornecendo ao programador uma total
flexibilidade em seu manuseio.
Abaixo apresentamos os métodos disponíveis para manuseio de string´s.
string.length - retorna o tamanho da string (quantidade de bytes)
string.charAt(posição) - retorna o caracter da posição especificada (inicia em 0)
string.indexOf("string") - retorna o número da posição onde começa a primeira "string"
string.lastindexOf("string") - retorna o número da posição onde começa a última "string"
string.substring(index1, index2) - retorna o conteúdo da string que corresponde ao intervalo especificado. Começando no caracter posicionado em index1 e terminando no caracter imediatamente anterior ao valor especificado em index2.
Ex.
Todo = "Elogica" Parte = Todo.substring(1, 4)
(A variável Parte receberá a palavra log) string.toUpperCase() - Transforma o conteúdo da string para maiúsculo (Caixa Alta) string.toLowerCase() - Transforma o conteúdo da string para minúsculo (Caixa Baixa) escape ("string") - retorna o valor ASCII da string (vem precedido de %) unscape("string") - retorna o caracter a partir de um valor ASCII (precedido de %)
MANIPULANDO DATAS
Existe apenas uma função para que se possa obter a data e a hora. É a função Date(). Esta função devolve data e hora no formato:Dia da semana, Nome do mês, Dia do mês, Hora:Minuto:Segundo e Ano
Ex.
Fri May 24 16:58:02 1996
Para se obter os dados separadamente, existem os seguintes métodos:
getDate() - Obtém o dia do mês (numérico de 1 a 31)
getDay() - Obtém o dia da semana (0 a 6)
getMonth() - Obtém o mês (numérico de 0 a 11)
getYear() - Obtém o ano
getHours() - Obtém a hora (numérico de 0 a 23)
getMinutes() - Obtém os minutos (numérico de 0 a 59)
getSeconds() - Obtém os segundos (numérico de 0 a 59)
No exemplo abaixo obteremos o dia da semana. Para tal, utilizaremos a variável DataToda
para armazenar data/hora e a variável DiaHoje para armazenar o número do dia da semana.
Vota este artigo
Exemplo
Agora podemos criar novas instâncias do objeto "CriaArray" e alimentá-los com os dados necessários.
NomeDia = new CriaArray(7)
NomeDia[0] = "Domingo"
NomeDia[1] = "Segunda"
NomeDia [2] = "Terça"
NomeDia[3] = "Quarta"
NomeDia[4] = "Quinta"
NomeDia[5] = "Sexta"
NomeDia[6] = "Sábado"
Atividade = new CriaArray(5)
Atividade[0] = "Analista"
Atividade[1] = "Programador"
Atividade[2] = "Operador"
Atividade[3] = "Conferente"
Atividade[4] = "Digitador"
Agora poderemos obter os dados diretamente dos arrays.
DiaSemana = NomeDia[4]
Ocupação = Atividade[1]
DiaSemana passaria a conter Quinta e Ocupação conteria Programador.
Outra forma de se trabalhar com arrays é criar novas instâncias dentro do próprio objeto do
array, o que proporciona o mesmo efeito de se trabalhar com matriz. Isso pode ser feito da
seguinte forma:
function Empresas (Emp, Nfunc, Prod) {
this.Emp = Emp
this.Nfunc = Nfunc
this.Prod = Prod }
TabEmp = new Empresas(3)
TabEmp[1] = new Empresas("Elogica", "120", "Serviços")
TabEmp[2] = new Empresas("Pitaco", "35", "Software")
TabEmp[3] = new Empresas("Corisco", "42", "Conectividade")
Assim, poderemos obter a atividade da empresa número 3, cuja resposta seria Conectividade, da seguinte forma:
Atividade = TabEmp[3].Prod
Obs:
É importante lembrar que, embora os exemplos estejam com indexadores fixos, os indexadores podem ser referências ao conteúdo de variáveis.
Vota este artigo
CRIANDO NOVAS INSTÂNCIAS
Através do operador new podem ser criadas novas instâncias a objetos já existentes, mudando o
seu conteúdo, porém, mantendo suas propriedades.
A sintaxe geral é a seguinte:
NovoObjeto = new ObjetoExistente (parâmetros)
Ex1.
MinhaData = new Date ()
MinhaData passou a ser um objeto tipo Date, com o mesmo conteúdo existente em Date
(data e hora atual)
Ex2:
MinhaData = new Date(1996, 05, 27)
MinhaData passou a ser um objeto tipo Date, porém, com o conteúdo de uma nova data.
Ex3:
Suponha a existência do seguinte objeto chamado Empresas
function Empresas (Emp, Nfunc, Prod)
{ this.Emp = Emp
this.Nfunc = Nfunc
this.Prod = Prod }
Podemos criar novas instâncias, usando a mesma estrutura, da seguinte forma:
Elogica = new Empresas("Elogica", "120", "Serviços")
Pitaco = new Empresas("Pitaco", "35", "Software")
Corisco = new Empresas("Corisco", "42", "Conectividade")
Assim, a variável Elogica.Nfunc terá o seu conteúdo igual a 120.
MANIPULANDO ARRAYS
O JavaScript não tem um tipo de dado ou objeto para manipular arrays. Por isso, para trabalhar com arrays é necessário a criação de um objeto com a propriedade de criação de um array.
No exemplo abaixo, criaremos um objeto tipo array de tamanho variável e com a função de "limpar" o conteúdo das variáveis cada vez que uma nova instância seja criada a partir dele.
function CriaArray (n) {
this.length = n
for (var i = 1 ; i <= n ; i++)
{ this[i] = "" } }
Vota este artigo
Funções Intrísecas
Observe-se que o parâmetro passado (quando ocorre o evento "onchange") foi o conteúdo da caixa de texto "Tempo" (propriedade "value") e que, na função, chamamos de "Anos". Ou seja, não existe co-relação entre o nome da variável passada e a variável de recepção na função. Apenas o conteúdo é passado.
FUNÇÕES INTRÍNSECAS
São funções embutidas na própria linguagem. A sintaxe geral é a seguinte:
Result = função (informação a ser processada)
- eval = Calcula o conteúdo da string
- parseInt - Transforma string em inteiro
- parseFloat - Transforma string em número com ponto flutuante
- date() - Retorna a data e a hora (veja o capítulo manipulando datas)
ex1: Result = eval ( " (10 * 20) + 2 - 8")
ex2: Result = eval (string)
No primeiro exemplo Result seria igual a 194. No segundo, depende do conteúdo da string, que também pode ser o conteúdo (value) de uma caixa de texto.
- Funções tipicamente Matemáticas:
Math.abs(número) - retorna o valor absoluto do número (ponto flutuante)
Math.ceil(número) - retorna o próximo valor inteiro maior que o número
Math.floor(número) - retorna o próximo valor inteiro menor que o número
Math.round(número) - retorna o valor inteiro, arredondado, do número
Math.pow(base, expoente) - retorna o cálculo do exponencial
Math.max(número1, número2) - retorna o maior número dos dois fornecidos
Math.min(número1, número2) - retorna o menor número dos dois fornecidos
Math.sqrt(número) - retorna a raiz quadrada do número
Math.SQRT2 - retorna a raiz quadrada de 2 (aproximadamente 1.414)
Math.SQRT_2 - retorna a raiz quadrada de 1/2 (aproximadamente 0.707)
Math.sin(número) - retorna o seno de um número (anglo em radianos)
Math.asin(número) - retorna o arco seno de um número (em radianos)
Math.cos(número) - retorna o cosseno de um número (anglo em radianos)
Math.acos(número) - retorna o arco cosseno de um número (em radianos)
Math.tan(número) - retorna a tangente de um número (anglo em radianos)
Math.atan(número) - retorna o arco tangente de um número (em radianos)
Math.pi retorna o valor de PI (aproximadamente 3.14159)
Math.log(número) - retorna o logarítmo de um número
Math.E - retorna a base dos logarítmos naturais (aproximadamente 2.718)
Math.LN2 - retorna o valor do logarítmo de 2 (aproximadamente 0.693)
Math.LOG2E - retorna a base do logarítmo de 2 (aproximadamente 1.442)
Math.LN10 retorna o valor do logarítmo de 10 (aproximadamente 2.302)
Math.LOG10E - retorna a base do logarítmo de 10 (aproximadamente 0.434)
Observação:
Em todas as funções, quando apresentamos a expressão "(número)", na verdade queremos
nos referir a um argumento que será processado pela função e que poderá ser: um número,
uma variável ou o conteúdo de um objeto (propriedade value).
Vota este artigo
Uma função é um set de instruções, que só devem ser executadas quando a função for acionada.
A sintaxe geral é a seguinte:
function NomeFunção (Parâmetros)
{ Ação }
Suponha uma função que tenha como objetivo informar se uma pessoa é maior ou menor de idade, recebendo como parâmetro a sua idade.
function Idade (Anos) {
if (Anos > 17)
{ alert ("Maior de Idade") }
else
{ alert ("menor de Idade") }
}
Para acionar esta função, suponha uma caixa de texto, em um formulário, na qual seja informada a idade e, a cada informação, a função seja acionada.
<form>
<input type=text size=2 maxlength=2 name="Tempo"
onchange="Idade(Tempo.value)">
</form>
Vota este artigo
Providencia um espaço de armazenamento para tabelas e outras ações temporárias ou intermediárias, tais como resultados que envolvam a cláusula GROUP BY, ORDER BY, DISTINCT e cursores (CURSORS). Possui as seguintes características:
a) criado automaticamente no DEVICE MASTER (atenção, DEVICE e DATABASE são coisas diferentes);
b) seu conteúdo é apagado quando o usuário fecha a conexão, exceto para tabelas temporárias globais;
c) quando o banco é parado (stoped) seu conteúdo é apagado completamente;
d) seu tamanho padrão é de 2 Mbytes.
e) pode ser colocado em memória RAM.
1.2 banco de dados MSDB
Providencia suporte ao serviço SQL Executive Service (o qual fornece serviços de schedulle de tarefas, replicação, gerenciamento de alertas). Possui as seguintes tabelas de sistema:
a) sysalerts - armazena informações sobre todos os alertas definidos por usuários;
b) sysoperators - informações sobre os operadores;
c) sysnotifications - relaciona quais operadores devem receber quais alertas;
d) systasks - mantém informações sobre todas as tarefas definidas por usuários;
e) syshistory - informações a respeito de quando um alerta e uma tarefa foram executados, se com sucesso ou falha, identificação do operador, data e hora da execução;
f) sysservermessages - mensagens sobre as operações relacionadas ao servidor.
1.3 localização dos bancos de dados
Os bancos de dados ficam armazenados em arquivos físicos que recebem o nome de DEVICES. Um DEVICE ocupa sempre a quantidade de disco que for a ele destinada, independentemente da existência ou não de bancos de dados em seu interior e independentemente da taxa de ocupação destes databases. Ou seja, mesmo vazio ele ocupará a porção de disco a ele destinada com seu arquivo
Vota este artigo
Funções de String
- Len
Esta função retorna o total de caracteres de uma string.
Sintaxe: Len(string)
Exemplo:
<CFSET tamanho = Len("coldfusionbrasil")>
- LTrim
Remove todos os espaços em branco à esquerda de uma string.
Sintaxe: LTrim(string)
Exemplo:
<CFSET palavra = Rtrim(" coldfusionbrasil")>
- RTrim
Remove todos os espaços em branco à direita de uma string.
Sintaxe: RTrim(string)
Exemplo:
Vota este artigo
Utilizando as funções de formatação DateFormat e TimeFormat [ Cold Fusion ]
Utilizando as funções de formatação DateFormat e TimeFormat
Vimos no exemplo anterior como utilizar na prática as funções de data e hora, e
agora poderemos otimizar este exemplo utilizando as funções DateFormat e
TimeFormat. Vejamos como:
<CFSET data_atual = DateFormat(Now(),"dd/mm/yyyy")>
<CFSET hora_atual = TimeFormat(Now(),"HH:mm:ss")>
<CFOUTPUT>
Data Gerada pelo sistema: #Now()#<p>
Data Gerada pela aplicação: #data_atual#<p>
Horário Gerado pela aplicação: #hora_atual#
</CFOUTPUT>
- URLEncodedFormat
Esta função converte uma string para formato de URL. Ou seja, se você tiver uma
string com espaços, esta função substitui estes espaços por caracteres especiais,
para que a string possa ser passada através da URL.
Sintaxe: URLEncodedFormat(string)
Exemplo:
<CFSET nome = "José Joaquim Silva">
<CFSET nomeURL = URLEncodedFormat("nome")>
Como resultado teremos: Jos%E9%20Joaquim%20Silva
Funções Matemáticas
- Max
Retorna o valor maior entre dois números.
Sintaxe: Max(número1, número2)
Exemplo:
<CFSET maior = Max(1,2)>
- Min
Retorna o valor menor entre dois números.
Sintaxe: Min(número1,número2)
Exemplo:
<CFSET menor = Min(1,2)>
- RandRange
Retorna um número aleatório entre dois números. Os números devem ser
menores que 100.000.000.
Sintaxe: RandRange(número1, número2)
Exemplo:
<CFSET sorteio = (1,35)>
Vota este artigo
