Class: Array

Inherits:
Object show all
Defined in:
lib/open_classes/array.rb

Overview

Array

Instance Method Summary collapse

Instance Method Details

#together ⇒ Object

Arrays loop together.

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together do |first, second|
  print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
end



14
15
16
17
18
19
20
 
# File 'lib/open_classes/array.rb', line 14

def together
  if_not_contain_array_rails_type_error
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    instance_eval "yield(#{eval_each_str})"
  end
end

#together_at(index) ⇒ Object Also known as: tat

Arrays bulk at.

together_at has alias :tat

same elements size case

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_at 2 # => output ['three', 3]

different elements size case

alpha = %w{one two three}
numbers = %w{1 2}
[alpha, numbers].together_at 2 # => output ['three', nil]



197
198
199
200
 
# File 'lib/open_classes/array.rb', line 197

def together_at(index)
  if_not_contain_array_rails_type_error
  reduce([]) { |ats, list|ats << list.at(index) }
end

#together_clear ⇒ Object Also known as: tclear

Arrays bulk clear.

together_clear has alias :tclear

same elements size case

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_clear # => output [[],[]]



210
211
212
213
 
# File 'lib/open_classes/array.rb', line 210

def together_clear
  if_not_contain_array_rails_type_error
  each { |list|list.clear }
end

#together_compact ⇒ Object Also known as: tcompact

Arrays bulk compact.(immutable)

together_compact has alias :tcompact

same elements size case

alpha = ['a','b','c', nil,'d']
numbers = [1, 2, nil, 3]
lists = [alpha, numbers]
ret = lists.together_compact
print lists # => output [['a','b','c', nil,'d'], [1, 2, nil, 3]]
print ret # => output [['a','b','c','d'], [1, 2, 3]]



226
227
228
229
 
# File 'lib/open_classes/array.rb', line 226

def together_compact
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.compact }
end

#together_compact! ⇒ Object Also known as: tcompact!

Arrays bulk compact!.(mutable)

together_compact! has alias :tcompact!

same elements size case

alpha = ['a','b','c', nil,'d']
numbers = [1, 2, nil, 3]
lists = [alpha, numbers]
ret = lists.together_compact!
print lists # => output [['a','b','c','d'], [1, 2, 3]]
print ret # => output [['a','b','c','d'], [1, 2, 3]]



242
243
244
245
 
# File 'lib/open_classes/array.rb', line 242

def together_compact!
  if_not_contain_array_rails_type_error
  each { |list|list.compact! }
end

#together_concat(other) ⇒ Object Also known as: tconcat

Arrays bulk concat.

together_concat has alias :tconcat

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together do |first, second|
  print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
end



179
180
181
182
 
# File 'lib/open_classes/array.rb', line 179

def together_concat(other)
  if_not_contain_array_rails_type_error
  each { |list|list.concat other }
end

#together_delete(value) ⇒ Object Also known as: tdelete

Arrays bulk delete.

together_delete has alias :tdelete

if delete target is exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete 2
print ret # => 2
print lists # => output [[1, 3, 4], [3, 4, 5]]

if delete target is not exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete 6
print ret # => nil
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]

if delete target is not exist and use block

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete(6) { 999 }
print ret # => 999
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]



274
275
276
277
278
279
280
 
# File 'lib/open_classes/array.rb', line 274

def together_delete(value)
  if_not_contain_array_rails_type_error
  ret = []
  each { |list|ret << list.delete(value) }
  default_return = block_given? ? yield : nil
  ret.compact.size == 0 ? default_return : value
end

#together_delete_at(index) ⇒ Object Also known as: tdelete_at

Arrays bulk delete_at.

together_delete_at has alias :tdelete_at

if delete_at target is exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at 2
print ret # => [3, 4]
print lists # => output [[1, 2, 4], [2, 3, 5]]

if delete_at target is not exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at 6
print ret # => [nil, nil]
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]

