blocks|key|1206214|text|在Ruby中，nil和false都是false，其他都是true。因此，不需要特定的布尔类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1206215|你可以尝试一下：|1206216|if+5
++puts+"5+is+true"
end|code-block|syntax|javascript|1206217|5的值为true|1206218|if+nil
++++puts+"nil+is+true"
else
++++puts+"nil+is+false"
end|1206219|将打印"nil+is+false“|1206220|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

In Ruby nil and false are false and everything else is true. Hence there is no need for a specific boolean class.

You can try it :

<pre><code>if 5
 puts "5 is true"
end
</code></pre>

5 evaluates to true 

<pre><code>if nil
 puts "nil is true"
else
 puts "nil is false"
end
</code></pre>

Will print "nil is false"

blocks|key|1206294|text|true和false可以由包含多个值的布尔类管理，但类对象必须具有内部值，因此每次使用时都必须取消引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1206295|相反，Ruby将true和false视为长值(0和1)，每个值对应一种对象类类型(FalseClass和TrueClass)。通过使用两个类而不是单个布尔类，每个类不需要任何值，因此可以简单地通过其类标识符(0或1)来区分。我相信这在Ruby引擎内部可以转化为显著的速度优势，因为在内部Ruby可以将TrueClass和FalseClass视为不需要从ID值转换的长值，而布尔对象必须在计算之前被解除引用。|1206296|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

true and false could be managed by a Boolean class that held multiple values, but then the class object would have to have internal values, and therefore have to be de-referenced with every use. 

Instead, Ruby treats true and false as long values (0 and 1), each of which corresponds to a type of object class (FalseClass and TrueClass). By using two classes instead of a single Boolean class, each class does not require any values and therefore can be distinguished simply by its class identifier (0 or 1). I believe this translates to significant speed advantages internal to the Ruby engine, because internally Ruby can treat TrueClass and FalseClass as long values that require zero translation from their ID value, whereas a Boolean object would have to be de-referenced before it could be evaluated.

blocks|key|991946|text|看起来Matz本人在2004年的一次mailing+list+message上回答了这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|991947|简而言之，他的回答是：“现在它运行良好，添加一个布尔值不会带来任何优势”。|991948|就我个人而言，我不同意这种说法；前面提到的“字符串解析”就是一个例子。另一个是，当你根据一个变量的类型对它进行不同的处理时(例如，一个yml解析器)，有一个"Boolean“类是很方便的--它去掉了一个"if”。它看起来也更正确，但这是我个人的观点。|991949|entityMap|0|LINK|mutability|MUTABLE|url|http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/96356^0|I|K|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

It seems that Matz himself answered this question on a <a href="http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/96356" rel="noreferrer">mailing list message</a> in 2004.

Short version of his answer: "right now it works ok, adding a Boolean doesn't give any advantage".

Personally I don't agree with that; the aforementioned "string parsing" is one example. Another one is that when you are applying different treatment to a variable depending on its type, (i.e. a yml parser) having a "Boolean" class is handy - it removes one "if". It also looks more correct, but that's a personal opinion.

blocks|key|1206496|text|因为在Ruby语言中，除了false和nil之外的所有内容在默认情况下都是真的，所以您只需要向String添加解析。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1206497|像这样的东西可能会起作用：|1206498|class+Object

++##+Makes+sure+any+other+object+that+evaluates+to+false+will+work+as+intended,
++##+++++and+returns+just+an+actual+boolean+(like+it+would+in+any+context+that+expect+a+boolean+value).
++def+trueish?;+!!self;+end

end

class+String

++##+Parses+certain+strings+as+true;+everything+else+as+false.
++def+trueish?
++++#+check+if+it's+a+literal+"true"+string
++++return+true+if+self.strip.downcase+==+'true'

++++#+check+if+the+string+contains+a+numerical+zero
++++[:Integer,+:Float,+:Rational,+:Complex].each+do+%7Ct%7C
++++++begin
++++++++converted_number+=+Kernel.send(t,+self)
++++++++return+false+if+converted_number+==+0
++++++rescue+ArgumentError
++++++++#+raises+if+the+string+could+not+be+converted,+in+which+case+we'll+continue+on
++++++end
++++end

++++return+false
++end

end|code-block|syntax|javascript|1206499|在使用时，这将为您提供：|1206500|puts+false.trueish?+++#+=>+false
puts+true.trueish?++++#+=>+true
puts+'false'.trueish?+#+=>+false
puts+'true'.trueish?++#+=>+true
puts+'0'.trueish?+++++#+=>+false
puts+'1'.trueish?+++++#+=>+true
puts+'0.0'.trueish?+++#+=>+false
puts+'1.0'.trueish?+++#+=>+true|1206501|我相信Ruby背后的“大创意”的一部分就是让你想要的行为成为程序固有的行为(例如布尔解析)，而不是创建一个完全封装的类，它存在于它自己的命名空间中(例如BooleanParser)。|1206502|entityMap^0|D|5|J|3|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

