Come caricare un progetto su Github

Dopo aver verificato questa domanda non ho ancora idea di come caricare un progetto sul mio repository Git Hub.

Sono nuovo di Git Hub e non ho idea di cosa fare. Ho creato un repository ma voglio caricare il mio progetto su di esso.

Ho cercato nella pagina del repository un pulsante di caricamento di qualche tipo, ma non ho visto nulla del genere.

Ho esaminato i link forniti finora ma non riesco ancora a trovare dove. Citano la riga di comando, è quella riga di comando di Windows o Git Bash? Perché non riesco nemmeno a fare nulla.

Ho anche provato a usare la GUI di Git ma quando seleziono la cartella che voglio dice che non è un repository Git ... deve essere zippato? Ho provato ad aggiungere il file .gitconfig nella cartella ma non fa differenza.

Grazie in anticipo :)

Da quando ho scritto questa risposta, github ha rilasciato un client Windows nativo che rende tutti i passaggi seguenti ridondanti.

Puoi anche usare sourcetree per ottenere sia git che mercurial setup su Windows.

Ecco come lo faresti in Windows:

1. Se non hai installato git, consulta questo articolo su come configurarlo.
2. Apri un prompt dei comandi di Windows.
3. Passare alla directory in cui si trova il codice sorgente nel prompt dei comandi.
4. Innanzitutto, crea un nuovo repository in questa directory git init. Questo dirà "Repository git vuoto inizializzato in .... git" ( ...è il percorso).
5. Ora devi dire a Git dei tuoi file aggiungendoli al tuo repository. Fallo con git add filename. Se vuoi aggiungere tutti i tuoi file, puoi farlogit add .
6. Dopo aver aggiunto i file e apportato le modifiche, è necessario eseguire il commit delle modifiche in modo che Git possa seguirle. Tipo git commit -m "adding files". -mti consente di aggiungere il messaggio di commit in linea.

Finora, i passaggi precedenti sono quelli che faresti anche se non stessi usando Github. Sono i normali passaggi per avviare un repository git. Ricorda che git è distribuito (decentralizzato), significa che non devi avere un "server centrale" (o anche una connessione di rete), per usare git.

Ora vuoi inviare le modifiche al tuo repository git ospitato con github. A te questo dicendo a git di aggiungere una posizione remota , e lo fai con questo comando:

git remote add origin https://github.com/yourusername/your-repo-name.git

* Nota: your-repo-namedovrebbe essere creato in GitHub prima di fare una git remote add origin ... volta che lo hai fatto, git ora conosce il tuo repository remoto. Puoi quindi dirgli di inviare (che è "upload") i tuoi file di commit:

git push -u origin master

Seguire questi passaggi per proiettare su Github

1) git init

2) git add .

3) git commit -m "Add all my files"

4) git remote add origin https://github.com/yourusername/your-repo-name.git

Il caricamento del progetto da zero richiede git pull origin master.

5) git pull origin master

6) git push origin master

git push --force origin master

se hai problemi con il caricamento!

Segui questi due passaggi:

1. Crea il repository online usando il link: https://github.com/new
2. Quindi collegare il repository locale al repository remoto utilizzando il comando: git add remote origin https://github.com/userName/repo.git Qui repo.git sarà il repository remoto appena creato.

Funzionerà come un fascino. Non c'è bisogno di preoccuparsi dei modi SSH o HTTPS. Per prima cosa ho affrontato lo stesso problema e ho impiegato ore per la soluzione. Ma questo ha funzionato per me.

Qui spiego come ho fatto su Window, forse aiuta anche gli altri :)

Assicurati di installare Git e GitHub .

Al termine dell'installazione, aprire "git bash";

quindi si aprirà una finestra come sotto:

Vai avanti e digita cd ~per assicurarti di essere nella home directory;

Puoi controllare l'indirizzo in cui ti trovi digitando pwd;

Ora devi creare un account GitHub ;

Dopo aver creato un account GitHub, vai avanti e accedi;

Dopo aver effettuato l'accesso, fai clic su + in alto a destra e scegli "Nuovo repository"

Quindi, nella finestra aperta, digitare il nome che si desidera avere per il repository nella casella "Nome repository". Aggiungi "Descrizione (facoltativo)" se vuoi, e segna "Inizializza questo repository con un README". Quindi fare clic su "Crea repository".

Ora vai al tuo driver C; crea una nuova cartella e chiamala "git" Ora vai alla finestra "git bash"; cambia la directory in c drive digitando cd ~; cd /c Se scrivi lslì ti mostrerebbe le cartelle lì; Assicurati che mostri la cartella git lì:

Ora torna al browser; vai alla tua pagina GitHub, fai clic sul repository che hai creato; e clicca su "Clona o scarica"; e copia l'indirizzo che mostra lì (scegliendo copia negli appunti)

