Какой командой можно создать ветку branch1

Как создать новую ветку в Git

Чтобы создать новую ветку в Git необходимо выполнить команду (вместо mybranch укажите название вашей новой ветки):

git branch mybranch

После выполнения команды, будет создана новая ветка с именем, которое вы указали. Обратите внимание, что вы все еще находитесь в текущей ветке.

Переключаемся на новую ветку

Чтобы переключиться на новую ветку, выполните команду:

git checkout mybranch

Создаем и переключаемся одной командой

Чтобы создать ветку и сразу же на нее переключиться, используется команда checkout с ключом -b :

git checkout -b mybranch

Смотрите также:

• Как изменить файлы в старом коммите (не последнем)
• Как добавить все файлы в коммит, кроме одного
• Как создать ветку из предыдущего коммита
• Команда Git stash. Как прятать изменения в Git
• Как показать файлы, которые будут добавлены в текущий коммит

julius1986 / git-all-commands.txt

This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters

//задаем имя пользователя глобально, можно использовать локальные конфигурации после init

git config —global user.name «FirstName LastName»

//задаем имейл глобально, можно использовать локальные конфигурации после init

git config —global user.email «email@blabla.com»

git config —list // показывает все настройки, можно добавить флаги —global или —local

git config user.name «Yuliy» //задает локальные настройки username

git config —unset user.name // удаляет локальные настройки username, можно добавить флаг —global

git config —remove-section user // удаляет все настройки в секции user

/*локальные настройки находятся в директории с проектом в папку .git, глобальные в домашней директории пользователя,

а системные настройки в папке где был установлен git*/

/*для того что бы задать редактор по умолчанию для git используем git config —global core.editor «some editor»

изначально в git используется редактор vim*/

//для notepad++ -w/—wait ненужно ставить

git config —global core.editor «atom —wait» // задаем atom по умолчанию, можно задать -w или —wait

/*alias или ссылки*/

git config —global alias.somename command; //тут мы задаем ссылку для какойто комманды

git config —local alias.lshort log —oneline —date=short // делаем ссылку для краткого лога в локальном репозитории

/*для выполнения нескольких команд используем вначале «!» а затем пишем команды через «;» */

git config —local alias.todo «!echo «this is alias»; git log;»

/*Пример инициализации и создания нового репозитория*/

git init //инициализируеи гит проект в текущей директории — локально

git add . //индексим все файлы в данной директории, если существуют. Можно к примеру добавить README.md

git add * // индщескирует все файлы

git commit -m «some commit» //делаем коммит если были проиндексированны файлы

git remote add origin git@github.com:blablabla/yourrep.git //связываем локальный и глобальный репозитории,

//задает имя origin и присваивает ему ссылку

git push -u origin master //делаем пуш локального репа веткт мастер на удаленный репозиторий

//-u тоже что и —set-upstream задает репозиторий и ветку по умолчанию и мы можем просто писать git push или git pull

/*Если нужно просто закинуть в удаленный репозиторий то достаточно*/

git remote add origin git@github.com:blablabla/yourrep.git //связываем локальный и глобальный репозитории

git push -u origin master //делаем пуш локального репа в ветку мастер на удаленном репозитории

/*Так же можно просто создать на сайте и склонировать репозиторий с сайта*/

git clone https://github.com/.

/*собирает незакомиченные изменения и в специальном файле сохраняет их в гит после чего приводит к состояние в HEAD*/

git stash

//что бы достать наши незакомиченные изменения так же используем stash при этом добавляем pop

git stash pop

//индексирует указанный файл. Так же можно использовать «.»(точка) или -a — индексирует все файлы.

git add fileName

//позволяет отменить все изменения

git reset fileName

/* возвращает индексацию text.txt к тому состоянию где находится HEAD(тоесть к последнему коммиту). Вместо HEAD можно указать хеш коммита.

Если мы хотим вернуть файл к тому состоянию то должны исользовать команду git checkout — text.txt */

git reset HEAD text.txt //убрали из индексации

git checkout — text.txt //откатили на ту версию которая в репозитории

//позволяет увидеть текущий статутс. Можно увидеть все ли файлы обновлены и тд.

git status

//делает коммит в локальный репозиторий

git commit -m «some changes»

/*так же если нам срочно нужно зкомитить не проиндексированный файл*/

git commit -m «hight priority file» nameOfFile, secondFile //коммитит только указанные файлы,

