‫Jonas: Esaminiamo ora molto
‫velocemente i fondamenti assolutamente fondamentali di Git,
‫e questa non è affatto una panoramica completa di Git.
‫Tutto quello che voglio fare qui
‫è farti iniziare con Git il più velocemente
‫possibile in modo che possiamo quindi distribuire il nostro progetto su Heroku.
‫E come ho detto nell'ultimo video,
‫inizierò a usare Git nella riga di comando ora, va bene?
‫E in realtà sto usando
‫di nuovo il terminale proprio qui in VS Code.
‫Quindi ora chiudiamo il processo in corso qui, ok?
‫E ora qui nella nostra
‫cartella del progetto locale,
‫creiamo un nuovo repository e lo facciamo scrivendo git init, ok?
‫Premi Invio e il gioco è fatto.
‫Quindi abbiamo appena inizializzato un repository Git vuoto,
‫o possiamo anche chiamarlo solo repository.
‫Quindi è un po' più facile da dire.
‫Quindi, ancora una volta, per creare un nuovo repository,
‫o repository, per il
‫tuo progetto, devi accedere a quella cartella
‫del progetto, che qui in VS Code avviene in modo automatico.
‫Quindi siamo automaticamente proprio qui nella
‫cartella Home e poi lì dentro scrivi git
‫init, e così poi si avvia questo nuovo repository.
‫E qui nella mia riga di
‫comando, puoi effettivamente vedere questa parte gialla ora qui del prompt,
‫e probabilmente sul tuo terminale non lo avrai, e non
‫ha molta importanza.
‫Quindi tutto ciò significa che
‫in questo momento abbiamo un repository con un ramo chiamato master, ok?
‫E un po' di più sul ramo principale più avanti.
‫Ad ogni modo, prima di fare qualsiasi
‫altra cosa, creiamo un file speciale chiamato gitignore, e
‫lì aggiungeremo tutti i
‫file che non vogliamo avere nel nostro repository.
‫Quindi è una specie di file
‫di configurazione proprio come queste configurazioni più carine o essenziali.
‫Quindi posso crearne uno nuovo qui.
‫L'uscita qui.
‫Così . gitignore, così, va bene?
‫E VS Code, in realtà
‫ancora una volta, ha già riconosciuto
‫questo file e vi aggiunge questo simpatico simbolo.
‫E la prima cartella
‫che in realtà vogliamo ignorare completamente è la
‫cartella node_modules, quindi scriviamo node_modules, va bene?
‫Dagli un secondo e poi
‫vuoi anche ignorare il file di configurazione.
‫Quindi tutti i file delle variabili di ambiente.
‫E quindi possiamo dire tutto il . env file, ok?
‫Quindi la cartella node_modules, non vogliamo
‫davvero nel nostro repository perché semplicemente non è necessario.
‫Quindi, ad esempio, se caricheremo il
‫nostro repository su GitHub, non vogliamo caricare tutte queste decine
‫di migliaia di file perché una volta
‫scaricato il progetto da
‫GitHub da qualche altra parte, possiamo facilmente
‫ottenere la cartella node_modules indietro scrivendo npm install, giusto?
‫E quindi tieni presente che Git riguarda anche la
‫condivisione, non solo il salvataggio del codice con le istantanee
‫nel tempo, ma anche tutta questa collaborazione.
‫Ora qui in VS Code su questo
‫lato sinistro, abbiamo effettivamente questa integrazione con Git.
‫Quindi, se fai clic
‫qui, vedrai tutti i file contrassegnati come modificati.
‫Bene, in questo momento
‫non ne vediamo nessuno qui, quindi ricarichiamolo, ma ancora non vengono visualizzati
‫qui, e penso che sia perché
‫inizialmente avevamo troppi file in node_modules, e
‫quindi ora VS Code è un po' confuso con quello.
‫Controlliamo i nostri problemi.
‫No, non ha niente a che fare con quello, va bene?
‫Ma, comunque, non ha molta importanza, ok?
‫Ciò che conta è che ora possiamo
‫effettivamente vedere anche tutti questi file modificati scrivendo git status.
‫Così, ok?
‫E quindi ecco ora tutti i file e le cartelle che
‫sostanzialmente non sono ancora stati inseriti nel nostro repository.
‫Quindi Git è tutto incentrato sul commit, quindi impariamo ora come
‫possiamo eseguire il commit dei file nel repository, ed è
‫una specie di processo in due fasi.
‫Per prima cosa dobbiamo aggiungere i file a una cosiddetta area di
‫staging e solo dopo che si trovano in
‫quest'area, possiamo eseguire il
‫commit di tutti i file presenti in un nuovo commit, ok?
‫Quindi facciamolo.
‫Quindi git add, e quindi se voglio
‫aggiungere tutti i file, posso semplicemente scrivere -A, giusto?
‫Quindi ci vuole un po'
‫di tempo ora perché ci sono così
‫tanti file, e quindi ora se scrivo di
‫nuovo git status, vediamo, ora sono tutti in realtà verdi.
‫Quindi qui puoi vedere tutte le tonnellate di
‫questi file che ora verranno aggiunti al nostro commit git, ok?
‫Ora, in realtà, non voglio questi file memorizzati nella
‫cache in questa cartella
‫cache, quindi liberiamoci rapidamente di questa cartella.
‫Ok, quindi spero che ora se ne siano andati in realtà anche da questo.
‫Quindi speriamo che se ne siano andati anche da qui adesso.
‫Ed elimina, ora sono eliminati, quindi non sono
‫più qui, ma
‫vediamo se tutti gli altri sono ancora qui.
‫Ok, quindi vedi che questi non sono messi in scena
‫per il commit, ma
‫tutti questi altri file verranno ora salvati nel repository.
‫Ora probabilmente ti sembra un po' confuso il
‫motivo per cui dobbiamo prima aggiungere questi file all'area di staging
‫e solo allora possono essere confermati.
‫E la rapida ragione è che
‫potresti voler aggiungere file diversi per commit diversi, ok?
‫Quindi immagina di cambiare 10 file ma
‫di volerne impegnare solo cinque in un determinato commit.
‫E quindi mettendo in scena, puoi farlo.
‫Ma vogliamo solo mantenerlo molto semplice qui, quindi aggiungiamo semplicemente
‫tutti i file a
‫quest'area di staging e poi li commettiamo tutti.
‫E, in effetti, ripetiamolo
‫perché ora ho cancellato tutti questi file.
‫Quindi aggiungiamo di nuovo -A, ok?
‫E quindi ora siamo pronti per
‫eseguire il commit dei file scrivendo git
‫commit -m, quindi specifichiamo un messaggio di commit.
‫E questo messaggio dovrebbe essere davvero descrittivo
‫dei cambiamenti che hai fatto.
‫Ora di solito il primo commit si chiama commit iniziale,
‫quindi facciamolo anche qui.
‫Quindi commit iniziale, premi Invio e il gioco è fatto.
‫Quindi con questo commit abbiamo
‫salvato tutte le modifiche nel repository e, di
‫nuovo, un commit è come un'istantanea di tutto
‫il codice a un certo punto nel tempo, va bene?
‫E una sorta di filosofia è quella di creare un nuovo commit ogni
‫volta che si apportano modifiche significative alla base di codice.
‫Quindi il concetto di commit è davvero il punto centrale di Git.
‫Quindi tutto ruota intorno all'impegno, ok?
‫E ora proviamo a modificare qualche file qui.
‫Quindi possiamo chiudere tutti questi.
‫Ora apriamo l'app. js qui, va bene?
‫Chiudi questo un po' di più.
‫E qui diciamo solo Avvia app express.
‫Salvalo e vedrai subito in
‫VS Code come otteniamo questa linea verde.
‫E quindi significa
‫che a questo punto c'era qualcosa di nuovo inserito.
‫Ora puoi anche fare
‫clic su di esso e vedere sostanzialmente come appariva
‫prima, e puoi anche, proprio qui, tornare indietro nel tempo.
‫Quindi annulla la modifica.
‫E la stessa cosa quando elimini qualcosa.
‫Quindi cancelliamo questa riga di codice.
‫E così qui vedete che
‫prima c'era praticamente qualcosa.
‫Quindi, di nuovo, puoi fare
‫clic su questo e sostanzialmente vedere cosa c'era prima.
‫Puoi tornare indietro nel
‫tempo, quindi facciamolo per riportarlo indietro.
‫Ora proviamo velocemente a caricarlo qui,
‫ma per qualche motivo i file modificati non vengono visualizzati qui.
‫Quindi, idealmente, ora app. js sarebbe qui in
‫questo elenco perché questo è il file che ho appena modificato, ok?
‫Ma, ancora una volta, comunque, non è molto importante.
‫Dovrebbe anche apparire qui in questo
‫albero di file con un colore diverso non appena l'ho modificato, ok?
‫Ora se diciamo di nuovo
‫git status, vedrai qui modificato: app. js, ok?
‫Quindi questo è l'unico output che abbiamo
‫qui, e vedi anche che le
‫modifiche non sono ancora state preparate per il commit, ok?
‫E quindi ora, di nuovo, aggiungiamoli tutti.
‫Quindi git add e poi -A,
‫o potremmo anche aggiungere questo singolo file all'add.
‫Quindi app. js, va bene?
‫Proviamo di nuovo con git status, quindi ora è verde.
‫E quindi ciò significa che le modifiche verranno salvate
‫non appena eseguiamo un nuovo commit.
‫Quindi facciamolo, git commit -m.
‫Per il messaggio, aggiunto un commento, e il gioco
‫è fatto.
‫Quindi, vedete, il messaggio ha aggiunto il commento.
‫Un file è cambiato e c'è stato un inserimento.
‫Quindi questa è questa linea qui.
‫E così ora quella barra verde che avevamo qui è sparita,
‫e questo significa che ora tutto è di nuovo pulito.
‫Ora vedete anche questo master qui, lo vedete
‫anche qui, e
‫questo significa che siamo nel ramo master.
‫Quindi i rami sono un altro concetto molto importante in Git, ma
‫a questo punto non entrerò proprio in questo.
‫Per ora lavoreremo sempre e solo nel ramo master.
‫Ottimo, quindi ora hai un repository locale con
‫tutto il tuo codice impegnato.
‫E così nel prossimo video,
‫inseriamo effettivamente questo ramo su un ramo remoto su GitHub.
‫Quindi fondamentalmente ospitalo sull'account GitHub che abbiamo
‫appena creato prima.
‫Quindi spero di vederti presto lì.