Ruby for all ||

|-----------------------------------|
|Campanha RUBY FOR ALL|
|-----------------------------------|



Eu andei me adiantando para que o 'Curso' fosse de melhor intendimento para todos .
Eu tive que correr contra o tempo e escrever ele o quanto antes .

Vamos começar : 

Como eu Havia Dito o primeiro tema que iremos abordar dessa vez será Classes :

Nas Classes nós podemos juntar novos metódos, modelos e o que a imaginação deixar, podemos também escrever as classes de any maneiras e enfim, vamos a um code que depois eu irei explicar :

CÓDIGO:


class Jogador
   def initialize(nome,idade,pontos)
    @nome = nome
    @idade = idade
    @pontos = pontos
   end
   def to_s
    "nome:"+@nome+" idade:"+@idade.to_s+" pontos:"+@pontos.to_s
   end
end

nba = Jogador::new("Lebron","28","720")
puts nba

Bom, vocês devem ter percebido que os 'codes' agora estao diferentes, não vou usar mais os codes no interpretador e sim no 'SciTE' é o editor de texto que vem com o ruby e se tu tiver usando linux é só escrever o code e depois rodar com o comando do ruby.
Deixa eu explicar agora isto aí que você viu : 
'class' é o modo em que sempre vamos começar uma 'classe' , depois eu chamei ela de 'Jogador' . 'def' que vocês já viram é usado em conjunto com 'initialize' que é outro parametro 'fixo' para se iniciar uma classe, logo depois entre parentese coloco o nome , idade e pontos que seram os componentes da classe . Bom, como eu citei no texto passado existem varios 
depois atribuimos as variaveis de instancia seus respectivos 'nomes'
depois usamos o to_s para transformar objetos em strings depois colocamos que o nome é igual a "+@nome+" e assim vai, não entedeu, espera, vai entender agora : embaixo eu chamo tudo isso de 'nba' para depois atribuir os valores reais de cada um, manjou ? é simples .


PLUS , então vamos a nossa SubCategora :

Variaveis de Instância

Essas variaveis são como variaveis especificas que no caso são atribuidas ao componentes .

" @nome = nome " 
E para atribuirmos essas variaveis é só usar o '@' antes da variavel manjaram ?

e bom, já que eu estou falando sobre Variaveis vamos aprofundar um pouco mais :
As variaveis no Ruby são 'diferenciadas' pelas suas diferentes formas oficiais de serem nomeadas , como o '@' antes da variavel ou o '$' e assim vai ..

Variaveis Globais (ou Publicas)

CÓDIGO:


irb(main):001:0> $var_gen = "abc"
=> "abc"

Essa como vocês veem é iniciada pelo '$' e o nome já diz tudo né . 

