Ruby 操作符

操作符是一个符号，代表了对一个或多个操作数进行的操作。操作符是任何编程语言的基础。操作符允许我们对操作数进行不同类型的操作。在Ruby中使用的不同类型的运算符如下：

算术运算符

这些运算符用于对操作数进行算术/数学运算。

加法（+）： 运算符将两个操作数相加。例如， x+y
减法（-）： 运算符减去两个操作数。例如， x-y
乘法（*）： 运算符将两个操作数相乘。例如， **x*y **
除法(/)： 运算符将第一个操作数除以第二个操作数。例如， x/y
模数(%)： 当第一个操作数除以第二个操作数时，运算符返回余数。例如， x%y
指数(**)： 操作者返回操作数的指数（幂）。例如，x**y

示例：

# Ruby program to demonstrate
# the Arithmetic Operators
 
# Addition
puts ("Addition:")
puts (10 + 20)
 
# Subtraction
puts ("Subtraction:")
puts (40 - 20)
 
# Division
puts ("Division:")
puts (100 / 20)
 
# Multiplication
puts ("Multiplication:")
puts (10 * 20)
 
# Modulus
puts ("Modulus:")
puts (20 % 7)
 
# Exponent
puts ("Exponent:")
puts (2 ** 4)

输出：

Addition:
30
Subtraction:
20
Division:
5
Multiplication:
200
Modulus:
6
Exponent:
16

比较运算符

比较运算符或关系运算符用于两个值的比较。让我们逐一来看看：

Equal To(==) 运算符检查两个给定的操作数是否相等。如果是，它返回真。否则，它将返回错误。例如， 5==5 将返回真。
不等于(!=) 操作符检查两个给定的操作数是否相等。如果不是，它返回真。否则返回false。它是’ ==’ 运算符的精确布尔值补充。例如， 5！=5 将返回false。
大于（ >）运算符检查第一个操作数是否大于第二个操作数。如果是这样，它返回真。否则返回false。例如， **6 >5 **将返回true。
小于（ <）运算符检查第一个操作数是否小于第二个操作数。如果是，则返回真。否则返回false。例如， **6 <5 **将返回false。
**Greater Than Equal To( >=) **操作符检查第一个操作数是否大于或等于第二个操作数。如果是，它返回真。否则它返回false。例如， **5 >=5 **将返回true。
**Less Than Equal To( <=) **操作符检查第一个操作数是否小于或等于第二个操作数。如果是，它返回真。否则返回false。例如， **5 <=5 **也会返回真。
组合运算符 **（ <=>） **当第一操作数等于第二操作数时返回0，当第一操作数大于第二操作数时返回1，当第一操作数小于第二操作数时返回-1。
Case Equality Operator(===) 它将测试case语句中的平等性。
‘.eql?’ 如果接收器和参数的类型相同且数值相等，该操作符返回真。
‘. Equal? ‘ 如果接收方和参数有相同的对象ID，该操作符返回true。

例如：

# Ruby program to demonstrate
# the Comparison Operators
  
puts "Equal To Operator:"
puts (10 == 20)
  
puts "Not Equal To Operator:"
puts (40 != 20)
  
puts "Greater than Operator"
puts (100 > 20)
  
puts "Less than Operator"
puts (10  < 20)
  
puts "Less than Equal To Operator"
puts (2  <=  5)
 
puts "Greater than Equal To Operator"
puts (2  >=  5)
  
puts "Combined combination operator"
puts(20 <=> 20)
puts(10 <=> 20)
puts(20 <=> 10)

输出：

Equal To Operator:
false
Not Equal To Operator:
true
Greater than Operator
true
Less than Operator
true
Less than Equal To Operator
true
Greater than Equal To Operator
false
Combined combination operator
0
-1
1

逻辑运算符

它们被用来结合两个或更多的条件/约束，或补充考虑原始条件的评估。它们描述如下：

