I den här artikeln beskrivs hur du använder Git för att hantera filer och källkod i Dreamweaver CC.

Dreamweaver CC stöder Git – ett versionshanteringssystem som distribueras via öppen källkod och används för att hantera filer och källkod. Integreringen av Git i Dreamweaver gör att du kan arbeta självständigt med din kod var du än är och sammanfoga dina ändringar med en central Git-databas vid ett senare tillfälle. Git håller koll på alla ändringarna i en fil och gör det även möjligt att gå tillbaka till tidigare versioner.

Git-databaser är även användbara när ni arbetar i team eftersom Git hjälper er att enkelt skapa och underhålla grenar. Om du till exempel är designer och vill arbeta med en designändring för din webbplats medan en annan teammedlem arbetar med ändringsbegäranden för samma webbplats kan ni båda arbeta oberoende av varandra med Git. I det här fallet kan ni båda var för sig skapa en gren och göra era ändringar i era respektive lokala databaser. Den lokala databasen innehåller en fullständig historik över alla ändringar du har gjort i källan. Du kan när som helst pausa arbetet och sammanfoga ändringarna med den centrala databasen. Genom sammanslagning säkerställs att den centrala databasen alltid har den senaste koden, med bådas ändringar.

Läs vidare för att få information om hur du kommer i gång med användningen av Git i Dreamweaver.

Komma i gång med Git i Dreamweaver

Om du är ny Git-användare måste du först hämta en Git-klient och skapa ett Git-konto. En Git-klient måste finnas innan Git kan användas inifrån Dreamweaver.

Om du redan har ett Git-konto loggar du in på det. Se till att du laddat ned Git-klienten till din dator. 

Utför följande steg för att komma igång med Git i Dreamweaver:

  1. Ladda ned Git-klienten för ditt operativsystem.

  2. Skapa ett konto för din Git-klient.

    Om du redan har ett Git-konto anger du dina inloggningsuppgifter för att logga in på Git-klienten.

Vi rekommenderar att du använder standardinställningarna för konfiguration när du installerar Git-klienten. Dreamweaver väljer sedan automatiskt sökvägen till den körbara filen.

Du kan nu starta Dreamweaver och koppla din webbplats till en Git-databas.

Git-panelen

Dreamweaver har stöd för åtgärder i Git via Git-panelen (Fönster > Git). I Dreamweaver kan du använda den här panelen för vanliga Git-åtgärder som t.ex. implementera, push, pull, hämta osv.

Obs!

Du kan bara visa den här panelen i Dreamweaver efter att du har laddat ned Git-klienten på datorn.

Git-panelen i Dreamweaver CC
Git-panelen i Dreamweaver

A. Implementera B. Hämta alla fjärrmappar och uppdatera räknare C. Git-pull D. Git-push E. Visa databashistorik F. Visa filhistorik G. Skapa tagg H. Öppna Bash/Terminal-konsol I. Fler åtgärder J. Sök K. Diff L. Återställ fil 

Koppla din webbplats till Git

Om du vill börja använda Git i Dreamweaver måste du först koppla din Dreamweaver-plats till en Git-databas. En Git-databas fungerar som en mapp du skapar för att hjälpa till att spåra ändringar i filer. Du kan ha ett valfritt antal Git-databaser på din dator. Alla databaser i datorn är oberoende av varandra. Det innebär att ändringarna som sparas i en Git-databas inte påverkar innehållet i övriga databaser.

Du kan koppla din webbplats till en databas antingen genom att skapa en ny databas eller genom att klona en befintlig databas. När du initierar eller skapar en ny databas skapas en tom Git-databas i din aktuella arbetskatalog, med en .gitignore-fil i mappen.

Om du i stället klonar en befintlig Git-databas klonas alla filer från den överordnade databasen till din dator.

Läs vidare om du vill veta hur du initierar en Git-databas eller klonar en databas.

Initiera en Git-databas

