Opérateurs Ruby

Opérateurs arithmétiques Ruby

Hypothétiquement, la valeur de la variable a est 10La valeur de la variable b est 2Si 0, alors :

Opérateurs de comparaison Ruby

Hypothétiquement, la valeur de la variable a est 10La valeur de la variable b est 2Si 0, alors :

Opérateur d'assignation Ruby

Hypothétiquement, la valeur de la variable a est 10La valeur de la variable b est 2Si 0, alors :

Affectation parallèle Ruby

Ruby prend également en charge l'affectation parallèle des variables. Cela permet à plusieurs variables d'être initialisées en une seule ligne de code Ruby. Par exemple :

a =　10
b =　20
c =　30

L'affectation parallèle permet de déclarer plus rapidement :

a, b, c =　10,　20,　30

L'affectation parallèle est très utile pour échanger les valeurs de deux variables :

a, b = b, c

Opérateurs de bit Ruby

Les opérateurs de bit agissent sur les bits et exécutent des opérations bit par bit.

Hypothétiquement, si a = 60, et b = 13Maintenant, en format binaire, ils sont les suivants :

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

Le tableau suivant liste les opérateurs binaire pris en charge par Ruby.

Opérateurs logiques Ruby

Le tableau suivant liste les opérateurs logiques pris en charge par Ruby.

Hypothétiquement, la valeur de la variable a est 10La valeur de la variable b est 2Si 0, alors :

Ruby 三元运算符

有一个以上的操作称为三元运算符。第一个计算表达式的真假值，然后根据这个结果决定执行后边两个语句中的一个。条件运算符的语法如下：

Ruby 范围运算符

在 Ruby 中，序列范围用于创建一系列连续的值 - 包含起始值、结束值（视情况而定）和它们之间的值。

在 Ruby 中，这些序列是使用 ".." 和 "..." 范围运算符来创建的。两点形式创建的范围包含起始值和结束值，三点形式创建的范围只包含起始值不包含结束值。

Ruby defined? 运算符

defined? 是一个特殊的运算符，以方法调用的形式来判断传递的表达式是否已定义。它返回表达式的描述字符串，如果表达式未定义则返回 nil。

下面是 defined? 运算符的各种用法：

用法 1

defined?　variable　#　如果　variable　已经初始化，则为　True

例如：

foo　=　42
defined?　foo　　#　=>　"local"-variable"
defined?　$_　　#　=>　"global"-variable"
defined?　bar　　#　=>　nil（未定义）

用法 2

defined?　method_call　#　如果方法已经定义，则为　True

例如：

defined?　puts　　#　=>　"method"
defined?　puts(bar)　　#　=>　nil（在这里　bar　未定义）
defined?　unpack　　#　=>　nil（在这里未定义）

用法 3

#　如果存在可被　super　用户调用的方法，则为　True
defined?　super

例如：

defined?　super　　#　=>　"super"（如果可被调用）
defined?　super　　#　=>　nil（如果不可被调用）

用法 4

defined?　yield　　#　如果已传递代码块，则为　True

例如：

defined?　yield　　#　=>　"yield"（如果已传递块）
defined?　yield　　　　#　=>　nil（si aucun bloc n'est passé）

Opérateur point Ruby "." et opérateur double deux-points "::"

Vous pouvez appeler une méthode de la classe ou du module en ajoutant le nom de la classe ou du module et . devant le nom de la méthode. Vous pouvez utiliser le nom de la classe ou du module et deux deux-points :: pour faire référence à une constante de la classe ou du module.

:: 　est un opérateur unaire, qui permet de définir des constantes, des exemples de méthodes et des méthodes de classe à l'intérieur d'une classe ou d'un module, et peut être accédé à partir de n'importe où à l'extérieur de la classe ou du module.

Rappelez-vous :Dans Ruby, les classes et les méthodes peuvent également être utilisées comme des constantes.

Vous n'avez qu'à ajouter le nom du constant avant l'expression. :: Préfixe, vous pouvez retourner l'objet approprié de la classe ou du module.

Si l'expression avant :: est un nom de classe ou de module, elle renvoie la valeur correspondante de la classe ou du module ; si il n'y a pas d'expression précédente, elle renvoie la valeur de la classe principale Object. 。

Voici deux exemples :

MR_COUNT　=　0　　　　　　　　#　Défini dans la classe principale Object
module　Foo
　　MR_COUNT　=　0
　　::MR_COUNT　=　1　　　　#　Définir le compteur global　1
　　MR_COUNT　=　2　　　　　　#　Définir le compteur local　2
end
puts　MR_COUNT　　　　　　　　#　C'est　constant globale
puts　Foo::MR_COUNT　　#　C'est　"Foo"　constant locale

Deuxième exemple :

CONST　=　'　out　there'
class　Inside_one
　　　CONST　=　proc　{'　in　there'}
　　　def　where_is_my_CONST
　　　　　　::CONST　+　'　inside　one'
　　　end
end
class　Inside_two
　　　CONST　=　'　inside　two'
　　　def　where_is_my_CONST
　　　　　　CONST
　　　end
end
puts　Inside_one.new.where_is_my_CONST
puts　Inside_two.new.where_is_my_CONST
puts　Object::CONST　+　Inside_two::CONST
puts　Inside_two::CONST　+　CONST
puts　Inside_one::CONST
puts　Inside_one::CONST.call　+　Inside_two::CONST

Priorité des opérateurs Ruby

Le tableau suivant liste tous les opérateurs par ordre de priorité décroissant.

Attention :est identifié dans la liste des méthodes sous est Les opérateurs sont en fait des méthodes, donc ils peuvent être redéfinis.