**逻辑AND( &&) **运算符在考虑的两个条件都满足时返回真。否则，它返回假。使用 “和 “ 是&&运算符的一种替代方法。例如，当a和b都为真（即非零）时， **a && b **返回真。
逻辑OR(||) 运算符在其中一个（或两个）条件得到满足时返回真。否则就会返回错误。使用 “或 “ 是||运算符的一种替代方法。例如， a||b 如果a或b中有一个是真的（即非零），则返回真。当然，当a和b都为真时，它返回真。
逻辑NOT(!)： 操作符在所考虑的条件不满足时返回真。否则，它返回假。使用 “not “ 是！操作符的一种替代方法。例如， !”真 “返回 “假”。

示例：

# Ruby program to demonstrate
# the Logical Operators
  
# Variables
a = 10
b = 20
c = 30
 
# using && operator
if a == 10 && b == 20 && c == 30
    puts "Logical AND Operator"
    puts result = a * b * c
end
 
# using || operator
puts "Logical OR operator"
if a == 10 || b == 20
    puts result = a + b + c
end
 
# using ! operator
puts "Logical Not Operator"
puts !(true)

输出：

Logical AND Operator
6000
Logical OR operator
60
Logical Not Operator
false

赋值运算符

赋值运算符用于将一个值赋给一个变量。赋值运算符的左边操作数是一个变量，赋值运算符的右边操作数是一个值。右边的值必须与左边的变量具有相同的数据类型，否则编译器会产生错误。
不同类型的赋值运算符如下所示：

简单赋值（=） ：运算符是最简单的赋值运算符。该运算符用于将右边的值赋给左边的变量。
加和赋值（+=） 运算符用于将左边的操作数与右边的操作数相加，然后将其赋给左边的变量。
减法和赋值（-=） 运算符用于将左边的操作数与右边的操作数相减，然后将其分配给左边的变量。
乘法和赋值（*=） 运算符用于将左操作数与右操作数相乘，然后将其分配给左边的变量。
Divide AND Assignment (/=) 操作符用于将左边的操作数与右边的操作数相除，然后将其分配给左边的变量。
Modulus AND Assignment (%=) 操作符用于将左边的操作数与右边的操作数进行模数分配，然后将其分配给左边的变量。
指数与赋值(=)** 运算符用于将左操作数的幂提高到右操作数，并将其赋给左边的变量。

例如：

# Ruby program to demonstrate
# the Assignments Operators
  
puts "Simple assignment operator"
puts a = 20
 
puts "Add AND assignment operator"
puts a += 10
 
puts "Subtract AND assignment operator"
puts a -= 5
 
puts "Multiply AND assignment operator"
puts a *= 10
 
puts "Divide AND assignment operator"
puts a /= 4
 
puts "Modulus AND assignment operator"
puts a %= 3
 
puts "Exponent AND assignment operator"
puts a **= 3

输出：

Simple assignment operator
20
Add AND assignment operator
30
Subtract AND assignment operator
25
Multiply AND assignment operator
250
Divide AND assignment operator
62
Modulus AND assignment operator
2
Exponent AND assignment operator
8

位操作符

在Ruby中，有6个位操作符，它们在位级工作或用于执行逐位操作。以下是分位运算符：

**Bitwise AND ( &) **以两个数字为操作数，对两个数字的每一个位进行AND。只有当两个比特都是1时，AND的结果才是1。
Bitwise OR (|) 以两个数字为操作数，对两个数字的每一个位进行OR操作。OR的结果是1，任何两个位都是1。
Bitwise XOR (^) 以两个数字为操作数，对两个数字的每一个位进行XOR。如果两个比特不同，XOR的结果是1。
**左移 ( << **) 以两个数字为操作数，对第一个操作数的位进行左移，第二个操作数决定移位的数量。
**右移 ( >> **) 取两个数字，右移第一个操作数的位，第二个操作数决定要移的位数。
单一补数 (~) 该操作符取一个数字，用于执行8位的补数操作。

例如：

# Ruby program to demonstrate
# the Bitwise Operators
 
# variables
a = 10
b = 20
 
puts "Bitwise AND operator"
puts (a & b)
 
