新手不要使用终端 vim。

入门建议

之前断断续续的写过一些 vim 的相关文章，和断断续续的使用 vim。 之前一直想着把 vim 当作 IDE 使用。但是繁琐的配置和一些不敬如人意的地方，导致在使用过程中会逐步的放弃。

而最近两个月，我开始使用了 vim。使用 vim 来说，就像打字盲打一样，主要靠肌肉记忆，而不是思考。

不是把 vim 当作 IDE，而是把 IDE 当 vim。 目前，大多数的 IDE 都会有 vim 的相关 keymap 设置，而我目前使用的工具主要是 Vscode 和 Goland。 这两款工具都对 vim 有良好的支持。

Vim 的模式

针对 vim 上手困难，首先的一个困难我觉得来自于它的模式，说实话，从我接触电脑来说，无模式感觉是一种正常的情况。打开 word，可以直接进行编辑，打开 IDE，可以直接进行编码，这种情况对与我来说那就是理所当然，就应该是这样。

而这些对于 vim 来看，有显示的那么反直觉，打开后无从下手，但是当你学会编辑，需要移动的时候，不停的在 normal 和 insert 两个模式换来换去。

这些对于刚刚入手 vim 来说，都将成为放弃的理由。

命令

当你逐渐了解了 vim 的模式之后，剩下的就是 vim 的命令，或者说是快捷键。

首先就是移动，通过 h,j,k,l 四个键来进行光标移动，而不是我们习惯的方向键(虽然方向键也可以移动)，熟练使用这四个键进行光标移动绝对是入门 vim 的重要点，刚刚开始的时候是在强迫自己使用这四个键来进行移动，下意识的练习才能使自己不断的掌握 vim 的基本操作。

除了光标的移动，那么剩下的最重要的功能就是编辑了。在编辑过程中，单单就插入来说就有多个快捷键，例如 i，I，a，A，o，O 等，都可以从 normal 模式转化为 insert 模式，但是每个命令又有细微的差别，例如 a 可以理解为 append ，那么就是在光标都追加单词，而 i 可以记忆为 insert ，表示为光标前添加。

为了熟练的掌握这些命令，在刚刚开始使用的时候，嘴里或者心里都会默念一些 “口诀” 。

例如我修改引号内代码，就念 change inner " 手上对应的 c，i，⇧ '。

但是还有一个问题，你需要知道这些快捷键，你才能在心中默念出相关“口诀”，vim的相关命令比较多，而且同一键在不同的情况下代表的含义是不一样的，比如上述提到的 i，可以是 insert，还可以是 inner。

这些操作都不需要任何的插件，也不需要任何的设置，对于 vim 来说，这些操作都是一致的。

配置

这里我贴出我的 vim 配置。分别是 vscode 和 goland 的。

Vscode

{
    "vim.easymotion": true,
    "vim.incsearch": true,
    "vim.useSystemClipboard": true,
    "vim.useCtrlKeys": true,
    "vim.hlsearch": true,
    "vim.insertModeKeyBindings": [
        {
            "before": [
                "j",
                "j"
            ],
            "after": [
                "<Esc>"
            ]
        }
    ],
    "vim.normalModeKeyBindingsNonRecursive": [
        {
            "before": [
                "<leader>",
                "d"
            ],
            "after": [
                "d",
                "d"
            ]
        },
        {
            "before": [
                "<C-n>"
            ],
            "commands": [
                ":nohl"
            ]
        },
        {
            "before": [
                "K"
            ],
            "commands": [
                "lineBreakInsert"
            ],
            "silent": true
        },
        {
            "before": [
                "leader",
                "="
            ],
            "commands": [
                {
                    "command": "editor.action.formatDocument"
                }
            ]
        },
        {
            "before": [
                "leader",
                "g"
            ],
            "commands": [
                {
                    "command": "go.test.generate.function"
                }
            ]
        }
    ],
    "vim.leader": "<space>",
    "vim.handleKeys": {
        "<C-a>": false,
        "<C-f>": false
    },
    "editor.lineNumbers": "relative"
}

