
Ruby é uma linguagem interpretada, criada por [Yukihiro Matsumoto](https://twitter.com/yukihiro_matz). O primeiro `release` da linguagem foi feito em 21 de dezembro de 1995, no Japão. Em setembro de 2000, o primeiro livro em inglês foi impresso ([Programming Ruby](http://ruby-doc.org/docs/ProgrammingRuby/)). No ano de 2003, foi lançado o **meta-framework**(framework de frameworks), Rails. Por volta de 2005, o interesse pela linguagem Ruby cresceu com o Ruby on Rails.

## Instalação

Você pode usar diversas ferramentas para instalar o Ruby. Para verificar se já tem o Ruby instalado, basta digitar o comando `ruby --version` ou o seu atalho `ruby -v` no terminal ou console. Caso, ainda não tenha instalado, siga os passos abaixo, para cada sistema operacional.

### Linux

O Debian GNU/Linux e o Ubuntu usam o gerenciador de pacotes apt. Você pode utilizá-lo da seguinte forma:

```bash
sudo apt-get install ruby-full
```

O CentOS, o Fedora e o RHEL usam o gerenciador de pacotes yum. Você pode utilizá-lo da seguinte maneira:

```bash
sudo yum install ruby
```

### Windows

Se você está no Windows, existe um ótimo projeto para ajudá-lo a instalar o Ruby: [RubyInstaller](http://rubyinstaller.org/). Ele te dá tudo o que você precisa para configurar um ambiente de desenvolvimento em Ruby completo no Windows.

### OS X

No OS X Yosemite e Mavericks, o Ruby 2.0 já está incluso. O OS X Mountain Lion, Lion e Snow Leopard vêm com o Ruby 1.8.7.
Muitas pessoas no OS X usam o Homebrew como gerenciador de pacotes. É muito fácil de obter uma versão mais nova do Ruby usando o Homebrew:

```bash
// instala a versão mais recente
brew install ruby
```

## Interactive Ruby Shell – IRB

O IRB é uma ferramenta para interpretar código Ruby com uma resposta imediata que é executada em um terminal ou console. Ela se encaixa na categoria de programas RELP (Read, Eval, Print, Loop), ou seja, ela aceita ou lê uma instrução (read), avalia ou interpreta esta (evalution), mostra ou imprime o resultado (print), e volta para o primeiro passo (loop). Quando o ruby é instalado essa ferramenta é também instalada. Para que possamos usá-la basta digitar o comando irb no se prompt de comando ou terminal:

```bash
irb(main):001:0>
```

## Variável

No Ruby as variáveis são associadas de acordo com a nomenclatura e cada variável permite sua utilização de acordo como ela foi nomeada. Quando se programa em Ruby, é interessante que se utilize as variáveis de "menor impacto" possível. Sendo assim, dar preferência pela variável local, caso não seja possível, pela de instância e assim em diante.

As variáveis são as seguintes:

- **_local_** - inicia-se com letra minúscula ou undeline, mesma nomenclatura de métodos, e funcionam apenas dentro de métodos, elas não mantém seu valor, e por isso são preferencialmente usadas quando possíveis.

- **@instância** - A nomenclatura para variáveis de instância no Ruby, são as palavras precedidas por @, por exemplo, @variavel. A variável de instância mantêm o seu valor e podem ser acessadasr todo o objeto aonde foi inicializada. Variáveis de instância podem ser acessadas fora do objeto se usado como atributo daquele objeto.

- **$globais** - As variáveis globais podem ser acessadas de qualquer parte do programa, essas variáveis inclusive são utilizadas pelos eventos do RPG Maker (switches e variáveis).

- **@@classe ou estática** - Algumas vezes, as classes precisam armazenar informações referentes a si próprias, ou seja, ter de alguma forma o seu próprio estado, e é aí que entram as variáveis de classe. Uma variável de classe é compartilhada entre todos os objetos desta classe, portanto podem ser usadas por cada um deles e também pelos métodos da classe.

- **constantes** – Apesar de não ser uma variável, é importante ressaltar e explicar como ela funciona. As constantes no Ruby, diferente de muitas outras linguagens, podem ser mudadas, porém é altamente não recomendado. As constantes como o nome diz, devem ser usadas para valores que não mudam através do programa.

Além das regras já mencionadas, depois do primeiro caractere do seu nome, uma varíavel só poder ter combinações de letras, números e o caractere de underscore (convenção `snake case`). E quando uma variável possui mais de uma palavra no seu nome, as palavras são separadas pelo undescore. Além disso, o caractere após @ e @@ não pode ser um dígito, ou seja, @@1 e @2 são nomes de variáveis inválidos no Ruby.

Os 4 escopos de variáveis do Ruby.

```ruby
answer = "Sim"

@age = 29

$version = 1.2

@@count = 57
```

## Tipos de dados

Ruby não tem tipos de dados primitivos, ou seja, números, strings, arrays, hashes, símbolos, valores booleanos são objetos e podem ser alterados dinamicamente.

**Boolean**:

Aceita 2 valores (true ou false).

```ruby
#!/usr/bin/ruby

status = true

if status
  puts "Permitido"
else
  puts "Negado"
end

# => "Permitido"
```

**Symbol**:

A diferença de um símbolo para uma variável é o prefixo com dois pontos `:`. Você não precisa pré-declarar um símbolo e se certificar que sejam únicos. Não é preciso atribuir um valor para um símbolo, o Ruby cuida disso para você. Não importa onde apareça em seu programa, um símbolo particular terá sempre o mesmo valor.

Ele é apenas um nome e um ID interno. Símbolos são mais eficientes que strings. Duas strings com o mesmo conteúdo são dois objetos diferentes, mas para qualquer nome existe apenas um objeto Symbol. Isso pode economizar tempo e memória.

```ruby
#!/usr/bin/ruby

puts "teste".object_id
puts "teste".object_id
puts :symbol.object_id
puts :symbol.object_id

# 9258800
# 9258180
# 776028
# 776028

```

**Number**:

Ruby pode lidar com ambos os números inteiros e números de ponto flutuante (números com decimais).

```ruby
#!/usr/bin/ruby
ten = 10
fifteen_point_two = 15.2
```

Você pode usar o `underscore` como um divisor de milhares ao escrever números longos. O Rubu ignora o `underscore`. Isso deixa mais fácil de ler, números grandes.

```ruby
#!/usr/bin/ruby
billion = 1_000_000_000
```

**String**:

Não é diferente das outras linguagens que deve ter visto. Você pode usar tanto aspas duplas e aspas simples para criar uma string.

```ruby
#!/usr/bin/ruby
example = "Hello, World!"
new_example = 'New example'
```

Ruby permite incorporar o resultado de algum código dentro de uma string. O código da interpolação de string vai entre #{ e }.

```ruby
#!/usr/bin/ruby
name = "Hemerson"
phrase = "Meu nome é #{name}"
result = "30 + 5 = #{40 - 5}"
```

**Array**:

Existem duas maneiras de criar um array vazio:

```ruby
#!/usr/bin/ruby
my_array = Array.new
my_other_array = []
```

**Hash**:

Um hash em Ruby é como um objeto literal em JavaScript ou um array associativo em PHP. Eles são feitos de forma semelhante aos arrays.

```ruby
#!/usr/bin/ruby
my_hash = Hash.new
my_other_hash = {}
```

Para colocar item em um hash, usasse colchetes. Você pode usar qualquer valor como a chave, mas strings ou símbolos são opções mais comuns.

```ruby
#!/usr/bin/ruby
my_hash["name"] = "Hemerson"
my_hash[:age] = 29
```

Para criar um hash com objetos nele desde o início, você usa uma notação quase idêntica aos literais de um objeto JavaScript. A única diferença é que Ruby usa uma seta (=>) entre chaves e valores:

```ruby
#!/usr/bin/ruby
developer = { :name => "Hemerson", :age => 29, :job => "front-end" }
```

## Conclusão

Tenho a se ver sobre Ruby, principalmente sobre Rails. Nos próximos artigos, estaremos olhando mais sobre o assunto.


UI2CodeGo to Home Page

Ruby

Compartilhar