Ruby on Rails handledning

Rails skapades av David Heinemeier Hansson, allmänt känd som DHH. Det är ett av de mest inflytelserika och populära verktygen för att bygga webbapplikationer. Det används av stora webbplatser som Airbnb, GitHub och Shopify.

Varför Rails?

Innan verktygskedjan installeras är det bra att förstå varför Rails fortfarande är ett populärt val för fartygping webbapplikationer snabbt.

• Rails är förpackad som en Ruby-juvel, och du kan använda den för att bygga en mängd olika applikationer.
• Det låter dig bygga vanliga webbapplikationer, e-handelswebbplatser, innehållshanteringssystem och mer.
• Rails är ett fullstack-ramverk som innehåller allt du behöver för att skapa en databasdriven webbapplikation med hjälp av Model-View-Controller (MVC)-mönstret.
• Alla lager är utformade för att fungera sömlöst tillsammans, så Rails-projekt behöver vanligtvis färre rader kod än motsvarande projekt i andra ramverk.

Hur man laddar ner och installerar Ruby på Windows

Installationsprocessen beror på ditt operativsystem. Följande avsnitt handlar om att installera Ruby på Windows, Mac och Linux.

Steg 1) Ladda ner Rubyinstaller.
Det enklaste sättet att installera Ruby på din Windows datorn är via Ruby Installer, tillgänglig på https://rubyinstaller.org/.

Kör installationsprogrammet när det har laddats ner.

Steg 2) Klicka på det nedladdade installationsprogrammet.
Double-klicka på den nedladdade installationsfilen, till exempel rubyinstaller-2.4.1-2-x64.exe.

Steg 3) Acceptera licensen.
Markera alternativknappen ”Jag accepterar licensen” och klicka på knappen ”Nästa”. Du bör se skärmen nedan.

Steg 4) Markera de två första kryssrutorna.
Markera de två första kryssrutorna för att göra det enklare att köra Ruby-skript.

Klicka på knappen ”Installera” för att starta installationen. Du bör se skärmen nedan när den är klar.

Steg 5) Klicka på Slutför.
Avmarkera inte alternativet som installerar MSYS2. Klicka på "Slutför" för att slutföra installationen. Ett kommandotolksfönster öppnas enligt nedan.

Steg 6) Installera MSYS2.
Det här steget installerar MSYS2, en byggplattform som har en pakethanterare för enkel installation av paket på Windows.

Tryck Enter för att installera alla komponenter eftersom de alla krävs för en smidig Ruby on Rails-utvecklingsmiljö. Windows.

Installation av skenor

Du bör ha Ruby installerat från föregående avsnitt. Installera sedan Rails. Du kan installera Rails med ett paket från RailsInstaller, men paketet levererar ofta inte den senaste versionen av alla nödvändiga beroenden.

Om du redan har den senaste Ruby och grundläggande RubyGems och tillägg installerade, kör helt enkelt följande kommando vid kommandotolken för att installera Rails på ditt system: gem install rails.

Du måste också installera node.js om du inte redan har det, eftersom vissa bibliotek som Rails är beroende av kräver en JavaSkriptkörning ska fungera korrekt. Hämta nod på https://nodejs.org.

En mer vanlig och föredragen metod för Windows är att använda Windows Delsystem för Linux. Det tillhandahåller en GNU/Linux-miljö med kommandoradsverktyg, verktyg och vanliga applikationer direkt inuti Windows.

Installera Ruby på Mac

Din Mac har redan Ruby förinstallerat. Den förinstallerade versionen är dock ofta föråldrad, så du bör installera en nyare version.

Det enklaste sättet att göra detta är att använda en pakethanterare som t.ex. HomebrewDu kan först behöva installera Homebrew genom att köra kommandot nedan i terminalen.

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Detta visar en varning och uppmanar dig att ange ditt lösenord. Ange ditt Mac-lösenord (tecknen visas inte när du skriver) och tryck på Enter när du är klar. Kör sedan detta Homebrew-kommando för att installera Ruby på din Mac.

brew install ruby

Kör sedan det här kommandot:

echo 'export PATH="/usr/local/bin:/usr/local/sbin:$PATH"' >> ~/.bash_profile

Detta ställer in den nya Ruby-installationen som standard Ruby på ditt system istället för den förinstallerade Ruby.