Goland (IDEA)

"" Source your .vimrc
"source ~/.vimrc
let mapleader=" "
"" -- Suggested options --
" Show a few lines of context around the cursor. Note that this makes the
" text scroll if you mouse-click near the start or end of the window.
set scrolloff=5
set so=5
"set ideajoin
"set idearefactormode=keep
"set relativenumber
set nu
set showmode
set relativenumber

set clipboard+=unnamed
set clipboard+=ideaput
set virtualedit=onemore
"set cursorline
set keep-english-in-normal

" Do incremental searching.
set incsearch

" Don't use Ex mode, use Q for formatting.
map Q gq

set surround
set multiple-cursors
set commentary
set argtextobj
" set easymotion
set textobj-entire
set ReplaceWithRegister
set exchange

"" -- Map IDE actions to IdeaVim -- https://jb.gg/abva4t
"" Map \r to the Reformat Code action


"" Map <leader>d to start debug
"map <leader>d <Action>(Debug)

"" Map \b to toggle the breakpoint on the current line
"map \b <Action>(ToggleLineBreakpoint)

" map <leader>f <Plug>(easymotion-s)
" map <leader>e <Plug>(easymotion-f)

nmap <leader>d <Action>(Debug) " Debug 当前方法
map <leader>r <Action>(RenameElement) " 重命名变量
noremap <leader>c <Action>(Stop)
noremap <leader>z <Action>(ToggleDistractionFreeMode) " 禅模式

map <leader>s <Action>(SelectInProjectView)
map <leader>a <Action>(Annotate)
map <leader>h <Action>(Vcs.ShowTabbedFileHistory)
map <S-Space> <Action>(GotoNextError)

map <leader>b <Action>(ToggleLineBreakpoint) " 打断点
map <leader>o <Action>(FileStructurePopup)
" Editor
nmap <leader>= <Action>(ReformatCode)

" Find more examples here: https://jb.gg/share-ideavimrc
" 全局查找
noremap g/ <ESC>:action FindInPath<CR>

noremap / <ESC>:action Find<CR>
noremap <leader>g <ESC>:action Generate<CR>
set ideajoin

这已经是我第 N + 1 次尝试 vim 了。这是之前的 基础教程

个人认为学习 vim 的曲线是比较陡峭的，尤其是刚刚开始的时候，各种指令让人根本记不住。就连熟悉的 Ctrl c/v 大法都不能用了。

这里我安装的是 neovim

命令

后来开始慢慢的尝试，发现要学会 vim 的各种命令，首先要明白各种命令代表着是什么意思。

命令实在太多了，需要慢慢记忆和使用。

插件

任何一款强大的编辑器都离不开插件系统的支持，有插件的支持可以使得任何文本编辑器逐渐媲美IDE。

在vim中安装插件要麻烦一点，毕竟原有的 vim 本身并没有插件系统，需要其他程序来实现。

neovim 在 windows 中的配置文件在 ~/AppData/Local/nvim 中的 init.vim （如果没有该文件自己新建一个即可）。

首先安装插件系统，对于 vim 中的插件系统是很多的。例如 Vundle、NeoBundle、VimPlug等。

我使用的是 vimPlug 。首先要安装 VimPlug 。对于 Vimplug 在windows上的安装只需要一行命令。

iwr -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
    ni "$(@($env:XDG_DATA_HOME, $env:LOCALAPPDATA)[$null -eq $env:XDG_DATA_HOME])/nvim-data/site/autoload/plug.vim" -Force

安装完成需要将下面配置添加到 init.vim 中的插件系统是很多的。例如

call plug#begin('~/AppData/Local/nvim/plugged') 


call plug#end()

插件将在这个块中进行配置。

新增插件后只需要保存后，通过命令 :PlugInstall 命令进行安装即可。

Golang 环境

对 Golang 的支持