När du börjar arbeta med Git i Dreamweaver vill du troligen börja med att skapa en ny databas. När du initierar en Git-databas för din webbplats skapar du en ny Git-databas där du kan lägga till de filer som är kopplade till din Dreamweaver-plats.

  1. När du använder Dreamweaver kan du antingen starta med en ny plats eller arbeta med en befintlig plats som du vill koppla till en Git-databas. Oavsett vilken metod du väljer följer du den här proceduren för att initiera en Git-databas.

    • Klicka på Plats > Ny plats för att koppla en ny Dreamweaver-plats.
    • Du kopplar en befintlig Dreamweaver-plats genom att klicka på Plats > Hantera platser. I dialogrutan Hantera platser dubbelklickar du på den plats du vill koppla till en Git-databas.
  2. Om du skapar en ny plats anger du ett namn för platsen.

    Om du har en mapp som innehåller filer som är kopplade till din plats använder du fältet Lokal mapp för platsen för att peka på mappen.

    Ange namnet och sökvägen för din nya Dreamweaver-plats.
    Ange namnet och sökvägen för din nya Dreamweaver-plats.

    Om du vill koppla din nya webbplats till en befintlig Git-databas måste du se till att Lokal mapp för platsen pekar mot rätt Git-databas.

  3. Markera kryssrutan Koppla en Git-databas till den här webbplatsen. Välj sedan alternativet Initiera som en Git-databas.

    Initiera en Git-databas i Dreamweaver
    Initiera en Git-databas för din nya Dreamweaver-plats
  4. Klicka på Spara.

    Observera att filerna från din lokala mapp nu är synliga på panelen Filer (Git-vyn). Filerna är i ett läge där de inte spåras. Det innebär att dessa filer ännu inte har implementerats i din Git-databas.

    Du kan fortsätta arbeta med dina filer och implementera filerna senare eller öppna Git-panelen (Fönster > Git) och implementera dina filer i databasen. Information om hur du implementerar filer i Git finns i Spåra och implementera ändringar.

Klona en befintlig databas

Om du redan arbetar med en befintlig Git-databas som lagras på Github, Bitbucket eller någon annan populär värdtjänst följer du anvisningarna nedan för att klona databasen från Dreamweaver. När du klonar en befintlig databas skapar du en kopia av måldatabasen på din dator.

  1. Klicka på Plats > Ny plats.

  2. Markera kryssrutan Koppla en Git-databas till den här webbplatsen i dialogrutan Platskonfiguration. Välj sedan Klona befintlig Git-databas med URL.

  3. Ange en URL för den databas du vill klona.

    Se till att https-URL för den måldatabas som du anger är giltig. Om du vill testa om URL:en är giltig klickar du på Test i den här dialogrutan. En ogiltig URL resulterar i fel när du klonar och utför åtgärder som Git-hämtning eller Pull.

    Klona en Git-databas från Dreamweaver
    Klona en Git-databas från Dreamweaver

    Obs!

    Dreamweaver stöder för närvarande inte kloning av URL:er som använder en SSH-nyckel med lösenfras. Fälten för användarnamn och lösenord inaktiveras.

  4. Markera kryssrutan Spara uppgifter för att spara dina inloggningsuppgifter. På så vis slipper du ange dina inloggningsuppgifter varje gång du utför fjärråtgärder som Git-push eller Git-pull.

  5. Klicka på Spara.

    När du har klonat en databas skapas en lokal kopia av databasen. Du kan visa och redigera de lokala filerna direkt i Dreamweaver.

    En ögonblicksbild av den ursprungliga databasen som klonats visas längst upp till höger i Git-panelen > Ursprung.

    Observera den ursprungliga databasen från Git-panelen
    Observera den ursprungliga databasen från Git-panelen

Använda Git för versionskontroll

När du har kopplat Dreamweaver-platsen till en Git-databas kan du visa filerna i Git från filpanelen (Git-vyn). Git kategoriserar filerna i den lokala databasen som:

  • Ej spårade filer: Filer som aldrig har implementerats i Git-databasen. När du har initierat en Git-databas spåras inte filerna förrän du implementerar dem.
  • Oförändrade filer: Filer som inte har ändrats.
  • Ändrade filer: Filer som har redigerats.
  • Mellanlagrade filer: Filer som har ändrats och är klara att implementeras.

