Merge branch 'master' of github.com:adambard/learnxinyminutes-docs

This commit is contained in:
Adam 2015-10-19 14:33:47 +08:00
commit 226767916c
2 changed files with 245 additions and 31 deletions

View File

@ -5,8 +5,18 @@ contributors:
- ["David Underwood", "http://theflyingdeveloper.com"] - ["David Underwood", "http://theflyingdeveloper.com"]
- ["Joel Walden", "http://joelwalden.net"] - ["Joel Walden", "http://joelwalden.net"]
- ["Luke Holder", "http://twitter.com/lukeholder"] - ["Luke Holder", "http://twitter.com/lukeholder"]
- ["Tristan Hume", "http://thume.ca/"]
- ["Nick LaMuro", "https://github.com/NickLaMuro"]
- ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
- ["Ariel Krakowski", "http://www.learneroo.com"]
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
- ["Levi Bostian", "https://github.com/levibostian"]
- ["Rahil Momin", "https://github.com/iamrahil"]
- ["Gabriel Halley", "https://github.com/ghalley"]
- ["Persa Zula", "http://persazula.com"]
translators: translators:
- ["Camilo Garrido", "http://www.twitter.com/hirohope"] - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
- ["Erick Bernal", "http://www.twitter.com/billowkib"]
lang: es-es lang: es-es
--- ---
@ -33,6 +43,8 @@ Tu tampoco deberías
8 - 1 #=> 7 8 - 1 #=> 7
10 * 2 #=> 20 10 * 2 #=> 20
35 / 5 #=> 7 35 / 5 #=> 7
2**5 #=> 32
5 % 3 #=> 2
# La aritmética es sólo azúcar sintáctico # La aritmética es sólo azúcar sintáctico
# para llamar un método de un objeto # para llamar un método de un objeto
@ -55,8 +67,6 @@ false.class #=> FalseClass
# Desigualdad # Desigualdad
1 != 1 #=> false 1 != 1 #=> false
2 != 1 #=> true 2 != 1 #=> true
!true #=> false
!false #=> true
# Además de 'false', 'nil' es otro valor falso # Además de 'false', 'nil' es otro valor falso
@ -70,14 +80,29 @@ false.class #=> FalseClass
2 <= 2 #=> true 2 <= 2 #=> true
2 >= 2 #=> true 2 >= 2 #=> true
# Operadores lógicos
true && false #=> false
true || false #=> true
!true #=> false
# Existen versiones alternativas de los operadores lógicos con menor prioridad
# Estos son usados como constructores controladores de flujo que encadenan
# sentencias hasta que una de ellas retorne verdadero o falso
# `has_otra_cosa` solo se llama si `has_algo` retorna verdadero.
has_algo() and has_otra_cosa()
# `registra_error` solo se llama si `has_algo` falla
has_algo() or registra_error()
# Los strings son objetos # Los strings son objetos
'Soy un string'.class #=> String 'Soy un string'.class #=> String
"Soy un string también".class #=> String "Soy un string también".class #=> String
referente = "usar interpolacion de strings" referente = "usar interpolación de strings"
"Yo puedo #{referente} usando strings de comillas dobles" "Yo puedo #{referente} usando strings de comillas dobles"
#=> "Yo puedo usar interpolacion de strings usando strings de comillas dobles" #=> "Yo puedo usar interpolación de strings usando strings de comillas dobles"
# Imprime a la salida estándar # Imprime a la salida estándar
@ -119,15 +144,16 @@ status == :aprovado #=> false
# Arreglos # Arreglos
# Esto es un arreglo # Esto es un arreglo
[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] arreglo = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
# Arreglos pueden contener elementos de distintos tipos # Arreglos pueden contener elementos de distintos tipos
arreglo = [1, "hola", false] #=> => [1, "hola", false] [1, "hola", false] #=> => [1, "hola", false]
# Arreglos pueden ser indexados # Arreglos pueden ser indexados
# Desde el frente # Desde el frente
arreglo[0] #=> 1 arreglo[0] #=> 1
arreglo.first #=> 1
arreglo[12] #=> nil arreglo[12] #=> nil
# Tal como la aritmética, el acceso como variable[índice] # Tal como la aritmética, el acceso como variable[índice]
@ -138,15 +164,25 @@ arreglo.[] 12 #=> nil
# Desde el final # Desde el final
arreglo[-1] #=> 5 arreglo[-1] #=> 5
arreglo.last #=> 5
# Con un índice de inicio y final # Con un índice de inicio y longitud
arreglo[2, 4] #=> [3, 4, 5] arreglo[2, 3] #=> [3, 4, 5]
# Invertir un arreglo
a = [1, 2, 3]
a.reverse! #=> [3, 2, 1]
# O con rango # O con rango
arreglo[1..3] #=> [2, 3, 4] arreglo[1..3] #=> [2, 3, 4]
# Añade elementos a un arreglo así # Añade elementos a un arreglo así
arreglo << 6 #=> [1, 2, 3, 4, 5, 6] arreglo << 6 #=> [1, 2, 3, 4, 5, 6]
# O así
arreglo.push(6) #=> [1, 2, 3, 4, 5, 6]
#Verifica si un elemento ya existe en ese arreglo
arreglo.include?(1) #=> true
# Hashes son los diccionarios principales de Ruby con pares llave/valor. # Hashes son los diccionarios principales de Ruby con pares llave/valor.
# Hashes se denotan con llaves: # Hashes se denotan con llaves:
@ -161,17 +197,16 @@ hash['numero'] #=> 5
# Preguntarle a un hash por una llave que no existe retorna 'nil': # Preguntarle a un hash por una llave que no existe retorna 'nil':
hash['nada aqui'] #=> nil hash['nada aqui'] #=> nil
# Itera sobre un hash con el método 'each':
hash.each do |k, v|
puts "#{k} is #{v}"
end
# Desde Ruby 1.9, hay una sintaxis especial cuando se usa un símbolo como llave: # Desde Ruby 1.9, hay una sintaxis especial cuando se usa un símbolo como llave:
nuevo_hash = { defcon: 3, accion: true} nuevo_hash = { defcon: 3, accion: true}
nuevo_hash.keys #=> [:defcon, :accion] nuevo_hash.keys #=> [:defcon, :accion]
# Verifica la existencia de llaves y valores en el hash
new_hash.has_key?(:defcon) #=> true
new_hash.has_value?(3) #=> true
# Tip: Tanto los arreglos como los hashes son Enumerable (enumerables) # Tip: Tanto los arreglos como los hashes son Enumerable (enumerables)
# Comparten muchos métodos útiles tales como 'each', 'map', 'count', y más # Comparten muchos métodos útiles tales como 'each', 'map', 'count', y más
@ -194,9 +229,15 @@ end
#=> iteracion 4 #=> iteracion 4
#=> iteracion 5 #=> iteracion 5
# Aunque # SIN EMBARGO, nadie usa ciclos `for`
# Nadie usa los ciclos `for` # En su lugar debes usar el método "each" y pasarle un block (bloque).
# Usa `each`, así: # Un bloque es un fragmento código que puedes pasar a métodos como `each`.
# Es símilar a las funciones lambda, funciones anónimas o `closures` en otros
# lenguajes de programación.
#
# El método `each` de un Range (rango) ejecuta el bloque una vez por cada elemento.
# Al bloque se le pasa un contador como parametro.
# Usar el método `each` con un bloque se ve así:
(1..5).each do |contador| (1..5).each do |contador|
puts "iteracion #{contador}" puts "iteracion #{contador}"
@ -207,10 +248,27 @@ end
#=> iteracion 4 #=> iteracion 4
#=> iteracion 5 #=> iteracion 5
counter = 1 # También puedes envolver el bloque entre llaves:
while counter <= 5 do (1..5).each { |counter| puts "iteración #{contador}" }
puts "iteracion #{counter}"
counter += 1 #El contenido de las estructuras de datos en ruby puede ser iterado usando `each`.
arreglo.each do |elemento|
puts "#{elemento} es parte del arreglo"
end
hash.each do |llave, valor|
puts "#{llave} es #{valor}"
end
# Si aún necesitas un índice puedes usar "each_with_index" y definir una variable
# índice.
arreglo.each_with_index do |element, index|
puts "#{element} tiene la posición #{index} en el arreglo"
end
contador = 1
while contador <= 5 do
puts "iteracion #{contador}"
contador += 1
end end
#=> iteracion 1 #=> iteracion 1
#=> iteracion 2 #=> iteracion 2
@ -218,6 +276,19 @@ end
#=> iteracion 4 #=> iteracion 4
#=> iteracion 5 #=> iteracion 5
# Hay una gran variedad de otras funciones iterativas útiles en Ruby,
# por ejemplo `map`, `reduce`, `inject`, entre otras. Map, por ejemplo,
# toma el arreglo sobre el cuál está iterando, le hace cambios
# definidos en el bloque, y retorna un arreglo completamente nuevo.
arreglo = [1,2,3,4,5]
duplicado = array.map do |elemento|
elemento * 2
end
puts duplicado
#=> [2,4,6,8,10]
puts array
#=> [1,2,3,4,5]
nota = 'B' nota = 'B'
case nota case nota
@ -234,6 +305,34 @@ when 'F'
else else
puts "Sistema alternativo de notas, ¿eh?" puts "Sistema alternativo de notas, ¿eh?"
end end
#=> "Mejor suerte para la proxima"
# Los casos también pueden usar rangos
nota = 82
case nota
when 90..100
puts 'Excelente!'
when 80..100
puts 'Buen trabajo'
else
puts '¡Reprobaste!'
end
#=> "Buen trabajo"
# Manejo de excepciones
begin
# código que podría causar excepción
raise NoMemoryError, 'Se te acabó la memoria'
rescue NoMemoryError => variable_de_excepcion
puts 'El error NoMemoryError ocurrió', variable_de_excepcion
rescue RuntimeError => otra_variable_de_excepcion
puts 'El error RuntimeError ocurrió'
else
puts 'Esto se ejecuta si ningun error ocurrió'
ensure
puts 'Este código siempre se ejecuta, sin importar que'
end
# Funciones # Funciones
@ -244,7 +343,7 @@ end
# Funciones (y todos los bloques) implícitamente retornan el valor de la última instrucción # Funciones (y todos los bloques) implícitamente retornan el valor de la última instrucción
doble(2) #=> 4 doble(2) #=> 4
# Paréntesis son opcionales cuando el resultado es ambiguo # Paréntesis son opcionales cuando el resultado no es ambiguo
doble 3 #=> 6 doble 3 #=> 6
doble doble 3 #=> 12 doble doble 3 #=> 12
@ -259,7 +358,7 @@ suma 3, 4 #=> 7
suma suma(3,4), 5 #=> 12 suma suma(3,4), 5 #=> 12
# yield # yield
# Todos los métodos tienen un parámetro de bloqueo opcional e implícitp # Todos los métodos tienen un parámetro bloque opcional e implícito
# puede llamarse con la palabra clave 'yield' # puede llamarse con la palabra clave 'yield'
def alrededor def alrededor
@ -274,6 +373,17 @@ alrededor { puts 'hola mundo' }
# hola mundo # hola mundo
# } # }
# Puedes pasar un bloque a una función
# '&' representa una referencia a un bloque
def visitantes(&bloque)
bloque.call
end
# Puedes pasar una lista de argumentos, que serán convertidos en un arreglo
# Para eso sirve el operador ('*')
def visitantes(*arreglo)
arreglo.each { |visitante| puts visitante }
end
# Define una clase con la palabra clave 'class' # Define una clase con la palabra clave 'class'
class Humano class Humano
@ -299,16 +409,26 @@ class Humano
@nombre @nombre
end end
# La funcionalidad anterior puede ser encapsulada usando el método attr_accessor
# de la siguiente manera
attr_accessor :name
# Los métodos de tipo getter y setter también se pueden crear de manera individual
# de la siguiente manera
attr_reader :name
attr_writer :name
# Un método de clase usa 'self' (sí mismo) para distinguirse de métodos de instancia. # Un método de clase usa 'self' (sí mismo) para distinguirse de métodos de instancia.
# Sólo puede ser llamado en la clase, no por una instancia. # Sólo puede ser llamado en la clase, no por una instancia.
def self.decir(mensaje) def self.decir(mensaje)
puts "#{mensaje}" puts mensaje
end end
def especie def especie
@@especie @@especie
end end
end end
@ -328,6 +448,23 @@ dwight.nombre #=> "Dwight K. Schrute"
# Llama el método de clase # Llama el método de clase
Humano.decir("Hi") #=> "Hi" Humano.decir("Hi") #=> "Hi"
# El alcance de las variables es definido por la manera en que las nombramos.
# Las variables que inician con $ tienen un alcance global
$var = "Soy una variable global"
defined? $var #=> "global-variable"
# Las variables que empiezan con @ tienen un alcance de instancia
@var = "Soy una variable de instancia"
defined? @var #=> "instance-variable"
# Variables que empiezan con @@ tienen un alcance de clase
@@var = "Soy una variable de clase"
defined? @@var #=> "class variable"
# Las variables que empiezan con letra mayuscula son constantes
Var = "Soy una constante"
defined? Var #=> "constant"
# Las clases también son un objeto en ruby. Por lo cual, las clases también pueden tener variables de instancia. # Las clases también son un objeto en ruby. Por lo cual, las clases también pueden tener variables de instancia.
# Variables de clase son compartidas a través de la clase y todos sus descendientes. # Variables de clase son compartidas a través de la clase y todos sus descendientes.
@ -371,7 +508,67 @@ end
class Doctor < Humano class Doctor < Humano
end end
Human.bar # 0 Humano.bar # 0
Doctor.bar # nil Doctor.bar # nil
module ModuloEjemplo
def foo
'foo'
end
end
# Al incluir un módulo sus métodos se comparten con las instancias de la clase
# Al extender un módulo sus métodos se comparten con la clase misma
class Persona
include ModuloEjemplo
end
class Libro
extend ModuloEjemplo
end
Persona.foo # => NoMethodError: undefined method `foo' for Persona:Class
Persona.new.foo # => 'foo'
Libro.foo # => 'foo'
Libro.new.foo # => NoMethodError: undefined method `foo'
# Las llamadas de retorno (callbacks) son ejecutadas cuando se incluye o
# extiende un módulo
module EjemploConcern
def self.incluido(base)
base.extend(MetodosClase)
base.send(:include, MetodosInstancia)
end
module MetodosClase
def bar
'bar'
end
end
module MetodosInstancia
def qux
'qux'
end
end
end
class Algo
include EjemploConcern
end
Algo.bar #=> 'bar'
Algo.qux #=> NoMethodError: undefined method `qux'
Algo.new.bar # => NoMethodError: undefined method `bar'
Algo.new.qux # => 'qux'
``` ```
## Recursos adicionales
- [Aprende Ruby Mediante Ejemplo con Ejercicios](http://www.learneroo.com/modules/61/nodes/338) - Una variante de
esta referencia con ejercicios en navegador.
- [Documentación Oficial](http://www.ruby-doc.org/core-2.1.1/)
- [Ruby desde otros lenguajes](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
- [Programando Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Una
[edición antigua](http://ruby-doc.com/docs/ProgrammingRuby/) gratuita disponible en línea.
- [Guía de estilo de Ruby](https://github.com/bbatsov/ruby-style-guide) - Guía de estilo creada por la comunidad.

View File

@ -104,7 +104,8 @@ END;
echo 'This string ' . 'is concatenated'; echo 'This string ' . 'is concatenated';
// Strings can be passed in as parameters to echo // Strings can be passed in as parameters to echo
echo 'Multiple', 'Parameters', 'Valid'; echo 'Multiple', 'Parameters', 'Valid'; // Returns 'MultipleParametersValid'
/******************************** /********************************
* Constants * Constants
@ -117,8 +118,10 @@ echo 'Multiple', 'Parameters', 'Valid';
// followed by any number of letters, numbers, or underscores. // followed by any number of letters, numbers, or underscores.
define("FOO", "something"); define("FOO", "something");
// access to a constant is possible by direct using the choosen name // access to a constant is possible by calling the choosen name without a $
echo 'This outputs '.FOO; echo FOO; // Returns 'something'
echo 'This outputs '.FOO; // Returns 'This ouputs something'
/******************************** /********************************
@ -159,9 +162,9 @@ echo('Hello World!');
print('Hello World!'); // The same as echo print('Hello World!'); // The same as echo
// echo is actually a language construct, so you can drop the parentheses. // echo and print are language constructs too, so you can drop the parentheses
echo 'Hello World!'; echo 'Hello World!';
print 'Hello World!'; // So is print print 'Hello World!';
$paragraph = 'paragraph'; $paragraph = 'paragraph';
@ -219,7 +222,11 @@ assert($a !== $d);
assert(1 === '1'); assert(1 === '1');
assert(1 !== '1'); assert(1 !== '1');
// spaceship operator since PHP 7 // 'Spaceship' operator (since PHP 7)
// Returns 0 if values on either side are equal
// Returns 1 if value on the left is greater
// Returns -1 if the value on the right is greater
$a = 100; $a = 100;
$b = 1000; $b = 1000;
@ -445,6 +452,16 @@ function parameters() {
parameters('Hello', 'World'); // Hello | 0 - Hello | 1 - World | parameters('Hello', 'World'); // Hello | 0 - Hello | 1 - World |
// Since PHP 5.6 you can get a variable number of arguments
function variable($word, ...$list) {
echo $word . " || ";
foreach ($list as $item) {
echo $item . ' | ';
}
}
variable("Separate", "Hello", "World") // Separate || Hello | World |
/******************************** /********************************
* Includes * Includes
*/ */