//даже если есть другие проиндексированные файлы

/*можно закомитить файлы сразу без использования индексации, однако неотслеживаемые файлы будут проигнорированы*/

git commit -a -m «commit all files» //файлы должры быть отслежеваные, так же можно использовать сокращение -am «message»

//позволяет вывести лог коммитов

git log

// параметры для log

—oneline показывает в одну строку и делает хеш комитов короче

git reflog //показывает разные интересные логи, а точнее то что мы делали, можно восстановить недоавно удаленные коммиты

git show HEAD //показывает текущий комит

git show HEAD~3 //показывает комит 3 шага назад

//Важнейшая комманда. Позволяет переходить по коммитам. Так же позволяет переходить по веткам. Так же откатывать изменения.

git checkout someHash //переход к коммиту по хешу

git checkout -b someBranch //создание новой ветки и переход на нее. Сокращение git branch someBranch, git checkout someBranch

git checkout -B someBranch hashCommit //создаст новую ветку и перейдет в нее, если ветка существует то она будет создана на текущий //или указанный коммит

git checkout — someFile //если файл не проиндексирован, позволяет сделать откат на тот который в репозитории

git checkout — . //делает откат всех файлов если они еще небыли проиндексированы

git checkout nameOfCommit folder/file.html //если нам нужно в текущее состояние получить файл из какогото камита или ветки.

git checkout HEAD^ //перейти на 1 коммит назад

git checkout nameOfBranch //переходим в нужную ветку на последний коммит ветки, HEAD — становиться в конец ветки

git checkout -f HEAD //приводит файлы в рабочей директории к состоянию HEAD, состоянию которое было до нашего редактирования

git checkout hashCodeCommit file1 file2 // позволяет получить старые файлы в рабочую директорию

git checkout branchName file1 file2 // позволяет получить файлы в рабочую директорию из другой ветки

git reset — . //отменяет индексированность файлов(git add .)

git reset —soft HEAD^1 //делает откат на 1 шаг при этом текущее состояние имеет эти изменеия, их можно повторно комитить

git reset —hard HEAD^1 //делает откат на 1 шаг назад, удаляя текущие изменения

//позволяет откатить последний коммит или откатиться к указанному коммиту. Но в истории все коммииты остануться. Создает коммит отменяющий предыдущий.

git revert HEAD —no-edit //если повторять постоянно эту комманду то мы будет откатываться коммит за коммитом.

git revert someHash —no-edit // важно проверить git status и решить конфликты если есть.

// —no-edit — значит что коментарий будет по умолчанию, если не указывать этот параметр мы должны будем ввести сообщение

//после этого могут появитьяс конфликты, которые необходимо будет решить

//решить конфликт в файлах, сделать индексацию и потом сделать —continue

git status //проверяем есть ли конфликт

/*правим файл с конфликтом*/

git add fileName

git revert —continue

//При слиянии(merge) аналогичная операция, только можно просто использовать коммит

git log //показывает лог

git log —graph —oneline // показывает ввиде графа, в одну строку

git log format =»%h — %s — %an» //можно выводить лог в нужном формате в данном случае хэш, сообщение, автор

—date=short //выводит более короткую дату

—max-count //количество записей для вывода

/*rebase позволяет подтянуть изменения из другой ветки*/

//к примеру мы работаем в ветке dev и нам нужно подтянуть какието изменения из ветки master для этого можно использовать merge.

//rebase не сохраняет очередность(историю) коммитов в отличии от merge, тоесть сначала подтягиваются изменения

//из ветки/удаленного репозитория, а затем накладываются наши изменения.

//rebase — можно использовать в своих локальных репозиториях в остальных случаях лучше использовать merge

git rebase nameOfBranch // сливает изменения в ту ветку где мы находимся из ветки nameOfBranch

git pull —rebase origin dev // подтянуться изменения удаленного репозитория, а затем наши изменения

git rebase dev //если мы в мастере, то начиная от точки когда dev ушла от мастера, применятся комиты dev ветки

//а затем, применятся комиты мастера. Если же мы применим rebase на ветке dev то в ветке dev начиная от общего комита

//применятся комиты ветки master, а затем комиты dev ветки.

/*если мы не проиндексировали изменения то мы можем отправить их в stash(корзина или буфер)*/

git stash //поместить в корзину

git stash pop //достает последнее изменение и удаляет его из корзины