För att bekräfta att installationen lyckades, kör följande i Terminalen:

ruby --version

Detta skriver ut Ruby-versionsnumret som du har installerat. Utdata ser ut ungefär så här:

ruby 2.6.0p0 (2018-12-25 revision 66547) [x86_64-darwin18]

Installerar Ruby på Ubuntu (Linux)

Det enklaste sättet att installera Ruby Ubuntu sker via pakethanteraren apt. Kör följande kommandon i terminalen för att installera den senaste Ruby från Ubuntu förråden.

• sudo apt uppdatera – Detta uppdaterar standardinställningen Ubuntu förråden.
• sudo apt install ruby-full – Detta laddar ner och installerar den senaste Ruby-versionen.

För att bekräfta installationen, kör ruby-versionDetta skriver ut den Ruby-version du har installerat.

Montering av skenor på Ubuntu (Linux)

Följ stegen nedan för att installera Rails på din Linux-maskin.

Steg 1) Uppdatera din ädelstenshanterare genom att köra uppdateringssystem för pärlor i terminalen eller kommandotolken.

Steg 2) Körning pärla installationsskenor för att installera den senaste versionen av Rails på din dator.

Steg 3) Installera bundler-gemen för enkel hantering av gem-beroenden i Rails-applikationer. geminstallationsbuntaren.

Två principer för räls

Rails följer grundläggande principer för programvarudesign och uppmuntrar dig att också använda dem.

De två vanligaste är:

• Upprepa inte dig själv (TORR) – detta leder till koncis, konsekvent och lättskött kod.
• Konvention framför konfiguration – Rails är förkonfigurerat med förnuftiga standardvärden som passar de flesta vanliga användningsområden. Detta gör applikationsutvecklingen snabb och ger dig mindre kod att underhålla.

Rails – Projektfilstrukturer

Med Rails installerat på ditt system, skapa en Rails-applikation. I följande avsnitt går vi igenom ett Ruby on Rails-exempel genom att bygga en Todo-list-applikation. Kör följande kommando i din terminal för att skapa applikationen:

rails new todo_app

Detta kommando skapar en katalog med namnet att-göra-app i den aktuella katalogen med den grundläggande mappstrukturen för en Rails-webbapplikation, som visas nedan.

Här är de huvudsakliga katalogerna som genererats för projektet:

app – grupperar underkataloger för UI/layout (vyer och hjälpfunktioner), controllern (controllerfiler) och modellerna (affärs-/applikationslogik).

app/kontroller – lagrar kontrollfiler som används av Rails för att hantera förfrågningar från klienten.

app/tillgångar – innehåller statiska filer som behövs av programmets frontend, grupperade efter typ: JavaScript filer, bilder och stilmallar.

app/hjälpare – innehåller hjälpfunktioner som håller din applikationsmodell, vy och kontrolllogik fokuserad, liten och översiktlig.

app/modeller – innehåller filer som modellerar din applikations databas. Modellklasserna gör det mycket enkelt att arbeta med databasen.

app/visningar – innehåller mall-/layoutfilerna som användaren av din applikation interagerar med. Mallarna kombinerar HTML med data från databasen.

bin – innehåller Rails-skript som startar din applikation. Det kan också innehålla andra skript som du använder för att konfigurera och uppgradera applikationen.

config – innehåller konfigurationsfiler som t.ex. databas.yml, miljö.rb, rutter.rb, etc., som din applikation behöver för att köras.

db – innehåller filer och skript som används för att hantera din applikationsdatabas.

lib – innehåller utökade moduler för din applikation.

log – innehåller loggfiler som t.ex. server.log, development.log, test.log och production.log, används för felsökning eller övervakning av din applikation.

allmän – innehåller statiska filer och kompilerade resurser, såsom HTML-filer, JavaSkriptfiler, bilder och stilmallar.

test – innehåller testfiler som du skriver för att testa din applikations funktionalitet.

tmp – innehåller temporära filer som cache- och pid-filer.

leverantör – innehåller tredjepartsbibliotek.

Gemfiles – specificerar de grundläggande kraven för att köra din webbapplikation. Du kan gruppera ädelstenarna i utveckling, test eller produktion, och Rails vet när varje ädelsten ska inkluderas.

