blocks|key|1667924|text|我在过去遇到的一个问题是换行符(\n)转义序列--以及其他字符--不支持单引号内的字符串。反斜杠本身被转义。您必须使用双引号进行转义才能按预期工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1667925|entityMap^0|G|2|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

One that's caught me out in the past is that the newline character (<code>\n</code>) escape sequence&mdash;amongst others&mdash;isn't supported by strings within single quotes. The backslash itself gets escaped. You have to use double quotes for the escaping to work as expected.

blocks|key|1667952|text|Ruby中的Inheritence+plays+no+part+in+determining+method+visibility。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1667953|entityMap|0|LINK|mutability|MUTABLE|url|http://weblog.jamisbuck.org/2007/2/23/method-visibility-in-ruby^0|6|1M|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://weblog.jamisbuck.org/2007/2/23/method-visibility-in-ruby" rel="noreferrer">Inheritence plays no part in determining method visibility</a> in Ruby.

blocks|key|1452986|text|x+=+(true+and+false)+#+x+is+false|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1452987|正如您所指出的，0和'‘是正确的。|unstyled|1452988|您可以使用相同的名称拥有一个方法和一个模块/类(这是有意义的，因为该方法实际上被添加到Object中，因此具有其自己的名称空间)。|1452989|没有多重继承，但经常使用“混合模块”将公共方法添加到多个类中。|1452990|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>x = (true and false) # x is false
</code></pre>

0 and '' are true, as you pointed out.

You can have a method and a module/class by the same name (which makes sense, because the method actually gets added to Object and thus has its own namespace).

There is no multiple inheritance, but frequently "mixin modules" are used to add common methods to multiple classes.

blocks|key|1668053|text|了解Time和Date类之间的区别。两者都是不同的，在rails中使用它们时都会产生问题。Time类有时会与标准ruby/rails库中的其他Time类库冲突。就我个人而言，我花了很多时间来理解我的rails应用程序到底发生了什么。后来，我想当我这么做的时候|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1668054|Time.new|offset|length|style|CODE|1668055|它指的是一个我甚至都不知道的地方的某个库。|1668056|如果我不清楚我想说什么，很抱歉。如果其他人遇到过类似的问题，请重新解释。|1668057|entityMap^0|0|0|8|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Understanding the difference between Time and Date class. Both are different and have created issues while using them in rails. The Time class sometimes conflicts with other Time class libraries present in standard ruby/rails library. It personally took me a lot of time to understand what was exactly going on in my rails app. Later, I figured when I did 

<code> Time.new </code>

It was referring to some library in a location that I was not even aware of. 

Sorry if I am not clear with what I want to say exactly. If others have faced similar problems, please re-explain.

blocks|key|1453071|text|在不带参数的情况下调用super时，实际上会使用与覆盖方法相同的参数来调用被覆盖的方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1453072|class+A
++def+hello(name="Dan")
++++puts+"hello+#{name}"
++end
end

class+B+<+A
++def+hello(name)
++++super
++end
end

B.new.hello("Bob")+#=>+"hello+Bob"|code-block|syntax|javascript|1453073|要在不带参数的情况下实际调用super，需要声明super()。|1453074|entityMap^0|B|5|0|0|E|5|O|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

When calling <code>super</code> with no arguments, the overridden method is actually called with the same arguments as the overriding method.

<pre><code>class A
 def hello(name="Dan")
 puts "hello #{name}"
 end
end

class B &lt; A
 def hello(name)
 super
 end
end

B.new.hello("Bob") #=&gt; "hello Bob"
</code></pre>

To actually call <code>super</code> with no arguments, you need to say <code>super()</code>.

blocks|key|1668196|text|我认为"and“和"or”是对Perl的认可，Perl是Ruby比较明显的“父母”之一(其他最突出的是Smalltalk)。与你应该使用的运算符&&和%7C%7C相比，它们的优先级都要低得多(实际上，比赋值更低，这就是所提到的行为的来源)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1668197|其他需要注意的事情并不是一目了然的：|1668198|您并不真正调用方法/函数，尽管它看起来是这样的。相反，就像在Smalltalk中一样，您需要向对象发送一条消息。所以method_missing实际上更像message_not_understood。|1668199|some_object.do_something(args)|code-block|syntax|javascript|1668200|等同于|1668201|some_object.send(:do_something,+args)+#+note+the+:|1668202|符号的使用非常广泛。这是从:开始的那些事情，它们并不是一目了然的(嗯，对我来说不是)，但你越早掌握它们就越好。|1668203|Ruby很喜欢“鸭子类型”，遵循这样的原则：“如果它走起来像鸭子，叫起来像鸭子……”这允许在没有任何显式继承或混合关系的情况下，使用公共方法子集非正式地替换对象。|1668204|entityMap^0|4|3|A|2|20|2|23|2|0|0|1M|E|25|M|0|0|0|0|D|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1D|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1F|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1J|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|X|$]]