Med Git kan du spåra ändringar i filerna. När du ändrar filerna i ditt lokala system visas de ändrade filerna i en annan färg i filpanelen. När du dubbelklickar på och öppnar filen i kodvyn kan du även se kolumnmarginalmärket mot raderna som har ändrats. Du kan implementera dina ändrade filer i Git för att synkronisera ändringarna.

När du implementerar dina filer ger Git dig möjlighet att skriva loggmeddelanden för varje implementering och använda skillnadsfunktionen för att granska ändringarna. Du kan även visa versionshistoriken för varje fil och för hela databasen.

Läs vidare för att lära dig hur du spårar dina ändringar i Dreamweaver och implementerar ändringarna i Git.

Spåra ändringar i Git

Git-ikonen på panelen Filer i Dreamweaver gör det möjligt att växla mellan FTP-vyn och Git-vyn. Klicka på Git-ikonen för att växla till Git-vyn.

Om du har initierat en Git-databas men inte implementerat filerna, förblir filerna ej spårade. Om du däremot har implementerat filerna efter att du har initierat databasen identifieras filerna av Git.

Visa ej spårade filer i filpanelen
Visa ej spårade filer i filpanelen
Filer efter att de har implementerats i Git-databasen
Visa implementerade filer som identifierats av Git

Om du har klonat alla dina filer från en annan databas identifieras filerna på nytt av Git.

När du ändrar en fil och klickar på Spara visas de ändrade filerna i en annan färg i filpanelen. Dubbelklicka på den ändrade filen för att visa de exakta ändringarna i kodvyn.

Observera kolumnmarginalmärket i kodvyn
Observera kolumnmarginalmärket i kodvyn

Ett kolumnmarginalmärke visar vilka rader som har ändrats. Gröna kolumnmarginalmärken visar ny kod som lagts till. Gula kolumnmarginalmärken visar på ändrad kod, och röda visar på kodrader som tagits bort.

Visa kolumnmarginalmärken för att se kodändringar i Dreamweaver
Visa kolumnmarginalmärken för att se kodändringar

När du klickar på det gula marginalmärket visas den borttagna kodraden i röd färg, och koden som du nyss lagt till visas i grön färg.

Lägg märke till R-symbolen i det vänstra hörnet av de borttagna kodraderna. Klicka på den här R-symbolen för att sätta tillbaka den borttagna kodraden i filen.

Klicka på R-symbolen för att lägga tillbaka borttagen kod i Dreamweaver Git
Klicka på R-symbolen för att lägga tillbaka borttagen kod

Använd marginalmärken för att visa diff, och granska dina ändringar innan du implementerar dem i Git-databasen.

Visa skillnaderna i ändrade filer

När du öppnar Git-panelen visas en lista med de filer som har ändrats. Du kan klicka på en fil i listan och visa de ändringar som gjorts i filen efter den föregående implementeringen (diff). Om du vill visa skillnaderna (diff) för en fil gör du något av följande från Git-panelen:

  • Klicka på varje fil för att visa de gjorda ändringarna. De röda markeringarna anger den tidigare versionen och de gröna markeringarna anger den senaste ändringen.
  • Markera den fil som du vill visa skillnader för. Klicka på  (diff-ikonen). Dialogrutan Git Diff öppnas och ändringarna visas markerade i rött och grönt.
Visa skillnaderna i ändrade filer
Visa skillnaderna i ändrade filer

Implementera ändringar

