Ruby: Como converter uma string em booleano

Eu tenho um valor que será uma de quatro coisas: boolean true, boolean false, a string "true" ou a string "false". Desejo converter a string em booleano se for uma string, caso contrário, não a modificarei. Em outras palavras:

"verdadeiro" deve se tornar verdadeiro

"falso" deve se tornar falso

verdadeiro deve permanecer verdadeiro

falso deveria permanecer falso

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

Se você usa Rails 5, você pode fazer ActiveModel::Type::Boolean.new.cast(value).

No Rails 4.2, use ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

O comportamento é um pouco diferente, como no Rails 4.2, o valor verdadeiro e falso são verificados. No Rails 5, apenas valores falsos são verificados - a menos que os valores sejam nulos ou correspondam a um valor falso, ele é considerado verdadeiro. Os valores falsos são iguais nas duas versões: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

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

Eu frequentemente usei esse padrão para estender o comportamento central do Ruby para tornar mais fácil lidar com a conversão de tipos de dados arbitrários em valores booleanos, o que torna realmente fácil lidar com parâmetros variáveis ​​de URL, 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

Então, digamos que você tenha um parâmetro fooque pode ser:

• um inteiro (0 é falso, todos os outros são verdadeiros)
• um verdadeiro booleano (verdadeiro / falso)
• uma string ("verdadeiro", "falso", "0", "1", "VERDADEIRO", "FALSO")
• nada

Em vez de usar um monte de condicionais, você pode apenas chamar foo.to_booleane ele fará o resto da mágica para você.

No Rails, eu adiciono isso a um inicializador chamado core_ext.rbem quase todos os meus projetos, já que esse padrão é muito comum.

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

Não pense muito:

bool_or_string.to_s == "true"  

Assim,

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

Você também pode adicionar ".downcase", se estiver preocupado com letras maiú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] 

Em um aplicativo Rails 5.1, eu uso esta extensão principal construída sobre ele ActiveRecord::Type::Boolean. Está funcionando perfeitamente para mim quando eu desserializo booleano da string 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 extensões principais

# 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

Em Rails eu prefiro usar ActiveModel::Type::Boolean.new.cast(value)como mencionado em outras respostas aqui

Mas quando escrevo Ruby lib simples. então eu uso um hack onde JSON.parse(biblioteca Ruby padrão) irá converter string "true" para truee "false" para false. Por exemplo:

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

Exemplo de aplicativo ao vivo:

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

confirmado em Ruby 2.5.1

Trabalhando no 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

Eu tenho um pequeno hack para este. JSON.parse('false')retornará falsee JSON.parse('true')retornará verdadeiro. Mas isso não funciona com JSON.parse(true || false). Portanto, se você usar algo parecido JSON.parse(your_value.to_s), deverá atingir seu objetivo de uma forma simples, mas "hacky".

Uma gema como https://rubygems.org/gems/to_bool pode ser usada, mas pode ser facilmente escrita em uma linha usando um regex ou ternário.

exemplo regex:

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

exemplo ternário:

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

A vantagem do método regex é que as expressões regulares são flexíveis e podem corresponder a uma ampla variedade de padrões. Por exemplo, se você suspeitar que var pode ser "Verdadeiro", "Falso", 'T', 'F', 't' ou 'f', poderá modificar o regex:

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

Embora eu goste da abordagem de hash (já usei no passado para coisas semelhantes), dado que você realmente só se preocupa em combinar valores verdadeiros - já que - tudo o mais é falso - você pode verificar a inclusão em uma matriz:

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

ou se outros valores podem ser considerados verdadeiros:

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

você teria que fazer outras coisas se o original valuefosse maiúsculo:

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

mas, novamente, para sua descrição específica de seu problema, você poderia usar esse último exemplo como sua solução.

Em trilhos, já fiz algo assim:

class ApplicationController < ActionController::Base
  # ...

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

  # ...
end

O que é bom se você está tentando combinar suas comparações de strings booleanas da mesma maneira que o rails faria para seu banco de dados.

Perto do que já foi postado, mas sem o 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