Ruby: So konvertieren Sie einen String in einen Booleschen Wert

Ich habe einen Wert, der eines von vier Dingen sein wird: boolean true, boolean false, die Zeichenfolge "true" oder die Zeichenfolge "false". Ich möchte den String in einen Booleschen Wert konvertieren, wenn es sich um einen String handelt, andernfalls möchte ich ihn unverändert lassen. Mit anderen Worten:

"wahr" sollte wahr werden

"falsch" sollte falsch werden

wahr sollte wahr bleiben

false sollte false bleiben

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

Wenn Sie Rails 5 verwenden, können Sie dies tun ActiveModel::Type::Boolean.new.cast(value).

Verwenden Sie in Rails 4.2 ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

Das Verhalten unterscheidet sich geringfügig, da in Rails 4.2 der wahre und der falsche Wert überprüft werden. In Rails 5 werden nur falsche Werte überprüft. Sofern die Werte nicht Null sind oder mit einem falschen Wert übereinstimmen, wird angenommen, dass sie wahr sind. Falsche Werte sind in beiden Versionen gleich: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

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

Ich habe dieses Muster häufig verwendet, um das Kernverhalten von Ruby zu erweitern und die Konvertierung beliebiger Datentypen in boolesche Werte zu vereinfachen, wodurch es wirklich einfach ist, mit unterschiedlichen URL-Parametern usw. umzugehen.

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

Nehmen wir also an, Sie haben einen Parameter, fooder sein kann:

• eine ganze Zahl (0 ist falsch, alle anderen sind wahr)
• ein wahrer Boolescher Wert (wahr / falsch)
• eine Zeichenfolge ("wahr", "falsch", "0", "1", "WAHR", "FALSCH")
• Null

Anstatt eine Reihe von Bedingungen zu verwenden, können Sie einfach anrufen foo.to_booleanund es wird den Rest der Magie für Sie erledigen.

In Rails füge ich dies einem Initialisierer hinzu, der core_ext.rbin fast allen meinen Projekten benannt ist, da dieses Muster so häufig vorkommt.

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

Denk nicht zu viel nach:

bool_or_string.to_s == "true"  

So,

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

Sie können auch ".downcase" hinzufügen, wenn Sie sich Sorgen um Großbuchstaben machen.

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 einer Rails 5.1-App verwende ich diese Kernerweiterung, auf der aufgebaut ist ActiveRecord::Type::Boolean. Es funktioniert perfekt für mich, wenn ich Boolesche Werte aus JSON-Zeichenfolgen deserialisiere.

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

Initialisieren Sie die Kernerweiterungen

# 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 bevorzuge ich die Verwendung, ActiveModel::Type::Boolean.new.cast(value)wie in anderen Antworten hier erwähnt

Aber wenn ich einfach Ruby lib schreibe. dann benutze ich einen Hack, bei dem JSON.parse(Standard-Ruby-Bibliothek) die Zeichenfolge "true" in trueund "false" in konvertiert false. Z.B:

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

Beispiel aus einer Live-Anwendung:

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

bestätigt unter Ruby 2.5.1

Arbeiten in Schienen 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

Ich habe einen kleinen Hack für diesen. JSON.parse('false')wird zurückkehren falseund JSON.parse('true')wird true zurückgeben. Aber das funktioniert nicht mit JSON.parse(true || false). Wenn Sie also so etwas verwenden JSON.parse(your_value.to_s), sollten Sie Ihr Ziel auf einfache, aber hackige Weise erreichen.

Ein Edelstein wie https://rubygems.org/gems/to_bool kann verwendet werden, aber es kann leicht mit einem regulären Ausdruck oder einem ternären Text in einer Zeile geschrieben werden.

Regex-Beispiel:

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

ternäres Beispiel:

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

Der Vorteil der Regex-Methode besteht darin, dass reguläre Ausdrücke flexibel sind und einer Vielzahl von Mustern entsprechen können. Wenn Sie beispielsweise den Verdacht haben, dass var "True", "False", "T", "F", "t" oder "f" sein könnte, können Sie den regulären Ausdruck ändern:

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

Obwohl ich den Hash-Ansatz mag (ich habe ihn in der Vergangenheit für ähnliche Dinge verwendet), können Sie, da alles andere falsch ist, überprüfen, ob er in ein Array aufgenommen wurde:

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

oder wenn andere Werte als wahr angesehen werden könnten:

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

Sie valuemüssten andere Dinge tun, wenn Ihr Original ein gemischter Fall wäre:

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

Für Ihre spezifische Beschreibung Ihres Problems könnten Sie jedoch das letzte Beispiel als Lösung verwenden.

In Schienen habe ich vorher so etwas gemacht:

class ApplicationController < ActionController::Base
  # ...

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

  # ...
end

Das ist schön, wenn Sie versuchen, Ihre booleschen Zeichenfolgenvergleiche auf dieselbe Weise abzugleichen, wie dies bei Rails für Ihre Datenbank der Fall wäre.

Nahe an dem, was bereits gepostet wurde, aber ohne den redundanten Parameter:

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

Verwendung:

do_stuff = "true"

if do_stuff.true?
    #do stuff
end