Ruby: Bir dizeyi boole'ye dönüştürme

Dört şeyden biri olacak bir değere sahibim: boolean true, boolean false, "true" dizesi veya "false" dizesi. Bir dizge ise dizeyi boolean'a dönüştürmek, aksi takdirde değiştirmeden bırakmak istiyorum. Diğer bir deyişle:

"doğru" gerçek olmalı

"yanlış" yanlış olmalı

doğru doğru kalmalı

yanlış, yanlış kalmalı

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

Rails 5 kullanıyorsanız, yapabilirsiniz ActiveModel::Type::Boolean.new.cast(value).

Rails 4.2'de kullanın ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

Davranış biraz farklıdır, Rails 4.2'de olduğu gibi, gerçek değer ve yanlış değerler kontrol edilir. Rails 5'te, yalnızca yanlış değerler kontrol edilir - değerler sıfır değilse veya yanlış bir değerle eşleşmedikçe, doğru olduğu varsayılır. Yanlış değerler her iki sürümde de aynıdır: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

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

Keyfi veri türlerini boole değerlerine dönüştürmeyi kolaylaştırmak için Ruby'nin temel davranışını genişletmek için sık sık bu kalıbı kullandım, bu da değişken URL parametreleri vb. İle başa çıkmayı gerçekten kolaylaştırır.

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

Diyelim ki aşağıdaki gibi bir parametreniz foovar:

• bir tam sayı (0 yanlıştır, diğerleri doğrudur)
• gerçek bir boole (doğru / yanlış)
• bir dize ("doğru", "yanlış", "0", "1", "DOĞRU", "YANLIŞ")
• sıfır

Bir sürü koşullu ifade kullanmak yerine, sadece arayabilirsin foo.to_booleanve o sihrin geri kalanını senin için yapacak.

Rails'de, core_ext.rbbu model çok yaygın olduğu için bunu neredeyse tüm projelerimde adı geçen bir başlatıcıya ekliyorum .

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

Fazla düşünmeyin:

bool_or_string.to_s == "true"  

Yani,

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

Büyük harflerle ilgili endişeleriniz varsa ".downcase" de ekleyebilirsiniz.

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] 

Bir raylar 5.1 uygulamasında, üzerine kurulu bu çekirdek uzantısını kullanıyorum ActiveRecord::Type::Boolean. JSON dizesinden boolean'ın serisini kaldırdığımda benim için mükemmel çalışıyor.

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

çekirdek uzantıları başlat

# 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

Raylarda Çalışma 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

Rails'de ActiveModel::Type::Boolean.new.cast(value)buradaki diğer yanıtlarda belirtildiği gibi kullanmayı tercih ediyorum

Ama düz Ruby lib yazdığımda. daha sonra JSON.parse(standart Ruby kitaplığı) "true" dizesini "true" ya trueve "false" dizgisine dönüştüren bir hack kullanıyorum false. Örneğin:

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

Canlı uygulamadan örnek:

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

Ruby 2.5.1 kapsamında onaylandı

Bunun için ufak bir hack'im var. JSON.parse('false')dönecek falseve JSON.parse('true')doğru dönecektir. Ancak bu işe yaramıyor JSON.parse(true || false). Öyleyse, JSON.parse(your_value.to_s)bunun gibi bir şey kullanırsanız , hedefinize basit ama hileli bir şekilde ulaşmalısınız.

Https://rubygems.org/gems/to_bool gibi bir mücevher kullanılabilir, ancak bir normal ifade veya üçlü kullanılarak tek satırda kolayca yazılabilir.

normal ifade örneği:

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

üçlü örnek:

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

Normal ifade yönteminin avantajı, normal ifadelerin esnek olması ve çok çeşitli desenlerle eşleşebilmesidir. Örneğin, değişkenin "True", "False", "T", "F", "t" veya "f" olabileceğinden şüpheleniyorsanız, normal ifadeyi değiştirebilirsiniz:

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

Hash yaklaşımını sevmeme rağmen (bunu geçmişte benzer şeyler için kullandım), sadece doğru değerleri eşleştirmeyi gerçekten önemsediğiniz için - çünkü - diğer her şey yanlıştır - bir diziye dahil olup olmadığını kontrol edebilirsiniz:

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

veya diğer değerler doğru kabul edilebilirse:

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

orijinaliniz valuebüyük / küçük harf karışıksa başka şeyler yapmanız gerekir:

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

ama yine, sorununuzun özel açıklaması için, çözümünüz olarak o son örnekle kurtulabilirsiniz.

Raylarda daha önce şöyle bir şey yaptım:

class ApplicationController < ActionController::Base
  # ...

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

  # ...
end

Boolean dizeleri karşılaştırmalarınızı veritabanınız için rails ile aynı şekilde eşleştirmeye çalışıyorsanız, bu güzel.

Önceden nakledilene yakın, ancak yedek parametre olmadan:

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

kullanım:

do_stuff = "true"

if do_stuff.true?
    #do stuff
end