code guest register log in programs messages repl documentation source about privacy terms /up french production

Dictionary

Global

Dictionary < Object

examples

!{}

Dictionary.new

Dictionary.new(a: 1, b: 2).a

{ a: 1, b: 2 }.b

{}

{} == {}

{}.to_list

instance functions

<

examples

{ a: 1 } < { a: 1, b: 2 }
<=

examples

{ a: 1 } <= { a: 1, b: 2 }
<=>

examples

{ a: 1 } <=> { a: 1, b: 2 }
>

examples

{ a: 1 } > { a: 1, b: 2 }
>=

examples

{ a: 1 } >= { a: 1, b: 2 }
[]

examples

{ a: 1 }[:a]
any?

examples

{ a: 1 }.any?
at

examples

{ a: 1 }.at(:a)
clear

examples

d = { a: 1 } d.clear d
compact

examples

{ a: nothing, b: 2 }.compact
compact!

examples

d = { a: nothing, b: 2 } d.compact! d
compare

examples

{ a: 1 }.compare({ a: 1, b: 2 })

{ a: 1 }.compare(a: 1, b: 2)
delete

examples

d = { a: 1, b: 2 } d.delete(:a) d
delete_if

examples

d = { a: 1, b: 2 } d.delete_if { |key, value| value.one? } d

d = { a: 1, b: 2 } d.delete_if { |key, value| key == :a } d

d = { a: 1, b: 2 } d.delete_if(Integer) d

d = { a: 1, b: 2 } d.delete_if { |key, value, index| index.zero? } d

d = { a: 1, b: 2 } d.delete_if { |key, value, index, dictionary| dictionary.many? } d
delete_unless

examples

d = { a: 1, b: 2 } d.delete_unless { |key, value| value.one? } d

d = { a: 1, b: 2 } d.delete_unless { |key, value| key == :a } d

d = { a: 1, b: 2 } d.delete_unless(Integer) d

d = { a: 1, b: 2 } d.delete_unless { |key, value, index| index.zero? } d

d = { a: 1, b: 2 } d.delete_unless { |key, value, index, dictionary| dictionary.many? } d
dig

examples

{ a: { b: { c: 3 } } }.dig(:a, :b, :c)

{ a: { b: [1, 2, 3, 4] } }.dig(:a, :b, 2)
each

examples

{ a: 1, b: 2 }.each { |key| puts(key) }

{ a: 1, b: 2 }.each { |key, value| puts(value) }

{ a: 1, b: 2 }.each { |key, value, index| puts(index) }

{ a: 1, b: 2 }.each { |key, value, index, dictionary| puts(dictionary) }
eight?

examples

{ a: 1 }.eight?

{ a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, f: 8 }.eight?
empty?

examples

{}.empty?

{ a: 1 }.empty?
except

examples

{ a: 1, b: 2 }.except(:a)
fetch

examples

{ a: 1, b: 2 }.fetch(:a)

{ a: 1, b: 2 }.fetch(:c) { 3 }
fetch_values

examples

{ a: 1, b: 2 }.fetch_values(:a, :b)
filter

examples

{ a: 1, b: 2 }.filter { |key| key == :a }

{ a: 1, b: 2 }.filter { |key, value| value.one? }

{ a: 1, b: 2 }.filter { |key, value, index| index.zero? }

{ a: 1, b: 2 }.filter { |key, value, index, dictionary| dictionary.many? }
filter!

examples

d = { a: 1, b: 2 } d.filter! { |key| key == :a } d

d = { a: 1, b: 2 } d.filter! { |key, value| value.one? } d

d = { a: 1, b: 2 } d.filter! { |key, value, index| index.zero? } d

d = { a: 1, b: 2 } d.filter! { |key, value, index, dictionary| dictionary.many? } d
five?

examples

{ a: 1 }.five?

{ a: 1, b: 2, c: 3, d: 4, e: 5 }.five?
flatten

examples

{ a: 1 }.flatten

{ a: { b: 2 } }.flatten

{ a: { b: 2 } }.flatten(1)

{ a: { b: { c: 3 } } }.flatten(2)
four?

examples

{ a: 1 }.four?

{ a: 1, b: 2, c: 3, d: 4 }.four?
get

examples

{ a: 1 }.get(:a)
has_key?

examples

{ a: 1 }.has_key?(:a)

{ a: 1 }.has_key?(:b)
has_value?

