Dictionary < Object

code register log in programs messages download about privacy terms french production

home / documentation / Dictionary

examples

dictionary not operator evaluation

input

!{}

result

false

dictionary new

input

Dictionary.new

result

{}

dictionary new access a

input

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

result

dictionary access b

input

{ a: 1, b: 2 }.b

result

dictionary empty

input

{}

result

{}

dictionary equality comparison

input

{} == {}

result

true

dictionary to list

input

{}.to_list

result

[]

instance functions

<

examples

object comparison true

input

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

result

true
<=

examples

object comparison

input

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

result

true
<=>

examples

two way comparison object subset with additional keys returns zero

input

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

result

0
>

examples

greater than objects comparison

input

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

result

false
>=

examples

greater than or equal comparison

input

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

result

false
[]

examples

ruby hash access

input

{ a: 1 }[:a]

result

1
any?

examples

any method hash

input

{ a: 1 }.any?

result

true
at

examples

hash access with at method

input

{ a: 1 }.at(:a)

result

1
clear

examples

dictionary clear method

input

d = { a: 1 } d.clear d

result

{}
compact

examples

hash compact result

input

{ a: nothing, b: 2 }.compact

result

{"b" => 2}
compact!

examples

compact

input

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

result

{"b" => 2}
compare

examples

compare objects error

input

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

result

0

compare objects formatting error

input

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

result

0
delete

examples

hash key delete

input

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

result

{"b" => 2}
delete_if

examples

delete if

input

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

result

{"b" => 2}

delete if key equals a

input

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

result

{"b" => 2}

delete if invalid argument

input

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

result

{}

delete if index zero

input

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

result

{"b" => 2}

delete if index dictionary many

input

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

result

{"b" => 2}
delete_unless

examples

delete unless one

input

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

result

{"a" => 1}

delete unless key a

input

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

result

{"a" => 1}

delete unless integer

input

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

result

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

delete unless index zero

input

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

result

{"a" => 1}

delete unless many

input

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

result

{"a" => 1, "b" => 2}
dig

examples

dig operation

input

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

result

3

array element retrieval

input

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

result

3
each

examples

each

input

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

output

a b

result

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

each with value output

input

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

output

1 2

result

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

each with index

input

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

output

0 1

result

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

each dictionary output

input

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

output

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

result

{"a" => 1, "b" => 2}
eight?

examples

dictionary eight query

input

{ a: 1 }.eight?

result

false

dictionary eight query

input

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

result

false
empty?

examples

empty question

input

{}.empty?

result

true

empty question example

input

{ a: 1 }.empty?

result

false
except

examples

hash except

input

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

result

{"b" => 2}
fetch

examples

hash fetch method example

input

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

result

1

hash fetch with default

input

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

result

3
fetch_values

examples

hash fetch values

input

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

result

[1, 2]
filter

examples

hash key comparison

input

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

result

{"a" => 1}

hash filter by value one

input

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

result

{"a" => 1}

hash filter by index zero

input

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

result

{"a" => 1}

hash filter by dictionary many

input

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

result

{"a" => 1, "b" => 2}
filter!

examples

hash filter a key

input

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

result

{"a" => 1}

hash filter value one

input

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

result

{"a" => 1}

filter hash by index zero

input

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

result

{"a" => 1}

filter hash by many

input

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

result

{"a" => 1, "b" => 2}
five?

examples

evaluate length check

input

{ a: 1 }.five?

result

false

evaluate five method on hash

input

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

result

true
flatten

examples

single level hash flattening with one key value pair

input

{ a: 1 }.flatten

result

["a", 1]

nested hash flattening with default level

input

{ a: { b: 2 } }.flatten

result

["a", {"b" => 2}]

nested hash flatten one level

input

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

result

["a", {"b" => 2}]

nested hash two level flattening

input

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

result

["a", {"b" => {"c" => 3}}]
four?

examples

check hash size

input

{ a: 1 }.four?

result

false

hash four check

input

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

result

true
get

examples

hash get symbol

input

{ a: 1 }.get(:a)

result

1
has_key?

examples

hash has key a

input

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

result

true

hash has key b

input

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

result

false
has_value?

examples

hash value lookup

input

{ a: 1 }.has_value?(1)

result

true

hash value lookup

input

{ a: 1 }.has_value?(2)

result

false
inferior

examples

inferior object comparison

input

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

result

true

inferior object comparison

input

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

result

true
inferior_or_equal

examples

map objects comparison

input

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

result

true

map objects comparison

input

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

result

true
invert

examples

single key value inversion

input

{ a: 1 }.invert

result

{1 => "a"}

hash keys and values invert

input

{ a: 1, b: 2 }.invert

result