Om du vill registrera alla ändringar i din lokala databas måste du implementera ändringarna som du gjort i filerna. Så här implementerar du dina ändringar i Git:
  1. I Git-panelen väljer du den fil eller de filer som du vill implementera.

    Implementera ändringarna till din lokala Git-databas
    Implementera ändringarna till din lokala Git-databas
  2. Klicka på  (implementeringsikonen).

    När du klickar på Implementera visas implementeringsdialogrutan för Git. Den här dialogrutan visar de filer som innehåller ändringar.

    Du kan klicka på varje fil och se ändringarna innan du går vidare och implementerar filerna.

  3. Om du vill implementera filerna skriver du ett implementeringsmeddelande i meddelanderutan och klickar på OK.

    När filerna har implementerats tas de bort från Git-panelen.

    Implementera ändringarna i Git
    Implementera ändringarna i Git

Återställa ändringar

Om du redan har implementerat dina ändringar och vill återgå till den tidigare versionen av en fil gör du så här:

  1. I Git-panelen väljer du den fil eller de filer som du vill återställa.

  2. Klicka på ikonen med tre streck på Git-panelen och välj Återställ alla ändringar sedan senaste implementering.

    Den föregående versionen av filerna återställs i din lokala databas. Du kan även se återställda filer i filpanelen.

    Återställa ändringar efter att filer har implementerats
    Återställa ändringar efter att filer har implementerats

    Obs!

    Om du vill återställa en fil efter att ha implementerat den måste du ha implementerat filen minst två gånger.

  3. Gör så här om du vill återställa ändringarna före implementering:

    Gör så här om du vill bevara den senast implementerade versionen av filen innan du implementerar filen:

    1. Öppna Git-panelen.
    2. Markera den fil du vill behålla och klicka på uppdateringsikonen.
    3. Klicka på OK i bekräftelsedialogrutan.

    Den markerade filen tas bort från listan med ändrade filer och den föregående versionen av filen återställs.

    Återställa en fil innan ändringarna implementeras i Git
    Återställa en fil innan ändringarna implementeras

Skapa taggar

Du kan skapa taggar varje gång du implementerar ändringarna i Git. Du kan använda taggar för att markera viktiga implementeringar. Till exempel vid en incheckning då stora förändringar har begärts av kunden. Taggarna fungerar som pekare till specifika implementeringar.

  1. Du skapar en tagg genom att klicka på  (ikonen för att skapa en tagg) på Git-panelen.

  2. Ange ett namn för taggen i dialogrutan Skapa tagg. Klicka på OK.

    Skapa en tagg för din implementering
    Skapa en tagg för din implementering

    Den skapade taggen är kopplad till din implementering.

    Om du skapar en tagg när du har utfört en implementering kopplas taggen automatiskt till din senaste implementering.

Visa filhistorik

Varje gång du sparar en fil i Git kan du visa filens historik tillsammans med informationen om implementeringen. Den här funktionen hjälper till att identifiera viktiga implementeringar och taggar som är kopplade till implementeringar.

  1. Gör något av följande i Git-panelen:
  • Markera önskad fil och klicka på (ikonen för visning av filhistorik).
  • Högerklicka på filen i filpanelen och välj Filhistorik.

Systemet visar Git-filhistoriken för den valda filen. Dialogrutan ger dig även möjlighet att visa information om implementeringen för den här filen.

Visa filhistoriken i Git
Visa filhistoriken i Git

Visa databashistorik

Förutom att visa en fils historik i Git kan du även visa ändringar som gjorts på databasnivån. Du kan visa alla ändringar och implementeringar som gjorts på databasnivån. Följ de här stegen för att visa databashistoriken:

  1. Klicka på ikonen för visning av databashistorik från Git-panelen. Systemet visar Git-databashistoriken med information om alla implementeringar.

  2. Du kan visa implementeringsmeddelandet, datumet och tiden när filerna implementerades, de taggar som är kopplade till en implementering och information om användaren som implementerade filerna.

  3. Databashistoriken visar normalt listan med filer som implementerats på databasnivå. Du kan visa ändringshistoriken på filnivå genom att klicka på respektive fil.

Använda Git för samarbete

En av de mest speciella funktionerna i Git är grenar. Till skillnad från de flesta andra versionshanteringssystem kan en Git-gren likställas med en fristående rad med alla kopplade filer eller kod. Som standard finns det en gren i databasen som är huvudgren. Huvudgrenen är den centrala eller huvudsakliga grenen. Du kan skapa grenar utifrån huvudgrenen och göra ändringar i de olika grenarna.

