Github for windows как пользоваться

Git Guide

Everything you need to know about Git, from getting started to advanced commands and workflows.

What is Git?

Git is distributed version control software. Version control is a way to save changes over time without overwriting previous versions. Being distributed means that every developer working with a Git repository has a copy of that entire repository — every commit, every branch, every file. If you’re used to working with centralized version control systems, this is a big difference!

Whether or not you’ve worked with version control before, there are a few things you should know before getting started with Git:

• Branches are lightweight and cheap, so it’s OK to have many of them
• Git stores changes in SHA hashes, which work by compressing text files. That makes Git a very good version control system (VCS) for software programming, but not so good for binary files like images or videos.
• Git repositories can be connected, so you can work on one locally on your own machine, and connect it to a shared repository. This way, you can push and pull changes to a repository and easily collaborate with others.

Why Use Git?

Version control is very important — without it, you risk losing your work. With Git, you can make a «commit», or a save point, as often as you’d like. You can also go back to previous commits. This takes the pressure off of you while you’re working. Commit often and commit early, and you’ll never have that gut sinking feeling of overwriting or losing changes.

There are many version control systems out there — but Git has some major advantages.

Speed

Like we mentioned above, Git uses SHA compression, which makes it very fast.

Merge conflicts

Git can handle merge conflicts, which mean that it’s OK for multiple people to work on the same file at the same time. This opens up the world of development in a way that isn’t possible with centralized version control. You have access to the entire project, and if you’re working on a branch, you can do whatever you need to and know that your changes are safe.

Cheap branches

Speaking of branches, Git offers a lot of flexibility and opportunity for collaboration with branches. By using branches, developers can make changes in a safe sandbox.

Instead of only committing code that is 100% sure to succeed, developers can commit code that might still need help. Then, they can push that code to the remote and get fast feedback from integrated tests or peer review.

Without sharing the code through branches, this would never be possible.

Ease of roll back

If you make a mistake, it’s OK! Commits are immutable, meaning they can’t be changed. (Note: You can change history, but it will create new replacement commits instead of editing the existing commits. More on that later!) This means that if you do make a mistake, even on an important branch like main, it’s OK. You can easily revert that change, or roll back the branch pointer to the commit where everything was fine.

The benefits of this can’t be overstated. Not only does it create a safer environment for the project and code, but it fosters a development environment where developers can be braver, trusting that Git has their back.

Getting Started With Git

Depending on your operating system, you may already have Git installed. But, getting started means more than having the software! To get started, it’s important to know the basics of how Git works. You may choose to do the actual work within a terminal, an app like GitHub Desktop, or through GitHub.com. (Note: while you can interact with Git through GitHub.com, your experience may be limited. Many local tools can give you access to the most widely used Git functionalities, though only the terminal will give you access to them all.)

There are many ways to use Git, which doesn’t necessarily make it easier! But, the fundamental Git workflow has a few main steps. You can practice all of these in the Introduction to GitHub course.

Create a branch

The main branch is usually called main. We want to work on another branch, so we can make a pull request and make changes safely. To get started, create a branch off of main. Name it however you’d like — but we recommend naming branches based on the function or feature that will be the focus of this branch. One person may have several branches, and one branch may have several people collaborate on it — branches are for a purpose, not a person. Wherever you currently «are» (wherever HEAD is pointing, or whatever branch you’re currently «checked out» to) will be the parent of the branch you create. That means you can create branches from other branches, tags, or any commit! But, the most typical workflow is to create a branch from main — which represents the most current production code.

Make change (and make a commit)

Once you’ve created a branch, and moved the HEAD pointer to it by «checking out» to that branch, you’re ready to get to work. Make the changes in your repository using your favorite text editor or IDE.

Next, save your changes. You’re ready to start the commit!

To start your commit, you need to let Git know what changes you’d like to include with git add [file].

Once you’ve saved and staged the changes, you’re ready to make the commit with git commit -m "descriptive commit message".

Push your changes to the remote

So far, if you’ve made a commit locally, you’re the only one that can see it. To let others see your work and begin collaboration, you should «push» your changes using git push. If you’re pushing from a branch for the first time that you’ve created locally, you may need to give Git some more information. git push -u origin [branch-name] tells Git to push the current branch, and create a branch on the remote that matches it with the same name — and also, create a relationship with that branch, so that git push will be enough information in the future.

By default, git push only pushes the branch that you’re currently checked out to.

Sometimes, if there has been a new commit on the branch on the remote, you may be blocked from pushing. Don’t worry! Start with a simple git pull to incorporate the changes on the remote into your own local branch, resolve any conflicts or finish the merge from the remote into the local branch, and then try the push again.

Open a pull request

Pushing a branch, or new commits, to a remote repository is enough if a pull request already exists, but if it’s the first time you’re pushing that branch, you should open a new pull request. A pull request is a comparison of two branches — typically main, or the branch that the feature branch was created from, and the feature branch. This way, like branches, pull requests are scoped around a specific function or addition of work, rather than the person making the changes or amount of time the changes will take.

Pull requests are the powerhouse of GitHub. Integrated tests can automatically run on pull requests, giving you immediate feedback on your code. Peers can give detailed code reviews, letting you know if there are changes to make, or if it’s ready to go.

Make sure you start your pull requests off with the right information. Put yourself in the shoes of your teammates, or even of your future self. Include information about what this change relates to, what prompted it, what is already done, what is left to do, and any specific asks for help or reviews. Include links to relevant work or conversations. Pull request templates can help make this process easy by automating the starting content of the body of pull requests.

Collaborate (get feedback from tests or peers, make more commits locally and then push them up and get more feedback)

Once the pull request is open, then the real fun starts. It’s important to recognize that pull requests aren’t meant to be open when work is finished. Pull requests should be open when work is beginning! The earlier you open a pull request, the more visibility the entire team has to the work that you’re doing. When you’re ready for feedback, you can get it by integrating tests or requesting reviews from teammates.

It’s very likely that you will want to make more changes to your work. That’s great! To do that, make more commits on the same branch. Once the new commits are present on the remote, the pull request will update and show the most recent version of your work.