{1 => "a", 2 => "b"}
keep_if

examples

keep integer keys

input

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

result

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

keep if key equals a

input

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

result

{"a" => 1}

keep if value one

input

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

result

{"a" => 1}

index zero filter

input

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

result

{"a" => 1}

dictionary many check

input

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

result

{"a" => 1, "b" => 2}
keep_unless

examples

d keep unless integer empty

input

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

result

{}

d keep unless key equals a

input

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

result

{"b" => 2}

d keep unless value 1

input

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

result

{"b" => 2}

d keep unless many keeps all

input

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

result

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

d keep unless many with index

input

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

result

{"b" => 2}
key

examples

ruby hash key method

input

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

result

"a"

ruby hash missing key

input

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

result

nothing

ruby hash block key lookup

input

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

result

4

ruby hash key with block

input

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

result

"a"
keys

examples

object keys extraction

input

{ a: 1, b: 2 }.keys

result

["a", "b"]
merge

examples

merge hash

input

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

result

{"a" => 1, "b" => 3, "c" => 4}

merge hashes

input

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

result

{"a" => 1, "b" => 3, "c" => 4}
merge!

examples

merge operation with hash

input

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

result

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

merged_hash_original

input

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

result

{"a" => 1, "b" => 2}
nine?

examples

hash nine method

input

{ a: 9 }.nine?

result

false

hash nine query

input

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

result

false
one?

examples

one query single pair

input

{ a: 2 }.one?

result

true

one query multiple pairs

input

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

result

false
select

examples

select method single key

input

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

result

{"a" => 1}

filter_hash_by_value

input

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

result

{"a" => 1}

syntax error in block

input

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

result

{"a" => 1}

too_many_block_args

input

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

result

{"a" => 1, "b" => 2}
select!

examples

select with key

input

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

result

{"a" => 1}

select with value one

input

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

result

{"a" => 1}

index zero select

input

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

result

{"a" => 1}

select with dictionary many

input

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

result

{"a" => 1, "b" => 2}
seven?

examples

single property value check

input

{ a: 7 }.seven?

result

false

multiple properties size check

input

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

result

true
six?

examples

single key

input

{ a: 5 }.six?

result

false

hash six keys

input

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

result

true
size

examples

empty dictionary size zero

input

{}.size

result

0

dictionary size one

input

{ a: 1 }.size

result

1

dictionary size two

input

{ a: nothing, b: 2 }.size

result

2
superior

examples

object method comparison

input

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

result

false

object superior comparison error

input

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

result

false
superior_or_equal

examples

superior or equal

input

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

result

false

superior or equal

input

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

result

false
ten?

examples

map has ten method

input

{ a: 10 }.ten?

result

false

map has ten method

input

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

result

false
three?

examples

evaluate hash three question operator

input

{ a: 3 }.three?

result

false

hash three question operator

input

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

result

true
to_query

examples

hash to query

input

{ a: 1, b: 2 }.to_query

result

"a=1&b=2"
transform_values

examples

ruby hash transformation

input

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

result

{"a" => "A", "b" => "B"}

ruby hash transform values

input

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

result

{"a" => 2, "b" => 3}

ruby hash index error

input

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

result

{"a" => 0, "b" => 2}

dictionary access error

input

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

result

{"a" => 1, "b" => 1}
two?

examples

evaluate hash with two keys

input

{ a: 2 }.two?

result

false

evaluate hash with two keys

input

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

result

true
values

examples

object values retrieval

input

{ a: 1, b: 2 }.values

result

[1, 2]
zero?

examples

hash zero method

input

{ a: 0 }.zero?

result

false

empty hash zero

input

{}.zero?

result

true
many?

examples

empty hash example

input

{}.many?

result

false

hash many query

input

{ a: 1 }.many?

result

false

hash many query

input

{ a: 1, b: 2 }.many?

result

true

hash many query

input

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

result

true
positive?

examples

.positive check on empty hash

input

{}.positive?

result

false

.positive check with one key value pair

input

{ a: 1 }.positive?

result

true

positive check with two key value pairs

input

{ a: 1, b: 2 }.positive?

result

true

positive check three key value pairs

input

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

result

true
negative?

examples

empty hash negative check

input

{}.negative?

result

false

hash negative method

input

{ a: 1 }.negative?

result

false

hash negative method

input

{ a: 1, b: 2 }.negative?

result

false

hash negative method

input

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

result

false
zero?

examples

hash zero question mark empty

input

{}.zero?

result

true

hash zero question mark one

input

{ a: 1 }.zero?

result

false

hash zero question mark two

input

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

result

false

hash zero question mark three

input

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

result

false
one?

examples

empty hash returns false

input

