 |
|
Você está aqui: Lisp ::: Fundamentos da Linguagem ::: Operadores Aritméticos |
Como usar o operador de incremento 1+ da linguagem LISPQuantidade de visualizações: 479 vezes |
|
Nesta dica mostrarei como podemos incrementar o valor de uma variável numérica em 1 usando o operador 1+ da linguagem LISP (e AutoLISP para programadores AutoCAD). Note que este operador atual sobre o seu argumento e retorna o valor do argumento aumentado em 1. Veja o código LISP completo para o exemplo: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- ; programa LISP que demonstra o uso do operador ; de incremento (let((valor)) ; inicialmente vamos definir o valor ; como 10 (setq valor 10) (format t "O valor atual é: ~D~%" valor) ; agora vamos incrementar o valor em 1 (setq valor (1+ valor)) (format t "O novo valor é: ~D~%" valor) ; vamos incrementar o valor em 1 novamente (setq valor (1+ valor)) (format t "O novo valor é: ~D" valor) ) Ao executar este código LISP nós teremos o seguinte resultado: O valor atual é: 10 O novo valor é: 11 O novo valor é: 12 |
 Link para compartilhar na Internet ou com seus amigos: |
Lisp ::: Fundamentos da Linguagem ::: Estruturas de Controle |
Como usar o laço loop for da linguagem LispQuantidade de visualizações: 601 vezes |
|
O laço for loop da linguagem Common Lisp é usado quando sabemos exatamente quantas vezes uma instrução ou um grupo de instruções deve ser repetido. Este laço é similar ao laço for encontrado na maioria das linguagens de programação. Vamos começar vendo um laço for loop que conta de 1 até 10: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- ; Um laço for loop que conta de 1 até 10 (loop for i from 1 to 10 do (print i) ) Ao executar este código Common Lisp nós teremos o seguinte resultado: 1 2 3 4 5 6 7 8 9 10 Agora veja o mesmo laço usado para contar de 10 até 1, ou seja, em ordem decrescente: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- ; Um laço for loop que conta de 10 até 1 (loop for i from 10 downto 1 do (print i) ) Note que, agora, eu troquei "to" por "downto" para que a variável de controle fosse decrementada, em vez de incrementada. Dessa forma, ao executarmos este código Common Lisp, o resultado será: 10 9 8 7 6 5 4 3 2 1 |
Lisp ::: Fundamentos da Linguagem ::: Variáveis e Constantes |
Como declarar variáveis globais em Lisp usando as funções defvar e defparameterQuantidade de visualizações: 884 vezes |
|
Em algumas situações nós precisamos declarar variáveis globais em Lisp, ou melhor, em Common Lisp, que é a padronização da Lisp que adotamos para estas dicas. Variáveis globais em Common Lisp se comportam de forma idêntica àquelas de outras linguagens de programação, ou seja, possuem valores permanentes por todo o sistema Lisp e mantém seus valores até que novos valores são especificados. Se quisermos, por exemplo, a partir do corpo de uma função acessar uma variável fora dela, então esta variável deverá ser declarada globalmente. Em Common List nós podemos declarar variáveis globais usando as funções defvar e defparameter. Vamos ver exemplos envolvendo as duas e no final desta dica eu mostro a diferença. Veja um trecho de código Common Lisp na qual declaramos uma variável global chamada valor e a acessamos de dentro de uma função: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- ; vamos declarar uma variável global (defvar valor 10) ; vamos mostrar o valor atual da variável global (format t "O valor da variável global é ~D" valor) ; agora vamos acessar a variável global ; de dentro de uma função (defun ModificaValor() ; vamos alterar o valor da variável global (setq valor 50) ) ; chamamos a função ModificaValor (ModificaValor) ; e checamos se o valor da variável global foi ; mesmo alterado (terpri) (format t "O valor da variável global é ~D" valor) Ao executar este código Common List nós teremos o seguinte resultado: O valor da variável global é 10 O valor da variável global é 50 Veja agora um trecho de código Common Lisp no qual usamos a função defparameter para declarar e inicializar as variáveis globais: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- ; vamos declarar três variáveis globais (defparameter *a* 5) (defparameter *b* 3) (defparameter *soma* 0) ; agora vamos acessar as variáveis globais ; de dentro de uma função (defun Somar() ; vamos somar as duas variáveis globais ; e guardar o resultado em uma terceira ; variáveis global (setq *soma* (+ *a* *b*)) ) ; chamamos a função Somar (Somar) ; e mostramos o resultado da soma (format t "A soma das variáveis globais é ~D" *soma*) Ao executar este novo código Common Lisp nós teremos o seguinte resultado: A soma das variáveis globais é 8 Note que coloquei asteríscos (*) ao redor dos nomes das variáveis globais. Esta é uma prática comum entre programadores Lisp e altamente recomendado pelo comunidade, pois facilita a distinção entre variáveis globais e locais. Então, qual é a diferença entre defvar e defparameter? A primeira delas é que a função defparameter nos obriga a informar o valor inicial para a variável global, enquanto a função defvar não o faz. A segunda diferença é que, ao redefinirmos o valor de uma variável global usando defparameter, o valor armazenado anteriormente será sobreposto, enquanto a função defvar não altera o valor anterior. |
Lisp ::: Fundamentos da Linguagem ::: Variáveis e Constantes |
Como declarar variáveis locais em Lisp usando o comando letQuantidade de visualizações: 715 vezes |
|
Em várias situações nós gostaríamos de declarar variáveis que serão usadas em um espaço limitado, ou seja, dentro de uma função Common Lisp ou até mesmo em um bloco de código. Entram em cena as variáveis locais. Variáveis locais, como o próprio nome indica, são visíveis apenas dentro do corpo de uma função ou dentro do bloco no qual elas são declaradas. Em Common Lisp as variáveis locais são declaradas usando-se o comando let. Veja um exemplo no qual nós declaramos três variáveis locais e que serão usadas no corpo de uma função Multiplicar(): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
; vamos definir a função Multiplicar()
(defun Multiplicar()
; vamos usar o comando let para declarar
; três variáveis locais
(let ((a 3)(b 9)(produto))
; agora vamos obter o produto das variáveis
; a e b
(setq produto (* a b))
; e mostramos o resultado
(format t "O produto dos dois valores é ~D" produto)
)
)
; chamamos a função Multiplicar()
(Multiplicar)
Ao executar este código nós teremos o seguinte resultado: O produto dos dois valores é 27 Agora veja como podemos declarar variáveis locais dentro de um bloco de código em Common Lisp: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- ; vamos usar o comando let para declarar ; três variáveis locais (dentro de um bloco ; de código) (let ((a 7)(b 5)(produto)) ; agora vamos obter o produto das variáveis ; a e b (setq produto (* a b)) ; e mostramos o resultado (format t "O produto dos dois valores é ~D" produto) ) Execute este código e você terá o seguinte resultado: O produto dos dois valores é 35 Nos dois trechos de código, se tentarmos acessar as variáveis locais fora de seus escopos, nós teremos o seguinte erro: The variable PRODUTO is unbound. |
Veja mais Dicas e truques de Lisp |
Dicas e truques de outras linguagens |
|
R - R para Matemática e Estatística - Como calcular desvio padrão usando a função sd() da linguagem R MySQL - Como usar joins no MySQL |
Códigos Fonte |
 Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimentoDiga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais |
 Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesTenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais |
Linguagens Mais Populares |
|
1º lugar: Java |
