Ruby: Cómo convertir una cadena a booleana

Tengo un valor que será una de cuatro cosas: booleano verdadero, booleano falso, la cadena "verdadero" o la cadena "falso". Quiero convertir la cadena en un booleano si es una cadena; de lo contrario, déjela sin modificar. En otras palabras:

"verdadero" debería convertirse en realidad

"falso" debería convertirse en falso

la verdad debería permanecer verdad

lo falso debe permanecer falso

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

Si usa Rails 5, puede hacerlo ActiveModel::Type::Boolean.new.cast(value).

En Rails 4.2, utilice ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

El comportamiento es ligeramente diferente, como en Rails 4.2, se verifican el valor verdadero y los valores falsos. En Rails 5, solo se verifican los valores falsos; a menos que los valores sean nulos o coincidan con un valor falso, se asume que es verdadero. Los valores falsos son los mismos en ambas versiones: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

Rails 5 Fuente: https://github.com/rails/rails/blob/5-1-stable/activemodel/lib/active_model/type/boolean.rb

Con frecuencia he usado este patrón para extender el comportamiento central de Ruby para facilitar la conversión de tipos de datos arbitrarios en valores booleanos, lo que hace que sea realmente fácil lidiar con parámetros de URL variables, etc.

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

Entonces digamos que tiene un parámetro fooque puede ser:

• un número entero (0 es falso, todos los demás son verdaderos)
• un booleano verdadero (verdadero / falso)
• una cadena ("verdadero", "falso", "0", "1", "VERDADERO", "FALSO")
• nulo

En lugar de usar un montón de condicionales, puedes simplemente llamar foo.to_booleany hará el resto de la magia por ti.

En Rails, agrego esto a un inicializador nombrado core_ext.rben casi todos mis proyectos ya que este patrón es muy común.

## 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

No pienses demasiado:

bool_or_string.to_s == "true"  

Entonces,

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

También puede agregar ".downcase", si le preocupan las letras mayúsculas.

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] 

En una aplicación rails 5.1, utilizo esta extensión central construida sobre ActiveRecord::Type::Boolean. Funciona perfectamente para mí cuando deserializo un booleano de una cadena 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

inicializar extensiones centrales

# 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

En Rails prefiero usar ActiveModel::Type::Boolean.new.cast(value) como se menciona en otras respuestas aquí

Pero cuando escribo Ruby lib. luego uso un truco donde JSON.parse(biblioteca estándar de Ruby) convertirá la cadena "verdadero" en truey "falso" en false. P.ej:

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

Ejemplo de aplicación en vivo:

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

confirmado bajo Ruby 2.5.1

Trabajando en 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

Tengo un pequeño truco para este. JSON.parse('false')volverá falsey JSON.parse('true')volverá verdadero. Pero esto no funciona con JSON.parse(true || false). Entonces, si usa algo así JSON.parse(your_value.to_s), debería lograr su objetivo de una manera simple pero hacky.

Una joya como https://rubygems.org/gems/to_bool puede usar , pero se puede escribir fácilmente en una línea usando una expresión regular o un ternario.

ejemplo de expresiones regulares:

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

ejemplo ternario:

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

La ventaja del método regex es que las expresiones regulares son flexibles y pueden coincidir con una amplia variedad de patrones. Por ejemplo, si sospecha que var podría ser cualquiera de "True", "False", 'T', 'F', 't' o 'f', entonces puede modificar la expresión regular:

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

Aunque me gusta el enfoque hash (lo he usado en el pasado para cosas similares), dado que solo te importa hacer coincidir los valores de verdad, ya que todo lo demás es falso, puedes verificar la inclusión en una matriz:

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

o si otros valores pudieran considerarse veraces:

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

tendrías que hacer otras cosas si tu original valuepudiera ser un caso mixto:

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

pero nuevamente, para su descripción específica de su problema, podría salirse con la suya con ese último ejemplo como solución.

En rieles, anteriormente hice algo como esto:

class ApplicationController < ActionController::Base
  # ...

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

  # ...
end

Lo cual es bueno si está tratando de hacer coincidir sus comparaciones de cadenas booleanas de la misma manera que lo harían los rieles para su base de datos.

Cerca de lo que ya está publicado, pero sin el parámetro redundante:

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

uso:

do_stuff = "true"

if do_stuff.true?
    #do stuff
end