Latest web development tutorials

Matriz Ruby (Array)

matriz de rubí es cualquier índice entero ordenó colección de objetos. Cada elemento de la matriz con un índice-relacionados, y se puede obtener a través del índice.

matriz indexada a partir de 0, que es el mismo que C o Java. Un índice negativo en relación con el final de la matriz de cuentas, es decir, un índice de -1 significa que el último elemento de la matriz, -2 representa el segundo elemento de la cuenta atrás de la matriz, y así sucesivamente.

rubí matrices pueden almacenar objetos como String, Integer, Fixnum, Hash, Símbolo, e incluso pueden ser otros objetos Array.

Ruby no necesita especificar el tamaño de la matriz, al añadir elementos a una matriz, matriz de rubí crecerá de forma automática.

Creación de una matriz

Hay una variedad de maneras de crear o inicializar la matriz. Una forma es a través de unnuevométodo de clase:

names = Array.new

Puede ajustar el tamaño de la matriz al mismo tiempo, crear una matriz:

names = Array.new(20)

Tamaño denombres dematrices o longitud de 20 elementos. Se puede utilizar el tamaño o longitud método devuelve el tamaño de la matriz:

#!/usr/bin/ruby

names = Array.new(20)
puts names.size  # 返回 20
puts names.length # 返回 20

Ejecutar la salida anterior ejemplo es:

20
20

Puede asignar a cada elemento de la matriz de asignación, de la siguiente manera:

#!/usr/bin/ruby

names = Array.new(4, "mac")

puts "#{names}"

Ejecutar la salida anterior ejemplo es:

["mac", "mac", "mac", "mac"]

También puede utilizar los nuevos bloques con cada elemento de bloque utiliza para llenar los cálculos:

#!/usr/bin/ruby

nums = Array.new(10) { |e| e = e * 2 }

puts "#{nums}"

Ejecutar la salida anterior ejemplo es:

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Matriz Hay otra manera, [], como sigue:

nums = Array.[](1, 2, 3, 4,5)

Otra forma de creación de la matriz es la siguiente:

nums = Array[1, 2, 3, 4,5]

En los módulos básicos de Ruby puede recibir sólo un único método de parámetros de matriz para utilizar una gama como un argumento para crear una matriz de números:

#!/usr/bin/ruby

digits = Array(0..9)

puts "#{digits}"

Ejecutar la salida anterior ejemplo es:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Una serie de métodos incorporados

Necesitamos tener una instancia del objeto Array para invocar los métodos de matriz. Los siguientes son ejemplos de formas de crear un objeto Array:

Array.[](...) [or] Array[...] [or] [...]

Esto devolverá un objeto dado para llenar una nueva matriz. Ahora, utilizando objetos creados, podemos llamar a cualquiera de los métodos disponibles. Por ejemplo:

#!/usr/bin/ruby

digits = Array(0..9)

num = digits.at(6)

puts "#{num}"

Ejecutar la salida anterior ejemplo es:

6

El siguiente es un método public array(matrizsuponiendo es un objeto Array):

序号方法 & 描述
1array & other_array
返回一个新的数组,包含两个数组中共同的元素,没有重复。
2array * int [or] array * str
返回一个新的数组,新数组通过连接 self 的 int 副本创建的。带有 String 参数时,相当于 self.join(str)。
3array + other_array
返回一个新的数组,新数组通过连接两个数组产生第三个数组创建的。
4array - other_array
返回一个新的数组,新数组是从初始数组中移除了在 other_array 中出现的项的副本。
5str <=> other_str
把 str 与 other_str 进行比较,返回 -1(小于)、0(等于)或 1(大于)。比较是区分大小写的。
6array | other_array
通过把 other_array 加入 array 中,移除重复项,返回一个新的数组。
7array << obj
把给定的对象附加到数组的末尾。该表达式返回数组本身,所以几个附加可以连在一起。
8array <=> other_array
如果数组小于、等于或大于 other_array,则返回一个整数(-1、 0 或 +1)。
9array == other_array
如果两个数组包含相同的元素个数,且每个元素与另一个数组中相对应的元素相等(根据 Object.==),那么这两个数组相等。
10array[index] [or] array[start, length] [or]
array[range] [or] array.slice(index) [or]
array.slice(start, length) [or] array.slice(range)

返回索引为index的元素,或者返回从start开始直至length个元素的子数组,或者返回range指定的子数组。负值索引从数组末尾开始计数(-1 是最后一个元素)。如果index(或开始索引)超出范围,则返回nil
11array[index] = obj [or]
array[start, length] = obj or an_array or nil [or]
array[range] = obj or an_array or nil