Gemfile.lock – till skillnad från Gemfile, som explicit listar de ädelstenar du vill ha i din applikation, innehåller Gemfile.lock dessutom andra ädelstenar som de som listas i Gemfile är beroende av. Dessa installeras automatiskt för att uppfylla beroendena.

Readme.md – använd den här filen för att dela viktig information om din applikation, till exempel vad appen gör och hur man installerar och kör den.

Rakefile – innehåller olika definitioner av rake-uppgifter som hjälper till att automatisera dagliga administrationsuppgifter i din applikation.

config.ru – en rackkonfigurationsfil som tillhandahåller ett gränssnitt till webbservern för att starta din applikation.

Ändra katalogen till att-göra-app katalog Rails genererade och körs rails-server för att starta applikationen. Typ lokalvärd: 3000 i adressfältet i din webbläsare. Du bör se skärmen nedan om allt gick bra.

Detta är standardstartsidan för din applikation. Du kommer att ändra den i ett senare avsnitt av den här Ruby on Rails-handledningen. Du kan stoppa servern genom att trycka på Ctrl + C.

Rails – Generera kommandon

Kommandot Rails generate använder mallar för att skapa många användbara saker i din applikation. Dessa generatorer sparar mycket tid.

De skriver standardkod som är nödvändig för att din webbapplikation ska fungera. räls genererar av sig själv vid kommandotolken eller terminalen för att se en lista över tillgängliga generatorer, som visas nedan.

Du kan också köra räls genererar för att se en beskrivning av vad kommandot gör. Det listar praktiska alternativ och ett användningsexempel. Figuren nedan visar utdata för att köra rails genererar kontroller.

Använd kommandot rails generate scaffold för att automatiskt skapa modellen, vyn och kontrollenheten för Todo-listapplikationen du bygger. Kör följande i din terminal (se till att du fortfarande är i att-göra-app katalog):

rails generate scaffold todo_list title:string description:text

Detta skapar ett komplett CRUD-webbgränssnitt (skapa, läsa, uppdatera, ta bort) för TodoLists-tabellen.

Ett annat användbart kommando att känna till är räls förstörDet vänder vad som helst räls genererar gör.

Räls – Sträckning

Rails routingsystem, kallat Rails-routern, hanterar alla inkommande förfrågningar till din webbapplikation. Det undersöker URL för varje begäran och mappar den till den kontrollåtgärd som ansvarar för att hantera den, med hjälp av syntaxen som anges i routes-filen (config/routes.rb).

Ruttfilen styr varje URL aspekt av din webbapplikation. Rails använder en RESTful design baserad på REST-arkitekturstilen, vilket ger en kartaping mellan HTTP-verb och begäran URLs till kontrollantens åtgärder.

Ruttfilen skapades när du sprang skenor nya tidigare. Fortsätt med Todo-applikationen du bygger och kör följande:

rails db:migrate

Se till att du fortfarande är vid roten av programmet (den att-göra-app katalog).

Starta servern igen med rails-server. Typ http://localhost:3000/todo_lists/ i din webbläsare och tryck på Enter. Du bör få tillbaka en webbsida som den nedan.

Detta är Todo-listvyn som scaffold-kommandot genererade, och den styrs av TodoListsControllers index handling.

Lägg till en att-göra-lista genom att klicka på "Ny att-göra-lista" på sidan. Du bör se skärmen nedan.

Lägg märke till URL är nu http://localhost:3000/todo_lists/newDet här är sidan för att skapa en ny Att-göra-lista, och den styrs av TodoListsController's ny metod.

Ange din Att-göra-listas titel och beskrivning i formuläret och klicka på "Skapa Att-göra-lista". URL bör ändras till http://localhost:3000/todo_lists/1, enligt nedanstående.

Detta är visningssidan för en Att-göra-lista, styrd av TodoListsController's show metod. Om du går tillbaka till http://localhost:3000/todo_lists/, bör du nu se skärmen nedan med den nya Att-göra-listan tillagd.

Rails kunde mappa varje begäran till motsvarande TodoListsController-åtgärd med hjälp av ruttdefinitionen i config/routes.rb.

Om du tittar på den här filen ser du en enda rad resurser: att-göra-listor, vilket är Rails standardsätt att skriva RESTful-rutter. Den här enda raden skapar sju rutter, alla mappadeping till TodoLists-kontrollanten.

