mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 23:33:00 +03:00
removing lines of code in english
This commit is contained in:
Katyanna Moura
parent
d9a27d3aa4
commit
c1b08624fb
@ -7,7 +7,7 @@ contributors:
|
||||
---
|
||||
|
||||
```ruby
|
||||
# Isso é um comentario
|
||||
# Isso é um comentário
|
||||
|
||||
=begin
|
||||
Isso é um comentário multilinha
|
||||
@ -37,11 +37,8 @@ Você não deve usar também
|
||||
10.* 5 #=> 50
|
||||
|
||||
# Valores especiais são objetos
|
||||
nil # Nothing to see here
|
||||
nil # Nada para ver aqui
|
||||
true # truth
|
||||
true # verdadeiro
|
||||
false # falsehood
|
||||
false # falso
|
||||
|
||||
nil.class #=> NilClass
|
||||
@ -72,19 +69,14 @@ false.class #=> FalseClass
|
||||
|
||||
# Strings são objects
|
||||
|
||||
'I am a string'.class #=> String
|
||||
'Eu sou uma string'.class #=> String
|
||||
"I am a string too".class #=> String
|
||||
"Eu também sou uma string".class #=> String
|
||||
|
||||
placeholder = "use string interpolation"
|
||||
placeholder = "usar interpolação de string"
|
||||
"I can #{placeholder} when using double quoted strings"
|
||||
"Eu posso #{placeholder} quando estiver usando aspas duplas"
|
||||
#=> "Eu posso usar insterpolação de string quando estiver usando aspas duplas"
|
||||
|
||||
# imprime para output (saída)
|
||||
puts "I'm printing!"
|
||||
puts "Estou imprimindo"
|
||||
|
||||
# Variáveis
|
||||
@ -102,9 +94,7 @@ y #=> 10
|
||||
snake_case = true
|
||||
|
||||
# Use nomes de variáveis descritivos
|
||||
path_to_project_root = '/good/name/'
|
||||
caminho_para_a_raiz_do_projeto = '/bom/nome/'
|
||||
path = '/bad/name/'
|
||||
caminho = '/nome/ruim/'
|
||||
|
||||
# Símbolos (são objetos)
|
||||
@ -112,19 +102,14 @@ caminho = '/nome/ruim/'
|
||||
# valor inteiro. Eles são frequentemente usados no lugar de strings para transmitir com eficiência os valores
|
||||
# específicos e significativos
|
||||
|
||||
:pending.class #=> Symbol
|
||||
:pendente.class #=> Symbol
|
||||
|
||||
status = :pending
|
||||
status = :pendente
|
||||
|
||||
status == :pending #=> true
|
||||
status == :pendente #=> true
|
||||
|
||||
status == 'pending' #=> false
|
||||
status == 'pendente' #=> false
|
||||
|
||||
status == :approved #=> false
|
||||
status == :aprovado #=> false
|
||||
|
||||
# Arrays
|
||||
@ -134,7 +119,6 @@ status == :aprovado #=> false
|
||||
|
||||
# Arrays podem conter diferentes tipos de itens
|
||||
|
||||
array = [1, "hello", false] #=> => [1, "hello", false]
|
||||
array = [1, "Oi", false] #=> => [1, "Oi", false]
|
||||
|
||||
# Arrays podem ser indexados
|
||||
@ -162,7 +146,6 @@ array << 6 #=> [1, 2, 3, 4, 5, 6]
|
||||
|
||||
# Hashes são o principal dicionário de Ruby com pares de chaves(keys)/valor(value).
|
||||
# Hashes são simbolizados com chaves "{}"
|
||||
hash = {'color' => 'green', 'number' => 5}
|
||||
hash = {'cor' => 'verde', 'numero' => 5}
|
||||
|
||||
hash.keys #=> ['cor', 'numero']
|
||||
@ -172,7 +155,6 @@ hash['cor'] #=> 'verde'
|
||||
hash['numero'] #=> 5
|
||||
|
||||
# Procurar em um hash por uma chave que não existe retorna nil:
|
||||
hash['nothing here'] #=> nil
|
||||
hash['nada aqui'] #=> nil
|
||||
|
||||
# Interar sobre hashes com o método #each:
|
||||
@ -186,10 +168,8 @@ end
|
||||
|
||||
# Desde o Ruby 1.9, temos uma sintaxe especial quando usamos símbolos como chaves (keys)
|
||||
|
||||
new_hash = { defcon: 3, action: true}
|
||||
novo_hash = { defcon: 3, acao: true}
|
||||
|
||||
new_hash.keys #=> [:defcon, :action]
|
||||
novo_hash.keys #=> [:defcon, :acao]
|
||||
|
||||
# Dica: Tanto Arrays quanto Hashes são Enumerable.
|
||||
@ -197,14 +177,6 @@ novo_hash.keys #=> [:defcon, :acao]
|
||||
|
||||
# Estruturas de controle
|
||||
|
||||
if true
|
||||
"if statement"
|
||||
elsif false
|
||||
"else if, optional"
|
||||
else
|
||||
"else, also optional"
|
||||
end
|
||||
|
||||
if true
|
||||
"Se verdadeiro"
|
||||
elsif false
|
||||
@ -213,10 +185,6 @@ else
|
||||
"else, também é opicional"
|
||||
end
|
||||
|
||||
for counter in 1..5
|
||||
puts "iteration #{counter}"
|
||||
end
|
||||
|
||||
for contador in 1..5
|
||||
puts "interação #{contador}"
|
||||
end
|
||||
@ -230,10 +198,6 @@ end
|
||||
# Ninguém usa para loops
|
||||
# Use "each" em vez, dessa forma:
|
||||
|
||||
(1..5).each do |counter|
|
||||
puts "iteration #{counter}"
|
||||
end
|
||||
|
||||
(1..5).each do |contador|
|
||||
puts "interação #{contador}"
|
||||
end
|
||||
@ -243,12 +207,6 @@ end
|
||||
#=> contador 4
|
||||
#=> contador 5
|
||||
|
||||
counter = 1
|
||||
while counter <= 5 do
|
||||
puts "iteration #{counter}"
|
||||
counter += 1
|
||||
end
|
||||
|
||||
contador = 1
|
||||
while contador <= 5 do
|
||||
puts "interação #{contador}"
|
||||
@ -260,28 +218,11 @@ end
|
||||
#=> contador 4
|
||||
#=> contador 5
|
||||
|
||||
grade = 'B'
|
||||
|
||||
case grade
|
||||
when 'A'
|
||||
puts "Way to go kiddo"
|
||||
when 'B'
|
||||
puts "Better luck next time"
|
||||
when 'C'
|
||||
puts "You can do better"
|
||||
when 'D'
|
||||
puts "Scraping through"
|
||||
when 'F'
|
||||
puts "You failed!"
|
||||
else
|
||||
puts "Alternative grading system, eh?"
|
||||
end
|
||||
|
||||
grau = 'B'
|
||||
|
||||
case grau
|
||||
when 'A'
|
||||
puts "Um longo caminho a percorrer pequeno gafanhoto"
|
||||
puts "Um longo caminho a percorrer, pequeno gafanhoto"
|
||||
when 'B'
|
||||
puts "Melhor sorte da próxima vez"
|
||||
when 'C'
|
||||
@ -301,26 +242,18 @@ def dobrar(x)
|
||||
end
|
||||
|
||||
# Funções (e todos os blocos) retornam implicitamente o valor da última linha
|
||||
double(2) #=> 4
|
||||
dobrar(2) #=> 4
|
||||
|
||||
# Parênteses são opicionais onde o resultado é claro
|
||||
double 3 #=> 6
|
||||
dobrar 3 #=> 6
|
||||
|
||||
double double 3 #=> 12
|
||||
dobrar dobrar 3 #=> 12
|
||||
|
||||
def sum(x,y)
|
||||
x + y
|
||||
end
|
||||
|
||||
def somar(x,y)
|
||||
x + y
|
||||
end
|
||||
|
||||
# Argumentos de métodos são separados por uma vírgula
|
||||
sum 3, 4 #=> 7
|
||||
somar 3, 4 #=> 7
|
||||
|
||||
somar somar(3,4), 5 #=> 12
|
||||
@ -329,15 +262,6 @@ somar somar(3,4), 5 #=> 12
|
||||
# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco
|
||||
# ele pode ser chamado com a palavra chave 'yield'
|
||||
|
||||
def surround
|
||||
puts "{"
|
||||
yield
|
||||
puts "}"
|
||||
end
|
||||
|
||||
surround { puts 'hello world' }
|
||||
|
||||
|
||||
def ao_redor
|
||||
puts "{"
|
||||
yield
|
||||
@ -352,50 +276,15 @@ ao_redor { puts 'Olá mundo' }
|
||||
|
||||
|
||||
# Define uma classe com a palavra chave 'class'
|
||||
class Human
|
||||
|
||||
# A class variable. It is shared by all instances of this class.
|
||||
@@species = "H. sapiens"
|
||||
|
||||
# Basic initializer
|
||||
def initialize(name, age=0)
|
||||
# Assign the argument to the "name" instance variable for the instance
|
||||
@name = name
|
||||
# If no age given, we will fall back to the default in the arguments list.
|
||||
@age = age
|
||||
end
|
||||
|
||||
# Basic setter method
|
||||
def name=(name)
|
||||
@name = name
|
||||
end
|
||||
|
||||
# Basic getter method
|
||||
def name
|
||||
@name
|
||||
end
|
||||
|
||||
# A class method uses self to distinguish from instance methods.
|
||||
# It can only be called on the class, not an instance.
|
||||
def self.say(msg)
|
||||
puts "#{msg}"
|
||||
end
|
||||
|
||||
def species
|
||||
@@species
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
|
||||
class Humano
|
||||
|
||||
# Uma variavel de classe. Ela é compartilhada por todas as instancias dessa classe
|
||||
# Uma variável de classe. Ela é compartilhada por todas as instâncias dessa classe
|
||||
@@especies = "H. sapiens"
|
||||
|
||||
# Inicialização básica (contructor)
|
||||
def initialize(nome, idade=0)
|
||||
# Atribui o argumento para a variavel de instacia "nome" do objeto
|
||||
# Atribui o argumento para a variável de instancia "nome" do objeto
|
||||
@nome = nome
|
||||
# Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
|
||||
@idade = idade
|
||||
@ -411,7 +300,7 @@ class Humano
|
||||
@nome
|
||||
end
|
||||
|
||||
# Um método de classe usa a palavra chave self para se defenciar dos métodos de instancia.
|
||||
# Um método de classe usa a palavra chave self para se defenciar dos métodos de instância.
|
||||
# Ele só pode ser chamado na classe, não na instancia
|
||||
def self.diz(msg)
|
||||
puts "#{msg}"
|
||||
@ -425,51 +314,29 @@ end
|
||||
|
||||
|
||||
# Instanciando uma classe
|
||||
jim = Human.new("Jim Halpert")
|
||||
jim = Humano.new("Jim Halpert")
|
||||
|
||||
dwight = Human.new("Dwight K. Schrute")
|
||||
dwight = Humano.new("Dwight K. Schrute")
|
||||
|
||||
# Vamos chamar um par de métodos
|
||||
jim.species #=> "H. sapiens"
|
||||
jim.especies #=> "H. sapiens"
|
||||
|
||||
jim.name #=> "Jim Halpert"
|
||||
jim.nome #=> "Jim Halpert"
|
||||
|
||||
jim.name = "Jim Halpert II" #=> "Jim Halpert II"
|
||||
jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
|
||||
|
||||
jim.name #=> "Jim Halpert II"
|
||||
jim.nome #=> "Jim Halpert II"
|
||||
|
||||
dwight.species #=> "H. sapiens"
|
||||
dwight.especies #=> "H. sapiens"
|
||||
|
||||
dwight.name #=> "Dwight K. Schrute"
|
||||
dwight.nome #=> "Dwight K. Schrute"
|
||||
|
||||
# Chamar o método de classe
|
||||
Human.say("Hi") #=> "Hi"
|
||||
Humano.diz("Oi") #=> "Oi"
|
||||
|
||||
# Uma classe também é objeto em Ruby. Então uma classe pode possuir variável de instância
|
||||
# Variáveis de classe são compartilhadas entre a classe e todos os seus descendentes.
|
||||
|
||||
# base class
|
||||
class Human
|
||||
@@foo = 0
|
||||
|
||||
def self.foo
|
||||
@@foo
|
||||
end
|
||||
|
||||
def self.foo=(value)
|
||||
@@foo = value
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
# Classe base
|
||||
class Humano
|
||||
@ -488,30 +355,14 @@ end
|
||||
class Trabalhador < Humano
|
||||
end
|
||||
|
||||
Human.foo # 0
|
||||
Humano.foo # 0
|
||||
Worker.foo # 0
|
||||
Trabalhador.foo # 0
|
||||
|
||||
Human.foo = 2 # 2
|
||||
Humano.foo = 2 # 2
|
||||
Worker.foo # 2
|
||||
Trabalhador.foo # 2
|
||||
|
||||
# Uma variável de instância não é compartilhada por suas classes decendentes.
|
||||
|
||||
class Human
|
||||
@bar = 0
|
||||
|
||||
def self.bar
|
||||
@bar
|
||||
end
|
||||
|
||||
def self.bar=(value)
|
||||
@bar = value
|
||||
end
|
||||
end
|
||||
|
||||
class Humano
|
||||
@bar = 0
|
||||
|
||||
@ -524,9 +375,6 @@ class Humano
|
||||
end
|
||||
end
|
||||
|
||||
class Doctor < Human
|
||||
end
|
||||
|
||||
class Doutor < Humano
|
||||
end
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user