Hackety Hack

Utiliser Hackety Hack est bien plus qu'une simple utilisation de Ruby. C'est un univers plein d'images et de mini-navigateurs. Du beau boulot, qui mérite une explication n'est-ce pas?

Cette page présente les bases de l'utilisation de toutes ces choses à cliquer. Le menu sur la gauche propose d'autres pages (telles que les sections Canal et Bibouilleur) qui couvrent les commandes spécifiques à H-ety H.

Hé, utilise ce menu Programme bien pratique!

!screenshot-help-progdrop.png!

Sur l'écran pricipal d'Hackety Hack, tu trouve une liste de tes programmes sauvegardés. Au menu de chaque programme, tu pourras le Lancer, le Partager ou lEffacer'. Lancer et Partager sont les meilleurs!

• Lance le va démarrer le programme instantanement, à l'endroit où tu te trouve. C'est juste un raccourcis pratique pour le programme qui fonctionnent déjà, pour les choses que tu as déjà terminé.

• Partage le va charger le programme sur ton espace perso du site Hackety Hack.

• Efface le va supprimer le programme POUR TOUJOURS! Fais attention! (Alors que si tu as partagé ton programme, il restera disponible sur le site d'Hackety Hack.)

Oh, et les Tables en ont un, eux aussi.

!screenshot-help-tabledrop.png!

Pour les Tables, tu as un menu légérement plus court, réduit à Partage le et

Efface le.

Partager des Tables est un peu différent. Tu ne peux la partager qu'une seule fois.

!\screenshot-help-tablelink.png!

La première fois que tu partage une Table, elle est copiée dans ton espace personnel sur le site hacketyhack.net site. Après cela, le programme affiche une petit lien chainé. Ceci signifie que la table est déjà partagée.

Personnalise le

!\screenshot-help-setuplink.png!

Hackety Hack a quelques paramètres personnels à renseigner, afin de profiter pleinement de l'expérience.

Pour modifier tes préférences personnelles, clique sur l'icône de la maisonnette, dans la barre d'outils. Une fois sur la page d'accueil, cherche le liens Tes paramètres en dessous de l'image de Hacky la souris.

Oui, et bien, clique dessus.

L'écran de configuration ressemble à cela:

!screenshot-help-setup.png!

Avec seulement deux sections, il n'y a réellement pas grand chose sur cette page de configuration.

• La partie identifiant HacketyHack?.net est là pour enregistrer ton nom d'utilisateur et ton mot de passe pour le site hacketyhack.net. Si tu n'as pas de compte, [crée en un]!

• La partie HTTP Proxy n'est normallement pas nécessaire. Certaines écoles et certains espaces de travail utilise un proxu HTTP pour accèder à l'internet. Si tu es derrière un proxy, tu devras remplir ces champs sinon tout ce qui est lié à la bibliothèque Web ne fonctionnera pas pour toi!

Oh, et à propos des proxies HTTP: utilise une adresse HTTP complète. Donc, si ton proxy est proxy.com sur le port 9009, tu devras utilisé l'URL:

 http://proxy.com:9009/

Si tu proxy nécessite un identifiant et un mot de passe, ajoute le à l'URL, comme ceci:

 http://username:password@proxy.com:9009/

Méthodes par défaut

Ces méthodes peuvent être utilisées n'importe où dans les programmes Hackety Hack.

Toutes ces commandes sont inhabituelles car tu ne les attaches pas avec un point. Toutes les autres méthodes de ce manuel doivent être attachées à un objet par un point. Mais celles-ci sont fournies par défaut (aussi appelées méthode du noyau (Kernel) ou méthodes built-in.) Ce qui veux dire: pas de point!

Une commande très courante est puts:

 #!ruby

 puts "Pas de point en vue"

Compare là à la méthode reverse, qui n'est pas une méthode du Kernel et qui est disponible avec les Tableaux et les Chaînes:

 #!ruby

 "Sulfate de Calcium".reverse

   #=> "muiclaC ed etafluS"

 [:chiens, :vaches, :serpents].reverse

   #=> [:serpents, :vaches, :chiens]

ask( message )

Ouvre Pops up a window and asks a question. For example, you may want to ask someone their name.

 #!ruby

 name = ask("Saisis ton nom s'il te plaît:")

Quand le script ci-dessus est lancé, la personne assise devant l'ordinateur va voir apparaître une fenêtre avec une boîte de dialogue pour entrer son nom. Ce nom sera ensuite sauvegardé dans la variable name.

ask_color(titre: chaîne)

Fait apparaître une fenêtre avec un sélecteur de couleur. Le programme attendra qu'une couleur soit sélectionnée, puis retournera un objet Couleur. Consulte la page d'aide relative à Web.page pour les différentes façons d'utiliser cette couleur.

 #!ruby

 backcolor = ask_color("Choisis un arrière-plan")

 Web.page do

   body do

     style('background-color' => backcolor)

   end

 end

ask_open_file()

Ouvre une fenêtre "Ouvrir un fichier...". C'est la fenêtre standard qui t'affiche tous tes dossiers et te permet de sélectionner un fichier à ouvrir. Elle te renvoie le nom du fichier.

 #!ruby

 filename = ask_open_file

 puts File.read(filename)

ask_save_file()

Ouvre une fenêtre "Enregistrer un fichier..." , similaire à ask_open_file, décrite ci-dessus.

 #!ruby

 save_as = ask_save_file

exit()

Arrête ton programme. Appelle cette méthode chaque fois que tu veux lui indiquer de soudainement arrêter.

print( message, message, ... )

Écrit quelque chose sur la page du programme Hackety Hack. Chaque programme possède une page cachée sur laquelle on peut écrire. Quand le programme est terminé, cette page apparaît. Tu peux utiliser cette page pour afficher le rapport de tout ce que le programme à fait. Tu peux aussi construire une page avec des liens vers d'autres programmes ou d'autres fichiers.

 #!ruby

 print "Ce programme est terminé. À présent chacun peut rentrer chez soi."

puts( message, message, ... )

Une variante de print. La méthode print écrit les messages sur une seule longue ligne. La méthode puts, quand à elle, écrira chacuns de ces messages sur une ligne séparée.

 #!ruby

 puts "Salut.", "Bonjour.", "Il y a quelqu'un ici?"

Le code qui suit affichera chaque message sur sa propre ligne.

 Salut.

 Bonjour.

 Il y a quelqu'un ici?

p( obj, obj, ... )

La méthode p t'aide à voir le type des objets aux quels tu as à faire. Si tu as un object dans la variable stuff, tu peux utiliser p pour connaître ce qu'il y a à l'intérieur.

 #!ruby

 stuff = Web.fetch("http://feeds.feedburner.com/boingboing/iBag")

 p stuff

Dans l'exemple ci-dessous, la méthode Web.fetch est utilisée pour obtenir un flux du blog Boing Boing.

 (Web::Feed "Boing Boing")

Bien sur, il faut que la variable stuff contienne un flux défini!

say( message )

Lorsqu'un programme tourne, un petit sucrfe d'orge tourne avec un message disant "Tourne...". Si ton programme doit tourner longtemps, tu voudras peut-être changer ce message. Peut-être voudras tu informer la personne devant l'ordinateur que 50% de la tâche est déjà effectuée.

 #!ruby

 say("Ok, j'en suis à 50%.")

Une fois ton programme terminé, le message et le sucre d'orge vont disparaître.

Address

Une Addresse identifie un endroit dans le monde. Pour l'instant, c'est un peu primitif, elle utilise une simple carte Yahoo!

Les Addresses sont crées grâce à une chaîne. Pour les adresses aux États-Unis, indique la rue, la ville, et l'état. Beaucoup d'abréviations fonctionnent, alors essaie simplement et vois ce qui se passe!

 #!ruby

 motel = Address("606 E 27th, Scottsbluff, NE 69361")

 puts motel

Google Maps entre en conflit avec Hackety Hack les mauvais jours, mais j'espère que cela va s'améliorer un jour

L'objet Channel

Le "Channel" offrent aux bidouilleurs un moyen de se passer des messages. Chaque bidouilleur enregistré sur le site hacketyhack.net peut paramétrer sont propre canal.

Pour se connecter au canal central de test:

 #!ruby

 chan = Hacker('central').channel('test')

La variable chan contient à présent un objet "Channel", qui peut être utilisé pour envoyer et lire des messages.

 #!ruby

 chan.say("Y'a quelqu'un?")

Tout objet Ruby peut être envoyé par ce canal. Cela signifie qeu tu peux envoyer des images (Pictures), par exemple.

Ou une Adress.

 #!ruby

 chan.say(Picture("C:/test.jpg"))

 chan.say(Address("6 Delancey St, New York, NY 10002"))

hear()

Récupère depuis le canal tous les lessages non lus.

 #!ruby

 chan.messages().each do |message|

   puts(message)

 end

name()

Le nom de ce "channel", une chaîne de caractère.

 #!ruby

 chan = Hacker('why').channel('lobby')

 chan.name()  #=> "lobby"

owner()

Le nom du bidouilleur qui possède ce "channel".

 #!ruby

 chan = Hacker('why').channel('lobby')

 chan.owner()  #=> "why"

say( Object )

Envoi un message au canal.

 #!ruby

 chan.say("Y'a quelqu'un?")

start()

Démarre le canal, s'il na jamais été utilisé auparavant. Pour pouvoir le démarrer, il faut que ce soit sous ton identifiant Hackety Hack.

 #!ruby

 Hacker('test').channel('brandnew').start

Picture

Les objets images sont un moyen d'afficher des images stockées sur ton ordinateur.

 #!ruby

 icon = Picture("C:/my-icon.gif")

 puts icon

La classe Hacker

Les objets Hacker te permettent d'utiliser du code ou des messages avec d'autres bidouilleurs.

 #!ruby

 Hacker('why').load_program('youtube.rb')

La bibliothèque Table

Les Tables sont là pour stocker des listes de choses qui se ressemblent. Par exemple: un blog.

Les entrées de blog se ressemble: elles sont toutes un titre et un zone de saisie. Tu peux stocker une série d'entrées de blog dans une seule table.

Regarde aussi Web.popup(name), qui créer automatiquement les tables qui sont associées au fenêtres popups.

all()

Ouvre un Tableau de tous les éléments que tu as sélectionnés. Tu peux aussi utiliser each pour te déplacer parmis les élémentsto, dans l'ordre.

each() { |item| }

Pour se déplacer parmi les éléments que tu as séléctionné.

 #!ruby

 Table("Blog").recent(10).each do |entry|

   puts entry[:title]

 end

Dans cet exemple, le each illustre le fait que j'ai sélectioné les dix dernières entrées de blog, en utilisant la méthode recent.

first()

Récupère le premier élément dans la table, parmi ceux que tu as sélectionné. L'élément retourné est un dictionnaire, un hachage.

last()

Récupère le dernier élément dans la table, parmi ceux que tu as sélectionné. L'élément retourné est un dictionnaire, un hachage.

limit( un Nombre )

Réduit le nombre d'éléments que tu obtiens.

only( un Nombre )

Récupère un élément spécific d'un Table à partir de son ID.

 #!ruby

 entry = Table("Blog").only(6)

 puts entry[:title]

recent( un Nombre )

Récupère l'élément le plus récent d'une Table.

 #!ruby

 entries = Table("Blog").recent(10)

Ceci va charger les dix plus récentes entrées de la Table Blog.

La méthode recent est en fait un simple raccourcis pour utiliser conjointement order et limit:

 #!ruby

 entries = Table("Blog").order("Created DESC").limit(num)

save( un Dictionnaire )

Enregistre un seul élément dans la table.

 #!ruby

 Table("ToDo").save(:what => "Faire un curry-coco",

   :finished => false, :difficulty => 4)

L'élément doit être un dictionnaire, comme vu ci-dessus. La clé du Tableau (comme par exemple :what, :finished and :difficulty) fixe un patron pour

tous les éléments ToDo. La prochaine fois que quelque chose sera enregistré dans la table ToDo, ce modèle sera de nouveau appliqué.

 #!ruby

 id = Table("ToDo").save(:what => "Trouver des sommiers à ressorts",

        :finished => true, :difficulty => 1)

Quand tu sauvegardes avecsave, tu récupères un id, un numéro pour cet élément. Quand tu sauvegardes pour la première fois, tu récupères 1. La fois suivante, tu obtiens 2. Ce nombre est nécessaire lorsque tu utilises la méthode only.

Il existe quelques clés spéciales que tu ne peux pas sauvegarder. Ce sont:

:id, :created, and :updated. Le :id dont nous venons de parler.

La clé :created indique la date de première sauvegarde de cet élément.

La clé :updated qui est la date de la dernière mise à jour.

 #!ruby

 latest_entry = Table("ToDo").recent(1).first

 puts latest_entry[:created]

Video

Les objets Video te permettent d'afficher les vidéos enregistrées sur ta machine.

 #!ruby

 puts Video("video.flv")

Ruby

Hackety Hack ajoute tout un tas de choses bien pratique. La bibliothèque standard contient toutes les choses qui sont normalement fournies avec le langage Ruby lui même. Des choses basiques et fondamentales telles que les nombres et les listes.

Tu peux trouver un bon résumé des composants de Ruby sur l'anti-sèche d'Hackety Hack, qui apparaît lorsque

tu clique sur l'icône baguette magique de la barre d'outils.

Types spéciaux

Ruby propose trois types spéciaux: nil, true et false.

nil

Nil est unique en son genre. Littérallement, elle signifie "rien". Nil est la chose à mettre dans une variable

si tu veux vraiment que cette variable soit vide.

Beaucoup de méthodes Ruby retournent nil. La plupart du temps cela signifie "rien n'a été trouvé"

ou "non, cela ne fait rien." C'est une façon sure de ne rien retrourner,

plutôt que de rapporter une erreur (qui pourrait stopper le programme.)

 #!ruby

 list = [1, 2, "January", [3, 4, 5]]

 found = list.detect { |x| x == "February" }

  #=> nil

Dans cet exemple, nous cherchons la chaîne "February" dans la liste. Nil est retournée.

Un premier exemple de "rien n'a été trouvé."

Tu peux contrôler nil en utilisant le if.

 #!ruby

 if found

   puts "Found February!"

 end

Nil possède possède une méthode bien pratique! En effet, tout est objet en Ruby. Ceci signifie que toute chose

est utile et possède ses propres actions (appelées méthodes.)

Une méthode nil? existe pour chaque objet. Elle répond true uniquement pour l'objet nil.

 #!ruby

 if found.nil?

   puts "The `found` variable is really nil!"

 end

true et false

Les types true et false sont les yin et yang, oui et non, positif et négatif.

On utilise très souvent ces deux là avec if.

 #!ruby

 if tivo_shows.include?("Le rapport Colbert ")

   puts("Très bien, le rapport Colbert est en cours d'enregistrement")

 end

Dans l'exemple ci-dessus, nous avons une liste d'émissions de télé dans la variable tivo_shows.

Nous utilisons la méthode include? pour certaines émissions. Puisque include? nous retourne un oui ou un non

(vrai ou faux), l'utilisation d'un if est toute indiquée. Le if nous laissera continuer si l'émission

est trouvée.

Les méthodes telles que Array.detect, Hash.has_key? et File.exists? retournent toutes

vrai ou faux. Si la méthode a un point d'intérrogation à la fin, elle renvoie généralement

un vrai ou faux.

COmbine les avec un if dans ton programme.

Tableaux

Un tableau est une liste de choses. Utilise cela lorsque tu as des choses que tu

cherches à conserver dans un ordre précis.

Tu crées un nouveau tableau en utilisant des crochets pour encadrer une liste d'éléments. Penses-y comme

à une chenille agrafée dans ton code. Les crochets sont les agrafes. Les virgules entre chaques éléments

sont les pattes de la chenille.

 #!ruby

 soap_brands = ["Zest", "Irish Spring", "Dove"]

Les tableaux peuvent être facilement complétés avec la méthode push. Ou encore l'opérateur <<, qui un

un symbole signifiant "ajouter".

 #!ruby

 soap_brands.push "Lava"

 soap_brands << "Ivory"

Les tableaux commencent à compter à partir de 0. Cela signifie que le premier élément

dans la liste à l'indice zéro.

 #!ruby

 feed = Web.fetch("http://redhanded.hobix.com/", :as => Web::Feed)

 feed.items = [feed.items[0], feed.items[1], feed.items[3]]

Le code ci-dessus fait un nouveau tableau à partir du premier, du deuxième et du quatrième élément

trouvé dans le flux.

Oh, une chose encore. Tu peux aussi utiliser les emplacements négatifs, qui comptent à partir de la fin de la liste.

Ainsi, -1 est la position du dernier élément. -2 est l'avant dernier élément et ainsi de suite.

 #!ruby

 puts soap_brand[-1]

tableau + tableau

Les tableaux peuvent être ajouter entre eux avec le signe plus. Un nouveau tableau est retourné

avec les éléments de la première liste, suivis de ceux de la seconde liste.

 #!ruby

 robots = ["Trurl", "Klapaucius"] + ["R2-D2", "C-3PO"]

 robots  #=> ["Trurl", "Klapaucius", "R2-D2", "C-3PO"]

tableau - tableau

Les tableaux peuvent aussi être soustraits! Un nouveau tableau est crée avec tout ce qui se trouve dans le

premier tableau moins tout ce qui se trouve aussi dans le second tableau.

 #!ruby

 numbers = [1, 2, 3, 4, 5, 6]

 evens = [2, 4, 6]

 numbers - evens  #=> [1, 3, 5]

<< un Object

Le double signe < ajoute n'importe quel objet à la fin d'un tableau. Il est souvent appelé "le concatenateur"

 #!ruby

 fruit = ["pommes", "mangues"]

 fruit << "ananas"

 fruit.length   #=> 3

[ position: un nombre ]

Récupère l'élément à un certain emplacement. Un tableau commence à zero, donc array[0] te donnera le

premier élément du tableau.

 #!ruby

 huxtables = ["Heathcliff", "Clair", "Denise", "Theo", 

              "Vanessa", "Rudy"]

 huxtables[0]     #=> "Heathcliff"

 huxtables[-1]    #=> "Rudy"

Comme le montre la dernière ligne, le positionnement négatif peut être utlisé.

Si rien n'est trouvé à cet emplacement, nil est retourné.

[ position: un nombre ] = un Objet

Tu peux placer un objet à un endroit précis grâce au signe égal placé après le crochet.

 #!ruby

 list = ["faire un jogging", "aller nager"]

 list[1] = "nage annulée"

Si rien n'est à cet emplacement, nil est retourné.

[ de: un nombre .. à: un nombre ]

Fait un nouveau tableau à partir d'une petite partie de ce même tableau. Commence à partir du de

et va jusqu'à l'emplacement indiqué par à.

 #!ruby

 sites = [:H, :A, :C, :K, :E, :T, :Y]

 sites[2..-2]    #=> [:C, :K, :E, :T]

Cet exemple commence à la position 2 (où est le :C) et garde tout jusqu'à la position -2,

qui est l'avant dernier objet du tableau (le :T).

S'il t'arrive d'indiquer des nombres qui dépassent la fin du tableau, Ruby s'arrêtera à la fin.

Si rien n'est trouvé entre ces emplacements, tu récupéreras un nil (comme dans "rien n'a été trouvé.")

[ départ: un nombre, combien: un nombre ]

Fabrique un nouveau tableau par extraction de certains éléments de ce tableau. Cela commence à l'emplacement

indiqué par départ et récupère le nombre d'éléments précisé par combien.

 #!ruby

 sites = ["yahoo.com", "google.com", "msn.com", "technorati.com"]

 sites[1, 2]    #=> ["google.com", "msn.com"]

Cet exemple commence à la position 1 (où se situe "google.com") et place deux éléments dans le nouveau tableau.

Si tu cherches à saisir quoique ce soit au delà de la fin du tableau, Ruby s'arrêtera à la fin de celui-ci.

Si rien n'est trouvé à partir du point de départ, tu récupèreras un nil.

at( position: un nombre )

Obtenir un élément à une certaine position. Fonctionne exactement comme array[position], décrite plus avant.

 #!ruby

 huxtables = ["Heathcliff", "Clair", "Denise", "Theo", 

              "Vanessa", "Rudy"]

 huxtables.at(0)     #=> "Heathcliff"

 huxtables.at(-1)    #=> "Rudy"

clear()

Vide le tableau. Évidemment, tu peux le remplir à nouveau.

 #!ruby

 list = File.readlines('README.txt')

 list.clear    #=> []

collect() { |éléments| ... }

Un bloc doit être attaché à la méthode collect. Le bloc boucle dans le tableau et place chaque

éléments dans la boucle. Quoi que retourne le bloc, l'élément est remis dans un nouveau tableau,

à la même position. C'est une super manière d'éditer chacun des éléments d'un tableau!

 #!ruby

 dogs = ["Pluto", "Astro", "Benji", "Lassie"]

 updogs = dogs.collect { |item| item.upcase }

 updogs

  #=> ["PLUTO", "ASTRO", "BENJI", "LASSIE"]

 dogs

  #=> ["Pluto", "Astro", "Benji", "Lassie"]

Cela ne change donc pas le premier tableau. Tu vois? Cela fait juste un nouveau tableau, à partir de l'ancien.

Si tu veux faire une copie légérement différente d'un tableau, collect (aussi appelée map)

est l'endroit à connaître pour démarrer.

collect!() { |item| ... }

Tout comme la méthode collect ci dessus: le bloc manipule chaque élément du tableau

et le modifie.

Mais à la place de faire un nouveau tableau, il change le tableau existant. C'est pour cela que cette

méthode possède un point d'exclamation. C'est dangereux: cela va remplacer tout ce qui est dans le tableau!

 #!ruby

 dogs = ["Pluto", "Astro", "Benji", "Lassie"]

 dogs.collect! { |item| item.length }

 dogs

  #=> [5, 5, 5, 6]

Tu vois, le tableau à écrit réécrit. Avec la taille de chacun des éléments. Et d'une dangereuse façon:

tous les noms de chiens... sont partis.

compact()

Retire tous les nils du tableau. Pour le cas où tu veux uniquement des choses consistantes.

C'est vrai, à quoi sert nil ici?

 #!ruby

 ["a", nil, "b", nil, "c", nil].compact

  #=> ["a", "b", "c"]

concat( an Array )

Ajoute un tableau à la fin.

 #!ruby

 ["canards", "mule"].concat( ["moutons", "chats"] )

  #=> ["canards", "mule", "moutons", "chats"]

Tu peux aussi utiliser += pour faire la même chose.

 #!ruby

 animals = ["canards", "mule"]

 animals += ["moutons", "chats"]

delete( un Objet )

Efface d'un tableau tout ce qui est égale à l'objet qui lui est passé.

delete_if { |élément| ... }

Un bloc est attaché à delete_if qui parcourt chaque élément du tableau.

Si le bloc retourne nil ou false, alors l'élément est effacé du tableau.

Un nouveau tableau est alors crée, sans les objets qui ont été supprimés.

Donc: array.delete_if { nil } efface tout!

Et: array.delete_if { |x| x.even? } efface aussi les nombres

dans une liste entièrement faite de nombres.

each { |élément| ... }

Une des choses les plus courantes que tu puisses faire avec un tableau

est d'utiliser la méthode each. Le bloc attaché va récupérer chaque éléments du tableau,

un par un, dans l'ordre. Ce qui est bien avec cette méthode, c'est que tu n'as pas besoin

de connaître la longueur du tableau, each commencera au début et arrêtera à la fin.

Par exemple, si tu veux afficher chaque éléments présent dans un tableau:

 #!ruby

 array.each { |élément| puts élément }

En programmation, ce concept d'exploration d'une liste d'un bout à l'autre s'appelle une "boucle".

first()

Retourne le premier élément d'un tableau. Tout simple!

include?( un Objet )

Recherche un objet dans un tableau. Il demande, "est-ce que cet objet est inclu dans ce tableau?" et

retourne la réponse sous la forme true ou false.

 #!ruby

 robots = ["Trurl", "Klapaucius", "R2-D2", "C-3PO"]

 robots.include?("R2")       #=> false

 robots.include?("R2-D2")    #=> true

index( un Objet )

Lorsque tu recherche la position d'un objet dans une liste.

La méthode index fait exactement cela. Si elle trouve l'objet dans le tableau, elle retournera

l'indice correspondant à sa position.

Sinon, tu obtiendras un nil. Ce qui signifie "rien n'a été trouvé".

 #!ruby

 animals = ["ours", "lapins", "panthères"]

 animals.index("lapins")  #=> 1

 animals.index("MAMMOUTHS") #=> nil

join( séparateur: une chaîne )

Génère une chaîne à partir d'un tableau. La chaîne séparatrice sera placée entre chaque éléments.

 #!ruby

 ["ours", "lapins", "panthères"].join(" & ")

   #=> "ours & lapins & panthères"

Tu vois, c'est pratique pour mettre des phrases ensemble.

last()

Retourne le dernier élément de le tableau. Au cas où tu serais curieux.

length()

Quelle est la taille du tableau? La méthode length retourne un nombre. Zero si la taille est nulle.

map() { |élément| ... }

Un raccourcis pour collect, décrite plsu haut dans cette page.

map!() { |élément| ... }

Un autre raccourics pour collect!. Vérifie, c'est un peu plus haut dans cette page.

reverse()

Génère un nouveau tableau avec tous les éléments dans l'ordre inverse. Donc si tu as une liste

d'entrées de blog allant du plus récent au plus ancien, tu peux utiliser cela pour passer

au tri allant du plus ancien au plus récent.

 #!ruby

 Table('Blog').recent(10).reverse()

Ca marche aussi bien avec sort(). Si tu désires une liste de A à Z, tu peux l'inverser de Z à A.

 #!ruby

 cats = ["Sylvester", "Boo", "Tom"]

 cats.sort().reverse()

   #=> ["Tom", "Sylvester", "Boo"]

sort()

Renvoie un nouveau tableau avec son contenu trié. Pour la plupart des choses, cela fonctionne simplement.

Les chaînes sont triées alphabetiquement. Les nombres sont triés à partir de zéro.

 #!ruby

 cats = ["Sylvester", "Boo", "Tom"]

 cats.sort()

   #=> ["Boo", "Sylvester", "Tom"]

Comment connaît-il la façon de trier les choses alors?? Et bien, il utilise la méthode vaisseau spatial!

La méthode vaisseau spatial ressemble à ceci: <=>. Elle est utilisée pour dire comment ordonner les choses.

 #!ruby

 "Sylvester" <=> "Boo"

   #=> 1

Une réponse 1 signifie que l'élément ne fonctionne pas.

Donc "Boo" doit être placée avant.

Quoi qu'il en soit, la chose importante ici est: tout ce qui possède la méthode vaisseau spatial

peut être trié.

to_a()

Retourne l'élément en tant que tableau.

to_ary()

Encore une fois, retourne l'élément en tant que tableau. Pas besoin de le transformé en tableau,

c'en est déjà un.

to_s()

Transforme le tableau en une nouvelle chaîne en appellant join(). Puisqu'il n'y a pas de séparateur, tous les

éléments sont envoyés ensemble dans la nouvelle chaîne.

 #!ruby

 animals = ["ours", "lapins", "panthères"]

 animals.to_s  #=> "ourslapinspanthères"

Dir

Dir est l'abbréviation de "directory", répertoire en Français. Ce qui signifie: un dossier de ton

disque dur. Utilise Dir pour lister les fichiers présent dans les dossiers.

 #!ruby

 Dir["#{DOWNLOADS_DIR}/*"].each do |nomdefichier|

   puts nomdefichier

 end

Il n'y a vraiment que deux choses courantes que tu puisses faire avec Dir. Dans

l'exemple précédent, nous avons listé tous les fichiers en utilisant une variable "globale".

Tu peux aussi créer de nouveaux dossiers avec Dir.mkdir.

Dir[ globale: une chaîne ]

Liste des fichiers dans un répertoire. Tu récupère un tableau de chaîne -- une liste

de nom de fichier. Il y a ici quelques petites choses à savoir.

Premièrement, tu peux utliser une étoile, qui est un caratère générique signifiant "tout fichier".

 #!ruby

 Dir["*"].each do |item|

   puts "#{item} is #{File.size(item)} bytes big"

 end

Ensuite, tu peux utiliser les accolades pour préciser une liste des mots à filtrer. Autrement

dit, si tu cherches tous les fichiers qui contiennent MP3s ou M4A:

 #!ruby

 Dir["*Ghost.{mp3,m4a}"] #=> ["Tuff Ghost.mp3", "Sea Ghost.mp3"]

Dir.mkdir( nom: une chaîne )

Crée un nouveau dossier vide.

 #!ruby

 Dir.mkdir('C:/Hacks')

File

Un File est un fichier sur ton disque dur. Comme un fichier texte, un courriel ou un MP3 que

tu as enregistré.

Tu peux aller à l'intérieur d'un fichier en utilisant File.open. Ouvrons ici un nouveau fichier appelé "À Faire.txt":

 #!ruby

 File.open("À Faire.txt", "w") do |f|

   f << "S'approvisionner en lait de coco."

 end

Le "w" est utilisé pour demander à Ruby d'ouvrir le fichier en écriture. Tu pourras alors ajouter

un élément à ta liste de chose à faire.

La variable f dans le bloc est un objet File. Donc, une fois ouvert, le fichier

peut utiliser n'importe laquelle des méthodes ci-dessous.

 #!ruby

 insides = File.open("À faire.txt", "r") do |f|

   f.read()

 end

 puts(insides)

Le mode "r" sert à lire des fichiers.

(!) NOTE IMPORTANTE: Sous Windows, les fichiers standard sont traités comme des fichiers textes.

Si tu voulais ouvrir une image (un GIF, un JPEG) ou tout autre fichier ne contenant pas de texte pur, assure-toi

de le lire en mode binaire "rb" et d'écrire dedans en mode binaire "wb"`.

 #!ruby

 File.open("stinky-the-skunk.png", "rb") do |f|

   puts "Image is #{f.read().length()} bytes long."

 end

N'oublie pas ask_open_file et ask_save_file de la liste des fonctions pré-définies.

Elles vont bien avec les objets Fichiers!

File.basename( nom de fichier: un Chaîne )

Fournis à cette méthode le chemin complet vers un fichier (comme par exemple "C:/WINDOWS/notepad.exe") et elle te

retournera uniquement le nom du fichier, débarrassé du nom du dossier (ici, "notepad.exe".)

 #!ruby

 comics = "C:/Documents and Settings/Philarp/My Documents/comics.txt"

 File.basename(comics)   #=> "comics.txt"

File.delete( nom de fichier: une chaîne )

Efface un fichier, définitivement.

 #!ruby

 File.delete("D:/Vids/Good-Burger.mov")

File.dirname( nom de fichier: une chaîne )

Fournis à cette méthode le chemin complet vers un fichier (par exemple "C:/WINDOWS/notepad.exe") et elle

te retournera le nom du dossier uniquement (ici: "C:/WINDOWS")

 #!ruby

 comics = "C:/Documents and Settings/Philarp/My Documents/comics.txt"

 File.basename(comics)   #=> "C:/Documents and Settings/Philarp/My Documents"

File.exists?( nom de fichier: une chaîne )

Vérifie qu'un fichier est vraiment là, sur ton disque dur. Puisqu'elle possède un

point d'interrogation -- est-ce vrai? -- tu récupères simplement true ou false.

 #!ruby

 if File.exists?("C:/corn-cob.png")

   puts "Pourquoi gardes-tu les images d'épis de maïs couchés - je ne le saurai jamais."

 end

File.join( une chaîne, une chaîne, ... )

Assemble un nombre quelconque de chaînes, en ajoutant un slash entre chaque. C'est donc un

bonne façon de construire des noms de fichiers.

 #!ruby

 File.join("C:", "Robots", "Trurl.txt")

   #=> "C:/Robots/Trurl.txt"

File.open( nom de fichier: une Chaîne, mode: "r", "w", "rb" or "wb" ) { |file| ... }

Ouvre un fichier en lecture ou écriture. Utilise "r" pour lire depuis un fichier de texte standard ou

"w" pour écrire dans un fichier texte. Ajoute le "b" pour lire et écrire depuis un fichier binaire

(des choses comme les images, les MP3s, qui ne contiennent pas du texte plein.)

 #!ruby

 # Ce programme sauvegarde tous les messages du salon lobby de Why.

 c = Hacker('why').channel('lobby')

 loop do

   f = File.open("C:/Chat.txt")

   chan.hear.each do |m|

     f.write "#{m.hacker} said at #{m.at}:\n#{m.object}\n"

   end

   f.close

   sleep 5

 end

Encore mieux, tu peux utiliser un bloc pour automatiquement fermer le fichier à ta place.

Tu as vu comment j'ai utilisé close après avoir écrit dedans? Si tu utilises un block, le fichier se fermera lorsque tu atteindras la fin du bloc.

Comme ceci:

 #!ruby

 File.open("C:/Chat.txt") do |f|

   chan.hear.each do |m|

     f.write "#{m.hacker} said at #{m.at}:\n#{m.object}\n"

   end

 end

L'utilisation du block est sans équivalent, utilise le sans hésitation!

File.rename( depuis: une chaîne, jusqu'à: une chaîne )

Change le nom d'un fichier. Le déplace.

 #!ruby

 File("basil-kirchin.mp3", "Quantum-Part-1.mp3")

Ceci va renommer le MP3 basil-kirchin.mp3 en Quantum-Part-1.mp3, son nouveau nom. Très pratique pour tes collections de musique et de photos.

File.size( nom de fichier: une chaîne )

Mesure la taille d'un fichier, en octets.

 File.size("Adventure Time.flv")

   #=> 18814749

La taille de Adventure Time.flv est donc de 18,814,749 octets. Ou, en gros, 18 mégaoctets.

<< un chaîne

Écrit un message dans le fichier ciblé par les doubles flèches. C'est la même chose qu'utiliser

write, mais c'est pratique pour ceux d'entre vous qui aiment les symboles visuels plutôt que les mots.

 #!ruby

 File.open("FavoriteTreats.txt", "w") do |f|

   f << "Pickle Surprise"

 end

close()

Ferme le fichier. Ceci indique à l'ordinateur que tu en as terminé avec le fichier et que tu passes à autre chose. Une bonne raison de fermer un fichier est de laisser d'autre programmes l'utiliser.

 #!ruby

 f = File.open("GiraffeNames.txt")

 puts "J'aime les noms de giraffes. Par exemple:"

 puts f.read

 f.close

 puts "Elles sont toutes là!"

Si tu utilise un bloc, If you're using a block, alors ne te soucie de rien! Le bloc fermera le fichier pour toi. Consulte l'aide de File.open, si tu veux voir un exemple.

read()

Stock tout dans le fichier sous forme de chaîne.

 #!ruby

 File.open("GiraffeNames.txt") do |f|

   names = f.read

 end

Considère que GiraffeNames.txt est un fichier texte plein. Comme ceci:

 Chopsy

 McCoy

 Beanback

 Shlomi

Et nous le bidouillons comme ceci:

 #!ruby

 f.read

   #=> "Chopsy\nMcCoy\nBeanback\nShlomi\n"

 f.read

   #=> ""

La méthode read demarrera au début du fichier et le lira jusqu'à la fin. Ce qui veux dire que si tu tente de lire (read) après qu'il ait atteint la fin,

tu n'obtiendras rien en réponse.

Essaie d'utiliser la méthode rewind pour revenir au début et recommencer à nouveau.

Oh, encore une chose: tu peux read un chiffre. Et il s'arrêtera après avoir lu ce nombre de lettres. Ou octets, devrais-je dire.

 #!ruby

 f.read(6) # lit seulement des six premières lettres

   #=> "Chopsy"

readlines()

Tout comme read, nous récupérons le fichier en entier. Mais cette fois en tant que tableau plein de chaînes. Et chaque chaîne contient une ligne du fichier.

Utilisons le fichier GiraffeNames.txt mentionné dans l'exemple read ci-dessous:

 #!ruby

 f.readlines

   #=> ["Chopsy\n", "McCoy\n", "Beanback\n", "Shlomi\n"]

 f.readlines

   #=> []

rewind()

Retourne au début du fichier. Lorsque tu ouvres un fichier, tu commences toujours en haut, tu n'as donc pas à l'utiliser à moins d'avoir déjà fait quelques lectures ou écritures.

 #!ruby

 f.read

   #=> "Chopsy\nMcCoy\nBeanback\nShlomi\n"

 f.rewind

 f.read

   #=> "Chopsy\nMcCoy\nBeanback\nShlomi\n"

write( texte: une chaîne )

Ajoute la chaîne texte au fichier. Regarde aussi la méthode << un peu avant, c'est la même chose.

 #!ruby

 File.open("FavoriteTreats.txt", "w") do |f|

   f.write "Pickle Surprise"

 end

Fixnum

Un Fixnum est un chiffre. 1, 2 et 3. Et ainsi de suite!

Oh, et aussi les chiffres négatifs.

 #!ruby

 4 + 6      # ajoute

   #=> 10

 14 - -2    # soustrait

   #=> 16

 12 / 2     # divise

   #=> 6

 200 * 3    # multiplie

   #=> 600

Heureusement tu n'auras pas à faire beaucoup de math, quoi que. Le plus souvent, tu utiliseras un chiffre pour répéter un bloc de code encore et encore, en utilisant la méthode times.

Comme par exemple, pour répeter un bloc cinq fois:

 #!ruby

 5.times do

   puts "Odelay!"

 end

Ce qui affichera Odelay''' cinq fois. Bien, très facile à comprendre.

Une autre chose qui peut être bien pratique. Si tu as un nombre dans une variable, tu peux l'augmenter avec le signe +=.

 #!ruby

 num = 6

 num += 1

  # À présent `num` vaut 7

La plupart des langages utilisent ++ pour cela. Mais oublie cela pou l'instant, d'accord?

abs()

Retire le signe négatif. Cela s'appelle la "valeur absolue" d'un nombre.

 #!ruby

 -16.abs

   #=> 16

downto( fin: un nombre ) { |nombre| }

Compte depuis ce nombre jusqu'au nombre à la fin. À chaque boucle,

le nombre juste en dessous est passé au bloc.

 #!ruby

 puts "Compte à rebour:"

 10.downto(1) do |nombre|

   puts "#{nombre}!!"

 end

 puts "Yay, mon chapeau est en feu à présent."

times { |nombre| }

Compte à partir de zéro jusqu'au nombre. À chaque comptage, le bloc prends le nombre où nous sommes.

 #!ruby

 5.times do |i|

   puts "Odelay!! (#{i})"

 end

to_s()

Convertit un nombre en chaîne de façon à pouvoir l'afficher à l'écran ou le stocker dans une table ou autre.

 #!ruby

 5.to_s

   #=> "5"

upto( haut: un nombre ) { |nombre| }

Compte à partir de ce chiffre jusqu'au nombre précisé en haut. À chaque comptage, tu obtiens le numéro suivant sur l'échelle, qui est donné au bloc.

 #!ruby

 puts "Compter:"

 1.downto(10) do |nombre|

   puts "#{nombre}!!"

 end

 puts "JE SUIS UN CHAMPION."

Hash

Un hachage est un dictionnaire de paires. Ce qui signifie: il apparie les choses. Tu seras surpris de sa fréquente utilisation.

Comme à chaque fois que tu vois cela:

 #!ruby

 Web.fetch('http://metafilter.com', :as => Web::Feed)

La dernière partie est un hachage. La partie qui dit: :as => Web::Feed.

On peut aussi l'écrire comme cela:

 #!ruby

 Web.fetch('http://metafilter.com', {:as => Web::Feed})

Quand tu construis une hachage à l'extérieur d'une méthode, tu utiliseras les accolades ouvrantes et fermatnes:

 #!ruby

 livre = {

   "Les aventures de Gulliver" => :excellent,

   "Une paix séparée" => :ennuyeux,

   "Le bûcher des vanités" => :pas_mon_style

 }

Regarde, voici un bon exemple d'un hachage utile. Ce dictionnaire apparie un titre de livre avec mon sentiment sur ce livre. Je peux faire un grand dictionnaire de tous les livres que j'ai lu et de mes impressions.

Ensuite, lorsque je veux examiner un livre en particulier:

 #!ruby

 books["Une paix séparée"]

   #=> :ennuyeux

Les crochets peuvent être utilisés pour examiner le nom d'un livre.

Le plus souvent, dans Hackety Hack, tu conserveras des choses comme cela dans une table. Mais les tables peuvent être chargées dans un dictionnaire.

Utiliser des dictionnaires comme des espaces de stockage temporaires est chose très courante.

(!) NOTE IMPORTANTE: N'attend pas d'un hachage qu'il conserve les choses dans l'ordre!! Les dictionnaires ne s'occupent pas de la façon dont les choses sont ordonnées. Utilise un tableau pour classer beaucoup de chose et un hachage pour en apparier deux.

Encore une fois, pense à l'exemple du livre. L'ordre des livres m'importe peu. Je veux simplement trouver rapidement quelle impression j'ai attribué à certain livre.

[ consultation: un objet ]

C'est le but principal d'un hachage. Pour consulter un élément d'un dictionnaire.

Les hachages sont stocker par paires. Cela s'appelle une paire de clef-valeur.

La clef est à la gauche de laflèche, la valeur à droite.

Regarde:

 #!ruby

 livres = {"Voyages de Gulliver" => :excellent}

La clef est "Voyages de Gulliver". La valeur est :excellent.

La belle affaire! Bon, lorsque tu recherches une choses, tu consulte sa clef. Exactement comme dans un vrai dictionnaire. TU as un mot et une définition dans le dictionnaire Larousse. Tu le consultes en cherchant un mot, pas sa définition.

Pour consulter le commentaire d'un livre, on utilise la clef:

 #!ruby

 books["Voyages de Gulliver"]

   #=> :excellent

Si rien ne correspond à ta recherche, nil est retourné. Autrement dit,

"rien n'a été trouvé."

[ clef: un objet ] = valeur: un objet

Voici une façon rapide d'ajouter quelquechose à un hachage. Lance une consultation, mais ajoute à ta recherche le signe égale.

 #!ruby

 books = {}

 books["Catch 22"] = :bien

delete( clef: un objet )

Efface (Delete) une entrée du hachage. Utilise la clef, exactement comme une consultation, pour dire à Ruby quelle entrée effacer.

 #!ruby

 livres = {"Alice au pays des merveilles" => :phénomenal}

 livres.delete("Alice au pays des merveilles")

   #=> :phénomenal

 livres["Alice au pays des merveilles"]

   #=> nil

each { |clef, valeur| }

Si tu veux parcourir chaque entrées du dictionnaire, utilise each.

Le bloc associé va prendre chacunes des paires du hachage, une par une,

sans ordre particulier.

Ainsi, si par exemple tu veux afficher chaque paire du dictionnaire:

 #!ruby

 livres.each do |clef, valeur|

   puts "KEY: #{clef}"

   puts "VALUE: #{valeur}"

   puts

 end

En programmation, cette façon de parcourir cycliquement, du début à la fin, est appelé une "boucle".

empty?()

Est-ce que ce distionnaire contient des entrées? Si oui, tu obtiendras un false (faux) par retour.

si non, true (vrai).

has_key?( clef: un objet )

Vérifie que le dictionnaire possède une key (clef). Cela revien à faire une consultation, mais avec des réponses true ou false.

 #!ruby

 books.has_key?("CivilWarLand in Bad Decline")

   #=> false

 books.has_key?("Voyages de Gulliver")

   #=> true

C'est très pratique si tu veux être certain que tu n'obtiendras pas un nil après une consultation.

index( valeur: un objet )

Ne cherche pas la clef mais sa valeur. Si tu veux trouver un livre qui à qui j'ai donné un :bon classement:

 #!ruby

 books.index(:bon)

   #=> "Catch 22"

keys()

Construis un tableau à partir de toutes les clefs du dictionnaire. Si tu utilises l'analogie avec le dictionnaire, ceci donne la liste de tous les mots du dictionnaire qui ont une définition.

Dans le cas de notre exemple, une liste de tous les livres commentés:

 #!ruby

 books.keys

   #=> ["Voyages de Gulliver", "Une paix séparée", "Le bûcher des vanités"]

length()

Combien de paires sont dans ce dictionnaire? Un nombre est retourné.

 books.length

   #=> 3

Ah, j'ai donc commenté trois livres.

merge( dictionnaire2: un dictionnaire )

Combine ce dictionnaire avec un autre dictionnaire. Tu obtiens un nouveau dictionnaire qui mélange les deux. Cepedant, si une clef est trouvée dans le premier dictionnaire et qu'elle est aussi dans le second, alors cette dernière écrasera la première clef.

 #!ruby

 nos_livres = mes_livres.merge(livres_de_Dave)

Dans l'exemple précédent, mes livres et ceux de Dave sont combinés dans un unique dictionnaire des commentaires. Si Dave à commenté les Voyages de Gulliver, sont commentaire survivra alors que le mien disparaîtra.

merge!( dictionnaire2: un dictionnaire )

Combine les dictionnaires, tout comme merge, mais sans créer de nouveau dictionnaire. Le second hachage est simplement fusionné dans le premier.

 #!ruby

 mes_livres.merge!(livres_de_Dave)

sort()

Tri alphabetiquement les clefs du dictionnaire, en convertissant le hachage en tableau, ou les choses conservent leur ordre.

Donc, pour afficher mes commentaires classé alphabetiquement:

 #!ruby

 livres.sort.each do |titre, classement|

   puts "#{titre} à été noté: #{classement}"

 end

Objet

Tout -- nombres, chaînes, tabelaux, etc. -- est un objet. Toutes ces méthodes peuvent donc être utilisées sur n'importe quel objet! Y compris cette page.

Un objet est simplement une chose vide. Tu n'utiliseras probablement jamais un objet à lui seul.

 #!ruby

 Object.new

   #=> (Object)

Tu vois, rien. Pas tellement utile.

objet == objet

Est-ce que ces deux objets sont les mêmes? Le signe double-egal est largement utilisé dans Ruby. Tu peux tester deux objets pour voir s'ils sont identiques.

• nom == "Philippe" -- est-ce que la variable nom contient une chaîne qui dit "Philippe"?

• code_postal == 34143 -- est-ce que la variable code_postal contient le nombre 34143?

Ceci est habituellement combiné à un if (si).

 #!ruby

 if nom == "Philippe"

   puts "Ah, je t'attendais."

 end

class()

T'indique à quelle classe appartient cet objet. Est-ce que c'est une chaîne? Ou un hachage?

Ou une Image?

 #!ruby

 "".class

   #=> String

 {}.class

   #=> Hash

 Picture("icon.png")

   #=> Picture

dup()

Fait une copie de cet objet. Lorsque tu créer quelquechose, comme une chaîne ou un tableau, tu en fait seulement un exemplaire. Au fil de ton programme, tu peux vouloir modifier cet objet ou le placer dans de nouvelles variables. Mais il n'y a toujours qu'un seul objet réel, avec des surnoms différents.

La méthode dup fait une copie de l'objet, pour le cas ou tu voudrais travailler avec une copie plutôt que de modifier l'objet de façon permanente.

 #!ruby

 soda = "Coca Cola"

 pop = soda.dup

 pop += "!"

   #=> "Coca Cola!"

 soda

   #=> "Coca Cola"

inspect()

Encore une autre méthode cruciale, à mon avis. Cette méthode transforme n'importe quel objet en une chaîne. Cette chaîne décrit habituellement tout ce qui peut l'être pour l'objet. Donc, pour les hachages, tu obtiens une liste de toutes les paires à l'intérieur du hachage. Et pour les objets, tu verras une liste de ses variables.

 #!ruby

 {"Eau" => "Claire", "Lait" => "Blanc"}.inspect

   #=> "{\"Eau\" => \"Claire\", \"Lait\" => \"Blanc\"}"

 Object.new.inspect

   #=> "(Object)"

La plupart du temps, tu n'utiliseras pas cette méthode directement. Tu utilisera plutôt la méthode pré-définies appelée p.

is_a?( classe )

Vérifie si l'objet appartient à une certaine classe. Tu obtiens encore true ou false, comme avec toutes les méthodes possédant un point d'intérrogation.

 #!ruby

 "Spiderman".is_a?(String)

   #=> true

 {"Bone" => "Jeff Smith"}.is_a?(Array)

   #=> false

object_id()

C'est un nombre unique qui caractérise cet objet. Tu ne devrais beaucoup l'utiliser, mais c'est important de savoir que Ruby attribue à chaque objet son propre numéro.

respond_to?( méthode: un symbole )

Celle-ci est incroyablement utile!! respond_to? vérifie si l'objet peut avoir certaine méthode associée.

Donc, si tu as une variable, et que tu veux savoir si elle peut être modifiée en utilisant la méthode reverse:

 #!ruby

 obj.respond_to?(:reverse)

   #=> false

Oh, elle ne peut pas être renversée. Donc on ne fait pas.

Cette méthode retourne true ou false, c'est donc pratique avec un if.

Regexp

Regexp est un raccourcis pour "regular expression", expressions régulière. Une Regexp sert à trouver un motif dans des mots ou des paragraphes.

Ces ventouses ne sont pas pour le faible du coeur!

Une expression régulière est habituellement entourée de slashes:

 #!ruby

 r = /^image:/

Cette expression régulière trouve n'importe quelle chaîne qui commencant par les lettres "image:". Le symbole ^ représente le début de la ligne.

C'est ce qui rend les expressions régulières si puissantes: tous les symboles spéciaux qui représentent des choses différentes. Les expressions régulières sont réellement un petit langage à part entière.

Écrire des Expressions Régulières

Voici les symboles importants:

  ^  trouve le début d'une ligne

  $  trouve la fin d'une ligne

  .  trouve n'importe quel caractère

  \d trouve un nombre

  \w trouve une lettre, un nombre ou un _

  \s trouve une espace, une tabulation, ou une nouvelle ligne

  \S trouve tout ce qui n'est pas une espace, une tabulation, une nouvelle ligne

Donc si tu veux trouver un code-postal à 5 chiffres: /\d\d\d\d\d/

Ou, si tu veux vérifier si une chaîne se termine avec ".mp3": /\.mp3$/

Remarque comment je place un antislash devant le point. Normalement, un point est un symbole qui trouve n'importe quoi. Mais si je fais un antislash-point \., alors le point sera en fait trouvé.

Raccourcis

Voici un raccourcis pour trouver des codes-postaux facilement: /\d{5}/

Le {5} signifie "trouve le dernier symbole 5 fois". Le dernier symbole était \d qui signifie "un nombre". Donc, au final: "trouve un nombre 5 fois."

Voici quelques autres raccourcis:

 {3}   trouve 3 fois

 {3,}  trouve 3 fois ou plus

 {3,5} trouve entre 3 et 5 fois

 *     trouve zero fois ou plus

 +     trouve une fois ou plus

 ?     trouve zero ou une fois

À présent tu peux écrire des expressions régulières vraiment stupéfiantes. Par exemple, pour récupérer le premier mot dans une phrase: /^\w+/

Exemples

Voici quelques exemples courants:

 #!ruby

 "pinball.mp3"[/\.\w+$/]         # trouve l'extension du fichier

   #=> ".mp3"

 "map:Seattle, WA"[/^map:(.+)/, 1]  # trouve tou ce qui est après "map:"

   #=> "Seattle, WA"

match( une chaîne )

Essaie de trouver cette expression régulière une seule fois dans unes chaîne. Si une correspondance est trouvé, tu obtiens un objet MatchData. Continue et converti ceci en tableau, en utilisant to_a:

 match = /^map:(.+)/.match("map:Seattle, WA").to_a

   #=> ["map:Seattle, WA", "Seattle, WA"]

Si aucune correspondance n'est trouvée, tu obtiens un nil, comme dans "rien n'a été trouvé."

Je te recommande d'éviter cette méthode. Utilise plutôt une chaîne avec une consultation str[/regexp/] ou str.scan(/regexp/).

Chaîne

Un chaîne est une série de lettres. Lorsque tu charge un fichier, tu en retires une longue chaîne. Une page web n'est rien d'autre qu'une chaîne. Tout ce qui contient des mots, des phrases des paragraphes, ets une chaîne.

Même les images sont des chaînes! (Illisibles, Unreadable, ce sont des chaînes qui paraissent désordonnées.) Pour créer une nouvelle chaîne, entoure ton message de guillemet doubles.

 #!ruby

 chaine = "I quit my job blowing leaves, 

   telephone bills up my sleeves"

 puts string

Tout ce qui est entre guillemet est une chaîne, même si la chaîne se trouve sur plusieurs lignes.

Les guillemets simples fonctionnent aussi: 'comme ceci.'

<< une chaîne

Ajoute à la fin de cette chaîne.

 #!ruby

 nom = "Philarp"

 nom << " Tremaine"

 puts nom

   #=> Philarp Tremaine

Tu peux même les enchaîner si tu veux:

 #!ruby

 nom = "P"

 nom << "h" << "i" << "l"

 puts nom

   #=> Phil

chaîne + chaîne

Génère une nouvelle chaîne en combinant deux chaînes, dans l'ordre.

 #!ruby

 lettres = "abc" + "xyz"

   #=> "abcxyz"

En général, tu n'utilisera pas cela, mais plutôt cette notation.

 #!ruby

 lettres = "#{"abc"}#{"xyz"}"

   #=> "abcxyz"

La raison derrière tout cela étant que l'addition de chaîne échouera si tu as un nombre ou autre chose dedans.

 #!ruby

 abc = "abc"

 un = 1

 lettres = abc + un

   #=> [TypeError] can't convert Fixnum into String

 lettres = "#{abc}#{un}"

   #=> "abc1"

string[ à partir de: un nombre .. jusqu'à: un nombre ]

Récupère une partie de la chaîne et en fait une nouvelle.

Admettons que tu veux uniquement les lettres depuis la seconde jusqu'à la cinquième:

 #!ruby

 string[2..5]

string[ /regexp/: une expression régulière ]

Essaie de trouver une Regexp une seule fois dans la chaîne. La première correspondance trouvée est retournée (en tant que chaîne). Si rien n'est trouvé, alors nil est retourné.

 #!ruby

 "pinball.mp3"[/\.\w+$/]

   #=> ".mp3"

 "J'ai 13 lapins!!"[/\d+/]

   #=> "13"

Si tu veux obtenir une certain groupe parmis les correspondances, tu peux aussi préciser un nombre à la RegExp?:

 #!ruby

 "Seattle, WA"[/(\w+), ([A-Z]+)/, 1]

   #=> "Seattle"

 "Seattle, WA"[/(\w+), ([A-Z]+)/, 2]

   #=> "WA"

Regarde le chapitre sur les Regexp pour en savoir plus sur cette créature rare et complexe.

capitalize()

Met en lettre capitales la première lettre d'une chaîne et te retourne une copie.

downcase()

Fait une nouvelle chaîne à partir de la chaîne d'origine, mais avec toutes les lettres capitales de la chaîne transformées en lettres minuscules. "A" devient "a",

"B" devient "b", et ainsi de suite.

empty?()

Est-ce que cette chaîne est vide? Une chaîne vide est "". Si tu as affaire à une chaîne vide, tu obtiendras true. Sinon, false. Comme pour toutes les méthodes qui présentent un point d'intérrogation.

 #!ruby

 "".empty?

   #=> true

 "OK".empty?

   #=> false

include?( trouve: une chaîne )

Vérifie que la chaîne contient find quelquepart. C'est comme une mini recherche.

Puisque les descriptions d'éléments de blog sont des chaînes, nous pouvons utiliser cette méthode pour voir si l'article le plus récent sur MetaFilter? contient le mot "Colbert".

 #!ruby

 blog = Web.fetch("metafilter.com", :as => Web::Feed)

 blog.items[0].description.include? "Colbert"

   #=> false

ends?( fin: une chaine )

Est-ce que cette chaîne se termine par cette fin? Pratique pour vérifier les extensions de fichier!

 #!ruby

 "Dark Star.avi".ends?(".avi")

   #=> true

 "Dark Star.avi".ends?(".mp4")

   #=> false

length()

Combien de caractères sont dans cette chaîne? Ceci inclus les lettres, les nombres, les espaces.

 #!ruby

 "Boston".length()

   #=> 6

 "Tammany Hall".length()

   #=> 12

remove( expression: une chaîne )

Génère une nouvelle chaîne en retirant l'expression. Ceci n'enlèvera pas l'expression à chaque fois quelle apparaît, mais uniquement la première apparition de cette expression.

 #!ruby

 "Beck - The New Pollution.mp3".remove(".mp3")

   #=> "Beck - The New Pollution"

reverse()

Fait une copie de cette chaîne, en inversant tous les caractères.

 #!ruby

 "Rocky Dennis".reverse

   #=> "sinneD ykcoR"

scan( motif: une Regexp )

Parcours la chaîne, en cherchant la correspondance avec l'expression régulière autant de fois que possible. Tu obtiens en retour un tableau des correspondances.

Ainsi, par exemple, pour obtenir une liste de tous les mots dans une chaîne:

 #!ruby

 "Deux platines et un microphone".downcase.scan(/\w+/)

   #=> ["Deux", "platines", "et", "un", "microphone"]

C'est une méthode très puissante trop souvent oubliée! Disons que tu veux trouver combien de fois le mot "George" apparait dans une chaîne:

 #!ruby

 str.scan(/George/i).length

   #=> 4

Le i à la fin de la Regexp signifie case-insensitive, insensible à la casse. Elle trouvera donc toutes les correspondances avec "george", minuscules et capitales .

split( marque: une chaîne )

Ceci va casser ta chaîne en morceaux, dans un tableau. Et la coupure se fait sur la marque. C'est souvent quelque chose comme une virgule ou un point-virgule par exemple.

 #!ruby

 "Jeff, Jim, Jillian".split(",")

   #=> ["Jeff", " Jim", " Jillian"]

Tu peux aussi découper à partir d'expressions régulières. Si, par exemple, nous voulions nous débarrasser des espaces avant chaque nom:

 #!ruby

 "Jeff, Jim, Jillian".split(/\s*,\s*/)

   #=> ["Jeff", "Jim", "Jillian"]

Maintenant les espaces devant Jim et Jillian sont partis!

starts?( début: une chaîne )

Est-ce que cette chaîne commence par ce début? C'est pratique lorsque tu l'utilise en combinaison de la méthode remove. Comme si tu voulais inventer ta propre commande de clavardage.

 #!ruby

 "map:Seattle, WA".starts?("map:")

   #=> true

 "map:Seattle, WA".remove("map:")

   #=> "Seattle, WA"

Dans notre programme de messagerie, tu voudras trouver toutes les fois ou tu as saisie "map:Une Addresse". Puis tu voudras envoyer cette carte via ta messagerie en utilisant un objet Adresse.

 #!ruby

 if cmd.starts?("map:")

   # Une carte à été trouvée!

   addr = Address(cmd.remove("map:"))

   chan.say(addr)

 else

   # Normal talking, just say it.

   chan.say(cmd)

 end

strip()

Retire tous les espaces, tabulations ou nouvelles lignes au début et à la fin d'une chaîne, puis retourne une copie.

to_i()

Essaie de changer cette chaîne en nombre.

 #!ruby

 "23".to_i

   #=> 23

 "02-Blueberry_Boat.mp3".to_i

   #=> 2

Regarde bien le second exemple. Puisque le nom du MP3 commence par un nombre,

la méthode to_i va poursuivre et utiliser cela comme le nombre.

to_sym()

Créer un symbole du même nom que la chaîne. Regarde la page Symbol pour en savoir plus sur la pertinence des symboles.

 #!ruby

 "Feed".to_sym

   #=> :Feed

Même si n'importe quelle chaîne peut être transformer en symbole, tu ne devrais pas transformer de grandes chaînes en symboles. De telles choses peuvent vraiment mettre des batons dans les roues de ton travail.

upcase()

Fabrique une nouvelle chaîne à partir de cette chaîne, mais avec toutes les lettres en minuscules de la chaîne transformées en lettres capitales. "a" devient "A",

"b" devient "B", et ainsi de suite.

Symbole

Un symbole est un type très très simple de chaîne. Les symboles font que le code parait un peu plus joli. Au lieu de mettre des guillemets, place juste un double-point au début du mot et tu obtiens un :symbol!

Les symboles sont plutôt primitifs, aussi préféreras-tu sans doute éviter de les utiliser lorsque tu peux utiliser une chaîne.

Il y a deux bonnes raisons d'utiliser un symbole:

En tant que clef d'un dictionnaire. Les symboles apparaissent bien plus clairement comme clef d'un hachage.

 #!ruby

 livre = {:titre => "Mother Night", :auteur => "Kurt Vonnegutt"}

Regarde comme il est facile de voir les clefs lorsqu'elles sont notées comme symboles. Si tu as des chaînes pour les clefs, ls guillemets deviennent rapidement de trop. Tu peux évidemment utiliser des chaînes, si tu préfères, mais la plupart des gens penses que les symboles présentent une syntaxe plus propre.

 #!ruby

 livre[:titre]

   #=> "Mother Night"

Ceci s'applique aussi lorsque tu utilises des méthodes dont la syntaxe se rapproche de celle des hachages.

 #!ruby

 Web.fetch("metafilter.com", :as => Web::Feed)

Dans la définition de classe. Ceci s'applique aux utilisateurs plus avancés. Parfois tu utiliseras des méthodes telles que attr_accessor ou define_method. Ces méthodes sont aussi plus lisibles avec des symboles.

 #!ruby

 class Creature

   attr_accessor :life, :strength, :charisma, :weapon

 end

Donc, en résumé: les symboles sont super pour les clefs de dictionnaire ou lorsque elles apparaissent dans les définitions de classes et sont uniquement utilisés pour que le code soit plsu clair.

to_s()

Génère une chaîne avec le nom du symbole.

 #!ruby

 :Feed.to_s

   #=> "Feed"

Time

Un objet Time contient un format spécifique de date et de temps, de l'ordre de la milliseconde. Et aussi des information sur la zone horaire.

Tu peux toujours obtenir la date précise avec Time.now!

 Time.now

   #=> Mon Apr 16 09:10:01 -0400 2007

Tu verras aussi le temps utilisé pour les messages dans les salons de discussion de Hackety Hack.

Tout comme dans un message, la méthode at indique l'heure d'envoi du message.

 #!ruby

 chan.hear.each do |m|

   puts m.at

 end

Normalement, tu ne chercheras pas à modifier les objets Time. Tu voudras simplement les changer en chaînes de caractères. Les objets Times propose différents formats..

 #!ruby

 Time.now.calendar

   #=> "April 16th, 2007"

 Time.now.calendar_with_time

   #=> "April 16th, 2007 at 6:27 PM"

 Time.now.time_only

   #=> "6:27 PM"

 Time.now.quick

   #=> "Apr 16, 2007 at 6:27pm"

 Time.now.short

   #=> "2007-04-16"

 Time.now.full

   #=> "2007-04-16 18:27:57"

Une autre méthode courante est la méthode since (depuis), qui indique la durée écoulée à partir d'un instant donné.

 #!ruby

 Time.local(2001, 9, 11).since

   #=> "5 years"

 Time.now.since

   #=> "less than a minute"

Time.local( année, mois, jour, heure, minute, seconde, milliseconde )

Crée un nouvel objet Time pour ta zonde horaire locale. Cette méthode prend plusieurs nombres, en commencant par l'année pour aller jusqu'à la milliseconde.

 #!ruby

 Time.local(2007)

   #=> Mon Jan 01 00:00:00 -0400 2007

 Time.local(2001, 9, 11)

   #=> Tue Sep 11 00:00:00 -0400 2001

Comme tu peux le voir, tu peux oublier des nombres. Si tu indique un seul nombre, il considérera le premier jour et la première seconde de cette année. Si tu précises quatre nombres, Ruby te donnera la première seconde de cette heure pour cette date.

Time.now()

Donne l'heure courante. Tout de suite.

calendar()

Transforme le temps en chaîne au format "Mois Jour Année".

Ceci est tout indiqué pour afficher une date lisible, comme celle que tu lis sur un journal ou sur un calendrier.

 #!ruby

 Time.now.calendar

   #=> "April 16th, 2007"

calendar_with_time()

La date calendaire de la méthode calendar avec l'heure à la fin.

 #!ruby

 Time.now.calendar_with_time

   #=> "April 16th, 2007 at 6:27 PM"

full()

Une chaîne complète de date, aussi courte que possible, et au format:

ANNÉE-MOIS-JOUR HEURES:MINUTES:SECONDES. L'affichage de l'heure est au format "24 heures".

 #!ruby

 Time.now.full

   #=> "2007-04-16 18:27:57"

quick()

Une chaîne complète de date avec le nom du mois abrégé, d'encombrement limité. Pratique pour les blogs et les forums, où les dates doivent restées compactes.

 #!ruby

 Time.now.quick

   #=> "Apr 16, 2007 at 6:27pm"

short()

Une abbréviation de la date au format ANNÉE-MOIS-JOUR.

 #!ruby

 Time.now.short

   #=> "2007-04-16"

time_only()

Retourne une chaîne à partir de l'heure, avec AM et PM, et sans préciser le jour, le mois ou l'année.

 #!ruby

 Time.now.time_only

   #=> "6:27 PM"

zone()

Le nom de la zone horaire que représente cet objet Time.

 #!ruby

 Time.now.zone

   #=> "EST"

URI

Une URI est une adresse web. Tu auras probablement affaire aux URIs (aussi appelées URLs) à l'occasion et cette classe rend la chose un peu plus aisée.

Par exemple, tu dois parfois mettre une URI à part. Prenons cette recherche Google:

 http://www.google.com/search?hl=en&q=Hackety+Hack&btnG=Search

Quel bazard! Tu ne peux pas en faire grand chose. Organisons là:

 #!ruby

 uri = URI("http://www.google.com/search?hl=en&q=Hackety+Hack&btnG=Search")

 puts uri.host

   #=> "www.google.com"

 puts uri.path

   #=> "/search"

 puts uri['q']

   #=> "Hackety Hack"

Beaucoup mieux! Maintenant tu peux voir le host(hôte) et le path (chemin) de l'URI. La meilleure partie reste la dernière ligne, où la clef q est extraite de l'URI.

La clef q est la partie de la chaîne Google où sont conservés les termes de la recherche.

Un autre exemple est l'URI YouTube?:

 http://youtube.com/watch?v=on7btklYzX4

La clef v de l'URI contient le code de la vidéo:

 #!ruby

 uri = URI("http://youtube.com/watch?v=on7btklYzX4")

 puts uri['v']

   #=> "on7btklYzX4"

La bibliothèque Web

La bibliothèque Web contient des méthodes pour télécharger des fichiers et récupérer des informations sur le web.

Bien qu'elle soit vraiment minuscule, la bibliothèque web embarque:

• des méthodes Downloads qui enregistrent les fichiers internet ou lisent des flux de nouvelles.

• des méthodes Search pour obtenir les résultats des recherches Google et Yahoo.

• et, les classes Page Web pour faire tes propres pages web et les afficher rapidement.

Download

Télécharger des fichiers et lire des blogs est enfantin grâce à Hackety Hack. C'est généralement une seule ligne de Web.download ou Web.fetch.

Une ligne vraiment fantastique est le lecteur de blog:

 #!ruby

 blog = Web.fetch("http://rubyinside.com", :as => Web::Feed)

Cette ligne de code va visiter l'adresse du blog et essayer de trouver sont flux RSS. RSS signifie [Really Simple Syndication]. C'est un fichier que proposent la plupart des blog et qui contient les derniers articles de ce blog.

Une fois récupéré le flux du blog, tu peux parcourir ces entrées:

 #!ruby

 blog.items.each do |item|

   puts "Titre: #{item.title}"

   puts "Liens: #{item.link}"

   puts item.description

 end

Web.download( url: a String , save_as: a String )

Si tu veux suavegarder une fichier w<eb sur ton ordniateur, utilise Web.download avec deux arguments. Le premier est l'URL du fichier sur le web. Le second argument est le nom du fichier sur ton ordinateur.

 #!ruby

 Web.download("http://example.org/songs/Y-Fford-Oren.mp3", "y-fford-oren.mp3")

Web.fetch( url: a String )

Si tu veux récupérer une page web et l'enregistrer dans une variable, utilise Web.fetch.

 #!ruby

 google = Web.fetch("http://google.com/search")

Lorsque Web.fetch rencontre un flux RSS ou XML, tu récupéreras un objet Web::Feed contenant les nouvelles. Si Web.fetch rencontre un fichier JSON, tu récupérera un objet à l'interieur de ce fichier JSON.

Search

La recherhce est un grosse partie du web. Ces deux méthodes, Web.google et Web.yahoo, te permettent d'embarquer les moteurs de recherche directement dans ton programme.

Tu peux même écrire ton propres moteur de recherche personnalisé , afin de chercher uniquement sur certain site. Les méthodes Web.google et Web.yahoo ont toutes deux une clef :site dans laquelle ont peu préciser une liste des sites à utiliser:

 #!ruby

 Web.google( "hackety hack", :site => ["redhanded.hobix.com", "rubyinside.com"])

   #=> [(Web::Feed::Item), (Web::Feed::Item), ...]

Web.google( search: a String )

Effectue une recherche Google. Donne lui une chaîne avec les mots de ta recherche (ou un tableau de mots) et elle te retournera un tableau avec les résultats de ta recherche. Les résultsts sont tous au format Web::Item (exactement comme tu les vois dans le flux des blogs).

 #!ruby

 Web.popup do

   Web.google("hackety hack").each do |item|

     title item.title

     link_to item.link

     para item.description

   end

 end

Cette recherhce propose quelques clefs que tu peux utiliser pour améliorer ta recherche:

• :exact cherchera les mots dans l'ordre exacte où ils sont présent dans la chaîne.
  

(Exemple: :exact => true)

• :limit indique à la recherche combien de résultat elle doit prendre.
  

(Exemple: :limit => 30)

• :page prend les 2nd, 3ème, 4ème pages de la recherche, etc.

(Exemple: :page => 2)

• :site recherche uniquement dans la liste des sites que tu fournis.
  

(Exemple: :site => ["digg.com", "slashdot.org"])

Web.yahoo( recherche: une chaîne )

Effectue une recherche Yahoo!. Fourni lui une chaîne avec les mots de ta recherche. Tu récupères un tableau de Web::éléments. Tout comme Web.google descrite avant.

 #!ruby

 puts Web.yahoo("hackety hack")

Cette recherche propose quelques clefs que tu peux utiliser pour améliorer ta recherche:

• :exact cherchera les mots dans l'ordre exacte où ils sont présent dans la chaîne.
  

(Exemple: :exact => true)

• :limit indique à la recherche combien de résultat elle doit prendre.
  

(Exemple: :limit => 30)

• :page prend les 2nd, 3ème, 4ème pages de la recherche, etc.

(Exemple: :page => 2)

• :site recherche uniquement dans la liste des sites que tu fournis.
  

(Exemple: :site => ["digg.com", "slashdot.org"])

Pages

Contruit des pages HTML à partir de zéro.

Web.page { ... }

Puisque Hackety Hack est construit sur les bases d'un navigateur internet, tu peux faire des pages web sur la page de programme masquée. Je dois proposer une façon d'expliquer tout ceci...

 #!ruby

 Web.page {

   h1 'Mes liens'

   ul {

     li { a 'Google', :href => 'http://google.com' }

     li { a 'Hackety Hack', :href => 'http://code.whytheluckystiff.net/hacketyhack/' }  

   }

 }

Web.popup { ... }

Ouvre une fenêtre popup. À l'intérieur du bloc, crée un contenu popup exactement comme c'est expliquer ci-dessus dans Web.page above.

 #!ruby

 Web.popup {

   h1 'Es-tu certain?'

   buttons { Annuler; Enregistrer }

 }

Web.popup( name: a String ) { ... }

C'est une variation de la fenêtre popup précédente. Tu crées toujours un popup à l'intérieur du bloc.

La différence se situe dans la chaîne que tu passes à la méthode. La chaîne sera utilisée pour lier la popup à une table.

 #!ruby

 Web.popup("Blog") do

   titre "Ajouter une entrée"

   editline "Titre"

   editbox

   buttons { Annuler; Enregistrer }

 end

Dans cet exemple, la fenêtre popup conservent ces informations dans la table Blog. Deux choses seront conservées dans la table: les champs d'éditions editline, appelées "Titre" et "Editbox". Si la table n'existe pas , elle sera crée à partir du popup.

Regarde aussi l'aide sur les Tables pour en savoir plus sur l'utilisation des tables.