Enligt konvention mappas varje kontrollenhetsåtgärd till en specifik CRUD-operation (skapa, läsa, uppdatera, ta bort) i databasen.

Körning spårvägar i kommandoraden för att se de olika tillgängliga rutterna i din applikation. Figuren nedan visar utdata från att köra spårvägar.

Räls – Vyer

Vylagret är en av komponenterna i MVC-paradigmet och ansvarar för att generera HTML-svaret för varje förfrågan till din applikation. Rails använder ERB (Embedded Ruby) som standard, vilket är ett kraftfullt mallsystem för Ruby.

ERB gör mallar enkla att skriva och underhålla genom att kombinera vanlig text med Ruby-kod för variabelsubstitution och flödeskontroll. En ERB-mall använder .html.erb förlängning.

Du kommer oftast att använda två taggmarkörer, som var och en gör att den inbäddade koden bearbetas och hanteras på ett visst sätt.

En tagg med ett likhetstecken <%= %> indikerar att den inbäddade koden är ett uttryck, och resultatet av koden ska ersättas med utdata när mallen renderas.

Den andra taggen utan likhetstecken <% %> indikerar för renderaren att kodens resultat inte ska ersättas eller skrivas ut i utdata.

Varje styrenhet i din Rails-applikation har en motsvarande underkatalog i app/visningar, och varje åtgärd i en kontroller har en motsvarande .html.erb filen i den underkatalogen.

Ta en titt på app/visningar i Todo-appen du bygger. Du hittar en underkatalog med namnet att-göra-listor innehållande .html.erb filer med namn som motsvarar åtgärderna i Todolistor styrenheten.

Rails – ActiveRecord, Active Record Pattern och ORM

ActiveRecord är Ruby-implementeringen av Active Record-mönstret. I det här mönstret representerar en klass en databastabell, och en instans av klassen representerar en rad i den tabellen.

ActiveRecord kallas vanligtvis för en ORM (Object Relational Map).ping)-lagret, en teknik som låter dig hantera din databas med hjälp av ett språk du är mest bekväm med. Det är databasoberoende, så du kan enkelt växla mellan databaser – till exempel, SQLite, MySQL, PostgreSQL, SQL Server eller Oracle — med samma kod och logik.

För att till exempel få en array som innehåller alla Att-göra-listor i din applikation behöver du inte skriva kod som öppnar en anslutning, kör en SQL SELECT-fråga och konverterar resultatet.

Du skriver bara Att-göra-lista.alla, och ActiveRecord returnerar arrayen fylld med TodoList-objekt som du kan använda som du vill.

Allt du behöver göra är att ställa in konfigurationen i config/database.yml, och ActiveRecord hanterar skillnaderna mellan databassystem. När du växlar från en databas till en annan behöver du inte skriva om din kod.

Du fokuserar på applikationslogik, och ActiveRecord tar hand om de mindre detaljerna kring att ansluta till din databas. Den använder namngivningskonventioner för att mappa modeller till databastabeller.

Rails pluraliserar dina modellklassnamn för att hitta motsvarande databastabell. Så, för en klass Att göra lista, ActiveRecord använder en databastabell som heter att-göra-listor.

Räls – Migrationer

En Rails-migrering är ett skript som du använder för att utveckla din applikationsdatabas. Det används för att konfigurera eller ändra din databas utan att manuellt skriva SQL.

Den använder Ruby för att definiera ändringar i databasschemat och gör det möjligt att använda versionskontroll för att hålla din databas synkroniserad mellan miljöer.

Rails-migreringar använder ett Ruby Domain Specific Language (DSL). Detta fungerar som ett abstracoch gör det möjligt att använda eller ändra din databasmotor baserat på dina krav.

Migreringar kan delas med alla som arbetar i applikationen och kan även rullas tillbaka för att ångra ändringar. Detta är en stark säkerhetsmekanism, så du behöver inte oroa dig för att orsaka permanent skada på din databas.

Rails – ActiveRecord Associations

En koppling mellan två ActiveRecord-modeller kallas för en association. Associationer gör det mycket enklare att utföra operationer på relaterade poster i din kod. Det finns fyra vanliga kategorier.

En till en: En post innehåller exakt en instans av en annan modell. Ett bra exempel är en användarprofil – en användare har bara en profil. Den använder har_en nyckelord.