Du kan också skapa en gren utifrån en annan gren och på så sätt skapa en kopia av den överordnade grenen. Du kan arbeta oberoende med de båda grenarna i samma Git-databas. Du kan till exempel arbeta med en ny funktion för din webbplats i en gren samtidigt som du arbetar med ändringsbegäranden i en annan gren.

Git gör det även möjligt att sammanfoga grenar om du vill lägga till ändringarna från den aktuella grenen i en målgren. När du sammanfogar två grenar finns båda grenarna fortfarande kvar som självständiga grenar. Du kan fortsätta att arbeta med den överordnade grenen och målgrenen.

När många utvecklare och designer arbetar tillsammans med en webbplats i Dreamweaver kan varje användare skapa en gren utifrån huvudgrenen och göra ändringar oberoende av varandra. De kan när som helst enkelt sammanfoga sina ändringar med en annan gren och fortsätta arbeta med båda grenarna.

Läs följande avsnitt för att få mer information om hur du skapar och hanterar grenar i Git:

Skapa grenar i Git

  1. Öppna panelen Filer och välj den listruta som visar alla grenarna.

  2. Klicka på Hantera grenar.

    Skapa en gren i Git
    Skapa en gren i Git
  3. Klicka på plustecknet längst ned till vänster i dialogrutan Hantera grenar.

    Klicka på plustecknet längst ned i dialogrutan Hantera grenar.
    Klicka på plustecknet längst ned i dialogrutan Hantera grenar.
  4. I dialogrutan Skapa ny gren väljer du den ursprungliga gren du vill göra en kopia av.

    Om det är den första grenen du skapar blir den ursprungliga grenen din huvudgren.

    Markera den ursprungliga grenen
    Markera den ursprungliga grenen

  5. Ange ett namn för den nya grenen i fältet Grennamn.

  6. Klicka på OK.

Sammanfoga grenar

  1. Öppna panelen Filer och välj den listruta som visar alla dina grenar.

  2. Klicka på Hantera grenar. Välj den gren du vill sammanfoga i dialogrutan Hantera grenar.

  3. Klicka på  (ikonen för att sammanfoga grenar) längst ned i dialogrutan.

  4. Välj målgrenen i dialogrutan Sammanfoga gren. Den här grenen är den måldatabas du vill sammanfoga din gren med.

    Du kan även ange ett meddelande som är kopplat till den här sammanfogningen.

  5. Klicka på OK för att sammanfoga din gren med ditt mål.

    Sammanfoga grenar i Git
    Sammanfoga grenar i Git

    Om filändringar från en implementering är i konflikt med ändringar från en annan gren pausas sammanfogningsprocessen. Ett konfliktmeddelande visas med de filer som orsakar konflikten.

    Git-panelen visar också de filer som har en konflikt. Lägg märke till ikonen som anger att det finns en konflikt.

    Git-panelen med filer som orsakat en konflikt vid sammanslagning
    Git-panelen med filer som orsakat en konflikt vid sammanslagning

    Om du vill utföra sammanfogningen måste du först lösa konflikten med Rebase-alternativet eller fortsätta med sammanfogningen genom att använda alternativet för snabb sammanslagning.

  6. Om det uppstår en sammanfogningskonflikt väljer du något av följande alternativ:

    • Använd rebase: När du väljer Rebase-alternativet tillämpas dina aktuella ändringar för konflikterna i din målgren. När du har valt Rebase och klickat på OK öppnas Git-panelen för att visa de filer som ännu inte har implementerats. Sedan kan du avbryta Rebase eller starta om Rebase. När du avbryter Rebase stoppas Rebase-åtgärden och inga ändringar tillämpas i målgrenen. När du startar om Rebase ignoreras dina ändringar för de konflikter som finns i målgrenen.
    • Skapa en sammanslagen implementering även vid snabb sammanslagning: Du kan även sammanfoga din implementering trots de konflikter som finns mellan din gren och målgrenen. I det här fallet görs en tvingande sammanslagning med dina ändringar. Ändringarna i målgrenen åsidosätts.

    Mer information om användningen av Rebase-funktionen i Git finns i Använda Rebase i Git.