Merge into main

Once you and your team decide that the pull request looks good, you can merge it. By merging, you integrate the feature branch into the other branch (most typically the main branch). Then, main will be updated with your changes, and your pull request will be closed. Don’t forget to delete your branch! You won’t need it anymore. Remember, branches are lightweight and cheap, and you should create a new one when you need it based on the most recent commit on the main branch.

If you choose not to merge the pull request, you can also close pull requests with unmerged changes.

How to Use Git

Learning & Mastering Git Commands

If you’re getting started with Git, a great place to start is the Git Cheat sheet. It’s translated into many languages, open source as a part of the github/training-kit repository, and a great starting place for the fundamentals on the command line.

Some of the most important and most used commands that you’ll find there are:

• git clone [url]: Clone (download) a repository that already exists on GitHub, including all of the files, branches, and commits.
• git status: Always a good idea, this command shows you what branch you’re on, what files are in the working or staging directory, and any other important information.
• git branch: This shows the existing branches in your local repository. You can also use git branch [banch-name] to create a branch from your current location, or git branch --all to see all branches, both the local ones on your machine, and the remote tracking branches stored from the last git pull or git fetch from the remote.
• git checkout [branch-name]: Switches to the specified branch and updates the working directory.
• git add [file]: Snapshots the file in preparation for versioning, adding it to the staging area.
• git commit -m "descriptive message": Records file snapshots permanently in version history.
• git pull: Updates your current local working branch with all new commits from the corresponding remote branch on GitHub. git pull is a combination of git fetch and git merge.
• git push: Uploads all local branch commits to the remote.
• git log: Browse and inspect the evolution of project files.
• git remote -v: Show the associated remote repositories and their stored name, like origin.

Getting Started With GitHub

If you’re wondering where Git ends and GitHub begins, you’re not alone. They are tied closely together to make working with them both a seamless experience. While Git takes care of the underlying version control, GitHub is the collaboration platform built on top of it. GitHub is the place for pull requests, comments, reviews, integrated tests, and so much more. Most developers work locally to develop, and use GitHub for collaboration. That ranges from using GitHub to host the shared remote repository, to working with colleagues and capitalizing on features like protected branches, code review, GitHub Actions, and more.

The best place to practice using Git and GitHub is the Introduction to GitHub course.

If you already know Git and need to sign up for a GitHub account, head over to github.com.

Contribute to this article on GitHub.

Иллюстрация: GitHub / Colowgee для Skillbox Media

83 миллиона пользователей, четыре миллиона организаций и 200 миллионов репозиториев. В Сети много сервисов для размещения исходного кода своих проектов, но говорят чаще всего именно про GitHub. В чём же дело?

Конечно, известный владелец сервиса (Microsoft) и привычка играют свою роль, но главная причина — возможности платформы.

• Что такое GitHub и чем он отличается от Git
• Как понять, нужен ли вам GitHub
• Основные концепции GitHub простыми словами
• Создание репозитория и загрузка файлов
• Просмотр файлов в репозитории
• Поиск и чтение репозиториев
• Создание веток

• Переключение веток и решение конфликтов
• Настройка описания репозитория
• Создание сайта из вашего GitHub-профиля
• Подключение GUI-клиента GitHub Desktop
• Работа с GitHub через CLI
• Настройка GitHub-профиля
• Вместо end()

GitHub — это облачная платформа для хостинга IT-проектов и совместной разработки, под капотом которой находится популярная система контроля версий Git, а также полноценная социальная сеть для разработчиков.

Здесь можно найти кучу open-source-проектов на разных языках и поучаствовать в них, разместить своё портфолио с примерами кода, чтобы приложить ссылку к резюме, подглядывать в открытых проектах интересные архитектурные решения, смотреть, как опытные разработчики пишут код, и скачивать огромное количество полезных в разработке и бесплатных инструментов для разработки. Кстати, некоторые умельцы умудряются собирать в GitHub целые библиотеки — книг и статей, а не программистские либы

И да, если вы недовольны какими-то фичами в любимой открытой программе и она выложена на GitHub, вы всегда можете прийти и поругаться в комментариях к проекту А лучше всего — оформить issue (мы расскажем, что это) и самостоятельно пофиксить проблему на радость всем пользователям. Не забывайте и благодарить авторов классных открытых проектов — донатами и просто тёплыми словами. Им будет очень приятно.

Придя практически в любую IT-компанию, вы столкнётесь с тем, что код где-то хранится — и в подавляющем большинстве случаев этим «где-то» будет именно GitHub. У GitHub есть довольно известный конкурент — GitLab, он тоже основан на Git, но это разные платформы разных компаний, хотя их функциональность очень похожа.

А ещё не стоит путать GitHub и Git. GitHub — лишь одна из реализаций системы контроля версий Git (только взгляните на полный список Git-клиентов с графическим интерфейсом), в которую добавлено много удобных инструментов и возможностей (те же комментарии, issues, гиперссылки, форматированный текст и тому подобное). Помните, GitHub можно использовать и без знания Git (обратное тоже верно).

Ну как, звучит круто? Тогда приступайте к нашему гайду о том, как пользоваться GitHub, чтобы во всём разобраться и вообще понять, нужен ли он вам прямо сейчас.

Безусловно, GitHub нужен не всем. Допустим, вы ещё только учитесь кодить или неспешно делаете небольшой проект для личного пользования — и вас устраивает хранение проекта на локальной машине. Может, сейчас вы просто учите язык, который вам нравится, и на данном этапе не хотите хвататься за всё сразу.

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

И действительно, есть множество других способов хранения исходников: можно создать для них папку в разделе «Мои документы», закидывать их в облако и подписывать версии или даже загружать в «Избранное» в Telegram или «ВКонтакте» (костыльно, да, но вполне реально).

А ещё можно накидывать список изменений в заметках в телефоне/на холодильнике текстом в приватном Telegram-канале. Можно деплоить проект с помощью простого скачивания и распаковки ZIP-архива с файлами вашей программы (особенно если цель — просто показать программу другу или девушке, которой вы пришли «помочь с ноутбуком» ^_^). В конце концов, можно сообщать о багах в вашем любимом фреймворке сообществу анонимов в паблике в VK — возмущаться вместе очень весело.