I think "<code>and</code>" and "<code>or</code>" are nods to Perl, which is one of Ruby's more obvious "parents" (the most prominent other being Smalltalk). They both have much lower precedence (lower than assignment, in fact, which is where the behaviour noted comes from) than <code>&amp;&amp;</code> and <code>||</code> which are the operators you should be using.

Other things to be aware of that aren't immediately obvious:

You don't really call methods/functions, although it kinda looks that way. Instead, as in Smalltalk, you send a message to an object. So <code>method_missing</code> is really more like <code>message_not_understood</code>.

<pre><code>some_object.do_something(args)
</code></pre>

is equivalent to 

<pre><code>some_object.send(:do_something, args) # note the :
</code></pre>

Symbols are very widely used. That's those things that start with <code>:</code> and they're not immediately obvious (well they weren't to me) but the earlier you get to grips with them the better.

Ruby is big on "duck-typing", following the principal that "if it walks like a duck and quacks like a duck..." that allows informal substitution of objects with a common subset of methods without any explicit inheritance or mixin relationship.

blocks|key|1453194|text|我在理解类变量、类属性和类方法时遇到了很多麻烦。这段代码可能会对新手有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1453195|class+A
++@@classvar+=+"A1"
++@classattr+=+"A2"
++def+self.showvars
++++puts+"@@classvar+=>+"%2B@@classvar
++++puts+"@classattr+=>+"%2B@classattr
++end
end

A.showvars
++#+displays:
++#+@@classvar+=>+A1
++#+@classattr+=>+A2

class+B+<+A
++@@classvar+=+"B1"
++@classattr+=+"B2"
end

B.showvars
++#+displays:
++#+@@classvar+=>+B1
++#+@classattr+=>+B2

A.showvars
++#+displays:
++#+@@classvar+=>+B1+++#Class+variables+are+shared+in+a+class+hierarchy!
++#+@classattr+=>+A2+++#Class+attributes+are+not|code-block|syntax|javascript|1453196|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|$]]

I had a lot of trouble understanding class variables, class attributes and class methods. This code might help a newbie:

<pre><code>class A
 @@classvar = "A1"
 @classattr = "A2"
 def self.showvars
 puts "@@classvar =&gt; "+@@classvar
 puts "@classattr =&gt; "+@classattr
 end
end

A.showvars
 # displays:
 # @@classvar =&gt; A1
 # @classattr =&gt; A2

class B &lt; A
 @@classvar = "B1"
 @classattr = "B2"
end

B.showvars
 # displays:
 # @@classvar =&gt; B1
 # @classattr =&gt; B2

A.showvars
 # displays:
 # @@classvar =&gt; B1 #Class variables are shared in a class hierarchy!
 # @classattr =&gt; A2 #Class attributes are not
</code></pre>

blocks|key|1453238|text|我认为在某些事情上使用.length总是很好的。因为几乎所有东西都支持大小，并且Ruby有动态类型，所以当类型错误时调用.size会得到非常奇怪的结果……我更希望得到一个NoMethodError:未定义的方法‘`length'，所以我通常不会在Ruby语言中调用对象的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1453239|咬了我不止一次。|1453240|还要记住对象有id，所以为了避免混淆，我尽量不使用调用id或object_id的变量。如果我需要用户对象上的id，最好将其命名为类似user_id的名称。|1453241|这只是我的两点意见|1453242|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I think it is always good to use .length on things... since size is supported by nearly everything and Ruby has dynamic types you can get really weird results calling .size when you have the wrong type... I would much rather get a NoMethodError: undefined method `length', so I generally never call size on objects in Ruby.

bit me more than once.

Also remember objects have ids, so I try not to use variables call id or object_id just to avoid confusion. If I need an id on a Users object it is best to call it something like user_id.

Just my two cents

blocks|key|1668324|text|我学到的一件事就是小心地使用操作符%7C%7C=。如果你要处理布尔值，要特别小心。我通常使用%7C%7C=+b作为catch+all，以便在其他所有操作都失败而'a‘仍然为空的情况下给'a’一个默认值。但如果a为false，b为true，则a将被指定为true。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1668325|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

one thing i learned was to use the operator ||= carefully. and take special care if you are dealing with booleans. i usually used a ||= b as a catch all to give 'a' a default value if everything else failed and 'a' remained nil. but if a is false and b is true, then a will be assigned true.

blocks|key|1668368|text|与monkut的响应相关，Ruby的to_foo方法暗示了它们将进行多严格的转换。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1668369|像to_i，to_s这样的短类型告诉它是惰性的，并将它们转换为目标类型，即使它们不能以该格式准确地表示出来。例如：|1668370|"10".to_i+==+10
:foo.to_s+==+"foo"|code-block|syntax|javascript|1668371|更长的显式函数，如to_int，to_s，意味着对象可以本机表示为该类型的数据。例如，Rational类表示所有有理数，因此可以通过调用to_int将其直接表示为Fixnum+(或Bignum)整数。|1668372|Rational(20,4).to_int+==+5|1668373|如果您不能调用较长的方法，这意味着对象不能以该类型本机表示。|1668374|所以基本上，在转换时，如果你懒于处理方法名，Ruby就会懒于处理转换。|1668375|entityMap^0|I|6|0|1|4|6|4|0|0|9|6|G|4|17|8|1W|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1F|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1G|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|V|$]]