git stash apply //достает последнее изменение но не удаляет его из корзины

git stash drop // удаляет последнее изменение

git stash list // показывает все хранящиеся в корзине изменения

git stash show // показывает последнее изменение

git stash clear // удаляет все изменения в корзине

/*для удаления файла или папки используем rm*/

git rm fileName // теперь файл не будет отслеживаться

git rm -r folderName // папки и все файлы в ней прекратят отслеживаться

/*что бы удаляемый файл или директория остались в рабочем каталоге используем ключ —cached*/

git rm fileName —cached // файл не будет отслеживаться но в рабочем каталоге он останется, его можно самому удалить

/*для переименования файла используем git mv old.txt new.txt*/

git mv index.txt index.html //переименюет файл

//можно так же вручную переименовать и потом использовать git add .

/*Ветки*/

git branch // показывает все ветки, и текущую

git branch nameNewBranch //создает новую ветку с указателем(HEAD) на текущй коммит

git checkout nameOfBranch // переходим на ветку

git checkout -b nameOfNewBranch // создает новую ветку и сразу на нее переходит, указатель(HEAD) на текущий коммит

git branch -d nameOfBranch // удаляет ветку если она была слита(merge)

git branch -D nameOFBranch // принудительно удаляет ветку, даже если она не была слита(merge)

git checkout -f branchName hashCommit // позволяет принудительно перевести указатель(HEAD) для ветки на нужный коммит

//при этом необходимо находиться в другой ветке

git branch -d -r origin/ удаляет из отслеживаемых удаленную ветку

//удаляем ветку локально и глобально

git branch -d nameOFBranch

git push origin —delete crazy-experiment

//Прекращает отслеживать, сравнивать векти

git branch —no-track mywork origin/mywork

//Начинает отслеживать, сравнивать векти

git branch —track mywork origin/mywork

/*для применения комита из другой ветки, или же любого другого комита к нашей ветке используем cherry pick*/

git cherry pick hashOfCommit //применяет к нашей текуще ветке коммит с указанным хешем.

/*для просмотра всех недостижимых коммитов или коммитов которые вне веток*/

git fsck —unreachable

git clean -f //удаляет неотслеживаемые файлы

git clean -dxf //удаляет неотслеживаемые файлы, -d удаляет директории, -x удаляет файлы игнорируемые через .gitingnore

GIT FLOW — структура веток для проекта.

/СТАНДАРТНАЯ/

/*состоит из трех веток*/

master — тут выкатываются релизы

dev — тут ведется активная разработка, мерджится в тест

test — тут находятся пред релизные наработки для тестеров, если все хорошо то происходит мердж в мастером

/*————————————————————*/

git init — создать локальный репозиторий

git add filename — добавить файл в индекс(запомнить и следить за изменениями в файлах)

git rm —cached filename — убрать файл из индекса

git commit -a(добавить modified в индекс) -m «комментарий к версии» — зафиксировать добавленные в индекс(на сцену) файлы, создать версию.

git log — история версий/коммитов

git status — текущее состояние репозитория

git reset —hard commit — откатиться к commit с потерей изменений в файлах

git reset —soft commit — откатиться к commit без потери изменений в файлах

git branch — посмотреть все ветки

git branch branchname — создать ветку branchname

git branch -d branchname — удалить ветку branchname

git checkout branchname — переключиться на ветку branchname

git checkout -b branchname — создать и переключиться на ветку branchname

— инициализация нового репозитория

echo «# mygo» >> README.md

git init

git add README.md

git commit -m «first commit»

git remote add origin https://github.com/smarigowda/mygo.git

git push -u origin master

—

git config global

git checkout -b ‘BRANCH_NAME’ //checkout and create a new branch

git branch -D BRANCH_NAME //delete local branch

git branch -a //shows remote branches

git branch -m new_branch_name //переименовывает текущую ветку

git branch //посмотреть все ветки

git branch -v //посмотреть текущее состояние веток

git checkout —track -b BRANCH_NAME origin/BRANCH_NAME //track remote branch to local

git add -A //stages new, modified, and delete files

git reset //undo git add

git stash //stashes changes on a branch so you can switch to another

git stash pop //returns the changes from git stash

git diff —name-only branch_name_1..branch_name_2 //shows files changed between 2 branches

git diff branch_name_1 branch_name_2 — file_name.extension //diff a file between 2 branches

git checkout origin/master filename //restore a file to master/branch version

