218 lines
4.8 KiB
Markdown
218 lines
4.8 KiB
Markdown
---
|
|
title: Common Array Methods
|
|
localeTitle: Métodos comunes de Array
|
|
---
|
|
## Métodos comunes de Array
|
|
|
|
Los Arrays (arreglos) de Ruby forman una base fundamental en la programación en Ruby, y en la mayoría de los lenguajes de hecho. Se utilizan tanto que sería beneficioso conocer e incluso memorizar algunos de los métodos más utilizados para arrays. Si quieres saber más sobre los Arrays de Ruby, tenemos [un artículo sobre ellos](https://guide.freecodecamp.org/ruby/ruby-arrays).
|
|
|
|
Para los fines de esta guía, nuestro array será el siguiente:
|
|
|
|
``` ruby
|
|
array = [0, 1, 2, 3, 4]
|
|
```
|
|
#### .length
|
|
El método .length calcula el número de elementos en tu array y retorna la cuenta:
|
|
|
|
``` ruby
|
|
array.length
|
|
=> 5
|
|
```
|
|
Este método es similar a los métodos .count y .size.
|
|
|
|
``` ruby
|
|
array.count
|
|
=> 5
|
|
```
|
|
``` ruby
|
|
array.size
|
|
=> 5
|
|
```
|
|
|
|
#### .first
|
|
El método .first accede al primer elemento del array, es decir el elemento en el índice 0:
|
|
|
|
``` ruby
|
|
array.first
|
|
=> 0
|
|
```
|
|
|
|
#### .last
|
|
El método .last accede al último elemento del array:
|
|
|
|
``` ruby
|
|
array.last
|
|
=> 4
|
|
```
|
|
|
|
#### .take
|
|
El método .take retorna los primeros n elementos del array:
|
|
|
|
``` ruby
|
|
array.take(3)
|
|
=> [0, 1, 2]
|
|
```
|
|
|
|
#### .drop
|
|
El método .drop retorna los elementos siguientes después de los primeros n elementos del array:
|
|
|
|
``` ruby
|
|
array.drop(3)
|
|
=> [3, 4]
|
|
```
|
|
|
|
#### índice del array
|
|
Puedes acceder a un elemento determinado en el array a través de su índice. Si el índice no existe en el array, se retornará nulo:
|
|
|
|
```ruby
|
|
array[2]
|
|
=> 2
|
|
|
|
array[5]
|
|
=> nil
|
|
```
|
|
|
|
#### .pop
|
|
El método .pop removerá de forma permanente el último elemento del array:
|
|
|
|
``` ruby
|
|
array.pop
|
|
=> [0, 1, 2, 3]
|
|
```
|
|
|
|
#### .shift
|
|
El método .shift removerá de forma permanente el primer elemento del array y retornará este elemento:
|
|
|
|
``` ruby
|
|
array.shift
|
|
=> 0
|
|
array
|
|
=> [1, 2, 3, 4]
|
|
```
|
|
|
|
#### .push
|
|
El método .push te permitirá agregar un elemento al final del array:
|
|
|
|
``` ruby
|
|
array.push(99)
|
|
=> [0, 1, 2, 3, 4, 99]
|
|
```
|
|
|
|
#### .unshift
|
|
El método .unshift te permitirá agregar un elemento al principio del array:
|
|
|
|
```
|
|
array = [2, 3]
|
|
array.unshift(1)
|
|
=> [1, 2, 3]
|
|
```
|
|
|
|
#### .delete
|
|
El método .delete remueve un elemento determinado de un array de forma permanente:
|
|
|
|
``` ruby
|
|
array.delete(1)
|
|
=> [0, 2, 3, 4]
|
|
```
|
|
|
|
#### .delete_at
|
|
El método .delete_at te permite remover de forma permanente un elemento del array para un índice determinado:
|
|
|
|
``` ruby
|
|
array.delete_at(0)
|
|
=> [1, 2, 3, 4]
|
|
```
|
|
|
|
#### .reverse
|
|
El método .reverse retorna un nuevo array con los mismos elementos del array original, pero con el orden invertido:
|
|
|
|
``` ruby
|
|
array.reverse
|
|
=> [4, 3, 2, 1, 0]
|
|
array
|
|
=> [0, 1, 2, 3, 4]
|
|
```
|
|
|
|
#### .select
|
|
El método .select itera sobre un array y retorna un nuevo array que incluye cualquier item que retorne verdadero a la expresión provista:
|
|
|
|
``` ruby
|
|
array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
|
array.select { |number| number > 4 }
|
|
=> [5, 6, 7, 8, 9, 10]
|
|
array
|
|
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
|
```
|
|
|
|
#### .include?
|
|
El método include? verifica si el argumento dado está incluido en el array:
|
|
|
|
``` ruby
|
|
array = [1, 2, 3, 4, 5]
|
|
=> [1, 2, 3, 4, 5]
|
|
array.include?(3)
|
|
=> true
|
|
```
|
|
|
|
#### .flatten
|
|
|
|
El método .flatten se puede usar para tomar un array que contiene arrays anidados y crear uno nuevo de una sola dimensión:
|
|
|
|
``` ruby
|
|
array = [1, 2, [3, 4, 5], [6, 7]]
|
|
array.flatten
|
|
=> [1, 2, 3, 4, 5, 6, 7]
|
|
```
|
|
|
|
#### .join
|
|
El método .join retorna una cadena con todos los elementos del array separados por un parámetro separador. Si el parámetro separador es nulo, el método usa una cadena vacía como separador:
|
|
|
|
``` ruby
|
|
array.join
|
|
=> "01234"
|
|
array.join("*")
|
|
=> "0*1*2*3*4"
|
|
```
|
|
|
|
#### .each
|
|
El método .each itera sobre cada elemento del array, permitiéndote ejecutar acciones sobre ellos:
|
|
|
|
``` ruby
|
|
array.each { |element| puts element }
|
|
=>
|
|
0
|
|
1
|
|
2
|
|
3
|
|
4
|
|
```
|
|
|
|
#### .map
|
|
El método .map es igual que el método .collect. Los métodos .map y .collect iteran sobre cada elemento del array, permitiéndote ejecutar acciones sobre ellos. Los métodos .map y .collect se diferencian del método .each en que éstos retornan un array que contiene los elementos transformados:
|
|
|
|
``` ruby
|
|
array.map { |element| element * 2 }
|
|
=> [0, 2, 4, 6, 8]
|
|
```
|
|
|
|
#### .uniq
|
|
El método .uniq toma un array que contiene elementos duplicados y retorna una copia del array conteniendo solo los elementos únicos. Cualquier elemento duplicado es removido de este array:
|
|
|
|
``` ruby
|
|
array = [1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 8]
|
|
array.uniq
|
|
=> [1, 2, 3, 4, 5, 6, 7, 8]
|
|
```
|
|
|
|
#### .concat
|
|
El método .concat concatena los elementos de un array provisto con los del array original. El método .concat puede tomar múliples arrays como argumento, lo cual concatenará múltiples arrays al array original:
|
|
|
|
``` ruby
|
|
array = [0, 1, 2, 3, 4]
|
|
array.concat([5, 6, 7], [8, 9, 10])
|
|
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
|
```
|
|
|
|
## Más información
|
|
* [Documentos de Ruby Array](http://ruby-doc.org/core-2.5.1/Array.html)
|