Related to monkut's response, Ruby's <code>to_foo</code> methods hint at how strict a conversion they'll do.

Short ones like <code>to_i</code>, <code>to_s</code> tell it to be lazy, and convert them to the target type even if they're not able to be represented accurately in that format. For example:

<pre><code>"10".to_i == 10
:foo.to_s == "foo"
</code></pre>

The longer explicit functions like <code>to_int</code>, <code>to_s</code> mean that the object can be natively represented as that type of data. For example, the <code>Rational</code> class represents all rational numbers, so it can be directly represented as a Fixnum (or Bignum) integer by calling <code>to_int</code>.

<pre><code>Rational(20,4).to_int == 5
</code></pre>

If you can't call the longer method, it means the object can't be natively represented in that type.

So basically, when converting, if you're lazy with the method names, Ruby will be lazy with the conversion.

blocks|key|1453378|text|ruby散列上的迭代不能保证以任何特定的顺序发生。(这不是一个bug，而是一个特性)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1453379|如果您需要特定的订单，则Hash#sort非常有用。|offset|length|style|CODE|1453380|相关问题：Why+are+Ruby’s+array+of+1000+hashes'+key+and+value+pairs+always+in+a+particular+order?|1453381|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3516125/why-rubys-array-of-1000-hashes-key-and-value-pairs-are-always-in-a-particular-o^0|0|C|9|0|5|2E|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Iteration over ruby hashes aren't guaranteed to happen in any particular order. (It's not a bug, it's a feature)

<code>Hash#sort</code> is useful if you need a particular order.

Related question: <a href="https://stackoverflow.com/questions/3516125/why-rubys-array-of-1000-hashes-key-and-value-pairs-are-always-in-a-particular-o">Why are Ruby’s array of 1000 hashes' key and value pairs always in a particular order?</a>

blocks|key|1453431|text|默认情况下，块和方法返回最后一行的值。出于调试目的而将puts语句添加到末尾可能会产生令人不快的副作用|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1453432|entityMap^0|R|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Blocks and methods return the value of the last line by default. Adding <code>puts</code> statements to the end for debugging purposes can cause unpleasant side effects

blocks|key|1453461|text|1..5.each+{%7Cx%7C+puts+x}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1453462|不起作用。您必须将范围放在括号中，例如|unstyled|1453463|(1..5).each+{%7Cx%7C+puts+x}|1453464|这样它就不会认为你在给5.each打电话。我认为这是一个优先级问题，就像x+=+true+and+false的问题一样。|offset|length|style|CODE|1453465|entityMap^0|0|0|0|B|6|10|I|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>1..5.each {|x| puts x}
</code></pre>

doesn't work. You have to put the range into parentheses, like

<pre><code>(1..5).each {|x| puts x}
</code></pre>