git clean -f //remove untracked files

git clone https://github.com/.

git add index.html — adding the file for commit.

git status — checks the changes

git commit -m «added index.html»

git push — will sync it to your repository

git pull — pulling down the github files to your working directory.

git pull = git fetch + git merge

git fetch — подтягивает данные с удаленного репозитория

git merge — обьединяет данные последнего и текущего состояния.

git merge Branch1 — применяет изменеия ветки Branch1 к текущей.

git merge — оставляет ветку при слиянии и добавляет изменеия в конец текущей ветки.

git rebase — расстворяет(обьединяет) ветку с того момента как было ответвление,

а затем только применяет коммиты текущей ветки.

git reset — reset add

git reset — reset all add

git reset —hard откатывает все файлы к HEAD.

Remove directory from git and local

git rm -r one-of-the-directories

git commit -m «Remove duplicated directory»

git push origin (typically ‘master’, but not always)

Какой командой можно создать ветку branch1

Мы продолжаем курс по системе контроля версий git. Сегодня разберемся, как работать с ветками. Ветки позволяют работать над кодом так, чтобы на время разработки, основная версия проекта оставалась без изменений.

Представьте, что у вас есть код, который работает. В какой-то момент вы решили добавить в него изменения. Работа над изменениями может занять некоторое время, в какой-то момент код может даже перестать работать. А вам нужно, чтобы в любой момент можно было воспользоваться рабочей версией проекта. В таких ситуациях могут помочь ветки.

Съемка и монтаж: Глеб Лиманский

Как настроить отображение веток

Git изначально настроен на работу с ветками. Когда мы создавали репозиторий, у нас автоматически появилась ветка main, в которую и коммитились все наши изменения. Важно всегда понимать, в какой ветке мы сейчас находимся. В git для этого есть понятие current branch.

Откроем терминал по адресу нашей папки. На Windows вы сразу увидите, в какой ветке находитесь. На mac это нужно настроить.

Создадим файл: touch ~/.zchrc.

Откроем ее: open ~/.zchrc.

Введем в открывшийся редактор кусок кода:

git branch 2> /dev/null | sed -n -e ‘s/^\* \(.*\)/[\1]/p’

Сохраним изменения в файле и вернемся в терминал.

Вводим команду source ~/.zchrc. Обозначение ветки появилось.

Когда в следующий раз будем открывать терминал, достаточно ввести только последнюю команду.

Добавляем код в открывшийся редактор

Наш терминал

Как создать ветку в Git

Представим, что мы хотим добавить в код input, чтобы пользователь вводил свое имя с клавиатуры. Пробовать изменения мы будем в отдельной ветке.

Создать новую ветку можно с помощью команды git branch . Важно, чтобы название было понятным для вас и других участников проекта.

Создадим новую ветку для проекта: git branch input.

Переключимся на новую ветку с помощью команды git checkout input. (Чтобы создать ветку и переключиться на нее за одно действие, можно воспользоваться флагом -b: git checkout -b .)

Внесем изменения в наш файл в ветке input. Для этого перейдем в редактор. Пусть код запрашивает имя пользователя, а потом здоровается с ним.

Добавим в начало запрос на ввод: name = input(«What’s your name? «)

И изменим первую строку вывода: print(«Hello, «, name,»!»)

Проверим, как работает наш код. Для этого нужно нажать на значок play в верхнем правом углу редактора. Код сначала просит нас ввести имя, а потом выводит нужную информацию. Изменения удались.

Закоммитим изменения: git commit -a -m “Add input”.

Проверим git status, убедимся, что рабочее дерево чистое. Проверим историю: git log. Видим весь путь работы: последнее изменение и все изменения, которые были еще до ответвления. Чтобы выйти из истории, нужно нажать q в английской раскладке.

Вернемся в основную ветку с помощью команды git checkout main и зайдем в редактор. Изменения пропали, потому что в основную ветку мы их еще не добавляли. Проверяем историю: git log. В ветке main видим только старые коммиты, до ответвления.

Как сливать ветки и решать конфликты

Когда мы сделали все нужные изменения в коде, проверили, что они работают так, как мы хотим, можно переносить изменения в основной код.

Сначала нужно переключиться на основную ветку: git checkout main.

Теперь можем забрать изменения из ветки input: git merge —no-ff -m “Сообщение о слиянии веток”.