Ora torniamo a "git bash"; Usa il comando cd gitper andare alla cartella git; ora scrivi i seguenti comandi per connetterti a GitHub (inserisci il nome utente e la password di GitHub quando ti viene chiesto)

git config --global user.name "Your Name"

E poi: git config --global user.email youremail@domain.com. Tipo successivo:, git clone (url)anziché (url), digita l'indirizzo del repository GitHub che hai copiato dalla tua pagina GitHub; (ad es. clone git https://github.com/isalirezag/Test.git ).

Ora se fai il lscomando vedrai lì il tuo repository; Se apri anche la cartella git che hai nella tua finestra vedrai che il tuo repository viene aggiunto come cartella.

Ora usa il comando cd per andare al repository: cd Test

Vai avanti e copia e incolla tutti i file che vuoi inserire in questo repository in quella cartella.

Per trasferire i file nel tuo repository, devi ora eseguire le seguenti operazioni:

Digita git

add filename (nome file è il nome del file che si desidera caricare) oppure è possibile digitare il comando seguente se si desidera aggiungere tutti i file nella cartella:

git add .

Tipo Poi: git commit -m "adding files". E poi: git push -u origin master.

E poi dovresti essere pronto, se aggiorni il tuo account GitHub i file dovrebbero essere lì :)

Segui questi passaggi per caricare il tuo progetto su Github

1) git init

2) git add .

3) git commit -m "Add all my files"

4) git remote add origin https://github.com/yourusername/your-repo-name.git

Il caricamento del progetto da zero richiede git pull origin master.

5) git pull origin master

6) git push origin master

In caso di problemi durante l'uso della spinta git push --force origin master

Questo ha funzionato per me;

1- git init
2- git add .
3- git commit -m "Add all my files"
4- git remote add origin https://github.com/USER_NAME/FOLDER_NAME
5- git pull origin master --allow-unrelated-histories
6- git push origin master

Crea un nuovo repository su GitHub. Per evitare errori, non inizializzare il nuovo repository con file README, licenze o gitignore. Puoi aggiungere questi file dopo che il tuo progetto è stato inviato a GitHub. Apri Terminale (per utenti Mac) o il prompt dei comandi (per utenti Windows e Linux).

Cambia la directory di lavoro corrente nel tuo progetto locale.

Inizializza la directory locale come repository Git.

git init
#Add the files in your new local repository. This stages them for the first commit.

git add
# Adds the files in the local repository and stages them for commit. To unstage a file, use 'git reset HEAD YOUR-FILE'. Commit the files that you've staged in your local repository.

git commit -m 'First commit'
#Commits the tracked changes and prepares them to be pushed to a remote repository. To remove this commit and modify the file, use 'git reset --soft HEAD~1' and commit and add the file again.

1. Nella parte superiore della pagina di installazione rapida del repository GitHub, fare clic su per copiare l'URL del repository remoto. Nella parte superiore della pagina di installazione rapida del repository GitHub, fare clic per copiare l'URL del repository remoto.
2. Alla riga di comando, aggiungere l'URL per il repository remoto in cui verrà inviato il repository locale.

$ git remote add origin remote repository URL # Sets the new remote git remote -v # Verifies the new remote URL Note: GitHub for Windows users should use the command git remote set-url origin instead of git remote add origin here. Push the changes in your local repository to GitHub.

$ git push origin master
# Pushes the changes in your local repository up to the remote repository you specified as the origin.

Attribuzione della fonte: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/

Presumo che tu sia su un sistema Windows come me e abbia installato GIT. Puoi eseguire questi comandi con un semplice prompt dei comandi nella directory del progetto oppure puoi usare GitBash.

Passaggio 1: creare manualmente un repository in GIT. Dagli qualunque nome sembri in forma.

Passaggio 2: vieni nella directory del tuo progetto locale. Se vuoi pubblicare il tuo codice in questo nuovo repository che hai appena creato, assicurati che nella directory root dei progetti non ci sia il nome della cartella .git, se è stato eliminato. Esegui comandogit init

Passaggio 3: eseguire il comando git add .

passaggio 4: eseguire il comando git commit -m YourCommitName

Passaggio 5: eseguire il comando git remote add YourRepositoryName https://github.com/YourUserName/YourRepositoryName.git

Passaggio 6: eseguire il comando git push --set-upstream YourRepositoryName master --force

Si prega di notare che sto usando l'ultima versione di GIT al momento in cui scrivo. Si noti inoltre che non ho specificato alcun ramo particolare in cui inserire il codice, quindi è andato al master. Nel passaggio 6 GIT ti chiederà di autorizzare il comando chiedendoti di inserire nome utente e password in una finestra popup.

Spero che la mia risposta abbia aiutato.