if delete_at target is exist(minus index)

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at -3
print ret # => [2, 3]
print lists # => output [[1, 3, 4], [2, 4, 5]]



309
310
311
312
 
# File 'lib/open_classes/array.rb', line 309

def together_delete_at(index)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.delete_at(index) }
end

#together_delete_if(&block) ⇒ Object Also known as: tdelete_if

Arrays bulk delete_if.

together_delete_if has alias :tdelete_if

if delete_if target is exist. return self.

lists = [[1, 2, 3, 4], [6, 4, 6, 8]]
ret = lists.together_delete_if {|first, second|(first + second).odd?}
print ret # => [[2, 4], [4, 8]]

if delete_if target is not exist. return nil.

lists = [[2, 2, 4, 4], [6, 4, 6, 8]]
ret = lists.together_delete_if {|first, second|(first + second).odd?}
print ret # => nil



327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/open_classes/array.rb', line 327

def together_delete_if(&block)
  if_not_contain_array_rails_type_error
  have_deleted = false
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    is_delete = instance_eval "yield(#{eval_each_str})"
    if is_delete
      each { |e|e.delete_at i }
      have_deleted = true
    end
  end
  have_deleted ? self : nil
end

#together_empty? ⇒ Boolean Also known as: tempty?

Arrays bulk empty?.

together_empty? has alias :tempty?

empty case

lists = [[], []]
ret = lists.together_empty?
print ret # => true

not empty case

lists = [[1], []]
ret = lists.together_empty?
print ret # => false

Returns:

  • (Boolean) 


354
355
356
357
358
359
 
# File 'lib/open_classes/array.rb', line 354

def together_empty?
  if_not_contain_array_rails_type_error
  is_empty = true
  each { |list|is_empty = is_empty && list.empty? }
  is_empty
end

#together_fill(fill_value = nil, &block) ⇒ Object Also known as: tfill

Arrays bulk fill.

together_fill has alias :tfill

not use block case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill(99)
print ret # => [[99, 99, 99, 99, 99], [99, 99, 99, 99, 99]]

use block, no args case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill { |i|(i + 1) + 1 }
print ret # => [[2, 3, 4, 5, 6], [2, 3, 4, 5, 6]]

use block, has args case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill(2) { |i|(i + 1) + 1 }
print ret # => [[1, 2, 4, 5, 6], [6, 7, 4, 5, 6]]



379
380
381
382
383
384
385
386
387
388
389
390
391
 
# File 'lib/open_classes/array.rb', line 379

def together_fill(fill_value = nil, &block)
  if_not_contain_array_rails_type_error
  if block
    fill_value = 0 if fill_value.nil?
    first.each_with_index do |i_v, i|
      next if i < fill_value
      each { |list|list[i] = yield(i) }
    end
  else
    each { |list|list.fill fill_value }
  end
  self
end

#together_first(index = nil) ⇒ Object Also known as: tfirst

Arrays bulk first.

together_first has alias :tfirst

no args case

lists = [[*1..5], [*6..10]]
ret = lists.together_first
print ret # => [1, 6]

has args 2 case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 2
print ret # => [[1, 2], [6, 7]]

has args 0 case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 0
print ret # => [[], []]

has args over size case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 6
print ret # => [[*1..5], [*6..10]]



416
417
418
419
420
 
# File 'lib/open_classes/array.rb', line 416

def together_first(index = nil)
  if_not_contain_array_rails_type_error
  each_return = index == 0 ? '[]' : index.nil? ? 'list.first' : 'list[0..index - 1]'
  reduce([]) { |ret, list|ret << eval(each_return, binding) }
end

#together_include?(value, is_multi = false) ⇒ Boolean Also known as: tinclude?

Arrays bulk include?.

together_include? has alias :tinclude?

both include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 5
print ret # => true

one include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 9
print ret # => true

both not include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 10
print ret # => false

both include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 5, true
print ret # => [true, true]

one include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 9, true
print ret # => [false, true]