Все эти способы по-своему хороши, но для работы в IT нужно привыкать к GitHub: это стандарт индустрии.

Интересный факт: недавно появилась российская альтернатива GitHub под названием GitFlic. Команда сервиса заявила, что намерена дать «новый импульс разработке отечественных операционных систем, программ, приложений и серверных решений». Среди цепляющих возможностей — интеграция с Telegram.

Большая часть необходимых возможностей GitHub бесплатна, хотя у платформы есть и платные тарифы — однако с ними можно долго не сталкиваться, потому что бесплатных обычному разработчику хватает с лихвой.

Новичков интерфейс GitHub может сбивать с толку: за годы с момента создания площадка обросла множеством инструментов, но главное остаётся неизменным.

Почти вся терминология наследуется у Git. Основные термины — репозиторий, ветка, коммит, форк. Выбор некоторых из этих названий может показаться не очень интуитивным (даже если вы владеете английским), но так уж сложилось.

Как заливать файлы, создавать репозитории и проводить другие операции, мы рассмотрим в следующем разделе, так что не пугайтесь упоминания разных действий в определениях терминов — всё покажем с картинками

Это просто корневая папка с файлами и вложенными директориями вашей программы — и одновременно её страница на GitHub. Загрузить в репозиторий можно всё что угодно, но предполагается, что вы будете хранить в нём файлы с исходным кодом и какие-нибудь дополнительные материалы — допустим, необходимую для GUI или вёрстки графику (картинки, иконки и тому подобное).

Репозитории могут быть публичными и приватными, в них можно создавать другие папки и отслеживать изменения версий. Управлять своими репозиториями можно прямо через интерфейс сайта, командную строку, десктопное приложение GitHub или различные средства разработки (IDE), поддерживающие интеграцию с сервисом.

В ветки группируются изменения и обновления — допустим, одна главная ветка (по умолчанию создаётся main) и одна beta. Ветки независимы друг от друга, но при желании их можно объединять (merge — слияние) — даже если между ними есть разница в коде.

Внести в содержимое репозитория изменения можно напрямую или создав копию. Само внесение изменений называется «коммит» (от английского commit — совершить), у него есть временная метка и хеш-сумма.

Перенос изменений-коммитов из локального репозитория (на вашем ПК) на удалённый (remote repository, то есть в данном случае на GitHub) называется «пуш» (push) — от английского «толкать» (дословно — «проталкивать» изменения).

Скопировать репозиторий для внесения изменений в копию можно двумя основными способами:

• клонировать (clone) — то есть просто скопировать на локальный компьютер или сервер;
• или форкнуть (от английского fork — развилка) — сделать отдельную копию репозитория (обычно чужого) для продолжения разработки «по другому пути развилки».

Если вы форкнули чужой проект, чтобы предложить автору конкретные улучшения, нужно по готовности «запулить» их в исходный репозиторий — то есть сделав pull request (запрос на изменения).

Это 90% необходимых фактов. Более скучные подробности описаны в документации и разделе обучения GitHub, а также в руководстве по самому Git, ну а мы попробуем применить всё это на практике.

Конечно, самый простой способ пользоваться GitHub — через сайт, поэтому начнём отсюда.

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

Очень кратко повторим выводы из нашего прошлого материала:

• для создания репозитория нужно нажать на + в правом верхнем углу сайта, выбрать пункт New Repository, заполнить название и описание, проставить нужные галочки и щёлкнуть на Create Repository;
• для загрузки файлов нужно зайти в нужный репозиторий, щёлкнуть на Add file и выбрать Upload files.

Но для обучения Тёмной стороне Силы работе с GitHub полезно потренироваться выполнять и другие необходимые в процессе разработки действия: клонирование/форк, объединение веток, просмотр и разрешение конфликтов и другие.

Давайте пошагово пройдём всё это вместе — сначала через сайт, а потом взглянем одним глазком на работу через GUI-клиенты и интерфейс командной строки (CLI).

Согласитесь, что в ряде случаев удобно не скачивать исходники, а просто бегло ознакомиться с ними. Для таких простых операций вовсе не нужен десктопный клиент: все файлы можно быстро открыть в веб-версии (и код, и те же картинки). Просто щёлкните по ним для просмотра!

Хотя сёрфинг по чужим репозиториям — залипательное времяпровождение, в первую очередь это один из способов нахождения полезных инструментов вам в помощь. Над многими функциями, которые вы хотели бы добавить в своё приложение, уже кто-то работал, остаётся только найти GitHub-репозитории таких проектов.

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

Важнее другое — на что обращать внимание. Пройдёмся по некоторым пунктам со скриншота выше.

Во-первых, самое очевидное — это описание на главной странице. Именно в нём находится ответ на ваш главный вопрос — что это и чем может вам помочь.

Если точнее, предусмотрено два описания репозиториев — краткое (один абзац справа вверху) и полное (по центру, под списком файлов).

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

После этого оцените, подходит ли вам частота обновлений, — это можно сделать в разделе Releases (ссылка прямо под кратким описанием). Конечно, это зависит от ситуации: где-то может пригодиться инструмент, который не обновлялся четыре года, но чаще всего нужна хотя бы минимальная поддержка — то есть обновления минимум раз в несколько месяцев.

Важно знать и где посмотреть количество и содержание коммитов — кликабельный счётчик находится над списком файлов справа.

Наконец, стоит взглянуть и на количество отметок, демонстрирующих популярность проекта среди сообщества, — отслеживаний, форков и звёздочек (это в каком-то смысле местные аналоги лайков и репостов).

Ещё чуть ниже справа — одна из самых интересных штук: анализ используемых в репозитории языков программирования. В репозитории со скриншота выше набор выглядит так.

Вообще, неплохо изучать репозитории известных приложений, которыми сами пользуетесь (как на скриншоте выше), и отмечать понравившиеся звёздочками. Это не только интересно — со временем GitHub изучит ваши предпочтения и станет предлагать в блоке Explore то, что вам может понравиться.

