Ruby: как преобразовать строку в логическое значение

У меня есть значение, которое будет одним из четырех: логическое истина, логическое ложь, строка «истина» или строка «ложь». Я хочу преобразовать строку в логическое значение, если это строка, в противном случае оставьте ее неизменной. Другими словами:

"правда" должно стать правдой

"ложь" должна стать ложной

правда должна оставаться верной

ложь должна оставаться ложной

def true?(obj)
  obj.to_s.downcase == "true"
end

Если вы используете Rails 5, вы можете это сделать ActiveModel::Type::Boolean.new.cast(value).

В Rails 4.2 используйте ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

Поведение немного отличается, так как в Rails 4.2 проверяются истинное значение и ложное значение. В Rails 5 проверяются только ложные значения - если значения не равны нулю или не совпадают с ложным значением, оно считается истинным. Ложные значения одинаковы в обеих версиях: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

Источник Rails 5: https://github.com/rails/rails/blob/5-1-stable/activemodel/lib/active_model/type/boolean.rb

Я часто использовал этот шаблон, чтобы расширить базовое поведение Ruby, чтобы упростить преобразование произвольных типов данных в логические значения, что упрощает работу с различными параметрами URL и т. Д.

class String
  def to_boolean
    ActiveRecord::Type::Boolean.new.cast(self)
  end
end

class NilClass
  def to_boolean
    false
  end
end

class TrueClass
  def to_boolean
    true
  end

  def to_i
    1
  end
end

class FalseClass
  def to_boolean
    false
  end

  def to_i
    0
  end
end

class Integer
  def to_boolean
    to_s.to_boolean
  end
end

Допустим, у вас есть параметр, fooкоторый может быть:

• целое число (0 - ложь, все остальные - истина)
• истинное логическое значение (истина / ложь)
• строка («истина», «ложь», «0», «1», «ИСТИНА», «ЛОЖЬ»)
• ноль

Вместо того, чтобы использовать кучу условных операторов, вы можете просто позвонить, foo.to_booleanи все остальное волшебство сделает за вас.

В Rails я добавляю это в инициализатор, названный core_ext.rbпочти во всех моих проектах, поскольку этот шаблон очень распространен.

## EXAMPLES

nil.to_boolean     == false
true.to_boolean    == true
false.to_boolean   == false
0.to_boolean       == false
1.to_boolean       == true
99.to_boolean      == true
"true".to_boolean  == true
"foo".to_boolean   == true
"false".to_boolean == false
"TRUE".to_boolean  == true
"FALSE".to_boolean == false
"0".to_boolean     == false
"1".to_boolean     == true
true.to_i          == 1
false.to_i         == 0

Не думай слишком много:

bool_or_string.to_s == "true"  

Так,

"true".to_s == "true"   #true
"false".to_s == "true"  #false 
true.to_s == "true"     #true
false.to_s == "true"    #false

Вы также можете добавить «.downcase», если вас беспокоят заглавные буквы.

if value.to_s == 'true'
  true
elsif value.to_s == 'false'
  false
end

h = { "true"=>true, true=>true, "false"=>false, false=>false }

["true", true, "false", false].map { |e| h[e] }
  #=> [true, true, false, false] 

В приложении rails 5.1 я использую это расширение ядра, созданное поверх ActiveRecord::Type::Boolean . У меня он отлично работает, когда я десериализую логическое значение из строки JSON.

https://api.rubyonrails.org/classes/ActiveModel/Type/Boolean.html

# app/lib/core_extensions/string.rb
module CoreExtensions
  module String
    def to_bool
      ActiveRecord::Type::Boolean.new.deserialize(downcase.strip)
    end
  end
end

инициализировать основные расширения

# config/initializers/core_extensions.rb
String.include CoreExtensions::String

rspec

# spec/lib/core_extensions/string_spec.rb
describe CoreExtensions::String do
  describe "#to_bool" do
    %w[0 f F false FALSE False off OFF Off].each do |falsey_string|
      it "converts #{falsey_string} to false" do
        expect(falsey_string.to_bool).to eq(false)
      end
    end
  end
end

Работа в Rails 5

ActiveModel::Type::Boolean.new.cast('t')     # => true
ActiveModel::Type::Boolean.new.cast('true')  # => true
ActiveModel::Type::Boolean.new.cast(true)    # => true
ActiveModel::Type::Boolean.new.cast('1')     # => true
ActiveModel::Type::Boolean.new.cast('f')     # => false
ActiveModel::Type::Boolean.new.cast('0')     # => false
ActiveModel::Type::Boolean.new.cast('false') # => false
ActiveModel::Type::Boolean.new.cast(false)   # => false
ActiveModel::Type::Boolean.new.cast(nil)     # => nil

В Rails я предпочитаю использовать ActiveModel::Type::Boolean.new.cast(value) как упоминалось в других ответах здесь

Но когда я пишу простой Ruby lib. затем я использую хак, где JSON.parse(стандартная библиотека Ruby) преобразует строку "true" в trueи "false" в false. Например:

require 'json'
azure_cli_response = `az group exists --name derrentest`  # => "true\n"
JSON.parse(azure_cli_response) # => true

azure_cli_response = `az group exists --name derrentesttt`  # => "false\n"
JSON.parse(azure_cli_response) # => false

Пример из живого приложения:

require 'json'
if JSON.parse(`az group exists --name derrentest`)
  `az group create --name derrentest --location uksouth`
end

подтверждено в Ruby 2.5.1

У меня есть небольшая хитрость для этого. JSON.parse('false')вернется falseи JSON.parse('true')вернет истину. Но это не работает JSON.parse(true || false). Итак, если вы используете что-то подобное, вы JSON.parse(your_value.to_s)должны достичь своей цели простым, но хитрым способом.

Жемчужина вроде https://rubygems.org/gems/to_bool , но его можно легко записать в одну строку с использованием регулярного выражения или тройного выражения.

пример регулярного выражения:

boolean = (var.to_s =~ /^true$/i) == 0

троичный пример:

boolean = var.to_s.eql?('true') ? true : false

Преимущество метода регулярных выражений заключается в том, что регулярные выражения гибкие и могут соответствовать большому количеству шаблонов. Например, если вы подозреваете, что var может быть любым из «True», «False», 'T', 'F', 't' или 'f', вы можете изменить регулярное выражение:

boolean = (var.to_s =~ /^[Tt].*$/i) == 0

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

value = [true, 'true'].include?(value)

или если другие значения могут считаться правдивыми:

value = [1, true, '1', 'true'].include?(value)

вам придется делать другие вещи, если ваш оригинал valueможет быть смешанным:

value = value.to_s.downcase == 'true'

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

В рельсах я раньше делал что-то вроде этого:

class ApplicationController < ActionController::Base
  # ...

  private def bool_from(value)
    !!ActiveRecord::Type::Boolean.new.type_cast_from_database(value)
  end
  helper_method :bool_from

  # ...
end

Что хорошо, если вы пытаетесь сопоставить свои логические сравнения строк так же, как rails для вашей базы данных.

Близко к тому, что уже опубликовано, но без избыточного параметра:

class String
    def true?
        self.to_s.downcase == "true"
    end
end

использование:

do_stuff = "true"

if do_stuff.true?
    #do stuff
end