93 lines
5.2 KiB
Markdown
93 lines
5.2 KiB
Markdown
---
|
||
title: Clojure
|
||
localeTitle: Clojure
|
||
---
|
||
## Começando com o Clojure
|
||
|
||
Antes de começar, você pode querer [instalar o Clojure](http://clojure.org/guides/getting_started) e o [Leiningen](http://leiningen.org/#install) (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
|
||
```
|
||
|
||
 [IDEOne isso!](https://ideone.com/SWlvKn)
|
||
|
||
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
|
||
```
|
||
|
||
 [IDEOne isso!](https://ideone.com/VftymP)
|
||
|
||
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](//forum.freecodecamp.com/t/what-is-clojure/18419) | [ Casa ](//forum.freecodecamp.com/t/clojure-resources/18422) | [Próximo ](//forum.freecodecamp.com/t/clojure-conditionals/18412) |
|
||
| [Resumo](//forum.freecodecamp.com/t/what-is-clojure/18419) | [Índice](//forum.freecodecamp.com/t/clojure-resources/18422) | [Condicionais](//forum.freecodecamp.com/t/clojure-conditionals/18412) | |