Retour au sommaire du support de cours
Itérations :
5.times { print "Odelay!" }
['toast', 'fromage', 'vin'].each { |nourriture| print nourriture.capitalize }
Expressions conditionnelles :
exit unless "restaurant".include? "aura"
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
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.
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.
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.
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.
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.
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!"
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.