Ruby: Jak przekonwertować ciąg znaków na wartość logiczną

Mam wartość, która będzie jedną z czterech rzeczy: logiczna prawda, logiczna fałsz, ciąg „prawda” lub ciąg „fałsz”. Chcę przekonwertować ciąg na wartość logiczną, jeśli jest to ciąg, w przeciwnym razie pozostawić go niezmienionym. Innymi słowy:

„prawda” powinna stać się prawdą

„fałsz” powinien stać się fałszem

prawda powinna pozostać prawdziwa

fałsz powinien pozostać fałszywy

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

Jeśli używasz Rails 5, możesz to zrobić ActiveModel::Type::Boolean.new.cast(value).

W Railsach 4.2 użyj ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

Zachowanie jest nieco inne, ponieważ w Railsach 4.2 sprawdzane są wartości prawda i fałsz. W Railsach 5 sprawdzane są tylko wartości fałsz - o ile wartości nie są zerowe lub nie pasują do wartości fałsz, przyjmuje się, że są prawdziwe. Fałszywe wartości są takie same w obu wersjach: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

Rails 5 Źródło: https://github.com/rails/rails/blob/5-1-stable/activemodel/lib/active_model/type/boolean.rb

Często używałem tego wzorca, aby rozszerzyć podstawowe zachowanie Rubiego, aby ułatwić sobie konwersję dowolnych typów danych na wartości logiczne, co bardzo ułatwia radzenie sobie z różnymi parametrami adresu URL itp.

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

Powiedzmy, że masz parametr, fooktórym może być:

• liczba całkowita (0 oznacza fałsz, wszystkie inne są prawdziwe)
• prawdziwy boolean (prawda / fałsz)
• ciąg („prawda”, „fałsz”, „0”, „1”, „PRAWDA”, „FAŁSZ”)
• zero

Zamiast używać kilku warunków, możesz po prostu zadzwonić, foo.to_booleana resztę magii wykona za Ciebie.

W Railsach dodaję to do inicjalizatora nazwanego core_ext.rbw prawie wszystkich moich projektach, ponieważ ten wzorzec jest tak powszechny.

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

Nie myśl za dużo:

bool_or_string.to_s == "true"  

Więc,

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

Możesz również dodać „.downcase”, jeśli martwisz się dużymi literami.

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] 

W aplikacji rails 5.1 używam tego podstawowego rozszerzenia zbudowanego na ActiveRecord::Type::Boolean . Działa idealnie dla mnie, gdy deserializuję wartość logiczną z ciągu 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

zainicjuj podstawowe rozszerzenia

# 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

Praca w Railsach 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

W Railsach wolę używać ActiveModel::Type::Boolean.new.cast(value) jak wspomniano w innych odpowiedziach tutaj

Ale kiedy piszę zwykły Ruby lib. następnie używam hacka, w którym JSON.parse(standardowa biblioteka Ruby) zamieni ciąg znaków „prawda” na truei „fałsz” na false. Na przykład:

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

Przykład z aplikacji na żywo:

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

potwierdzone w Rubim 2.5.1

Mam mały hack do tego. JSON.parse('false')powróci falsei JSON.parse('true')wróci prawda. Ale to nie działa JSON.parse(true || false). Tak więc, jeśli używasz czegoś takiego JSON.parse(your_value.to_s), powinieneś osiągnąć swój cel w prosty, ale hakerski sposób.

Klejnot taki jak https://rubygems.org/gems/to_boolMożna użyć , ale można go łatwo zapisać w jednej linii za pomocą wyrażenia regularnego lub trójskładnika.

przykład wyrażenia regularnego:

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

potrójny przykład:

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

Zaletą metody regex jest to, że wyrażenia regularne są elastyczne i mogą pasować do wielu różnych wzorców. Na przykład, jeśli podejrzewasz, że zmienna może mieć dowolną wartość „True”, „False”, „T”, „F”, „t” lub „f”, możesz zmodyfikować to wyrażenie regularne:

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

Chociaż podoba mi się podejście haszujące (użyłem go w przeszłości do podobnych rzeczy), biorąc pod uwagę, że tak naprawdę zależy Ci tylko na dopasowywaniu prawdziwych wartości - ponieważ - wszystko inne jest fałszywe - możesz sprawdzić, czy jest włączona do tablicy:

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

lub jeśli inne wartości można uznać za prawdziwe:

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

musiałbyś zrobić inne rzeczy, jeśli oryginał valuemoże być mieszany:

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

ale znowu, dla twojego konkretnego opisu problemu, ostatni przykład może ci ujść na sucho jako rozwiązanie.

W szynach robiłem wcześniej coś takiego:

class ApplicationController < ActionController::Base
  # ...

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

  # ...
end

Co jest fajne, jeśli próbujesz dopasować swoje porównania ciągów logicznych w taki sam sposób, jak railsy dla twojej bazy danych.

Blisko tego, co już zostało opublikowane, ale bez zbędnego parametru:

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

stosowanie:

do_stuff = "true"

if do_stuff.true?
    #do stuff
end