{}.one?

result

false

hash one key

input

{ a: 1 }.one?

result

true

hash two keys

input

{ a: 1, b: 2 }.one?

result

false

hash three keys

input

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

result

false
two?

examples

empty dictionary has no key named two

input

{}.two?

result

false

single_key_no_match

input

{ a: 1 }.two?

result

false

key b exists

input

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

result

true

three_keys_no_match

input

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

result

false
three?

examples

empty hash checks

input

{}.three?

result

false

hash method three

input

{ a: 1 }.three?

result

false

hash method three

input

{ a: 1, b: 2 }.three?

result

false

hash method three

input

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

result

true
four?

examples

empty hash four false

input

{}.four?

result

false

hash four false

input

{ a: 1 }.four?

result

false

hash four false

input

{ a: 1, b: 2 }.four?

result

false

hash_four_false

input

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

result

false
five?

examples

empty object

input

{}.five?

result

false

five question mark

input

{ a: 1 }.five?

result

false

object has five fields

input

{ a: 1, b: 2 }.five?

result

false

three fields

input

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

result

false
six?

examples

hash six predicate

input

{}.six?

result

false

hash six predicate

input

{ a: 1 }.six?

result

false

hash six predicate

input

{ a: 1, b: 2 }.six?

result

false

hash six predicate

input

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

result

false
seven?

examples

empty hash not seven

input

{}.seven?

result

false

hash seven question mark

input

{ a: 1 }.seven?

result

false

hash two seven

input

{ a: 1, b: 2 }.seven?

result

false

hash three seven

input

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

result

false
eight?

examples

empty object eight query

input

{}.eight?

result

false

empty object query

input

{ a: 1 }.eight?

result

false

object_has_eight_elements_query

input

{ a: 1, b: 2 }.eight?

result

false

object three elements eight query

input

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

result

false
nine?

examples

hash nine method

input

{}.nine?

result

false

hash nine method

input

{ a: 1 }.nine?

result

false

hash nine method

input

{ a: 1, b: 2 }.nine?

result

false

hash nine method

input

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

result

false
ten?

examples

object method call with ten question mark

input

{}.ten?

result

false

object method call with ten question mark

input

{ a: 1 }.ten?

result

false

object method call with ten question mark

input

{ a: 1, b: 2 }.ten?

result

false

object method call with ten question mark

input

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

result

false
eleven?

examples

check eleven presence

input

{}.eleven?

result

false

check eleven presence

input

{ a: 1 }.eleven?

result

false

check_key_eleven

input

{ a: 1, b: 2 }.eleven?

result

false

check key eleven

input

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

result

false
twelve?

examples

empty object method check

input

{}.twelve?

result

false

method check object

input

{ a: 1 }.twelve?

result

false

method check object

input

{ a: 1, b: 2 }.twelve?

result

false

method check object

input

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

result

false
thirteen?

examples

empty object test

input

{}.thirteen?

result

false

one property test

input

{ a: 1 }.thirteen?

result

false

two properties test

input

{ a: 1, b: 2 }.thirteen?

result

false

three properties test

input

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

result

false
fourteen?

examples

empty_object_invalid_method_call

input

{}.fourteen?

result

false

method call invalid

input

{ a: 1 }.fourteen?

result

false

method call invalid

input

{ a: 1, b: 2 }.fourteen?

result

false

method call invalid

input

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

result

false
fifteen?

examples

fifteen query false

input

{}.fifteen?

result

false

check fifteen method

input

{ a: 1 }.fifteen?

result

false

two elements false

input

{ a: 1, b: 2 }.fifteen?

result

false

three elements false

input

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

result

false
sixteen?

examples

empty hash sixteen check

input

{}.sixteen?

result

false

single key false

input

{ a: 1 }.sixteen?

result

false

two keys false

input

{ a: 1, b: 2 }.sixteen?

result

false

three keys false

input

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

result

false
seventeen?

examples

empty object result false

input

{}.seventeen?

result

false

object contains seventeen

input

{ a: 1 }.seventeen?

result

false

object contains seventeen

input

{ a: 1, b: 2 }.seventeen?

result

false

object contains seventeen

input

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

result

false
eighteen?

examples

eighteen method test

input

{}.eighteen?

result

false

eighteen method example

input

{ a: 1 }.eighteen?

result

false

eighteen method example

input

{ a: 1, b: 2 }.eighteen?

result

false

eighteen method test

input

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

result

false
nineteen?

examples

object method check

input

{}.nineteen?

result

false

object method check

input

{ a: 1 }.nineteen?

result

false

object method check

input

{ a: 1, b: 2 }.nineteen?

result

false

object method check

input

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

result

false
twenty?

examples

empty object