Создать новую ветку очень просто:

• Жмём на большую зелёную кнопку New branch.
• Вводим название новой ветки.
• Выбираем исходную ветку для копирования (то есть main, так как пока других и нет).
• Щёлкаем на Create branch.

В данном случае нужно сначала уточнить, что имеется в виду: если необходимо просто зайти в альтернативную ветку, это можно сделать в списке веток репозитория (нужная ссылка есть над списком файлов).

Создадим также альтернативную ветку №2 (sava) и посмотрим, как всё это выглядит в итоге.

Можно говорить и про переключение между ветками в другом смысле — когда изменения из альтернативной ветки сливают с главной веткой. Смотрите: у нас есть файл code.js, но его содержимое немного отличается:

• в ветке main там JS-команда console.log («Дефолтная ветка») и картинка с великим маэстро современности Риком Эстли;
• однако в ветке koshka тот же файл содержит команду console.log («Кошка!»);, а вместо Рика — смешной кот;
• и всё совсем усложняется третьей веткой sava, где консольный вывод вида console.log («Сова!»); и используется картинка с совой (естественно, все перечисленные картинки во всех ветках называются одинаково — pic.jpg).

Получается, между ветками есть конфликт и просто слить любую из альтернативных веток с главной нельзя! Но для этого уже есть решение: GitHub предлагает нам сравнить конфликтующие ветки, и если мы захотим, то и запулить изменения в основную — то есть сделать тот самый pull request, о котором говорилось выше.

Вот как выглядит сравнение веток (c koshka и sava соответственно).

Допустим, мы решаем принять изменения из ветки sava и создаём pull request с небольшим комментарием.

Дальше он появляется в списке пул-реквестов репозитория, где мы определяем дальнейшую судьбу данного запроса на изменения.

Пул-реквест можно окончательно принять, подтвердив слияние (merge) веток, или отклонить, закрыв запрос (Close pull request).

При этом главную ветку main можно защитить от изменений, включив соответствующие опции в настройках репозитория (что вам и будет предложено при создании новых веток).

Чтобы поменять данный ряд параметров, зайдите в своём репозитории в раздел Settings -> Branches. Нужные настройки — в подразделе Branch protection rules (целых 10 галочек на выбор).

Основное описание вашего GitHub-проекта задаётся в файле Readme.md, который можно создать вместе с репозиторием или после. Расширение md — это просто сокращение от названия популярного языка упрощённой разметки контента — Markdown.

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

Чтобы оформить Readme со вкусом, можно воспользоваться руководством GitHub по markdown-разметке. Вот как будет выглядеть Readme нашего репозитория-примера после прокачки (первый и второй экран соответственно).

Обратите внимание: в оформлении можно использовать всё что угодно — заголовки разных уровней, выделение жирным/курсивом, изображения, эмодзи, ссылки и так далее.

Файл Readme может быть довольно длинным, но всё же для оформления большой документации GitHub рекомендует создать «Вики».

Захостить сайт на GitHub можно с помощью функции GitHub Pages. Это очень просто:

• Зайдите в настройки репозитория.
• В блоке Code and automation выберите Pages.
• Выберите источник (Deploy from a branch, затем нужную ветку).
• Кликните на Save.
• Обновите страницу, и вверху страницы появится ссылка на ваш новый сайт.

В случае создания сайта для продвижения себя, а не проекта, просто создайте репозиторий с кодом сайта-визитки и дайте ему имя вида [username].github.io, где username — название вашего аккаунта на GitHub. Более подробно про эту функцию — тут.

Если вам удобнее такой способ работы, здесь всё тоже просто. Опять же, повторим кратко выводы из нашего более подробного гайда на эту тему:

• Скачиваем и устанавливаем сам клиент.
• Авторизуемся в своей учётной записи.
• Работаем с существующими репозиториями или создаём новые (локальные).

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

Клонированные из удалённого GitHub-репозитория файлы хранятся в специальной папке на вашем компьютере, и в них легко вносить изменения — клиент будет открывать их в выбранном вами редакторе кода / среде разработки (хотя удобнее всё по отдельности — выбрав нужный файл-исходник в папке).

В общем, всё просто, как раз-два-три.

Работать с GitHub можно и через командную строку Windows или PowerShell. Это не очень сложно: для начала интерфейс командной строки также нужно скачать и установить (документация — здесь).

Команды для GitHub CLI начинаются с сокращения gh — к примеру gh repo clone.

Есть и другой вариант — использовать собственно Git и работать через его собственный CLI. Git скачивается и устанавливается отдельно, там есть минималистичный GUI, но его уже логичнее использовать в терминале.

Главное, что нужно про это знать: все команды Git начинаются соответственно — со слова git, после чего указывается тип действия: git clone, git merge, git fork и прочее. Чтобы воспользоваться ими, установите Git, распечатайте себе любую памятку по его командам и смело начинайте ими пользоваться.

Кастомизация профиля — важная часть самопрезентации разработчика: резюме, визитная карточка и витрина проектов, над которыми вы работали.

Эту информацию оценивают работодатели, поэтому стоит заполнить информацию о себе и сделать публичными несколько ваших лучших репозиториев (конечно, если там ничего секретного :)) — именно они будут частью вашей персональной витрины.

Посмотрим на профиль какого-нибудь крутого разработчика из тех, кто сейчас в тренде GitHub (да-да, есть и такой раздел).

На первом месте — некий Стивен Селис. А что в его профиле? Указано место работы, есть сайты и контакты, а в статистике — 123 репозитория и 1725 изменений в репозиториях за год (круглый год). То есть невооружённым глазом видно, что человек как минимум активный и опытный.

Даже если вы пока ещё не в топе GitHub, нужно стремиться к подобному наполнению профиля: подробная информация + показательный ряд проектов (вы можете закреплять их по-своему, нажав в собственном профиле на Customize your pins).

Всё не так сложно, как может показаться (говоря иносказательно, каждый разработчик в своей жизни сначала учится есть вилкой, а потом — форкать GitHub-репозитории).

