Ruby 操作符

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

Python教程

Java教程

Web教程

数据库教程

图形图像教程

大数据教程

开发工具教程

计算机教程