Ruby: come convertire una stringa in booleano

Ho un valore che sarà una delle quattro cose: boolean true, boolean false, la stringa "true" o la stringa "false". Voglio convertire la stringa in un booleano se è una stringa, altrimenti lasciarla non modificata. In altre parole:

"vero" dovrebbe diventare vero

"false" dovrebbe diventare falso

vero dovrebbe rimanere vero

false dovrebbe rimanere false

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

Se usi Rails 5, puoi farlo ActiveModel::Type::Boolean.new.cast(value).

In Rails 4.2, usa ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

Il comportamento è leggermente diverso, poiché in Rails 4.2 vengono controllati il ​​valore vero e quelli falsi. In Rails 5, vengono controllati solo i valori falsi - a meno che i valori non siano nulli o corrispondano a un valore falso, si presume che sia vero. I valori falsi sono gli stessi in entrambe le versioni: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

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

Ho spesso usato questo modello per estendere il comportamento principale di Ruby per rendere più facile gestire la conversione di tipi di dati arbitrari in valori booleani, il che rende davvero facile gestire parametri URL variabili, ecc.

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

Quindi diciamo che hai un parametro fooche può essere:

• un numero intero (0 è falso, tutti gli altri sono veri)
• un vero booleano (vero / falso)
• una stringa ("true", "false", "0", "1", "TRUE", "FALSE")
• zero

Invece di usare un mucchio di condizionali, puoi semplicemente chiamare foo.to_booleane farà il resto della magia per te.

In Rails, lo aggiungo a un inizializzatore denominato core_ext.rbin quasi tutti i miei progetti poiché questo modello è così comune.

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

Non pensare troppo:

bool_or_string.to_s == "true"  

Così,

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

Puoi anche aggiungere ".downcase", se sei preoccupato per le lettere maiuscole.

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] 

In un'app per rails 5.1, utilizzo questa estensione principale costruita sopra ActiveRecord::Type::Boolean. Funziona perfettamente per me quando deserializzo booleano dalla stringa 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

inizializza le estensioni principali

# 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

In Rails preferisco usare ActiveModel::Type::Boolean.new.cast(value)come menzionato in altre risposte qui

Ma quando scrivo plain Ruby lib. quindi utilizzo un hack in cui JSON.parse(libreria Ruby standard) converte la stringa "true" in truee "false" in false. Per esempio:

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

Esempio dall'applicazione live:

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

confermato in Ruby 2.5.1

Lavorare in 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

Ho un piccolo trucco per questo. JSON.parse('false')tornerà falsee JSON.parse('true')tornerà vero. Ma questo non funziona con JSON.parse(true || false). Quindi, se usi qualcosa del genere JSON.parse(your_value.to_s), dovresti raggiungere il tuo obiettivo in modo semplice ma hacky.

Una gemma come https://rubygems.org/gems/to_bool può essere utilizzata, ma può essere facilmente scritta in una riga utilizzando un'espressione regolare o ternaria.

esempio di regex:

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

esempio ternario:

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

Il vantaggio del metodo regex è che le espressioni regolari sono flessibili e possono corrispondere a un'ampia varietà di modelli. Ad esempio, se sospetti che var possa essere "True", "False", 'T', 'F', 't' o 'f', puoi modificare la regex:

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

Anche se mi piace l'approccio hash (l'ho usato in passato per cose simili), dato che ti interessa solo far corrispondere valori veritieri - poiché - tutto il resto è falso - puoi verificare l'inclusione in un array:

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

o se altri valori potrebbero essere ritenuti veritieri:

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

dovresti fare altre cose se l'originale valuepotrebbe essere in maiuscolo:

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

ma ancora una volta, per la tua descrizione specifica del tuo problema, potresti farla franca con l'ultimo esempio come soluzione.

In rails, ho già fatto qualcosa del genere:

class ApplicationController < ActionController::Base
  # ...

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

  # ...
end

Il che è bello se stai cercando di abbinare i tuoi confronti di stringhe booleane allo stesso modo di rails per il tuo database.

Vicino a quanto già pubblicato, ma senza il parametro ridondante:

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

utilizzo:

do_stuff = "true"

if do_stuff.true?
    #do stuff
end