vim-go 是一个很好的插件，安装即可完成对 golang 的支持。其中第一次使用的时候需要安装一些配置。通过命令 :GoInstallBinaries 安装必要的包。等待安装完成后就有了基本的对 Golang 的支持了，比如运行代码等。通过 :GoRun 就可以完成代码的运行，但是目前还有问题，下方的输出会看不到多余的输出代码，这个问题还要继续研究研究。

vim-go 还有很多功能，日后逐渐熟悉了再介绍。

自动补全

自从微软提出了 LSP 服务，自动补全变得比较统一。通过安装 coc-nvim 来进行自动补全。我这里主要是 Golang 的自动补全。

需要 nodejs 环境进行自动补全。 Coc 是 vim 的插件，同时 Coc 又有自己的插件（套娃组合）

通过 :CocInstall 进行安装服务。

在完成 Golang 的 LSP 服务后，就可以完成自动补全了。

效果如下所示

有自动补全的提示和文档提示。

工欲善其事，必先利其器

最近重新开始了学习c语言和数据结构的过程，毕竟考研要用，所以 clon 在windows上的表现一直感觉不如在linux上，而且也重量，所以不打算使用 clon,而是打算用微软的vscode+gcc完成。

# 基于命令行运行

首先肯定要下载和安装好 visual studio code 和下载 minGW。这里不在赘述，安装好 minGW 记得配置环境变量。在终端中敲入 gcc -v 查看

然后我们新建一个文件夹并且在文件夹里新建一个 Hello.cpp 文件并且用 vscode 打开，此时 vscode 会提示你安装插件。

此时我们在Hello.cpp中书写我们的代码

#include "stdio.h"

int main(){
    printf("Hello World \n");
    return 0;
}

打开终端，使用 gcc Hello.cpp 进行编译，会形成一个a.exe的文件。然后输入 a.exe 就可以运行

gcc Hello.cpp

a.exe

这样就会编译和运行一个HelloWorld

经过一周的准备，完成了 Git 的一些使用经验及教程。

主要是从命令行的角度来讲解。

Git 是什么

git 在维基百科上的解释是这样的

git是一个分布式版本控制软件，最初由林纳斯·托瓦兹（Linus Torvalds）创作，于2005年以GPL发布。最初目的是为更好地管理Linux内核开发而设计。应注意的是，这与GNU Interactive Tools（一个类似Norton Commander界面的文件管理器）有所不同。

在我看来 Git 是一个 版本控制工具 和 团队协作 软件。

Git 版本控制

简单的使用看这个博客 Git教程操作

这个博客会在这个基础上更加详细的讲解命令行的使用，以及一些操作原理。

git status

当我们通过 git add 命令添加文件到 git 中的时候，可以通过 git status 来了解当前代码库的情况。

通过 git status这个命令我们可以知道当前代码库的状态

git add -?

为什么每次都要使用 git add 把修改文件添加，之后在提交。

这就是 git 的一个原理图。

git 工作时候分为工作区和版本库。工作区就是我们自己本地编辑的区域。而代码库又有一个 暂存区/缓存区。我们每次提交版本(commit) 都是在暂存区向代码库提交。所以我们每次都要通过 add 命令进行对修改的添加。

在给 git 添加文件的时候，我们使用的是 git add <filename>,但是当我们要添加大量的文件的时候，采用 git add 不仅浪费时间，而且还容易出错。此时我们使用 git add -A 会把所更改(包括文件的添加，删除，修改)的文件添加到代码库中。

git add -i 会进入一个命令的子系统，提供我们选择。

git diff

git diff 是一个比较代码的命令，如果不加参数表示本次和上一次的比较。我们可以添加要比较的两个版本的哈希值。

git diff 01df58 6e1baa

Git 协作开发

之前的 Git 是用来用做简单的 版本控制，记录了每一个版本。下面我们进行团队协作开发。

Git 分支

当一个人开发功能 A 而另一个人开发功能 B ，之后代码进行整合的时候，使代码既有功能 A 也有功能 B 。在 Git 中，Git 给了我们分支的概念。