1. Apri Git Bash.
2. Cambia la directory di lavoro corrente nel tuo progetto locale.
3. Inizializza la directory locale come repository Git: $ git init
4. Aggiungi i file nel tuo nuovo repository locale. Questo li mette in scena per il primo commit:$ git add .
5. Esegui il commit dei file che hai messo in scena nel tuo repository locale: $ git commit -m "First commit"
6. Nella parte superiore della pagina di installazione rapida del repository GitHub, fare clic per copiare l'URL del repository remoto.
7. Alla riga di comando, aggiungere l'URL per il repository remoto in cui verrà inviato il repository locale: $ git remote add origin remote repository URL
8. Invia le modifiche nel tuo repository locale a GitHub: $ git push origin master

Penso che la cosa più semplice da fare sarebbe installare il plugin git per eclipse, funziona più o meno come i plugin CVS e SVN di eclipse:

http://www.eclipse.org/egit/

GL!

1. Per prima cosa devi creare un account su Github
2. Quindi crea un nuovo progetto: assegna un nome al progetto desiderato, quindi verrà mostrato l'URL del progetto
3. Ora copia l'URL
4. Quindi apri il prompt dei comandi e vai alla directory o alla cartella che desideri caricare utilizzando cmd

5. Quindi digitare i seguenti comandi

    git init
    git add .
    git commit -m "initial commit"
    git remote add origin PASTE URL
    git push -u origin master
   

6. Ora controlla il tuo account GitHub, il repository è stato caricato con successo.

Per una guida completa, puoi guardare questo video .

