13.md

## 4.比较与逻辑

### 4.1。 逻辑运算符

逻辑运算符使你可以确定天气是否正确。 例如，一个就是一个，那就是人类的想法，让我们看看计算机对此的想法。 发射你的 irb 并输入 1 等于 1，如图所示

```rb
>> 1 == 1
=> true
```

好吧，那等于符号的两倍呢？ 单个等于号表示分配，例如`a = 5`，将值`5`放入`a`。 双等于符号是比较。 因此，以上我们检查了 1 是否等于 1 且答案为`true`。 电脑是智能的，不是吗？ OK，现在让我们检查 1 是否等于 2，所以我们输入`1==2`和...

```rb
>> 1 == 2
=> false
```

计算机（在这种情况下为 Ruby 解释器）告诉计算机`false`。

很好，如果在我们键入计算机时 1 与计算机不等于 2，则必须输出 true，因此请在控制台中键入

```rb
>> 1 != 2
=> true
```

`!=`代表不等于。 ！ 代表不

现在我们检查 1 是否不等于 1，并且计算机按预期给出`false`作为输出。

```rb
>> 1 != 1
=> false
```

现在，我们检查 2 是否大于 3，对于大于，我们使用`>`符号

```rb
>> 2 > 3
=> false
```

现在，我们将检查 2 是否小于 3，因为小于`<`符号

```rb
>> 2 < 3
=> true
```

凉！ 我们发现如果 2 不大于 3，则其小于 3。那么我们将获得数学诺贝尔奖:)

`&gt;=`代表大于或等于

```rb
>> 5 >= 3
=> true
```

由于 5 大于 3，因此返回`true`

参见下面的表达式，因为 5 等于 5，它仍然返回`true`

```rb
>> 5 >= 5
=> true
```

5 不大于 5，因此在下面返回 false

```rb
>> 5 > 5
=> false
```

3 小于 5，因此小于或等于运算符`⇐`返回 true

```rb
>> 3 <= 5
=> true
```

3 等于 3，因此小于或等于运算符仍返回 true

```rb
>> 3 <= 3
=> true
```

3 不小于 3，等于 3，因此小于运算符返回`false`

```rb
>> 3 < 3
=> false
```

你也可以尝试使用数字

<colgroup><col style="width: 50%;"> <col style="width: 50%;"></colgroup> 
| 操作员 | 含义 |
| ！ &lt; | 不小于 |
| ！ &gt; | 不大于 |

他们工作吗？ ;）

### 4.2。 true！=“ true”

在逻辑运算符部分，你可能会看到 irb 提供`true`或`false`作为输出。 你不要与`“true”`和`“false”`混淆。 `true`和`false`是逻辑值，而`“true”`和`“false”`是`String`。

### 4.3。 ===