分支可以使用我们快速的开发协作，并且快速的合并。

分支的使用

通过命令 git branch 来查看分支情况，当前分支会前面带 * 标识。git branch <branch name> 来创建分支。 分支创建会拷贝当前的内容到新的分支。通过 git checkout <branch name> 来切换到我们需要切换的分支。

我们也可以通过 git checkout -b <filename> 来创建分支并且切换到该分支。

分支的合并

当我们创建出新的分支的时候，就可以对这个分支进行版本的迭代。当我们做完版本迭代，版本更新的时候，就会向我们的 master 分支上就行合并。

如果我们要向 master 分支上合并我们新创建的分支叫 dev ，那么我们先切换分支到 master，在通过 git merge dev 进行合并两个分支。期间会有合并冲突，通过修改来进行保留。

Git flow

如上图，git flow 是 git 给我们的一个协作的开发流程，master 分支一般是用于上线产品的发布，develop 分支使用开发， 在他的支线上我们一般会创建功能分支。我们在功能分支上开发完成后合并到 develop 分支上。这样就完成了我们的 git flow 开发。

PPT下载

什么是Junit，Junit是用于java代码单元测试的框架。

为什么要用Junit

简单的说，我们在写java代码的时候每次写完一个类，都要写一个public static void main(String args[])的方法来进行方法的调用，写完之后再删除，如果类比较多那么我们所创建的方法也比较多，操作起来比较麻烦。而Junit就是为了解决这种情况，他可以在一个类里面创建多个可运行的方法，来进行测试，这便是我们所使用Junit的原因。

如何使用

我们在我们的项目中使用Junit需要先下载junit.jar包和hamcrest-core.jar并添加Github地址。 这样我们就可以进行使用了。

示例代码

我们创建了一个HelloWorld的类，类里面有sayHello这个方法，我们要对这个方法进行测试。

public class HelloWorld {
    public void sayHello(){
        System.out.println("Hello");
    }
}

我们写一个类进行测试。

public class HelloWorldTest {
    @Test
    public void sayHello() throws Exception {
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.sayHello();
    }
}

我们可以这样对sayHello方法就行测试。

但是，我们创建这个方法要满足一下要求。

1. 方法必须是公用且无返回值(public void)
2. 方法必须可以抛出异常throws Exception
3. 方法必须用@test注解

这样我们就创建好了一个测试方法，并且我们可以在该类下写无数个这个的方法用于不同的测试。

IDEA演示

• 版本IDEA U 2016.3.1

首先我们先写好我们的HelloWorld类 针对我们的sayHello方法进行测试，快捷键ctrl+shift+t 这样我们就可以测试我们的方法了。

一般为了方便，我们会新建一个test文件夹。标记为test目录，这样自动生成的test类就会放到test目录中，不影响我们正常编写的代码。

结果如下

Maven是一个跨平台的项目管理工具，主要用于基于Java平台的项目构建，依赖管理。

maven之前的项目管理一般为 ant。

Maven的作用

Maven的出现时为了解决项目的一些问题：

1. 如果有好几个项目，这好几个项目中，需要用到很多相同的jar包， 能不能只建立一个仓库来解决这个问题？
2. 测试方法能不能全部运行呢？
3. 怎么样把一个模块的功能放入到仓库中

Maven的安装和配置

Maven的安装

Jdk要求

jdk要求1.7+

下载Maven

从Maven官网上下载最新版本的Maven

设定环境变量

将下载好的Maven的bin追加到环境变量path中。

检查Maven是否配置成功

在cmd中运行mvn -v，当出现下面的提示证明配置正确

注意：要用管理员权限运行cmd，否则会报错

建库

Maven的很大作用就是导入jar包,所以我们建立一个仓库来放置项目所用的jar包，在需要的时候进行管理。

路径

Maven的仓库默认路径是C:\Users\UserName\.m2 ,注：UserName为个人电脑名称

