Retour au sommaire du support de cours

Aide mémoire tiré de Why's Poignant Guide To Ruby

1. Instructions de bloc

Itérations :

5.times { print "Odelay!" }

['toast', 'fromage', 'vin'].each { |nourriture| print nourriture.capitalize }

Expressions conditionnelles :

exit unless "restaurant".include? "aura"

2. Éléments du langage

Variables

Tout mot simple, en minuscules est une Variable. Les Variables peuvent être constituées de lettres, chiffres et tirets soulignés.

x, y, banane2 ou appelle_un_ami sont des exemples.

Affectation :

teddy_bear_fee = 121.08

Addition :

total = orphan_fee + teddy_bear_fee + gratuity

Nombres

Le type de nombre le plus simple est un integer, une serie de chiffres qui peut commencer par un signe plus ou moins.

1, 23, et -10000 sont des exemples.

Les virgules ne sont pas permises dans les nombres, mais les tiret souslignés le sont.

population = 12_000_000_000

Les Nombres Décimaux sont appelés floats. Ils sont constitués de nombres avec une partie décimale ou une notation scientifique.

3.14, -808.08 et 12.043e-04 sont des exemples.

Chaînes

Les Chaînes sont toute sorte de caractères (lettres, chiffres, ponctuations) entourés par des quotes. Simple et double quotes sont utilisées pour creer des chînes.

"aquarium", '2021', ou "Ces BDs sont hilarantes!" sont des exemples.

Symboles

Les symboles ressemblent à des variables. A nouveau, ils peuvent contenir des lettres, chiffres, ou tirets-soulignés. Mais ils commencent par deux points.

:a, :b, ou :olive_et_tom sont des exemples.

Les Symboles sont des chaînes légères. Habituellement, ils sont utilisés dans des situations ou vous avez besoin d'une chaîne mais sans l'imprimer à l'écran.

Constantes

Les Constantes sont des mots commes les variables, mais les constantes commencent par une Majuscule.

Temps, Tableau ou Bugs_Bunny_a_Disparu sont des exemples.

Les constantes ne peuvent pas être changées après avoir été fixées.

EmpireStateBuilding = "350 5th Avenue, NYC, NY"

Si nous essayons de changer la constante, Ruby nous le fera remarquer.

Méthodes

Si les variables et les constantes sont les noms, alors les Méthodes sont les verbes. Les Méthodes sont habituellement attachées à la fin des variables et constants par un point.

porte_de_devant.ouvrir

Dans certains cas, vous verez des actions chaînées ensemble :

porte_de_devant.ouvrir.fermer

Nous avons demandé à l'ordinateur d'ouvrir la porte de devant puis de la fermer immédiatement.

porte_de_devant.est_ouverte?

C'est une action aussi. Nous demandons à l'ordinateur de voir si elle est ouverte. La méthode pourrait s'appeller Porte.tester_pour_voir_si_elle_est_ouverte, mais le nom est_ouverte? est succinct et tout à fait correct. Point d'exclamation et point d'interrogation peuvent être utilisés tous les deux dans les noms de méthode.

Arguments de Méthode

Une méthode peut avoir besoin de plus d' informations pour executer son action.

Les arguments de méthode sont attachés à la fin de la méthode. Les arguments sont habituellement entourés par des parenthèses et separés par des virgules.

porte_de_devant.peindre( 3, :rouge )

Pour peindre la porte de devant avec trois couches de rouge.

Les méthodes avec des arguments peuvent être chaînées.

porte_de_devant.peindre( 3, :rouge ).secher( 30 ).fermer()

Pour peindre la porte, la faire sécher 30 minutes, puis la fermer.

Bien que la dernière méthode n'aie pas d'argument, vous pouvez toujours mettre des parenthèses si vous voulez. Elles sont normallement retirées.

Certaines méthodes (comme print) sont des méthodes du noyau. Ces méthodes sont utilisées partout dans Ruby. Parcequ'elles sont vraiment communes, vous n'aurez pas à utiliser le point en préfixe.

print "Vous voyez, pas de point avant!"

