Git ბიძგი ახალ ფილიალში. შექმნა ახალი ფილიალი სერვერზე მიმდინარე ადგილობრივი ფილიალიდან. რა განსხვავებაა ”git pull” და ”git fetch” შორის

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

  1. $ git კლონი https: // მომხმარებლის სახელი: [ელ.ფოსტა დაცულია]/opt/git/repository.git

ფილიალებთან მუშაობა

  აჩვენეთ ყველა ფილიალი:
  1. $ git ფილიალი
  შექმენით ახალი ფილიალი:
  1. $ git ფილიალი
  გადადით ახალ ფილიალში:
  1. $ git გადახდა
  შექმენით ახალი ფილიალი და გადადით მასზე:
  1. $ git გადახდა -b
  ადგილობრივი ფილიალის წაშლა:
  1. $ git ფილიალი –d
  წაშალეთ ფილიალი დისტანციური საცავიდან:
  1. $ git push წარმოშობის - ამოღება

მუშაობა ვალდებულებების შესრულებით

როგორ წაშლა ბოლო ჩადენა?

  1. $ git გადატვირთვა - მაღალი HEAD ^
გაითვალისწინეთ როგორ. თავი 16. ვალდებულებების გაუქმება
გაითვალისწინეთ როგორ. თავი 17. ფილიალისგან ვალდებულებების ამოღება
ოფიციალური დოკუმენტაცია. Git საფუძვლები - ცვლილებების დაბრუნება

როგორ შევცვალოთ ბოლო ჩადენა?

  1. $ git დაამატეთ new_file.txt
  2. $ git ჩადენა --amend

როგორ შევცვალოთ კომენტარი ბოლო ჩადენის შესახებ?

  1. $ git ჩადენა --amend
  2. $ git ჩადება --amend -m "ახალი კომენტარი"

როგორ გავაერთიანოთ მრავალი ვალდებულება?

  1. $ git rebase -i HEAD ~ 3
   HEAD ~ 3-ის ნაცვლად, შეგიძლიათ გამოიყენოთ ჩადენის ჰაში. აუცილებელია გადავიდეს იმ ჰალის მიმართ, რომლის მიმართაც ყველაფერი საჭიროა შერწყმა (გაბრტყელება).
რედაქტორი გახსნის ვალდებულებების ჩამონათვალს, ყველაზე ძველი ჩადენილი იქნება ზედა.
  1. აირჩიე 1111111 1 კომენტირება
  2. აირჩიე 2222222 მოვალეობა 2 კომენტარი
  3. შეარჩიე 3333333 კომიტეტის 3 კომენტარი
   თქვენ უნდა შეცვალოთ პიკაპი მწვანით, რომ მიიღოთ ეს:
  1. აირჩიე 1111111 1 კომენტირება
  2. squash 2222222 მოვალეობა 2 კომენტარი
  3. squash 3333333 3 კომენტარი
   შემდეგი, თქვენ უნდა შეინახოთ ფაილი და გამოვიდეთ. კვლავ გაიხსნება ტექსტური რედაქტორი, ყველა კომენტარის შესახებ კომიტეტისთვის. თქვენ უნდა შეცვალოთ, შეინახოთ და გამოხვიდეთ. ამ ქმედებების შემდეგ, კომიტეტები გაერთიანდება.

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

  1. $ git გადახდა - file.txt

როგორ უნდა გავაუქმოთ ყველა დაუვიწყარი (დაუმთავრებელი) ცვლილებები?

  1. $ git გადახდა

როგორ ჩავატაროთ რამდენიმე ფაილი შემდეგი ჩადენისთვის?

დავუშვათ, რომ გსურთ შეცვალოთ ზოგიერთ ფაილში და შეასრულოთ ცვლილებები სხვა ფაილებში შემდეგ ვალდებულებაში. შემდეგ შეგიძლიათ დროებით ამოიღოთ ისინი საცავიდან (არასტაბილური ფაილები), შემდეგ კი კვლავ დაამატეთ ისინი.
  1. $ git გადატვირთეთ HEAD ფაილი.txt
   ეს ბრძანება წაშლის ფაილს საცავიდან, ის ძველ კომიტეტებში დარჩება. ხელმძღვანელი მიუთითებს ბოლო ვალდებულებაზე მიმდინარე ფილიალში.

თუ ვერ გადაიტანეთ დისტანციური საცავი, რადგან საცავის ახლანდელი ვერსია უფრო მცირეა, ვიდრე დისტანციური საცავი

ამ შემთხვევაში, შეგიძლიათ დააყენოთ ბიძგი.
  1. $ git push -f წარმოშობის ოსტატი

ფილიალების შერწყმა

როგორ ავიღოთ მხოლოდ რამდენიმე ფილიალიდან მხოლოდ რამდენიმე ფაილი?

  1. $ git checkout ფილიალის სახელი - გზა / ფაილში. ფაილი

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

აჩვენეთ ინფორმაცია დისტანციური საცავის შესახებ

  1. $ git დისტანციური შოუს წარმოშობა
  ის აჩვენებს მსგავსი რამ:
  1. * დისტანციური წარმოშობის
  2. მიიღეთ URL: [ელ.ფოსტა დაცულია]: /opt/git/test-project.git
  3. დააჭირეთ URL: [ელ.ფოსტა დაცულია]: /opt/git/test-project.git
  4. ხელმძღვანელის ფილიალი: ოსტატი
  5. დისტანციური ფილიალი:
  6. სამაგისტრო ახალი (შემდეგი ნაყოფი ინახავს დისტანციურად / წარმოშობით)
  7. ადგილობრივი Ref კონფიგურაციაა "git push" - ისთვის:
  8. ოსტატი უბიძგებს ოსტატობას (ადგილობრივი დროიდან არის ძველი)

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

  1. $ git დისტანციური დაამატეთ წარმოშობა [ელ.ფოსტა დაცულია]: /opt/git/test-project.git

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

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

ისტორია გადაწერეთ ბიძგი

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


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

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

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

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

ეს ყველაფერი შეიძლება დამაბნეველი იყოს, ამიტომ მოდით შევხედოთ მაგალითს. დისტანციური საცავი შევქმენი GitHub– ზე https://github.com/n0tb0dy/RemoreBranches

იქ სამი კომიტეტი გავაკეთე


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

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

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

”წარმოშობა” არ არის განსაკუთრებული სახელი

ეს მსგავსია სამაგისტრო ფილიალის სახელწოდების სახელზე, რომელიც ნაგულისხმევი მოცემულია ადგილობრივი საცავის შექმნისას. ისევე როგორც ფილიალი ოსტატი  შეიქმნა ნაგულისხმევი, როდესაც ბრძანება git ინიციატივა, ისევე როგორც ნაგულისხმევი სახელი გამოიყენება წარმოშობა  ბრძანებით გიტ კლონი. თუ გიიტ კლონს - Booyah ბრძანებას მისცემთ, მიიღებთ booyah / master– ს, როგორც თქვენს დისტანციურ დისტანციურ ფილიალს.

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

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

და ასე ჩვენს უკან დაბრუნებას. დისტანციურ საცავზე ისინი ასე გამოიყურება

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

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

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

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

ჩვეულებრივ, უმჯობესია გამოიყენოთ git fetch ბრძანება და git შერწყმის ბრძანება, რომ შეძლოთ საკუთარი თავის შერწყმის კონტროლი.

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

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

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

ადგილობრივი შვილობილი ეფექტები სხვა დეველოპერებისთვის

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

$ git push წარმოშობა - ამოღება სერვერზე


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

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

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