Ruby: Як перетворити рядок у булева

У мене є значення, яке буде однією з чотирьох речей: булева істина, булева помилка, рядок "справжній" або рядок "хибна". Я хочу перетворити рядок у булеву, якщо вона є рядком, інакше залиште її без змін. Іншими словами:

"справжній" повинен стати істинним

"false" має стати хибним

правда повинна залишатися вірною

false має залишатися хибним

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

Якщо ви використовуєте Rails 5, ви можете це зробити ActiveModel::Type::Boolean.new.cast(value).

У Rails 4.2 використовуйте ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

Поведінка дещо інша, тому що в Rails 4.2 перевіряється справжнє значення та помилкові значення. У Rails 5 перевіряються лише помилкові значення - якщо значення не дорівнюють нулю або не відповідають ложному значенню, воно вважається істинним. Помилкові значення однакові в обох версіях: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

Rails 5 Джерело: https://github.com/rails/rails/blob/5-1-stable/activemodel/lib/active_model/type/boolean.rb

Я часто використовував цю схему для розширення основної поведінки Ruby, щоб полегшити роботу з перетворенням довільних типів даних у булі значення, що полегшує роботу з різними параметрами URL-адреси тощо.

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

Скажімо, у вас є параметр, fooякий може бути:

• ціле число (0 помилкове, всі інші істинні)
• справжній булевий (вірний / хибний)
• рядок ("true", "false", "0", "1", "TRUE", "FALSE")
• нуль

Замість того, щоб використовувати купу умовних умов, ви можете просто зателефонувати, foo.to_booleanі це зробить решту магії за вас.

У Rails я додаю це до ініціалізатора, названого core_ext.rbмайже у всіх моїх проектах, оскільки ця модель є такою поширеною.

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

Не думайте занадто багато:

bool_or_string.to_s == "true"  

Так,

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

Ви також можете додати ".case", якщо ви переживаєте з великої літери.

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] 

У додатку rails 5.1 я використовую це основне розширення, побудоване поверх ActiveRecord::Type::Boolean. Це прекрасно працює для мене, коли я десериалізую булева з рядка 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

ініціалізувати розширення ядра

# 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

У Rails я вважаю за краще використовувати, ActiveModel::Type::Boolean.new.cast(value)як згадується в інших відповідях тут

Але коли я пишу звичайний Ruby lib. тоді я використовую хак, де JSON.parse(стандартна бібліотека Ruby) перетворить рядок "true" в true"false" в false. Наприклад:

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

Приклад з живої програми:

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

підтверджено відповідно до Ruby 2.5.1

Робота в рейки 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

У мене є трохи хак для цього. JSON.parse('false')повернеться falseі JSON.parse('true')повернеться правдою. Але це не працює JSON.parse(true || false). Отже, якщо ви використовуєте щось подібне, JSON.parse(your_value.to_s)ви повинні досягти своєї мети простим, але хакітним способом.

Можна використовувати такий дорогоцінний камінь, як https://rubygems.org/gems/to_bool , але його можна легко записати в один рядок, використовуючи регулярний вираз або потрійну форму.

Приклад регулярного вираження:

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

потрійний приклад:

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

Перевага методу регулярного вираження полягає в тому, що регулярні вирази є гнучкими і можуть відповідати найрізноманітнішим шаблонам. Наприклад, якщо ви підозрюєте, що var може бути будь-яким із "True", "False", "T", "F", "t" або "f", ви можете змінити регулярний вираз:

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

Хоча мені подобається хеш-підхід (я його використовував раніше для подібних матеріалів), враховуючи, що ви дійсно дбаєте про відповідність правдивих значень - оскільки - все інше помилкове - ви можете перевірити на включення до масиву:

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

або якщо інші значення можна вважати правдивими:

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

вам доведеться робити інші речі, якщо ваш оригінал valueможе бути змішаним корпусом:

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

але знову ж таки, для конкретного опису вашої проблеми ви можете піти з цього останнього прикладу як свого рішення.

У рейках я раніше робив щось подібне:

class ApplicationController < ActionController::Base
  # ...

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

  # ...
end

Що приємно, якщо ви намагаєтеся зіставити булеві струнні порівняння так само, як рейки для вашої бази даних.

Близький до того, що вже розміщено, але без зайвого параметра:

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

використання:

do_stuff = "true"

if do_stuff.true?
    #do stuff
end