იგი აღწერს GIT- ის გამოყენების საკითხის პრაქტიკულ ნაწილს - მისი მონტაჟი და რეგისტრაცია GitHub.com სერვერთან.

GitHub.com არის სერვისი, რომელიც გთავაზობთ თქვენი კოდის და მონაცემების შენახვას ვერსიის კონტროლის სისტემის გამოყენებით. Git.. GitHub უზრუნველყოფს უფასო სატარიფო გეგმა 300MB მონაცემების შენახვისთვის ღია ფორმით. ეს იმას ნიშნავს, რომ ნებისმიერ ინტერნეტ მომხმარებელს შეუძლია ჩამოტვირთოთ თქვენი მონაცემები. On GitHub შეიძლება განთავსდეს და დაიხურა სხვა საცავი, გადახდის $ 7 თვეში. უფასო GitHub ანგარიშზე, ჩვეულებრივ, ვერავინ ვერ შეცვლის თქვენს მონაცემებს (შეიძლება მხოლოდ წაკითხული). მაგრამ თქვენ შეგიძლიათ მოითხოვოთ, თუ ვინ არის GitHub სისტემის მომხმარებლებისთვის ჩანაწერის უფლება.

სტატიაში დეტალურად აღწერს, თუ როგორ უნდა გააკეთოთ GIT- ის პარამეტრი Windows- ში და Linux OS- ში.

დამონტაჟება GIT ქვეშ Linux

Linux მომხმარებლებს, მე ვფიქრობ, რომ აზრი არ აქვს იმის ახსნა, თუ როგორ უნდა დააყენოთ Git - ეს კეთდება სხვადასხვა გზით. Debian სისტემაში (რომელიც ღირს ჩემთან ერთად), დააყენოთ Git, შეგიძლიათ გამოიყენოთ ბრძანება:

apt-get დააყენოთ git

ინსტალაცია Git ქვეშ Windows

ჩვენ მივდივართ ოფიციალური Git გვერდი http://git-scm.com, დააწკაპუნეთ ჩამოტვირთეთ ფანჯრები. ფანჯარაში, რომელიც ხსნის, დააწკაპუნეთ სრული ინსტალერი ოფიციალური Git. გაუშვით exe-shnik მიიღო.

ინსტალაციის პროცესში, ეს კითხვა დასჭირდება:

ვურჩევ არჩევანის გაკეთებას "Run Git Windows Command Prompt- ისგან". ყველა სხვა ვარიანტი შეიძლება დარჩეს. GIT- ის ინსტალაციის შემდეგ, თქვენ უნდა გადატვირთოთ ან შეავსოთ მომხმარებლის სხდომა და შეხვიდეთ გზების სისტემის ცვლადში ცვლილებების გამოყენებაში.

თუ თქვენ მიიღებთ ინფორმაციას ვერსიის შესახებ, მაშინ Git დამონტაჟებულია და გაშვებული. თუ მივიღებთ ინფორმაციას, რომ GIT პროგრამა არ არის ნაპოვნი, ჩვენ გვესმის, რა გააკეთეს არასწორი.

SSH გასაღები Setup

GitHub- თან დარეგისტრირების დაწყებამდე, პირველად უნდა გამოიმუშაოთ SSH გასაღები შიფრაცია. ეს გასაღები საჭიროა სწრაფად დააყენოთ კავშირი GitHub- თან, პაროლი შესვლის გარეშე. ასეთი GitHub გასაღების გარეშე, ეს არ იქნება ადვილი მუშაობა.

ყურადღება!

ძირითადი თაობის დროს, პაროლი მოითხოვება. ეს პაროლი ხელმისაწვდომობის დახურულ გასაღებს, რომელიც ინახება მხოლოდ თქვენს მანქანაში და სხვაგან. ეს პაროლი არის მაქსიმალური ფასიანი ქაღალდებისათვის, თუმცა ამის გაკეთება შეგიძლიათ. თქვენ უნდა იცოდეთ, რომ პირადი გასაღების პაროლის შექმნის გზით, თქვენ უნდა შეიტანოთ ეს პაროლი თითოეული GitHub სერვერთან. ამდენად, როდესაც მითითებულია პაროლი, ყველა კომფორტული გამოყენებით დაშიფვრის გასაღებები ქრება.

MyTetra- ის მომხმარებლები: სინქრონიზაციის დროს გამოყენებულ ბრძანებებთან მუშაობის ინტერფეისი, რომელიც სინქრონიზაციის დროს გამოიყენება, ვერ იმუშავებს სიმბოლოებზე. ამიტომ, თუ თქვენ დააკონკრეტებთ პაროლს, სინქრონიზაცია არ იმუშავებს.

შექმნის SSH გასაღებები Linux- ში

Linux ოპერაციული სისტემა, პირველი უნდა გამოიყურებოდეს ~ / .ssh დირექტორია. თუ არსებობს ID_RSA ფაილები და ID_RSA.PUB, მაშინ ეს არის SSH გასაღებები. თუ არ არსებობს ასეთი დირექტორია ან ასეთი ფაილი, მაშინ გასაღებები უნდა გენერირებული. მოდით გუნდი:

ნაცვლად [Email protected] თქვენ უნდა მიუთითოთ თქვენი ელ. ძირითადი თაობის პროცესში, თქვენ ვთხოვთ სად უნდა დააყენოთ ფაილი, უბრალოდ დააჭირეთ Enter. პაროლის მოთხოვნისას უბრალოდ დააჭირეთ Enter. თაობის შემდეგ, ID_RSA და ID_RSA.PUB ფაილი უნდა გამოჩნდეს ~ / .ssh დირექტორიაში, ისინი მოგვიანებით შესაფერისი იქნება.

კონფიგურაცია SSH გასაღებები Windows

Windows- ის ოპერაციულ სისტემაში SSH- ის ძირითადი გენერატორი შედის Git პაკეტში. გენერირება გასაღებები, თქვენ უნდა აწარმოებს შეასრულოს ფაილი C: \\ Program ფაილი \\ git \\ git bash.vbs. ეს შეიძლება დაიწყოს ჩვეულებრივი exe-shnik. Git Console პროგრამა გაიხსნა. მას უნდა მიეცეს გუნდი:

sSH-Keygen -t RSA -C " [Email protected]"

იყავით ფრთხილად, ამ კონსოლში, Cop-past შეამჩნევთ, უბრალოდ შეიყვანეთ ბრძანება ხელით. როგორც ელ-ფოსტა, მიუთითეთ თქვენი საფოსტო ყუთი. Მოთხოვნისამებრ " შეიყვანეთ ფაილი, რომელშიც შენახვა გასაღები"უბრალოდ დააჭირეთ ღილაკს" Enter Passward Passphrase "და" შეიტანეთ იგივე Passphrase კვლავ "უბრალოდ დააჭირეთ Enter. კონსოლში გასაღების მომტანი პროცესში, დაახლოებით შემდეგი ინფორმაცია გაიცემა:

გენერირება საჯარო / პირადი RSA გასაღები წყვილი.
შეიტანეთ ფაილი, რომელშიც შენახვა გასაღები (/ C / დოკუმენტები და პარამეტრები / მომხმარებლის სახელი / .SSH / ID_RSA)
შეიყვანეთ passphrase (ცარიელი არ არის passphrase):
შეიყვანეთ იგივე პაროლი:
თქვენი იდენტიფიკაცია ინახება / C / C / CODING და პარამეტრები / მომხმარებლის სახელი / .SSH / ID_RSA.
თქვენი საჯარო გასაღები შენახულია / C / C / დოკუმენტებსა და პარამეტრებში / მომხმარებლის სახელი / .ssh / id_rsa.pub.
ძირითადი თითის ანაბეჭდი არის:
51: 73: 31: 9.: 51: _ 7A: 91: 3D: 9D: 9C: 3D: 35: 8F: 95 [Email protected]

ამ პროგრამის შესრულების შემდეგ კატალოგში C: \\ დოკუმენტები და პარამეტრები \\ მომხმარებლის სახელი \\ .ssh Id_rsa და id_rsa.pub ფაილი იქნება განთავსებული, ისინი სასარგებლო იქნება ჩვენთვის მოგვიანებით.

რეგისტრაცია GitHub.com- ზე.

ახლა ყველაფერი მზად არის რეგისტრაციისთვის. გადადით Github.com- ის დაწყების გვერდზე. ინტერფეისი არის ცოტა დაბნეული, ამიტომ მე მივცემ წყვილს ეკრანის, სადაც რა არის დაჭერილი. დიზაინი და განლაგება შეიძლება შეიცვალოს ნებისმიერ დროს, ამიტომ მე აღწერს ლოგიკა მოქმედების მომენტში.

ზედა მენიუში მოვძებნოთ პუნქტი " ფასები და ხელმოწერა."და დააჭირეთ მას:

სატარიფო გეგმის შერჩევის გვერდი იხსნება. აირჩიეთ უფასო ანგარიში " შექმენით უფასო ანგარიში":

SSH გასაღების ინსტალაცია GitHub- ში

რეგისტრაციის შემდეგ, აუცილებელია Gutub სისტემაში (ღია SSH გასაღები) მისი საჯარო საკვანძო კოდირების გასაღების რეგისტრაცია. იმისათვის, რომ დაამატოთ გასაღები, თქვენ უნდა დააჭიროთ ზედა მარჯვენა კუთხეში. " Ანგარიშის პარამეტრები":

ფანჯარაში, რომელიც იხსნება, თქვენ უნდა დააჭიროთ მენიუში " SSH საჯარო გასაღებები."და დააჭირეთ" დაამატეთ სხვა საჯარო გასაღები"ორი ველი გამოჩნდება - გასაღები სახელი ( ტიტული) და ძირითადი შინაარსი ( Გასაღები.).

სფეროში ტიტული თქვენ შეგიძლიათ დაწეროთ კომპიუტერი, რომელზეც საჯარო გასაღები გენერირდება. თქვენ შეგიძლიათ დაწეროთ რუსულ ენაზე.

სფეროში Გასაღები. თქვენ უნდა ჩაწეროთ ID_RSA.PUB ფაილის შინაარსი. გახსოვდეთ, რომელი კატალოგი ისინი? გადადით ამ დირექტორიაში, გახსენით ნებისმიერი ტექსტური რედაქტორი ID_RSA.PUB (ეს არის. PUB გაფართოება, არ აღრეული). ჩვენ ხაზს ვუსვამთ ყველა ტექსტს, ასლს და ჩასვლას GitHub გვერდზე სფეროში Გასაღები..

გასაღების დასტის შემდეგ, კომპიუტერს შეუძლია Github- ის Github- სთან დაკავშირება და არ უნდა მოხდეს შეცდომები.

შექმნა საცავი GitHub- ზე

ახლა დროა შექმნას თქვენი პირველი საცავი GitHub- ზე. საცავი შეიძლება ჩაითვალოს უბრალოდ, როგორც დირექტორია, რომელშიც სინქრონიზებული ფაილები და ქვედანაქტორია იქნება ცრუობს. თქვენ უნდა შექმნათ საცავი GitHub ვებ ინტერფეისი, და თქვენ უკვე შეავსოთ იგი ფაილი და მუშაობა მას გამოყენებით GIT პროგრამა თქვენს კომპიუტერში.

საცავების შესაქმნელად, საჭიროა ზედა მარჯვენა კუთხეში დააჭირეთ " დაფა."ფანჯარაში, რომელიც ხსნის, თქვენ იხილავთ პუნქტს" შექმენით საცავი.":

ასე რომ, ჩვენ არ გვჭირდება ეს საქონელი! ეს საქონელი ხსნის არა საცავების შექმნის დიალოგს და დახმარების გვერდს. ამ პუნქტზე დაჭერით ნაცვლად, ჩვენ ვეძებთ ქვემოთ გვერდზე ნაკლებად სავარაუდოა ბმული " შექმენით საცავი."ის ასევე გახსნის დიალოგს, რათა დაამატოთ ახალი საცავი.

