opérateurs Ruby

Ruby opérateurs arithmétiques

Supposons que la variable d'une valeur de 10, la valeur de b variable de 20, puis:

comparaison Ruby

Supposons que la variable d'une valeur de 10, la valeur de b variable de 20, puis:

Ruby opérateur d'affectation

Supposons que la variable d'une valeur de 10, la valeur de b variable de 20, puis:

Ruby cession parallèle

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

a = 10
b = 20
c = 30

Utilisation de l'affectation parallèle plus rapide Avertissement:

a, b, c = 10, 20, 30

Affectation parallèle lors de l'échange des valeurs de deux variables sont également utiles:

a, b = b, c

Opérateurs sur les bits Ruby

Opérateurs binaires agissant sur le bit et bit par opération binaire.

Si supposé que a = 60, b = 13, maintenant dans un format binaire, qui est le suivant:

a = 0011 1100

b = 0000 1101

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

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ A = 1100 0011

Le tableau suivant indique le Ruby supporte les opérateurs de bits.

opérateurs logiques Ruby

Le tableau suivant indique le Ruby supporte les opérateurs logiques.

Supposons que la variable d'une valeur de 10, la valeur de b variable de 20, puis:

Ruby opérateur ternaire

Il y a plus d'une action est appelée opérateur ternaire. La première valeur de calcul de la vérité de l'expression, puis a décidé de mettre en œuvre deux derrière dans une déclaration sur la base du résultat. Opérateur conditionnel a la syntaxe suivante:

opérateur de gamme Ruby

Dans Ruby, la séquence est utilisée pour créer une série de valeur de plage consécutive - contient la valeur de départ, la valeur finale (sous réserve de disponibilité) et les valeurs entre elles.

Dans Ruby, ces séquences est l'utilisation de ".." et "..." les opérateurs de gamme pour créer. Range contient deux formes créent des valeurs de début et de fin, la gamme de trois pour créer un formulaire qui ne contient que la valeur finale de la valeur de départ ne sont pas inclus.

Ruby défini? Opérateur

défini? est un opérateur spécial, que ce soit sous la forme d'un appel de méthode pour passer l'expression du jugement est défini. Elle renvoie la chaîne expression de description, si l'expression est undefined retournenil.

Voici les différents opérateurs définis utilisation ?:

Utilisation 1

défini? variable # Si la variable a été initialisée vrai,

Par exemple:

foo = 42
défini? foo # => "local-variable"
défini? $ _ # => "global-variable"
défini? bar # => nil (undefined)

Utilisation 2

défini? method_call # Si la méthode a été définie, True

Par exemple:

défini? met # "méthode" =>
puts définis? (bar) # => nil (undefined ici bar)
défini? déballer # => nil (undefined ici)

Utilisation 3

# Si la méthode peut être invoquée en tant que super utilisateur existe donc vrai
défini? Super

Par exemple:

défini? Super # => "super" (si on peut appeler)
défini? Super # => nil (si pas être invoquée)

Utilisation 4

défini? céder # Si le bloc de code adopté Vrai,

Par exemple:

défini? rendement # => "rendement" (si le bloc de transfert)
défini? céder # => nil (si pas passer le bloc)

Ruby dot opérateur "." Et l'opérateur double colon "::"

Vous pouvez ajouter le nom du module et de souligner d'appeler une méthode de module avant le nom de la méthode. Vous pouvez utiliser le nom du module et deux deux-points pour faire référence à une constante.

:: Est un opérateur unaire, permettant des constantes, des méthodes d'instance et les méthodes de classe définies dans la classe ou le module qui peut être consulté partout dans la classe ou le module de l'extérieur.

Rappelez - vous:Dans Ruby, classes et méthodes peuvent également être utilisés comme une constante.

Vous avez seulement besoin d'ajouter avant le nom de l'expression:: préfixe constant, pour revenir à l'objet de classe ou module approprié.

Si l'expression de préfixe est pas utilisé, la classe principale de l'objet par défaut.

Voici deux exemples:

MR_COUNT = 0 # classe Object défini dans les principales constantes Module Foo
  MR_COUNT = 0
  :: MR_COUNT = 1 # pour définir le nombre global 1
  MR_COUNT = 2 # définir le nombre local 2
fin
met MR_COUNT # Ceci est une constante globale met Foo :: MR_COUNT # Qu'est-ce que "Foo" constantes locales 

Deuxième exemple:

CONST = 'là-bas'
classe Inside_one
   CONST = proc { 'y'}
   def where_is_my_CONST
      :: CONST + 'une à l'intérieur'
   fin
fin
classe Inside_two
   CONST = 'intérieur de deux'
   def where_is_my_CONST
      CONST
   fin
fin
met Inside_one.new.where_is_my_CONST
met Inside_two.new.where_is_my_CONST
met Object :: CONST + Inside_two :: CONST
met Inside_two :: CONST + CONST
met Inside_one :: CONST
met Inside_one :: CONST.call + Inside_two :: CONST

Ruby priorité des opérateurs

Le tableau suivant Sur la base de l'opérateur de priorité répertorie tous les opérateurs.

Remarque: La colonneestidentifiée comme étant la méthode de l' opérateur est en fait une méthode, il peut être surchargé.