Arbeta med fjärrdatabaser

Fjärrdatabaser i Git är versioner av ett projekt som lagras i ett annat nätverk. Du får åtkomst till fjärrdatabaser genom att skapa anslutningar till dessa databaser. Beroende på de åtkomsträttigheter som anges i fjärrdatabasen kan du antingen ha läsbehörighet eller skrivbehörighet till den aktuella databasen.

När du arbetar i ett team hjälper fjärrdatabaserna dig att skicka data till och hämta data från andra databaser. Git-panelen i Dreamweaver ger dig möjlighet att skapa en fjärranslutning och utföra flera Git-åtgärder, till exempel Hämta, Git-överföring, Dra in Git och Fjärruppdatera.

Läs följande text för att få mer information om hur du skapar och hanterar fjärrdatabaser.

Lägga till en fjärrdatabas

Du kan lägga till en fjärrdatabas för att dela filer och pågående arbete och få åtkomst till dina projektfiler som lagras i ett annat nätverk. Genom att lägga till en fjärrdatabas kan du upprätta en fjärranslutning till måldatabasen. Dreamweaver gör det möjligt att skapa fjärrdatabaser från Git-panelen.

Innan du lägger till en fjärrdatabas måste du kontrollera att offentliga inställningar är aktiverade för den andra databasen.

  1. Klicka på Skapa fjärrmapp i Git-panelen.

  2. Ange ett namn för fjärrdatabasen.

  3. Ange URL och autentiseringsuppgifter för fjärrdatabasen.

    För att kontrollera att du angett en giltig URL när du lägger till en fjärrdatabas kan du klicka på Test efter att du angett URL:en. När du klickar på Test kontrolleras URL:ens giltighet.

    Det här testet kan inte användas för att validera inloggningsuppgifterna.

    Lägga till en fjärrdatabas i Dreamweaver
    Lägga till en fjärrdatabas

    Viktigt:

    Om du inte anger en giltig URL eller autentiseringsuppgifter uppstår fel när du utför funktionerna Pull, Push, Hämta m.m.

  4. Klicka på OK.

    När du lägger till en fjärrdatabas kan du se databasen i listrutan högst upp på Git-panelen. Du kan även visa fler ikoner för att utföra funktionerna Git-överföring, Dra in Git, Hämta fjärrmapp och uppdatera räknare.

    Lägga till fjärrdatabaser i Git
    Lägga till fjärrdatabaser i Git

Hantera fjärrdatabaser

När du har lagt till en fjärrdatabas och upprättat en anslutning kan du hämta filerna från fjärrdatabasen till din lokala databas. Du kan även skicka dina filer till fjärrdatabasen. Du måste dock först hämta filer från fjärrdatabasen innan du kan utföra åtgärden Git-överföring för första gången.

Kom ihåg att implementera alla dina filer i den lokala databasen innan du försöker skicka dina filer. Om din lokala databas innehåller mellanlagrade filer misslyckas åtgärden Git-överföring. 

Du kan utföra följande Git-åtgärder direkt i Dreamweaver:

Hämta alla

Klicka på  för att hämta alla filer från alla dina fjärranslutningar. Vi rekommenderar att du utför en Git-hämtning innan du utför åtgärden Git-överföring eller Dra in Git. Den här åtgärden hämtar bara filer från fjärrmappen och förändrar inte din lokala databas.

Dra in filer (Pull) från fjärrdatabaser