input

{}.twenty?

result

false

one property false

input

{ a: 1 }.twenty?

result

false

two properties false

input

{ a: 1, b: 2 }.twenty?

result

false

three properties false

input

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

result

false
twenty_one?

examples

twenty one error false

input

{}.twenty_one?

result

false

twenty one method error false

input

{ a: 1 }.twenty_one?

result

false

twenty one method error false

input

{ a: 1, b: 2 }.twenty_one?

result

false

twenty one method error false

input

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

result

false
twenty_two?

examples

dot twenty two query

input

{}.twenty_two?

result

false

dot twenty two query

input

{ a: 1 }.twenty_two?

result

false

dot twenty two query

input

{ a: 1, b: 2 }.twenty_two?

result

false

dot twenty two query

input

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

result

false
twenty_three?

examples

check if empty hash key is twenty three

input

{}.twenty_three?

result

false

hash key check

input

{ a: 1 }.twenty_three?

result

false

hash key check

input

{ a: 1, b: 2 }.twenty_three?

result

false

hash key check

input

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

result

false
twenty_four?

examples

check if hash has twenty four keys

input

{}.twenty_four?

result

false

check if hash has twenty four keys

input

{ a: 1 }.twenty_four?

result

false

hash has twenty four keys

input

{ a: 1, b: 2 }.twenty_four?

result

false

hash has twenty four keys

input

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

result

false
twenty_five?

examples

empty hash twenty five

input

{}.twenty_five?

result

false

empty hash twenty five

input

{ a: 1 }.twenty_five?

result

false

hash twenty five

input

{ a: 1, b: 2 }.twenty_five?

result

false

check size with twenty five

input

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

result

false
twenty_six?

examples

false_twenty_six_check

input

{}.twenty_six?

result

false

single element hash

input

{ a: 1 }.twenty_six?

result

false

hash has fewer elements than twenty six

input

{ a: 1, b: 2 }.twenty_six?

result

false

hash with less than twenty six elements

input

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

result

false
twenty_seven?

examples

empty hash check returns false

input

{}.twenty_seven?

result

false

single key-pair hash check false

input

{ a: 1 }.twenty_seven?

result

false

hash check for twenty seven method

input

{ a: 1, b: 2 }.twenty_seven?

result

false

hash check twenty seven

input

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

result

false
twenty_eight?

examples

check object key count

input

{}.twenty_eight?

result

false

object key count check

input

{ a: 1 }.twenty_eight?

result

false

object key count check

input

{ a: 1, b: 2 }.twenty_eight?

result

false

object key count check

input

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

result

false
twenty_nine?

examples

check key existence

input

{}.twenty_nine?

result

false

check key existence

input

{ a: 1 }.twenty_nine?

result

false

check key existence

input

{ a: 1, b: 2 }.twenty_nine?

result

false

check key existence

input

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

result

false
thirty?

examples

is thirty key present

input

{}.thirty?

result

false

is thirty key present

input

{ a: 1 }.thirty?

result

false

is thirty key present

input

{ a: 1, b: 2 }.thirty?

result

false

check thirty key presence

input

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

result

false
thirty_one?

examples

empty hash thirty one

input

{}.thirty_one?

result

false

single key hash

input

{ a: 1 }.thirty_one?

result

false

two key hash

input

{ a: 1, b: 2 }.thirty_one?

result

false

three key hash

input

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

result

false
thirty_two?

examples

empty dictionary thirty two question mark

input

{}.thirty_two?

result

false

single key dictionary

input

{ a: 1 }.thirty_two?

result

false

two key dictionary

input

{ a: 1, b: 2 }.thirty_two?

result

false

three key dictionary

input

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

result

false
thirty_three?

examples

empty object method check

input

{}.thirty_three?

result

false

method check

input

{ a: 1 }.thirty_three?

result

false

method check

input

{ a: 1, b: 2 }.thirty_three?

result

false

method check with multiple keys

input

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

result

false
thirty_four?

examples

thirty four

input

{}.thirty_four?

result

false

thirty four question mark

input

{ a: 1 }.thirty_four?

result

false

thirty four question mark

input

{ a: 1, b: 2 }.thirty_four?

result

false

thirty four question mark

input

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

result

false
thirty_five?

examples

empty hash evaluates to false

input

{}.thirty_five?

result

false

single key hash evaluates false

input

{ a: 1 }.thirty_five?

result

false

two key hash

input

{ a: 1, b: 2 }.thirty_five?

result

false

three key hash evaluates false

input

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

result

false
thirty_six?

examples

empty object thirty six check

input

{}.thirty_six?

result

false

hash thirty six check

input

{ a: 1 }.thirty_six?

result

false