examples

{ a: 1 }.has_value?(1)

{ a: 1 }.has_value?(2)
inferior

examples

{ a: 1 }.inferior({ a: 1, b: 2 })

{ a: 1 }.inferior(a: 1, b: 2)
inferior_or_equal

examples

{ a: 1 }.inferior_or_equal({ a: 1, b: 2 })

{ a: 1 }.inferior_or_equal(a: 1, b: 2)
invert

examples

{ a: 1 }.invert

{ a: 1, b: 2 }.invert
keep_if

examples

d = { a: 1, b: 2 } d.keep_if(Integer) d

d = { a: 1, b: 2 } d.keep_if { |key| key == :a } d

d = { a: 1, b: 2 } d.keep_if { |key, value| value.one? } d

d = { a: 1, b: 2 } d.keep_if { |key, value, index| index.zero? } d

d = { a: 1, b: 2 } d.keep_if { |key, value, index, dictionary| dictionary.many? } d
keep_unless

examples

d = { a: 1, b: 2 } d.keep_unless(Integer) d

d = { a: 1, b: 2 } d.keep_unless { |key| key == :a } d

d = { a: 1, b: 2 } d.keep_unless { |key, value| value.one? } d

d = { a: 1, b: 2 } d.keep_unless { |key, value, dictionary| dictionary.many? } d

d = { a: 1, b: 2 } d.keep_unless { |key, value, index, dictionary| dictionary.many? } d
key

examples

{ a: 1, b: 2 }.key(1)

{ a: 1, b: 2 }.key(3)

{ a: 1, b: 2 }.key(3) { |key| key + 1 }

{ a: 1, b: 2 }.key(3) { |key, dictionary| dictionary.key(1) }
keys

examples

{ a: 1, b: 2 }.keys
merge

examples

{ a: 1, b: 2 }.merge(b: 3, c: 4)

{ a: 1, b: 2 }.merge({ b: 3, c: 4 })
merge!

examples

d = { a: 1, b: 2 } d.merge(b: 3, c: 4) d

d = { a: 1, b: 2 } d.merge({ b: 3, c: 4 }) d
nine?

examples

{ a: 9 }.nine?

{ a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, f: 8, h: 9 }.nine?
one?

examples

{ a: 2 }.one?

{ a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, f: 8, h: 9 }.one?
select

examples

{ a: 1, b: 2 }.select { |key| key == :a }

{ a: 1, b: 2 }.select { |key, value| value.one? }

{ a: 1, b: 2 }.select { |key, value, index| index.zero? }

{ a: 1, b: 2 }.select { |key, value, index, dictionary| dictionary.many? }
select!

examples

d = { a: 1, b: 2 } d.select! { |key| key == :a } d

d = { a: 1, b: 2 } d.select! { |key, value| value.one? } d

d = { a: 1, b: 2 } d.select! { |key, value, index| index.zero? } d

d = { a: 1, b: 2 } d.select! { |key, value, index, dictionary| dictionary.many? } d
seven?

examples

{ a: 7 }.seven?

{ a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7 }.seven?
six?

examples

{ a: 5 }.six?

{ a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }.six?
size

examples

{}.size

{ a: 1 }.size

{ a: nothing, b: 2 }.size
superior

examples

{ a: 1 }.superior({ a: 1, b: 2 })

{ a: 1 }.superior(a: 1, b: 2)
superior_or_equal

examples

{ a: 1 }.superior_or_equal({ a: 1, b: 2 })

{ a: 1 }.superior_or_equal(a: 1, b: 2)
ten?

examples

{ a: 10 }.ten?

{ a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, f: 8, h: 9, i: 10 }.ten?
three?

examples

{ a: 3 }.three?

{ a: 1, b: 2, c: 3 }.three?
to_query

examples

{ a: 1, b: 2 }.to_query
transform_values

examples

{ a: 1, b: 2 }.transform_values { |key| key.upcase }

{ a: 1, b: 2 }.transform_values { |key, value| value + 1 }

{ a: 1, b: 2 }.transform_values { |key, value, index| index * 2 }

{ a: 1, b: 2 }.transform_values { |key, value, index, dictionary| dictionary.a }
two?

examples

{ a: 2 }.two?

{ a: 1, b: 2 }.two?
values

examples

{ a: 1, b: 2 }.values
zero?

examples

{ a: 0 }.zero?

{}.zero?