Métodos e Propriedades de Arrays em JavaScript, Python, Go e Ruby on Rails

Quem alterna entre linguagens passa boa parte do tempo perguntando a mesma coisa: "como é que se faz isso aqui de novo?" Este artigo é uma referência prática para o catálogo mais usado — operações sobre arrays (JavaScript), listas (Python), slices (Go) e Array (Ruby on Rails).

A organização espelha a do post original em JavaScript: tamanho, manipulação de elementos, acesso e busca, iteração e transformação, ordenação, fatiamento e junção, predicados e achatamento. Cada método traz um snippet equivalente nas quatro linguagens, sempre na variante mais idiomática.

Antes de Começar: Três Diferenças Importantes

Mutação vs nova coleção. Em JavaScript e Python, sort e reverse mutam a coleção; já map, filter e slice devolvem nova. Em Ruby, a convenção é clara pelo sufixo: sort! muta, sort devolve nova. Em Go, slices compartilham storage subjacente — sempre verifique se está mutando o original.
Tratamento de "não encontrado". JavaScript usa -1, Python lança ValueError, Go retorna -1 via slices.Index, e Ruby devolve nil. Não são detalhes — mudam o controle de fluxo.
Go é mais verboso por design. A std de Go evita closures genéricas até onde dá. O pacote slices (Go 1.21+) cobre boa parte do gap; o resto resolve com for range. Ruby on Rails segue o caminho oposto: blocos com { |v| ... } tornam quase tudo uma linha.

Tamanho

length / len

Retorna o número de elementos do array, lista ou slice.

JavaScript

arr.length;

Python

len(arr)

len(arr)

Ruby on Rails

arr.length # ou arr.size

Manipulação de Elementos

push / append

Adiciona um elemento ao final.

JavaScript

arr.push(4);

Python

arr.append(4)

arr = append(arr, 4)

Ruby on Rails

arr.push(4) # ou arr << 4

pop

Remove e retorna o último elemento.

JavaScript

const last = arr.pop();

Python

last = arr.pop()

last := arr[len(arr)-1]
arr = arr[:len(arr)-1]

Ruby on Rails

last = arr.pop

unshift / insert no início

Adiciona um elemento no início.

JavaScript

arr.unshift(0);

Python

arr.insert(0, 0)

arr = append([]int{0}, arr...)

Ruby on Rails

arr.unshift(0)

shift / pop no início

Remove e retorna o primeiro elemento.

JavaScript

const first = arr.shift();

Python

first = arr.pop(0)

first := arr[0]
arr = arr[1:]

Ruby on Rails

first = arr.shift

splice

Insere e remove elementos arbitrariamente em qualquer posição.

JavaScript

arr.splice(1, 2, "a", "b");

Python

arr[1:3] = ["a", "b"]

arr = append(arr[:1],
  append([]string{"a", "b"}, arr[3:]...)...)

Ruby on Rails

arr[1, 2] = ["a", "b"]

concat

Concatena dois arrays e retorna um novo.

JavaScript

const c = a.concat(b);

Python

c = a + b

c := append(a, b...)

Ruby on Rails

c = a + b # a.concat(b) muta a

Acesso e Busca

Go e Ruby expõem boa parte dessas operações via std. Em Go 1.21+, o pacote slices traz utilitários nativos; em Rails, o ActiveSupport adiciona helpers como pluck e compact_blank sobre o Array de Ruby.

indexOf

Retorna o índice da primeira ocorrência, ou um valor sentinela quando não encontra.

JavaScript

arr.indexOf(x); // -1 se não achar

Python

arr.index(x) # lança ValueError se não achar

slices.Index(arr, x) // -1 se não achar

Ruby on Rails

arr.index(x) # nil se não achar

lastIndexOf

Retorna o índice da última ocorrência.

JavaScript

arr.lastIndexOf(x);

Python

len(arr) - 1 - arr[::-1].index(x)

slices.IndexFunc(arr, func(v int) bool {
  return v == x
}) // ou loop reverso

Ruby on Rails

arr.rindex(x)

includes

Indica se o elemento existe no array.

JavaScript

arr.includes(x);

Python

x in arr

slices.Contains(arr, x)

Ruby on Rails

arr.include?(x)

find

Retorna o primeiro elemento que satisfaz a condição.

JavaScript

arr.find((v) => v > 3);

Python

next((v for v in arr if v > 3), None)

i := slices.IndexFunc(arr, func(v int) bool {
  return v > 3
})
if i >= 0 { /* arr[i] */ }

Ruby on Rails

arr.find { |v| v > 3 }

findIndex

Retorna o índice do primeiro elemento que satisfaz a condição.

JavaScript

arr.findIndex((v) => v > 3);

Python

next(
  (i for i, v in enumerate(arr) if v > 3),
  -1,
)

