Array

Public Class Methods

new(size=0, obj=nil, &block) click to toggle source

Private method for Array creation.

ISO 15.2.12.5.15

 
               # File mrblib/array.rb, line 63
def initialize(size=0, obj=nil, &block)
  raise TypeError, "expected Integer for 1st argument" unless size.kind_of? Integer
  raise ArgumentError, "negative array size" if size < 0

  self.clear
  if size > 0
    self[size - 1] = nil  # allocate

    idx = 0
    while(idx < size)
      self[idx] = (block)? block.call(idx): obj
      idx += 1
    end
  end

  self
end

Public Instance Methods

ary & other_ary → new_ary click to toggle source

Set Intersection—Returns a new array containing elements common to the two arrays, with no duplicates.

[ 1, 1, 3, 5 ] & [ 1, 2, 3 ]   #=> [ 1, 3 ]

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 91
def &(elem)
  raise TypeError, "can't convert #{elem.class} into Array" unless elem.class == Array

  hash = {}
  array = []
  elem.each{|v| hash[v] = true }
  self.each do |v|
    if hash[v]
      array << v
      hash.delete v
    end
  end
  array
end

ary - other_ary → new_ary click to toggle source

Array Difference---Returns a new array that is a copy of the original array, removing any items that also appear in other_ary. (If you need set-like behavior, see the library class Set.)

[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 55
def -(elem)
  raise TypeError, "can't convert #{elem.class} into Array" unless elem.class == Array

  hash = {}
  array = []
  elem.each { |x| hash[x] = true }
  self.each { |x| array << x unless hash[x] }
  array
end

collect!(&block) click to toggle source

Calls the given block for each element of self and pass the respective element. Each element will be replaced by the resulting values.

ISO 15.2.12.5.7

 
               # File mrblib/array.rb, line 46
def collect!(&block)
  self.each_index{|idx|
    self[idx] = block.call(self[idx])
  }
  self
end

Also aliased as: map!

compact → new_ary click to toggle source

Returns a copy of self with all nil elements removed.

[ "a", nil, "b", nil, "c", nil ].compact
                  #=> [ "a", "b", "c" ]

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 179
def compact
  result = self.dup
  result.compact!
  result
end

compact! → ary or nil click to toggle source

Removes nil elements from the array. Returns nil if no changes were made, otherwise returns ary.

[ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ]
[ "a", "b", "c" ].compact!           #=> nil

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 196
def compact!
  result = self.select { |e| e != nil }
  if result.size == self.size
    nil
  else
    self.replace(result)
  end
end

delete(key, &block) click to toggle source

Delete element with index key

 
               # File mrblib/array.rb, line 83
def delete(key, &block)
  while i = self.index(key)
    self.delete_at(i)
    ret = key
  end
  if ret == nil && block
    block.call
  else
    ret
  end
end

each(&block) click to toggle source

Calls the given block for each element of self and pass the respective element.

ISO 15.2.12.5.10

 
               # File mrblib/array.rb, line 12
def each(&block)
  idx, length = -1, self.length-1
  while idx < length and length <= self.length and length = self.length-1
    elm = self[idx += 1]
    unless elm
      if elm == nil and length >= self.length
        break
      end
    end
    block.call(elm)
  end
  self
end

each_index(&block) click to toggle source

Calls the given block for each element of self and pass the index of the respective element.

ISO 15.2.12.5.11

 
               # File mrblib/array.rb, line 31
def each_index(&block)
  idx = 0
  while(idx < length)
    block.call(idx)
    idx += 1
  end
  self
end

flatten → new_ary click to toggle source

flatten(level) → new_ary

Returns a new array that is a one-dimensional flattening of this array (recursively). That is, for every element that is an array, extract its elements into the new array. If the optional level argument determines the level of recursion to flatten.

s = [ 1, 2, 3 ]           #=> [1, 2, 3]
t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
a.flatten                 #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = [ 1, 2, [3, [4, 5] ] ]
a.flatten(1)              #=> [1, 2, 3, [4, 5]]

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 123
def flatten(depth=nil)
  ar = []
  self.each do |e|
    if e.is_a?(Array) && (depth.nil? || depth > 0)
      ar += e.flatten(depth.nil? ? nil : depth - 1)
    else
      ar << e
    end
  end
  ar
end

flatten! → ary or nil click to toggle source

flatten!(level) → array or nil

Flattens self in place. Returns nil if no modifications were made (i.e., ary contains no subarrays.) If the optional level argument determines the level of recursion to flatten.

a = [ 1, 2, [3, [4, 5] ] ]
a.flatten!   #=> [1, 2, 3, 4, 5]
a.flatten!   #=> nil
a            #=> [1, 2, 3, 4, 5]
a = [ 1, 2, [3, [4, 5] ] ]
a.flatten!(1) #=> [1, 2, 3, [4, 5]]

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 152
def flatten!(depth=nil)
  modified = false
  ar = []
  self.each do |e|
    if e.is_a?(Array) && (depth.nil? || depth > 0)
      ar += e.flatten(depth.nil? ? nil : depth - 1)
      modified = true
    else
      ar << e
    end
  end
  if modified
    self.replace(ar)
  else
    nil
  end
end

map!(&block) click to toggle source

Alias for collect!

ISO 15.2.12.5.20

Alias for: collect!

sort!(&block) click to toggle source

Sort all elements and replace self with these elements.

 
               # File mrblib/array.rb, line 108
def sort!(&block)
  self.replace(self.sort(&block))
end

uniq → new_ary click to toggle source

Returns a new array by removing duplicate values in self.

a = [ "a", "a", "b", "b", "c" ]
a.uniq   #=> ["a", "b", "c"]

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 38
def uniq
  ary = self.dup
  ary.uniq!
  ary
end

uniq! → ary or nil click to toggle source

Removes duplicate elements from self. Returns nil if no changes are made (that is, no duplicates are found).

a = [ "a", "a", "b", "b", "c" ]
a.uniq!   #=> ["a", "b", "c"]
b = [ "a", "b", "c" ]
b.uniq!   #=> nil

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 15
def uniq!
  ary = self.dup
  result = []
  while ary.size > 0
    result << ary.shift
    ary.delete(result.last)
  end
  if result.size == self.size
    nil
  else
    self.replace(result)
  end
end

ary | other_ary → new_ary click to toggle source

Set Union—Returns a new array by joining this array with other_ary, removing duplicates.

[ "a", "b", "c" ] | [ "c", "d", "a" ]
       #=> [ "a", "b", "c", "d" ]

 
               # File mrbgems/mruby-array-ext/mrblib/array.rb, line 75
def |(elem)
  raise TypeError, "can't convert #{elem.class} into Array" unless elem.class == Array

  ary = self + elem
  ary.uniq! or ary
end

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please see Improve the docs, or visit Documenting-ruby.org.

Home Classes Methods

In Files

Parent

Methods

Included Modules

Files

Class/Module Index

Array

Public Class Methods

Public Instance Methods