hash thirty six check

input

{ a: 1, b: 2 }.thirty_six?

result

false

hash thirty six check

input

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

result

false
thirty_seven?

examples

empty object method check

input

{}.thirty_seven?

result

false

object method check

input

{ a: 1 }.thirty_seven?

result

false

object method check

input

{ a: 1, b: 2 }.thirty_seven?

result

false

object method check

input

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

result

false
thirty_eight?

examples

empty object method call returns false

input

{}.thirty_eight?

result

false

object method call

input

{ a: 1 }.thirty_eight?

result

false

two element object method call

input

{ a: 1, b: 2 }.thirty_eight?

result

false

three element object method call

input

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

result

false
thirty_nine?

examples

thirty nine check

input

{}.thirty_nine?

result

false

thirty nine check

input

{ a: 1 }.thirty_nine?

result

false

thirty nine check

input

{ a: 1, b: 2 }.thirty_nine?

result

false

thirty nine check

input

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

result

false
forty?

examples

forty query result false

input

{}.forty?

result

false

forty query result false

input

{ a: 1 }.forty?

result

false

forty query result false

input

{ a: 1, b: 2 }.forty?

result

false

forty query result false

input

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

result

false
forty_one?

examples

empty hash forty one method

input

{}.forty_one?

result

false

single_key_value_pair_false

input

{ a: 1 }.forty_one?

result

false

hash forty one question test

input

{ a: 1, b: 2 }.forty_one?

result

false

hash forty one question test

input

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

result

false
forty_two?

examples

empty dictionary check

input

{}.forty_two?

result

false

dictionary check not forty two

input

{ a: 1 }.forty_two?

result

false

dictionary check

input

{ a: 1, b: 2 }.forty_two?

result

false

dictionary check with three keys

input

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

result

false
forty_three?

examples

empty hash false

input

{}.forty_three?

result

false

single_key_false

input

{ a: 1 }.forty_three?

result

false

forty three boolean check

input

{ a: 1, b: 2 }.forty_three?

result

false

three_keys_false

input

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

result

false
forty_four?

examples

forty four question mark empty hash false

input

{}.forty_four?

result

false

forty four question mark

input

{ a: 1 }.forty_four?

result

false

forty four question mark

input

{ a: 1, b: 2 }.forty_four?

result

false

forty four question mark

input

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

result

false
forty_five?

examples

false result for empty hash using forty five method

input

{}.forty_five?

result

false

single_key_in_hash_returns_false

input

{ a: 1 }.forty_five?

result

false

two keys in hash returns false

input

{ a: 1, b: 2 }.forty_five?

result

false

three keys in hash returns false

input

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

result

false
forty_six?

examples

empty hash forty six method false

input

{}.forty_six?

result

false

hash forty six false

input

{ a: 1 }.forty_six?

result

false

hash forty six method false

input

{ a: 1, b: 2 }.forty_six?

result

false

hash forty six method false

input

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

result

false
forty_seven?

examples

empty dictionary check

input

{}.forty_seven?

result

false

dictionary single element

input

{ a: 1 }.forty_seven?

result

false

dictionary two elements

input

{ a: 1, b: 2 }.forty_seven?

result

false

dictionary three elements

input

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

result

false
forty_eight?

examples

false for empty hash

input

{}.forty_eight?

result

false

hash single key false

input

{ a: 1 }.forty_eight?

result

false

hash with two keys false

input

{ a: 1, b: 2 }.forty_eight?

result

false

hash with three keys false

input

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

result

false
forty_nine?

examples

empty object method call `forty_nine?` returns false

input

{}.forty_nine?

result

false

object method call forty nine returns false

input

{ a: 1 }.forty_nine?

result

false

object method call forty nine returns false

input

{ a: 1, b: 2 }.forty_nine?

result

false

object method call forty nine returns false

input

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

result

false
fifty?

examples

evaluate object fifty method

input

{}.fifty?

result

false

object fifty method

input

{ a: 1 }.fifty?

result

false

object fifty method

input

{ a: 1, b: 2 }.fifty?

result

false

object fifty method

input

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

result

false
fifty_one?

examples

empty hash fifty one query

input

{}.fifty_one?

result

false

hash fifty one query result

input

{ a: 1 }.fifty_one?

result

false

hash fifty one query result

input

{ a: 1, b: 2 }.fifty_one?

result

false

hash fifty one query result

input

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

result

false
fifty_two?

examples

empty hash fifty two

input

{}.fifty_two?

result

false

single key

input

{ a: 1 }.fifty_two?

result

false

two key hash fifty two

input

{ a: 1, b: 2 }.fifty_two?

result

false

three key hash fifty two

input

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

result

false
fifty_three?