GitHub пользуются все: это один из важных общих навыков вне зависимости от выбранного вами языка программирования и направления разработки. И, как и школьные уроки ОБЖ, тот же git clone когда-нибудь вас спасёт.

Поэтому важно начинать пользоваться GitHub как можно раньше — хотя бы даже для бэкапов учебного кода, и уже скоро это станет полезной привычкой.

Жизнь можно сделать лучше!
Освойте востребованную профессию, зарабатывайте больше и получайте от работы удовольствие. А мы поможем с трудоустройством и важными для работодателей навыками.
Посмотреть курсы

Время на прочтение
6 мин

Количество просмотров 79K

Если ваш проект хранится только у вас на диске, то с поломкой диска вас ожидают неприятности. Даже регулярный бэкап не всегда сможет вас спасти.

Некоторые разработчики могут наворотить в проекте столько всего, что сами в шоке. А вспомнить, что и где делалось, затруднительно. Та еще неприятность.

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

Если вы вдруг не знакомы, то я хочу немного познакомить вас с системой управления версиями по имени Git. Под катом вас ожидает описание того, как использовать GitHub вместе с Visual Studio.

Актуальное расширение называется GitHub Extension for Visual Studio. Оно подходит для Visual Studio 2015 и выше. Скачать vsix можно с github странички или с Visual Studio gallery.

Установить расширение можно и при установке Visual Studio:

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

Push – отправка изменений из локального репозитория в удаленный репозиторий (в нашем случае он будет расположен на GitHub).

Fetch – получение изменений из удаленного репозитория для сравнения и возможного последующего слияния.

Merge – слияние. Применение изменений совершенных в другом репозитории текущим репозиторием. Что-то вроде объединения двух репозиториев.

Pull – комбинация fetching и merging. Сперва из удаленного репозитория получается список изменений, а затем изменения применяются к текущему репозиторию.

То есть, если кто-то кроме вас поработал и совершил изменения в репозитории GitHub, то вы можете последовательно совершить 2 действия: Fetch, а затем Merge. Или же вы можете сразу выполнить Pull. После этого в вашем локальном репозитории отобразятся совершенные изменения.

После установки GitHub Extension for Visual Studio, панель Team Explorer будет выглядеть так:

Если панель Team Explorer скрыта, то отобразить ее можно через меню «View» / «Вид». Подключившись к GitHub (нажав Connect… и введя логин с паролем) получим возможность склонировать репозиторий GitHub или создать новый (кнопочки Clone и Create):

При клонировании будут выведен список репозиториев к которым у вас есть доступ:

При создании репозитория, вы сможете ввести его название, описание и выбрать лицензию, в соответствии с которой разрешено использование кода:

В данном случае Git ignore содержит предустановки для проектов различного типа. А так этот файлик формата .gitignore предназначен для того, чтобы указать в нем какие директории и файлы требуется исключить из системы управления версиями.

На случай, если вы хотите очень хорошо спрятать от посторонних глаз

котлету

репозиторий, то вы можете пометить его как Private. Но для этого нужна платная подписка.

Для студентов GitHub предлагает специальное предложение — Student Developer Pack, которое в частности включает в себя бесплатное неограниченное количество приватных репозиториев.

После создания репозитория необходимо создать проект. Лично я предпочитаю наоборот, сначала создать проект и только затем его добавить в Git. Можно при создании проекта создать и репозиторий Git. Для этого достаточно поставить галочку.

Если эту галочку при создании проекта не поставить, а просто открыть проект в VS, то в меню Файл станет доступен пункт «Add to Source Control» / «Добавить в систему управления версиями»

После его нажатия, проект будет добавлен в систему управления версиями Git, и внутри папки с проектом будет создана локальная папка .git. В Team Explorer это будет выглядеть так:

Переключившись между Team Explorer и Solution Explorer можем совершить какие-то изменения в проекте. После любых изменений можно совершить коммит — своеобразную точку восстановления. Для этого вернемся в Team Explorer, в меню которого имеется кнопка с нарисованным на ней домиком. Нажатие на нее приведет вас в главное меню:

Кнопка «Changes» / «Изменения» позволит зафиксировать изменения (при этом обязательно необходимо указать комментарий с описанием изменений). Но все действия пока что будут совершены только с локальным репозиторием git.

При создании проекта иногда создается так называемый «Initial commit», в котором пишется что-то вроде «Проект был создан за три дня». Если вы только что создали проект, то изменений в нем пока что еще нет. А если изменений нет, то коммит создать не получится. Я добавлял строку с текстом, поэтому в комментарии постарался описать это коротко, но понятно:

Можно просмотреть совершенные изменения. Для этого на интересующем нас файле нужно вызвать контекстное меню и выбрать «Compare with Unmodified…» / «Сравнить с неизмененной…»

Получим примерно такое вот сравнение:

В данном случае было добавлено всего 2 строки кода. Через то же самое контекстное меню все изменения, произошедшие со времени последнего коммита можно отменить. Очень удобная фича.

Теперь, давайте, опять перейдем в главное меню, нажав домик. Для того чтобы отправить изменения на GitHub необходимо нажать кнопку «Sync» / «Синхронизация».

Так как наш проект еще не был опубликован на GitHub, то нам предложат это сделать:

Кстати, .git вполне можно опубликовать не только на GitHub, но и на Visual Studio Team Services.

Если мы публиковали проект ранее, то в списке исходящих фиксаций будет расположен наш коммит:

Нажатие Push приведет к отправке изменений в репозиторий, расположенный на сервере GitHub.

Совершив для пробы некоторые изменения прямо через браузер в репозитории, расположенном на GitHub (да, так тоже можно), я снова зашел в синхронизацию и нажал Fetch:

Здесь двойным кликом можно открыть информацию о коммите:

И кликнув уже на файл просмотреть изменения:

В том же самом окне синхронизации можно просмотреть историю:

Историю можно просматривать в простом представлении и в подробном:

Теперь, давайте представим, что мы работаем в команде и кто-то другой уже совершил какие-то изменения в своем локальном репозитории и отправил из в GitHub. И вы тоже совершили изменения в том же самом файле и в той же самой строке. В таком случае при синхронизации с GitHub у вас возникнет конфликт:

Кликнув на Conflicts получим такое вот окошко в котором после клика на файле откроется меню с кнопкой Merge:

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

После внесения изменения нужно нажать Accept Merge (в верхнем левом углу), после чего сделать коммит:

Страничка самого расширения на GitHub: github.com/github/visualstudio

Github Desktop и PowerShell environment for Git

Github Desktop — утилита совершенно независимая и с Visual Studio никак не связанная. Скачать можно здесь.

Утилита доступна для пользователей Mac и Windows. Вместе с ней устанавливается и командная строка Git Shell. Фактически это PowerShell с набором скриптов для интеграции с Git. Называется PowerShell environment for Git. Сокращенно posh-git.

На GitHub страничке проекта posh-git можно найти краткую инструкцию о том, как установить командную строку posh для git вручную.

Интерфейс самой утилиты и работу с ней я рассматривать не буду. Думаю, что он не сложный и с ним вы сможете разобраться сами. Давайте лучше немного поиграем с командной строкой. В отличие от GUI командная строка, как правило, предоставляет гораздо больше возможностей. Но мы рассмотрим только основные команды.

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

git config –list

Для того чтобы склонировать репозиторий достаточно выполнить команду git clone. Например:

git clone https://github.com/programmersommer/Barcode_Scanner_UWP.git BarcodeScanner

После выполнения этой команды, в текущей директории появится папка с проектом. Кроме http:// и https:// поддерживаются и протоколы SSH и git://. Если перейти в папку с проектом с помощью команды cd (в случае примера cd BarcodeScanner), то командная строка преобразится:

Строка статуса PowerShell отобразит текст posh~git, что обозначает, что вы попали в среду PowerShell для Git. Можно выполнить команду git status, чтобы узнать, не требуется ли синхронизировать локальный репозиторий. Ответ может быть таким:

Самые популярные команды это те, которые мы уже рассматривали в рамках интерфейса расширения VS: git fetch, git merge, git push. Если вы зайдете в директорию (наименование PortableGit_xxx директории, я так полагаю, может быть несколько иным):

C:\Users\{user_name}\AppData\Local\GitHub\PortableGit_284a859b0e6deba86edc624fef1e4db2aa8241a9\usr\bin

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

Например, если в директории проекта появится новый файл, то команда git status выдаст:

А значит добавить файл нужно командой git add index.html. Теперь изменения нужно подтвердить с помощью git commit. Эта команда откроет текстовый редактор, который установлен по умолчанию. В нем необходимо в первую строку ввести текст, описывающий совершенные изменения. Если начать строку с символа #, то это будет комментарий. Комментарии можно оставить в строках ниже. Если не оставить никакого текста с описанием коммита, то коммит не произойдет. Можно указать текст коммита сразу в коммандной строке с помощью параметра –m. Например: git commit –m «File index.html added»

Теперь можно с помощью git push отправить изменения в GitHub репозиторий. Если это ваш репозиторий. Чужой репозиторий вы можете скопировать к себе, создав развилку/копию репозитория — Fork. Сделав какие-то изменения, вы сможете предложить их автору оригинального репозитория создав pull request.

На этом позвольте завершить описание возможностей работы с GitHub для пользователей Windows. Если хотите продолжить изучение, то на MVA вы можете посмотреть курс GitHub for Windows Users

Что такое Git, регистрируемся на GitHub, для чего нужен GitHub Desktop, установим и рассмотрим его базовое использование

Так как эти темы довольно обширные, в статье рассмотрим их обзорно, с минимально необходимой информацией, для общего понимания и базовой работы с GitHub Desktop.

Что такое Git

Определение из Wikipedia

Git (произносится «гит») — распределённая система управления версиями.

Система управления версиями — определение из Wikipedia

Система управления версиями (от англ. Version Control System, VCS или Revision Control System) — программное обеспечение для облегчения работы с изменяющейся информацией. Система управления версиями позволяет хранить несколько версий одного и того же документа, при необходимости возвращаться к более ранним версиям, определять, кто и когда сделал то или иное изменение, и многое другое.

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

При использовании системы Git мы запоминаем версии кода на нужных нам этапах. Имеем доступ к ранним версиям. Можем смотреть изменения, которые были сделаны между версиями. Можем отменить изменения до любой из версий.

В статье часто будем использовать термин Git, чтобы проще было понять, представим, что Git это условная “записная книжка”, в которую будем записывать, какие изменения происходят в нашем проекте. Добавили файл — записываем, что файл добавлен. Изменили файл — записываем изменения, которые были сделаны в файле. Удалили файл — записываем что файл был удален. И все эти записи храняться в “записной книжке” Git

Технически Git для проекта — это скрытая папка .git в папке вашего проекта. Скрытая папка .git содержит служебные файлы, которые нельзя изменять и удалять

У Git много возможностей, но на данный момент рассматриваем только базовые

---

Информация из Wikipedia

GitHub — крупнейший веб-сервис для хостинга IT-проектов и их совместной разработки.

Введем еще один термин, который также будет часто встречаться в статье и в работе с GitHub Desktop — репозиторий.

Репозиторий — определение из Wikipedia

Репозито́рий (англ. repository), хранилище — место, где хранятся и поддерживаются какие-либо данные. Чаще всего данные в репозитории хранятся в виде файлов, доступных для дальнейшего распространения по сети.

Если говорить совсем просто, то репозиторий — это наш проект (папка с файлами и системой Git)

Репозиторий может храниться локально на компьютере или чаще всего на таких веб-сервисах, как GitHub

---

Для чего нужен Github Desktop

Работа с Git подразумевает работу через командную строку, но компания GitHub выпустила приложение, которое сильно упрощает использование Git

Для работы с GitHub Desktop, необходимо зарегистрироваться на GitHub

---

Регистрация на GitHub

Переходим на официальный сайт GitHub

На главной странице заполняем форму справа и нажимаем “Sign up for GitHub”