ახალი საცავის დიალოგის დამატებაში, თქვენ უნდა შეავსოთ მინიმუმ პროექტის სახელი " Პროექტის სახელი."პროექტის სახელით, უმჯობესია, არ გამოიყენოთ კირილეკი, ვინაიდან პროექტის სახელია დირექტორია. პრობლემების თავიდან ასაცილებლად, პროექტის სახელი შეიცავს მხოლოდ ლათინურ ენას. ღილაკზე დაჭერის შემდეგ" შექმნა საცავი.", შეიქმნება საცავი.

GitHub სისტემაში საცავების საოპერაციო მითითება იქმნება. თუ დარეგისტრირდით სახელით სახელით, და თქვენი საცავი ეწოდება Reponame, მაშინ შეგიძლიათ გამოიყენოთ შემდეგი ბმულები ამ საცავში წვდომისთვის:

Git Syntax- ში:

[Email protected]: ნიკი / reponame.git

HTTPS SYNTAX- ში:

https: // [Email protected]/Username/reponame.git.

Github- ის მეშვეობით Github- ზე საცავებთან მუშაობა

ამიერიდან, GitHub ვებ ინტერფეისის გარშემო ცეკვები შეიძლება ჩაითვალოს. შემდეგი, თქვენ შეგიძლიათ მხოლოდ მუშაობა გამოყენებით GIT პროგრამა.

თავდაპირველად, თქვენ უნდა გააკეთოთ მცირე კონფიგურაცია GIT პროგრამის: მიუთითეთ ადგილობრივი Git სისტემის მომხმარებლის და ელ. ეს კეთდება შემდეგი ბრძანებით, რომელიც შეიძლება შესრულდეს ნებისმიერ დირექტორიაში:

git config --global user.name "yourfullname"
Git config --global user.email [Email protected]

სად არის ნაცვლად თქვენი სახელი, და ნაცვლად [Email protected] - თქვენი ელ. ფოსტა. ეს ღირებულებები გამოიყენება GitHub- ზე შესასვლელად. ამიტომ, თქვენ უნდა მიუთითოთ თქვენი შესვლა GitHub - ადგილზე [Email protected] თქვენ უნდა მიუთითოთ ელფოსტა, რომელიც შევიდა დაშიფვრის გასაღების შექმნისას.

ამ პარამეტრების შემდეგ, შეგიძლიათ დააჭერთ თქვენს ფაილებს საცავში. გადადით კატალოგში თქვენი პროექტით და მისცეს გუნდები:

gIT- ის ვალდებულება - "პირველი"

git დისტანციური დამატება წარმოშობა [Email protected]: ნიკი / reponame.git

git Push -u წარმოშობის ოსტატი

ამ ბრძანების შემდეგ, GitHub სერვერზე ჩამოყალიბებული ფაილების ასლი ჩამოყალიბებულია, რომელშიც შესრულდა ბრძანების მონაცემები. შემდეგი, თქვენ უკვე შეგიძლიათ გააკეთოთ ჩადენილი, შეავსოთ GitHub სერვერის ცვლილებები, წაიკითხეთ ცვლილებები სერვერზე. მაგრამ ეს სრულიად განსხვავებული ამბავია.

ხალხისთვის, ბუნებრივად აღუდგეს ცვლილებებს. თუ GIT არ დაგხვდებათ, როდესაც თქვენ დაიწყო მუშაობა ვერსიების კონტროლის სისტემებთან, თქვენ ალბათ უფრო კომფორტულად გრძნობენ სუბვერსიის სისტემაში (SVN).

ხშირად ამბობენ, რომ git ძალიან რთულია დამწყებთათვის. მიუხედავად ამისა, მე დავუშვებ თავს, რომ არ ვეთანხმები მას.

ამ გაკვეთილში, მე გეტყვით, თუ როგორ გამოიყენოთ Git თქვენს პროექტებში. დავუშვათ, რომ შექმნათ პროექტი ნულიდან და გვინდა, რომ მართოთ იგი GIT- ის გამოყენებით. ძირითადი ბრძანებების სიაში დადიოდა, თქვენ მიიღებთ იდეას, თუ როგორ უნდა განათავსოთ თქვენი კოდი Cloud- ში GitHub- ის მიერ.

ამ სტატიაში ჩვენ ვისაუბრებთ GIT- ის საფუძვლებს - როგორ უნდა დაიწყოს თქვენი პროექტები, როგორ უნდა მართოთ ახალი და არსებული ფაილები და როგორ გადავარჩინოთ თქვენი კოდი ღრუბლებში.

ჩვენ არ შევეცდებით შედარებით კომპლექსურ ნაწილებს, როგორიცაა ფილიალი, რადგან ეს გაკვეთილი დამწყებთათვის განკუთვნილია.

დამონტაჟება GIT.

ოფიციალური საიტი Git არის Დეტალური ინფორმაციამისი მონტაჟი Linux, Mac და Windows. ჩვენს შემთხვევაში, ჩვენ გამოვიყენებთ Ubuntu 13.04 დემონსტრირებას GIT- ის გამოყენებით APT- ის გამოყენებით:

sudo Apt-Get Install Git

თავდაპირველი პარამეტრი

მოდით შევქმნათ დირექტორია, რომლის ფარგლებშიც ჩვენ ვიმუშავებთ. გარდა ამისა, თქვენ შეგიძლიათ გამოიყენოთ GIT- ის ერთ-ერთი არსებული პროექტის მართვა; ამ შემთხვევაში, თქვენ არ უნდა შექმნან დემო დირექტორია ქვემოთ მოცემული:

mkdir my_git_project cd my_git_project

პირველი ნაბიჯი არის Git- ის ინიციალიზაცია დირექტორიაში. ეს შეიძლება გაკეთდეს Init ბრძანების გამოყენებით, რომელიც ქმნის. GIT- ის დირექტორია, რომელიც შეიცავს თქვენს პროექტთან დაკავშირებულ ყველა ინფორმაციას.

git config - config --global user.name "shaumik" git config --global user.email " [Email protected]"Git config --global color.ui" ავტო "

მნიშვნელოვანია აღინიშნოს, რომ თუ არ მიუთითეთ თქვენი სახელი და ელექტრონული ფოსტის მისამართი, გამოყენებული იქნება ნაგულისხმევი ღირებულებები. ჩვენს შემთხვევაში, ნაგულისხმევი ღირებულებები იქნება დენის სახელი და ელექტრონული ფოსტის მისამართი [Email protected].

გარდა ამისა, ჩვენ შევქმენით ავტო ღირებულების მომხმარებლის ინტერფეისის ფერი, ისე, რომ გამომავალი Git ბრძანების ექნება ფერი განათება.

-Global Prefix საჭიროა იმისათვის, რომ არ შეიტანოთ ამ პარამეტრების ბრძანებები მომდევნო დროს ჩვენ დავიწყებთ Git პროექტს ჩვენს სისტემაში.

ჩაიდინოს ფაილების მომზადება

შემდეგი ნაბიჯი არის ფაილების შექმნა დირექტორიაში. თქვენ შეგიძლიათ გამოიყენოთ, მაგალითად, Vim ტექსტური რედაქტორი. გაითვალისწინეთ, რომ თუ თქვენ აპირებთ დაამატოთ Git არსებულ დირექტორიაში, თქვენ არ უნდა შეასრულოს ეს ნაბიჯი:

შეამოწმეთ საცავი სტატუსი

ახლა, რომ ჩვენ გვაქვს რამდენიმე ფაილი ჩვენს საცავში, ვნახოთ, როგორ ხდება GIT მათზე. მიმდინარე საცავის სტატუსის შესამოწმებლად, თქვენ უნდა გამოიყენოთ Git სტატუსის ბრძანება:

დასძინა ფაილი git სიმღერა

ამ ეტაპზე ჩვენ არ გვაქვს ფაილები, რომლითაც გიტოვებთ. ჩვენ უნდა დაამატოთ ფაილები სპეციალურად git, რათა მიუთითოთ git, რომ თქვენ უნდა თვალყური.

დაამატეთ ფაილების დამატება ბრძანება:

საცავის მდგომარეობის შემოწმების შემდეგ, დავინახავთ, რომ ერთი ფაილი დაემატა:

მრავალჯერადი ფაილების დასამატებლად შეგიძლიათ გამოიყენოთ შემდეგი ბრძანების ჩანაწერი (გაითვალისწინოთ, რომ ჩვენ დემონსტრაციის კიდევ ერთი ფაილი დავამატეთ):

git Add MyFile2 MyFile3

თქვენ შეგიძლიათ გამოიყენოთ GIT დამატება რეკურსიულად, მაგრამ ფრთხილად იყავი ამ ბრძანებით. არსებობს გარკვეული ფაილები (მაგალითად, შედგენილი ფაილები), რომლებიც, როგორც წესი, ინახება GIT საცავის გარეთ.

თუ თქვენ იყენებთ Add Command- ს რეკურსიულად, დაამატებთ ყველა ასეთ ფაილს, თუ ისინი თქვენს საცავში არსებობს.

ფაილების წაშლა

მაგრამ მარტივი Git RM ბრძანება აღსრულება წაიშლება ფაილი არა მხოლოდ git, არამედ თქვენი ადგილობრივი ფაილური სისტემა! -კენ

GIT შეჩერდა Tracking ფაილი, მაგრამ ფაილი თავად შენარჩუნებულია თქვენს ადგილობრივ სისტემაში, აწარმოებს შემდეგ ბრძანებას:

git rm --cached

შეიცავდეს ცვლილებებს

მას შემდეგ, რაც თქვენ განთავსებული თქვენი ფაილი, შეგიძლიათ შეასრულოს მათ git. წარმოიდგინეთ, რომ ჩაიდინოს გარკვეული წერტილი, რომელიც შეგიძლიათ დაბრუნდეთ თქვენს საცავში ამ ეტაპზე.

თქვენ შეგიძლიათ აკმაყოფილებთ თითოეულ კომიტეტს, რომელიც დაემატა პრეფიქსის გამოყენებით:

gIT ვალდებულებას - "ჩემი პირველი ვალდებულება"

ხელს უწყობს სასარგებლო შეტყობინებებს, რადგან ის დაგეხმარებათ განსაზღვროთ, თუ რა შეიცვალა ამ com.

თავიდან აცილება ძალიან საერთო შეტყობინებები, როგორიცაა " ფიქსირებული შეცდომები" თუ თქვენ გაქვთ ამოცანა Tracker, შეგიძლიათ დაამატოთ შეტყობინებები სახით " ფიქსირებული შეცდომა # 234».

კარგი პრაქტიკაა გამოიყენოს ფილიალის სახელი ან ფუნქციის სახელი, როგორც პრეფიქსი, როგორც ვალდებულება. Მაგალითად, " აქტივების მართვა: დამატებულია ფუნქცია PDF აქტივების ფაილების გენერირება"არის მნიშვნელოვანი გზავნილი.

GIT იდენტიფიცირებულია ჩადენილი გრძელ hexadecimal რიცხვი თითოეულ ჩადენაში. როგორც წესი, თქვენ არ გჭირდებათ კოპირება მთელი სიმებიანი, რათა დადგინდეს თქვენი ვალდებულნი საკმაოდ 5-6 სიმბოლო.

გთხოვთ გაითვალისწინოთ, რომ Screenshot- ში, ჩვენი პირველი ვალდებულება განისაზღვრება 8DD76FC კოდით.

შემდგომი ჩართვა

ახლა მოდით შევცვალოთ მრავალი ფაილი ჩვენი პირველი ჩადენის შემდეგ. მათი ცვლილების შემდეგ, ჩვენ ვნახავთ, რომ GIT- ის სტატუსის მინიჭების აღსრულების შედეგად, მე აღმოვაჩინე ცვლილებები ფაილებში, რომ ეს სიმღერები:

თქვენ შეგიძლიათ შეამოწმოთ ცვლილებები Tracking ფაილებში ბოლო კომენტარში Git Diff ბრძანების გამოყენებით. თუ გსურთ შეცვალოთ ცვლილებები კონკრეტულ ფაილში, გამოიყენეთ GIT DIFF ბრძანება :

თქვენ უნდა დაამატოთ ეს ფაილი კვლავ ცვლილებების შეტანა Tracking ფაილი შემდეგი ჩაიდინოს. თქვენ შეგიძლიათ დაამატოთ ყველა მონიტორინგი ფაილი ბრძანებით:

