Première nuit
Commencer à apprendre Ruby on Rails sans même une connaissance minimale de Ruby lui-même serait étrange. J'ai déjà suivi le guide interactif ruby-lang.org. Mais en le passant, il oublia tout de suite. Ses créateurs promettent qu'il faudra quinze minutes pour parcourir et maîtriser la syntaxe Ruby. Il m'en a fallu trente. C'est vrai, avec une distraction constante sur Twitter. Le processus ressemble à ceci. Ils vous disent : « Les tableaux dans Ruby sont déclarés comme ceci, et les données des tableaux sont récupérées comme ceci. Essayons maintenant de créer un tableau et d'en extraire N éléments. Et on vérifiera." Vous lisez comment tout fonctionne et l'essayez immédiatement. Bien sûr, vous ne pouvez pas apprendre Ruby comme ça. Mieux vaut le considérer comme un cours super express qui fonctionne. Pourtant, Ruby lui-même est loin du framework Ruby on Rails. Je voulais maîtriser exactement les rails. De notre article sur l'éducation en ligne, je me suis définitivement souvenu du cours sensationnel Zombie for Rails railsforzombies.org. C'est comme Try Ruby, un didacticiel interactif qui commence à vous apprendre à préparer des applications ferroviaires dès le départ. Tout d'abord, ils vous lisent une mini-conférence (en anglais, mais tout est très clair - activez les sous-titres) sur la structure des fichiers d'une application ferroviaire, l'approche CRUD pour travailler avec des données, ils expliquent comment le modèle MVC est implémenté dans les rails , etc. Après chaque vidéo, vous êtes invité à effectuer des tâches pour consolider le matériel. Tout semble simple et direct, le parcours passe inaperçu en une heure ou deux (c'est petit). Mais! Après le cours, ai-je senti que je pouvais rédiger une candidature ferroviaire ? Malheureusement non!Deuxième nuit
L'une des raisons pour lesquelles certaines connaissances de base émergent après Rails for Zombies, mais il n'y a aucune certitude, est l'environnement virtuel dans lequel l'apprentissage a lieu. D'une part, il réduit le seuil d'entrée à la limite : vous n'avez pas à vous soucier de l'environnement. D'un autre côté, vous ne créez rien de réel en cours de route - pas de "Hello World" à la fin. Et surtout, on ne sait pas de quel côté aborder sa création. À partir de ce moment, j'ai voulu essayer Ruby on Rails en pratique, l'installer sur le système (avant cela, vous ne pouviez même pas essayer) et créer une application simple à partir de zéro. Je ne me souviens pas comment, mais tout à fait par accident, je suis tombé sur un cours de screencast très réussi sur rails.hasbrains.org en russe. Merci à l'auteur pour la présentation compétente: il explique méthodiquement les principes de l'application ferroviaire en détail, vous plongeant dans toutes les subtilités nécessaires en cours de route. Bref, le deuxième soir de l'expérience, j'ai regardé la première moitié de plus de trente épisodes de ces screencasts. Une image de la façon dont l'application est générée, comment travailler avec la console ferroviaire, comment créer des modèles et des migrations, comment mettre à jour les modèles et comment valider les données qu'ils contiennent, les contrôleurs RESTful, etc., est enfin fixée dans ma tête. En regardant chacun des épisodes, j'ai immédiatement tout essayé en action, créant une application ferroviaire entièrement fonctionnelle. Il est devenu clair comment les rails sont disposés en principe.Troisième nuit
Le troisième soir, il restait les derniers épisodes de screencasts, que j'ai réussi à regarder d'une seule traite : travailler avec des rails ne me semblait plus aussi sauvage. À ce stade, quelqu'un m'a dit que le cours Rails for Zombies avait une suite sensée et beaucoup plus profonde. Certes, le cours est déjà payant et est hébergé par la Code School www.codeschool.com. Ce n'était pas dommage de donner 25 dollars pour avoir accès à tous les cours de l'école. Il s'agit d'un coût mensuel, donc si vous ne l'aimez pas, n'oubliez pas d'annuler votre abonnement. Le cours Rails for Zombies 2 s'est avéré être un véritable succès. Certes, beaucoup de choses sont devenues une répétition de ce que j'ai vu dans les screencasts - mais c'était même plutôt agréable. Cinq niveaux et cinq blocs d'exercices que vous faites directement dans la console interactive. À ce stade, les rails semblaient déjà logiques, compréhensibles et utilisables. Dans Code School, vous pouvez programmer directement dans le navigateur en complétant les devoirs de coursEt après?
Ai-je appris à faire des projets complexes ? Non. Mais j'ai définitivement réalisé les approches utilisées dans les rails et compris leur commodité. J'ai appris à créer rapidement des applications simples et en très peu de temps à augmenter ses fonctionnalités à l'aide de gemmes écrites par la communauté. J'ai pris le courage et suis heureux d'apprendre les meilleures pratiques dans les programmes de Code School (je regarde maintenant un cours sur les tests unitaires). Et je suis tellement heureux que la technologie soit devenue si facile à apprendre.Beaucoup de mes collègues développeurs parlent de Rails de manière flatteuse, mais je n'arrivais pas à comprendre pourquoi. Qu'est-ce que Rails et en quoi est-il réellement différent de Ruby on Rails ? Est-il difficile d'apprendre ? Est-ce vraiment un langage de programmation ? Que dois-je savoir avant d'apprendre Ruby on Rails ?
Ces questions et bien d'autres tournaient constamment dans ma tête, mais il s'est avéré que je ne suis pas le seul. Nos lecteurs étaient également intéressés par cette question, alors pour en savoir plus à ce sujet, j'ai décidé de poser à l'un de mes collègues quelques questions de base sur Ruby. C'est ainsi qu'est né cet article.
Tu est prêt? Aller!
13 faits sur Ruby on Rails - Que devez-vous savoir ?
1. Qu'est-ce que Rails ?
Rails est un framework d'applications Web conçu pour écrire du code Ruby. Cela semble déroutant, n'est-ce pas ?
Essayons encore. Il y a le langage de programmation Ruby. C'est un plaisir d'écrire dessus. Soit dit en passant, la personne qui l'a créé a déclaré que son objectif principal était de créer un langage qui améliorerait la vie des programmeurs. N'est-ce pas merveilleux ?
Laisse moi te donner un exemple.
Si je veux afficher du texte à l'écran en PHP, je dois écrire
écho « Bonjour le monde » ;
Vous voyez le point-virgule ? Et cet "écho" - qu'est-ce que ça veut dire ?
D'un autre côté, si je dois faire la même chose en Ruby, je devrai écrire ce qui suit :
met "Bonjour le monde"
Pas de point-virgule, et bien que "puts" puisse paraître un peu adolescent, je trouve cela plus logique que "echo". Lorsque vous écrivez du code pendant des heures, ces petits détails jouent un GRAND rôle.
Le seul problème avec Ruby était qu'il n'était pas conçu pour créer des applications Web. C'est-à-dire que vous ne pourrez pas créer un site Web dessus, par exemple. C'était avant Rails. Je ne sais pas si Rails a été le premier framework Web pour Ruby, mais c'est CERTAINEMENT le plus populaire.
La mission de Rails est de fournir un cadre et des capacités qui vous permettront de créer des applications Ruby, telles qu'un site Web. Jusqu'à présent, cela semble plutôt flou, alors je vais essayer de l'expliquer comme ceci. Si j'écrivais
met "Bonjour le monde"
alors dans un document HTML, vous verriez le texte entier. Mais je veux que vous voyiez SEULEMENT ceci :
Bonjour le monde
En termes simples, Rails vous permet de le faire. Mais ce n'est pas tout.
2. Qu'est-ce que Ruby on Rails ?
Ruby on Rails est le nom officiel COMPLET du framework Rails. Mais dans la conversation, les développeurs ne disent généralement pas la première partie et l'appellent simplement Rails. Donc, si vous voulez être « au top » et avoir l'air féru de technologie, vous devriez certainement l'appeler Rails, mais RAPPELEZ-VOUS ce que signifie cette première partie - « Ruby on ».
3. J'ai entendu dire que Rails est parfait pour les débutants. Pourquoi?
Il y a plusieurs raisons pour lesquelles Rails est idéal pour les débutants. Le premier est que le langage Ruby lui-même est vraiment bon pour les débutants, et c'est le premier avantage. Il est beaucoup plus facile d'apprendre à écrire du code en Ruby que dans d'autres langages, car le langage est assez flexible et libéral, ce qui vous épargnera des nerfs et vous permettra de consacrer plus de temps à l'apprentissage des bases de la programmation.
Pourquoi Rails est-il si agréable pour les débutants ? C'est juste très stable et fait une énorme couche de travail pour vous.
Pour moi, travailler chez Rails, c'est comme conduire un camion cargo. Il est incroyablement puissant, regardez - vous conduisez un camion !!! Cependant, savez-vous bien comment fonctionne la voiture que vous conduisez ?
Le fait que Rails soit responsable de tant de tâches, les faisant pour vous, vous permettra d'être immédiatement satisfait. grande quantité avantages sympas. Cependant, cela peut parfois jouer contre vous, si parfois vous vous dépassez et n'apprenez pas complètement les bases que vous devez simplement connaître.
Pour cette raison, il est très important d'apprendre Ruby on Rails à partir de zéro. Plus important encore, vous devez vous assurer que vous êtes vraiment à l'aise avec Ruby. Sinon, vous allez juste sortir de ce camion à mi-chemin et vous dire : "Attends, est-ce que j'ai vraiment fait ce truc ?"
4. En quoi Rails diffère-t-il d'un développeur Ruby ?
Techniquement, la différence est qu'un pur "développeur Ruby" créera des applications en Ruby, mais pas en Rails. Bien que cela, en règle générale, ne se produise pas. Il est certainement possible de créer des applications Web Ruby en utilisant d'autres frameworks comme Sinatra, mais je parie que 99% du temps, il est peu probable que vous soyez embauché en tant que programmeur Ruby. Par conséquent, vous devez quand même apprendre Rails.
5. Dans quelle mesure devrais-je bien connaître Ruby ? Que dois-je apprendre avant de commencer la formation ?
Il existe différentes opinions à ce sujet, mais en suivant l'exemple du gros camion, je pense que vous devriez vous sentir à l'aise de travailler avec Ruby afin d'approfondir Rails. Tout comme, disons, il vaut mieux d'abord apprendre à faire du vélo, avant de passer à une voiture de tourisme, puis réfléchir à la façon de conduire un camion.
Et voici autre chose. Lorsque vous travaillez sur Rails, vous passez beaucoup de temps à écrire du code Ruby. Pour cette raison, vous devez très bien connaître ce langage, en particulier ses bases : types de données, méthodes, orientation objet, débogage, etc. Et vous n'avez pas besoin d'être un programmeur Ruby super expérimenté - vous devez juste vous sentir aussi confiant qu'un poisson dans l'eau lorsque vous travaillez avec.
6. Pourquoi devrais-je apprendre Rails ? Qu'est-ce qui le rend spécial ?
C'est exquis et tout simplement incroyable. Que devez-vous savoir d'autre ? Lorsque Rails est apparu pour la première fois, ce fut une véritable découverte et un accomplissement dans l'art du design. Avec les meilleures pratiques qui ont été prises en compte lors de sa création, Rails vous guide pratiquement sur le chemin de l'écriture de bon code, même si vous ne le souhaitez pas (ou ne savez pas comment le faire).
Si vous souhaitez créer des applications Web robustes qui évoluent selon les besoins et sont faciles à entretenir à l'avenir, Rails est une excellente option. De plus, il est populaire auprès de nombreuses entreprises cool. La dernière grande raison pour laquelle Rails est si populaire parmi les startups est qu'il est idéal pour se moquer rapidement. En quelques heures seulement, vous pouvez concevoir, créer et exécuter l'application Rails dont vous avez besoin. Il y a en fait très peu d'autres frameworks qui pourraient gérer cela.
7. Que pouvez-vous créer avec Rails ?
Que veux-tu créer ? Rails convient à toutes les applications Web. Pour une référence rapide, consultez ces excellents exemples de sites basés sur Rails : Hulu, Airbnb et Basecamp.
8. Puis-je créer des applications mobiles Rails ?
Oui et non. Vous ne pourrez pas créer d'applications mobiles dans Rails, mais dans Rails, vous pouvez certainement créer une application Web et l'utiliser comme back-end pour application mobile.
Il existe également un outil appelé RubyMotion, qui facilite la création d'applications natives iOS et Android dans Ruby (mais pas Rails). C'est-à-dire que vous n'utiliserez PAS SPÉCIFIQUEMENT Rails pour créer une application mobile pour Magasin d'applications mais Rails peut certainement être une partie importante de votre projet mobile. Espérons que l'image soit plus claire maintenant.
9. Ruby on Rails - Quel genre de travail puis-je obtenir ?
Rails est l'une des compétences les plus demandées à l'heure actuelle, il existe donc un large éventail d'entreprises avec lesquelles travailler. Rails est particulièrement apprécié des startups comme Zearn. Il s'agit d'une start-up, une entreprise informatique éducative à but non lucratif. Vous pouvez également choisir une plus grande entreprise comme Bloomberg et participer au développement de sites Web et d'applications utilisés par des millions d'utilisateurs. Le travail indépendant est également une bonne option pour les développeurs Rails. Étant indépendant, vous pourrez choisir les projets auxquels vous souhaitez participer : petits et à court terme ou sérieux et à long terme.
10. J'ai essayé un autre langage de programmation, mais je ne l'ai pas aimé. Dois-je essayer Rails ?
Je tiens à souligner à nouveau - Rails n'est en fait pas un langage de programmation, mais un framework. Si vous vous demandez s'il est utile d'essayer d'aimer un langage de programmation, je ne peux dire qu'une chose - Ruby est le langage de programmation le plus vénéré et le plus préféré des utilisateurs dans le monde. Je n'abandonnerais donc pas la programmation tant que vous n'aurez pas essayé Ruby.
11. Puis-je apprendre JavaScript avec Rails ?
Au lieu de cela - non. De plus - Sans aucun doute.
Le développeur Rails devra apprendre JavaScript(). Ce n'est pas une exigence pour apprendre Rails, mais c'est une compétence dont vous aurez besoin au fur et à mesure de votre apprentissage.
Pour être honnête, au fur et à mesure que vous vous plongerez dans le domaine de la technologie, vous commencerez à vous rendre compte que vous devrez avoir un assez grand nombre de compétences (en fait, cela signifie que tout le monde doit s'efforcer d'être un développeur Full-Stack) . Heureusement, au fur et à mesure que vous acquerrez de l'expérience, il vous deviendra plus facile d'apprendre à la fois de nouveaux langages et de nouveaux frameworks.
Quant à savoir lequel choisir - JavaScript ou Rails - je vais vous dire sans ambages que vous ne pouvez pas vous tromper de toute façon. Ruby me semble beaucoup plus facile à apprendre que JavaScript. De plus, je connais beaucoup de gens qui ont trouvé JavaScript plus facile après avoir appris Ruby pour la première fois. Mais, comme je l'ai dit plus haut, vous ne vous tromperez certainement pas si vous étudiez les deux.
12. Combien de temps durera la formation ?
Combien de temps par jour devrez-vous consacrer à l'entraînement ? Je pense qu'il faut des mois de formation spéciale pour bien comprendre Rails. Mais comme pour toute compétence, il faut des dizaines de milliers d'heures pour devenir un pro Rails, il est donc préférable de ne pas perdre de temps et de commencer tout de suite.
La vitesse d'apprentissage sera grandement influencée par votre niveau de connaissances dans le domaine de la programmation en général. Mais si vous êtes un débutant complet, Ruby et Rails valent la peine d'être essayés.
13. Ruby on Rails - Par où commencer ?
Je recommande de commencer par le meilleur cours Ruby on Rails de la journée. Si vous n'avez pas écrit une seule ligne de code dans votre vie, la première chose à faire est de suivre le cours HTML et CSS. Heureusement, les cours sur HTML et CSS sont faciles à trouver. Après cela, vous devrez apprendre Ruby, Git et la ligne de commande.
Dans le cadre de votre programme, vous serez généralement guidé progressivement vers Rails en vous apprenant à travailler avec Sinatra et ActiveRecord. Cela ne vous dit rien pour le moment, mais l'essentiel est qu'avant de conduire ce "camion" que j'ai mentionné plus tôt, vous devez commencer par des cours de conduite simples sur Rails.
La meilleure chose à faire pendant l'apprentissage est de créer votre propre projet, de travailler sur quelque chose et de développer, de comprendre que vous avancez dans la bonne direction et d'avoir un bon soutien ! Au cours du processus d'apprentissage, vous aurez des millions de petites questions, et pour obtenir le meilleur résultat, il est important que vous ayez quelqu'un qui puisse vous aider à comprendre et suggérer quelque chose si vous rencontrez des difficultés.
Alexander est le fondateur du projet de site Internet « Web Laboratory of Success », créé pour accompagner les entrepreneurs Internet débutants et confirmés. Un bourreau de travail convaincu, derrière qui l'expérience professionnelle de gestion du comité éditorial d'un magazine Internet, création et gestion de sa propre boutique en ligne . Occupation principale : promotion commerciale (y compris les magasins en ligne) via Facebook et Google Adwords. Passe-temps principal : monétiser les sites via des outils de marketing d'affiliation et Google Adsense. Record personnel confirmé : 3 millions de visiteurs du blog par mois.
Apprendre un nouveau langage de programmation peut prendre beaucoup de temps et être extrêmement ennuyeux. Les développeurs .Net vont devenir furieux en ce moment et s'exclamer : "Pourquoi devrais-je apprendre cela, parce que je suis un développeur .Net professionnel, et mon emploi du temps quotidien ne sera probablement pas en mesure de se faufiler dans le processus d'apprentissage d'un nouveau Langue!" Mais ce sera une déclaration extrêmement imprudente, car lors de l'apprentissage de nouveaux langages de programmation, vous apprenez beaucoup de choses nouvelles et utiles, surtout si ce langage est une version mise à jour d'un autre langage existant auparavant. Ruby est exactement ce type de langage. Je conviens que le processus de passage d'un développeur débutant à un développeur professionnel dans un langage de programmation est le processus le plus difficile, mais l'expérience en vaut la peine. Maintenant, je ne peux que vous mettre au courant, et je suis sûr que vous ne voudrez certainement pas vous arrêter. Allez-y doucement!
Remarque : Veuillez noter que cet article n'est qu'une introduction superficielle à Ruby (un langage de programmation) et à Rails (une application de plate-forme). L'objectif principal est de vous mettre à jour avec Ruby et de vous motiver à donner l'impulsion nécessaire pour commencer. nouveau langage la programmation.
Qu'est-ce que Ruby ?
Ruby, comme mentionné, est une combinaison mise à jour de différentes approches de programmation. Ruby est un excellent mélange de l'approche de workflow facile à comprendre de Python, de la sophistication de Smalltalk et du style léger qui accompagne le développement de Perl. Ruby est un haut niveau de programmation orientée objet (comme c'est le cas avec la plupart des autres langages de programmation aujourd'hui), qui a commencé au milieu des années 90 au Japon. Au fil du temps, Ruby s'est propagé aux États-Unis et en Europe.
Ruby est connu pour son système de type dynamique et son allocation de mémoire automatique. Par type dynamique, je veux dire que la plupart des types vérifiés dans un programme Ruby sont exécutés au démarrage, ce qui signifie que vous n'avez pas à vous soucier des types entiers ou minuscules. Ruby le fait pour vous. nous le verrons dans petit exemple plus tard.
L'objectif principal du démarrage de Ruby était de permettre aux gens d'interagir plus facilement avec les machines et de comprendre le code. Le fondateur de Ruby, Yukihiro Matsumoto, insiste sur l'idée que Ruby a été conçu pour améliorer la productivité des programmeurs, et non pour optimiser une application du côté machine.
«Souvent, les gens, en particulier les ingénieurs informaticiens, se concentrent sur les machines. Ils pensent qu'en faisant cela, il est possible d'accélérer le fonctionnement de la machine, d'augmenter son efficacité, qu'il est possible de tout améliorer, tout, tout sur la machine. » Ils s'accrochent aux machines. Mais en réalité, nous devons concentrer notre attention sur les personnes, prendre soin d'elles, faciliter le processus de travail avec les applications via les machines. Nous sommes réels et vivants, et les machines n'obéissent qu'à nous.
Qu'est-ce que Rails ?
Rails est une application de plate-forme incroyablement productive écrite en Ruby par David Heinemeier Hansson. Le développement d'applications Web Rails devrait être 10 fois plus rapide que la plate-forme Java. Rails est un framework open source (bien sûr !) basé sur Ruby que vous pouvez utiliser pour intégrer votre base de données rapidement et facilement.
Rails est connu pour ses idées exceptionnellement de première classe qui ont permis diverses nouvelles approches de programmation et la création d'un cadre de programmation dynamique. Le code principal de l'application et la base de données mise à jour incluront toujours toutes les propriétés Ruby requises pour exécuter le programme du début à la fin.
Programme Ruby régulier
Voyons à quel point les choses sont simples et intéressantes après cela :
Le code:
personnel = "Je n'aime pas ma copine"
met personnel
A la sortie :
je n'aime pas ma copine
Oui oui! Aucune initialisation, aucun point-virgule et aucune méthode.
Essayons maintenant de voir la différence entre PHP et Ruby en utilisant l'exemple d'un cas où nous devons inverser une chaîne :
PHP :
strrev (« chaîne ») ;
Rubis:
"Chaîne" .reverse
Voila ! Nous ne passons pratiquement pas de temps et renversons complètement la séquence des enregistrements. Il faut tenir compte de la différence des efforts faits dans les deux langues. Un langage de programmation basé sur Ruby facilite grandement le processus d'écriture d'un programme. Cela ressemble à l'écriture en anglais plutôt qu'à un langage de programmation. C'est l'avenir de toutes les langues.
Avantages de l'utilisation de Ruby (et Rails)
Tout le monde sait que le monde Ruby est très vaste, et aujourd'hui nous n'avons même pas couvert 1%, mais cette entrée vous permettra de ressentir le pouvoir de cette langue programmation et vous stimulera à commencer à la connaître vous-même. Plongeons maintenant dans le monde des avantages Ruby :
* Disponibilité... Comme indiqué précédemment, c'est l'un des principaux avantages de Ruby. En tant que langage de programmation, Ruby est très raffiné et ressemble beaucoup à langue Anglaise... C'est la similitude avec la langue parlée commune qui permet aux débutants de se familiariser facilement avec le travail avec Ruby.
* Concision et puissance... L'exemple ci-dessus nous montre à quel point le code Ruby est concis. C'est aussi concis que possible. De plus, Ruby est un langage aussi puissant que d'autres langages peuvent l'être, car c'est un langage de programmation orienté objet de haut niveau.
* pas besoin de réinventer la roue... Rails (basé sur Ruby) est une interface de programmation avec laquelle vous n'avez plus à réinventer la roue. Il génère du code qui peut être utilisé plusieurs fois dans différents cas.
* Tests intégrés... Rails est populaire pour sa sécurité et sa patchabilité. La plateforme vous fournira options possiblesécrire du code, ce qui facilitera grandement le processus de développement. De plus, Rails fournit quelques tests simples qui peuvent être étendus selon les souhaits des programmeurs.
* Environnements de développement, de test et de production... Rails vous permet de démarrer votre projet dans trois environnements différents appelés Dev, Test et Prod. Les trois environnements se comportent légèrement différemment.
Une sélection
Jetons maintenant un coup d'œil à certains des sites Web (populaires) qui ont été développés à l'aide de l'outil Ruby. Vous verrez à quel point les concepteurs sont intelligents pour gérer leurs projets avec Ruby.
02.
03.
04.
05.
06.
Le principal mérite de tout concepteur de sites Web est de pouvoir comprendre - et même organiser - ce qui se passe dans les coulisses.
À tout le moins, vous devriez prendre des leçons de programmation. Je ne parle pas des langages frontaux comme HTML et CSS - vous en connaissez probablement déjà beaucoup. Je parle de trucs de back-end.
Si vous savez poser les bases, vous comprendrez mieux comment concevoir le reste du site. Le fait est qu'apprendre à programmer fera de vous un concepteur plus érudit. De plus, qui ne voudrait pas embaucher un designer qui sait tout, de la conception au développement de sites Web ?
L'astuce consiste à choisir un endroit pour commencer. Apprendre la programmation peut être un processus délicat, surtout si vous choisissez l'un des langages les plus difficiles comme C++ ou PHP.
Alors, quel est le meilleur endroit pour commencer ? Il n'y a qu'une seule réponse : Ruby on Rails est l'un des meilleurs langages de programmation et frameworks pour apprendre les bases du design.
Pourquoi Ruby est-il le meilleur choix ?
Pour les débutants, Ruby est l'un des langages les plus faciles à apprendre, surtout si vous avez une certaine expérience HTML ou CSS que la plupart des concepteurs ont.
L'un des premiers programmes que vous ferez lorsque vous commencerez à apprendre une langue est le tristement célèbre Hello World, qui consiste à afficher ces mots à l'écran.
Avec des langages comme C++, il peut y avoir de cinq à sept lignes de code juste pour afficher ces deux mots. Mais si vous utilisez Ruby, il n'y aura qu'une seule ligne et une seule commande.
Met "hello, world!"
C'est tout! C'est tout ce dont vous avez besoin pour taper les mots "Hello world!" sur l'écran. Assez facile, non?
Ruby on Rails est aussi un langage très sec. En tant que l'un des principes de développement, DRY (dry) signifie « Ne vous répétez pas » - c'est-à-dire, ne programmez pas à nouveau l'élément lorsque vous pouvez utiliser celui que vous avez déjà créé. Cela fait de Ruby un langage de programmation très léger et souvent utilisé pour le développement, car il vise à terminer rapidement et efficacement un projet.
Rubis ou Rails ?
Ruby est un langage de programmation. Rails est un framework qui utilise Ruby pour faire le travail. Le framework Ruby on Rails est une collection de code pré-construit ou pré-écrit qui peut aider à accélérer le processus de création de nouveaux projets. Il a été créé à l'origine pour développer l'outil de gestion de projet Basecamp. Outre Basecamp, il existe d'autres applications Web populaires construites avec Rails telles que 500px, ThemeForest et MyFitnessPal.
Une fois que vous avez compris comment travailler avec le langage Ruby et que le matériel fonctionne dans le framework Ruby on Rails, vous pouvez commencer à créer des applications Web.
Ruby est à son apogée !
Grâce à l'explosion de popularité appareils mobiles et une technique qui est toujours en contact, Ruby est incroyablement populaire maintenant. Et, probablement, il en sera ainsi à l'avenir. L'indice TIOBE classe Ruby comme le 13ème langage de programmation le plus populaire. Conformément aux tendances émergentes, selon Indeed.com, Ruby connaît également une demande étonnamment forte.
Indice TIOBE
Dans tous les cas, quel que soit votre choix - demande ou popularité - Ruby est très populaire. Cela en fait l'un des meilleurs endroits pour commencer, car une fois que vous maîtrisez la langue, vous pouvez faire le travail assez rapidement. Et c'est avant de commencer à apprendre une autre langue pour élargir vos compétences.
Ruby a une base solide !
Certains des autres langages existent depuis plus longtemps, c'est vrai, mais même ainsi, le support et la documentation sont dérisoires par rapport à ce qui est disponible pour Ruby. D'autres langues manquent également de cohésion sociale autour d'un cadre hautement pris en charge.
Grâce au framework Ruby On Rails, il existe déjà des tonnes de code préexistant que vous pouvez utiliser dans vos propres projets. Ruby Gems, une bibliothèque de frameworks Ruby, propose plus de 600 000 bibliothèques parmi lesquelles choisir.
Chaque fois que vous apprenez quelque chose de nouveau, vous avez besoin de beaucoup de documentation et de support. Il y a une tonne d'endroits à trouver matériel éducatif, des tutoriels, des tutoriels et même des forums de questions-réponses. Si vous rencontrez un problème spécifique, une simple recherche sur le Web le résoudra probablement. C'est important.
Une documentation simple et un accès facile au support sont essentiels lorsque vous apprenez une nouvelle langue - lorsque vous apprenez réellement quelque chose de nouveau.
Ruby "permet" plus de contrôle sur la conception
Si vous n'êtes qu'un concepteur de sites Web, la création d'un site Web peut être un processus long et complexe. Lorsque vous vous asseyez pour travailler avec un programmeur et discuter du back-end nécessaire pour votre site, vous devez souvent sacrifier le front-end pour que tout fonctionne correctement.
En fin de compte, cela peut conduire à un produit qui semble complètement différent de votre vision d'origine. Le programmeur ne s'en souciera peut-être pas, mais ce sera probablement problématique pour vous.
Vous ne rencontrerez pas de problèmes de ce genre si vous programmez vous-même. Vous n'avez pas besoin de dépendre des autres pour obtenir un projet fini, et vous aurez une bien meilleure compréhension de ce qui peut être réalisé en termes de développement. Il y a sûrement eu un moment ou deux où les objectifs de votre projet étaient trop élevés pour un programmeur ou une équipe de développement ? Lorsque vous apprenez une langue comme Ruby, vous pouvez en revanche profiter de la facilité de compréhension des besoins et des possibilités.
Fondamentalement, Ruby est destiné à être utilisé dans les applications Web et le développement Web, c'est donc l'endroit idéal pour les concepteurs Web en herbe. Une fois que vous aurez compris ce langage et appris à utiliser le framework Ruby on Rails, vous aurez beaucoup plus de contrôle sur vos projets.
Où apprendre Ruby ?
La meilleure façon d'apprendre une langue est de s'immerger et de travailler avec elle. Il existe également de nombreux tutoriels et tutoriels auxquels vous pouvez vous référer. Si vous avez une mémoire visuelle développée et que vous comprenez mieux grâce aux présentations visuelles, alors allez-y sur YouTube - il y a un grand choix de vidéos de formation.
Si vous souhaitez un apprentissage traditionnel en classe, vous pouvez vous former sur des sites dédiés à l'apprentissage de la programmation. Vous n'avez pas besoin d'aller à l'université ou au collège pour obtenir un diplôme professionnel.
L'une de mes ressources préférées - et entièrement gratuite - pour apprendre Rails est le didacticiel Rails de Michael Hartl. Il vous guidera d'un projet simple à un projet complexe à votre propre rythme d'apprentissage, et vous pourrez repartir de zéro sans aucune connaissance de Ruby on Rails.
Quelle que soit la voie d'apprentissage que vous choisissez, rappelez-vous que seule la pratique mène à l'excellence. Fixez-vous des objectifs personnels pour passer un certain temps chaque jour à travailler avec Ruby. Tenez-vous-en à ces objectifs et persévérez. Avant de connaître ce langage jusqu'au bout, vous serez déjà un expert capable de créer des projets fantastiques.
Ce guide couvre l'installation et l'exécution de Ruby on Rails.
Après l'avoir lu, vous découvrirez :
- Comment installer Rails, créer une nouvelle application Rails et attacher votre application à la base de données.
- La structure générale d'une application Rails.
- Principes de base du MVC (Model, View Controller) et de la conception basée sur RESTful.
- Comment générer rapidement le code d'application Rails initial.
Hypothèses dans ce guide
Ce tutoriel est destiné aux débutants qui souhaitent démarrer une application Rails à partir de zéro. Cela ne signifie pas que vous avez déjà travaillé avec Rails.
Rails est un framework de développement Web écrit dans le langage de programmation Ruby. Si vous débutez avec Ruby, il peut être difficile de démarrer immédiatement avec Rails. Il existe de bonnes ressources en anglais pour apprendre Ruby, par exemple :
Notez que certaines des ressources, bien qu'elles soient toujours excellentes, couvrent toujours les anciennes versions de Ruby telles que la 1.6, et surtout la 1.8, et n'incluent pas une partie de la syntaxe que vous verrez dans votre développement Rails au quotidien.
Qu'est-ce que Rails ?
Rails est un framework de développement Web écrit dans le langage de programmation Ruby. Il est conçu pour faciliter la programmation d'applications Web en utilisant un certain nombre d'hypothèses sur ce dont chaque développeur a besoin pour créer un nouveau projet. Il vous permet d'écrire moins de code lors de la programmation que les autres langages et frameworks. Les développeurs professionnels de Rails notent également que le développement d'applications Web est plus amusant avec =)
Rails est magistral Logiciel... Il part du principe qu'il existe une "meilleure" façon de faire quelque chose, et il est conçu pour encourager cette façon - et dans certains cas même décourager les alternatives. Si vous étudiez "The Rails Way", vous découvrirez probablement une augmentation significative de la productivité. Si vous persistez et transférez d'anciennes habitudes d'autres langages dans le développement Rails, et essayez d'utiliser des modèles appris ailleurs, votre expérience de développement sera moins heureuse.
La philosophie de Rails comprend deux principes directeurs importants :
- Ne vous répétez pas : DRY est un principe de développement logiciel qui stipule que "Chaque élément d'information doit avoir une représentation unique, non redondante et faisant autorité dans le système." N'écrivez pas les mêmes informations encore et encore, le code sera plus facile à maintenir et plus extensible et moins bogué.
- Convention sur la configuration: Rails a des opinions sur la meilleure façon faire beaucoup de choses dans une application Web, et ces conventions sont exposées par défaut, au lieu de vous obliger à modifier de nombreux fichiers de configuration dans de petits détails.
Créer un nouveau projet Rails
La meilleure façon d'utiliser ce didacticiel est de le parcourir étape par étape. Toutes les étapes sont essentielles à l'exécution de l'exemple d'application et aucun code ou étape supplémentaire n'est requis.
En suivant ce tutoriel, vous allez créer un projet Rails appelé blog, un blog web très simple. Avant de commencer à construire notre application, nous devons nous assurer que Rails lui-même est installé.
Les exemples suivants utilisent $ pour désigner une chaîne d'entrée de terminal dans UNIX-like systèmes d'exploitation ah, bien qu'il puisse être configuré différemment. Si vous utilisez Windows, la ligne ressemblera à c: \ code_source>
3.1. Installation des rails
Avant d'installer Rails, vous devez vérifier que les pré-dépendances requises sont installées sur votre système. Ceux-ci incluent Ruby et SQLite3.
Ouvrir des applications pour ligne de commande... Sur macOS, ouvrez Terminal.app, sur Windows, choisissez Exécuter dans le menu Démarrer et tapez cmd.exe. Toutes les commandes commençant par un signe dollar $ doivent être exécutées sur la ligne de commande. Assurez-vous que la version actuelle de Ruby est installée :
$ ruby -v ruby 2.5.0
Rails nécessite l'installation de Ruby 2.5.0 ou version ultérieure. Si le numéro de version est inférieur à cela, vous devrez installer une nouvelle copie de Ruby.
Pour installer rapidement Ruby et Ruby on Rails sur un système, Utilisateurs Windows pouvez utiliser le programme d'installation de Rails. Méthodes supplémentaires les paramètres de la plupart des systèmes d'exploitation peuvent être consultés sur ruby-lang.org.
Si vous utilisez Windows, vous devez installer le kit de développement Ruby Installer.
Vous aurez également besoin d'une installation de base de données SQLite3.
De nombreux systèmes d'exploitation de type UNIX sont livrés avec une version acceptable de SQLite3. Sous Windows, si vous avez installé Rails à l'aide du programme d'installation de Rails, vous avez déjà installé SQLite. Les autres utilisateurs peuvent se référer aux instructions d'installation sur le site Web de SQLite3. Vérifiez qu'il est correctement installé et inclus dans votre PATH :
$ sqlite3 --version
Le programme doit signaler sa version.
Pour installer Rails, utilisez la commande gem install fournie par RubyGems :
$ gem installer des rails
Pour vérifier que tout est correctement installé, vous devez procéder comme suit :
$ rails --version
Si vous voyez quelque chose comme "Rails 6.0.0", vous pouvez continuer.
3.2. Création de l'application Blog
Rails est livré avec un certain nombre de scripts appelés générateurs, conçus pour faciliter la vie du développeur en créant tout ce qu'il faut pour démarrer une tâche donnée. L'un est le New Application Generator, qui vous fournit les bases d'une application Rails afin que vous n'ayez pas à l'écrire vous-même.
Pour utiliser ce générateur, ouvrez un terminal, allez dans le dossier où vous avez l'autorisation de créer des fichiers et écrivez :
$ rails nouveau blog
Cela créera une application Rails nommée Blog dans le répertoire du blog et installera les gems dont les dépendances sont mentionnées dans le Gemfile à l'aide de l'installation du bundle.
À en utilisant Windows Sous-système pour Linux, il existe certaines restrictions de message système de fichiers, ce qui signifie désactiver le ressort et écouter les gemmes, ce qui peut être fait en exécutant rails new blog --skip-spring --skip-listen.
Vous pouvez voir toutes les options de ligne de commande possibles que le générateur d'applications Rails accepte en exécutant rails new -h.
Une fois que vous avez créé l'application de blog, accédez à son dossier :
Le répertoire du blog contient plusieurs fichiers et dossiers générés automatiquement qui définissent la structure de votre application Rails. La plupart des travaux de ce didacticiel auront lieu dans le dossier de l'application, mais pour l'instant, passons en revue les fonctions de chaque dossier créé par Rails dans la nouvelle application par défaut :
| Dossier de fichiers | Rendez-vous |
|---|---|
| application / | Contient des contrôleurs, des modèles, des vues, des assistants, des expéditeurs, des canaux, des travaux et des actifs pour votre application. Nous examinerons ce dossier plus en détail plus tard. |
| poubelle / | Contient des scripts Rails qui démarrent votre application, et le répertoire peut également contenir d'autres scripts que vous utilisez pour configurer, mettre à jour, déployer ou exécuter. |
| configuration / | Les configurations de route, la base de données de votre application, etc. Ceci est couvert plus en détail dans Configuration des applications Rails. |
| config.ru | Configuration en rack pour les serveurs en rack utilisés pour exécuter l'application. Pour plus d'informations sur Rack, consultez le site Web Rack. |
| db / | Contient le schéma actuel de votre base de données ainsi que les migrations de base de données. |
| Gemfile Gemfile.lock |
Ces fichiers vous permettent de spécifier les dépendances gems dont votre application Rails a besoin. Ces fichiers sont utilisés par la gem Bundler. Pour plus d'informations sur Bundler, consultez le site Web de Bundler. |
| lib / | Modules externes pour votre application. |
| Journal / | Fichiers journaux des applications. |
| package.json | Ce fichier vous permet de spécifier quelles dépendances npm sont nécessaires pour votre application Rails. Ce fichier est utilisé par Yarn. Pour plus d'informations sur Yarn, consultez le site Web Yarn. |
| Publique / | Le seul dossier accessible de l'extérieur tel quel. Contient des fichiers statiques et des actifs compilés. |
| Rakefile | Ce fichier recherche et charge les tâches qui peuvent être exécutées à partir de la ligne de commande. Une tâche spécifique est disponible dans tous les composants Rails. Au lieu de modifier le Rakefile, vous pouvez ajouter vos propres tâches en ajoutant des fichiers au répertoire lib/tâches de l'application. |
| LISEZMOI.md | Il s'agit d'un didacticiel d'introduction à votre application. Il doit être édité pour dire aux autres ce que fait votre application, comment la configurer, etc. |
| stockage / | Fichiers de stockage actifs pour le service de disque. Ceci est couvert dans le guide Présentation du stockage actif. |
| test / | Tests unitaires, montages et autres appareils de test. Ceci est couvert dans le didacticiel Testing Rails Applications. |
| tmp / | Fichiers temporaires (tels que les fichiers cache et pid) |
| vendeur / | Un emplacement pour le code tiers. Dans une application Rails typique, inclut des gems externes. |
| .gitignore | Ce fichier indique à git les fichiers (explicitement ou sauvagement) à ignorer. Pour plus d'informations sur l'ignorance des fichiers, consultez GitHub - Ignorer les fichiers. |
| .ruby-version | Ce fichier contient la version Ruby par défaut. |
Salut les Rails !
Tout d'abord, affichons du texte à l'écran. Cela nécessite un serveur en cours d'exécution pour votre application Rails.
4.1. Lancement du serveur Web
En fait, vous avez déjà une application Rails fonctionnelle. Pour être sûr, vous devez exécuter un serveur Web sur votre machine. Cela peut être fait en exécutant la commande suivante à partir du répertoire du blog :
Si vous utilisez Windows, vous devez diriger les scripts du dossier bin directement vers l'interpréteur Ruby, c'est-à-dire le serveur ruby bin \ rails.
La compression des actifs JavaScript nécessite une exécution JavaScript sur votre système, et son absence entraînera une erreur execjs lors de la compression des actifs. Généralement, macOS et Windows sont livrés avec un runtime JavaScript installé. therubyrhino est l'environnement d'exécution recommandé pour les utilisateurs de JRuby et est ajouté au fichier Gemfile si l'application est générée avec JRuby. Vous pouvez tout savoir sur les runtimes pris en charge dans ExecJS
Cela démarrera Puma, le serveur Web par défaut avec Rails. Pour voir l'application en action, ouvrez une fenêtre de navigateur et accédez à http:// localhost: 3000. Vous devriez voir la page d'informations Rails par défaut :
Pour arrêter le serveur Web, appuyez sur Ctrl + C dans le terminal où il s'exécute. Vous devriez voir à nouveau le curseur de la ligne de commande pour vérifier que le serveur a été arrêté. Pour la plupart des systèmes de type UNIX, y compris macOS, ce sera le signe dollar $. En mode développement, Rails ne nécessite généralement pas d'arrêter le serveur ; toutes les modifications que vous apportez aux fichiers sont automatiquement récupérées par le serveur.
La page Welcome Aboard est comme un test pour une nouvelle application Rails : elle montre que vos programmes sont suffisamment configurés pour afficher la page.
4.2. Dites bonjour à Rails
Pour que Rails dise bonjour, vous devez créer au moins manette et vyuhu(représentation).
Le contrôleur a pour but de recevoir des requêtes spécifiques pour l'application. Routage décide quel contrôleur recevra quelles demandes. Il y a souvent plus d'une route vers chaque contrôleur, et différentes routes peuvent être gérées différemment. jeux d'action... Le but de chaque action est de collecter des informations à présenter à la vue.
Le but d'une vue est d'afficher ces informations dans un format lisible. Une distinction importante à faire est que le lieu de collecte des informations est manette, pas une vue. La vue ne doit afficher que ces informations. Par défaut, les modèles de vue sont écrits dans un langage appelé eRuby (Embedded Ruby), qui est converti par une boucle de requête Rails avant d'être envoyé à l'utilisateur.
Pour créer un nouveau contrôleur, vous démarrez le générateur « contrôleur » et lui dites que vous voulez un contrôleur nommé « Bienvenue » avec une action nommée « index », comme ceci :
$ rails generate controller Index de bienvenue
Rails va créer des fichiers et un itinéraire.
Créer une application / contrôleurs / route welcome_controller.rb obtenir "bienvenue / index" invoquer erb créer une application / vues / bienvenue créer une application / vues / bienvenue / index.html.erb invoquer test_unit créer un test / contrôleurs / welcome_controller_test.rb invoquer l'aide créer une application / helpers / welcome_helper.rb invoquer test_unit invoquer des actifs invoquer scss créer une application / actifs / feuilles de style / welcome.scss
Les plus importants d'entre eux sont, bien sûr, le contrôleur situé dans app / controllers / welcome_controller.rb et la vue située dans app / views / welcome / index.html.erb.
Ouvrez app / views / welcome / index.html.erb dans un éditeur de texte. Supprimez tout le code existant dans le fichier et remplacez-le par la ligne de code suivante :
Si vous soumettez à nouveau le formulaire, vous verrez quelque chose comme ce qui suit :
Cette action affiche maintenant les paramètres de l'article provenant du formulaire. Cependant, cela reste inutile. Oui, vous pouvez voir les paramètres, mais essentiellement ne faites rien avec eux.
5.4. Création du modèle d'article
Les modèles dans Rails utilisent un nom au singulier et leur table de base de données correspondante utilise un nom au pluriel. Rails fournit un générateur de modèles que la plupart des développeurs Rails utilisent pour créer de nouveaux modèles. Pour créer un nouveau modèle, exécutez cette commande dans votre terminal :
$ rails generate model Titre de l'article : string text : text
Avec cette commande, nous disons à Rails que nous voulons un modèle d'article avec l'attribut Titre type de chaîne et attribut texte type de texte. Ces attributs seront automatiquement ajoutés à la table des articles et liés au modèle d'article.
Rails créera une série de fichiers en réponse. Maintenant, nous ne nous intéressons qu'à app / models / article.rb et db / migrate / 20140120191729_create_articles.rb (votre nom peut être légèrement différent). Ce dernier est chargé de créer la structure de la base de données, c'est pourquoi nous l'examinerons plus loin.
Active Record est suffisamment intelligent pour associer automatiquement les noms de colonnes aux attributs du modèle, ce qui signifie que vous n'avez pas besoin de déclarer les attributs dans les modèles Rails, Active Record le fera automatiquement.
5.5. Exécution de la migration
Comme vous l'avez vu, les rails génèrent le modèle généré le fichier migrations de bases de données dans le répertoire db/migrate. Migrations est une classe Ruby conçue pour faciliter la création et la modification de tables de base de données. Rails utilise des commandes rake pour exécuter les migrations, et il est possible d'annuler la migration une fois qu'elle a été appliquée à votre base de données. Le nom du fichier de migration comprend un horodatage pour garantir qu'ils sont exécutés dans l'ordre dans lequel ils ont été créés.
Si vous regardez dans le fichier db/migrer/AAAAMMJJHHMMSS_create_articles.rb (rappelez-vous, votre fichier a un nom légèrement différent), voici ce que vous y trouvez :
Créer des articles de classe< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end
Cette migration crée une méthode de modification appelée lorsque cette migration démarre. Les actions définies dans cette migration sont également réversibles, ce qui signifie que Rails sait comment annuler les modifications apportées par cette migration au cas où vous décideriez de les annuler ultérieurement. Lorsque vous exécutez cette migration, elle crée une table d'articles avec une colonne de chaîne et une colonne de texte. Il créera également deux champs d'horodatage pour suivre quand l'article a été créé et mis à jour.
Nous devons maintenant utiliser la commande rails pour lancer la migration :
$ rails db : migrer
Rails exécutera cette commande de migration et signalera qu'il a créé la table Articles.
Créer des articles : migrer ================================================ == - create_table (: articles) -> 0.0019s == CreateArticles: migré (0.0020s) ============================== ============
Puisque vous travaillez dans l'environnement de développement par défaut, cette commande s'appliquera à la base de données définie dans la section développement de votre fichier config/base de données.yml. Si vous souhaitez migrer dans un environnement différent, par exemple en production, vous devez le passer explicitement lorsque vous invoquez la commande : rails db: migrate RAILS_ENV = production.
5.6. Sauvegarde des données dans le contrôleur
De retour dans ArticlesController, nous devons modifier l'action de création pour utiliser le nouveau modèle d'article afin de conserver les données dans la base de données. Ouvrez app/controllers/articles_controller.rb et modifiez l'action de création comme suit :
Def create @article = Article.new (params [: article]) @ article.save redirect_to @article end
Voici ce qui se passe ici : chaque modèle Rails peut être initialisé avec les attributs appropriés qui se lieront automatiquement aux colonnes de base de données correspondantes. Dans la première ligne, nous faisons exactement cela (rappelez-vous que params [: article] contient les attributs qui nous intéressent). Ensuite, @ article.save est responsable de l'enregistrement du modèle dans la base de données. Enfin, nous redirigeons l'utilisateur vers l'action show, que nous définirons plus tard.
Vous vous demandez peut-être pourquoi le A dans Article.new est en majuscule, bien que toutes les autres références d'articles de ce didacticiel soient toutes en minuscules. Dans ce contexte, nous faisons référence à une classe appelée Article, qui est définie dans app/models/article.rb. Les noms de classe en Ruby doivent commencer par une lettre majuscule.
Maintenant qu'il y a des validations, appeler @ article.save sur un article invalide renverra false. Si vous rouvrez app / controllers / articles_controller.rb, vous pouvez voir que nous ne vérifions pas le résultat de l'appel de @ article.save dans l'action de création. Si @ article.save échoue dans cette situation, nous devons à nouveau montrer le formulaire à l'utilisateur. Pour ce faire, remplacez les actions new et create dans app/controllers/articles_controller.rb par celles-ci :
Def new @article = Article.new end def create @article = Article.new (article_params) if @ article.save redirect_to @article else render "new" end end private def article_params params.require (: article) .permit (: title ,: texte) fin
La nouvelle action crée maintenant une nouvelle variable d'instance nommée @article, et vous verrez pourquoi dans quelques paragraphes.
Notez que dans l'action de création, nous avons utilisé render au lieu de redirect_to lorsque save renvoie false. La méthode render est utilisée pour que l'objet @article soit renvoyé au nouveau modèle lorsqu'il est rendu. Ce rendu est fait dans le cadre de la même demande que la soumission du formulaire, tandis que redirect_to indique au navigateur de faire une autre demande.
5.11. Mise à jour des articles
Nous avons découvert la partie "CR" de CRUD. Concentrons-nous maintenant sur la partie "U", en mettant à jour les articles.
La première étape consiste à ajouter une action d'édition à ArticlesController, généralement entre les actions new et create, comme indiqué.
Def new @article = Article.new end def edit @article = Article.find (params [: id]) end def create @article = Article.new (article_params) if @ article.save redirect_to @article else render "new" end finir
La vue contiendra un formulaire similaire à celui que nous avons utilisé lors de la création de nouveaux articles. Créez un fichier nommé app/views/articles/edit.html.erb et ajoutez-y les éléments suivants :
Rédaction d'article
<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %><%= pluralize(@article.errors.count, "error") %>
-
<% @article.errors.full_messages.each do |msg| %>
- <%= msg %> <% end %>
<%= form.label:title %>
<%= form.text_field:title %>
<%= form.label:text %>
<%= form.text_area:text %>
<%= form.submit %>
<% end %> <%= link_to "Back", articles_path %>Nous pointons maintenant le formulaire vers une action de mise à jour qui n'a pas encore été définie, mais nous le ferons bientôt.
Passer un objet article à la méthode form_with définira automatiquement l'URL pour soumettre le formulaire d'article modifié. Cette option indique à Rails que nous voulons que ce formulaire soit soumis en utilisant PATCH, la méthode HTTP qui devrait être utilisée pour renouvellement ressources conformément au protocole REST.
Ensuite, vous devez créer une action de mise à jour dans app / controllers / articles_controller.rb. Ajoutez-le entre l'action de création et la méthode privée :
Def create @article = Article.new (article_params) if @ article.save redirect_to @article else render "new" end end def update @article = Article.find (params [: id]) if @ article.update (article_params) redirect_to @article else render "edit" end end private def article_params params.require (: article) .permit (: title,: text) end
La nouvelle méthode, update, est utilisée lorsque vous souhaitez mettre à jour un enregistrement qui existe déjà et accepte un hachage contenant les attributs que vous souhaitez mettre à jour. Comme auparavant, s'il y a une erreur lors de la mise à jour de l'article, nous souhaitons afficher à nouveau le formulaire à l'utilisateur.
Nous avons réutilisé la méthode article_params que nous avons définie précédemment pour l'action de création.
Il n'est pas nécessaire de passer tous les attributs à mettre à jour. Par exemple, si @ article.update (title: "A new title") a été appelé, Rails mettra à jour uniquement l'attribut title, laissant tous les autres attributs intacts.
| Titre | Texte | ||
|---|---|---|---|
| <%= article.title %> | <%= article.text %> | <%= link_to "Show", article_path(article) %> | <%= link_to "Edit", edit_article_path(article) %> |
Et ajoutez également au modèle app / vues / articles / show.html.erb afin que le lien "Modifier" se trouve également sur la page de l'article. Ajoutez ce qui suit à la fin de votre modèle :
... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>
Et voici à quoi ressemble notre application maintenant :
5.12. Utilisation de partiels pour nettoyer la répétition dans les vues
Notre page d'édition est très similaire à la nouvelle page, en fait, ils utilisent le même code pour rendre le formulaire. Supprimons cette duplication en utilisant une vue partielle. Par convention, les fichiers partiels commencent par un trait de soulignement.
Créez un nouveau fichier app/views/articles/_form.html.erb avec le contenu suivant :
<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>
<%= pluralize(@article.errors.count, "error") %>interdit d'enregistrer cet article :
-
<% @article.errors.full_messages.each do |msg| %>
- <%= msg %> <% end %>
<%= form.label:title %>
<%= form.text_field:title %>
<%= form.label:text %>
<%= form.text_area:text %>
<%= form.submit %>
<% end %>Mettons à jour maintenant la vue app/views/articles/new.html.erb pour utiliser ce nouveau partiel en le réécrivant dans son intégralité :
Nouvel article
<%= render "form" %> <%= link_to "Back", articles_path %>Et idem pour la vue app/views/articles/edit.html.erb :
Modifier l'article
<%= render "form" %> <%= link_to "Back", articles_path %>5.13. Supprimer des articles
Nous sommes maintenant prêts à développer la partie "D" de CRUD, en la supprimant de la base de données. Conformément à la convention REST, la route pour supprimer des articles dans la sortie des routes de rails est la suivante :
SUPPRIMER /articles/:id(.:format) articles # détruire
La méthode de routage de suppression doit être utilisée pour les routes qui détruisent les ressources. Si vous la laissez comme une route d'obtention normale, il serait possible de créer les URL malveillantes suivantes :
regarde ce chat !
Nous utilisons la méthode delete pour détruire les ressources, et cette route est associée à une action de destruction dans app / controllers / articles_controller.rb qui n'existe pas encore. La méthode destroy est généralement la dernière action CRUD dans le contrôleur, et comme les autres actions CRUD publiques, elle doit être placée avant toute méthode privée ou protégée. Ajoutons-le :
Def destroy @article = Article.find (params [: id]) @ article.destroy redirect_to articles_path end
Le contrôleur d'articles complet dans app/controllers/articles_controller.rb devrait maintenant ressembler à ceci :
Articles de classeContrôleur< ApplicationController def index @articles = Article.all end def show @article = Article.find(params[:id]) end def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end private def article_params params.require(:article).permit(:title, :text) end end
Vous pouvez appeler destroy sur les objets Active Record lorsque vous souhaitez les supprimer de la base de données. Notez que nous n'avons pas besoin d'ajouter une vue pour cette action, car nous redirigeons vers l'index.
Liste des articles
<%= link_to "New article", new_article_path %>| Titre | Texte | |||
|---|---|---|---|---|
| <%= article.title %> | <%= article.text %> | <%= link_to "Show", article_path(article) %> | <%= link_to "Edit", edit_article_path(article) %> | <%= link_to "Destroy", article_path(article), method: :delete, data: { confirm: "Are you sure?" } %> |
Ici, nous utilisons link_to d'une manière différente. Nous passons la route nommée comme deuxième argument et options comme autre argument. La méthode :: delete et data: (confirmez: "Êtes-vous sûr?") Les options sont utilisées comme attributs html5, donc lorsque le lien est cliqué, Rails montrera d'abord à l'utilisateur une boîte de dialogue de confirmation, puis enverra le lien en utilisant la méthode de suppression . Cela se fait à l'aide du fichier JavaScript rails-ujs, qui est automatiquement inclus dans la mise en page de l'application (app / views / layouts / application.html.erb) lorsque l'application est générée. Sans ce fichier, la boîte de dialogue de confirmation ne s'affichera pas.
Félicitations, vous pouvez désormais créer, visualiser tous et individuellement, mettre à jour et détruire les articles.
Ajout d'un deuxième modèle
Il est maintenant temps d'ajouter un deuxième modèle à l'application. Le second modèle traitera les commentaires sur les articles.
6.1. Génération du modèle
Nous avons l'intention d'utiliser le même générateur que celui utilisé précédemment lors de la création du modèle Article. Cette fois, nous allons créer un modèle de commentaire contenant un lien vers l'article. Exécutez la commande suivante dans le terminal :
$ rails generate model Commenter commenter : chaîne corps : texte article : références
Cette commande génère quatre fichiers :
Tout d'abord, jetez un œil à app / models / comment.rb :
Commentaire de classe< ApplicationRecord belongs_to:article end
Ceci est très similaire au modèle Article que nous avons vu plus tôt. La différence réside dans la ligne appartient_à : article, qui définit lien Enregistrement actif. Vous verrez des liens dans la section suivante du guide.
Le mot-clé (:references) utilisé dans la commande bash est un type de données spécial pour les modèles. Il crée une nouvelle colonne dans votre base de données appelée le modèle présenté avec _id ajouté qui peut contenir valeurs numériques... Pour mieux comprendre, analysez le fichier db/schema.rb après avoir effectué la migration.
En plus du modèle, Rails a également effectué une migration pour créer la table de base de données correspondante :
Classe CréerCommentaires< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, null: false, foreign_key: true t.timestamps end end end
La ligne t.references crée une colonne numérique nommée article_id, un index pour celle-ci et une contrainte de clé étrangère pointant vers la colonne id de la table articles. Ensuite, nous commençons la migration :
$ rails db : migrer
Rails est suffisamment intelligent pour effectuer uniquement les migrations qui n'ont pas encore été exécutées pour la base de données actuelle, dans notre cas, vous verrez :
CréerCommentaires : migration =============================================== = = - create_table (: commentaires) -> 0,0115s == CreateComments: migré (0,0119s) ============================== ========
6.2. Lier des modèles
Les liens Active Record vous permettent de déclarer facilement une relation entre deux modèles. Dans le cas des commentaires et des articles, vous pouvez décrire la relation comme suit :
- Chaque commentaire appartient à un article.
- Un article peut avoir plusieurs commentaires.
En fait, c'est très proche de la syntaxe que Rails utilise pour déclarer cette relation. Vous avez déjà vu la ligne de code dans le modèle Comment (app / models / comment.rb) qui fait que chaque commentaire appartient à l'article :
Commentaire de classe< ApplicationRecord belongs_to:article end
Vous devez modifier app/models/article.rb en ajoutant l'autre côté du lien :
Article de classe< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end
Ces deux annonces mettent automatiquement à disposition une grande variété d'options. Par exemple, si vous avez une variable d'instance @article contenant un article, vous pouvez obtenir tous les commentaires appartenant à cet article dans un tableau en appelant @ article.comments.
6.3. Ajout d'un itinéraire pour commentaires
Comme pour le contrôleur de bienvenue, nous devons ajouter une route pour que Rails sache où nous voulons aller pour voir les commentaires. Ouvrez à nouveau le fichier config/routes.rb et modifiez-le comme suit :
Ressources : les articles font les ressources : les commentaires se terminent
Cela créera des commentaires comme ressource imbriquée dans les articles. C'est l'autre face de la capture des relations hiérarchiques qui existent entre les articles et les commentaires.
6.4. Générer un contrôleur
Avec le modèle en main, tournons notre attention vers la création du contrôleur approprié. Utilisons le même générateur que nous avons utilisé auparavant :
$ rails generate controller Commentaires
Quatre fichiers et un répertoire vide seront créés :
Comme pour tout blog, nos lecteurs publieront leurs commentaires immédiatement après avoir lu l'article, et après avoir ajouté un commentaire, ils seront redirigés vers la page d'affichage de l'article et verront que leur commentaire a déjà été pris en compte. À cet égard, notre CommentsController sert à créer des commentaires et à supprimer le spam, le cas échéant.
Tout d'abord, nous allons étendre le modèle d'exposition d'article (app / views / articles / show.html.erb) pour nous permettre d'ajouter nouveau commentaire:
Titre: <%= @article.title %>
Texte: <%= @article.text %>
Ajouter un commentaire:
<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>
<%= form.label:commenter %>
<%= form.text_field:commenter %>
<%= form.label:body %>
<%= form.text_area:body %>
<%= form.submit %>
<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>Cela ajoutera un formulaire à la page d'affichage de l'article, créant un nouveau commentaire lorsque l'action de création est appelée sur le CommentsController. L'appel form_with utilise ici un tableau, qui créera une route imbriquée telle que / articles / 1 / comments.
Écrivons créer dans app / controllers / comments_controller.rb :
Commentaires de la classeContrôleur< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end
C'est un peu plus compliqué que ce que vous avez vu dans l'article contrôleur. Cette effet secondaire pièce jointe que vous avez configurée. Chaque demande de commentaire garde une trace de l'article auquel le commentaire est attaché, nous résolvons donc d'abord le problème de la récupération de l'article en appelant find sur le modèle Article.
De plus, le code tire parti de certaines des méthodes disponibles pour les relations. Nous utilisons la méthode create sur @ article.comments pour créer et enregistrer un commentaire. Cela lie automatiquement le commentaire pour qu'il appartienne à un article spécifique.
Une fois que nous avons créé un nouveau commentaire, nous ramenons l'utilisateur à l'article d'origine en utilisant l'assistant article_path (@article). Comme nous l'avons vu, il appelle l'action show sur ArticlesController, qui à son tour rend le modèle show.html.erb. C'est là que nous voulons afficher les commentaires, ajoutons donc ce qui suit à app / views / articles / show.html.erb.
Titre: <%= @article.title %>
Texte: <%= @article.text %>
commentaires
<% @article.comments.each do |comment| %>Commentateur : <%= comment.commenter %>
Commenter: <%= comment.body %>
<% end %>Ajouter un commentaire:
<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>
<%= form.label:commenter %>
<%= form.text_field:commenter %>
<%= form.label:body %>
<%= form.text_area:body %>
<%= form.submit %>
<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>Vous pouvez désormais ajouter des articles et des commentaires à votre blog et les afficher aux bons endroits.
Refactorisation
Maintenant que nous avons des articles et des commentaires de travail, jetons un coup d'œil au modèle app / views / articles / show.html.erb. C'est devenu long et inconfortable. Utilisons les partiels pour le décharger.
7.1. Rendu des collections partielles
Tout d'abord, faisons un commentaire partiel montrant tous les commentaires pour l'article. Créez un fichier app/views/commentaires/_comment.html.erb et placez-y les éléments suivants :
Commentateur : <%= comment.commenter %>
Commenter: <%= comment.body %>
Ensuite, vous pouvez modifier app / vues / articles / show.html.erb comme ceci :
Titre: <%= @article.title %>
Texte: <%= @article.text %>
commentaires
<%= render @article.comments %>Ajouter un commentaire:
<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>
<%= form.label:commenter %>
<%= form.text_field:commenter %>
<%= form.label:body %>
<%= form.text_area:body %>
<%= form.submit %>
<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>Cela rendra maintenant l'application / vues / commentaires / _comment.html.erb partielle une fois pour chaque commentaire dans la collection @ article.comments. Puisque la méthode render itère sur la collection @ article.comments, elle affecte chaque commentaire à une variable locale portant le même nom que le partiel, dans notre cas comment, qui est à notre disposition dans le partiel à afficher.
7.2. Rendre une forme de manière partielle
Déplaçons également la nouvelle section de commentaires dans notre partiel. Encore une fois, créez un fichier app/views/commentaires/_form.html.erb contenant :
<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>
<%= form.label:commenter %>
<%= form.text_field:commenter %>
<%= form.label:body %>
<%= form.text_area:body %>
<%= form.submit %>
<% end %>Modifiez ensuite app/views/articles/show.html.erb comme suit :
Titre: <%= @article.title %>
Texte: <%= @article.text %>
commentaires
<%= render @article.comments %>Ajouter un commentaire:
<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>Le deuxième rendu définit simplement le modèle du partiel que nous voulons rendre, les commentaires/formulaires. Rails est assez intelligent pour mettre un trait de soulignement sur cette ligne et réaliser que vous vouliez rendre le fichier _form.html.erb dans le répertoire app/views/commentaires.
L'objet @article est disponible sur tous les partiels rendus dans la vue, puisque nous l'avons défini comme une variable d'instance.
Supprimer des commentaires
Une autre caractéristique importante du blog est la possibilité de supprimer le spam. Pour ce faire, vous devez insérer un lien dans la vue et une action de destruction dans le CommentsController.
Commentateur : <%= comment.commenter %>
Commenter: <%= comment.body %>
<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>
En cliquant sur ce nouveau lien "Destroy Comment" exécutera DELETE / articles // article_id / comments // id dans notre CommentsController, qui sera ensuite utilisé pour trouver le commentaire que nous voulons supprimer, ajoutons donc une action de destruction à notre contrôleur (app / contrôleurs / comments_controller.rb) :
Commentaires de la classeContrôleur< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end def destroy @article = Article.find(params[:article_id]) @comment = @article.comments.find(params[:id]) @comment.destroy redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end
L'action de destruction trouvera l'article que nous visualisons, trouvera le commentaire dans la collection @ article.comments, puis le supprimera de la base de données et nous ramènera pour voir l'article.
8.1. Suppression d'objets associés
Si vous supprimez un article, les commentaires associés doivent également être supprimés, sinon ils prendront simplement de la place dans la base de données. Rails vous permet d'utiliser l'option dépendante sur un lien pour y parvenir. Modifiez le modèle de l'article, app / models / article.rb, comme suit :
Article de classe< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end
Sécurité
9.1. Authentification de base
Si vous publiez votre blog en ligne, tout le monde peut ajouter, modifier et supprimer des articles ou supprimer des commentaires.
Rails fournit un système d'authentification HTTP de base qui fonctionne bien dans cette situation.
Dans ArticlesController, nous avons besoin d'un moyen de bloquer l'accès à diverses actions si l'utilisateur n'est pas authentifié. Ici, nous pouvons utiliser la méthode Rails http_basic_authenticate_with pour autoriser l'accès aux actions requises, si la méthode le permet.
Pour utiliser un système d'authentification, nous allons le définir en haut de notre ArticlesController dans app / controllers / articles_controller.rb. Dans notre cas, nous voulons que l'utilisateur soit authentifié pour chaque action sauf index et show, donc nous écrivons comme ceci :
Articles de classeContrôleur< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости
Nous voulons également autoriser uniquement les utilisateurs authentifiés à supprimer des commentaires, donc dans le CommentsController (app / controllers / comments_controller.rb) nous écrirons :
Commentaires de la classeContrôleur< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости
Maintenant, si vous essayez de créer un nouvel article, vous rencontrerez un défi d'authentification de base HTTP :
D'autres méthodes d'authentification sont également disponibles pour les applications Rails. Devise et Authlogic, entre autres, sont deux modules complémentaires populaires pour Rails.
9.2. D'autres réflexions sur la sécurité
La sécurité, en particulier dans les applications Web, est un domaine vaste et détaillé. La sécurisation de votre application Rails est décrite plus en détail dans le guide Sécurisation des applications Rails. La façon la plus simple de travailler avec Rails est de stocker toutes les données externes en UTF-8. Sinon, les bibliothèques Ruby et Rails seront souvent capables de convertir vos données natives en UTF-8, mais cela ne fonctionne pas toujours de manière fiable, il est donc préférable de s'assurer que toutes les données externes sont en UTF-8.
Si vous faites une erreur dans ce domaine, le symptôme le plus courant est un losange noir avec un point d'interrogation à l'intérieur qui apparaît dans le navigateur. Un autre symptôme courant est l'apparition de caractères tels que "ü" au lieu de "ü". Rails prend un certain nombre de mesures internes pour atténuer les cas courants de problèmes qui peuvent être automatiquement détectés et résolus. Cependant, s'il existe des données externes qui ne sont pas stockées en UTF-8, cela peut entraîner ce genre de problèmes qui ne peuvent pas être automatiquement détectés par Rails et résolus.
Les deux sources de données les plus courantes qui ne sont pas en UTF-8 sont :
- Ton éditeur de texte: La plupart des éditeurs de texte (tels que TextMate) enregistrent les fichiers au format UTF-8 par défaut. Si votre éditeur de texte ne le fait pas, cela peut entraîner Symboles spéciaux tapé dans vos modèles (comme é) apparaîtra sous la forme d'un losange avec un point d'interrogation dans le navigateur. Cela s'applique également à vos fichiers de traduction i18N. La plupart des éditeurs qui ne définissent pas la valeur par défaut sur UTF-8 (comme certaines versions de Dreamweaver) offrent un moyen de modifier les valeurs par défaut en UTF-8. Faites ceci.
- Votre base de données : Rails convertit les données de votre base de données en UTF-8 par défaut à la frontière. Cependant, si votre base de données n'utilise pas UTF-8 en interne, il se peut qu'elle ne puisse pas stocker tous les caractères saisis par l'utilisateur. Par exemple, si votre base de données utilise en interne Latin-1 et que votre utilisateur saisit le russe, l'hébreu ou caractères japonais, les données seront perdues dès leur entrée dans la base de données. Si possible, utilisez UTF-8 comme stockage interne dans votre base de données.