`===`运算符用于检查特定实例 &lt;sup class="footnote"&gt;[ [12](#_footnotedef_12 "View footnote.") ]&lt;/sup&gt; 是否属于一类（即类型）。 例如，`“abc”`是`String`类型的对象，`1`是`Integer`，因此让我们在其上应用`===`并检查

```rb
>> String === "abc"
=> true
>> Integer === 1
=> true
```

从上面的示例中可以看到，我们在左边有类名，在右边有实例。 前两个示例为`true`，因为`“abc”`为字符串，`1`为整数。

```rb
>> String === 7
=> false
```

在上面的示例中，由于`7`绝对不是`String`，因此它显然返回 false，这就是你可能会想到的；）

但是有些奇怪，请看下面的例子

```rb
>> "abc" === String
=> false
```

因此，始终将类放在左侧，将实例放在右侧。

### 4.4。 如果

如果满足条件，则使用 if 关键字执行语句。 看看下面的程序。 执行它。

```rb
# if.rb

puts "Whats your name?"
name = gets.chop
puts "#{name} is genius" if name == "Zigor"
puts "#{name} is idiot" if name != "Zigor"
```

如果你输入的名称不是 Zigor，结果将会是这样

```rb
Whats your name?
Karthik
Karthik is idiot
```

看一下程序。 看一下下面这行

```rb
puts "#{name} is genius" if name == "Zigor"
```

该程序在名为`name`的变量中获取你的名字。 现在，它检查上面代码中名称是否为 Zigor（在关键字`if`的右侧），如果是，则执行与之关联的语句（即关键字`if`的左侧的语句） ），在这种情况下，它会打印出特定的名称是 genius。 然后归结为下一条语句

```rb
puts "#{name} is idiot" if name != "Zigor"
```

在此语句中，它检查名称是否不是 Zigor，如果是，则打印名称为 idiot。

### 4.5。 如果别的

让我们以另一种形式编写 who genius 程序，这里我们使用 if else 条件代替`if`。 看一下下面的名为 if_else.rb 的代码

```rb
# Zigor says if the person is intelligent or not
print "Enter your name: "
name = gets.chop
if name == "Zigor"
  puts "#{name} is intelligent"
else
  puts "#{name} is idiot"
end
```

程序在执行时会提供与先前的 if.rb 相同的输出，不同之处在于程序内部逻辑的表示方式。 我们看到一个叫做`if name == "Zigor"`的东西，然后在代码正确的情况下执行该操作，如图所示

```rb
if name == "Zigor"
  puts "#{name} is intelligent"
```

现在，我们可以在之后放置任意数量的语句，如果满足给定的条件，则所有语句将被执行。 到目前为止，还不错，但是 Ruby 如何知道 if 语句在哪里结束呢？ 为了说到此为止，我们如下所示放置了`end`关键字。

```rb
if name == "Zigor"
  puts "#{name} is intelligent"
end
```

假设`if`中给出的条件不满足，我们需要做一些`if`条件无效的操作，然后将条件失败时执行的语句放在`else`关键字下，如下所示

```rb
if name == "Zigor"
  puts "#{name} is intelligent"
else
  puts "#{name} is idiot"
end
```

请注意，`else`和条件失败时需要执行的语句位于`end`语句之前。 结束标记`if else`块的结束。 不一定总是需要其他，而是可以有一个如下所示的代码

```rb
if <condition>
  # many lines of code goes here
end
```

在上面，你可以在`if … end`块中放入许多需要执行的代码。

### 4.6。 埃尔斯夫

当我们使用`if`和`else`时，如果满足条件，则将执行`if`下的代码，否则将执行`else`部分下的代码。 让我们有一个新的场景，其中`if`下的代码不满足，然后程序立即跳转到`else`部分，现在逻辑要求我们也需要在`else`级别检查另一个条件，我们应该怎么做？ 做？ 为了应对这种情况，我们可以使用`elsif`命令。 看看下面的代码

```rb
# elsif.rb
# finds the greatest of three numbers

a,b,c = 3,7,5

if a >= b and a >= c
  puts "a = #{a} is greatest"
elsif b >= c and b >= a
  puts "b = #{b} is greatest"
else puts "c = #{c} is greatest"
end
```

执行后会产生以下结果

```rb
b = 7 is greatest
```

让我们逐步浏览代码。 让我们看看这条线

```rb
a,b,c = 3,7,5
```

在这一行中，我们为变量`a,b`和`c`分配值 3、7 和 5。 现在来看 if 语句

```rb
if a > b and a > c
```

在此语句中，我们检查`a`是否大于`b`和`a`是否大于`c`。 注意关键字`and`。 仅当两个条件都为真时，才满足`if`条件。 `a`小于`b`，因此此条件失败，因此程序跳过`if`语句并进入`elsif`语句

```rb
elsif b > c and b > a
```

`elsif`是`else`加`if`，在这里我们检查由`and`分隔的另外两个条件，我们检查`b `is greater than `a`和`b`是否大于`c`，两者均为真，因此 `elsif`下的声明

```rb
puts "b = #{b} is greatest"
```

得到执行，我们得到结果。 由于`elsif`满足其他`else`的要求，并且其下的代码也将被忽略。

### 4.7。 如果那样的话

还有另一个条件构造，它的 if 称为 if then else，它与 if else 并没有太大区别，下面出于理论目的显示了一个示例，就我个人而言，它并没有任何实际目的，但是出于理论上的考虑 将示例放在下面，执行并亲自查看。

```rb
#if_then_else.rb

number = 42

if number % 2 == 0
  then
  puts "Even"
  else
    puts "Odd"
end
```

### 4.8。 除非

除非是检查状况的另一种方法。 假设一个人是未成年人，除非他或她大于 18 岁。 那么如何在 Ruby 中编码呢？ 考虑下面的程序，在文本编辑器中键入并执行它。

```rb
# unless.rb
print "Enter your age:"
age = gets.to_i
p "You are a minor" unless age >= 18
```

执行后，这就是我们得到的

```rb
Enter your age:16
"You are a minor"
```

程序会询问你的年龄，如果年龄不大于 18，则表示你是未成年人。也就是说，除非你的年龄大于或等于 18（如在此情况下所示），否则你将是未成年人`unless age &gt;= 18`。 `p`是看跌期权 &lt;sup class="footnote"&gt;[ [13](#_footnotedef_13 "View footnote.") ]&lt;/sup&gt; 的简称。 如果编写`puts “something”`，则红宝石解释程序将打印`something`。 如果你使用`p ”something”`，则红宝石解释器将打印`”something”`（这与这些引号一起使用）。

如果我们想在`unless`块下放置多行代码，可以使用`unless …​. end`块，如下所示

```rb
unless <condition>
  # many lines of code goes here
end
```

如果`&lt;condition&gt;`失败，则执行块中的代码。 可以认为`unless`与`if`相反。 如果 if 块被执行`if`的条件是`true`，则`unless`块被执行的条件是`false`。

### 4.9。 除非另有

就像`if`和`else`一样，我们可以在`unless`语句中使用`else`。 输入以下程序并执行

```rb
# unless_1.rb
print "Enter your age:"
age = gets.to_i
unless age >= 18
  p "You are a minor"
  else p "You are a grown up"
end
```

这是执行时得到的

```rb
Enter your age:37
"You are a grown up"
```

好的，这是它的工作原理，你可以确定年龄，将其转换为`age = gets.to_i`中的整数，并将其存储在名为`age`的变量中。 专注于这段代码：

```rb
unless age >= 18
  p "You are a minor"
  else p "You are a grown up"
end
```

除非`age`小于 18 `“You are a minor”`不会被打印出来。 如果年龄大于或等于 18，则将其路由到`else`语句，并打印`“You are a grown up”`。 请注意，如果将`else`与`unless`一起使用，则必须使用`end`命令终止`unless`块。

现在让我们看一下另一个使用`unless else`的程序。 我们想招募人员来武装，这个人应该在 18 到 35 岁之间，我们的计划向想要入学的人询问详细信息，检查其年龄并告知结果。 在下面输入程序并执行

```rb
# unless_2.rb
print "Enter your age:"
age = gets.to_i
unless age < 18 or age > 35
  p "You can enter Armed forces"
  else p "You cannot enter Army. You are either too young or too old"
end
```

执行时将是结果

```rb
Enter your age:23
"You can enter Armed forces"
```

我认为你可以自行解释该程序。 如果没有其他联系方式，除非我很懒，否则我会写一个解释。

### 4.10。 情况何时

假设你要编写一个程序，该程序对于确定的输入具有确定的输出，则可以在以下情况下使用这种情况。 假设我们要编写一个拼写为 1 到 5 的程序，我们可以按照 code / case_when.rb [case_when.rb]中所示的方法进行操作，在文本编辑器中键入该程序并执行。

```rb
# case_when.rb
# This program spells from one to five

print "Enter a number (1-5):"
a = gets.to_i
spell = String.new

case a
  when 1
    spell = "one"
  when 2
    spell = "two"
  when 3
    spell = "three"
  when 4
    spell = "four"
  when 5
    spell = "five"
  else
    spell = nil
end

puts "The number you entered is "+spell if spell
```

输出量

```rb
Enter a number (1-5):4
The number you entered is four
```

让我们看看上面的程序是如何工作的。 首先，提示用户输入数字，当他输入数字时，在以下语句中将其从字符串转换为整数

```rb
a = gets.to_i
```

变量`a`现在包含我们输入的数字的值，我们具有`case`语句，如下所示

```rb
case a
  …......
end
```

在上面的空 case 语句中，我们将编写根据`a`的值执行的代码。 当`a`为 1 时，我们需要将其拼写为`“one”`，因此我们添加以下代码

```rb
case a
  when 1
  spell = "one"
end
```

同样，我们添加代码直到大小写为 5，如图所示

```rb
case a
  when 1
  spell = "one"
  when 2
  spell = "two"
  when 3
  spell = "three"
  when 4
  spell = "four"
  when 5
  spell = "five"
end
```

在某些情况下，运行此程序的人员可能会输入错误的信息，因此我们也需要处理这些情况。 为此，我们添加了一个名为`else`的特殊语句，如果所有情况都失败了，则执行 else 下的代码，但是必须注意，在`case … end`块之间没有`else`是强制性的。 所以现在程序更改如下所示

```rb
case a
  when 1
  spell = "one"
  when 2
  spell = "two"
  when 3
  spell = "three"
  when 4
  spell = "four"
  when 5
  spell = "five"
  else
  spell = nil
end
```

接下来，我们要做的就是打印出`spell`，我们在以下语句中这样做

```rb
puts "The number you entered is "+spell if spell
```

请注意，仅当`spell`包含值时才打印，否则，如果`spell`为`nil`，则不打印任何内容。 上面声明中的`if`条件要小心。

有时可能有必要针对许多条件执行同一组语句。 让我们以一个示例应用程序为例，在该应用程序中，程序确定 1 到 10（包括两者）之间的数字是奇数或偶数。 键入下面的代码（code / case_odd_even.rb [case_odd_even.rb]）并执行

```rb
# case_odd_even.rb

num = 7 # put any number from 1 to 10

case num
  when 1, 3, 5, 7, 9
    puts "#{num} is odd"
  when 2, 4, 6, 8, 10
    puts "#{num} is even"
end
```

Output

```rb
7 is odd
```

注意，在上面的程序中，我们为变量`num`分配了值 7，接下来，我们将`num`放入`case`语句中。 当数字为 1、3、5、7 和 9 时，我们需要打印其奇数，因此我们要做的只是对个案进行分组。 如果满意，则必须将其打印为`odd`，如果你按照下面的代码所示放置，就足够了

```rb
case num
  when 1, 3, 5, 7, 9
  puts "#{num} is odd"
end
```

接下来，我们只需要打印数字，即使该数字是 2、4、6、8 和 10，要做到这一点，我们要做的就是添加下面突出显示的代码

```rb
case num
  when 1, 3, 5, 7, 9
  puts "#{num} is odd"
  when 2, 4, 6, 8, 10
  puts "#{num} is even"
end
```

而已。 该代码适用于从 1 到 10 的所有数字。故事的寓意是，我们可以轻松地将案例分组并在其中执行通用代码。

### 4.11。 情况下，检查类类型

在 Ruby 中，一切都是对象。 让我们在 irb 中尝试一些例子来证明这一点

```rb
>> 1.class
=> Integer
>> "Zigor".class
=> String
```

在第一条语句中，我们查询了`1`的类/对象类型，并说其类型为`Integer`。 当被问及`“Zigor”`的类别时，它说`String`。 在 Ruby 中，你可以使用此函数来了解所使用的类型变量。 它是一个非常强大的功能。

现在看看下面的程序

```rb
# case_when_checking_class_type.rb
a = "Zigor"
case a
when String
  puts "Its a string"
when Fixnum
  puts "Its a number"
end
```

Output

```rb
Its a string
```

参见上面程序中的行，我们有两个语句，例如`when String`和`when Integer`，这将检查`case a`语句中变量`a`的类型。 如果变量类型为`String`，它将在`when String`事物下执行语句，而当其为`Integer`时，将执行另一个语句。 由于此`a`是 String 类型的，因此我们得到了打印输出`Its a String`。

### 4.12。 情况和范围

请检查以防万一。

### 4.13。 情况以及正则表达式

Case 语句也可以匹配正则表达式。 阅读正则表达式部分以了解以下示例。

```rb
# case_when_regexp.rb

string = "I Love Ruby"
# string = "I Love Python"

case string
when /Ruby/
  puts "string contains Ruby"
else
  puts "string does not contain Ruby"
end
```

Output

```rb
string contains Ruby
```

在上面的示例中，检查语句`when /Ruby/`，它会检查表达式`/Ruby/`出现在`string`中。 在上面的示例中，它确实出现了。 因此它打印出`string contains Ruby`。

### 4.14。 情况何时和 lambdas

在 [case_odd_even.rb](code/case_odd_even.rb) 中，当我们尝试检查数字是否为奇数或偶数时，我们给出了一个冗长的程序，其范围限制为 1 到 10 之间的数字。 我们可以编写如下所示的相同程序

```rb
# case_odd_even_lambda.rb

num = 76

case num
when -> (n) { n % 2 == 0 }
  puts "#{num} is even"
else
  puts "#{num} is odd"
end
```

Output

```rb
76 is even
```

要理解以上示例，你必须先阅读 Proc，Lambda 和 Blocks。 观看代码`when → (n) { n % 2 == 0 }`，在其中将一个 lambda 传递给`when`，当调用该代码时，它将为`n`的值 76 或任何偶数返回`true`，如果`n`为奇数则返回`false` 。 因此，与以前的奇偶程序不同，它适用于从零到无限的所有自然数。

### 4.15。 case 和 matcher 类的情况

要了解下面的程序，你需要阅读===并检查案例类型时的大小写。 在下面输入程序并执行

```rb
# case_when_matcher_classes.rb

class Zigor
  def self.===(string)
    string.downcase == "zigor"
  end
end

name = "Zigor"

case name
when Zigor
  puts "Nice to meet you Zigor!!!"
else
  puts "Who are you?"
end
```

Output

```rb
Nice to meet you Zigor!!!
```

考虑这一部分

```rb
case name
when Zigor
  puts "Nice to meet you Zigor!!!"
else
  puts "Who are you?"
end
```

`case`语句检查`name`并查看其实例类型是否为`Zigor`。 嗯，这并不奇怪吗？ 怎么可能 属于`String`类的一个实例如何变为`Zigor`类的一个实例？ 好吧，情况是什么，它调用了`Zigor`类中的`===`方法，其定义可以在 &lt;sup class="footnote"&gt;[ [14](#_footnotedef_14 "View footnote.") ]&lt;/sup&gt; 下看到。

```rb
def self.===(string)
  string.downcase == "zigor"
end
```

在这里我们定义`self.===`，在其中接受一个参数字符串，在这里传递给`case`的`name`被复制到`string`，并检查`string`的`downcase`是否等于`“zigor”` 在`string.downcase == "zigor"`中，如果是，则返回`true`，否则返回`false`。 如果`true`被执行，当 when Zigor 块中的代码被执行时，我们得到输出`Nice to meet you Zigor!!!`。 将名称更改为其他值，然后看看会发生什么。

如果你现在不了解此章节，请不要担心。 在完成本书的复习之后，你可能会更好地理解它。

### 4.16。 ？ ：

`? :`被称为三元运算符。 它可以用作简单的`if`。 请执行以下所示的程序。 专心`max = a &gt; b ? a : b`

```rb
# max_of_nums.rb

a,b = 3,5
max = a > b  ? a : b
p "max = "+max.to_s
```

执行后，程序给出以下输出

```rb
"max = 5"
```

？：的工作原理如下。 它的语法是这样的

```rb
<evaluate something > ? <if true take this thing> : <if false take this thing>
```

你在问号之前给出一个表达式。 该表达式必须返回`true`或`false`。 如果表达式返回 true，则`it`返回`?`和`:`之间的内容；如果`false`，则返回`:`之后的内容。

在表达中

```rb
max = a > b  ? a : b
```

我们可以如下替换`a`和`b`的值

```rb
max = 3 > 5  ? 3 : 5
```

3 不大于 5，因此其`false`。 因此，将`:`之后的值分配给`max`。 因此，`max`变为 5。

### 4.17。 将逻辑语句分配给变量

不管你是否注意到了天气，在前面的示例 [max_of_nums.rb](code/max_of_nums.rb) 中，我们使用了这样的语句

```rb
max = a > b  ? a : b
```

这里`a &gt; b`是逻辑，如果它的`true`它将返回`a`，该`a`被分配给`max`，或者它返回`b`，其被分配给`max`。

现在相同的程序可以编写如下

```rb
# max_of_nums_with_if.rb

a, b = 3, 5
max = if a > b
  a
else
  b
end
p "max = " + max.to_s
```

Output

```rb
"max = 5"
```

此处将变量`max`分配给`if`条件。 因此，如果`a`大于`b`，则会将`a`放入`max`，否则会将`b`放入`max`。 就如此容易。

现在还有另一件事。 如果`if`或`else`下还有其他语句怎么办？ 由于在此代码块中

```rb
max = if a > b
  a
else
  b
end
```

在`if`块下只有一个语句`a`，在`else`块下我们只有`b`，所以它很简单。 现在让我们尝试下面给出的示例

```rb
# max_of_nums_with_if_many_statements.rb

a,b = 3,5
max = if a > b
  a + b
  a
else
  a - b
  b
end
p "max = "+max.to_s
```

运行上面的程序，这就是你得到的

```rb
"max = 5"
```

那么要推断什么呢？ 规则是这样的，如果你在一个块中给出许多语句并将其分配给一个变量，则最后一条语句的输出将被返回并将被放入变量 &lt;sup class="footnote"&gt;[ [15](#_footnotedef_15 "View footnote.") ]&lt;/sup&gt; （在这种情况下为最大值）。

这是另一个程序， [case_when.rb](code/case_when.rb) 的分支，我想你知道它现在如何工作

```rb
# case_when_2.rb
# This program spells from one to five

print "Enter a number (1-5):"
a = gets.to_i
spell = String.new

spell = case a
  when 1
    "one"
  when 2
    "two"
  when 3
    "three"
  when 4
    "four"
  when 5
    "five"
  else
    nil
end

puts "The number you entered is " + spell if spell
```

运行并亲自查看。