A outra é variavel local que é simples não se usa nenhuma nomenclatura especial, essas vocês já viram né ?! (:



PLUS || 

Vamos ver algumas coisas a mais agora, hehe .


Ranges

Isto é bem simples moçada, por isso nao vai ocupar muito a cabeça de vocês :

CÓDIGO:


irb(main):001:0> r = 0..100
=> 0..100
irb(main):002:0> r2 = 0...100
=> 0...100
irb(main):003:0>

é o seguinte, no primeiro caso (r) o meu intervalo vai de 0 até 100 já no segundo intervalo(r2) vai de 0 a 99 pois quanto menos pontinhos tiver, maior será o intervalo.

Arrays 

Aposto que você já ouviu falar, não é mesmo ?

Aqui no Ruby é assim :

CÓDIGO:


irb(main):003:0> a = ['Eu', 3, 'Ruby']
=> ["Eu", 3, "Ruby"]
irb(main):004:0>

Nesse caso eu 'misturei' agora vamos usar só Strings :

CÓDIGO:


irb(main):003:0> b = %w(arroz, feijao, carne, miojo, frango)
=> ["arroz,", "feijao,", "carne,", "miojo,", "frango"]
irb(main):004:0>

Olha o exemplo da compra do mês aí em cima ^^ (:
e se quisermos escrever isso aí só que de forma 'separada' :

CÓDIGO:


irb(main):001:0> a = []
=> []
irb(main):002:0> a.push "um"
=> ["um"]
irb(main):004:0> a.push "dois"
=> ["um", "dois"]
irb(main):005:0> a.push "tres"
=> ["um", "dois", "tres"]
irb(main):006:0>

entenderam ? é mole !





f0nt_Drk .

Ruby for all .

|------------------------------------| 
| Campanha RUBY FOR ALL|
|------------------------------------|




Salve, Salve, moçada (:

Adiantando, Ruby é uma linguagem contemporânea, que abrange muitos recursos porem de forma seca e sem frescura, é rapida, muito poderosa quando se sabe usar, ainda não é muito difundida, porem será, com certeza .

Bom, O que é mesmo esse tal de "Ruby" ?
firmeza moçada, é o seguinte, 
Temos como base do ruby, uma sintaxe simples, a mesma é oriantada a objetos, não a comparemos com Python ou Perls, pois Quando falamos orientada a objeto, tudo nela, é "considerado um objeto", algo que tambem é interassante frizar é que não precisamos eventualmente "declarar uma variavel", apenas com o uso de 'nomenclaturas' nao para especificar, e sim, delimitar o escopo da mesma, bom as 'coisas' no ruby sao muito exploraveis, mas relaxa, nao lembro de cabeça, ao longo do curso eu vou falando e ai voces pegam o bloquinho e pá, ta ligado [: 

|------------------------------------------------|
| Numbaah one - Instalando o Ruby | 
|------------------------------------------------|

Bem, voces podem baixar o Ruby no proprio site, no final do texto estarei disponibilizando alguns links uteis
é o seguinte, depois de baixado e intalado o Ruby no seu sistema operacional seja ele qual for, pois o Ruby é uma otima linguagem feita para todos os Sistemas, num linux voce abre uma shell e digita :

CÓDIGO:


irb

já num Windows, basta voce ir no atalho localizado no menu iniciar do FXRI

okay agora entao, que se inicie a festa 

|-------------------------------------------------------------------|
|Numbaah two - Conceitos Basicos da Linguagem|
|-------------------------------------------------------------------|

Bom, nada melhor do que falarmos sobre Numeros, no Ruby trabalharemos com Valores inteiros ( EX: 1,10,255) e Numeros de Flutuantes ou como sao chamados na maioria das linguagens de "Float"
Vamos testar o nosso ruby, com ele aberto, digitemos nele o seguinte comando:

CÓDIGO:


puts 1 + 1

Bom, muito simples, o comando "puts" imprimira o valor da operacao realizada, lembrando que para somar usamos o "+", para subtrair usamos o "-", para multiplicar usamos o "*" e para dividirmos usamos o "/"
È logico que voce já devem entao imaginar o que o ruby nos retornara nao é ? 
entao vejamos..

CÓDIGO:


puts 1 + 1
2
=> nil

Sim, Claro, voces já deveriam imaginar isso, nao é ?  mas voces perguntam : o que é aquele "nil" ali ein Drk..
é simples, ele representa que voce realizou uma açao de valor nulo, resultado do uso do comando "puts" que sempre retorna um valor nulo ou "um nada absoluto"  
Entao agora voces podem testar Diversas acoes, multiplicando, somando e fazendo o caralho a quatro  lembrando, que isso sao apenas conceitos basicos..
|-----------------------------------------------------------------------|
|Numbaah two - Conceitos Basicos da Linguagem // | 
|-----------------------------------------------------------------------|
Agora iremos trabalhar com String  bem, levando em conta que voce já saiba programar em alguma outra linguagem, nao irei explicar nada referente ao mesmo..
entao, tentemos dar um "Olá mundo" no Ruby,isto é muito simples..
usamos o comando..

CÓDIGO:


puts 'ola mundo, strondando até umas hora, krlh ;@'

entao, vejamos o que nos retornou o 
Ruby..

CÓDIGO:

 
irb(main):002:0> puts 'ola mundo, strondando até umas hora, krlh ;@'
ola mundo, strondando até umas hora, krlh ;@
=> nil

é simples, isso nós já poderiamos imaginar..
Mas nós podemos Brincar um pouco mais..

CÓDIGO:


puts ' diz ae ' + ' mocada rlz '

e entao vajemos o resultado

CÓDIGO:


diz ae mocada rlz

Muito simples não ? ^^'

mas pra deixar bem claro, vejamos a diferenca de uma operacao numerica de uma operacao de manipulacao de string

CÓDIGO:


irb(main):001:0> puts '12' + '12'
1212
=> nil
irb(main):002:0> puts 12 + 12
24
=> nil

viram, como os apostrofos indicam o uso de uma string, e quando nao usados, eles leem o valor como numero comum, acho que já deu pra pegar a ideia de boa né nao mocada ? entao okay, bumba let's go :DD

|------------------------------------------------------------------------|
|Numbaah three Conceitos Basicos da Linguagem ///|
|------------------------------------------------------------------------|

Bom, agora abordaremos o topico "variaveis"
vamos entao, criar uma variavel em ruby

CÓDIGO:


var = 'é nois que tá ' + 'cachorro'
=> "é nois que ta cachorro"
puts var
é nois que tá cachorro
=>nill

Podemos entao, fazer o seguinte..

CÓDIGO:


var = 'eu nao sei como dizer '
=> "eu nao sei como dizer"
var1 = 'te amo'
=> "te amo"
var2 = var + var1
=> "eu nao sei como dizer te amo"

Viu, como podemos trabalhar com as variaveis, ao longo do curso, nos iremos aprender mais e se voce ainda nao entendeu, nao pare. continua, champs
Existe um "plus" ae pra mandar pra voces, como eu disse num previo conceito da linguagem ali em cima, não precisamos declara-las, usamos apenas nomenclaturas, tão sakando ? vamo ver essas nomen.. alguma coisa [:
’var’ = variavel local, ’@var’ = variavel de instancia,
’$var’= variavel global
Vamos brincar um pouco mais com numeros,

CÓDIGO:


irb(main):037:0> hex = 0xF
=> 15
irb(main):038:0> bin = 0b1111
=> 15

Aqui em cima eu realizei uma simples 'conversão' eu passei o valor hexa '0xF' para um numero real (classe dos Reais, numero comum) o mesmo com o binario '0b1111' mas rola uma pergunta, porque os dois deram o mesmo resultado ? é facil né, porque eu passei de hexa pra comum e o outros de binario pra comum, manjou ? essas são algumas brincadeiras que rola no Ruby .

|-------------------------------------------------------------|
|Numbaah four - Ruby, ná pratica, Metodos !|
|-------------------------------------------------------------|
Bem, em vez de nós estarmos sempre digitando o que queremos e depois digitando de novo e de novo.. ¬¬' vamos usar um metodo que daqui pra frente sera otimo para nós o def, que é um dos metodos, que começa com "def" e termina com "end".
e entao vamos testar.. 

CÓDIGO:


irb(main):001:0> def drk
irb(main):002:0> puts 'é nois que owna calango'
irb(main):003:0> end

como podemos ver, iniciamos o 'def' e o chamamos de "drk", usamos o comando 'puts' para inserir a string 'é nois que owna calango' e depois usamos o "end" para finalizarmos a nossa açao, e entao agora iremos chamar o nosso processo com o comando drk que na verdade é apenas o nome do nosso "def" que pode ser qualquer um..

CÓDIGO:


irb(main):004:0> drk
é nois que owna calango
=> nil

E entao, vimos com funciona a parada ;D
Dai voce pode usar sua imaginação, mas calma, ainda nao acabamos, estamos apenas começando 
Bem, vamos a mais um code, pra eu explicar mais 

CÓDIGO:


print ("digite seu nome:" )
name = gets()
puts (" Bem Vindo ao sistema #{name}" )

Bem, da pra ver que isto é simles, primeiramente, voces tao vendo que eu usei o "print", calma ainda estamos progamando sim, em Ruby, vou explicar, pra voces entenderem, basta entrar no interpretador ruby, e testar usar o comando print e o comando puts, os dois tem a mesma função, porem o puts, adiciona automaticamente, uma linha abaixo, já o print, deixa tudo na mesma linha ;D 
E agora, que historia de Gets é essa, bem muito simples, ele tem a mesma funçao do "scanf" na linguagem C, só que manipulamos ele de forma diferente, do C, voces já devem ter percebido, definimos "name" igual a "gets ()" que nao é obrigatorio o uso dos parenteses, depois, nós já usamos o puts, que não tem problema, voces podem ver o "#{name}" que é onde podemos chamar a função gets. 


|--------------------------------------------|
|Numbaah five - Ruby, ná pratica|
|--------------------------------------------|
Vejamos bem, vamos falar agora sobre " Classes" 

Bom, classes é o proximo, aguardem .


--------------------------------------------------


Notas de rodapé !

Sim, eu nem sei se isso ainda é um Curso, eu tinha realmente esquecido muita coisa, inclusive deste texto, Desculpem-me, eu peço desculpas mesmo , mas pode ter certeza de que vocês iram agradecer depois, vou dar continuidade espero escrever mais uns dois textos, envolvendo Ruby, acho que sera razoavelmente bom . eu espero . 

Até ;*

Writed by me .  f0nt_Drk