En till många: den vanligaste associationen — en modell har noll eller fler instanser av en annan modell. Använd har_många nyckelord för att beteckna denna association.

Många till många: lite mer komplicerat. ActiveRecord erbjuder två sätt att hantera det: har_och_tillhör_många och har_många :genom, vilket ger dig åtkomst till kopplingsmodellen som definieras i en separat tabell.

Polymorf en till många: en mer avancerad association i Rails. Den definierar en modell som kan tillhöra många olika modeller på en enda association.

Rails – ActiveRecord-valideringar

Validering hjälper till att säkerställa att du har korrekt data, eftersom det är riskabelt och kan kosta ditt företag pengar att arbeta med dålig data.

Validering ger också ett extra lager av säkerhet mot illvilliga användare som försöker infoga skadlig data i din databas. Rails erbjuder ett rent API med valideringshjälpmedel i ActiveRecord som håller din databas ren, säker och felfri.

ActiveRecord-valideringar körs på modellobjekt innan de sparas i databasen, vilket gör dem mer tillförlitliga och följer bästa praxis.

Följande ActiveRecord-metoder utlöser valideringar när de anropas på modellobjekt: skapa, skapa!, spara, spara!, uppdatera och uppdatera!Bang-versionerna (skapa!, spara! och uppdatera!) generera ett undantag om posten är ogiltig, medan icke-bang-versionerna returnerar falskt istället.

De vanligaste valideringshjälparna för ActiveRecord är:

• Bekräftelse: validerar att två fält har samma värde, till exempel lösenord och lösenordsbekräftelse. Den används tillsammans med hjälpprogrammet för närvarovalidering.
• Närvaro: kontrollerar att fältet inte är tomt.
• unikhet: säkerställer ett unikt värde för ett fält, till exempel användarnamn.
• Längd: upprätthåller en gräns för teckenlängden i ett fält.

Du kan också skapa din egen anpassade validering genom att använda validera metod och ge den namnet på en anpassad valideringsmetod.

Kontrollera modellens fel objekt för att ta reda på varför en validering misslyckades. Detta ger dig allt du behöver för att göra din applikation mer begränsad och säker, och endast tillåta giltig data i din databas.

Rails – ActionController

Rails-styrenheten är centrum för din webbapplikation. Det underlättar och koordinerar kommunikationen mellan användaren, modellerna och åsikterna.

Dina controllerklasser ärver från ApplicationController, som innehåller kod som kan köras i alla andra kontroller, och som i sin tur ärver från ActionController::Base.

Styrenheten tillhandahåller följande till din applikation:

• Den dirigerar externa förfrågningar till interna åtgärder.
• Den hanterar cachning, vilket ger prestandaökningar till din applikation.
• Den hanterar hjälpmetoder som utökar vymallarnas funktioner och hanterar även användarsessioner, vilket ger användarna en smidig upplevelse.

Räls – Konfigurationer

Du kan konfigurera komponenter som initialiserare, resurser, generatorer och mellanprogram med hjälp av dina Rails-applikationsinitialiserare och konfigurationsfiler i config katalog. Filer som config/applikation.rb, config/miljöer/utveckling.rboch config/miljöer/test.rb används här. Du kan också lägga till anpassade inställningar för din applikation.

Rails – Felsökning

När du bygger din applikation måste du felsöka din kod. Rails gör detta enkelt med hej då gem. Du kan starta en felsökningssession genom att placera nyckelordet hej då var som helst i din applikationskod.

Detta stoppar tillfälligt körningen vid den tidpunkten. Byebug-gemen erbjuder flera kommandon. De mest användbara är:

• nästa: går till nästa kodrad, hoppar överping alla metoder som anropas av den aktuella raden.
• steg: liknar Nästa, men stegar in i varje anropad metod.
• bryta: stoppar kodkörningen.
• fortsätta: fortsätter kodkörningen.

Andra felsökningsjuveler finns tillgängliga, till exempel bändaDe erbjuder alla liknande funktioner med något olika syntax. Felsökning av gems bör inte användas i produktion, eftersom de utgör risker för din applikation och en dålig upplevelse för dina användare.

Loggfiler kan inspekteras för fel i produktionen och hanteras därefter. Du bör också följa en testdriven utvecklingsmetod (TDD) när du bygger din applikation för att säkerställa att allt fungerar bra innan du driftsätter den i produktion.

Vanliga frågor