Проходим проверку и нажимаем “Join a free plan”

На следующей странице можно заполнить небольшую анкету (можно не заполнять)

На этой же странице спускаемся в самый низ и нажимаем “Complete setup”

Далее для завершения регистрации просят подтвердить свой email адрес.

Проверяем свою почту. Если письмо пришло, переходим к следующему пункту.

Если письмо не пришло, нажимаем “Resend verification email”.

Если по-прежнему письмо не приходит, можно проверить и изменить настройки — нажимаем “Change your email settings”

В письме от Github нажимаем “Verify email address”

Аккаунт GitHub успешно создан

---

Установка GitHub Desktop

Переходим на официальный сайт GitHub Desktop

Нажимаем “Download for Windows (64bit)” (операционная система может отличаться)

Запускаем скачанный файл. После установки в появившемся окне нажимаем “Sign in to GitHub.com”

В открывшемся окне браузера вводим в форму свои данные, как при регистрации, и нажимаем “Sign in”

Если браузер запросит, то подтвердить, что нужно “Открыть приложение GitHub Desktop”

Далее регистрационные данные перенесутся в форму конфигурации (настроек) Git — нажимаем “Continue”

Отключаем пункт “Yes, submit periodic usage stats”, если не хотите периодически передавать статистику работы GitHub Desktop и нажимаем “Finish”

Далее видим начальное окно GitHub Desktop

“Create a tutorial repository…“ — создать обучающий репозиторий

“Clone repository from the Internet…“ — клонировать (скопировать/скачать) репозиторий из GitHub к себе на компьютер

“Create a New Repository on your hard drive…“ — создать новый репозиторий на вашем жестком диске (на вашем компьютере) и добавить систему Git в проект

“Add an Existing Repository from your hard drive…“ — добавить на GitHub репозиторий, который уже есть на вашем компьютере и использует Git

Справа будут отображаться ваши репозитории, которые уже загружены на GitHub, но если только что зарегистрировались, то список будет пуст.

---

Создаём новый репозиторий

Создаём у себя на компьютере (например, на диске C:) папку projects, где локально будут храниться все наши репозитории.

Переходим в Github Desktop, нажимаем на начальном экране “Create a New Repository on your hard drive…“ или File > New Repository

В открывшемся окне в поле Name пишем название репозитория. В поле Description — описание репозитория, если необходимо. В Local Path выбираем созданную на диске C: папку projects, остальное оставляем по-умолчанию и нажимаем “Create repository”

В папке projects появился репозиторий Project-1

В репозитории Project-1 на данный момент находятся только необходимые служебные файлы Git.

На данный момент репозиторий расположен только локально на компьютере в папке Project-1. Чтобы репозиторий появился в аккаунте GitHub и хранился там, нажимаем “Publish repository”

В появившемся окне оставляем все по-умолчанию. Пункт “Keep this code private” оставляем отмеченным, чтобы репозиторий, пока что, был виден только нам, потом в любой момент репозиторий можно будет сделать открытым, чтобы его видели другие пользователи GitHub. Нажимаем “Publish repository”

Теперь репозиторий скопирован в аккаунт GitHub. Переходим в браузере на GitHub. Сверху справа нажимаем на круглую иконку аккаунта и выбираем пункт “Your repositories”

На странице наших репозиториев появился созданный репозиторий Project-1

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

Создадим на компьютере в папке Project-1 файл index.html и напишем в нем минимальную разметку.

На данный момент файл index.html расположен только локально в папке Project-1. Локальная система Git, которая была создана вместе с репозиторием, об этом файле ничего не знает.

Чтобы Git узнала, что в репозиторий добавился файл, необходимо сообщить это через команду Commit.

Commit — фиксирование текущего состояния файлов, звучит как коммит.

Коммитам необходимо давать названия.

Откроем Github Desktop. Во вкладке Changes видим созданный index.html.

Вводим в поле ниже название коммита — add index.html. Затем нажимаем “Commit to main”, чтобы зафиксировать данное состояние файлов в локальную систему Git. (На данный момент не будем углубляться в ветвление Git)

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

Далее, чтобы передать изменения в репозиторий на GitHub, нажимаем “Push origin”

Переходим в наш репозиторий на GitHub и убеждаемся, что файл index.html был добавлен

Далее внесем изменения в файл index.html — добавим заголовок <h1>Project-1</h1>

Переходим в GitHub Desktop, видим что index.html был изменен, вводим название нового коммита — add h1 и нажимаем “Commit to main”

И снова передаем изменения в репозиторий на GitHub — нажимаем “Push origin”

Видим, что index.html был изменен при коммите add h1

Нажав на название файла index.html, убеждаемся что заголовок добавлен

На данный момент умеем создать репозиторий, делать коммиты, и передавать на GitHub

Далее рассмотрим работу с GitHub Desktop с нескольких рабочих мест

Клонирование репозитория

Предположим, мы работаем с проектом дома на компьютере и в офисе на ноутбуке. Чтобы на ноутбуке у нас была актуальная версия проекта, мы должны получить ее из репозитория на GitHub — это действие называется “клонирование”.

Создадим теперь на ноутбуке папку для репозиториев, например notebook projects

Устанавливаем на ноутбук GitHub Desktop, заходим под своим аккаунтом. Нажимаем File > Clone Repository

В списке выбираем необходимый репозиторий

В пункте Local path, нажимаем кнопку “Choose…“ и выбираем созданную папку notebook projects. Далее нажимаем “Clone…“

Репозиторий клонирован (скопирован) в папку Project-1.

Если в GitHub Desktop посмотреть вкладку History, то увидим всю историю коммитов

Внесем изменения в index.html на ноутбуке, добавим <p>Add text from Notebook</p> и сделаем коммит c названием add text from notebook, далее нажимаем “Commit to main”

Отправим коммит в репозиторий на GitHub — нажимаем “Push origin”

Коммит виден в репозитории на GitHub

В index.html добавлен <p>Add text from Notebook</p>