Du kan dra in ändringar (Pull) från en enstaka databas eller från en grupp av databaser. När du klickar på Git Pull-ikonen visar systemet dialogrutan Dra in Git med olika alternativ.

  1. Klicka på  (Git Pull-ikonen) från Git-panelen för att dra in de ändrade filerna från fjärrdatabasen och sammanfoga ändringarna med din lokala databas.

  2. Välj spårningsgrenen i dialogrutan Dra in Git, ange om du vill dra in ändringar (Pull) från den aktuella grenen eller en annan gren och ange sedan Pull-inställningarna.

    Utföra en Dra in Git från fjärrdatabaser
    Utföra en Dra in Git från fjärrdatabaser

  3. Alternativet Standardsammanslagning är valt som standard. I det här fallet hämtas filerna från fjärrmappen till din lokala databas och ändringarna sammanfogas med din lokala databas.

  4. Du kan också välja ett av följande alternativ:

    • Undvik manuell sammanslagning: Välj det här alternativet om du vill inaktivera manuell sammanfogning av filer.
    • Slå samman utan implementering: Välj det här alternativet om du vill fortsätta sammanfoga till fjärrdatabasen även utan implementering av dina mellanlagrade filer.
    • Använd rebase: Välj det här alternativet om du vill utföra en Rebase. När du använder Rebase tas ändringarna från din aktuella gren och tillämpas på historiken för den gren som du drar in filer från. Den senast implementerade historiken för din gren skrivs om så att filerna matchar versionerna i den målgren som du drar in filerna från. Även om Rebase-funktionen skapar en rensad Git-historik för din gren måste du vara försiktig när du väljer alternativet Använd rebase.
    • Använd mjuk återställning: Välj det här alternativet om du vill göra en återställning eller en mjuk Rebase. Du kan välja alternativet Använd mjuk återställning när du drar in filer från en fjärrdatabas för första gången. I det här fallet fungerar fjärrdatabasen som en överordnad databas som den lokala databasen tar emot alla ändringar från. Däremot bevaras ändringarna i den lokala databasen. De filer som inte finns i fjärrdatabasen utan i din lokala databas identifieras inte av Git. Dessa filer visas som borttagna filer när du har utfört en mjuk återställning. Om du väljer att behålla de här filerna i den lokala databasen går fjärrändringarna förlorade.

    Viktigt:

    Om du väljer mjuk återställning tas dina filer som inte identifieras bort.

Överföra filer till fjärrdatabasen (Push)

När du har anslutit till fjärrdatabaser och sedan ändrar och implementerar de ändrade filerna lagrar Git dessa ändringar. Ikonen för Git Push på Git-panelen visar omedelbart antalet filer som har ändrats. Dessa filer kan nu skickas till fjärrdatabasen.

När du utför en Git-överföring skickas de implementeringar du har gjort i den lokala databasen till fjärrdatabasen.

Så här överför du filer direkt från Dreamweaver:

  1. Klicka på ikonen för Git Push från Git-panelen.

    Systemet visar dialogrutan Git-överföring. Du kan antingen skicka dina implementeringar till den aktuella spårningsgrenen eller till en annan gren som du anger.

    Skicka de lokala implementeringarna till en Git-fjärrdatabas
    Skicka de lokala implementeringarna till en Git-fjärrdatabas

  2. Du kan även ange inställningarna för överföring i den här dialogrutan. Alternativet Standard-push är valt som standard.

  3. Du kan också välja följande alternativ:

    • Framtvingad push: Välj det här alternativet om du vill framtvinga en överföring av dina ändringar till fjärrdatabasen, trots potentiella konflikter.
    • Ta bort gren för fjärrmapp: Välj det här alternativet om du vill ta bort den befintliga fjärrgrenen och överföra dina lokala filer till fjärrdatabasen.
  4. Du kan också markera kryssrutan Skicka taggar om du vill överföra dina taggar till fjärrdatabasen.

  5. Klicka på OK.

    Om det finns konflikter mellan dina lokala implementeringar och implementeringar som gjorts i fjärrdatabasen rekommenderar vi att du först löser alla konflikter innan du överför dina ändringar. 

    I så fall måste du först dra in ändringarna från fjärrdatabasen (pull), lösa konflikterna och sedan överföra filerna utan konflikter.

Söka efter filer på Git-panelen

