Эквивалент .try () для хэша, чтобы избежать ошибок «неопределенного метода» для nil? [Дубликат]

Объявление Ruby 2.3.0-preview1 включает введение безопасного навигатора.

Безопасный навигационный оператор, который уже существует в С#, Groovy и Swift, предназначен для упрощения обработки nil как obj&.foo. Array#dig и Hash#dig.

Это означает, что в 2.3 ниже кода

account.try(:owner).try(:address)

можно переписать на

account&.owner&.address

Однако следует быть осторожным, что & не является заменой #try. Взгляните на этот пример:

> params = nil
nil
> params&.country
nil
> params = OpenStruct.new(country: "Australia")
#<OpenStruct country="Australia">
> params&.country
"Australia"
> params&.country&.name
NoMethodError: undefined method `name' for "Australia":String
from (pry):38:in `<main>'
> params.try(:country).try(:name)
nil

Он также включает аналогичный путь: Array#dig и Hash#dig. Итак, теперь это

city = params.fetch(:[], :country).try(:[], :state).try(:[], :city)

можно переписать на

city = params.dig(:country, :state, :city)

Опять же, #dig не воспроизводит поведение #try. Поэтому будьте осторожны с возвращаемыми значениями. Если params[:country] возвращает, например, значение Integer, TypeError: Integer does not have #dig method.

Самое прекрасное решение - это старый ответ Младен Ябланович, поскольку он позволяет вам копать в хэш глубже, чем вы могли с помощью прямых вызовов .try() если вы хотите, чтобы код по-прежнему выглядел красиво:

class Hash
  def get_deep(*fields)
    fields.inject(self) {|acc,e| acc[e] if acc}
  end
end

Вы должны быть осторожны с различными объектами (особенно params), потому что строки и массивы также отвечают на: [], но возвращаемое значение может быть не таким, как вы хотите, и Array вызывает исключение для строк или символов, используемых в качестве индексов.

Вот почему в предложенной форме этого метода (см. ниже) вместо (обычно лучше) используется (обычно уродливый) тест для .is_a?(Hash) .respond_to?(:[]):

class Hash
  def get_deep(*fields)
    fields.inject(self) {|acc,e| acc[e] if acc.is_a?(Hash)}
  end
end

a_hash = {:one => {:two => {:three => "asd"}, :arr => [1,2,3]}}

puts a_hash.get_deep(:one, :two               ).inspect # => {:three=>"asd"}
puts a_hash.get_deep(:one, :two, :three       ).inspect # => "asd"
puts a_hash.get_deep(:one, :two, :three, :four).inspect # => nil
puts a_hash.get_deep(:one, :arr            ).inspect    # => [1,2,3]
puts a_hash.get_deep(:one, :arr, :too_deep ).inspect    # => nil

В последнем примере возникло бы исключение: "Символ как индекс массива (TypeError)", если он не был защищен этим уродливым "is_a? (Hash)".

Правильное использование try с хешем @sesion.try(:[], :comments).

@session.try(:[], :comments).try(:[], commend.id).try(:[], 'temp_value')

Обновление: По состоянию на Ruby 2.3 используйте # dig

Большинство объектов, которые отвечают на [], ожидают аргумент Integer, причем Hash является исключением, которое примет любой объект (например, строки или символы).

Ниже приведен немного более надежный вариант ответа Arsen7, который поддерживает вложенные Array, Hash, а также любые другие объекты, которые ожидают, что Integer передан в [].

Это не безупречное доказательство, поскольку кто-то может создать объект, который реализует [] и не принимает аргумент Integer. Однако это решение отлично работает в общем случае, например. вытягивание вложенных значений из JSON (имеющего как Hash, так и Array):

class Hash
  def get_deep(*fields)
    fields.inject(self) { |acc, e| acc[e] if acc.is_a?(Hash) || (e.is_a?(Integer) && acc.respond_to?(:[])) }
  end
end

Его можно использовать так же, как решение Arsen7, но также поддерживает массивы, например.

json = { 'users' => [ { 'name' => { 'first_name' => 'Frank'} }, { 'name' => { 'first_name' => 'Bob' } } ] }

json.get_deep 'users', 1, 'name', 'first_name' # Pulls out 'Bob'

@myvar = session.fetch(:comments, {}).fetch(@comment.id, {})["temp_value"]

Из Ruby 2.0 вы можете сделать:

@myvar = session[:comments].to_h[@comment.id].to_h["temp_value"]

Из Ruby 2.3 вы можете сделать:

@myvar = session.dig(:comments, @comment.id, "temp_value")

скажите, что вы хотите найти params[:user][:email], но не уверены, есть ли user в params или нет. Тогда -

вы можете попробовать:

params[:user].try(:[], :email)

Он вернет либо nil (если user не существует, либо email не существует в user), либо иначе значение email в user.

Другой подход:

@myvar = session[:comments][@comment.id]["temp_value"] rescue nil

Это также может считаться немного опасным, потому что он может скрыть слишком много, лично мне это нравится.

Если вы хотите большего контроля, вы можете рассмотреть что-то вроде:

def handle # just an example name, use what speaks to you
    raise $! unless $!.kind_of? NoMethodError # Do whatever checks or 
                                              # reporting you want
end
# then you may use
@myvar = session[:comments][@comment.id]["temp_value"] rescue handle

По сравнению с Ruby 2.3 это становится немного проще. Вместо того, чтобы вставлять операторы try или определять свой собственный метод, вы можете теперь использовать Hash#dig (документацию).

h = { foo: {bar: {baz: 1}}}

h.dig(:foo, :bar, :baz)           #=> 1
h.dig(:foo, :zot)                 #=> nil

Или в приведенном выше примере:

session.dig(:comments, @comment.id, "temp_value")

Это имеет дополнительное преимущество, чтобы быть более похожим на try, чем некоторые из приведенных выше примеров. Если какой-либо из аргументов приведет к тому, что хеш вернет nil, тогда он ответит nil.

Когда вы это сделаете:

myhash[:one][:two][:three]

Вы просто связываете кучу вызовов с методом "[]", возникает ошибка, если myhash [: one] возвращает nil, потому что nil не имеет метода []. Таким образом, один простой и довольно хакерский способ заключается в добавлении метода [] к Niclass, который возвращает nil: я бы установил это в приложении rails следующим образом:

Добавьте метод:

#in lib/ruby_extensions.rb
class NilClass
  def [](*args)
    nil
  end
end

Требовать файл:

#in config/initializers/app_environment.rb
require 'ruby_extensions'

Теперь вы можете вызывать вложенные хэши без страха: я демонстрирую на консоли здесь:

>> hash = {:foo => "bar"}
=> {:foo=>"bar"}
>> hash[:foo]
=> "bar"
>> hash[:doo]
=> nil
>> hash[:doo][:too]
=> nil

Эндрю ответ не работал у меня, когда я пробовал это снова недавно. Может, что-то изменилось?

@myvar = session[:comments].try('[]', @comment.id)

'[]' находится в кавычках вместо символа :[]

Попробуйте использовать

@myvar = session[:comments][@comment.id]["temp_value"] if session[:comments]