Méthodes de Classe

Comme les méthodes décrites plus haut (aussi appellées méthodes d'instance), les méthodes de classe sont habituellement attachées après des variables et constantes. Plutôt qu'un point, un double deux points est utilisé.

Porte::new( :chene )

Comme vu ci-dessus, la méthode new est le plus souvent utilisée pour créer des choses.

Variables Globales

Les variables qui commencent par un signe dollar sont globales.

$x, $1, $croquant et $DElicieux_bACOn sont des exemples.

La plupart des variables sont plutôt temporaires par nature. Avec les variables globales, vous pouvez être garanti que la variable est la même dans chaque partie du code.

Les variables globales peuvent être utilisées partout dans votre programme. Elles ne sont jamais perdue de vue.

Variables d'Instance

Les variables qui commencent avec un symbole arobase sont des variables d'instance.

@x, @y, et @le_dernier_nanar_que_J_ai_vu sont des exemples.

Ces variables sont souvent utilisées pour définir les attributs de quelquechose. Par exemple, vous pourriez fournir à Ruby la largeur de la porte_de_devant en fixant la variable @largeur dans cette porte_de_devant. Les variables d'instance sont utilisées pour définir les caracteristiques d'un object particulier en Ruby.

Pensez au symbole arobase comme voulant dire attribut.

Variables de classe

Les Variables commençant par un symbole double arobase sont des variables de classe.

@@x, @@y, et @@les_nanars_a_ne_jamais_voir sont des exemples.

Les variables de classe, aussi, sont utilisées pour définir des attributs. Mais plutôt que de définir un attribut pour un seul object dans Ruby, les variables de classe donnent un attribut à plein d'objets apparentés dans Ruby. Si les variables d'instance fixent des attributs pour une unique porte_de_devant, alors les variables de classe fixent les attributs pour tout ce qui est une Porte.

Pensez au préfixe double arobase comme voulant dire attribut all. Vous changez une variable de classe alors pas seulement une change, elles changent toutes.

Blocs

Tout code entouré par des accolades est un bloc.

2.times { print "Oui, Je parle de nanars dans cet Aide Mémoire, et je le re-fais!" } est un exemple.

Avec les blocs, vous pouvez grouper un ensemble d'instructions ensemble afin qu'elles puissent être transmises à votre programme. Quand vous voyez ces accolades, souvenez-vous que le code à l'intérieur à été regroupé en une unité unique.

Les accolades peuvent être remplacées par les mots do et end, ce qui est bien si votre bloc est plus long qu'une ligne.

Arguments de bloc

Les arguments de bloc sont un ensemble de variables entourées par des caractères pipe et séparatés par des virgules.

|x|, |x,y|, et |haut, bas, dans_toutes_les_directions| sont des exemples.

Les arguments de bloc sont utilisés au début d'un bloc.

{ |x,y| x + y }

Dans l'exemple ci-dessus, |x,y| sont les arguments. Après les arguments, nous avons un morceau de code. L'expression x + y ajoute les arguments ensemble.

Ces arguments sont comme dans un couloir entre les blocs et le monde autour d'eux.

Les variables sont passées à travers ce tunnel à l'intérieur du bloc.

Intervalles

Un intervalle est deux valeurs entourées par des parenthèses et separées par une ellipse (ayant la forme de deux ou trois points).

(1..3) est un intervalle, representant les nombres de 1 à 3.

('a'..'z') est un intervalle, representant un alphabet minuscule.

Normallement, seulement deux points sont utilisés. Si un troisiéme point est utilisé, la dernière valeur de l'intervalle est exclue.

(0...5) représente les nombres de 0 à 4.

Tableaux

Un tableau est une liste entourée par des crochets et séparée par des virgules.

[1, 2, 4] est un tableau de nombres.

['manteau', 'mitaines', 'snowboard'] est un tableau de chaînes.

Oui, un tableau est une collection de choses, mais il garde aussi ces choses dans un ordre spécifique.

Tableaux associatifs

Un tableau associatif est un dictionaire entouré par des accolades. Les dictionnaires mettent en relation des mots avec leurs définitions. En Ruby l'association se fait avec des flèches composées d'un signe égal, suivi d'un signe supérieur.

{'l' => 'lydie', 's' => 'sophie'} est un exemple.

Je ne compare pas les tableaux associatifs aux dictionnaires parceque l'on ne peut stocker que des définitions dans un tableau associatif. Dans l'exemple ci-dessus, j'ai stocké des informations personnelles pour Peter, le dresseur de lion avec une grande passion pour la flanelle. Les tableaux associatifs sont comme les dictionnaires parecequ'il est très facile de chercher dedans.

Contrairement aux tableaux, les éléments dans un tableau associatif ne sont pas gardés dans un ordre spécifique.

Expressions Régulières

Une expression régulière (ou regexp) est un ensemble de caractères entouré par des barres de division.

/ruby/, /[0-9]+/ et /^\d{3}-\d{3}-\d{4}/ sont des exemples.

Les expressions régulières sont utilisées pour trouver des mots ou motifs dans un texte.

Operateurs

Vous utiliserez la liste suivante des opérateurs pour faire des maths dans Ruby ou pour comparer des choses. Parcourez la liste, reconnaissez-en quelques uns. Vous savez, addition + soustraction - et ainsi de suite.

Mots-clés

JBA: TRADUCTION A TERMINER

Ruby has a number of built-in words, imbued with meaning. These words cannot be used as variables or changed to suit your purposes. Some of these we’ve already discussed. They are in the safe house, my friend. You touch these and you’ll be served an official syntax error.

Good enough. These are the illustrious members of the Ruby language. We’ll be having quite the junket for the next three chapters, gluing these parts together into sly bits of (poignant) code.

I’d recommend skimming all of the parts of speech once again. Give yourself a broad view of them. I’ll be testing your metal in the next section.

Out in the pickup truck.

3. If I Haven't Treated You Like a Child Enough Already

I’m proud of you. Anyone will tell you how much I brag about you. How I go on and on about this great anonymous person out there who scrolls and reads and scrolls and reads. “These kids,” I tell them. “Man, these kids got heart. I never…” And I can’t even finish a sentence because I’m absolutely blubbering.

And my heart glows bright red under my filmy, translucent skin and they have to administer 10cc of JavaScript to get me to come back. (I respond well to toxins in the blood.) Man, that stuff will kick the peaches right out your gills!

So, yes. You’ve kept up nicely. But now I must begin to be a brutal schoolmaster. I need to start seeing good marks from you. So far, you’ve done nothing but move your eyes around a lot. Okay, sure, you did some exceptional reading aloud earlier. Now we need some comprehension skills here, Smotchkkiss.

Say aloud each of the parts of speech used below.

5.times { print "Odelay!" }

You might want to even cover this paragraph up while you read, because your eyes might want to sneak to the answer. We have a number 5, followed by a method .times. Then, the first crab pincers of a block. The kernel method print has no dot and is followed by a string "Odelay!". The final crab pincers close our block.

Say aloud each of the parts of speech used below.

exit unless "restaurant".include? "aura"

Like the print method, exit is a kernel method. If you were paying attention during the big list of keywords, you’ll know that unless is just such a keyword. The string "restaurant" is clung to by the method include?. And finally, the string "aura".

Say aloud each of the parts of speech used below.

['toast', 'cheese', 'wine']. each { |food| print( food.capitalize ) }

This caterpillar partakes of finer delicacies. An array starts this example. In the array, three strings 'toast', 'cheese', and 'wine'. The whole array is trailed by a method each.

Inside of a block, the block argument food, travelling down its little waterslide into the block. The method capitalize then capitalizes the first letter of the block argument, which has become variable food. This capitalized string is passed to kernel method print.

Look over these examples once again. Be sure you recognize the parts of speech used. They each have a distinct look, don’t they? Take a deep breath, press firmly on your temples. Now, let’s dissect a cow’s eye worth of code.

4. An Example to Help You Grow Up

Gettin' cabin fever.

Say aloud each of the parts of speech used below.

The first line is a method call. The method called require is used. A string is passed to the method containing 'net/http'. Think of this first line of code as a sentence. We have told Ruby to load some helper code, the Net::HTTP library.

The next three lines all go together. The constant Net::HTTP refers to the library we loaded above. We are using the method start from the library. Into the method, we’re sending a string 'www.ruby-lang.org' and the number 80.

The word do opens a block. The block has one block variable http. Inside the block, the method print is called. What is being printed?

From the variable http, the method get is called. Into get, we pass a string containing the path '/en/LICENSE.txt'. Now, notice that another method is chained onto get. The method body. Then, the block closes with end.

Doing okay? Just out of curiousity, can you guess what this example does? Hopefully, you’re seeing some patterns in Ruby. If not, just shake your head vigorously while you’ve got these examples in your mind. The code should break apart into manageable pieces.

For example, this pattern is used a number of times:

variable . method ( method arguments )

You see it inside the block:

http.get( '/en/LICENSE.txt' )

We’re using Ruby to get a web page. You’ve probably used HTTP with your web browser. HTTP is the Hypertext Transfer Protocol. HTTP is used to transfer web pages across the internet. Conceptualize a bus driver that can drive across the internet and bring back web pages for us. On his hat are stitched the letters HTTP.

The variable http is that bus driver. The method is a message to the bus driver. Go get the web page called /en/LICENSE.txt.

So where you see the chain of methods:

http.get( '/en/LICENSE.txt' ).body

Since we’ll be getting back a web page from the http bus driver, you can read this in your brain as:

web page .body

And this bit of code:

print( http.get( '/en/LICENSE.txt' ).body )

This code gets the web page. We send a body message to the web page, which gives us all the HTML in a string. We then print that string. See how the basic dot-method pattern happens in a chain. The next chapter will explore all these sorts of patterns in Ruby. It’ll be good fun.

So, what does this code do? It prints the HTML for the Ruby home page to the screen. Using an web-enabled bus driver.

5. And So, The Quick Trip Came To An Eased, Cushioned Halt

Running after the truck.

So now we have a problem. I get the feeling that you are enjoying this way too much. And you haven’t even hit the chapter where I use jump-roping songs to help you learn how to parse XML!

If you’re already enjoying this, then things are really going bad. Two chapters from now you’ll be writing your own Ruby programs. In fact, it’s right about there that I’ll have you start writing your own role-playing game, your own file-sharing network (a la BitTorrent), as well as a program that will pull genuine random numbers from the Internet.

Proof has been extracted from the pudding.

And you know (you’ve got to know!) that this is going to turn into an obsession. First, you’ll completely forget to take the dog out. It’ll be standing by the screen door, darting its head about, as your eyes devour the code, as your fingers slip messages to the computer.

Thanks to your neglect, things will start to break. Your mounds of printed sheets of code will cover up your air vents. Your furnace will choke. The trash will pile-up: take-out boxes you hurriedly ordered in, junk mail you couldn’t care to dispose of. Your own uncleanliness will pollute the air. Moss will infest the rafters, the water will clog, animals will let themselves in, trees will come up through the foundations.

But your computer will be well-cared for. And you, Smotchkkiss, will have nourished it with your knowledge. In the eons you will have spent with your machine, you will have become part-CPU. And it will have become part-flesh. Your arms will flow directly into its ports. Your eyes will accept the video directly from DVI-24 pin. Your lungs will sit just above the processor, cooling it.

And just as the room is ready to force itself shut upon you, just as all the overgrowth swallows you and your machine, you will finish your script. You and the machine together will run this latest Ruby script, the product of your obsession. And the script will fire up chainsaws to trim the trees, hearths to warm and regulate the house. Builder nanites will rush from your script, reconstructing your quarters, retiling, renovating, chroming, polishing, disinfecting. Mighty androids will force your crumbling house into firm, rigid architecture. Great pillars will rise, statues chiseled. You will have dominion over this palatial estate and over the encompassing mountains and islands of your stronghold.

So I guess you’re going to be okay. Whatdya say? Let’s get moving on this script of yours?

Turn page.