examples

empty hash fifty three false

input

{}.fifty_three?

result

false

hash fifty three check

input

{ a: 1 }.fifty_three?

result

false

hash fifty three check

input

{ a: 1, b: 2 }.fifty_three?

result

false

hash fifty three check

input

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

result

false
fifty_four?

examples

object fifty four

input

{}.fifty_four?

result

false

object fifty four

input

{ a: 1 }.fifty_four?

result

false

object fifty four

input

{ a: 1, b: 2 }.fifty_four?

result

false

object fifty four

input

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

result

false
fifty_five?

examples

empty hash fifty five

input

{}.fifty_five?

result

false

sample code output

input

{ a: 1 }.fifty_five?

result

false

hash fifty five check

input

{ a: 1, b: 2 }.fifty_five?

result

false

sample hash fifty five

input

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

result

false
fifty_six?

examples

empty object fifty six question false

input

{}.fifty_six?

result

false

object single element fifty six question false

input

{ a: 1 }.fifty_six?

result

false

object two elements fifty six question false

input

{ a: 1, b: 2 }.fifty_six?

result

false

object three elements fifty six question false

input

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

result

false
fifty_seven?

examples

sixty three check

input

{}.fifty_seven?

result

false

hash method check

input

{ a: 1 }.fifty_seven?

result

false

hash fifty seven check

input

{ a: 1, b: 2 }.fifty_seven?

result

false

hash fifty seven check

input

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

result

false
fifty_eight?

examples

fifty eight check

input

{}.fifty_eight?

result

false

fifty eight check

input

{ a: 1 }.fifty_eight?

result

false

fifty eight check

input

{ a: 1, b: 2 }.fifty_eight?

result

false

fifty eight check

input

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

result

false
fifty_nine?

examples

hash method fifty nine

input

{}.fifty_nine?

result

false

hash method fifty nine

input

{ a: 1 }.fifty_nine?

result

false

hash method fifty nine

input

{ a: 1, b: 2 }.fifty_nine?

result

false

hash method fifty nine

input

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

result

false
sixty?

examples

empty object sixty check

input

{}.sixty?

result

false

one key object sixty check

input

{ a: 1 }.sixty?

result

false

two key object sixty check

input

{ a: 1, b: 2 }.sixty?

result

false

three key object sixty check

input

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

result

false
sixty_one?

examples

empty hash sixty one question mark

input

{}.sixty_one?

result

false

hash one sixty one

input

{ a: 1 }.sixty_one?

result

false

hash two sixty one

input

{ a: 1, b: 2 }.sixty_one?

result

false

hash three sixty one

input

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

result

false
sixty_two?

examples

empty hash sixty two check false

input

{}.sixty_two?

result

false

one key sixty two check

input

{ a: 1 }.sixty_two?

result

false

two key sixty two check

input

{ a: 1, b: 2 }.sixty_two?

result

false

three key sixty two check false

input

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

result

false
sixty_three?

examples

hash sixty three method missing

input

{}.sixty_three?

result

false

hash method sixty three missing

input

{ a: 1 }.sixty_three?

result

false

hash method sixty three missing

input

{ a: 1, b: 2 }.sixty_three?

result

false

hash method sixty three missing

input

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

result

false
sixty_four?

examples

empty hash sixty four check

input

{}.sixty_four?

result

false

one key

input

{ a: 1 }.sixty_four?

result

false

two key

input

{ a: 1, b: 2 }.sixty_four?

result

false

three keys

input

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

result

false
sixty_five?

examples

empty hash check

input

{}.sixty_five?

result

false

one key hash

input

{ a: 1 }.sixty_five?

result

false

hash two keys check

input

{ a: 1, b: 2 }.sixty_five?

result

false

hash three keys check

input

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

result

false
sixty_six?

examples

sixty six check empty false

input

{}.sixty_six?

result

false

check sixty six single element

input

{ a: 1 }.sixty_six?

result

false

check sixty six double element

input

{ a: 1, b: 2 }.sixty_six?

result

false

check sixty six triple element

input

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

result

false
sixty_seven?

examples

hash does not have sixty seven

input

{}.sixty_seven?

result

false

hash does not have sixty seven

input

{ a: 1 }.sixty_seven?

result

false

hash does not have sixty seven

input

{ a: 1, b: 2 }.sixty_seven?

result

false

hash does not have sixty seven

input

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

result

false
sixty_eight?

examples

empty object false

input

{}.sixty_eight?

result

false

one key false

input

{ a: 1 }.sixty_eight?

result

false

two keys false

input

{ a: 1, b: 2 }.sixty_eight?

result

false

three keys false

input

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

result

false
sixty_nine?

examples