Probabilmente la cosa più utile che potresti fare è esaminare il libro online [http://git-scm.com/book/en/] . È davvero una lettura abbastanza decente e ti dà il contesto concettuale con cui eseguire le cose correttamente.

Scarica SourceTree. È disponibile per Windows 7 + e Mac ed è altamente raccomandato di caricare file su Github tramite l'interfaccia utente interattiva.

Mi ci sono volute circa 2 ore per capire che avrei dovuto creare Repo su GitHub ( http://github.com/new ) prima di provare a inviare i miei file locali su github.

Dopo aver provato a spingere gli errori erano come:

remote: Repository not found.
fatal: repository 'https://github.com/username/project.git/' not found

Mi sento un idiota, ma vorrei davvero sottolineare questo. Ho appena pensato che il mio repository verrà creato automaticamente durante la prima spinta. Ho sbagliato così tanto.

Assicurati che git sia installato sul tuo sistema. Sto spiegando il processo usando il sistema operativo Windows

Ecco come ho fatto:

1.Aprire il cmd (si può fare anche con git bash).

2. Vai alla directory del tuo progetto (dove si trova il tuo progetto).

3. Adesso digita your_directory >git initquesto inizializzerà un repository vuoto se è la prima volta ed entra. per esempio:C:\Users>git init

4. Digitare ora your_directory >git add <filename>(se file specifici) o git add .(se si desidera aggiungere tutti i file) e inserire.

5. Adesso digita >git commit -m "commit message goes here"e inserisci.

(nel caso in cui sia necessario controllare lo stato che si può fare digitando >git status) e inserire.

6.Ora tipo >git remote add origin git_repository_url

(controlla >git remote -v) ed entra.

7.Ora girare per spingerlo ...>git push origin mastered entrare

(se ricevi un errore, lo spingi forzatamente digitando ...>git push -f origin mastere inviando.

Ora hai finito con l'aggiunta al tuo repository. Aggiorna e sarà lì nel tuo repository creato.

Spero che questo funzioni per te.

Segui le istruzioni di RishiKesh Pathak sopra, puoi anche abbreviare il comando push inserendo questa riga di comando una sola volta:

git config --global push.default simple

Quindi la prossima volta invece di usare git push origin masterdevi solo:

git push

Vedi i dettagli qui .

Il modo migliore per git è effettivamente avviare Gitting . Prova questo sito Web che ti guida passo dopo passo su quali sono i modi essenziali per eseguire funzioni sulla riga di comando per inviare un progetto su GitHub

Questo si chiama try.github.io o potresti anche seguire un corso su codeAcademy

Ho fatto come segue;

1. git init
2. git add.
3. git commit -m "Il tuo messaggio"
4. git remote aggiungi origin @your_git_repository
5. git push -u origine master

Ovviamente devi installare git

Passaggi per caricare il progetto su Git: -

step1-apri cmd e cambia la directory di lavoro corrente nella posizione del tuo progetto.

step2-Inizializza la directory del tuo progetto come repository Git.

$ git init

step3-Aggiungi file nel tuo repository locale.

$ aggiungi.

step4-Salva i file che hai messo in scena nel tuo repository locale.

$ git commit -m "Primo commit"

step5-Copia l'URL del repository remoto.

step6-aggiungi l'URL del repository remoto come origine nella tua posizione locale.

$ git aggiungi origin copied_remote_repository_url

step7-conferma che la tua origine non è aggiornata.

$ git mostra origine remota

step8-push il modificato nel tuo repository github

$ git push origin master.

1. Abbiamo bisogno di Git Bash
2. Nella sezione comandi di Git Bash:

1.1 ls

Ti mostrerà la posizione predefinita.

1.2 CD "C: \ Users \ user \ Desktop \ HTML" Dobbiamo assegnare il percorso del progetto

1.3 git init Inizializzerà il repository git vuoto in C: \ Users \ user \ Desktop \ HTML

1.4 l Elencherà tutti i nomi dei file

1.5 git remote add origin https://github.com/repository/test.git è il tuo https://github.com/repository/test.git è il percorso del tuo repository

1.6 git remote -v Per controllare il tempo abbiamo prendere o spingere permisson o no

1.7 git add. Se metti. allora significa che qualunque cosa abbiamo nella cartella perticolare pubblica tutto.

1.8 git commit -m "Prima volta"

1.9 git push -u origine master

Ciò di cui hai bisogno è una connessione SSH e GitHub init nel tuo progetto. Spiegherò sotto la macchina Linux.

Cominciamo con alcune cose semplici: naviga nel tuo progetto nel terminale e usa:

git init
git add .
git commit 

ora aggiungiamo SSH nel tuo computer: usa ssh-keygen -t rsa -C "your_email@example.com" e copia la chiave pubblica, quindi aggiungila al tuo repository GitHub Deploy keys -> add one al tuo progetto di macchina ora avvia: git push origin master se c'è un errore configura il tuo .github / config di nano .github/config e cambia l'URL in ssh uno di url = git@github.com:username/repo.... e basta

per caricare un nuovo progetto in GIT (per prima cosa devi avere una base di codice locale del progetto e il repository GIT in cui caricherai il progetto, in GIT devi avere le tue credenziali)

1. Voce di elenco

   1.open Git Bash

   2 vai alla directory in cui hai il codice base (posizione del progetto) cd per la posizione del progetto cd / * / *** / ***** / ***** Quindi qui devi eseguire i comandi git

   3. git init premi invio quindi vedrai qualcosa di simile qui sotto Repository Git vuoto inizializzato in *: / *** / **** / ***** /. git / così git init inizializzerà il repository GIT vuoto in locale

   4. git add. premere invio il comando sopra aggiungerà tutta la directory, la sottodirectory, i file ecc. vedrai qualcosa come questo avviso: LF verrà sostituito da CRLF in ****. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avvertenza: LF sarà sostituito da CRLF in ********. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF verrà sostituito da CRLF in *******. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avvertenza: LF sarà sostituito da CRLF in ********. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF verrà sostituito da CRLF in *******. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF sarà sostituito da CRLF in **************. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF sarà sostituito da CRLF in ************. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avvertenza: LF sarà sostituito da CRLF in *************** Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avvertenza: LF sarà sostituito da CRLF in j *******. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF sarà sostituito da CRLF in ***********. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF sarà sostituito da CRLF in **************. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF sarà sostituito da CRLF in ***********. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF sarà sostituito da CRLF in *********.

   5. git commit -m "primo commit" premere invio -m opzione fornita per l'aggiunta di commenti impegnerà il codice per mettere in scena env vedrai qualcosa del genere

[master (root-commit) 34a28f6] aggiungendo avvertimento ********: LF sarà sostituito da CRLF in c *******. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF verrà sostituito da CRLF in *******. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avvertenza: LF sarà sostituito da CRLF in ********. Il file avrà le sue terminazioni di riga originali nella directory di lavoro. avviso: LF sarà sostituito da CRLF in *********. Il file avrà le sue terminazioni di riga originali nella directory di lavoro.

avviso: LF sarà sostituito da CRLF in ***********.

27 file modificati, 3724 inserimenti (+) modalità di creazione 100644 ***** modalità di creazione 100644 ***** modalità di creazione 100644 ***** modalità di creazione 100644 ****** modalità di creazione 100644 ***** * modalità di creazione 100644 ***** modalità di creazione 100644 ******

6.git remoto aggiungi origine http: // nomeutente @ git: repopath.git premere invio per aggiungere al repository

7.premi push -u origine master premi invio per caricare tutto da locale a repository in questo passaggio devi inserire la password per il repository in cui caricherai il codice. vedrai qualcosa del genere sotto Conteggio degli oggetti: 33, fatto. Compressione delta utilizzando fino a 12 thread. Comprimere oggetti: 100% (32/32), fatto. Scrivere oggetti: 100% (33/33), 20.10 KiB | 0 byte / s, fatto. Totale 33 (delta 14), riutilizzato 0 (delta 0) A http: // nomeutente @ git: repolocation.git * master [nuovo ramo] -> master Branch master impostato per tenere traccia del master del ramo remoto dall'origine.