Med sökfältet i Git-panelen kan du söka efter filer genom att ange filnamn. Den här funktionen är särskilt användbar när du har ett stort antal filer som är kopplade till din plats.

Skriv in filnamnet i sökfältet om du vill söka efter en fil. Filen eller filerna som matchar ditt sökord visas omedelbart.

Lägga till filer i .gitignore-listan

Om du inte vill att Git ska hantera en fil kan du lägga till filen i .gitignore. Git ignorerar sedan filerna i den här mappen när du utför olika åtgärder, till exempel implementera, push och pull. Du måste implementera .gitignore-filen i din databas så att andra användare som klonar databasen också är medvetna om filerna i.gitignore-mappen.

Gå till panelen Filer i Dreamweaver för att lägga till filer i .gitignore. Markera och högerklicka på den fil du vill att Git ska ignorera och välj Git > Lägg till i .gitignore.

Lägga till filer i .gitignore
Lägga till filer i .gitignore

Du kan när som helst ta bort en fil från.gitignore genom att markera filen på panelen Filer. Högerklicka och välj Git > Ta bort från .gitignore.

Kontrollera att du har implementerat .gitignore-filen i den lokala databasen och fjärrdatabaserna när du har ändrat den här filen.

Komma åt Git via kommandoraden

I det föregående avsnitten i den här artikeln beskrevs hur du använder Git-panelen för att utföra åtgärder som t.ex. koppla en Git-databas till din plats, skapa och hantera fjärranslutningar, flytta filer till en databas via Push, eller ta filer från en databas via Pull. Du kan även utföra de här åtgärderna med Git-kommandon.

Gör så här för att utföra Git-åtgärder med terminalen:

  • Klicka på Fönster > Git och klicka på ikonen för öppning av Bash-/terminalkonsolen.
  • Öppna panelen Filer och växla till Git-vyn. Klicka på den ikon för att öppna Git-terminalen som finns bredvid listrutan med databaser.

En lista över vanliga Git-kommandon finns i lathunden för Git

Obs!

Vissa åtgärder som Git stash och kombinerad implementering efter Push kan för närvarande bara utföras från kommandoraden.

När vissa åtgärder utförs, t.ex. initiering av en Git-databas från kommandoraden, visas dessa ändringar även i Dreamweaver-gränssnittet.

Om du ändrar filer med kommandoraden när Dreamweaver inte är igång visas dock det här meddelandet när du startar Dreamweaver nästa gång:

Meddelande när filer ändrats med kommandoraden
Meddelande när filer ändrats med kommandoraden

Ange Git-inställningar i Dreamweaver

Git-inställningarna i Dreamweaver gör det möjligt att definiera vissa inställningar för användningen av Git i Dreamweaver. Du kan använda dialogrutan Inställningar för att göra inställningar för Git, till exempel sökvägen till terminalen och timeoutinställningar.

  1. Välj Redigera > Inställningar.

  2. Välj Git i dialogrutan Inställningar.

  3. Ange följande i dialogrutan Git-inställningar:

    • Sökväg till körbar Git-fil: .exe-filen för din Git-klient. Om din körbara fil finns lagrad på en annan plats navigerar du till den plats där du har sparat Git-.exe-filen.
    • Standardtimeout för Git-åtgärd: ange värdet för timeout (i sekunder) för Git-fjärråtgärder.
    • Sökväg till Terminal: den fullständiga sökvägen till den körbara filen för att öppna och använda Git-terminalen.
    • Kommandoargument: ange eventuella kommandoargument för dina Git kommandon.
    Ange inställningar för Git i Dreamweaver
    Ange inställningar för Git i Dreamweaver

  4. Klicka på Använd för att spara inställningarna.

Obs!

Starta om Dreamweaver för att de uppdaterade inställningarna ska börja gälla.

Denna produkt är licensierad enligt en Creative Commons Erkännande-Ickekommersiell-Dela Lika 3.0 Unported-licens  Twitter™- och Facebook-inlägg omfattas inte av villkoren i Creative Commons-licensen.

Juridiska meddelanden   |   Onlinesekretesspolicy