设置索引为index的元素,或者替换从start开始直至length个元素的子数组,或者替换range指定的子数组。如果索引大于数组的当前容量,那么数组会自动增长。负值索引从数组末尾开始计数。如果length为零则插入元素。如果在第二种或第三种形式中使用了nil,则从self删除元素。
12array.abbrev(pattern = nil)
self中的字符串计算明确的缩写集合。如果传递一个模式或一个字符串,只考虑当字符串匹配模式或者以该字符串开始时的情况。
13array.assoc(obj)
搜索一个数组,其元素也是数组,使用 obj.== 把 obj 与每个包含的数组的第一个元素进行比较。如果匹配则返回第一个包含的数组,如果未找到匹配则返回nil
14array.at(index)
返回索引为 index 的元素。一个负值索引从self的末尾开始计数。如果索引超出范围则返回 nil。
15array.clear
从数组中移除所有的元素。
16array.collect { |item| block } [or]
array.map { |item| block }

self中的每个元素调用一次block。创建一个新的数组,包含 block 返回的值。
17array.collect! { |item| block } [or]
array.map! { |item| block }

self中的每个元素调用一次block,把元素替换为block返回的值。
18array.compact
返回self的副本,移除了所有的nil元素。
19array.compact!
从数组中移除所有的nil元素。如果没有变化则返回nil
20array.concat(other_array)
追加 other_array 中的元素到self中。
21array.delete(obj) [or]
array.delete(obj) { block }

self中删除等于obj的项。如果未找到相等项,则返回nil。如果未找到相等项且给出了可选的代码block,则返回block的结果。
22array.delete_at(index)
删除指定的index处的元素,并返回该元素。如果 index 超出范围,则返回nil
23array.delete_if { |item| block }
block为 true 时,删除self的每个元素。
24array.each { |item| block }
self中的每个元素调用一次block,传递该元素作为参数。
25array.each_index { |index| block }
与 Array#each 相同,但是传递元素的index,而不是传递元素本身。
26array.empty?
如果数组本身没有包含元素,则返回 true。
27array.eql?(other)
如果arrayother是相同的对象,或者两个数组带有相同的内容,则返回 true。
28array.fetch(index) [or]
array.fetch(index, default) [or]
array.fetch(index) { |index| block }

尝试返回位置index处的元素。如果index位于数组外部,则第一种形式会抛出IndexError异常,第二种形式会返回default,第三种形式会返回调用block传入index的值。负值的index从数组末尾开始计数。
29array.fill(obj) [or]
array.fill(obj, start [, length]) [or]
array.fill(obj, range) [or]
array.fill { |index| block } [or]
array.fill(start [, length] ) { |index| block } [or]
array.fill(range) { |index| block }

前面三种形式设置self的被选元素为obj。以nil开头相当于零。nil的长度相当于self.length。最后三种形式用 block 的值填充数组。block通过带有被填充的每个元素的绝对索引来传递。
30array.first [or]
array.first(n)

返回数组的第一个元素或前n个元素。如果数组为空,则第一种形式返回nil,第二种形式返回一个空的数组。
31array.flatten
返回一个新的数组,新数组是一个一维的扁平化的数组(递归)。
32array.flatten!
array进行扁平化。如果没有变化则返回nil。(数组不包含子数组。)
33array.frozen?
如果array被冻结(或排序时暂时冻结),则返回 true。
34array.hash
计算数组的哈希代码。两个具有相同内容的数组将具有相同的哈希代码。
35array.include?(obj)
如果self中包含obj,则返回 true,否则返回 false。
36array.index(obj)
返回self中第一个等于 obj 的对象的index。如果未找到匹配则返回nil
37array.indexes(i1, i2, ... iN) [or]
array.indices(i1, i2, ... iN)

该方法在 Ruby 的最新版本中被废弃,所以请使用 Array#values_at。
38array.indices(i1, i2, ... iN) [or]
array.indexes(i1, i2, ... iN)

该方法在 Ruby 的最新版本中被废弃,所以请使用 Array#values_at。
39array.insert(index, obj...)
在给定的index的元素前插入给定的值,index 可以是负值。
40array.inspect
创建一个数组的可打印版本。
41array.join(sep=$,)
返回一个字符串,通过把数组的每个元素转换为字符串,并使用sep分隔进行创建的。
42array.last [or] array.last(n)
返回self的最后一个元素。如果数组为 ,则第一种形式返回nil
43array.length
返回self中元素的个数。可能为零。
44array.map { |item| block } [or]
array.collect { |item| block }

self的每个元素调用一次block。创建一个新的数组,包含 block 返回的值。
45array.map! { |item| block } [or]
array.collect! { |item| block }