Maven的约定

必须按照这个约定放置

Maven项目

知道了Maven的约定，那么我们就可以根据约定来进行创建第一个项目。 在HelloWorld.java文件

package com.young.maven.model;

public class HelloWorld{
  public String sayHello(){
    return "HelloWorld";
  }
}

HelloWorldTest.java文件

package com.young.maven.model;
import org.junit.*;
import org.junit.Assert.*;


public class HelloWorldTest{
  @Test
  public void testHello(){
    Assert.assertEquals("HelloWorld",new HelloWorld().sayHello());
  }
}

pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.young.maven</groupId>
    <artifactId>maven-model</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.10</version>
  </dependency>
</dependencies>
</project>

在根目录下执行命令mvn compile 这样就会编译成功。

Maven构建命令

Maven坐标

<groupId></groupId>
<artifactId></artifactId>
<version></version>

在Mevan中这三个就是基础坐标也是唯一的表示，可以快速定位到任何一个包

仓库

• 本地仓库
• 远程仓库
• 镜像仓库

如果Maven在本地仓库找不到构建，那么就会去Maven的中央仓库去寻找，如果Maven的中央仓库没有，就会报错。因为Maven的远程仓库在国外,常常无法访问或者很慢,这是我们就要使用一些镜像仓库,来帮助我们。 在"~\apache-maven-3.3.9\conf\settings.xml"文件中，找到mirrors,我们可以修改这里进行镜像设置。

Maven中央仓库

中央仓库地址: http://repo.maven.apache.org/

pom.xml

• project是包含了pom的约束信息
• modelVersion指定了当前pom的版本
• groupId当前maven输入那个项目，包名+项目名
• artifactId项目名+模块名 version版本号，第一个0表示大版本号，第二个0表示分支版本号，第三个0表示小版本号。snapshot快照，alpha内部测试版本，beta公测版本，Relese稳定版本，GA正式发布版本。
• packaging打包方式，默认为jar包，可以为war，zip
• name 项目描述
• url项目地址，项目描述
• developers 开发人员信息
• licenses 许可信息
• organization组织信息

<dependencies>
    <dependency>
        <groupId></groupId>
        <artifactId></artifactId>
        <version></version>
        <type></type>
        <scope>依赖范围</scope>
        <!--设置依赖是否可选-->
        <optional></optional>
        <!--排除依赖传递列表-->
        <exclusions>
            <exclusion>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>
<dependencyManagement>
  <dependencies>
  
  </dependencies>
</dependencyManagement>
<build>
  <plugins>
    <groupId></groupId>
    <artifactId></artifactId>
  </plugins>
</build>
<parent></parent>
<modules></modules>

Maven依赖

依赖范围

scope 控制依赖和三种classpath的关系。

三种classpath

1. 编译
2. 测试
3. 运行

scope一共有6个值分别为compile,provided,runtime,test,system,import。

依赖传递

例如MavenB项目依赖MavenA,而MavenC依赖于MavenB，这样的活那么MavenC就会依赖于MavenA。

依赖冲突

A和B依赖不同版本但是相同的构建，就会出现冲突。

处理原则：

• 断路优先 A->B -> C ->X(jar) A->D->X(jar) 会优先解析路径短的。
• 先声明先优先 如果两条路径一样，那么先声明的会先依赖。

Maven创建JavaWeb

• Maven
• IDEA

创建Maven项目,选择webapp 填写好 GroupId和ArtifacetId之后next。 这样我们就完成了一次创建。 因为只为我们创建了resource目录，按照Maven的约定，我们需要创建其他目录。

git下载

安装教程

装完成后，还需要最后一步设置，在命令行输入：

$ git config –global user.name “Your Name” $ git config –global user.email “email@example.com”

因为Git是分布式版本控制系统，所以，每个机器都必须自报家门：你的名字和Email地址。

创建本地仓库

$ git init

添加 add

把文件添加到仓库：

$ git add readme.txt