თქვენ შეგიძლიათ თავიდან ავიცილოთ ამ ბრძანების გამოყენება პრეფიქსით - GIT- ის ჩადენის ბრძანების გამოყენებით, რომელიც დაამატებთ ყველა ცვლილებას ფაილების თვალთვალისთვის.

ეს პროცესი, თუმცა, ძალიან საშიშია, რადგან მას შეუძლია ზიანი მიაყენოს პროექტს. მაგალითად, ვთქვათ, რომ თქვენ გახსენით ფაილი და შეცვალა შეცდომა.

თუ თქვენ შერჩევით ფაილები, მაშინ შეამჩნევთ ცვლილებებს თითოეულ ფაილში. მაგრამ თუ თქვენ დაამატებთ პრეფიქსს - თქვენს ვალდებულებას, ყველა ფაილი იქნება გაჯანსაღებული, და ვერ შეძლებთ შესაძლო შეცდომების იდენტიფიცირებას.

თქვენი ფაილების გამოქვეყნების შემდეგ, შეგიძლიათ გააგრძელოთ ჩაიდინოთ. მე აღვნიშნე, რომ ეს შეტყობინება, რომელიც ჩვენ შემოგთავაზებთ პრეფიქსის გამოყენებით, შეიძლება ასოცირებული იყოს თითოეულ კომიტეტთან.

თუმცა, შესაძლებელია რამდენიმე რიგის გაგზავნა რამდენიმე რიგის გამოყენებით GIT- ის შესრულების გამოყენებით, რომელიც იხსნება ჩაწერის ინტერაქტიული ფორმით:

Პროექტის მენეჯმენტი

თქვენი პროექტის ისტორიის სანახავად შეგიძლიათ შეასრულოთ შემდეგი ბრძანება:

ასე რომ, პროექტის მთელი ისტორია იქნება ნაჩვენები, რაც მათზე ყველა ჩადენისა და ინფორმაციის ჩამონათვალია. დოკუმენტის შესახებ ინფორმაცია შედის კეში, ავტორის, დროისა და სავალუტო შეტყობინების შესახებ. არსებობს სხვადასხვა ვარიანტები Git შესვლა, რომელიც შეგიძლიათ შეისწავლონ როგორც კი წონა კონცეფცია ფილიალი (ფილიალი) Git.

დეტალური ინფორმაციის სანახავად კონკრეტული კომერციისა და ფაილების შესახებ, რომლებიც შეიცვალა, აწარმოეთ შემდეგი ბრძანება:

git შოუ.

სად ეს არის ჰექსადეციალური ნომერი, რომელიც დაკავშირებულია. მას შემდეგ, რაც ეს გაკვეთილი ახალბედაა განკუთვნილია, ჩვენ არ მიგვაჩნია, თუ როგორ დავუბრუნდეთ გარკვეულ ვალდებულებას, თუ როგორ უნდა გააკონტროლონ ფილიალები.

კოდის განთავსება ღრუბელში

ახლა, რომ თქვენ შეიტყო, თუ როგორ უნდა მართოს კოდი თქვენს სისტემაში, დროა მოათავსოთ კოდი ღრუბელი.

GitHub არის ძალიან ცნობილი პლატფორმა შენახვის, დისტრიბუციისა და მმართველი კოდის ღია პროექტების კოდექსის. ეს სერვისი იყენებს მსოფლიოს ბევრ დეველოპერს, რომელთა შორის არიან მსხვილი კომპანიები, როგორიცაა Microsoft, Redhat და მრავალი სხვა, ასევე მრავალი პოპულარული პროექტების ასობით დეველოპერები.

პლატფორმა უზრუნველყოფს არა მარტო კოდის და მისი განაწილების სანახავად, არამედ ვერსიების ისტორიას, ერთობლივ განვითარების ინსტრუმენტებს, დოკუმენტაციის უზრუნველყოფას, რელიზებსა და გამოხმაურებას. და ყველაზე საინტერესო რამ, რაც შეგიძლიათ განათავსოთ Gihub როგორც ღია და კერძო პროექტები. ამ სტატიაში, ჩვენ შევხედავთ, თუ როგორ უნდა გამოვიყენოთ GitHub თქვენი პროექტის განთავსება. ასე რომ საუბარი, Github დამწყებთათვის.

ასე რომ, ვთქვათ, თქვენ გაქვთ საკუთარი პროექტი და გინდა, რომ კოდს გაეცნოთ სხვა მომხმარებლებს საზოგადოებრივ ხელმისაწვდომობაზე, შეეძლოთ და მონაწილეობა მიიღონ განვითარებაში. პირველი, რაც თქვენ უნდა გააკეთოთ, ანგარიშის შექმნაა.

1. ანგარიშის შექმნა

ახალი ანგარიშის შესაქმნელად საიტის გახსნა GitHub- ის მთავარ გვერდზე და დაუყოვნებლივ შეგიძლიათ დაუყოვნებლივ შეიტანოთ მონაცემები ახალი ანგარიშისთვის. თქვენ უნდა მიუთითოთ მომხმარებლის სახელი, ელფოსტა და პაროლი:

შესვლისას შესვლისას დააჭირეთ "დარეგისტრირდით უფასო":

მომდევნო ეტაპზე თქვენ უნდა აირჩიოთ საცავის ტიპი. საჯარო საცობები თავისუფალია, მაგრამ თუ გსურთ კერძო საცავების შექმნა, კოდექსი, საიდანაც მხოლოდ თქვენთვის ხელმისაწვდომი იქნება, თქვენ უნდა გადაიხადოთ $ 7 თვეში.

ანგარიში მზად არის და გადამისამართება გვერდზე, სადაც შეგიძლიათ შექმნათ თქვენი პირველი პროექტი. მაგრამ სანამ ამის გაკეთება შეგიძლიათ, თქვენ უნდა დაადასტუროთ თქვენი ელექტრონული ფოსტის მისამართი. ამისათვის გახსენით თქვენი საფოსტო ყუთი და დაიცვას ბმული წერილი GitHub- დან.

არ არის GitHub Setup საჭიროა, მხოლოდ რამდენიმე დაწკაპუნებით მაუსი.

2. საცავის შექმნა

გვერდზე, რომელიც იხსნება, ეს არის მთავარი გვერდი ავტორიზებული მომხმარებლებისთვის, დააჭირეთ "დაიწყე პროექტი":

თქვენ შეგიძლიათ დაუყოვნებლივ ინიციალიზაცია საცავების მიერ Readme ფაილის შექმნის გზით, ამისათვის საჭიროა აღარაფერი ვთქვათ "ამ საცავის ინიციალიზაცია Readme" გვერდის ბოლოში. ასევე შეგიძლიათ აირჩიოთ ლიცენზია:

როდესაც ყველაფერი მზად არის, აირჩიეთ "შექმენით პროექტი"ახალი პროექტი შეიქმნება Readme ფაილით, რომელიც შეიცავს აღწერილობას და ლიცენზიის ფაილს.

3. ფილიალების დამატება

GitHub ფილიალები საშუალებას გაძლევთ მუშაობა მრავალჯერადი პროექტის ვერსიებთან ერთად. ჩვეულებრივ, საცავების შექმნისას, სამაგისტრო ფილიალი იქმნება, ეს არის მთავარი სამუშაო ფილიალი. თქვენ შეგიძლიათ შექმნათ დამატებითი ფილიალები, მაგალითად, პროგრამული უზრუნველყოფის შესამოწმებლად, სანამ იგი გამოქვეყნდება სამაგისტრო ფილიალში. ამდენად, შეგიძლიათ ერთდროულად შეიმუშავოთ პროდუქტი და უზრუნველყონ მომხმარებლები სტაბილური ვერსიით. თქვენ ასევე შეგიძლიათ შექმნათ ინდივიდუალური ფილიალები პროგრამის ვერსიისთვის სხვადასხვა სისტემებისთვის.

ამჟამინდელი ფილიალი მითითებულია ზედა მარცხენა კუთხეში სიტყვის შემდეგ "ფილიალი".ახალი ფილიალის შესაქმნელად უბრალოდ ამ სიის განთავსება და მისი სახელით აკრეფის დაწყება:

საიტი გთავაზობთ ახალ ფილიალს შექმნას, აირჩიეთ "შექმნა ფილიალი".

შექმნის შემდეგ, თქვენ იმუშავებთ მხოლოდ შექმნილ ფილიალში.

4. ფაილების შეცვლა და ჩადენილი

GitHub ფაილების ნებისმიერი ცვლილება ხდება გამოყენებით. ვალდებულებას ასრულებს სასჯელაღსრულების თავად შესწორების გზით და აღწერს ამ კორექტივებს. ეს აუცილებელია იმისათვის, რომ გაიგოთ ეს და როდესაც შეიცვალა, და ასევე ადვილად აკონტროლებს გუნდის მუშაობას. სიტყვა Commote შეიძლება ითარგმნოს როგორც "Fix". ანუ, ჩვენ შეგვიძლია შევქმნათ ცვლილებები რამდენიმე ფაილზე, შემდეგ კი მათ დაფიქსირება. მოდით შევცვალოთ Readme ფაილი მაგალითად. ამისათვის, იპოვეთ ღილაკზე დაჭერით მარჯვენა მხარეს პანელის მარჯვენა მხარეს და დააჭირეთ მასზე:

ტექსტური რედაქტორი გაიხსნება, სადაც შეგიძლიათ შეიყვანოთ სისწორეში:

მას შემდეგ, რაც თქვენ ყველაფერი გჭირდებათ, თქვენ უნდა შეავსოთ ველი "ჩაიდინოს" გვერდის ბოლოში. მოკლედ აღწერეთ რა შეიცვალა და შემდეგ დააჭირეთ "შეიტანეთ ცვლილებები":

ეს ცვლილებები პროექტის მიმდინარე ფილიალში შევა, რადგან ჩვენ ახლა ვმუშაობთ ტესტირებაზე, მაშინ ცვლილებები გადაეგზავნება მას.

5. შერწყმის შეკითხვების შექმნა (გაიყვანეთ მოთხოვნა)

GitHub- ის დამწყებთათვის, როგორც ჩანს, ძალიან რთულია ასეთი თვისებების გამო, მაგრამ ძალიან მოსახერხებელია, თუ გაერკვია. შესართავების მოთხოვნა ან გაყვანის მოთხოვნა არის შესაძლებლობა, რომლის წყალობითაც ნებისმიერი დეველოპერი შეიძლება მოითხოვოს სხვა, მაგალითად, საცავის შემოქმედება მისი კოდის სანახავად და დაამატეთ იგი მთავარ პროექტს ან ფილიალს. მუშაობის ინსტრუმენტი Fusion მოთხოვნები იყენებს განსხვავებას შედარების ინსტრუმენტი, ასე რომ თქვენ შეგიძლიათ ნახოთ ყველა ცვლილება, ისინი ხაზს უსვამენ სხვა ფერი. გაიყვანეთ მოთხოვნის შექმნა დაუყოვნებლივ შექმნის შემდეგ. მოდით გავგზავნე ჩვენი ტესტირების ფილიალებისგან. პირველი, გახსენით tab "გაიგეთ მოთხოვნა".

აქ, დააჭირეთ "შექმენით თხოვნა":

ამ ფანჯარაში შეგიძლიათ იხილოთ ყველა ცვლილება, ახლა ჩვენ ვხედავთ ხაზს:

6. Fusion მოთხოვნის ნახვა და დამტკიცება

ახლა, იმავე გაიყვანოს ითხოვს tab, ჩვენ უბრალოდ გავაკეთეთ მოთხოვნის შერწყმა და ჩვენ შეგვიძლია მხოლოდ მას დაჭერით "შერწყმა თხოვნა":

მაგრამ თუ ეს მოთხოვნა სხვა პირისგან მოვიდა, უნდა შეამოწმოთ, რომ ის შეიცვალა და ამისათვის აუცილებელია ამის გაკეთება, დააჭირეთ შეკითხვის აღწერას და ნახავთ ნაცნობი ცვლილების ხედვას:

კოდექსი შემდეგ იმპორტირდება ძირითად ფილიალში და ტესტირების ფილიალი შეიძლება უსაფრთხოდ ამოიღონ.

7. შეცდომა ანგარიშები

ასევე მოსახერხებელია, რომ შესაძლებელია გამოიყენოთ GitHub არა მხოლოდ კოდის განვითარება და მართვა, არამედ მომხმარებელთა კავშირი. On tab "Პრობლემა" მომხმარებლებს შეუძლიათ დატოვონ შეტყობინებები იმ პრობლემების შესახებ, რომელთანაც ისინი თქვენს პროდუქტის გამოყენებისას შეექმნათ. ღია ჩანართი "საკითხები"და დააჭირეთ ღილაკს "ახალი საკითხი":

8. რელიზები

ეს უკანასკნელი, რომელიც დღეს ჩვენ განვიხილავთ, რელიზები არიან. როდესაც პროდუქტი გარკვეულ ეტაპზე მიაღწია, შეგიძლიათ გაათავისუფლონ გათავისუფლების მომხმარებლები და დარწმუნებული იყოთ, რომ ყველაფერი სტაბილურია და არავინ დაარღვია არაფერს არასწორი თხოვნით. პირველი თქვენ უნდა წავიდეთ მთავარ პროექტში გვერდზე, მაშინ tab "რელიზები":

ამ გვერდზე თქვენ უნდა მიუთითოთ ვერსია სფეროში. "Tag ვერსია", მაშინ გათავისუფლების სახელი და პატარა აღწერა. თუ თქვენ გაქვთ შედგენილი არქივები ორობითი, მაშინ მათ ასევე უნდა დაურთოს აქ. შემდეგ დააჭირეთ "შექმნა გათავისუფლება":

გათავისუფლების შექმნის შემდეგ, ასეთი გვერდი შეიქმნება:

დასკვნები

ამ სტატიაში, ჩვენ განვიხილეთ, როგორ გამოვიყენოთ GitHub ჩვენი პროექტის განთავსება და მართვა. მთელი სისტემა ინგლისურ ენაზეა, ამიტომ ენის ცოდნა ძალიან სასურველია, მაგრამ მათ გარეშეც კი GitHub- სთან მუშაობა არ იქნება ძალიან რთული. ვიმედოვნებ, რომ ეს ინფორმაცია თქვენთვის სასარგებლო იყო. თუ თქვენ დაინტერესებული ხართ, თუ როგორ უნდა მუშაობდეს ბრძანებათა ხაზისგან, იხილეთ სტატიის დამწყებთათვის.

დეტალური შესავალი Git- თან ერთად

რა არის git და რატომ არის ის ჩემთვის?

GIT არის განაწილებული ვერსია კონტროლის სისტემა, რომელიც საშუალებას გაძლევთ შეინახოთ ყველა ცვლილება საცავებში შენახული ფაილებში. ცვლილებები ინახება Snapshots- ის სახით, მოუწოდა ჩადენას, რომელიც შეიძლება ბევრ სერვერზე განთავსდეს. განვიხილოთ ეს სტანდარტული ღრუბელი სტეროიდების სარეზერვოდ - თქვენ არ შეგიძლიათ მხოლოდ აღადგინოთ კოდი, მაგრამ ასევე კოდის უკან დაბრუნება წინა შენახულ ქვეყნებში. თქვენ ასევე შეგიძლიათ ადვილად ურთიერთქმედება სხვა დეველოპერებთან - ისევ, როგორც რამდენიმე ადამიანს შეუძლია მუშაობა Google Docs- ში და დეველოპერებს ერთდროულად ერთდროულად მუშაობენ ერთ საცავში და შეინარჩუნონ ცვლილებები.

ყველა მისი უპირატესობის გათვალისწინებით, Git არის შეუცვლელი ინსტრუმენტი ყველასთვის, ვინც აკეთებს ან აპირებს განვითარებას. ამ სტატიაში ჩვენ შევხედავთ ყველაზე სასარგებლო git ბრძანებებს და სიტუაციას, როდესაც ისინი ღირს. ეს ასევე ხელს შეუწყობს მათი ცოდნის განახლებას, თუ თქვენ უკვე იცნობთ GIT- ს.

როგორ ვიმუშაოთ Git

ბევრი ბრძანებები ხელმისაწვდომია Git, ასე რომ სასარგებლოა გაყოფილი მათ საგანი / მიზეზი გამოიყენოს. პირველ რიგში, ჩვენ შევხედავთ სამუშაოს ადგილობრივ მანქანასთან ერთად, რადგან უმეტესი ოპერაციები ხდება ზუსტად იქ, შემდეგ კი მოდით მივმართოთ Multiplayer ფორმატში.

ერთად git, თქვენ შეგიძლიათ იმუშაოთ როგორც ბრძანებათა ხაზის მეშვეობით, და გრაფიკული ინტერფეისის საშუალებით, როგორიცაა GitHub Desktop. მიუხედავად იმისა, რომ ბრძანების ხაზი დამწყები დეველოპერები შეიძლება შეშინება, ჯერ კიდევ უკეთესი შესწავლა, რადგან ის უზრუნველყოფს მეტი შესაძლებლობები, ვიდრე ბევრი ინსტრუმენტები ინტერფეისი.

როგორც წესი, Git გუნდები მიიღებენ ტიპის git<команда> <аргументы> სადაც არგუმენტი შეიძლება იყოს ფაილის გზა. გუნდები ასევე შეიძლება იყოს პარამეტრები, რომლებიც მითითებულია როგორც -<опция> ან -<однобуквенная опция> . ისინი საშუალებას გაძლევთ კონფიგურაცია ბრძანება ქმედებები უფრო დეტალურად. ამ სტატიაში, გუნდი ზოგადად იქნება წარმოდგენილი, ასე რომ ყველაფერი არის<> თქვენ უნდა შეცვალოთ საკუთარი მნიშვნელობა.

თუ არ იცით, როგორ გამოიყენოთ ბრძანება, შეგიძლიათ გახსენით გზამკვლევი GIT- ის დახმარებით<команда> , და თუ თქვენ უბრალოდ უნდა შეხსენება, გამოიყენოთ git<команда> -H ან git.<команда> --ჰელპი (- ჰელპ და--H არის ექვივალენტი).

მომზადება git.

დამონტაჟება GIT.

Windows მომხმარებლებს შეუძლიათ ჩამოტვირთოთ აქედან.

Macos (OS X) Git მოდის როგორც ნაწილი Xcode ბრძანების ინსტრუმენტები, ასე რომ თქვენ უნდა დააყენოთ მათ. შეამოწმეთ GIT- ის ხელმისაწვდომობის, ტერმინალის გახსნისა და ვერსიის შესამოწმებლად ვერსიის შესამოწმებლად.

თუ გამოიყენებთ Linux- ს, მაშინ გამოიყენეთ Sudo APT- ის ინსტალაცია Git- ყველა ბრძანება ან Sudo DNF ინსტალაცია Git-All (საფუძველზე RPM).

კონფიგურაციის კონფიგურაციის ფაილი

პირველი, რაც თქვენ უნდა გავაკეთოთ შემდეგ ინსტალაციის შემდეგ, არის კონფიგურაცია მომხმარებლის სახელი და ელ, რადგან ისინი გამოიყენება იდენტიფიცირება და შენახული ყველა სურათები თქვენ მიღებული. ეს პარამეტრები ინახება კონფიგურაციის ფაილში ყველა დანარჩენთან.

თქვენ შეგიძლიათ პირდაპირ შეცვალონ file.gitconfig ტექსტური რედაქტორის გამოყენებით, ან GIT Config- ის გამოყენებით - გლობალური ბრძანების გამოყენებით, და შეგიძლიათ ცალკეული დარგების რედაქტირება Git Config --Global Command<поле> <значение> - ჩვენ ვართ დაინტერესებული მომხმარებლის.ახლა და მომხმარებლის.ემისის სფეროებში.

თქვენ ასევე შეგიძლიათ კონფიგურაცია ტექსტური რედაქტორი დაწერა შეტყობინებები გამოყენებით Core.Editor სფეროში. თავდაპირველად იყენებს სტანდარტული სისტემის რედაქტორს, მაგალითად, VI Linux / Mac- სთვის. Suject.Template ველი საშუალებას გაძლევთ მიუთითოთ თარგი, რომელიც გამოყენებული იქნება თითოეული COM- ზე.

არსებობს ბევრი სხვა სფერო, მაგრამ ერთ-ერთი ყველაზე სასარგებლოა, რომელიც ფსევდონიმს ასრულებს გუნდს. მაგალითად, git config --global alias.t "სტატუსი -s" საშუალებას გაძლევთ გამოიყენოთ Git St ნაცვლად Git სტატუსის შესახებ

Git Config - list ბრძანება გამოჩნდება ყველა სფეროში და მათი ღირებულებები კონფიგურაციის ფაილი.

შექმნა Git საცავი

ახალი საცავის ინიციალიზაციის მიზნით. Git Init ბრძანება შეიძლება გამოყენებულ იქნას ან თუ გსურთ კოპირება არსებული, Git Clone<адрес репозитория> .

ისტორია ჩაიდინა Git

GIT ინახავს მონაცემებს მსუბუქი "სნაფშოტების" კომპლექტის სახით. ისინი ინახავს ფაილური სისტემის სტატუსს გარკვეულ მომენტში, ისევე როგორც წინა (ებ) ის მაჩვენებელი (ებ) ის მაჩვენებელი. თითოეული კომიტეტი შეიცავს უნიკალურ შემოწმებას - იდენტიფიკატორი, რომელიც GIT იყენებს ვალდებულებას. რჩება ამბავი, Git მაღაზიები ხელმძღვანელი მაჩვენებელი, რომელიც მიუთითებს პირველი ვალდებულება (ჩვენ დაიცვას ჩაიდინოს ჯაჭვის საპირისპირო მიზნით მისაღებად წინა კომიტეტებში).

ჩვენ შეგვიძლია მივმართოთ ვალდებულებას, რომ მისი ჩეკიუმის მეშვეობით, ან მისი პოზიციის მეშვეობით, მაგალითად, ხელმძღვანელი ~ 4 ეხება ვალდებულებას, რომელიც 4-ს უფრო ადრე შეასრულებს.

ფაილური სისტემა Git.

Git Tracks ფაილი სამი ძირითადი სექციები:

• სამუშაო დირექტორია (თქვენი კომპიუტერის ფაილური სისტემა);
• მომზადებული ფაილების ფართობი (სტაბილური ტერიტორია ინახავს შემდეგი ჩადენის შინაარსს);
• ხელმძღვანელი (უკანასკნელი ვალდებულება საცავში).

ყველა ძირითადი ფაილი მუშაობის ფაილი მცირდება იმის გაგება, თუ როგორ Git აკონტროლებს ამ სამი სექცია. არსებობს საერთო misconception, რომ მომზადებული ფაილების ფართობი მხოლოდ ინახავს ცვლილებებს. უმჯობესია ვიფიქროთ ამ სამი სექციაზე, როგორც ცალკე ფაილური სისტემები, რომელთაგან თითოეული შეიცავს ფაილების ასლებს.

ცვლილებების ნახვა ფაილურ სისტემებში

Git სტატუსის ბრძანება აჩვენებს ყველა ფაილს, რომელიც განსხვავდება სამ ნაწილად. ფაილებს აქვთ 4 შტატები:

1. Unteracted (untraced) - არის სამუშაო დირექტორია, მაგრამ არ არსებობს ვერსია ხელმძღვანელი ან სფეროში მომზადებული ფაილი (GIT არ იცის შესახებ ფაილი).
2. შეიცვალა (მოდიფიცირებული) - არსებობს ახალი ვერსია სამუშაო დირექტორიაში, ვიდრე შენახული ან მომზადებული ფაილების სფეროში (ცვლილებები არ არის მომდევნო კომ.
3. მომზადებული (დადგმული) - არსებობს ახალი ვერსია სამუშაო დირექტორიაში და მომზადებული ფაილების ფართობი, ვიდრე ხელმძღვანელი (მზადყოფნა).
4. შეცვლის გარეშე - ფაილის ერთი ვერსია ყველა სექციაში, I.E., უკანასკნელ კომიტეტებში შეიცავდეს მიმდინარე ვერსიას.

შენიშვნა ფაილი ერთდროულად შეიძლება "შეიცვალა" და "მომზადებული", თუ სამუშაო დირექტორიაში ვერსია უფრო ახალია, ვიდრე მომზადებული ფაილების სფეროში, რაც, თავის მხრივ, ახალი ვერსიაა.

ჩვენ შეგვიძლია გამოვიყენოთ GIT- ის სტატუსის მქონე ვარიანტი, რათა მიიღოთ უფრო კომპაქტური გამომავალი (ფაილის მითითებით). თუ ფაილი არ არის თვალყური, მაშინ იქნება ნაჩვენები? ; თუ იგი შეიცვალა, მისი სახელი იქნება წითელი, და თუ მომზადებული - მწვანე.

ცვლილებების სანახავად, და არ შეცვლილა ფაილები, შეგიძლიათ გამოიყენოთ შემდეგი ბრძანებები:

• git Diff - სამუშაო დირექტორიის შედარება მომზადებული ფაილების ფართობით;
• git diff --staged - შედარებით ფართობი მომზადებული ფაილი ხელმძღვანელი.

თუ თქვენ იყენებთ არგუმენტს<файл/папка> , განსხვავება აჩვენებს ცვლილებებს მხოლოდ მითითებულ ფაილებს / საქაღალდეებს, როგორიცაა Git Diff SRC /.

ფაილური სისტემის განახლება

გუნდი Git დამატება<файл/папка> განახლებები ფაილების / ფოლდერის ფაილების ფართობი სამუშაო დირექტორიაში.

Git ვალდებულებების შესრულება ხელმძღვანელობს ახალ ვალდებულებას, რომელიც იღებს სურათების ფაილების მომზადებულ ფაილებს.

GIT RESET ბრძანების მოქმედება<коммит> შედგება სამი პოტენციური ნაბიჯი:

1. გადაადგილება ხელმძღვანელი მაჩვენებელი<коммит> (მაგალითად, როდესაც Rollback კონკურენციას სამუშაო დირექტორია და ფართობი მომზადებული ფაილი იქნება უფრო ახალი ვერსიები ფაილი, ვიდრე ხელმძღვანელი). ასევე, ფილიალის ხელმძღვანელი მაჩვენებელი გადაინაცვლებს ამ ვალდებულებას.
2. განახლებული ფაილების განაახლეთ ვალდებულებების შინაარსი. ამ შემთხვევაში, მხოლოდ სამუშაო დირექტორია იქნება ფაილების უახლესი ვერსიები.
3. განაახლოთ მომზადებულ ფაილების სამუშაოების დირექტორია. ამის შესახებ ფრთხილად უნდა იყოთ, რადგან ფაილის ცვლილებები საბოლოოდ განადგურდება.

By Default, Git Reset ბრძანება ასრულებს მხოლოდ ნაბიჯებს 1 და 2, მაგრამ მისი ქცევა შეიძლება შეიცვალოს გამოყენებით - Soft პარამეტრები (მხოლოდ 1 ნაბიჯი) და Hard (ყველა ნაბიჯი).

თუ თქვენ გააგზავნით გზას ფაილი / საქაღალდეში, ბრძანება შესრულდება მხოლოდ მათთვის, მაგალითად GIT RESET - Soft Head ~ 1 SRC /.

გუნდი Git Checkout ხელმძღვანელი<файл> მივყავართ იმავე შედეგს, როგორც Git Reset - Hard ხელმძღვანელი<файл> - გადაწერეთ ფაილის ვერსია მომზადებული ფაილების სფეროში და სათაო ვერსიის სამუშაო კორპუსში, ანუ, უკანასკნელ ვალდებულებასთან დაკავშირებული ცვლილებები შეცვლის.

მეორეს მხრივ, Git Checkout<файл> (უკვე გარეშე ხელმძღვანელი) overwrites ფაილის ვერსია სამუშაო დირექტორია სფეროში მომზადებული ფაილი, რომ არის, აუქმს ცვლილებები შემდეგ ბოლო მომზადებული ვერსია.

საბოლოოდ git rm<файл> აუქმებს თვალთვალის ფაილი და წაშლის მას სამუშაო დირექტორია, ვარიანტი --Cached გადაარჩენს ფაილი.

იგნორირება ფაილი

ხშირად, ჩვენ არ გვჭირდება Git ყველა ფაილი საცავებში, რადგან მათი რიცხვი შეიძლება შეიცავდეს:

• ფაილების მგრძნობიარე ინფორმაცია, როგორიცაა პაროლები;
• დიდი ორობითი ფაილი;
• შეკრების ფაილი, რომელიც გენერირდება თითოეული შედგენის შემდეგ;
• oS / IDE ფაილები, მაგალითად, .Ds_store. Macos ან im Intellij იდეისთვის - ჩვენ გვჭირდება საცავი, რომელიც დამოკიდებულია სისტემაში.

იგნორირება file.gitignore. აღსანიშნავად ფაილები, რომ ჩვენ გვინდა იგნორირება, შეგიძლიათ გამოიყენოთ ძებნა ნიმუშები (განიხილეთ მათ გამარტივებული რეგულარული გამონათქვამები):

• / ___ - თავიდან აცილების რეკურსიულობის - აკმაყოფილებს ფაილს მხოლოდ მიმდინარე დირექტორიაში;
• __ / - აკმაყოფილებს ყველა ფაილს მითითებულ დირექტორიაში;
• * ___ - აკმაყოფილებს ყველა ფაილს მითითებულ დასასრულს;
• ! - ფაილების იგნორირება მითითებულ ნიმუშზე;
• [__] - შეესაბამება კვადრატულ ფრჩხილებში მითითებულ ნებისმიერ პერსონაჟს;
• ? - შეესაბამება სიმბოლოს;
• / ** / ** შეესაბამება წყაროს დირექტორიები, მაგალითად, A / D / D / D / D, A / B / C / D და ა.შ. და ა.შ.

ჩვენ შეგვიძლია გამოვიყენოთ ძებნის ნიმუშების გამოყენება სხვა ბრძანებებში ფაილის / საქაღალდის მითითებისას. მაგალითად, Git დამატება SRC / *. CSS დაამატებთ ყველა ფაილს. CSS in SRC საქაღალდეში.

კომიტეტი

მას შემდეგ, რაც შეხსენება არის ვერსიების ისტორიის საფუძველი, არ იქნება ზედმეტი, რომ მათ უფრო მეტი გაეცნოთ.

Git ვალდებულებების ბრძანება გახსნის ტექსტურ რედაქტორს, რათა შეიტანოთ შეტყობინებები. გარდა ამისა, ეს გუნდი რამდენიმე საერთო არგუმენტს იღებს:

• -M საშუალებას გაძლევთ დაწეროთ შეტყობინება გუნდთან რედაქტორის გახსნის გარეშე. მაგალითად, Git ჩაიდინოს -M "ფიქსაცია ჩანთა";
• - გადარიცხავს ყველა მონიტორინგის ფაილს მომზადებული ფაილების ფართობი და მოიცავს მათ Commote- ში (საშუალებას გაძლევთ გამოტოვოთ GIT- ის ჩადენაში);
• - Mendake შეცვლის ბოლო ვალდებულებას ახალი მოდიფიცირებული ვალდებულებები, რომელიც სასარგებლოა, თუ არასწორად აკრეფილი უკანასკნელი ჩადენილი ან დაავიწყდა, რომ შეიტანოთ რამდენიმე ფაილი.

რამდენიმე რჩევა, ვისთვისაც ღირს მოსმენა:

• Committer ხშირად: თქვენ ვერ შეძლებთ გააფართოვოს უკან ცვლილებები თუ გააფართოვოს უკან რა.
• ერთი ცვლილება არის ერთი ვალდებულება: არ მოათავსოთ ყველა ცვლილება ერთი კომიტეტის, გაყოფა მათ ისე, რომ ეს იყო ადვილი გააფართოვოს უკან.
• შეტყობინება ფორმატი: სათაური უნდა იყოს იმპერატიული ანთების, 50-ზე ნაკლები სიმბოლოების სიგრძით და ლოგიკურად უნდა შეავსოთ ეს ჩადენილი ფრაზა ___ (ეს ჩადენა შეცდომებს დააფიქსირებს - ეს ვალდებულია შეცდომები დააფიქსირებს). შეტყობინება უნდა ახსნას, თუ რატომ გააკეთა ჩაიდინა და თავად თავად გვიჩვენებს, რა შეიცვალა. დეტალურადაა დაგეგმილი, თუ როგორ უნდა დაწერონ შეტყობინებები.
• (სურვილისამებრ) არ ჩაიდინოთ მცირე ცვლილებები: მსხვილ საცავებში, ბევრ მცირეწლოვანს შეუძლია ისტორია. კარგი ტონი ითვლება ასეთ ჩადენას, როდესაც განვითარებადი, და როდესაც მათ დიდი საცავში დასძენს, რათა მათ ერთ ჩაიდინოს.

ცვლილებების ნახვა ისტორიაში

თქვენ შეგიძლიათ გამოიყენოთ GIT- ის ჟურნალების გამოყენება წინა ჩანაწერების ისტორიის სანახავად. მან შეიძლება გაიაროს სხვადასხვა პარამეტრები:

• -P გვიჩვენებს ცვლილებებს თითოეულ COM- ში.
• - STAT გვიჩვენებს შემოკლებით სტატისტიკას, როგორიცაა შეიცვალა ფაილები და თითოეული მათგანის დამატებული / დისტანციური სტრიქონების რაოდენობა;
• -N გვიჩვენებს ნ. ბოლო ჩასმები;
• - არის \u003d ___ და - ___ ___ გაძლევთ საშუალებას გაძლევთ ფილტრის ჩადენას დროში, მაგალითად - "2019-01-01" გამოჩნდება 2019 წლის 1 იანვრიდან;
• - PRETTY საშუალებას გაძლევთ მიუთითოთ ჟურნალის ფორმატი (მაგალითად, --პრატულ \u003d ხახვი), ასევე შეგიძლიათ გამოიყენოთ - Pretty \u003d ფორმატი უფრო დიდი დაკონფიგურირება, მაგალითად - Pretty \u003d ფორმატი: "% h% s";
• - GREP და FILTER ჩართულია შეტყობინებები / შეცვლის კოდი, რომელიც შეიცავს მითითებულ სიმებიანი, მაგალითად, git log -s_name_name საშუალებას გაძლევთ იხილოთ ფუნქციის დამატება / წაშლა;
• - არა-შერწყმებები გადადის შერწყმის ფილიალებით;
• vETA1..TELL2 საშუალებას გაძლევთ დაინახონ, რომელი ვალდებულებები ფილიალიდან 2 არ არის ფილიალში 1 (სასარგებლო ფილიალების შერწყმისას). მაგალითად, git log master..test იქნება აჩვენებს, თუ რა ხდება გამოცდის ფილიალი არ არის სამაგისტრო (ისაუბრეთ ფილიალებში ცოტა მოგვიანებით).
• - Left-Right Branch1 ... ფილიალი 2 გვიჩვენებს, რომლებიც ფილიალში 1 ან ფილიალში 2, მაგრამ არა ორივე ორივე; ნიშანი< обозначает коммиты из ветка1 , а > - ფილიალიდან. ატვირთვის ყურადღება: სამი ქულა გამოიყენება, არა ორი;
• -L იღებს არგუმენტს დასაწყისში, დასასრული: ფაილი ან ფაილი: ფაილი და აჩვენებს ცვლილებების ისტორიას გადაცემის ზედიზედ ან ფუნქციებში ფაილში.

კიდევ ერთი სასარგებლო გუნდი არის ბრალი<файл> , რომელიც თითოეული ფაილის ხაზისთვის გვიჩვენებს ავტორის და ბოლო ჩადენის შემოწმების ოდენობას, რომელმაც შეცვალა ეს სიმებიანი. -L.<начало>, <конец> საშუალებას გაძლევთ შეზღუდოთ ეს ბრძანება მითითებულ რიგებში. ეს შეიძლება გამოყენებულ იქნას, მაგალითად, გაირკვეს, თუ რომელი კომიტეტების ხელმძღვანელობით კონკრეტული შეცდომა (ისე, რომ თქვენ შეგიძლიათ გააფართოვოს უკან).

საბოლოოდ, არსებობს git grep ბრძანება, რომელიც ეძებს ყველა ფაილი ჩაიდინოს ისტორია (და არა მხოლოდ სამუშაო დირექტორია, როგორც grep) მიხედვით მითითებული რეგულარული გამოხატვის. ვარიანტი, რომელიც აჩვენებს შესაბამის ხაზს თითოეულ მატჩში ფაილში, და - თითოეულ ფაილზე მატჩების რაოდენობა გვიჩვენებს.

შენიშვნა არ გაურკვეველი git grep ერთად git log --grep! პირველი ეძებს ფაილებს შორის, ხოლო ეს უკანასკნელი გამოიყურება ჟურნალების შეტყობინებებზე.

დისტანციური სერვერები

ჯერჯერობით, ჩვენ ვისაუბრეთ მხოლოდ ადგილობრივ მანქანებზე. თუმცა, ჩვენ შეგვიძლია შევინარჩუნოთ დისტანციური საცავების ვალდებულების ისტორია, რომელიც შეიძლება მონიტორინგი და განახლდეს (განვიხილოთ ჩვენი დისტანციური ღრუბლის სარეზერვო ისტორიის შესახებ).

GIT დისტანციური- AV ბრძანება აჩვენებს დისტანციური საცავების ჩამონათვალს, რომელიც ჩვენ ვაკონტროლებთ და სახელები ჩვენ მივეცით.

გამოყენებისას Git Clone Command ჩვენ არა მხოლოდ ჩატვირთეთ საცავების ასლი, არამედ ირიბად დისტანციური სერვერი, რომელიც მითითებულია მითითებულ მისამართზე და რომელიც ენიჭება სახელი წარმოშობას.

ყველაზე მოხმარებადი ბრძანებები:

• git დისტანციური დამატება.<имя> - დასძენს დისტანციური საცავი მითითებულ სახელით;
• git დისტანციური წაშლა.<имя> - ამოშლის დისტანციური საცავი მითითებულ სახელს;
• git დისტანციური გადარქმევა.<старое имя> <новое имя> - Renames დისტანციური საცავი;
• git დისტანციური კომპლექტი URL<имя> - ანიჭებს საცავებს ახალი მისამართი;
• git დისტანციური შოუ.<имя> - აჩვენებს ინფორმაციას საცავების შესახებ.

შემდეგი ბრძანებები მოქმედებს ამოღებულ ფილიალებთან:

• git fetch.<имя> <ветка> - სპეციფიკური საცავების ფილიალს იღებს მონაცემებს, მაგრამ არ იცვლება ცვლილებები;
• git გაიყვანოს<имя> <ветка> - მითითებული საცავის ფილიალის მონაცემები;
• git ბიძგი.<имя> <ветка> - მითითებულ საცავში ცვლილებებს აგზავნის ცვლილებებს. თუ ადგილობრივი ფილიალი უკვე აკონტროლებს დისტანციურ, მაშინ შეგიძლიათ გამოიყენოთ მხოლოდ Git ბიძგი ან git გაიყვანოს.

ამდენად, რამდენიმე ადამიანს შეუძლია მოითხოვოს სერვერის ცვლილებები, ცვლილებების შეტანა ადგილობრივი ასლებიდან და შემდეგ გააგზავნოთ დისტანციური სერვერი, რომელიც საშუალებას გაძლევთ ერთმანეთთან ურთიერთქმედება ერთ საცავში.

დარგი

ეს ყველაფერი კარგია და დიდი თუ თითოეული დეველოპერი მუშაობს პროექტზე სხვადასხვა დროს. ქვეჯგუფების მიერ ნაჩვენები სქემები თავდაპირველ საცავებში ან ადგილობრივ ასულში ცვლილებებით, მაგრამ არა რამდენიმე ადამიანის მუშაობას.

ეს გვაძლევს GIT - ფილიალის ძირითად ფუნქციას, პროექტის სხვადასხვა ვერსიებზე მუშაობის შესაძლებლობას. ეს იმას ნიშნავს, რომ ერთი სიის ნაცვლად ბრძანებულთა შეკვეთების ნაცვლად, სიუჟეტი გარკვეულ ქულებზე განსხვავდება (რაც მას ხეზე ჰგავს). თითოეული ფილიალი GIT შეიცავს სინათლის ხელმძღვანელს უკანასკნელ ვალდებულებას ამ თემაში, რომელიც საშუალებას გაძლევთ შექმნათ ბევრი ფილიალი დამატებითი ხარჯების გარეშე. რჩევა: მოვუწოდებთ ფილიალს მასში განვითარებული ფუნქციონირების შესაბამისად. ნაგულისხმევი ფილიალი ეწოდება სამაგისტრო.

ასე რომ, ჩვენ გვაქვს ზოგადი მაჩვენებელი ხელმძღვანელი. და ხელმძღვანელი თითოეული ფილიალი. ამდენად, ფილიალებს შორის გადართვა მხოლოდ მოძრაობს ხელმძღვანელი. შესაბამისი ფილიალის ხელმძღვანელობაში.

სტანდარტული გუნდები:

• git ფილიალი.<имя ветки> - ქმნის ახალ ფილიალს ხელმძღვანელი მითითებით ხელმძღვანელი.. თუ არ გადმოგცეთ არგუმენტი<имя ветки> გუნდი აჩვენებს ყველა ადგილობრივ ფილიალს;
• git Checkout<имя ветки> - ამ ფილიალს. თქვენ შეგიძლიათ გაიაროთ -B ვარიანტი, რათა შეიქმნას ახალი ფილიალი გადართვის დაწყებამდე;
• git branch -d.<имя ветки> - შლის ფილიალს.

როგორც ჩვენი ადგილობრივი საცავი და დისტანციური, შეიძლება ჰქონდეს ბევრი ფილიალი, ასე რომ, როდესაც თქვენ აკონტროლოთ დისტანციური საცავი, რეალურად მონიტორინგი ამოღებულ ფილიალი (Git Clone მოაქვს თქვენი სამაგისტრო ფილიალი წარმოშობის / სამაგისტრო ფილიალი დისტანციური საცავი).

სავალდებულო ფილიალში:

• git branch -u.<имя удалённого репозитория>/<удалённая ветка> - ახორციელებს მიმდინარე ფილიალს მითითებულ დისტანციურ ფილიალში;
• git Checkout --Track<имя удалённого репозитория>/<удалённая ветка> - წინა ბრძანების ანალოგი;
• git Checkout -B.<ветка> <имя удалённого репозитория>/<удалённая ветка> - ქმნის ახალ ადგილობრივ ფილიალს და იწყებს დისტანციურად;
• gIT BRANCH --VV - გვიჩვენებს ადგილობრივ და მონიტორინგს დისტანციურ ფილიალებს;
• git Checkout<удалённая ветка> - ქმნის ადგილობრივ ფილიალს იგივე სახელით, როგორც დისტანციური და იწყება თვალთვალისთვის.

ზოგადად, Git Checkout უკავშირდება ადგილმდებარეობის ადგილს, რომელიც მიუთითებს ფილიალების ხელმძღვანელს, რომელიც ჰგავს GIT RESET- ს გენერალურ ხელმძღვანელს.

ჰიპები და გაწმენდა

არსებობს ერთი subtlety - როდესაც გადართვის Git ფილიალებში მოითხოვს, რომ სამუშაო სახელმწიფო არის სუფთა, ანუ, ყველა ცვლილება თვალთვალის ფაილი უნდა დაფიქსირდეს.

დაახ. თარგმნა ეს ასე არ არის. ზოგიერთ შემთხვევაში, GIT- ს შეუძლია ავტომატურად გადავიდეს სხვა ფილიალზე.

თუმცა, ზოგჯერ თქვენ დაუმთავრებელი ცვლილებები, რომლებიც არ შეიძლება დაფიქსირდეს. ასეთ ვითარებაში, ისინი შეიძლება შენახული და "დამალვა" გამოყენებით git stash ბრძანება. ცვლილებების დაბრუნების მიზნით, გამოიყენეთ Git Stash ვრცელდება.

ალბათ ნაცვლად გსურთ წაშალოს ყველა ცვლილება. ამ შემთხვევაში, გამოიყენეთ GIT სუფთა ბრძანება. -D ვარიანტი ასევე წაიშლება არაკვალიფიციური ფაილები. რჩევა: დაამატეთ -n ვარიანტი, თუ რა მოხდება, როდესაც თქვენ დაიწყებთ Git სუფთა გარეშე პირდაპირი გამოყენების გარეშე.

აერთიანებს ფილიალებს

მას შემდეგ, რაც ჩვენ განვიხილეთ, რა ფილიალები და ორივე მათ შორის გადართვა, დროა ვისაუბროთ იმაზე, თუ როგორ შეიძლება კომბინირებული განვითარების შემდეგ. ფილიალი, რომელშიც ჩვენ გვინდა, რომ ცვლილებების შერწყმა გვინდა, მთავარ და ფილიალი, საიდანაც ჩვენ გავერთიანდეთ მათ - თემატურ. არსებობს ორი გზა, რათა შეიცვალოს ერთი ფილიალიდან მეორეზე: შერწყმა და გადაადგილება.

შეერთება

იგი მოიცავს ახალი ვალდებულებების შექმნას, რომელიც ეფუძნება ორი ფილიალის ზოგად დაწყებულ წინაპარს და მიუთითებს როგორც წინა ქვეწარმავტად. შერწყმა, ჩვენ მთავარ ფილიალს მივდივართ და გამოიყენეთ GIT შერწყმის ბრძანება<тематическая ветка> .

თუ ორივე ფილიალი შეცვალოს ფაილის იგივე ნაწილი, მაშინ კონფლიქტის კონფლიქტი ჩნდება - სიტუაცია, რომელშიც GIT არ იცის, რომელი ვერსია გადარჩენა, ამიტომ აუცილებელია კონფლიქტის მოგვარება. კონფლიქტის ფაილების სანახავად, Git სტატუსის გამოყენება.

ასეთი ფაილების გახსნის შემდეგ, თქვენ იხილავთ მსგავსი კონფლიქტების მოგვარების მარკერებს:

<<<<<<< HEAD:index.html Everything above the ==== is the version in master. ======= Everything below the ==== is the version in the test branch. >\u003e\u003e\u003e\u003e\u003e\u003e Test: index.html

შეცვალეთ ამ ბლოკში ყველაფერი, რაც გსურთ დატოვოთ და მოამზადეთ ფაილი. ყველა კონფლიქტის მოგვარების შემდეგ, შეგიძლიათ გამოიყენოთ GIT ვალდებულებები, რათა დასრულდეს შერწყმა.

შესახლება

შერწყმის კომიტეტის ორი ფილიალის კომბინირების ნაცვლად, თემატური ფილიალის კომიტეტებს, საბაზისო ფილიალის ახალი კომიტეტების სახით, რომელიც წყვეტს სუფთა ისტორიას.

Git Rebase ბრძანება გამოიყენება გადაადგილება<основная ветка> <тематическая ветка> რომელიც ხელს უწყობს თემატური ფილიალის ცვლილებებს; ხელმძღვანელი თემატური ფილიალი მიუთითებს უკანასკნელ რეპროდუცირებულ ვალდებულებას.

გადაადგილება vs. შეერთება

მას შემდეგ, რაც შერწყმის ჟურნალი ამბავი შეიძლება გამოიყურებოდეს საკმაოდ შემთხვევით. მეორეს მხრივ, მოძრავი საშუალებას გაძლევთ გადაწეროთ სიუჟეტი ნორმალურ, თანმიმდევრულ ფორმაში.

რატომ გჭირდებათ შერწყმა, თუ შეგიძლიათ გამოიყენოთ ყველა დროის გადაადგილება? სამწუხაროდ, მოძრავი არ არის პანაცეა დამაბნეველი ჟურნალებისგან, რადგან იძულებით გადაადგილებული პირები განსხვავდება ორიგინალიდან, თუმცა მათ აქვთ იგივე ავტორი, გაგზავნა და ცვლილება.

წარმოიდგინეთ სცენარი:

• თქვენს ფილიალში, თქვენ შექმნით რამდენიმე ჩადენას და შერწყმის მათ სამაგისტრო ფილიალში.
• ვინმეს გადაწყვეტს მუშაობა თქვენი ჩადენის საფუძველზე.
• თქვენ გადაწყვიტეთ გადაადგილება თქვენი ჩათვლით და გააგზავნეთ სერვერზე.
• როდესაც ვინმე ცდილობს მათი მუშაობის შერწყმა თქვენი თავდაპირველი ჩადენის საფუძველზე, საბოლოო ჯამში ორ პარალელურ ფილიალს მივიღებთ ერთი ავტორის, შეტყობინებების და ცვლილებებით, არამედ სხვადასხვა ჩათვლით.

აქედან გამომდინარე, აქ არის რჩევა:

ცვლილებების გადატანა მხოლოდ თქვენს კერძო ადგილობრივ ფილიალში - არ გადაიტანოთ ჩანაწერები, რომელზეც ვინმე დამოკიდებულია.

კომიტეტის Rollback - დაბრუნება და გადატვირთვა

მსგავსი დებატები, თუ რა არის უკეთესი გამოყენება, მოხდეს, როდესაც გსურთ გააფართოვოს commote. გუნდი Git დაბრუნების.<коммит> ქმნის ახალ ვალდებულებას, ცვლილებების გაუქმებას, მაგრამ ისტორიის შენარჩუნებას, ხოლო Git გადატვირთვა<коммит> მოძრაობს ხელმძღვანელი მაჩვენებელი, რომელიც უზრუნველყოფს სუფთა ისტორიას (თითქოს ეს არანაირი შემთხვევა არ მოხდა). მნიშვნელოვანია აღინიშნოს, რომ ეს ასევე ნიშნავს, რომ თქვენ აღარ დაბრუნდებიან ამ ცვლილებებზე, მაგალითად, თუ თქვენ ჯერ კიდევ გადაწყვეტენ, რომ ჩაიდინოს ვალდებულება არასაჭირო იყო. სუფთა - არ ნიშნავს უკეთესი!

შეჯამება

ამ ეტაპზე თქვენ თითქმის ყველაფერი თქვენ გჭირდებათ მუშაობა Git. ქვემოთ იქნება რამდენიმე (სურვილისამებრ) მოწინავე რჩევები უფრო დიდი კონტროლისთვის. გარდა ამისა, მაშინ ჩვენ casually გავლენას ახდენს Github - ერთი ყველაზე ცნობილი პლატფორმა, რომელიც მუშაობს GIT, რომელიც შეიძლება სასარგებლო იყოს თქვენთვის.

Github.

GitHub არის პლატფორმა, რომელიც ინახავს Git საცავი მის მრავალჯერადი სერვერებზე. როგორც GitHub მომხმარებელი, თქვენ შეგიძლიათ შეინახოთ თქვენი დისტანციური საცავები მათ სერვერებზე, ასევე ხელი შეუწყონ სხვა ღია საცავში. Github ავსებს გამოყენების Git ზოგიერთი ახალი თვისებები.

მაგალითად, თქვენ შეგიძლიათ გააკეთოთ ჩანგალი დისტანციური საცავი, რომელიც არის, რათა შეიქმნას თქვენი ასლი საცავის ჩრდილოეთით GitHub- ში. ეს სასარგებლოა იმ შემთხვევებში, როდესაც თქვენ არ გაქვთ უფლება, შექმნან ფილიალი თავდაპირველი საცავში. როდესაც თქვენ იყენებთ Git Clone Command- ს, თქვენი ადგილობრივი საცავი დისტანციურ ფორმას, როგორც წარმოშობის, და ორიგინალური საცავი, როგორც ზემოთ.

ამის შემდეგ თქვენ შეიძლება დაგჭირდეთ თქვენი დისტანციური საცავის თემატური ფილიალის გადინება ორიგინალური. ამისათვის თქვენ შეგიძლიათ შექმნათ ახალი დახვეწილი მოთხოვნა - ცვლილებების შეტანის მოთხოვნა, სადაც GitHub ამოწმებს კონფლიქტების არსებობას, სანამ თქვენ შექმენით შერწყმა. ხშირად არსებობს სხვა ამოწმებს შერწყმის დაწყებამდე, როგორიცაა კოდის დათვალიერება და დამტკიცების ან ტესტების დაწყებისას. შეკითხვაზე, თქვენ შეგიძლიათ განიხილონ კოდი და ყველა ჩადენილი, რომ თქვენ გადაგზავნილი დისტანციური თემატური ფილიალი ავტომატურად დაემატება მოთხოვნას, მაშინაც კი, თუ იგი შეიქმნა ადრე ამ ჩათვლით.

გაფართოებული გამოყენება: ინტერაქტიული მომზადება

თქვენ შეგიძლიათ მარტივად მართოთ მომზადებული ფაილების ფართობი (მაგალითად, ერთ დიდ მცირეწლოვანთა ნაცვლად, ერთი მცირეწლოვანი ნაცვლად) ინტერაქტიული კონსოლის გამოყენებით, რომლითაც შეიძლება დაიწყოს GIT Add -i. 8 გუნდი ხელმისაწვდომია:

• სტატუსი - აჩვენებს მოკლე აღწერა თითოეული ფაილი, რომელიც (არა) მომზადდა;
• განახლება - ამზადებს თვალთვალის ფაილებს;
• დაბრუნება - ამოღება ერთი ან მეტი ფაილი მომზადებული ფართობი;
• დაამატეთ untraced - ამზადებს არაკვალიფიციურ ფაილს;
• patch - ამზადებს მხოლოდ ფაილის ნაწილს (სასარგებლო, როდესაც თქვენ, მაგალითად, შეიცვალა რამდენიმე ფუნქცია, მაგრამ გსურთ შეცვალოთ ცვლილებები რამდენიმე ჩადენებში). ფაილის შერჩევის შემდეგ, თქვენ გისურვებთ ფრაგმენტებს და წარმოდგენილია შესაძლო ბრძანებები: ეტაპზე ეს hunk? . შემიძლია შესვლა? გაირკვეს, თუ რა ხდის თითოეულ გუნდს;
• diff - გვიჩვენებს სია მომზადებული ფაილი და საშუალებას გაძლევთ ნახოთ ცვლილებები თითოეული მათგანი;
• დატოვა - გამოდის ინტერაქტიული კონსოლიდან;
• დახმარება - აჩვენებს თითოეული გუნდის მოკლე აღწერა.

სიმბოლო * ფაილის შემდეგ ნიშნავს, რომ ბრძანება შეიცვლება მისი სტატუსი (მომზადებული / მოუმზადებელი დამოკიდებულია თუ არა განახლება ან rollback ხდება). თუ დააჭირეთ ღილაკს ნებისმიერი ბრძანების მენიუში, მაშინ ყველა ფაილი გადადის (არა) მომზადებულ სახელმწიფოს.

გთხოვთ გაითვალისწინოთ, რომ წერთ (ფაილის ნაწილის მომზადება) ხელმისაწვდომია არა მხოლოდ ინტერაქტიული კონსოლით, არამედ GIT Add -P- ის მეშვეობით.

გაფართოებული გამოყენება: წესების ისტორია

ადგილობრივი ფილიალის ისტორიის დიდი კონტროლისთვის შეგიძლიათ გამოიყენოთ GIT Rebase -i Head ~ ბრძანება ნ. რომელიც გახსნის ინტერაქტიულ კონსოლს ამ უკანასკნელის კომპლექტისთვის ნ. ძველიდან ახალი (ეს არის, რომლითაც ისინი გადაადგილდებიან). ასე რომ თქვენ შეგიძლიათ "ისტორიის რედაქტირება", თუმცა გახსოვდეთ, რომ ორიგინალი არ შეიძლება შეიცვალოს, მხოლოდ გადაადგილება.

თქვენ შეგიძლიათ შეცვალოთ შეკვეთის შეკვეთა შეკვეთის შეცვლით, სადაც ისინი ჩამოთვლილია.

შეცვალეთ ვალდებულება / გაყიდვა

კომიტეტის დაზუსტებისთვის გსურთ შეცვალოთ, რედაქტირების ბრძანება გამოიყენება. მაშინ, როდესაც git გადავა, ის შეწყდება ამ com. ამის შემდეგ, თქვენ შეგიძლიათ გამოიყენოთ GIT- ის ჩადენა - შეტყობინებების შეცვლა ან დავიწყებული ფაილები. თუ გსურთ გაყოფილი COMMOTE, შეჩერების შემდეგ, შეიტანეთ GIT RESET HEAD ^ (ხელმძღვანელის შედეგად, ის გადავიდა ერთი ჩაიდინოს და ყველა ფაილი შეიცვალა ამ ვალდებულებაში, მოუმზადებელი ". მაშინ თქვენ შეგიძლიათ დააფიქსიროთ ფაილი ინდივიდუალური ჩადენაში ჩვეულ რეჟიმში.

რედაქტირების შემდეგ დასრულდა, შეიტანეთ Git Rebase - Continue.

გადაწერა რამდენიმე ჩაიდინოს

ზოგჯერ შეიძლება დაგჭირდეთ რამდენიმე ჩანაწერის გადაწერა - ასეთ შემთხვევებში შეგიძლიათ გამოიყენოთ Git ფილტრაციის ფილიალი. მაგალითად, შემთხვევით ჩაწერილი ფაილის წაშლა, შეგიძლიათ შეიყვანოთ Git ფილტრაციის ფილიალი --Tree-filter "Git RM -F<имя файла>"უფროსი, თუმცა, განიხილეთ, რომ ამავე დროს მთელი ამბავი მოძრაობს.

აერთიანებს რამდენიმე ჩადენას

პროექტში ახალი ფუნქციის მუშაობისას თქვენ შეგიძლიათ ეტაპობრივად ჩაწეროთ თემატური ფილიალის ოდნავი ცვლილებებიც კი. თუმცა, ამის გამო, ისტორია ასეთ პატარა ჩადენებს, რაც ხელს შეუწყობს პროექტის წესებს. ეს შეიძლება გამოსწორდეს რამდენიმე წყვილის კომბინაციით. ამის გაკეთება, პირველი გამოიყენოთ აირჩიოთ ბრძანება შერჩევა პირველი ჩაიდინოს, შემდეგ კი squash შემდგომი. GIT გამოიყენებს ყველა ცვლილებას ერთიანად და გკითხოთ გენერალური ჩადენის შეცვლის შესახებ.

გადარიცხვა ცალკე COMMOTE

თემატური ფილიალის შერწყმის / გადაადგილების გარდა, თქვენ შეგიძლიათ მხოლოდ დაინტერესებული იყოს გარკვეული ვალდებულებით. დავუშვათ, რომ თქვენ გაქვთ ადგილობრივი პროექტების ფილიალი, სადაც მუშაობთ მრავალჯერადი პოტენციურ სტატიებზე, მაგრამ გსურთ მხოლოდ ერთი მათგანი გამოაქვეყნოთ. ამისათვის თქვენ შეგიძლიათ გამოიყენოთ Git Cherry-Pick ბრძანება. მიიღოს გარკვეული ჩადენილი, საიდანაც ჩვენ გვინდა აირჩიოთ, შეგიძლიათ გამოიყენოთ Git შესვლა<основная ветка>..<тематическая> .

გთხოვთ გაითვალისწინოთ, რომ ამ გზით შეიქმნება ახალი ვალდებულება, რომელიც მხოლოდ იმეორებს შერჩეულ ვალდებულებას (ეს არის განსხვავება ამ ჩადენასა და წინა) შორის, მაგრამ არა მისი მდგომარეობა.

დასკვნა

ამიტომ ჩვენ განვიხილეთ GIT- ის ძირითადი ცნებები. თქვენ შეგიძლიათ გამოიყენოთ ეს სტატია, როგორც მოკლე საცნობარო წიგნი, და შეგიძლიათ წაიკითხოთ წიგნი "პრო Git", რაც ბევრად უფრო (~ 450 გვერდები) და აღწერს უფრო ღრმად.

გინდა გათხრა ღრმა git, მაგრამ თქვენ გაქვთ პატარა (ან პირიქით, ბევრი) ერთი დიდი წიგნი? მაშინ უნდა გამოიყურებოდეს ჩვენს.

ცვლილებების დაპირისპირება - პირის მთავარი თვისება. იმ შემთხვევაში, თუ იმ დროს, როდესაც თქვენ დაიწყო მუშაობა ვერსიების კონტროლის სისტემებთან, არ იყო Git - ძალიან სავარაუდოა, რომ თქვენ დაიწყო სუბვერსიით. ხშირად ამბობენ, რომ git ძალიან რთულია დამწყებთათვის. მიუხედავად ამისა, მე დავუშვებ თავს არ ვეთანხმები თქვენთან ერთად.

ამ სტატიაში მე გეტყვით, თუ როგორ გამოიყენოთ GIT თქვენი პროექტების მუშაობაში. ჩვენ ვივარაუდოთ, რომ თქვენ შექმნით პროექტს ნულიდან და გსურთ გამოიყენოთ GIT, როგორც ვერსია კონტროლის სისტემა. ძირითადი ბრძანებების წაკითხვის შემდეგ, წაიკითხეთ, თუ როგორ შეგიძლიათ გააკეთოთ თქვენი კოდი GitHub- ზე.

ეს სტატია ისაუბრებს ძირითად საკითხებზე - როგორ უნდა დაიწყოს პროექტი, როგორ უნდა მართოს ახალი და არსებული ფაილები და როგორ უნდა შეინახოთ თქვენი კოდი ღრუბლებში. ჩვენ შევამცირებთ გარკვეულ რთულ რამეს, როგორიცაა ფილიალი, რადგან სტატია ორიენტირებულია დამწყებთათვის.

დამონტაჟება GIT.

ოფიციალურ საიტზე GIT არის სხვადასხვა სისტემები - Linux, Mac, Windows. ჩვენს შემთხვევაში, ჩვენ გამოვიყენებთ Ubuntu 13.04 და Git ჩვენ დამონტაჟდება მეშვეობით apt-get.

Sudo Apt-Get Install Git

თავდაპირველი კონფიგურაცია

შექმნა დირექტორია, რომელშიც ჩვენ ვიმუშავებთ. თქვენ ასევე შეგიძლიათ გამოიყენოთ git მუშაობა არსებული პროექტი, და ამ შემთხვევაში თქვენ არ შექმნიან დემონსტრაციის დირექტორია, როგორც ეს აღწერილია ქვემოთ.

Mkdir my_git_project cd my_git_project

უპირველეს ყოვლისა, აუცილებელია პროექტის დირექტორიაში Git საცავის ინიციალიზაცია. თქვენ შეგიძლიათ გააკეთოთ ეს init ბრძანება, რომელიც ქმნის დირექტორიაში. ყველა ინფორმაციას თქვენი პროექტის შესახებ.

Git config - config --global user.name "shaumik" git config --global user.email " [Email protected]"Git config --global color.ui" ავტო "

აღსანიშნავია, რომ თუ არ დააკონკრეტებთ თქვენს მისამართს და სახელს, მაშინ ნაგულისხმევი ღირებულებები გამოყენებული იქნება ნაცვლად. ჩვენს შემთხვევაში, ნაგულისხმევი ღირებულებები იქნება donny და [Email protected]

ჩვენ ასევე მითითებული ინტერფეისის ფერი ავტო ღირებულება, ისე, რომ გამომავალი Git ბრძანებები იქნება ფერი. ჩვენ დავამატებთ - გლობალური პრეფიქსის ამ ბრძანებებს, რათა ეს ღირებულებები გამოიყენება სისტემაში და არ იყო საჭირო თითოეული ინდივიდუალური პროექტისთვის.

ჩაიდინოს ფაილების მომზადება

შემდეგი ნაბიჯი ჩვენ შევქმნით რამდენიმე ფაილს. ამისათვის შეგიძლიათ გამოიყენოთ ნებისმიერი ტექსტური რედაქტორი. გაითვალისწინეთ, რომ თუ თქვენ მიიღებთ GIT- ს არსებულ პროექტში, თქვენ არ გჭირდებათ ეს ნაბიჯი.

შეამოწმეთ საცავის მდგომარეობა

ახლა, რომ არის ფაილები თქვენს პროექტში, ვნახოთ, როგორ მიმართავს GIT მათთან. მიმდინარე საცავის სტატუსის შესამოწმებლად, გამოიყენეთ GIT სტატუსის ბრძანება.

დაამატეთ ფაილები Git

ამ ეტაპზე, GIT არ შეესაბამება ერთ-ერთ ჩვენს ფაილს. აუცილებელია კონკრეტულად დაამატოთ ფაილი git ისე, რომ ეს მოხდა. ამისათვის გამოიყენეთ დამატება ბრძანება.

Git add my_file.

საცავების სტატუსის შემოწმების შემდეგ, ჩვენ ვხედავთ, რომ ერთ-ერთი ფაილი უკვე დაემატა მას.

მრავალჯერადი ფაილების დასამატებლად, ჩვენ ვიყენებთ შემდეგს (შეამჩნევთ, რომ პირველად დავამატეთ პირველი ფაილი, ასე რომ, მხოლოდ დანარჩენი ორი) დავამატებთ.

Git Add MyFile2 MyFile3

თქვენ შეგიძლიათ გამოიყენოთ GIT დამატება რეკურსიულად, მაგრამ ფრთხილად იყავი ამ ბრძანებით. არსებობს რამდენიმე ფაილი (მაგალითად, შედგენილი პროგრამები), რომელიც არ უნდა დაემატოს ვერსიის კონტროლის სისტემას. თუ თქვენ იყენებთ Git- ს რეკურსიულობას, ასეთი ფაილი ასევე იქნება საცავში.

Წაშალე ფაილები

წარმოიდგინეთ, რომ თქვენ შემთხვევით დასძინა ფაილი საცავში, რომელიც არ უნდა იქ. ან გსურთ ამოიღოთ ნებისმიერი ფაილი ვერსიის კონტროლის სისტემისგან. ზოგადად, Git RM ბრძანება არ იქნება უბრალოდ წაშლა ფაილი საცავიდან, არამედ ფიზიკურად წაშლის დისკზე. Git შეჩერება თვალთვალის ფაილი, მაგრამ ის დარჩა დისკზე, გამოიყენოთ შემდეგი ბრძანება:

Git rm --cached [ფაილის სახელი]

Commimim ცვლილებები

ერთხელ თქვენ დაემატა ყველა საჭირო ფაილი, შეგიძლიათ კომენტარი (ფიქსის) მათ git. წარმოიდგინეთ, რომ ვალდებულებას წარმოადგენს პროექტის სტატუსის სნაფშოტი, რომელიც ნებისმიერ დროს შეგიძლიათ დაბრუნდეთ და ნახეთ პროექტის სტატუსი იმ დროს. თითოეულ კომიტეტთან, გაგზავნა დაკავშირებულია, რომ არგუმენტი მითითებულია პრეფიქსის შემდეგ

GIT ვალდებულებას - "ჩემი პირველი ვალდებულება"

მიუთითეთ შეტყობინება, რომელიც შეიცავს სასარგებლო ინფორმაციას, რადგან ისინი დაეხმარება გაიგონ, რა შეიცვალა ამ ჩადენაში. მოერიდეთ საერთო შეტყობინებებს, როგორიცაა "შეცდომების წესები". თუ თქვენ გაქვთ Bug Tracker, შეგიძლიათ მიუთითოთ გაგზავნა ტიპის "Bug # 123". კარგი პრაქტიკა - მიუთითეთ ფილიალის სახელი ან გაუმჯობესება. მაგალითად, "აქტივების მართვა - დასძინა, რომ PDF- ის გენერირება აქტივის საფუძველზე" - ნათელი და გასაგები გაგზავნა.

GIT განსაზღვრავს COMMOTE LONG HEXADECIMAL რიცხვს. როგორც წესი, არ არის საჭირო მთელი ხაზის კოპირება, პირველი 5-6 სიმბოლო, რომელიც საკმარისია კონკრეტული ჩაიდინოს. Screenshot- ში, ჩანს, რომ ჩვენი COMPOTE იდენტიფიცირებულია 8DD76FC- ის მიერ.

შემდგომი ჩართვა

მოდით შევცვალოთ მრავალი ფაილი შემდეგ ჩვენ მათ. მას შემდეგ, რაც ჩვენ შევცვალა მათ, Git სტატუსი იქნება ანგარიშს, რომ ჩვენ შეიცვალა ფაილი.

თქვენ ხედავთ, რა შეიცვალა ამ ფაილებში, რადგან წინა ვალდებულება, Git Diff ბრძანების გამოყენებით. თუ გსურთ შეცვალოთ ცვლილებები კონკრეტული ფაილისთვის, შეგიძლიათ გამოიყენოთ Git Diff<файл> .

აუცილებელია ცვლილებების მაჩვენებელი და მათ. ყველა მოდიფიცირებული პროექტის ფაილი შეიძლება დაემატოს შემდეგ ბრძანებას ვალდებულებას:

თქვენ შეგიძლიათ თავიდან აცილება ამ ბრძანების გამოყენებით, თუ დაამატებთ პარამეტრს Git ჩაიდინოს. ეს ბრძანება ინდექსებს ყველა მოდიფიცირებულ ფაილს და კომფორტებს. მაგრამ ეს მიდგომა შეიძლება საკმაოდ სახიფათო იყოს, ასე რომ შეცდომით შეგიძლიათ გაითვალისწინოთ ის ფაქტი, რომ მე არ მინდა. მაგალითად, ვთქვათ, რომ თქვენ გახსნა ფაილი და შემთხვევით შეიცვალა იგი. შეცვლილი ფაილების ინდექსირება, თქვენ მიიღებთ თითოეულ ფაილში ცვლილებებს. მაგრამ თუ თქვენ გააგზავნით ყველა მოდიფიცირებულ ფაილს დახმარების გარეშე. GIT Comment -a, მაშინ ყველა ფაილი იქნება ჩადენილი, მათ შორის, ვინც თქვენ ჩაიდინოთ არ სურდა.

როგორც კი თქვენ ინდექსირებული ფაილი, შეგიძლიათ გააგრძელოთ ჩაიდინოს. როგორც ზემოთ აღვნიშნეთ, შეგიძლიათ მიუთითოთ შეტყობინება, რომ ჩაიდინოს გასაღები. მაგრამ თქვენ ასევე შეგიძლიათ მიუთითოთ მრავალმხრივი კომენტარი GIT- ის ვალდებულებების გამოყენებით, რომელიც Console რედაქტორს ანიჭებს კომენტარს.

პრობლემის მართვა

პროექტის ისტორიის სანახავად შეგიძლიათ გამოიყენოთ შემდეგი ბრძანება:

ეს იქნება სრული ისტორია ისტორიის სახით ჩადენილი სიის სახით და მათ შესახებ ინფორმაცია. ინფორმაცია ვალდებულია შეიცავს hash ვალდებულებას, ავტორის, დროისა და კომუტატების შეტყობინებას. არსებობს მრავალი სახის GIT Log გუნდები, რომელთაც უნდა გაეცნონ GIT- ში ფილიალის გამოყენებისას. კონკრეტული ჩაიდინოს დეტალების სანახავად და მოდიფიცირებული ფაილების დეტალები, აწარმოეთ შემდეგი ბრძანება:

Git შოუ.<хеш_коммита>

სად<хеш_коммита> - Hex ნომერი ასოცირდება ჩაიდინოს. მას შემდეგ, რაც ეს სახელმძღვანელო დამწყებთათვის განკუთვნილია, ჩვენ არ განვიხილავთ, თუ როგორ უნდა დავუბრუნდეთ სახელმწიფოს კონკრეტულ ვალდებულებას, ან როგორ უნდა გააკონტროლონ ფილიალები.