Ruby: Cách chuyển đổi một chuỗi thành boolean

Tôi có một giá trị sẽ là một trong bốn thứ: boolean true, boolean false, chuỗi "true" hoặc chuỗi "false". Tôi muốn chuyển đổi chuỗi thành boolean nếu nó là một chuỗi, nếu không thì hãy để nó không sửa đổi. Nói cách khác:

"true" phải trở thành true

"false" phải trở thành false

đúng nên luôn đúng

sai nên vẫn sai

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

Nếu bạn sử dụng Rails 5, bạn có thể làm được ActiveModel::Type::Boolean.new.cast(value).

Trong Rails 4.2, sử dụng ActiveRecord::Type::Boolean.new.type_cast_from_user(value).

Hành vi hơi khác một chút, như trong Rails 4.2, giá trị true và false được kiểm tra. Trong Rails 5, chỉ các giá trị false mới được kiểm tra - trừ khi các giá trị bằng không hoặc khớp với một giá trị false, nó được giả định là true. Giá trị sai giống nhau trong cả hai phiên bản: FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]

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

Tôi đã thường xuyên sử dụng mẫu này để mở rộng hành vi cốt lõi của Ruby để giúp dễ dàng hơn trong việc chuyển đổi các kiểu dữ liệu tùy ý thành các giá trị boolean, điều này giúp bạn thực sự dễ dàng đối phó với các tham số URL khác nhau, v.v.

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

Vì vậy, giả sử bạn có một tham số foocó thể là:

• một số nguyên (0 là sai, tất cả các số khác đều đúng)
• một boolean đúng (true / false)
• một chuỗi ("true", "false", "0", "1", "TRUE", "FALSE")
• không

Thay vì sử dụng một loạt các điều kiện, bạn chỉ có thể gọi foo.to_booleanvà nó sẽ thực hiện phần còn lại của phép thuật cho bạn.

Trong Rails, tôi thêm nó vào một trình khởi tạo có tên core_ext.rbtrong gần như tất cả các dự án của tôi vì mẫu này rất phổ biến.

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

Đừng suy nghĩ nhiều:

bool_or_string.to_s == "true"  

Vì thế,

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

Bạn cũng có thể thêm ".downcase" nếu bạn lo lắng về các chữ cái viết hoa.

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] 

Trong một ứng dụng rails 5.1, tôi sử dụng phần mở rộng cốt lõi được xây dựng trên ActiveRecord::Type::Boolean. Nó đang hoạt động hoàn hảo cho tôi khi tôi giải mã boolean từ chuỗi 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

khởi tạo phần mở rộng cốt lõi

# 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

Trong Rails, tôi thích sử dụng ActiveModel::Type::Boolean.new.cast(value)như đã đề cập trong các câu trả lời khác ở đây

Nhưng khi tôi viết Ruby lib đơn giản. sau đó tôi sử dụng một bản hack trong đó JSON.parse(thư viện Ruby tiêu chuẩn) sẽ chuyển đổi chuỗi "true" thành truevà "false" thành false. Ví dụ:

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

Ví dụ từ ứng dụng trực tiếp:

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

được xác nhận theo Ruby 2.5.1

Làm việc trong 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

Tôi có một chút hack cho cái này. JSON.parse('false')sẽ trở lại falsevà JSON.parse('true')sẽ trả về true. Nhưng điều này không hoạt động với JSON.parse(true || false). Vì vậy, nếu bạn sử dụng một cái gì đó giống như JSON.parse(your_value.to_s)nó sẽ đạt được mục tiêu của bạn một cách đơn giản nhưng khó hiểu.

Có thể sử dụng một gem như https://rubygems.org/gems/to_bool , nhưng nó có thể dễ dàng được viết thành một dòng bằng cách sử dụng regex hoặc ternary.

ví dụ regex:

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

ví dụ bậc ba:

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

Ưu điểm của phương pháp regex là biểu thức chính quy rất linh hoạt và có thể khớp với nhiều mẫu khác nhau. Ví dụ: nếu bạn nghi ngờ rằng var có thể là bất kỳ "True", "False", 'T', 'F', 't' hoặc 'f', thì bạn có thể sửa đổi regex:

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

Mặc dù tôi thích cách tiếp cận băm (trước đây tôi đã sử dụng nó cho những thứ tương tự), vì bạn chỉ thực sự quan tâm đến việc khớp các giá trị trung thực - vì - mọi thứ khác đều sai - bạn có thể kiểm tra để đưa vào một mảng:

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

hoặc nếu các giá trị khác có thể được coi là trung thực:

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

bạn phải làm những thứ khác nếu bản gốc của bạn valuecó thể là trường hợp hỗn hợp:

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

nhưng một lần nữa, đối với mô tả cụ thể về vấn đề của bạn, bạn có thể lấy ví dụ cuối cùng đó làm giải pháp cho mình.

Trong rails, trước đây tôi đã làm một việc như sau:

class ApplicationController < ActionController::Base
  # ...

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

  # ...
end

Thật tuyệt nếu bạn đang cố gắng so sánh các chuỗi boolean của mình theo cách giống như rails cho cơ sở dữ liệu của bạn.

Gần với những gì đã được đăng, nhưng không có tham số thừa:

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

sử dụng:

do_stuff = "true"

if do_stuff.true?
    #do stuff
end