Share
Welkom bij Ruby on Rails van Scratch Week 3! Deze week concentreren we ons op specifieke dingen die u moet weten over het kader. We gaan het bijvoorbeeld hebben over het manipuleren van de structuur van het project op twee manieren (renderen en doorverwijzen). We zullen het ook hebben over hoe u links in rails toevoegt en hoe u een opmerking maakt over de code. Laten we al beginnen!
Als u delen 1 en 2 niet hebt gelezen, wordt u sterk aangeraden deze te lezen voordat u verder gaat met deze zelfstudie.
Nu we hebben geleerd hoe we instantievariabelen kunnen instellen om informatie van de controller naar de weergave over te zetten, is het tijd om te leren hoe gegevens tussen verschillende acties in een controller kunnen worden verzonden. Voor deze zelfstudie gaan we door met het gebruiken van de leercontroller. We hoeven niet echt te houden wat we vorige week hebben gedaan, maar als je denkt dat het een goede bron is .. We beginnen eenvoudig:
Voor dit voorbeeld is de kop complexer dan de eigenlijke les. We gaan gewoon gebruiken wat in één actie is en hetzelfde doen in een andere. Laten we de kennis gebruiken die we vorige week hebben opgedaan over instantievariabelen en deze nu toepassen. Laten we eerst een nieuwe actie maken met de naam "another_action"; dan een andere actie genaamd "tekst". We gaan dan de actie van tekst halen en in "another_action" plaatsen. We gaan dit bewijzen door te verwijzen naar een instantievariabele in de weergave van "another_action" die is toegewezen in de "tekst" -controller. Sorry, als dat niet klopte. Als je niet hebt gekregen wat ik net zei, kijk dan naar de volgende code, die je hopelijk zal helpen:
klasse LearnController < ApplicationController def another_action text end def text @text = 'This text came from another action' end end
We gaan vervolgens een weergave maken met de naam "another_action.html.erb", waar we verwijzen naar de variabele tekst.
Actiedemo <%= @text %>
Uitleg
Zoals je kunt zien, verwezen we naar de actie "tekst" door simpelweg dat in "another_action" te plaatsen. Door dit te doen, hebben we ook de definitie van 'tekst' doorgegeven, die de instantievariabele was. Laten we dit principe nog eens toelichten door dit in verschillende situaties te plaatsen, die allemaal werken.
klasse LearnController < ApplicationController def another_action @text = text end def text misc_text = 'This text really traveled!' end end
Nu gaan we nog ingewikkelder worden:
klasse LearnController < ApplicationController def another_action @text = "text you'll never see" @text = text end def text wanted_text = overwrite_view end def overwrite_view overwrite_text = 'This text overwrote the original text' end end
Dit is de volgorde van de gebeurtenissen die de volgende code deed:
We zullen deze eenvoudiger houden:
klasse LearnController < ApplicationController def another_action @text = "text you'll never see" text end def text @text = 'This text overwrote the original text' end end
klasse LearnController < ApplicationController def another_action @text = text end def text first = 'This text should not be passed to @text' second = 'This text would be put into the variable on default' return first end end
Dit voorbeeld is vooral belangrijk omdat u nu een beetje meer syntaxis leert; de terugkeer commando. Dit zal de actie vertellen wat te retourneren aan het einde.
Iedereen zou al moeten weten hoe een normale HTML-link te maken. (Gebruik makend van Tekst) Maar er is ook een manier om het met Rails te doen. Deze methode is geen Ruby, maar eerder een onderdeel van het framework. Dat gezegd hebbende, je kunt het alleen gebruiken in embedded ruby HTML-bestanden, niet in pure rb-bestanden. Dus hoe doen we het? Hier is de code:
Rails Link Demo <%= link_to('Another Action Link', :controller => 'leren',: action => 'another_action')%>
Op het eerste gezicht kun je je afvragen waarom je ooit de manier van schrijven van links zou veranderen, vooral als de vervanging langer duurt! Eén van de belangrijkste redenen is leesbaarheid. Je kunt dit gemakkelijk lezen en precies weten waar het naar toe gaat. Wat de lengte betreft, is de: controller => deel niet nodig als u een link maakt naar een actie binnen dezelfde controller.
Met deze stuk rails-code zien we ook symbolen. De ": controller =>" is een symbool. We zullen later praten over wat ze later doen, maar nu herkennen we gewoon de dikke darm.
Eerder in deze serie hebben we een beetje gesproken over de verstandige standaardwaarden van rails. Een van de standaardwaarden is om een weergave te genereren die dezelfde naam heeft als de actie in de bijbehorende weergave. Maar wat als we wilden overschrijven wat rails automatisch doet? Dit is eigenlijk vrij eenvoudig en een zeer nuttige techniek. Wanneer je aan een echt wereldproject werkt, kun je je voorstellen hoe 'onhandig' je controller zou worden als je voor elke pagina een afzonderlijke weergave en actie in de controller moest maken. Rails heeft echter een oplossing, die rendering wordt genoemd. rendering kunt u opgeven welke weergave u voor elke actie wilt gebruiken. Houd er echter rekening mee dat, net als rails links, dit ook rails exclusieve code en niet robijn, en alleen bedoeld voor de controller.
Als het bovenstaande je een beetje in de war heeft gelaten, laat me je dan zien hoe je het moet doen. Dit zal het hopelijk een beetje verhelderen. Voor dit eerste voorbeeld gaan we de actie weergeven in de weergave die deze normaal toch zou weergeven. Met andere woorden, deze rendercode doet niets dat zonder haar niet zou gebeuren. Het enige wat het aan het doen is, is een code tonen die meestal gewoon 'aangenomen' is.
def index renderen: action => 'index' einde
Het laatste voorbeeld is niet echt nuttig, omdat het resultaat sowieso automatisch wordt bereikt. Maar wat als u een echt geavanceerde weergave had voor een andere actie en u dezelfde weergave wilde voor een andere actie. Het zou niet alleen vervelend zijn om nog een identieke weergave te maken voor elke actie die u maakt, maar het zou ook bijna onmogelijk zijn om bij te werken! Dat alles kan echter worden opgelost door elke vergelijkbare actie aan een specifieke actie te geven. Bestudeer het volgende stuk code dat ik naderhand zal uitleggen en let op de verschillende delen.
text_controller.rb:
klasse LearnController < ApplicationController def index render :action => 'tekst' end def text @text = 'Tekst'end def other @text ='anders'render: action =>' tekst 'einde
text.html.erb:
Rails Rendering Demo Welkom bij de <%= @text %> Pagina
Indexactie
Het is je misschien opgevallen dat ik een actie met de naam 'index' heb opgenomen. Deze actie wordt bekeken als u een map opent om te "leren". Het werkt als een gewoon indexbestand. U hoeft echter geen specifieke actie voor de index te maken. U kunt ook het eerder behandelde onderwerp van het overnemen van een andere actie gebruiken.
Terugkerende naar dezelfde weergave
Voor dit voorbeeld hadden we slechts één weergave nodig voor alle acties; en ze produceerden allemaal verschillende pagina's. Voor mij is dit vrij ongelofelijk voor de hoeveelheid werk die we hebben gedaan.
Opmerking: dit lijkt voor sommigen vanzelfsprekend, maar pas op voor dubbele weergave. Dubbele weergave veroorzaakt een fout omdat u een actie probeert weer te geven op twee verschillende plaatsen. Kun je op twee plaatsen tegelijkertijd zijn? Nee, en geen enkele actie. Als u wilt zien hoe het eruit ziet, kunt u een actie weergeven in twee verschillende weergaven. De reden dat dit gebeurt terwijl je meer complexe projecten doet, is omdat het spoor van acties behoorlijk ingewikkeld kan worden en je per ongeluk deze fout kunt maken.
Zorg ervoor dat je het basisconcept rendering krijgt, omdat het een zeer vitale techniek is die je vaak als railsontwikkelaar zult gebruiken.
Een actie omleiden is vergelijkbaar met het weergeven van een actie in het feit dat het ook een railscode is en alleen in de controller wordt gebruikt. Het beïnvloedt ook de stroom van de applicatie. Zoals je misschien uit de naam kunt raden, kun je met redirecting ... goed doorverwijzen.
U zult zich misschien verbazen over het aantal keer dat u de omleidingsopdracht gebruikt. Hier zijn enkele veelvoorkomende toepassingen:
Genoeg chit-chat, laten we naar de code gaan! Voor dit codevoorbeeld gaan we de controller van het laatste voorbeeld wijzigen en de weergave ongewijzigd laten. Zoals u zult zien, is redirecting qua indeling vergelijkbaar met rendering:
klasse LearnController < ApplicationController def index redirect_to :action => 'tekst' end def text @text = 'Tekst'redirect_to: action =>' other 'end def other render: action =>' text 'end end
Ga nu naar de indexactie in uw browser. U zult merken dat u terechtkomt bij de andere actie in uw adresbalk. Laten we deze code eens doorlopen:
Hoewel er enkele voor de hand liggende scenario's zijn die u zou kiezen voor renderen of omleiden; er kunnen moeilijkere beslissingen zijn. Een belangrijke sleutel is echter dat als u gegevens indient in een database of iets dat de toepassing wijzigt, een omleiding gebruikt. Anders kan een vernieuwing de gegevens opnieuw verzenden.
Ik hoop dat jullie veel hebben geleerd van de tutorial van deze week! We hebben veel belangrijke concepten behandeld, dus als je nog steeds door alles verward bent, lees het dan opnieuw. Volgende week zullen we waarschijnlijk in ruby-syntax raken!
Zoals altijd, voel je vrij om vragen achter te laten in de comments. Ook, digg dit artikel als het u heeft geholpen!
Accentsconagua