puts "Bitwise OR operator"
puts (a |b)
 
puts "Bitwise XOR operator"
puts (a ^ b)
 
puts "Bitwise Complement operator"
puts (~a)
 
puts "Binary right shift operator"
puts (a >> 2)
 
puts "Binary left shift operator"
puts (a << 2)

输出：

Bitwise AND operator
0
Bitwise OR operator
30
Bitwise XOR operator
30
Bitwise Complement operator
-11
Binary right shift operator
2
Binary left shift operator
40

三元运算符

这是一个条件运算符，是if-else语句的简写版本。它有三个操作数，因此被称为三元操作数。它将根据布尔表达式的值返回两个值中的一个。

语法：

condition ? first_expression : second_expression;

解释：

condition: 它被评估为真或假。

如果该条件为真
first_expression被评估并成为结果。

如果条件是假的。
第二个表达式被评估并成为结果。

例如：

# Ruby program to demonstrate
# the Ternary Operator
 
# variable
marks_obtained = 100
 
# using ternary operator
result = marks_obtained > 40 ? 'Pass' : 'Fail'
 
# displaying output
puts result

输出：

Pass

范围操作符

在Ruby中，范围操作符被用来创建指定元素的指定序列范围。在Ruby中，有两个范围操作符，如下：

双点（…） 运算符用于创建一个指定的序列范围，其中开始和结束的元素都将被包含。例如，7 … 10将创建一个像7，8，9，10的序列。
三点（…）运算符用于创建一个指定的序列范围，其中只有起始元素是包含的，而结束元素是排斥的。例如，7 … 10将创建一个像7，8，9的序列。

例如：

# Ruby program to demonstrate
# the Range Operator
 
# Array value separator
$, =", " 
 
# using .. Operator
range_op = (7 .. 10).to_a
 
# displaying result
puts "#{range_op}"
 
# using ... Operator
range_op1 = (7 ... 10).to_a
 
# displaying result
puts "#{range_op1}"

输出：

[7, 8, 9, 10]
[7, 8, 9]

defined? 操作符

defined? 操作符是一个特殊的操作符，用于检查传递的表达式是否被定义。如果传递的参数没有被定义，它返回 nil ，否则，它返回定义该参数的字符串。

语法：

defined? expression_to_be_checked

例如：

# Ruby program to demonstrate
# the defined? Operator
 
# variables
GFG =  1
Geeks = 70
 
 
puts ("define? Operator Results")
 
# using defined? Operator
# it returns constant
puts defined? GFG       
 
# it returns constant
puts defined? Geeks
 
# it returns expression
puts defined? a 
        
# it returns expression
puts defined? 50

输出：

define? Operator Results
constant
constant

expression

点”. “和双冒号”::”操作符

点(.) 操作符用于访问一个类的方法。
双冒号（::） 操作符用于访问一个类或模块中定义的常量、类方法和实例方法到类或模块之外的任何地方。需要记住的一点是，在Ruby中，类和方法可以被认为是常量，同时在: : Const_name前加上表达式，返回相应的类对象。如果没有使用前缀表达式，那么默认情况下，将使用主对象类。

例如：

# Ruby program to demonstrate
# Dot “.” and Double Colon
# “::” Operators
 
# defined constant on main Object class
CONS = 5  
 
# define module
module Geeks
     
   CONS = 5
    
   # set global CONS to 7
   ::CONS = 7  
    
    # set local CONS to 10
   CONS = 10   
end
 
# displaying global CONS value
puts CONS    
 
# displaying local "Geeks" CONS value
# using :: operator
puts Geeks::CONS  
 
class Gfg
    def Geeks2
        puts "Dot Operator"
    end
end
 
# calling Geeks2 module using
# Dot(.) operator
puts Gfg.new.Geeks2

输出：

7
10
Dot Operator

main.rb:14: warning: already initialized constant CONS
main.rb:6: warning: previous definition of CONS was here
main.rb:17: warning: already initialized constant Geeks::CONS
main.rb:11: warning: previous definition of CONS was here