5.2 KiB
| title | localeTitle |
|---|---|
| Clojure | Clojure |
Começando com o Clojure
Antes de começar, você pode querer instalar o Clojure e o Leiningen (que é uma ferramenta para gerenciar projetos no Clojure). Isso permitirá executar o Clojure na linha de comando usando um REPL (Read-Evaluate-Print-Loop).
Definindo Variáveis
O pão e a manteiga de qualquer linguagem de programação são variáveis e funções. Vamos definir uma variável!
(def our-string "Hello world!")
Mole-mole. Esse pedaço de código usa a macro def para associar uma string ( "Hello world!" ) A um símbolo ( our-string ). Poderíamos também ter definido um número, como 1 ou 1.1 , um caractere, como \a ou \Z , ou algo mais complicado, como uma lista ou uma expressão regular ( uuuugh ).
Note que nosso código está dentro de parênteses, como uma lista, porque tudo em um Lisp é uma lista! (Isso será muito importante quando começarmos a falar sobre macros.)
Definindo Funções
Agora vamos definir uma função!
(defn hello-world [] (println our-string))
Isso é um pouco mais complexo. Como def , ele usa uma macro ( defn ) para criar uma variável - embora, dessa vez, essa variável seja uma função. O vetor vazio (um vetor é um tipo de lista - pense nisso como um array) depois do hello-world define os argumentos para essa função - nesse caso, não temos nenhum. O código depois disso é o que a função faz. Ele avalia our-string , que é igual a "Hello world!" e imprime no console. Vamos correr!
(hello-world)
; => Hello world!
; nil
Você também pode escrever isto:
(def hello-world (fn [] (println our-string)))
defn é apenas um atalho para ajudar a manter seu código conciso. (defn ...) e (def ... (fn ...)) são os mesmos na prática.
Parâmetros
Bem, isso foi legal, mas não foi muito emocionante. Vamos tentar uma função com parâmetros. Que tal um que adiciona 3 números?
(defn add [xyz] (+ xyz))
(add 1 2 3)
; => 6
…Aguente. (+ xyz) Isso parece engraçado. Bem, Lisps são escritos usando "notação de prefixo", o que significa que a função sempre vem em primeiro lugar. Como todos os operadores matemáticos em Lisp ( + - * / ) são apenas funções, eles também vêm antes de seus argumentos (neste caso, xyz ).
Você notará que o nosso vetor tem algumas coisas agora: [xyz] ! Sempre que uma função tiver parâmetros, você os define nesse vetor ao lado do nome da função.
Destruturação
Um ótimo recurso sobre argumentos no Clojure é a desestruturação. Ele permite que você "puxe" elementos de uma lista.
(defn add [[xy] z] (+ xyz))
(add [1 2] 3)
; => 6
Os argumentos para essa função são uma coleção ( [xy] ) e um número ( z ). Podemos usar a desestruturação para extrair o primeiro e segundo elementos da lista e chamá-los de x e y .
Funções com qualquer número de parâmetros
Você também pode definir uma função com um número arbitrário de argumentos usando & .
(defn demonstrate-rest [first & rest]
(println first)
(println rest))
(demonstrate-rest 1 "foo" ["bar" 22])
; => 1
; ("foo" ["bar" 22])
; nil
Como você pode ver, usando & separamos os argumentos da nossa função em uma variável chamada first e uma lista de variáveis chamada rest . Isso significa que nossa função pode ter vários argumentos!
Retornando
Você pode ter notado algumas coisas estranhas. Sempre que usamos println , parece que nil está aparecendo em nossa saída. Além disso, nossa função add retorna 6 , mas nunca dissemos para retornar nada.
No Clojure, os retornos são 'implícitos'. Se você já usou Ruby, provavelmente está familiarizado com esse conceito. Em vez de dizer à nossa função para retornar algo, ela avalia todo o código dentro de seu corpo e retorna o resultado. Nossa função add , por exemplo, avalia (+ xyz) e, em seguida, retorna esse resultado.
A razão pela qual nossas funções que usam println output nil é porque println avaliado como nil . ( nil é como null ou None - não representa nada.)
| 
Anterior | 
Casa | Próximo 
|
| Resumo | Índice | Condicionais |