Since everything but <code>false</code> and <code>nil</code> evaluate to true in Ruby by default, you would only need to add parsing to String.

Something like this could work:

<pre><code>class Object

 ## Makes sure any other object that evaluates to false will work as intended,
 ## and returns just an actual boolean (like it would in any context that expect a boolean value).
 def trueish?; !!self; end

end

class String

 ## Parses certain strings as true; everything else as false.
 def trueish?
 # check if it's a literal "true" string
 return true if self.strip.downcase == 'true'

 # check if the string contains a numerical zero
 [:Integer, :Float, :Rational, :Complex].each do |t|
 begin
 converted_number = Kernel.send(t, self)
 return false if converted_number == 0
 rescue ArgumentError
 # raises if the string could not be converted, in which case we'll continue on
 end
 end

 return false
 end

end
</code></pre>

When used, this would give you:

<pre><code>puts false.trueish? # =&gt; false
puts true.trueish? # =&gt; true
puts 'false'.trueish? # =&gt; false
puts 'true'.trueish? # =&gt; true
puts '0'.trueish? # =&gt; false
puts '1'.trueish? # =&gt; true
puts '0.0'.trueish? # =&gt; false
puts '1.0'.trueish? # =&gt; true
</code></pre>

I believe part of the “big idea” behind Ruby is to just make the behavior you desire inherent to your program (e.g. boolean parsing), rather creating a fully encapsulated class that lives in it's own namespace world (e.g. BooleanParser).

blocks|key|992082|text|正如其他人所说，你可以“修补”Ruby。创建您自己的类。这是我想出来的。Boolean类上的方法有点傻，但它们在编程上可能会很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|992083|class+Boolean
++def+self.new(bool)
++++bool
++end

++def+self.true
++++true
++end

++def+self.false
++++false
++end
end

class+FalseClass
++def+is_a?(other)
++++other+==+Boolean+%7C%7C+super
++end

++def+self.===(other)
++++other+==+Boolean+%7C%7C+super
++end
end

class+TrueClass
++def+is_a?(other)
++++other+==+Boolean+%7C%7C+super
++end

++def+self.===(other)
++++other+==+Boolean+%7C%7C+super
++end
end|code-block|syntax|javascript|992084|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As others have said, you could "patch" Ruby. Create your own class. Here is something I came up with. The methods on the Boolean class are a bit silly, but they could be useful programmatically at some point.

<pre><code>class Boolean
 def self.new(bool)
 bool
 end

 def self.true
 true
 end

 def self.false
 false
 end
end

class FalseClass
 def is_a?(other)
 other == Boolean || super
 end

 def self.===(other)
 other == Boolean || super
 end
end

class TrueClass
 def is_a?(other)
 other == Boolean || super
 end

 def self.===(other)
 other == Boolean || super
 end
end
</code></pre>

I was working on serializing values when found out about this one. Ruby has a <a href="http://ruby-doc.org/core/classes/TrueClass.html" rel="noreferrer"><code>TrueClass</code></a> class, and a <a href="http://ruby-doc.org/core/classes/FalseClass.html" rel="noreferrer"><code>FalseClass</code></a> class, but it has no <code>Boolean</code> class. I'd like to know why is this.

I see some advantages in using a <code>Boolean</code>; for example, string parsing could be centralized on it.

Ruby developers are smarter than me, so there must be a lot of good reasons that I just don't see. But right now it looks to me like having <code>OneClass</code> and a <code>TwoClass</code> instead of <a href="http://ruby-doc.org/core/classes/Fixnum.html" rel="noreferrer"><code>Fixnum</code></a>.

Why does Ruby have TrueClass and FalseClass instead of a single Boolean class?

Ruby语言

Kernel

当我发现这一点时，我正在处理序列化的值。Ruby有一个类和一个类，但它没有Boolean类。我想知道为什么会这样。我看到了使用Boolean的一些优点；例如，字符串解析可以集中在它上。Ruby开发人员比我聪明，所以肯定有很多我看不到的好理由。但现在在我看来，OneClass和TwoClass取代了。

问为什么Ruby有TrueClass和FalseClass而不是一个布尔类？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Ruby有TrueClass和FalseClass而不是一个布尔类？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Ruby有TrueClass和FalseClass而不是一个布尔类？
EN