sixty nine method check

input

{}.sixty_nine?

result

false

sixty nine check

input

{ a: 1 }.sixty_nine?

result

false

sixty nine check

input

{ a: 1, b: 2 }.sixty_nine?

result

false

sixty nine check

input

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

result

false
seventy?

examples

seventy check false

input

{}.seventy?

result

false

one property seventy check

input

{ a: 1 }.seventy?

result

false

two properties seventy check

input

{ a: 1, b: 2 }.seventy?

result

false

three properties seventy check

input

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

result

false
seventy_one?

examples

empty hash

input

{}.seventy_one?

result

false

hash seventy one query

input

{ a: 1 }.seventy_one?

result

false

hash seventy one query

input

{ a: 1, b: 2 }.seventy_one?

result

false

hash seventy one query

input

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

result

false
seventy_two?

examples

empty hash seventy two query

input

{}.seventy_two?

result

false

single element hash query

input

{ a: 1 }.seventy_two?

result

false

hash seventy two query

input

{ a: 1, b: 2 }.seventy_two?

result

false

hash seventy two query

input

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

result

false
seventy_three?

examples

empty hash seventy three result false

input

{}.seventy_three?

result

false

hash seventy three method example

input

{ a: 1 }.seventy_three?

result

false

hash seventy three

input

{ a: 1, b: 2 }.seventy_three?

result

false

hash seventy three

input

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

result

false
seventy_four?

examples

empty object seventy four false

input

{}.seventy_four?

result

false

empty object seventy four false

input

{ a: 1 }.seventy_four?

result

false

object seventy four check false

input

{ a: 1, b: 2 }.seventy_four?

result

false

object seventy four check false

input

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

result

false
seventy_five?

examples

empty hash

input

{}.seventy_five?

result

false

single key hash seventy five

input

{ a: 1 }.seventy_five?

result

false

two key hash seventy five

input

{ a: 1, b: 2 }.seventy_five?

result

false

three key hash seventy five

input

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

result

false
seventy_six?

examples

empty object seventy six false

input

{}.seventy_six?

result

false

seventy six check

input

{ a: 1 }.seventy_six?

result

false

two keys seventy six check false

input

{ a: 1, b: 2 }.seventy_six?

result

false

three keys seventy six false

input

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

result

false
seventy_seven?

examples

hash empty seventy seven query

input

{}.seventy_seven?

result

false

hash one element seventy seven query

input

{ a: 1 }.seventy_seven?

result

false

hash two elements seventy seven query

input

{ a: 1, b: 2 }.seventy_seven?

result

false

hash three elements seventy seven query

input

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

result

false
seventy_eight?

examples

hash seventy eight check

input

{}.seventy_eight?

result

false

hash seventy eight check

input

{ a: 1 }.seventy_eight?

result

false

hash check

input

{ a: 1, b: 2 }.seventy_eight?

result

false

hash seventy eight

input

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

result

false
seventy_nine?

examples

{}_seventy_nine_false

input

{}.seventy_nine?

result

false

dictionary checking seventy nine

input

{ a: 1 }.seventy_nine?

result

false

dictionary seventy nine false

input

{ a: 1, b: 2 }.seventy_nine?

result

false

dictionary seventy nine false containing three elements

input

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

result

false
eighty?

examples

empty eighty check

input

{}.eighty?

result

false

one property false

input

{ a: 1 }.eighty?

result

false

two properties false

input

{ a: 1, b: 2 }.eighty?

result

false

three properties false

input

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

result

false
eighty_one?

examples

empty hash

input

{}.eighty_one?

result

false

non method hash check

input

{ a: 1 }.eighty_one?

result

false

non method hash check

input

{ a: 1, b: 2 }.eighty_one?

result

false

non method hash check

input

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

result

false
eighty_two?

examples

check if dictionary has eighty two

input

{}.eighty_two?

result

false

eighty two method call

input

{ a: 1 }.eighty_two?

result

false

check eighty two method

input

{ a: 1, b: 2 }.eighty_two?

result

false

check eighty two method

input

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

result

false
eighty_three?

examples

eighty three check

input

{}.eighty_three?

result

false

object eighty three question mark

input

{ a: 1 }.eighty_three?

result

false

object eighty three check

input

{ a: 1, b: 2 }.eighty_three?

result

false

object eighty three check

input

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

result

false
eighty_four?

examples

eighty four check

input

{}.eighty_four?

result

false

eighty four check

input

{ a: 1 }.eighty_four?

result

false

eighty four check

input

{ a: 1, b: 2 }.eighty_four?

result

false

eighty four query

input

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

result

false
eighty_five?

examples

empty hash eighty five check

input

{}.eighty_five?

result

false