执行上面的命令，没有任何显示，这就对了，Unix的哲学是“没有消息就是好消息”，说明添加成功。

把文件提交到仓库：

$ git commit -m “add readme”

git commit命令，-m后面输入的是本次提交的说明，可以输入任意内容，当然最好是有意义的，这样你就能从历史记录里方便地找到改动记录。

同步到Github

上传到github

例如我们给一个叫Test的仓库同步

$ git remote add origin git@github.com:youngxhui/Test.git

现在可以push到你的仓库了

$ git push -u origin master

第一次推送时，我们要添加-u

之后我们可以这条命令

$ git push origin master

下载到github

从github上下载到本地

$ git clone git@github.com:youngxhui/nuc_JavaLab.git

分支的操作

分支的创建

创建分支

$ git checkout -b dev

-b 参数表示创建并切换

查看分支

用git branch命令查看当前分支：

   $ git branch
   * dev
   master

git branch命令会列出所有分支，当前分支前面会标一个*号。

我们就可以在dev分支上正常提交

$ git add readme.txt

$ git commit -m “branch test”

切换分支

切换回master分支：

$ git checkout master

合并分支

把dev分支合并到master

$ git merge dev

删除分支

$ git branch -d dev

Android virtual Device（AVD）是Google推出的可以在x86,x64,AMD设备上运行的虚拟机。我们可以在Android Studio中创建并且使用。

在我们一般创建时，都再用默认的设置，这样会导致AVD使用时很卡，卡到爆……

下面我们就来一起设置，使它流畅的运行起来。

下载安装Intel HAXM

1. 打开SDK Manger，在SDK Tools目录下，选择并下载Intel HAXM。

2. 下载好并不代表安装，我们需要打卡SDK目录进行安装。

…\extras\intel\Hardware_Accelerated_Execution_Manager\intelhaxm-android.exe

安装只需要next就好。也可以适当的分配一点大的内存。

3. 重启你的电脑。

添加AVD

我们打开AVD Manager。行创建一个AVD

行创建一个AVD

选择一个你喜欢的机型，我在这里选择6P。

按照你的电脑选择API和ABI

Next->Finish

此时我们就添加好一个虚拟机了。

运行并修改参数

我们点击运行

此时我们需要观察Android Studio的输出日志。其中有一条值得我们注意

这一条警告提示我们VM heap低于最低值384M，要求我们去设置为384M。

此时我们打开编辑，修改VM heap为他所要求的值，我们的AVD就可以流畅的运行了。

基于Android　Studio 2.1，Intel X64 RAM 8G

在上述的几个教程里讲解了一些Github的基础使用，现在开始讲解一些使用技巧。

查找内容

在github页面上是没有搜索的按钮，如何搜索呢。 在网页上按 T 就会出现。 这样我们就能很方便的查找到我们需要的代码了。

评论小表情

常常在版本描述或者pull request时我们需要对伙伴的代码进行一下评论与说明，光是文字有点很死板，其实github给我有emoji，如何使用呢？其实很简单，只需要冒号就可以 ：，这样我们就可以看到emoji表情，当然默认会显示五个常用的，你也可以继续敲下emoji的名字，出现更多（这里有所有的表情）。

忽略不想上传的文件

有些在github中的文件我们是不想上传的，我们如何过滤掉它们呢？ 在github中对不想上传的文件点击右键。就会出现下面选项。

Ignore file忽略这个文件 Ignore all.txt files 忽略所有的以.txt结尾的文件 这样就可以过滤掉你不想上传的文件

搜索项目

如何高效的搜索一个你想要的库呢？ 我们常常评判一个项目的标准有star数目，fork数目和跟新时间。 通过搜索命令

stars

stars:>1000

表示star数目大于1000。

fork

fork:>1000

表示fork数目大于1000。

语言搜索

java，html等等

综合一下就是，比如你要查找一个stars大于1000的，fork大于200的java代码。

stars:>1000 fork:>200 java

就是这样。