Такая команда создаст новый коммит, в котором объединятся две ветки.

Флаг —no-ff отменяет механизм fast-forward, который стоит в git по умолчанию. Если его не отменить, git не будет создавать новый коммит, в котором объединятся две ветки, а просто сделает дополнительную ветку веткой main. Иногда такой механизм полезен, но сейчас он нас запутает, поэтому отключаем его. Вы можете поэкспериментировать и посмотреть, в какой ситуации какой механизм вам больше подходит.

В нашем случае git понял, как нужно совместить две ветки. Проверим редактор, чтобы убедиться, что результат тот, который нам нужен.

Иногда Git не понимает, как именно нужно объединить ветки и выводит сообщение о конфликте. В таких ситуациях, мы должны показать ему это. Для этого переходим в редактор, удаляем лишние символы и приводим код к тому виду, который нам нужен. Сохраняем файл в редакторе, проверяем git status — увидим сообщение о конфликте. Чтобы показать Git, что мы разрешили конфликт, просто закоммитим изменения: git commit -a -m «Add input in main».

Проверим историю: git log. Если видим сообщение о коммите, в котором сливаются две ветки, значит, все получилось.

Историю изменений, создания новых веток и слияния можно визуализировать: git log —oneline —graph.

Звездочкой показан каждый коммит, мы видим, что происходило на каждом шаге, в какой момент появилась новая ветка и что мы в ней делали, в какой момент слили ветки.

Как залить изменения на GitHub

Отправляем изменения на удаленный репозиторий: git push.

Проверяем GitHub. Изменения появились, но залилась только ветка main. Другие ветки нужно заливать отдельно: git push -u origin .

Зальем ветку input: git push -u origin input. Видим, что на GitHub появились две ветки. Переключиться между ветками можно в меню branch.

Как перемещаться по коммитам

Еще один важный указатель в git — это head. Он указывает, на какой ветке мы находимся. Если мы перейдем в историю, увидим, что head указывает на ветку main и на удаленную ветку origin_main. Это значит, наш локальный и удаленный репозитории синхронизированы.

Перейдем на другую ветку командой git checkout input, и в истории head будет указывать уже на input.

Мы можем перейти не только на другую ветку, но и на отдельный коммит. Будто перенестись в прошлое и посмотреть, как работал наш код на одном из этапов разработки. Сначала переключимся на основную ветку.

Посмотрим историю изменений: git log —oneline. (Эта команда дает более компактное отображение истории по сравнению с git log.)

Переходим на один из первых коммитов: git checkout . Head уже будет указывать на отдельный коммит, а в редакторе код тоже вернулся на тот этап.

С помощью таких перемещений по коммитам, мы можем искать ошибки, понимать, в какой момент код работал хорошо, а с какого этапа что-то пошло не так. Мы можем даже вносить изменения на этом этапе, но для этого нужно создать отдельную ветку.

Создадим новую ветку и переключимся на нее в одно действие с помощью флага -b: git checkout -b calc.

Добавим изменения в редактор: допишем строку 2+2. Сохраняем изменения в редакторе.

Добавим файл в отслеживание и коммитим изменения: git commit -a -m “Add calculation”.

Вернемся в основную ветку: git checkout main. Посмотрим все ветки: git branch. Видим, что появилась новая ветка calc.

Сделаем визуализацию наших изменений: git log —oneline —graph —all. Видим, что со второго коммита ответвилась еще одна ветка.

Как удалить ветку в Git

Если мы понимаем, что ветка больше не нужна, можно ее удалить. При этом удаляемая ветка не должна быть той веткой, в которой мы находимся. Удалим ветку calc: git branch -d calc. Git предупреждает, что ветка еще не объединена с основной веткой и что удалять ее опасно. Но мы уверены, что хотим удалить ветку, поэтому вводим еще одну команду, которую нам подсказывает git: git branch -D calc.

Теперь удалим ветку input. Она уже залита на GitHub, поэтому сначала удалим ее с удаленного репозитория: git push —delete origin input

Проверим Git Hub: ветка удалилась. Теперь удаляем ветку локально: git branch -d input.

Проверим наши ветки: git branch. Ветки удалились, осталась только ветка main.

Если по ходу работы у вас появляются ошибки, попробуйте найти решение в интернете. Часто достаточно скопировать полученную ошибку и вбить ее в поиск в браузере. Если все же не получается найти ответ, пишите нам в чате в Telegram.