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