Share
Det har skjedd for oss alle: Vi endrer noe i vår kode, og plutselig ser alt ut til å være "ødelagt". Dette er når versjonskontroll er en velsignelse - hvis du vet hvordan du bruker den. I denne opplæringen lærer vi hvordan du bruker Git fra kommandolinjen.
Xcode og andre moderne IDEer har grunnleggende alternativer for Git innebygd i deres grafiske brukergrensesnitt, men du får bare høyt nivå kontroll av repo (Git repository) via kommandolinjen. Hvis du gjør avansert koding eller Git-ledelse, er det viktig å være komfortabel med kommandolinjen. Hvis du aldri har brukt kommandolinjen før, kan du kanskje sjekke ut min andre veiledning på emnet:
Før vi kommer i gang, bør vi se gjennom hva versjonskontrollen er. EN Versjonskontrollsystem er en programvare løsning som lett kan lagre revisjoner av koden din og andre data, slik at du kan rulle tilbake til tidligere versjoner, gjennomgå endringer som er gjort, og dele oppdateringer med samarbeidspartnere.
Det er mange fordeler og bruk saker for versjonskontroll. For eksempel ved å se gjennom endringene ("forplikter") til prosjektet ditt, kan du identifisere hvem som skrev noen bestemt kode og hvorfor. Du kan også rulle tilbake eventuelle endringer som ble funnet å være feil eller for å bryte funksjonalitet.
Det mest brukte versjonskontrollsystemet i dag er Git, så det er det vi skal se på i dette innlegget. Vær oppmerksom på at det finnes andre mye brukte systemer, men for eksempel SVN og Mercurial.
Når du bruker versjonskontroll, oppretter du en oppbevaringssted, eller repo, og det er mest vanlig å være vert for denne repoen på en Repository Management Service. I denne veiledningen vil vi ikke være vert for vår repo hvor som helst, slik at du kan fokusere på å bruke versjonskontroll. Hvis du vil, kan du lese på disse depotstyringstjenestene, og du bør kunne bruke denne kunnskapen til dem hvis du ønsker det.
Noen eksempler på disse er GitHub, Bitbucket, GitLab og Coding, og de brukes mye av utviklere over hele verden. Jeg og mange andre bruker GitHub fordi det er vert for et stort antall open source-prosjekter. GitHub repos er offentlig som standard, men du kan opprette private repos for en månedlig avgift.
For å starte, må du opprette et nytt program i Xcode. For denne appen kan du bruke hvilken som helst mal du ønsker, og hvis du har en nåværende app som har et Git-depot, kan du også bruke det for denne opplæringen.
Her er hva IDE skal se ut like før du endelig lager prosjektet ditt (når du må bestemme plasseringen for å lagre prosjektet):
Pass på at boksen som sier Opprett Git-depot på min Mac er sjekket, da dette vil sikre at prosjektet ditt internt har repoen. Senere, hvis du velger å bruke et depotstyringssystem, vil du kunne trykk all denne koden, og alle begå du noensinne har laget vil dukke opp.
For å komme til kommandolinjen må du åpne Terminal. Du kan gjøre dette på en av to måter. Du kan åpne Launchpad, og der kan du finne Terminal ikonet i Annen mappe på første side av Launchpad. Eller du kan treffe Command-Space på tastaturet og søke etter Terminal i Spotlight.
Når du åpner terminalen, bør du se noe som følger.
Dette kalles "kommandoprompt" - du vil se den nåværende katalogen, deretter brukernavnet ditt etterfulgt av en $.
Greit! Du er nå klar til å lære om hvordan du bruker versjonskontroll på Terminal.
Her er noen av de grunnleggende kommandoene jeg skrev om i min veiledning om å komme i gang med Terminal. Du må kjenne disse for å kunne bruke terminalen effektivt.
Accentsconagua
hjelp-Som navnet antyder, kan du skrive denne kommandoen til Terminal for å få en liste over forskjellige kommandoer.Mann -I likhet med forrige kommando, forteller denne kommandoen nøyaktig hva en kommando gjør (og gir deg full dokumentasjon) uten at du må søke Google for det.Filbehandling
ls-Viser alt innholdet i gjeldende katalog. Denne kommandoen er nyttig hvis du ikke vil bruke Finder til å bla gjennom filer - du kan bare liste dem ved hjelp av denne kommandoen i Terminal.cd -Denne kommandoen brukes til å endre kataloger. Hvis du skriver cd alene, vil du flytte ut av gjeldende katalog. Etter bruk ls (for å se katalogene), kan du skrive navnet på katalogen du vil skrive inn.mislighold -Denne kommandoen brukes til å endre standard systeminnstillinger, hvorav noen ikke kan endres uten å bruke terminalen.caffeinate-Som navnet antyder, er denne kommandoen brukt til å forhindre at Mac-maskinen din dimming, slår av eller sover. For å avslutte dette, er alt du trenger å gjøre, å trykke Kontroll-C.vim -Dette er en av mine favoritter. Du kan redigere tekstfiler ved hjelp av standard TextEdit (eller en GUI-basert editor), men vim er i utgangspunktet en kommandolinje tekstredigerer-det vil si, det virker helt innenfor terminalen.ping -Denne kommandoen lar deg sjekke serverens svartid for en spesifisert nettadresse eller IP-adresse. Dette kan ikke være nyttig for alle utviklere, men det er fint å vite.sudo -en måte å overstyre brukerens privilegier og bli en superbruker av datamaskinen. Du blir bedt om et administratorpassord når du bruker det.Nå som du har sett noen grunnleggende terminalkommandoer, la oss lære om de forskjellige tingene du kan gjøre med Git. Jeg vil ikke dekke dem alle, men jeg vil lære deg om de viktigste som du skal bruke i den daglige utviklingen. Hvis du noen gang trenger mer informasjon, kan du bare kjøre git hjelp i din terminal for detaljer, og hvis det ikke er nok, kan du kjøre full dokumentasjon mann git for å få den manuelle siden.
Slik ser hjelpesidene ut:
git klone remote-repo-link-hvis du vil klone et lager fra en lageradministrasjonstjeneste, kan du bruke denne kommandoen sammen med nettadressen for å få en lokal kopi på datamaskinen din.git init-Hvis du oppretter et nytt lager fra en eksisterende mappe, kan du bruke denne kommandoen. Den vil initialisere gjeldende mappe for å være en ny repo. Vanligvis vil du gjøre dette når du oppretter et prosjekt for første gang.git status-forteller deg hvilke filer i arbeidskatalogen du har endret. Hvis du har endret filer, kan det være på tide å gjøre en forpliktelse!git commit -am "nyttig commit message"-Når du har gjort noen endringer i prosjektet ditt (for eksempel når du har fullført en enkel funksjon eller gjort en feilretting), bør du forplikte endringen. Pass på å gi en kortfattet og klar forpliktelsesmelding, da dette vil hjelpe andre utviklere å forstå hva du har gjort og hvorfor.git legg til filnavn eller git add --all-Hvis du legger til en ny fil i repo, må du legge den til repoen før du forplikter den. Bruke Legg til kommando. git grenen filnavn?-Med denne kommandoen kan du enten liste de nåværende grenene eller opprette en ny.git fusjon grennavn-slå sammen den nåværende grenen med grenen som er angitt. Dette vil kombinere koden i den nåværende grenen med den navngitte.git checkout filnavn-bytt til den angitte grenen. Dette vil ganske enkelt sette den nåværende grenen til side og gjøre den andre grenen aktiv.git push-oppdaterer lageret i lagringsstyringssystemet. Når du er ferdig med å gjøre endringer og er sikker på at koden din fungerer bra, kan du trykke på koden din slik at andre medlemmer kan se koden og trekke den.git pull-oppdaterer din lokale arbeidskopi av repo for å gjenspeile de nyeste oppdateringene som er blitt presset til depotstyringssystemet. Det er en god ide å gjøre dette før du gjør noen endringer hvis du jobber med et lag.Det er noen av de viktigste kommandoene du vil bruke i versjonskontroll for å komme i gang, men før vi avslutter denne opplæringen, la oss se på noen av disse i dybden med Xcode-prosjektet som vi opprettet tidligere.
Nå, la oss se på noen få eksempler på hvordan du bruker kommandolinje Git med Xcode-prosjektet som vi opprettet tidligere i denne opplæringen. Vær oppmerksom på at vi skal bruke terminalkommandoene ovenfor, så sørg for at du fortsetter å henvise til dem eller huske dem.
Før vi begynner, må du navigere til prosjektkatalogen ved hjelp av kommandoene som er nevnt ovenfor (hint: bruk cd og ls kommandoer). Når du er der, løp ls og sørg for at du har noe slikt:
Ta-da! Nå er du i prosjektkatalogen din og klar til å gjøre alt du trenger med prosjektet ditt. Bare følg med som vi forplikter og grener.
Å forplikte koden er det du vil gjøre oftest i programmeringen. Så snart du gjør en arbeidsendring, er det best å forplikte det med detaljerte kommentarer.
For å starte, gjør en endring til Xcode-prosjektet. For min, vil jeg bare legge til følgende linje dummy kode i min viewDidLoad () metode:
la foobar = "foo"
Når du er ferdig med å legge til (eller subtrahere) en linje eller to kode, er du klar til å sjekke statusen til prosjektet ditt. For å gjøre dette, lim inn følgende kommando (minus $ spørre) i terminalvinduet ditt:
$ git status
Du ser noe slikt:
Filen du har endret er uthevet i rødt, som forteller deg at den har ubegrensede endringer.
Hvis du bare vil forpligte bestemte filer, kan du gjøre det ved å bruke et "staging-område" der bare de filene vil bli forpliktet. Hvis du vil legge til alle de endrede filene i "oppsamlingsområdet", er alt du trenger å gjøre, å kjøre følgende kodekode:
$ git add -A
De -EN flagget som du ser betyr at alle filene du har endret vil bli lagt til (-EN er for alle, og du kan også skrive git add --all).
For å se at filene dine er klare til å begå, bare kjør følgende igjen:
$ git status
Du ser noe slikt:
Se? Den samme filen som var rød er nå grønn, noe som indikerer at du har klart å forberede den til å forplikte.
Til slutt, for å endelig forplikte koden din, er alt du trenger å gjøre, kjør følgende kommando i terminalen din, og mellom anførselstegn legger du til en melding.
$ git commit -m "My very first commit."
De -m flagg forteller Terminal at du vil legge til en melding til filen din, og det er ganske viktig å være klar med denne meldingen. Disse meldingene er avgjørende for å holde rede på endringene i prosjektet ditt.
Nå har du gjort din aller første forpliktelse! Du er på rett spor for å gjøre koden enklere og sikrere.
Den nest vanligste tingen du vil gjøre som utvikler, er å opprette, slå sammen og bruke grener til å sortere ut koden og isolere funksjoner før du ruller dem ut til kundene.
Som standard er du i det vi kaller "master" -grenen. Det er hovedgrenen som til slutt bør altes i. Beste praksis, spesielt med et lag, er å jobbe med nye hovedtrekk i sine egne grener, som blir fusjonert tilbake til mester når de er ferdige.
Å øve med å jobbe med grener, la oss lage en ny gren. For å gjøre dette, kjør følgende kommando:
$ git grenen min første grenen
Du kan navngi grenen uansett hva du vil.
For å se den nye grenen, kan du skrive:
$ git grenen
Når du kjører den kommandoen, ser du noe slikt:
Legg merke til at du kan se to grener: herre og min-første-gren (eller hva du kalt filialen din). I tillegg vil du se at det er en stjerne av herre gren, som indikerer at du for tiden er i den grenen.
Hvis du trenger å bytte til en annen eksisterende gren, må du Sjekk ut den grenen. Når du gjør dette, forlater du den nåværende grenen, og hele koden forblir intakt (sammen med de lokale endringene), men arbeidsboken din vil bli fylt med koden fra avdelingen du sjekket ut.
Prøv det med følgende kommando:
$ git checkout min første grenen
Du bør få en bekreftelse som ser noe ut som dette:
Nå bytter du til denne grenen, og den skal være en ren skifer. For å bekrefte dette, kjør git status for å sjekke om det er noen endrede filer.
Etter at du er ferdig med å gjøre endringer, vil du normalt slå sammen grenen til hovedgrenen. Vi har ikke gjort noen endringer, så la oss gjøre det nå før vi smelter sammen de to grenene.
Gjør en annen endring til Xcode-prosjektet. For min, vil jeg bare legge til følgende linje dummy kode i min viewDidLoad () metode:
la gooey = "fooey"
Du kan gjøre noen endringer du liker. Bare vær sikker på at du vet hvilken fil og hva du endrer.
Etter at det er gjort, kjør du igjen følgende linje av kode:
$ git status
Nå bør du se filnavnet i rødt, og du må plikte før du slår sammen denne endringen tilbake til hovedgrenen din. Jeg stoler på at du vet hvordan du gjør det, så la oss hoppe videre til neste trinn. Dobbeltklikk at begåingen var vellykket med git status.
Ved nå burde du ha begått koden, så la oss bli klare til å slå sammen de to grenene. Først kjør følgende kommando:
$ git checkout mester
Denne kommandoen bytter til herre gren for å forberede seg til å fusjonere med den andre grenen som vi opprettet. Til slutt, for å slå sammen, kjør følgende kommando:
$ git flette min første grenen
Du bør få en bekreftelse som ser slik ut:
Nå har endringene dine fra funksjonen grenen blitt fusjonert tilbake til mesteren. Hvis hovedavdelingen har endret seg siden grenen ble opprettet, vil Git forsøke å kombinere funksjonen forgreningsendringer med master automatisk. Hvis det ikke kan gjøres automatisk, vil det be deg om å løse eventuelle konflikter manuelt.
Nå vet du hvordan du kan slå sammen grener, lage dem, og bytte mellom dem ved å bruke bare Terminal!
Som du ser, er det ikke så vanskelig å gjøre versjonskontroll med prosjektet ditt, og belønningene er vel verdt det. Versjonskontroll er en kjernevirksomhet, og du bør være kjent med det hvis du vil jobbe i en faglig sammenheng.
Jeg håper dette innlegget har gitt deg tilliten til å bruke versjonskontroll på en daglig basis. Hvis du vil lære mer om Git, sjekk ut noen av våre animerte instruksjonsvideoer her på Envato Tuts+.