one element map

input

{ a: 1 }.eighty_five?

result

false

two element map eighty five check

input

{ a: 1, b: 2 }.eighty_five?

result

false

three element map check

input

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

result

false
eighty_six?

examples

empty object query

input

{}.eighty_six?

result

false

object eighty six check

input

{ a: 1 }.eighty_six?

result

false

object eighty six check with two properties

input

{ a: 1, b: 2 }.eighty_six?

result

false

object eighty six check with three properties

input

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

result

false
eighty_seven?

examples

empty object test

input

{}.eighty_seven?

result

false

eighty seven test with simple object

input

{ a: 1 }.eighty_seven?

result

false

eighty seven object

input

{ a: 1, b: 2 }.eighty_seven?

result

false

check eighty seven with multiple keys object

input

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

result

false
eighty_eight?

examples

empty object with eighty eight method returns false

input

{}.eighty_eight?

result

false

object eighty eight method check

input

{ a: 1 }.eighty_eight?

result

false

object eighty eight method check

input

{ a: 1, b: 2 }.eighty_eight?

result

false

object eighty eight method check

input

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

result

false
eighty_nine?

examples

empty object with eighty nine method

input

{}.eighty_nine?

result

false

object eighty nine method

input

{ a: 1 }.eighty_nine?

result

false

object with eighty nine method

input

{ a: 1, b: 2 }.eighty_nine?

result

false

three props eighty nine

input

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

result

false
ninety?

examples

empty object evaluates to false

input

{}.ninety?

result

false

object ninety question mark

input

{ a: 1 }.ninety?

result

false

object ninety question mark

input

{ a: 1, b: 2 }.ninety?

result

false

object ninety question mark

input

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

result

false
ninety_one?

examples

empty hash ninety one query

input

{}.ninety_one?

result

false

single pair ninety one query

input

{ a: 1 }.ninety_one?

result

false

two pair ninety one query

input

{ a: 1, b: 2 }.ninety_one?

result

false

three pair ninety one query

input

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

result

false
ninety_two?

examples

empty hash ninety two false

input

{}.ninety_two?

result

false

one key ninety two false

input

{ a: 1 }.ninety_two?

result

false

two key ninety two false

input

{ a: 1, b: 2 }.ninety_two?

result

false

three key ninety two false

input

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

result

false
ninety_three?

examples

empty hash ninety three check

input

{}.ninety_three?

result

false

hash ninety three check

input

{ a: 1 }.ninety_three?

result

false

ninety three check

input

{ a: 1, b: 2 }.ninety_three?

result

false

hash with three ninety three check

input

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

result

false
ninety_four?

examples

ninety four question

input

{}.ninety_four?

result

false

one key map

input

{ a: 1 }.ninety_four?

result

false

two key map

input

{ a: 1, b: 2 }.ninety_four?

result

false

three key map

input

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

result

false
ninety_five?

examples

ninety five check

input

{}.ninety_five?

result

false

one item hash ninety five check

input

{ a: 1 }.ninety_five?

result

false

hash ninety five check

input

{ a: 1, b: 2 }.ninety_five?

result

false

hash ninety five check three items

input

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

result

false
ninety_six?

examples

empty object ninety six false

input

{}.ninety_six?

result

false

one element object ninety six false

input

{ a: 1 }.ninety_six?

result

false

two element object ninety six false

input

{ a: 1, b: 2 }.ninety_six?

result

false

three element object ninety six false

input

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

result

false
ninety_seven?

examples

empty object ninety seven

input

{}.ninety_seven?

result

false

object ninety seven question

input

{ a: 1 }.ninety_seven?

result

false

object ninety seven

input

{ a: 1, b: 2 }.ninety_seven?

result

false

object ninty seven

input

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

result

false
ninety_eight?

examples

object ninety eight evaluation

input

{}.ninety_eight?

result

false

object ninety eight evaluation

input

{ a: 1 }.ninety_eight?

result

false

object ninety eight evaluation

input

{ a: 1, b: 2 }.ninety_eight?

result

false

object ninety eight evaluation

input

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

result

false
ninety_nine?

examples

ninety nine evaluation

input

{}.ninety_nine?

result

false

evaluate ninety nine

input

{ a: 1 }.ninety_nine?

result

false

evaluate ninety nine

input

{ a: 1, b: 2 }.ninety_nine?

result

false

evaluate ninety nine

input

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

result

false
one_hundred?

examples

empty hash one hundred test false

input

{}.one_hundred?

result

false

hash one hundred test

input

{ a: 1 }.one_hundred?

result

false

hash one hundred test

input

{ a: 1, b: 2 }.one_hundred?

result

false

hash one hundred test

input

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

result

false