array的每个元素调用一次block,把元素替换为 block 返回的值。
46array.nitems
返回self中 non-nil 元素的个数。可能为零。
47array.pack(aTemplateString)
根据 aTemplateString 中的指令,把数组的内容压缩为二进制序列。指令 A、 a 和 Z 后可以跟一个表示结果字段宽度的数字。剩余的指令也可以带有一个表示要转换的数组元素个数的数字。如果数字是一个星号(*),则所有剩余的数组元素都将被转换。任何指令后都可以跟一个下划线(_),表示指定类型使用底层平台的本地尺寸大小,否则使用独立于平台的一致的尺寸大小。在模板字符串中空格会被忽略。
48array.pop
array中移除最后一个元素,并返回该元素。如果array为空则返回nil
49array.push(obj, ...)
把给定的 obj 附加到数组的末尾。该表达式返回数组本身,所以几个附加可以连在一起。
50array.rassoc(key)
搜索一个数组,其元素也是数组,使用 == 把key与每个包含的数组的第二个元素进行比较。如果匹配则返回第一个包含的数组。
51array.reject { |item| block }
返回一个新的数组,包含当 block 不为 true 时的数组项。
52array.reject! { |item| block }
当 block 为真时,从array删除元素,如果没有变化则返回nil。相当于 Array#delete_if。
53array.replace(other_array)
array的内容替换为other_array的内容,必要的时候进行截断或扩充。
54array.reverse
返回一个新的数组,包含倒序排列的数组元素。
55array.reverse!
array进行逆转。
56array.reverse_each {|item| block }
与 Array#each 相同,但是把array进行逆转。
57array.rindex(obj)
返回 array 中最后一个等于 obj 的对象的索引。如果未找到匹配,则返回nil
58array.select {|item| block }
调用从数组传入连续元素的 block,返回一个数组,包含 block 返回true值时的元素。
59array.shift
返回self的第一个元素,并移除该元素(把所有的其他元素下移一位)。如果数组为空,则返回nil
60array.size
返回array的长度(元素的个数)。length 的别名。
61array.slice(index) [or] array.slice(start, length) [or]
array.slice(range) [or] array[index] [or]
array[start, length] [or] array[range]

返回索引为index的元素,或者返回从start开始直至length个元素的子数组,或者返回range指定的子数组。负值索引从数组末尾开始计数(-1 是最后一个元素)。如果index(或开始索引)超出范围,则返回nil
62array.slice!(index) [or] array.slice!(start, length) [or]
array.slice!(range)

删除index(长度是可选的)或range指定的元素。返回被删除的对象、子数组,如果index超出范围,则返回nil
63array.sort [or] array.sort { | a,b | block }
返回一个排序的数组。
64array.sort! [or] array.sort! { | a,b | block }
把数组进行排序。
65array.to_a
返回self。如果在Array的子类上调用,则把接收参数转换为一个 Array 对象。
66array.to_ary
返回 self。
67array.to_s
返回 self.join。
68array.transpose
假设 self 是数组的数组,且置换行和列。
69array.uniq
返回一个新的数组,移除了array中的重复值。
70array.uniq!
self中移除重复元素。如果没有变化(也就是说,未找到重复),则返回nil
71array.unshift(obj, ...)
把对象前置在数组的前面,其他元素上移一位。
72array.values_at(selector,...)
返回一个数组,包含 self 中与给定的selector(一个或多个)相对应的元素。选择器可以是整数索引或者范围。
73array.zip(arg, ...) [or]
array.zip(arg, ...){ | arr | block }

把任何参数转换为数组,然后把array的元素与每个参数中相对应的元素合并。

las instrucciones del paquete array

En la siguiente tabla se muestran las instrucciones del paquete de matriz # método de compresión.

指令描述
@移动到绝对位置。
AASCII 字符串(填充 space,count 是宽度)。
aASCII 字符串(填充 null,count 是宽度)。
B位字符串(降序)
b位字符串(升序)。
C无符号字符。
c字符。
D, d双精度浮点数,原生格式。
E双精度浮点数,little-endian 字节顺序。
e单精度浮点数,little-endian 字节顺序。
F, f单精度浮点数,原生格式。
G双精度浮点数,network(big-endian)字节顺序。
g单精度浮点数,network(big-endian)字节顺序。
H十六进制字符串(高位优先)。
h十六进制字符串(低位优先)。
I无符号整数。
i整数。
L无符号 long。
lLong。
M引用可打印的,MIME 编码。
mBase64 编码字符串。
NLong,network(big-endian)字节顺序。
nShort,network(big-endian)字节顺序。
P指向一个结构(固定长度的字符串)。
p指向一个空结束字符串。
Q, q64 位数字。
S无符号 short。
sShort。
UUTF-8。
uUU 编码字符串。
VLong,little-endian 字节顺序。
vShort,little-endian 字节顺序。
wBER 压缩的整数 \fnm。
X向后跳过一个字节。
xNull 字节。
Z与 a 相同,除了 null 会被加上 *。

Ejemplos

Prueba los siguientes ejemplos, los diversos compresión de datos.

a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3")   #=> "a  b  c  "
puts a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")      #=> "ABC"

Ejecutar la salida anterior ejemplo es:

a  b  c
abc
ABC