both not include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 10, true
print ret # => [false, false]

Returns:

  • (Boolean) 


455
456
457
458
459
 
# File 'lib/open_classes/array.rb', line 455

def together_include?(value, is_multi = false)
  if_not_contain_array_rails_type_error
  return reduce([]) { |ret, list|ret << list.include?(value) } if is_multi
  reduce(false) { |ret, list|ret = ret || list.include?(value) }
end

#together_map ⇒ Object

Arrays together map.

together_map has aliases [:tmap, :together_collect, :tcollect]

if you want to single Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
print [alpha, numbers].together_map do |first, second|
  "#{first}:#{second}\n"
end # => output one:1, two:2, three:3

if you want to multi Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
print [alpha, numbers].together_map do |first, second|
  ["#{first}:#{second}", "#{second}:#{first}"]
end # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]



54
55
56
57
58
59
60
61
62
63
 
# File 'lib/open_classes/array.rb', line 54

def together_map
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_map(ret, each_ret, i)
  end
  ret
end

#together_map! ⇒ Object

Arrays together map!.

together_map! has aliases [:tmap!, :together_collect!, :tcollect!]

if you want to single Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
ary = [alpha, numbers]
ret = ary.together_map! do |first, second|
  "#{first}:#{second}"
end
print ret # => output ['one:1', 'two:2', 'three:3']
print ary # => output ['one:1', 'two:2', 'three:3']

if you want to multi Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
ary = [alpha, numbers]
ret = ary.together_map! do |first, second|
  ["#{first}:#{second}", "#{second}:#{first}"]
end
print ret # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
print ary # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]



89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/open_classes/array.rb', line 89

def together_map!
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_map(ret, each_ret, i)
  end
  clear
  ret.each { |v|self << v }
end

#together_reduce(init = nil) ⇒ Object

Arrays loop together reduce.

together_reduce has aliases [:treduce, :together_inject, :tinject]

if you want to single return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce{|memo, first, second|memo + first + second}
print ret # => output  20

if you want to single return with init value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce(10){|memo, first, second|memo + first + second}
print ret # => output  30

if you want to single return with init string value

firsts = %w{a b c}
seconds =  %w{1 2 3}
ret = [firsts, seconds].together_reduce('start-'){|memo, first, second|memo + first + second}
print ret # => output 'start-a1b2c3'

if you want to single return with init Array value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce([]){|memo, first, second|memo << first + second}
print ret # => output [5, 4, 6, 5]

if you want to single return with init Hash value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce({}){|memo, first, second|memo[first] = second;memo}
print ret # => output {1=>4, 2=>2, 3=>3, 4=>1}



160
161
162
163
164
165
166
167
168
 
# File 'lib/open_classes/array.rb', line 160

def together_reduce(init = nil)
  if_not_contain_array_rails_type_error
  memo = initial_memo init
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    memo = instance_eval "yield(memo, #{eval_each_str})"
  end
  memo
end

#together_select ⇒ Object

Arrays loop together select.

together_select has aliases [:tselect, :together_find_all, :tfindall]

if you want to single Array return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_select{|first, second|first == second}
print ret # => output  [[2, 3], [2, 3]]

if you want to multi Array return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_select{|first, second|[first.odd?, second.even?]}
print ret # => output  [[1, 3], [4, 2]]



116
117
118
119
120
121
122
123
124
125
 
# File 'lib/open_classes/array.rb', line 116

def together_select
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_select(ret, each_ret, i)
  end
  ret
end

#together_with_index ⇒ Object

Arrays loop together with index.

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_with_index do |first, second, index|
  print "#{index.to_s}:#{first}:#{second}\n"  # => output 0:one:1, 1:two:2, 2:three:3
end



29
30
31
32
33
34
35
 
# File 'lib/open_classes/array.rb', line 29

def together_with_index
  if_not_contain_array_rails_type_error
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i, true
    instance_eval "yield(#{eval_each_str})"
  end
end