so it doesn't think you're calling <code>5.each</code>. I think this is a precedence issue, just like the <code>x = true and false</code> gotcha.

blocks|key|1668603|text|来自In+Ruby+why+won't+foo+=+true+unless+defined?(foo)+make+the+assignment?|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1668604|foo+=+true+unless+defined?(foo)+#Leaves+foo+as+nil|code-block|syntax|javascript|1668605|因为在调用defined?(foo)时，foo被定义为nil。|1668606|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/2291646/in-ruby-why-wont-foo-true-unless-definedfoo-make-the-assignment^0|K|V|2|1Y|0|0|0|5|D|K|3|R|3|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

From <a href="https://stackoverflow.com/questions/2291646/in-ruby-why-wont-foo-true-unless-definedfoo-make-the-assignment">In Ruby why won't <code>foo = true unless defined?(foo)</code> make the assignment?</a>

<pre><code>foo = true unless defined?(foo) #Leaves foo as nil
</code></pre>

Because <code>foo</code> is defined as <code>nil</code> when <code>defined?(foo)</code> is called.

blocks|key|1668679|text|如果您使用attr_writer或attr_accessor+(或def+foo=)声明了一个设置器(也称为赋值函数)，请注意从类内部调用它。因为变量是隐式声明的，所以解释器总是必须将foo+=+bar解析为声明一个名为foo的新变量，而不是调用方法self.foo=(bar)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1668680|class+Thing
++attr_accessor+:foo
++def+initialize
++++@foo+=+1++++++#+this+sets+@foo+to+1
++++self.foo+=+2++#+this+sets+@foo+to+2
++++foo+=+3+++++++#+this+does+*not*+set+@foo
++end
end

puts+Thing.new.foo+#=>+2|code-block|syntax|javascript|1668681|这也适用于Rails+ActiveRecord对象，这些对象获取基于数据库中的字段定义的访问器。由于它们甚至不是@样式的实例变量，因此单独设置这些值的正确方法是使用self.value+=+123或self['value']+=+123。|1668682|entityMap^0|5|B|H|D|X|8|2K|9|3H|E|0|0|2A|G|2R|J|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|N|$]]

If you declare a setter (aka mutator) using <code>attr_writer</code> or <code>attr_accessor</code> (or <code>def foo=</code>), be careful of calling it from inside the class. Since variables are implicitly declared, the interpreter always has to resolve <code>foo = bar</code> as declaring a new variable named foo, rather than calling the method <code>self.foo=(bar)</code>.

<pre><code>class Thing
 attr_accessor :foo
 def initialize
 @foo = 1 # this sets @foo to 1
 self.foo = 2 # this sets @foo to 2
 foo = 3 # this does *not* set @foo
 end
end

puts Thing.new.foo #=&gt; 2
</code></pre>

This also applies to Rails ActiveRecord objects, which get accessors defined based on fields in the database. Since they're not even @-style instance variables, the proper way to set those values individually is with <code>self.value = 123</code> or <code>self['value'] = 123</code>.

blocks|key|1453753|text|这个曾经让我抓狂过：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1453754|1/2+==+0.5+#=>+false
1/2+==+0+++#=>+true|code-block|syntax|javascript|1453755|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|$]]

This one made me mad once:

<pre><code>1/2 == 0.5 #=&gt; false
1/2 == 0 #=&gt; true
</code></pre>

I have recently learned the Ruby programming language, and all in all it is a good language. But I was quite surprised to see that it was not as simple as I had expected. More precisely, the "rule of least-surprise" did not seem very respected to me (of course this is quite subjective). For example:

<pre><code>x = true and false
puts x # displays true!
</code></pre>

and the famous:

<pre><code>puts "zero is true!" if 0 # zero is true!
</code></pre>

What are the other "Gotchas" you would warn a Ruby newbie about?

What are the Ruby Gotchas a newbie should be warned about?

Ruby语言

数据库

解释器

Perl

我最近学习了Ruby编程语言，总的来说，它是一种很好的语言。但令我惊讶的是，它并不像我预期的那样简单。更确切地说，在我看来，“最小意外原则”似乎并不是很受尊重(当然，这是相当主观的)。例如：x = true and falseputs x  # displays true!和著名的：puts "zero is true...

问新手应该注意的Ruby Gotchas是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问新手应该注意的Ruby Gotchas是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问新手应该注意的Ruby Gotchas是什么？
EN