查看项目中的语言类型

一个项目中，可能使用了多种语言，我们如何一下子就能看到一个项目使用了什么语言？其实很简单，Github已经为我们统计好了。

也行你注意过，但是没有发现它有什么用。 点击下面的彩条

github已经为我们统计好这个项目所有的语言及其比例。

一些常见的代码表示颜色

总结

码字不易，终于写完了，如果觉得对你有帮助，我的目的就达到了。 谢谢 如有错误，还望指正。

**GitHub Flow**是一个轻量级的，基于分支的工作流程，支持团队和部署在那里的定期做项目。

为团队成员写入权限

在我们的队友添加一个写的权限，这样我们的队友才能很好的修改代码。 我们打开网页上的GitHub,点击settings,

之后我们找到collaborators，这里会让我们验证密码，之后就有添加合作者的选项。这样我们就能添加我们的小伙伴了！

这样我们就添加了新的小伙伴，新的小伙伴有着同样的权限去修改和管理代码。 此时我们就会看到我的小伙伴wevan的github主页上就会出现关于我创建的First的各种通知。

创建分支

在我们创建一个叫add new function的分支。

创建一个分支

Create a branch

当您在进行项目时，在任何给定的时间都会有许多不同的功能或想法在进行中-其中一些已准备就绪，而另一些则没有。存在分支可帮助您管理此工作流程。

When you’re working on a project, you’re going to have a bunch of different features or ideas in progress at any given time – some of which are ready to go, and others which are not. Branching exists to help you manage this workflow.

在项目中创建分支时，正在创建一个环境，您可以在其中尝试新的想法。您在分支机构上所做的更改不会影响主分支，因此您可以自由地进行试验和提交更改，并且可以知道，在准备好与您的协作者进行审核之前，您的分支机构不会被合并，这是安全的。

When you create a branch in your project, you’re creating an environment where you can try out new ideas. Changes you make on a branch don’t affect the master branch, so you’re free to experiment and commit changes, safe in the knowledge that your branch won’t be merged until it’s ready to be reviewed by someone you’re collaborating with.

ProTip

分支在Git中是一个核心概念，整个GitHub的流量是基于它。这里只有一个规则：在任何主分支总是部署。

Branching is a core concept in Git, and the entire GitHub Flow is based upon it. There’s only one rule: anything in the master branch is always deployable.

正因为如此，这是非常重要的一个功能或修复工作时，你的新分支关老爷的创建。您的分支名应该是描述（例如，重构的身份验证，用户的内容缓存键，使视网膜-化身），以便其他人可以看到正在处理。

Because of this, it’s extremely important that your new branch is created off of master when working on a feature or a fix. Your branch name should be descriptive (e.g., refactor-authentication, user-content-cache-key, make-retina-avatars), so that others can see what is being worked on. 来自GitHub Flow

添加提交

我们首先把分支切换到新的分支上add new function

修改新的版本

填写好新的Summary和Description，提交新的版本并同步。 这样小伙伴登陆到GitHub上就看到了就可以清楚的看到一切的修改。

添加提交

Add commits

一旦你的分支已经建立，现在是时候开始进行更改。无论何时添加，编辑或删除一个文件，你作出承诺，并将其添加到您的分支。提交加入这一过程保持你的进步轨迹，你在一个特性分支工作。

Once your branch has been created, it’s time to start making changes. Whenever you add, edit, or delete a file, you’re making a commit, and adding them to your branch. This process of adding commits keeps track of your progress as you work on a feature branch.

还承诺创建工作的透明历史，其他人可以按照理解你做了什么，以及为什么。每次提交都有一个关联的提交信息，这是解释为什么一个特定的变化作出了说明。此外，每次提交被认为是变革的一个独立单元。这使您可以回滚的变化，如果发现错误，或者如果你决定在一个不同的方向前进。