Теперь возвращаемся из офиса домой, открываем GitHub Desktop на компьютере, и чтобы получить изменения, сделанные на ноутбуке, нажимаем “Fetch origin” — проверяем, есть ли отличия локального репозитория на компьютере и репозитория на GitHub

Отличия есть, поэтому далее нажимаем “Pull origin”

И получаем актуальный проект со всеми изменениями

---

Преимущества

Мы рассмотрели только базовое использование Git, GitHub, GitHub Desktop, но уже можем выделить достаточно много преимуществ (на самом деле их намного больше, как и возможностей)

1. Возможность фиксировать состояния проекта на необходимых этапах, и иметь доступ к ранним версиям
2. Умение пользоваться Git очень часто встречается в вакансиях — будет вашим преимуществом
3. На любом устройстве, в любой момент можете получить доступ до актуального проекта
4. Возможность делиться своим проектом с другими пользователями GitHub
5. Иметь проекты на GitHub большой плюс при поиске работы
6. Возможность пользоваться всеми преимуществами Git без командной строки

---

Итоги

Возможно, на первый взгляд, покажется сложным, но после небольшой практики, вся базовая работа с GitHub Desktop на начальном этапе сойдется к тому, что вы поработали с проектом на работе > сделали коммит (“Commit to main”) > отправили на GitHub (“Push origin”). Пришли домой > получили изменения из GitHub (“Pull origin”) и продолжаете работу дома.

1. “Commit to main”
2. “Push origin”
3. “Pull origin”

Возможно, через некоторое время напишу статью про другие возможности GitHub Desktop

Больше информации на официальном сайте GitHub Desktop

Самая короткая инструкция о том, как сохранить файлы в GitHub и ничего не сломать. И самое главное — никакой консоли, всё через окошки и с помощью мышки. Для этого используем GitHub Desktop.

Внимание! GitHub Desktop не работает на Windows 7×32, поэтому если у вас эта версия системы, обновитесь до Windows 10 или воспользуйтесь программой GitKraken.

В этой статье идёт рассказ о системах контроля версий. Если вы совсем ничего о них не знаете, прочитайте статьи «Словарь терминов для Git и GitHub» и «Введение в системы контроля версий», чтобы понять терминологию и разобраться, зачем мы вообще это делаем.

Регистрация и вход

После первого входа в GitHub Desktop вас попросят ввести ваши логин и пароль от GitHub.com. После этого у вас появится доступ ко всем репозиториям, сохранённым в профиле.

Создание репозитория

Если вы никогда не пользовались гитхабом, нужно будет создать репозиторий для работы над проектом. На главном экране GitHub Desktop выберите пункт «Create a New Repository on your hard drive».

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

После этого нажимаем на Create repository, ждём несколько секунд и готово — на компьютере появилась папка, которой можно пользоваться для разработки вашего проекта.

Клонирование репозитория

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

Выбираем Add -> Clone Repository…

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

После этого файлы репозитория начнут скачиваться — если их много, то это займет некоторое время.

Работа с репозиторием. Меняем файлы и сохраняем обратно

Вне зависимости от того, создали вы репозиторий или клонировали его, так выглядит GitHub Desktop с открытым репозиторием, в котором мы пока ничего не меняли.

Слева — поле для измененных файлов, справа — служебная информация. Слева снизу — поле для коммитов.

Если не усложнять, то склонированный репозиторий это просто каталог на компьютере. Можно нажать Show in Finder на Mac или Show in Explorer в Windows и откроется папка, где лежат все файлы, которые есть в репозитории.

Давайте добавим какой-нибудь файл. Например, я добавил в локальный репозиторий (скопировал в папку) файл index.html, который взял отсюда. Вы можете загрузить файл с кодом вашего проекта или изменить уже существующий.

Сразу после добавления или изменения файла в окне GitHub Desktop будет видно, что изменилось — если мы добавили целый новый файл, то все строчки будут с плюсиками и зелёные. Это значит, что они были добавлены в файл и GitHub Desktop раньше их никогда не видел.

Загружаем новый репозиторий на GitHub

Если вы не создавали новый репозиторий, а склонировали старый, то можете пропустить этот пункт.

После того, как мы добавили какой-то код в свежесозданный репозиторий, нужно сделать коммит, то есть зафиксировать все сохранённые изменения и дать им название. Текст должен быть лаконичным и в то же время сообщать о том, что делает коммит. Например, «добавляет имя наставника в Readme», «вводит функцию сортировки изображений», «правит ошибку в поиске городов на карте». Вводим имя жмём большую синюю кнопку «Commit to main»

Изменения, которые мы внесли и сохранили, пока локальны. Их нужно послать на GitHub. Чтобы опубликовать свежесозданный репозиторий на GitHub, нажмите Publish repository.

Появится подтверждение о публикации репозитория — проверяем название и описание, если нужно, ставим галочку о том, что код приватный, и публикуем.

Готово — после этого репозиторий появится в вашем профиле на GitHub. com.

Добавляем код и коммитим изменения

Репозиторий создан и загружен на GitHub, теперь нужно добавить немного кода.

Когда вы допишете код в файлы, которые находятся в репозитории, вы сможете просмотреть все их изменения в окне GitHub Desktop. Вот здесь, например, мы изменили «второй» на «третий» в тексте страницы — и изменения сразу видны, можно проверить, что всё исправленное будет загружено.

Дальше действуем по проверенной схеме — коммитим изменения.

В центре главного экрана появится предложение запушить коммит в удалённый репозиторий. Соглашаемся и жмём Push origin.

Готово! Теперь, если зайти на GitHub.com, в наш репозиторий, увидим изменённый файл, который мы только что отправили.

Всё получилось — теперь вы можете создать или склонировать репозиторий, добавить туда файлы, опубликовать всё это на GitHub.com, не прикасаясь к консоли.

Мы поработали только с основной веткой репозитория. Если вы хотите разобраться, как создавать новые ветки и добавлять их в основную ветку, прочитайте статью «Работа с git через консоль».

---

«Доктайп» — журнал о фронтенде. Читайте, слушайте и учитесь с нами.

ТелеграмПодкастБесплатные учебники