slices.IndexFunc(arr, func(v int) bool {
  return v > 3
})

Ruby on Rails

arr.index { |v| v > 3 }

Iteração e Transformação

forEach

Executa um efeito colateral para cada elemento.

JavaScript

arr.forEach((v) => console.log(v));

Python

for v in arr:
    print(v)

for _, v := range arr {
  fmt.Println(v)
}

Ruby on Rails

arr.each { |v| puts v }

map

Aplica uma transformação e devolve uma nova coleção.

JavaScript

const doubled = arr.map((v) => v * 2);

Python

doubled = [v * 2 for v in arr]

doubled := make([]int, len(arr))
for i, v := range arr {
  doubled[i] = v * 2
}

Ruby on Rails

doubled = arr.map { |v| v * 2 }

filter

Mantém apenas os elementos que satisfazem a condição.

JavaScript

arr.filter((v) => v > 3);

Python

[v for v in arr if v > 3]

var out []int
for _, v := range arr {
  if v > 3 {
    out = append(out, v)
  }
}

Ruby on Rails

arr.select { |v| v > 3 }

reduce / inject

Combina os elementos em um único valor, da esquerda para a direita.

JavaScript

arr.reduce((acc, v) => acc + v, 0);

Python

from functools import reduce
reduce(lambda acc, v: acc + v, arr, 0)
# ou simplesmente sum(arr)

acc := 0
for _, v := range arr {
  acc += v
}

Ruby on Rails

arr.reduce(0) { |acc, v| acc + v }
# ou simplesmente arr.sum

reduceRight

Mesmo reduce, mas percorrendo da direita para a esquerda.

JavaScript

arr.reduceRight((acc, v) => acc + v, 0);

Python

reduce(lambda acc, v: acc + v, reversed(arr), 0)

acc := 0
for i := len(arr) - 1; i >= 0; i-- {
  acc += arr[i]
}

Ruby on Rails

arr.reverse.reduce(0) { |acc, v| acc + v }

Ordenação

sort

Ordena os elementos em ordem crescente.

JavaScript

arr.sort((a, b) => a - b);

Python

arr.sort()

slices.Sort(arr)

Ruby on Rails

arr.sort! # ou arr.sort (não muta)

reverse

Inverte a ordem dos elementos.

JavaScript

arr.reverse();

Python

arr.reverse()

slices.Reverse(arr)

Ruby on Rails

arr.reverse! # ou arr.reverse (não muta)

Fatiamento e Junção

slice

Cria uma cópia (ou visão, em Go) de um intervalo.

JavaScript

arr.slice(1, 3);

Python

arr[1:3]

arr[1:3]

Ruby on Rails

arr[1..2] # ou arr.slice(1, 2)

join

Une os elementos em uma string usando um separador. Em Go, a coleção precisa ser de strings.

JavaScript

arr.join(",");

Python

",".join(arr)

strings.Join(arr, ",")

Ruby on Rails

arr.join(",")

Predicados e Achatamento

every / all?

Verdadeiro se todos os elementos satisfazem a condição.

JavaScript

arr.every((v) => v > 0);

Python

all(v > 0 for v in arr)

ok := true
for _, v := range arr {
  if v <= 0 {
    ok = false
    break
  }
}

Ruby on Rails

arr.all? { |v| v > 0 }

some / any?

Verdadeiro se pelo menos um elemento satisfaz a condição.

JavaScript

arr.some((v) => v > 0);

Python

any(v > 0 for v in arr)

slices.IndexFunc(arr, func(v int) bool {
  return v > 0
}) >= 0

Ruby on Rails

arr.any? { |v| v > 0 }

flat / flatten

Achata um nível de aninhamento.

JavaScript

arr.flat(1);

Python

[x for sub in arr for x in sub]

var out []int
for _, sub := range arr {
  out = append(out, sub...)
}

Ruby on Rails

arr.flatten(1)

flatMap / flat_map

Aplica uma função que devolve coleção e achata o resultado.

JavaScript

arr.flatMap((v) => [v, v * 2]);

Python

[x for v in arr for x in (v, v * 2)]

var out []int
for _, v := range arr {
  out = append(out, v, v*2)
}

Ruby on Rails

arr.flat_map { |v| [v, v * 2] }

Como Usar Esta Referência

O objetivo desta tabela cruzada não é cobrir todos os casos extremos — é fixar o equivalente mais idiomático para o cotidiano. Para semântica completa (alocação, complexidade, comportamento em edge cases), as referências canônicas são: MDN Array, Python Data Structures, Go slices e Ruby Array (mais extensões do ActiveSupport em projetos Rails).

Em resumo: os nomes mudam, mas o conjunto de operações que importa no dia a dia é estável entre linguagens. Saber o mapeamento corta dezenas de consultas e elimina aquele atrito de troca de stack.