Commits also create a transparent history of your work that others can follow to understand what you’ve done and why. Each commit has an associated commit message, which is a description explaining why a particular change was made. Furthermore, each commit is considered a separate unit of change. This lets you roll back changes if a bug is found, or if you decide to head in a different direction.

ProTip

提交信息是重要的，特别是因为Git跟踪更改，然后将它们显示为承诺一旦他们推到服务器。通过字迹清晰提交信息，你可以更容易为其他人跟着，并提供反馈。

Commit messages are important, especially since Git tracks your changes and then displays them as commits once they’re pushed to the server. By writing clear commit messages, you can make it easier for other people to follow along and provide feedback. 来自GitHub Flow

打开一个pull请求

这个是整个流程中比较关键的一步，发布Pull Request。

点击客户端或者网页上的Pull Request发布。 我们这里点击Pull Request

我们填写好必要的说明性文字 点击Send Pull Request 他既然让我们到GitHub上看，我们就听他的，点击，进入。 我们发现小伙伴已经在下面留言了！

讨论和审核你的代码

你的小伙伴开始对你的代码讨论，修改，迭代。

讨论和审查你的代码

Discuss and review your code

一旦拉入请求已被打开，人或团队审查您的变化可能有疑问或意见。也许编码风格不匹配项目的指导方针，改变缺少单元测试，或者也许一切看起来不错，道具都是为了。引入请求旨在鼓励并捕获这种类型的对话。

Once a Pull Request has been opened, the person or team reviewing your changes may have questions or comments. Perhaps the coding style doesn’t match project guidelines, the change is missing unit tests, or maybe everything looks great and props are in order. Pull Requests are designed to encourage and capture this type of conversation.

您还可以继续推送到你的分支在你提交的讨论和反馈光。如果有人评论说，你忘了做某件事，或者如果在代码中的错误，你可以在你的分支修复它，推高的变化。GitHub上会显示新的提交和其他任何意见，你可能会收到统一拉请求视图。

You can also continue to push to your branch in light of discussion and feedback about your commits. If someone comments that you forgot to do something or if there is a bug in the code, you can fix it in your branch and push up the change. GitHub will show your new commits and any additional feedback you may receive in the unified Pull Request view.

ProTip

拉请求的意见都写在降价，所以你可以插入图片和表情符，使用预先格式化的文本块，等轻质格式。

Pull Request comments are written in Markdown, so you can embed images and emoji, use pre-formatted text blocks, and other lightweight formatting.

部署

部署

Deploy

一旦你拉的请求进行了审查和部门通过你的测试，您可以部署您的更改，以验证他们的生产。如果你的分支造成的问题，您可以通过部署现有的主投产回滚

Once your pull request has been reviewed and the branch passes your tests, you can deploy your changes to verify them in production. If your branch causes issues, you can roll it back by deploying the existing master into production.

合并

合并分支我们之前已经说过，这里就不再赘述。

合并

Merge

现在，您的更改在生产中得到了验证，现在是时候你的代码合并到主分支。

Now that your changes have been verified in production, it is time to merge your code into the master branch.

合并后，引入请求保护的历史变迁到您的代码记录。因为他们是搜索的，他们不让任何人回去的时间理解为什么以及如何决定了。

Once merged, Pull Requests preserve a record of the historical changes to your code. Because they’re searchable, they let anyone go back in time to understand why and how a decision was made.

ProTip

通过将某些关键字到您的拉请求的文本，你可以用代码相关联的问题。当你拉入请求合并，相关问题也将被关闭。例如，输入短语关闭＃32将关闭在仓库中发行数量32。欲了解更多信息，请查看我们的帮助文章。

By incorporating certain keywords into the text of your Pull Request, you can associate issues with code. When your Pull Request is merged, the related issues are also closed. For example, entering the phrase Closes #32 would close issue number 32 in the repository. For more information, check out our help article.

注意：英文翻译为机器翻译，可能有翻译错误的地方，建议大家尽可能看英文

总结

基本的GitHub教程就算写完了，已有如果在有就是一些GitHub上的一些使用小技巧了。