正如您已经在问题中描述的那样，这三个都是非常相似的概念，在很多情况下很难决定，这取决于您的偏好。

但我可以概述一下这些差异：

[拦截器](https://docs.nestjs.com/interceptors)
======

拦截器可以在调用路由处理程序之前_和_之后访问响应/请求。

### 登记

* `@UseInterceptors()`直接在具有控制器或方法范围的控制器类中
* 全球范围 `app.useGlobalInterceptors()`内 `main.ts`

### 例子

* LoggingInterceptor：在路由处理程序之前请求，在其结果之后请求。测量需要的时间。
* ResultMapping：转换 `null`为 `[]`或将结果包装在响应对象中：`users`\->`{users: users}`

### 结论

与中间件相比，我喜欢注册更接近路由处理程序。但存在一些限制，例如，当您在路由处理程序中发送 `response`特定于库的对象时，您无法设置响应代码或使用拦截器更改响应，请参阅[文档](https://docs.nestjs.com/controllers#appendix-library-specific-approach)。`@Res()`[](https://docs.nestjs.com/controllers#appendix-library-specific-approach)

[中间件](https://docs.nestjs.com/middleware)
======

仅在调用路由处理程序之前调用中间件。您可以访问响应对象，但没有路由处理程序的结果。它们基本上是表达中间件功能。

### 登记

* 在模块中，选择相关路由的方式非常灵活（使用通配符，按方法，...）
* 全球范围 `app.use()`内 `main.ts`

### 例子

* FrontendMiddleware：将除 API 之外的所有路由重定向到 `index.html`，请参阅[此线程](https://stackoverflow.com/a/54840961/4694994)
* 您可以使用任何现有的快速中间件。有_很多_图书馆，例如[`body-parser`](https://github.com/expressjs/body-parser)或[`morgan`](https://github.com/expressjs/morgan)

### 结论

中间件的注册非常灵活，例如：适用于除一个之外的所有路由等。但由于它们是在模块中注册的，因此当您查看其方法时，您可能没有意识到它适用于您的控制器。您还可以利用现有的所有快速中间件库，这也很棒。

[异常过滤器](https://docs.nestjs.com/exception-filters)
==========

异常过滤器在路由处理程序和拦截器之后调用。它们是响应发出之前最后进行更改的地方。

### 登记

* `@UseFilters()`直接在具有控制器或方法范围的控制器类中
* 全球范围 `app.useGlobalFilters()`内您的 `main.ts`

### 例子

* UnauthorizedFilter：映射到用户易于理解的消息
* NotFoundFilter：将所有未找到的路由（不属于您的 api 的一部分）映射到您的 `index.html`.

### 结论

异常过滤器的基本用例是提供可理解的错误消息（隐藏技术细节）。但还有其他创造性的使用方式：当您提供单页面应用程序时，通常所有路由都应重定向到 `index.html`除 API 路由之外的路由。在这里，您可以重定向到 `NotFoundException`. 有些人可能会觉得这个很聪明，而另一些人可能觉得很老套。你的选择。;-)

---

所以执行顺序是：

中间件 -> 拦截器 -> 路由处理程序 -> 拦截器 -> 异常过滤器（如果抛出异常）

对于这三个工具，您可以在其构造函数中注入其他依赖项（如服务等）。

对于我们这些在视觉上更好地“理解”的人，我根据最新`v6.10`版本创建了这个 NestJs 管道图。如有不准确之处，敬请指出。如果需要的话，我会及时审查并更新。

[![在此输入图像描述](https://i.stack.imgur.com/2lFhd.jpg)](https://i.stack.imgur.com/2lFhd.jpg)

我假设您的意思是管道而不是过滤器，因为过滤器主要与异常处理相关。

肯定存在一些重叠，因为中间件是组成任何 Web 应用程序的灵活方式，但更多的是一个通用概念（创建一堆函数来构建管道）。其他是 Nest 特定的概念，因此与依赖注入等内容更自然地联系在一起。

管道用于转换输入数据（并且可以选择进行验证）。

拦截器非常简洁，因为它们可以转换传入和传出 API 的数据。它们使您能够通过使用可观察流来改变原始处理程序返回的内容。您可能需要使用两个中间件（在处理程序的两侧）来实现这一点。

当您想要转换传入处理程序的数据时，请使用管道。

当需要双向转换时使用拦截器。

当您想要更接近构建 Web 应用程序的传统（例如 Express）方式时，或者当您想要更广泛地同时将功能应用于多个处理程序时（代码中浮动的装饰器较少），请使用中间件。

Whats the difference between interceptor vs middleware vs filter in nest js

Cypress 是一个前端自动化测试工具，它不直接支持传统的条件语句（如 `if`），因为它运行在异步的 JavaScript 环境中。在 Cypress 中进行条件判定通常需要依赖其提供的链式命令和断言。如果您想根据某个元素是否存在来执行不同的命令，可以使用 `.then()` 方法来访问当前命令队列的状态，并编写自己的逻辑。

以下是一个 Cypress 中根据元素存在来决定执行逻辑的例子：

```javascript
// 检查元素是否存在
cy.get('body').then($body => {
  // 如果元素存在
  if ($body.find('.my-element').length) {
    // 元素存在时执行的代码
    cy.get('.my-element').click();
  } else {
    // 元素不存在时执行的代码
    // 例如：可以选择点击另一个按钮或者记录日志等
    cy.get('.other-button').click();
  }
});
```

在这个例子中，`.then()` 方法被用来访问 DOM 并对其进行检查。我们首先尝试获取 `body` 标签，然后在 `.then()` 的回调函数中检查我们感兴趣的 `.my-element` 类的元素是否存在。通过查找 `.my-element` 类的长度，我们可以判断元素是否存在来决定执行的逻辑。如果存在，执行一些操作（例如点击它），如果不存在，可能需要执行一些其他操作（例如点击一个替代的按钮或记录一条日志等）。这样，我们就能够根据页面上元素的存在与否来控制测试流程。

Cypress 允许 jQuery 处理 DOM 元素，因此这对您有用：

    cy.get("selector_for_your_button").then($button => {
      if ($button.is(':visible')){
        //you get here only if button is visible
      }
    })
    

**更新**：您需要区分现有按钮和可见按钮。下面的代码区分了 3 种不同的场景（存在且可见、存在且不可见、不存在）。如果你想在按钮不存在的情况下通过测试，你可以这样做`assert.isOk('everything','everything is OK')`

    cy.get("body").then($body => {
        if ($body.find("selector_for_your_button").length > 0) {   
        //evaluates as true if button exists at all
            cy.get("selector_for_your_button']").then($header => {
              if ($header.is(':visible')){
                //you get here only if button EXISTS and is VISIBLE
              } else {
                //you get here only if button EXISTS but is INVISIBLE
              }
            });
        } else {
           //you get here if the button DOESN'T EXIST
           assert.isOk('everything','everything is OK');
        }
    });

您还可以使用我的插件`cypress-if`来编写条件命令链

    cy.get('...').if('visible').click()
    

阅读[https://glebbahmutov.com/blog/cypress-if/](https://glebbahmutov.com/blog/cypress-if/)

试试这个代码：

    isElementVisible(xpathLocater) {
            this.xpath(xpathLocater).should('be.visible');
    };
    
    isElementNotVisible(xpathLocater) {
            this.xpath(xpathLocater).should('not.exist');
    };
    

然后将这两种方法与 if 语句一起使用，如下所示：

    if(isElementNotVisible) {
    }
    

或者

    if(isElementVisible) {
    }

Cypress : How to know if element is visible or not in using If condition?

在Cypress中，要获取元素的`href`属性，你可以使用`.invoke('attr', 'attributeName')`方法，其中`attributeName`就是你想要获取的属性名，比如`href`。下面是一个简单的例子说明如何获取一个链接（anchor tag `<a>`）的`href`属性：

```javascript
// 假设有一个链接<a id="my-link" href="/some-path">Click here</a>
// 用Cypress选择这个元素然后获取href属性

cy.get('#my-link') // 选择元素
  .invoke('attr', 'href') // 获取href属性
  .then(href => {
    // 现在你可以使用href变量，它包含了链接的href属性值
    console.log(href); // 输出: /some-path
    // 做其他的断言或操作
  });
```

在这个例子中，`.get('#my-link')`命令先选中ID为`my-link`的元素，然后`.invoke('attr', 'href')`命令用于获取该元素的`href`属性值。最后，`.then()`用于得到这个属性值，并且可以在这个回调函数中对`href`进行进一步的操作或断言。

如果你需要断言这个`href`属性是否有特定的值，你可以直接用Cypress提供的`.should()`断言方法，例如：

```javascript
// 断言元素的href属性是否等于某个特定值
cy.get('#my-link').should('have.attr', 'href', '/some-path');
```

在这个断言中，`should('have.attr', 'href', '/some-path')`会检查选中的元素是否有一个`href`属性，且该属性的值为`/some-path`。如果不匹配，测试会失败。

The code below should do what you're trying to achieve. There is also an entire [recipe with suggestions on how to test links that open in new tabs](https://github.com/cypress-io/cypress-example-recipes/blob/master/examples/testing-dom__tab-handling-links/cypress/e2e/tab_handling_anchor_links_spec.cy.js).

    it('Advertise link should refer to Contact page', () => {
       cy.get('div.footer-nav > ul > li:nth-child(2) > a')
         .should('have.attr', 'href').and('include', 'contact')
         .then((href) => {
           cy.visit(href)
         })
    })
    

I would also suggest reading through the Cypress document on the best ways to assign and work with variables: [https://on.cypress.io/variables-and-aliases](https://on.cypress.io/variables-and-aliases)

Solution 1: `invoke("attr", "href")`
------------------------------------

Navigate to the URL specified in the element's href attribute:

    cy.get(selector)
          .invoke('attr', 'href')
          .then(href => {
            cy.visit(href);
          });
    

Reference: [https://docs.cypress.io/api/commands/invoke.html#Function-with-Arguments](https://docs.cypress.io/api/commands/invoke.html#Function-with-Arguments)

* * *

Solution 2: Prevent content from opening in a new tab.
------------------------------------------------------

Remove the target attribute from the anchor element, then click on it to navigate to its URL within the same tab:

    cy.get(selector).invoke('removeAttr', 'target').click()
    

Reference: [https://docs.cypress.io/examples/examples/recipes.html#Tab-Handling-and-Links](https://docs.cypress.io/examples/examples/recipes.html#Tab-Handling-and-Links)

How to get href attribute in Cypress?

`hasClass()`CSS 选择器的 or是`has()`jQuery 中的内置方法，用于检查具有指定类名的元素是否存在。然后您可以返回一个布尔值来执行断言控制。

    Cypress.Commands.add('isExistElement', selector => {
      cy.get('body').then(($el) => {
        if ($el.has(selector)) {
          return true
        } else {
          return false
        }
      })
    });
    

然后，可以用 TypeScript 文件（index.d.ts）将其制作成特殊的 cypress 方法，并且可以采用可链接的形式。

    declare namespace Cypress {
        interface Chainable {
            isExistElement(cssSelector: string): Cypress.Chainable<boolean>
        }
    }
    

如下例所示：

    shouldSeeCreateTicketTab() {  
      cy.isExistElement(homePageSelector.createTicketTab).should("be.true");
    }

使用**元素轮询**并进行检查，以免测试失败。

在最大等待时间内，要么对话框永远不会到达，要么此代码将其关闭。

    cy.get('#login-username').type('username');
    cy.get('#login-password').type(`password{enter}`);
    
    const ifElementExists = (selector, attempt = 0) => {
      if (attempt === 100) return null           // no appearance, return null
      if (Cypress.$(selector).length === 0) {
        cy.wait(100, {log:false})                // wait in small chunks
        getDialog(selector, ++attempt)           // try again
      }
      return cy.get(selector, {log:false})       // done, exit with the element
    }
    
    ifElementExists('.warning').then($el => {
      if ($el?.length) {
        $el.find('#warn-dialog-submit').click()
      }
    })

export function clickIfExist(element) {
            cy.get('body').then((body) => {
                if (body.find(element).length > 0) {
                    cy.get(element).click();
                }
            });
        }

export const getEl = name => cy.get(`[data-cy="${name}"]`)
    
    export const checkIfElementPresent = (visibleEl, text) => {
       cy.document().then((doc) => {
         if(doc.querySelectorAll(`[data-cy=${visibleEl}]`).length){
          getEl(visibleEl).should('have.text', text)
    
          return ;
       }
    getEl(visibleEl).should('not.exist')})}

How to check for an element that may not exist using Cypress

在 Cypress 中，如果您想在运行测试用例之前在 `localStorage` 中设置令牌（token），可以使用Cypress的`cy`命令来实现。这通常会在`beforeEach`钩子中完成，以确保在每个测试运行前设置所需的状态。以下是一个示例：

```javascript
describe('Token Setting in LocalStorage', () => {
  beforeEach(() => {
    cy.visit('/'); // 访问应用的初始页面

    // 设置localStorage中的令牌
    cy.window().then((win) => {
      win.localStorage.setItem('token', 'yourTokenValue');
    });
  });

  // 这里写上测试用例
  it('should have token set in localStorage', () => {
    // 测试localStorage中的令牌是否正确设置
    cy.window().should((win) => {
      expect(win.localStorage.getItem('token')).to.eq('yourTokenValue');
    });
  });
});
```

在这个例子中，我们首先调用 `cy.visit('/')` 来加载应用程序的页面。然后，在 `beforeEach` 钩子中，我们通过 `cy.window()` 访问浏览器窗口对象，并利用该对象的 `localStorage.setItem` 方法来设置令牌。`'yourTokenValue'` 应该替换为实际的令牌值。

之后，每个 `it` 块中的测试用例都会在一个有令牌存在于 `localStorage` 的环境中运行。在测试用例中，我们还可以使用 `expect` 语句来确认 `localStorage` 中的令牌是否正确设置，这有助于验证设置操作是否成功。

请注意，有些情况下，您可能需要等待某些异步操作完成后再设置localStorage，或者您的应用程序可能在加载时清除localStorage，这时您应该确保 `localStorage` 在应用程序的初始化逻辑执行完毕后再进行设置。这可以通过在 `cy.visit('/').then(() => { /* set localStorage here */ })` 回调中完成来确保正确的时序。

Here's an example of adding a command `cy.login()` that you can use in any Cypress test, or put in a `beforeEach` hook.

    Cypress.Commands.add('login', () => { 
      cy.request({
        method: 'POST',
        url: 'http://localhost:3000/api/users/login',
        body: {
          user: {
            email: 'jake@jake.jake',
            password: 'jakejake',
          }
        }
      })
      .then((resp) => {
        window.localStorage.setItem('jwt', resp.body.user.token)
      })
    
    })
    

Then in your test:

    beforeEach(() => {
      cy.login()
    })

As an extra, you can also use the [cypress-localstorage-commands](https://www.npmjs.com/package/cypress-localstorage-commands) package to persist localStorage between tests, so login request will be made only once:

In support/commands.js:

    import "cypress-localstorage-commands";
    
    Cypress.Commands.add('login', () => { 
      cy.request({
        method: 'POST',
        url: 'http://localhost:3000/api/users/login',
        body: {
          user: {
            email: 'jake@jake.jake',
            password: 'jakejake',
          }
        }
      })
      .its('body')
      .then(body => {
        cy.setLocalStorage("jwt", body.user.token);
      })
    });
    

Then, in your tests:

    before(() => {
      cy.login();
      cy.saveLocalStorage();
    });
    
    beforeEach(() => {
      cy.restoreLocalStorage();
    });

I've used something along the lines of bkuceras answer for a while now. Recently I've run into an issue when testing multiple roles/logins throughout tests. Basically what is happening is I log in as an admin and do one test, then I log in as a non admin and do a second test. The first test runs fine and ends (cypress clears local storage) however there are still some xhr requests running from the first test when the second test starts. These xhr requests no longer see the token which triggers my app to see a 401 unauthorized error and clear local storage (including my non admin token I have set). Now the 2nd test fails because that non admin token is not available in local storage.

Ultimately my solution was to prefetch the token before the test then set the token in the onBeforeLoad function of visit. This ensures the token is not cleared by any race condition before your visit command.

    cy.visit('/app', {
        onBeforeLoad: function (window) {
            window.localStorage.setItem('token', myToken);
        }
    })
    

Really this is a pretty unique edge case, but heres hoping it may help someone as I've spent many hours finding this solution.

If you are open for the experimental mode, I highly recommend to use the cy.session to store the token:

    Cypress.Commands.add('login', (username, password) => {
      cy.session([username, password], () => {
        cy.request({
          method: 'POST',
          url: '/login',
          body: { username, password },
        }).then(({ body }) => {
          window.localStorage.setItem('authToken', body.token)
        })
      })
    })
    

For more information, please check the official cypress documentation: [https://docs.cypress.io/api/commands/session](https://docs.cypress.io/api/commands/session)

In Cypress, set a token in localStorage before test

在Cypress中选择某个元素内部的第n个子元素，可以使用`.children()`来获取所有子元素，然后使用`.eq(index)`来选取特定索引的子元素。索引是从0开始的，所以如果您想选择第n个子元素，您需要使用`.eq(n-1)`。这里有一个具体的例子：

假设我们有如下的HTML结构：

```html
<div class="parent">
  <div class="child">Child 1</div>
  <div class="child">Child 2</div>
  <div class="child">Child 3</div>
</div>
```

如果你想选择这个父元素内的第二个子元素，你可以这样写Cypress测试代码：

```javascript
cy.get('.parent').children().eq(1).should('contain', 'Child 2');
```

在这个例子中：
- `.get('.parent')` 选择了类名为`parent`的元素。
- `.children()` 获取了这个父元素的所有直接子元素。
- `.eq(1)` 选择了这些子元素中的第二个（索引为1）。
- `.should('contain', 'Child 2')` 是断言，检查选中的元素是否包含文本"Child 2"。

如果您想选择第n个子元素，请确保将n减去1，然后放在`.eq()`中，因为索引是基于0的。

Update
------

As pointed out by @dpstree in the comments, this doesn't answer the original question. Please see more recent answers for a complete solution.

Original
--------

By using [eq](https://docs.cypress.io/api/commands/eq.html#Usage)

    cy.get('tbody>tr').eq(0)    // Yield first 'tr' in 'tbody'
    cy.get('ul>li').eq(4)       // Yield fifth 'li' in 'ul'

In the particular context of _selecting_ the nth `option`, this may be appropriate:

    cy.get('select[name=subject] > option')
      .eq(3)
      .then(element => cy.get('select[name=subject]').select(element.val()))

Based on solution from [Miguel Rueda](https://stackoverflow.com/users/10451645/miguel-rueda), but using `prevSubject` option:

    Cypress.Commands.add(
      'selectNth',
      { prevSubject: 'element' },
      (subject, pos) => {
        cy.wrap(subject)
          .children('option')
          .eq(pos)
          .then(e => {
            cy.wrap(subject).select(e.val())
          })
      }
    )
    

Usage:
======

    cy.get('[name=assignedTo]').selectNth(2)
    

Explanation:
============

*   Using `children('option')` and `.eq(pos)` traverse children of select to specific element.
*   Call `select` method with value of selected element.

You can now select an option by `index` within the `.select(index)` command:

    cy.get('select').select(0)        // selects by index (yields first option) ie "What is this regarding?"
    cy.get('select').select([0, 1])   // select an array of indexes
    

This should be easy now with the release of cypress [v8.5.0](https://github.com/cypress-io/cypress/releases/tag/v8.5.0). See [documentation](https://docs.cypress.io/api/commands/select#Index) for more.

I had the same problem and solved it by creating a custom cypress command. No as pretty as I would like, but it did the job.

    Cypress.Commands.add("selectNth", (select, pos) => {
      cy.get(`${select} option +option`)
        .eq(pos)
        .then( e => {
           cy.get(select)
             .select(e.val())
        })
    })
    

then I used in the test as such

        cy.viewport(375, 667)
          .selectNth("customSelector", 3)
    

The `option +option` part was the only way I could find to get the full list of options inside a select and it's currently the bit of code i'm trying to work arround although it works fine.

How to select nth item inside select element in cypress

在Cypress中，要检验某个元素是否不存在，可以使用`.should('not.exist')`断言。这个断言会成功地通过，如果在DOM中找不到期望的元素。以下是一个简单的例子，展示了如何在Cypress中验证一个元素不存在：

```javascript
// 假设我们想要确保一个具有特定ID的元素不存在于页面中
cy.get('#element-to-find').should('not.exist');
```

这行代码会指示Cypress去查找具有ID `element-to-find` 的元素，并验证它确实不存在于DOM中。

在实际的测试场景中，你可能遇到需要等待某个异步操作完成后再检查元素是否存在的情况。例如，如果有一个元素是在某个动作执行后被从DOM中移除的，你可能想要使用`cy.wait()`来等待这个操作完成：

```javascript
// 假设执行某个动作后，元素会被从DOM中移除
cy.click('#remove-element-button'); // 触发移除元素的动作
cy.wait(1000); // 等待1000毫秒
cy.get('#element-to-remove').should('not.exist'); // 然后检查元素是否被移除
```

在这个例子中，我们首先触发了一个按钮点击事件，它会导致页面上的一个元素被移除。然后我们告诉Cypress等待一秒钟，以确保那个动作有足够的时间去完成移除元素的操作，最后我们检查元素是否真的不存在了。

总的来说，使用`.should('not.exist')`是一个确保元素不存在于页面中的简单而有效的方法。记住，在某些情况下，可能需要等待特定的异步事件完成后才能正确进行此类检查。

Well this seems to work, so it tells me I have some more to learn about .should()

    cy.get('.check-box-sub-text').should('not.exist');

You can also search for a text which is not supposed to exist:

    cy.contains('test_invite_member@gmail.com').should('not.exist')
    

Here you have the result in Cypress: `0 matched elements`

[![enter image description here](https://i.stack.imgur.com/W9QMR.png)](https://i.stack.imgur.com/W9QMR.png)

Reference: [Docs - Assertions, Existence](https://docs.cypress.io/guides/references/assertions.html#Existence)

Use `.should('not.exist')` to assert that an element does not exist in the DOM.

* * *

Do **not** use `not.visible` assertion. It would falsely pass in < 6.0, but properly fail now:

    // for element that was removed from the DOM
    // assertions below pass in < 6.0, but properly fail in 6.0+
    .should('not.be.visible')
    .should('not.contain', 'Text')
    

Migration Docs here: [Migrating-to-Cypress-6-0](https://docs.cypress.io/guides/references/migration-guide.html#Migrating-to-Cypress-6-0)

cy.get('[data-e2e="create-entity-field-relation-contact-name"]').should('not.exist');
    

might lead to some false results, as some error messages get hidden. It might be better to use

    .should('not.visible');
    

in that case.

How to test if element does not exist in Cypress?

在Cypress中，您可以利用`.its('length')`命令来获取选择元素的长度。这个命令会返回被选元素的数量。这个功能经常用于断言，以确保DOM中存在特定数量的元素。

以下是一个例子，假设我们要测试一个包含多个类为`.list-item`的列表项的页面：

```javascript
describe('List items count test', () => {
  it('should have the correct number of .list-item elements', () => {
    // 访问你的页面
    cy.visit('your-page-url');
    
    // 获取所有的.list-item元素，并断言其长度
    cy.get('.list-item').its('length').should('eq', 5);
  });
});
```

在这个例子中，我们期望页面上有5个`.list-item`的元素。`.its('length')`会获取到`.list-item`的数量，并且`.should('eq', 5)`用于断言这个数量是否等于5。如果不等于5，测试会失败。

Found a solution, This works to check a count of items:

    cy.get('.datatable').find('tr').should('have.length', 4)
    

This does not work with the `Cypress.$()` method of notation.

Reference: [https://docs.cypress.io/guides/references/assertions.html#Length](https://docs.cypress.io/guides/references/assertions.html#Length)

You can also get the length of a selection of items [through its property](https://docs.cypress.io/api/commands/its.html), for example:

    cy.get('.datatable').find('tr').its('length').should('eq', 4)
    cy.get('.datatable').find('tr').its('length').should('be.gte', 4)
    

In addition to `should('have.length', 4)`

[![enter image description here](https://i.stack.imgur.com/LeFkS.png)](https://i.stack.imgur.com/LeFkS.png) I tested with Cypress version 3.1.0 and 3.2.0.

if you want more flexible and have a dynamic result use this.

    cy.get('.listings-grid')
      .find('.listing')
      .then(listing => {
        const listingCount = Cypress.$(listing).length;
        expect(listing).to.have.length(listingCount);
      });

One option is to use "have.length" ...

    cy.get('.datatable tr').should('have.length', 4)
    

...another option is to use should

    cy.get('.datatable tr').should(($tr) => {
        expect($tr).to.have.length(4)
    })
    

...or then (synchronous queries)

    cy.get('.datatable').then(($table) => {
      // synchronously query to find length of elements
      expect($table.find('td').length).to.equal(4)
    })

From the [cypress API docs .should() section](https://docs.cypress.io/api/commands/should.html#Function), using an [arrow function](http://es6-features.org/#ExpressionBodies):

    cy.get('.datatable').find('tr').should(($listOfElements) => {
       expect($listOfElements).to.have.length(4)
       // any other assertions, for example the below one
       // expect($listOfElements).to.have.any.keys('key1', 'key2')
    })
    

This approach will allow you to use [Chai BDD notation](https://docs.cypress.io/guides/references/assertions.html#BDD-Assertions) and assert more than one thing on your list of elements.

How to count a selection of items and get the length in Cypress ？

`HEAD`在Git中是一个引用（reference），它指向当前工作目录中的最新提交。简单来说，它代表了你最后一次提交的结果，或者说是当前工作的快照。在Git中，`HEAD`通常用来表示当前的工作分支的尖端。

例如，如果你在`master`分支上工作，并做了一些提交，`HEAD`将会指向`master`分支的最新提交。如果你切换到另一个分支，比如`feature`，那么`HEAD`就会更新，以指向`feature`分支的最新提交。

在Git中，`HEAD`可以是附着的（attached）状态或游离的（detached）状态。当它处于附着状态时，它指向当前分支的最新提交。当处于游离状态时，它直接指向一个提交，而不是某个分支的尖端。这种情况通常发生在你检出一个特定的提交而不是分支时。

此外，`HEAD`还可以与其他引用一起使用，比如`HEAD~1`可以用来引用当前提交的父提交，`HEAD~2`用来引用父提交的父提交，依此类推。

一个实际的例子是，如果我想查看当前分支的历史中的上一个提交，我可以使用命令`git show HEAD~1`。如果我想将当前分支重置到这个上一个提交的状态，我可以使用命令`git reset --hard HEAD~1`。这将会使当前分支的`HEAD`指向那个提交，并且将工作目录的内容更新为那个提交的内容。

您可以将 HEAD 视为“当前分支”。当您使用 切换分支时`git checkout`，HEAD 修订版本会更改为指向新分支的尖端。

您可以通过执行以下操作来查看 HEAD 指向的内容：

    cat .git/HEAD
    

就我而言，输出是：

    $ cat .git/HEAD
    ref: refs/heads/master
    

HEAD 可以引用与分支名称不相关的特定修订版。这种情况称为[detached HEAD](http://git-scm.com/docs/git-checkout#_detached_head)。

引用[别人的话](http://www.eecs.harvard.edu/%7Ecduan/technical/git/git-1.shtml#heads)：

> 头只是对提交对象的引用。每个头都有一个名称（分支名称或标签名称等）。默认情况下，每个存储库中都有一个名为 master 的头。存储库可以包含任意数量的头。在任何给定时间，都会选择一个头作为“当前头”。该头是 HEAD 的别名，始终大写”。
> 
> 请注意这一区别：“head”（小写）指的是存储库中的任何一个命名头；“HEAD”（大写）专门指当前活动的头。这种区别在 Git 文档中经常使用。

[可以在这里](http://eagain.net/articles/git-for-computer-scientists/)找到另一个快速介绍 git 内部工作原理（从而更好地理解 head/HEAD）的好资源。引用 (ref:) 或标题或分支可以被视为粘贴在提交历史记录中的提交上的便利贴。[`git checkout`](http://linux.die.net/man/1/git-checkout)通常它们指向一系列提交的尖端，但它们可以通过或[`git reset`](https://www.kernel.org/pub/software/scm/git/docs/git-reset.html)等移动。

这些答案中可能存在一个微妙但重要的误解。我想我应该添加我的答案来澄清它。

> 什么是`HEAD`？

### 头就是你

`HEAD`是一个符号引用，指向您在提交历史记录中的任何位置。无论你走到哪里，无论你做什么，它都会像影子一样跟随你。如果你做出承诺，`HEAD`就会移动。如果你结账了一些东西，`HEAD`就会搬家。无论你做什么，如果你在提交历史中移动到了新的地方，`HEAD`它就会随着你一起移动。为了解决一个常见的误解：你无法将自己与`HEAD`. 这不是分离的 HEAD 状态。如果你发现自己在想：“哦不，我处于分离的头脑状态！我失去了我的头脑！” 记住，这是你的头。头就是你。你还没有脱离头脑，你和你的头脑已经脱离了其他东西。

### HEAD 可以连接什么？

`HEAD`可以指向提交，是的，但通常不会。让我再说一遍。_通常`HEAD`不指向提交。_它指向一个分支引用。它_附加_到该分支，当您执行某些操作（例如`commit`或[`reset`](https://stackoverflow.com/a/54934887/7936744)）时，附加的分支将随着 一起移动`HEAD`。您可以通过查看引擎盖下面的内容来了解​​它所指向的内容。

    cat .git/HEAD
    

通常你会得到这样的结果：

    ref: refs/heads/master
    

有时你会得到这样的信息：

    a3c485d9688e3c6bc14b06ca1529f0e78edd3f86
    

`HEAD`这就是当直接指向提交时会发生的情况。这称为分离头，因为`HEAD`它指向分支引用之外的其他内容。如果您在此状态下进行提交，`master`则不再附加到`HEAD`，将不再与您一起移动。该提交在哪里并不重要。**您可以与主分支位于同一提交上，但如果`HEAD`指向该提交而不是分支，则它会被分离，并且新的提交将不会与分支引用关联。**

如果您尝试以下练习，您可以以图形方式查看此内容。从 git 存储库运行此命令。你会得到一些稍微不同的东西，但它们的关键部分会在那里。当需要直接检查提交时，只需使用从第一个输出中获得的任何缩写哈希（此处是`a3c485d`）。

    git checkout master
    git log --pretty=format:"%h:  %d" -1
    # a3c485d:   (HEAD -> master)
    
    git checkout a3c485d -q # (-q is for dramatic effect)
    git log --pretty=format:"%h:  %d" -1   
    # a3c485d:   (HEAD, master)
    

好的，所以这里的输出有一点小小的差异。直接检查提交（而不是分支）给我们一个逗号而不是箭头。你怎么看，我们是否处于分离的 HEAD 状态？HEAD 仍然指与分支名称关联的特定修订版。我们仍然_在_master 分支上，不是吗？

现在尝试：

    git status
    # HEAD detached at a3c485d
    

没有。我们处于“分离头”状态。

`(HEAD -> branch)`您可以看到与 的`(HEAD, branch)`相同表示`git log -1`。

### 综上所述

`HEAD`是你。它指向您查看的任何内容，无论您身在何处。通常这不是提交，而是分支。如果`HEAD` _确实_指向提交（或标记），即使它与分支也指向相同的提交（或标记），您（和`HEAD`）也已与该分支分离。由于您没有附加分支，因此当您进行新提交时，分支不会跟随您。`HEAD`不过，会的。

HEAD 只是一个特殊的指针，指向您当前所在的本地分支。

来自[Pro Git](https://git-scm.com/book/en/v2)书籍，第[3.1 章 Git 分支 - 简而言之分支，在](https://git-scm.com/book/en/v2/Git-Branching-Branches-in-a-Nutshell)**创建新分支**部分：

> 如果创建一个新分支会发生什么？好吧，这样做会创建一个新的指针供您移动。假设您创建一个名为测试的新分支。您可以使用 gitbranch 命令执行此操作：
> 
>     $ git branch testing 
>     
> 
> 这会在您当前所在的同一提交处创建一个新指针
> 
> ![在此输入图像描述](https://i.stack.imgur.com/VBCtE.png)
> 
> Git 如何知道你当前所在的分支？它保留一个称为 HEAD 的特殊指针。请注意，这与您可能习惯的其他 VCS（例如 Subversion 或 CVS）中的 HEAD 概念有很大不同。在 Git 中，这是指向您当前所在的本地分支的指针。在这种情况下，你仍然是master。gitbranch 命令只创建了一个新分支——它并没有切换到该分支。
> 
> ![在此输入图像描述](https://i.stack.imgur.com/eAo7u.png)

我推荐 github 开发者 Scott Chacon 的这个定义 \[[视频参考](http://www.youtube.com/watch?feature=player_detailpage&v=ZDR433b0HJY#t=2791s)\]：

> Head 是您当前的分支。这是一个象征性的参考。它是对分支的引用。你总是有 HEAD，但 HEAD 将指向其他指针之一，指向你所在的分支之一。它是您下一次提交的父级。它应该是上次签出到您的工作目录中的内容...这是您的工作目录的最后一个已知状态。

整个视频将公正地介绍整个 git 系统，因此我也建议您如果有时间的话可以全部观看。

Git 中的 `HEAD` 是一个引用（reference），指向当前工作目录中所检出（checked out）的最新提交（commit）。换句话说，`HEAD` 指向当前分支的最新的本地提交，并且它会随着新的提交而移动。

当你切换分支时，`HEAD` 也会随之切换到新分支的最新提交。在多数情况下，`HEAD` 会指向一个分支名，比如 `master` 或 `main`，这被称为“依附的 HEAD”（attached HEAD）。这意味着你正处在正常的开发过程中，你的 `HEAD` 正依附于一个特定的分支上。

然而，也可以在没有依附任何分支的情况下检出某个特定的提交，这被称作“分离的 HEAD”（detached HEAD）。在这种模式下，你可以查看历史中的代码，或者进行实验性的提交，但要注意，如果你在分离的 HEAD 状态下创建了新的提交，那么，当你切换回一个正常的分支时，这些提交可能会丢失，除非你特别地创建一个新分支来保存这些变化。

你可以通过 `git log` 查看 `HEAD` 的指向，或者使用 `git show-ref --heads` 查看所有分支的当前提交。在 Git 的实现里，`HEAD` 通常是一个包含指向当前提交 SHA-1 值的文件，位于 `.git/` 目录中。

What is head in git?

全局的 Git 配置数据存储在用户的主目录下的 `.gitconfig` 文件中。当您在命令行使用 `git config --global` 命令设置配置时，它会将这些配置添加到这个文件中。

例如，如果我想设置我的全局用户名和电子邮件，我会在终端中使用以下命令：

```bash
git config --global user.name "Your Name"
git config --global user.email "your_email@example.com"
```

执行这些命令后，`.gitconfig` 文件将包含以下内容：

```ini
[user]
    name = Your Name
    email = your_email@example.com
```

这个文件是针对每个用户的，影响该用户在该系统上进行的所有 Git 操作。这与仓库级别的配置是分开的，仓库级别的配置存储在每个 Git 仓库的根目录下的 `.git/config` 文件中。

可以简单地使用：

```bash
git config --list --show-origin
```

使用 Git 2.26，您可以[添加一个 `--show-scope`选项](https://stackoverflow.com/a/60286340/6309)

```bash
git config --list --show-origin --show-scope
```

您将看到哪个配置设置在哪里。
请参阅“[我的 Git 配置中的设置来自哪里？](https://stackoverflow.com/a/35670933/6309) ”

我也在我的 Windows 电脑上寻找全局 `.gitconfig`文件，并使用 git 发现了这个巧妙的技巧。

执行以下操作：

```bash
git config --global -e
```

然后，如果幸运的话，您将打开一个加载了全局 `.gitconfig`文件的文本编辑器。然后只需从那里执行查找文件夹命令即可

在 \*nixes 上，它位于`~/.gitconfig`. 你家里有对应的文件吗？

在 Windows 上，您可以在[Git Bash](https://superuser.com/questions/1053633/what-is-git-bash-for-windows-anyway)中输入以下内容：

    notepad ~/.gitconfig

msygit 的路径是：

**Windows Vista+** `C:\Users\<user_name>\.gitconfig`

在 Windows MsysGit 上，全局位置是使用 HOMEDRIVE 和 HOMEPATH 环境变量导出的，除非您定义了 HOME 环境变量。“配置文件”脚本中有详细说明。

在我的公司环境中，HOMEDRIVE 是 H:，然后将其映射到网络 URL \\\\share\\$。然后，所有内容都会映射到“我的文档”，这不是其他人所期望的。驱动器到 URL 重新映射可能存在一些其他问题。无论如何，我什至无法调整 HOMEDRIVE 或 HOMEPATH 变量。

就我而言，我定义了一个个人 HOME 环境变量并将其指向 D:\\git\\GitHOME 并将所有这些 GIT 文件（没有扩展名）复制到 GitHOME 目录以安全保存。

可以通过“我的电脑”属性对话框中的“高级”选项卡设置 Windows 环境变量。

Where is the global git config data stored?

如果错误地命名了分支并将其推送到远程存储库，请按照以下步骤重命名该分支

1. **重命名您的本地分支：**

   * 如果在要重命名的分支上：
   * ```bash
     git branch -m new-name
     ```
   * 如果在不同的分支：
   * ```bash
     git branch -m old-name new-name
     ```
2. **删除 `old-name`远程分支并推送 `new-name`本地分支**：`git push origin :old-name new-name`
3. **重置新名称本地分支的上游分支**：
   切换到该分支，然后：
   `git push origin -u new-name`

[![示意图，可爱的 git 远程图](https://i.stack.imgur.com/YeBYR.jpg)](https://i.stack.imgur.com/YeBYR.jpg)

* * *

有几种方法可以实现这一点：

1.  更改您的本地分支，然后推送您的更改
2.  使用新名称将分支推送到远程，同时在本地保留原始名称

### 重命名本地和远程

    # Rename the local branch to the new name
    git branch -m <old_name> <new_name>
    
    # Delete the old branch on remote - where <remote> is, for example, origin
    git push <remote> --delete <old_name>
    
    # Or shorter way to delete remote branch [:]
    git push <remote> :<old_name>
    
    # Prevent git from using the old name when pushing in the next step.
    # Otherwise, git will use the old upstream name instead of <new_name>.
    git branch --unset-upstream <new_name>
    
    # Push the new branch to remote
    git push <remote> <new_name>
    
    # Reset the upstream branch for the new_name local branch
    git push <remote> -u <new_name>
    

[![控制台截图](https://i.stack.imgur.com/YOHON.png)](https://i.stack.imgur.com/YOHON.png)

* * *

### 仅重命名远程分支

信用：[ptim](https://stackoverflow.com/questions/30590083/how-do-i-rename-both-a-git-local-and-remote-branch-name/30590238#42173564)

    # In this option, we will push the branch to the remote with the new name
    # While keeping the local name as is
    git push <remote> <remote>/<old_name>:refs/heads/<new_name> :<old_name>
    

* * *

### 重要的提示：

当您使用`git branch -m`（移动）时，Git 也会使用新名称**更新您的跟踪分支。**

> `git remote rename legacy legacy`

`git remote rename`正在尝试更新配置文件中的远程部分。它将使用给定名称的遥控器重命名为新名称，但在您的情况下，它没有找到任何名称，因此重命名失败。

**但**它不会按照你的想法去做；它将重命名您的**本地**配置远程名称而**不是**远程分支。 

* * *

**注意** Git 服务器可能允许您使用 Web 界面或外部程序（如 Sourcetree 等）重命名 Git 分支，但您必须记住，在 Git 中所有工作都是在本地完成的，因此建议使用上述命令去工作。

查询正在使用的分支

```
git branch -a 
```

切换到要重命名的分支

```bash
git checkout branch_to_rename
```

使用重命名分支

```bash
git branch -m new_name
```

推动更改

```bash
git push origin :old_name new_name
```

*   **重命名您的本地分支机构**。

如果您在要重命名的分支上：

    git branch -m new-name
    

如果您当前住在不同的分支机构：

    git branch -m old-name new-name
    

*   **删除旧名称的远程分支并推送新名称的本地分支。**

留在目标分支上并且：

    git push origin :old-name new-name
    

*   **重置新名称本地分支的上游分支。**

切换到目标分支然后：

    git push origin -u new-name

看来有一个直接的办法：

> 如果您真的只想远程重命名分支（而不同时重命名任何本地分支），您可以使用单个命令来完成此操作，例如
> 
> `git push <remote> <remote>/<old_name>:refs/heads/<new_name> :<old_name>`
> 
> _[在 Git 中远程重命名分支](https://stackoverflow.com/questions/4753888/renaming-branches-remotely-in-git/21302474#21302474)_

有关更多详细信息，请参阅原始答案。

How do i rename both a git local and remote branch name?

在使用Git进行版本控制时，`cherry-pick` 是一项功能，它允许开发者选择一个或多个提交(commit)从一个分支复制到当前所在的分支。当你想要将指定的提交应用到你的分支，而不是合并整个分支的内容时，这非常有用。

要逐个挑选多个提交记录，你可以重复使用 `git cherry-pick` 命令，后面跟着你想要挑选的提交的哈希值（commit hash）。例如：

```sh
git cherry-pick commit_hash1
git cherry-pick commit_hash2
git cherry-pick commit_hash3
```

每执行一次 `cherry-pick`，就会将指定的提交应用到当前分支上。

如果你想一次挑选一系列连续的提交，你可以使用如下命令：

```sh
git cherry-pick commit_hash1^..commit_hash3
```

在这个例子中，`commit_hash1^` 表示 `commit_hash1` 的父提交，而 `commit_hash3` 是你想要挑选的最后一个提交。上面的命令将会挑选 `commit_hash1` 到 `commit_hash3` 之间的所有提交（包括 `commit_hash1` 和 `commit_hash3`）。

如果你想要挑选不连续的多个提交，可以在 `git cherry-pick` 命令中一次性列出所有想要挑选的提交哈希值，每个哈希值之间用空格隔开。例如：

```sh
git cherry-pick commit_hash1 commit_hash3 commit_hash5
```

这将会分别挑选 `commit_hash1`、`commit_hash3` 和 `commit_hash5` 这三个提交。

在执行 `cherry-pick` 操作时，可能会发生冲突。如果发生冲突，Git 会停止应用提交，并让你解决冲突。解决完冲突后，你需要使用 `git add` 命令将冲突文件标记为已解决，然后使用 `git cherry-pick --continue` 继续应用挑选的提交。如果你决定不继续这个 `cherry-pick` 操作，可以使用 `git cherry-pick --abort` 放弃更改，回到操作前的状态。

Git 1.7.2 引入了挑选一系列提交的功能。从[发行说明](https://raw.github.com/git/git/master/Documentation/RelNotes/1.7.2.txt)来看：

> `git cherry-pick`学会了选择一系列提交（例如`cherry-pick A..B`和`cherry-pick --stdin`）， 也是如此`git revert`；`rebase [-i]`不过，这些不支持更好的排序控制。

`A`要从一个提交到另一个提交`B`（其中`A`早于`B`）挑选所有提交，请运行：

    git cherry-pick A^..B
    

如果你想_忽略_A 本身，请运行：

    git cherry-pick A..B
    

评论中的注释：

*   `A`应该早于`B`，或者`A`应该来自另一个分支。
*   在 Windows 上，它应该是`A^^..B`因为插入符号需要转义，或者应该是`"A^..B"`（双引号）。
*   在`zsh`shell 中，它应该是`'A^..B'`（单引号），因为插入符号是一个特殊字符。
*   有关说明，请参阅[Gabriel Staples 的回答](https://stackoverflow.com/a/69472178/4561887)。

_（感谢评论中的 damian、JB Rainsberger、sschaef、Neptilo、Pete 和 TMin。）_

如果您有选择性的修订要合并，例如来自 A、B、C、D、E、F、G、H、I、J 提交的 A、C、F、J，只需使用以下命令：

    git cherry-pick A C F J

最简单的方法是`onto`选择`rebase`. 假设当前结束的分支称为 mybranch，并且这是您要移动到的`a`分支。`c``f`

    # checkout mybranch
    git checkout mybranch
    
    # reset it to f (currently includes a)
    git reset --hard f
    
    # rebase every commit after b and transplant it onto a
    git rebase --onto a b

如何挑选单个提交、多个提交或一系列提交
-------------------

**...到您当前签出的分支：**

1\. 挑选一个名为的_分支_或提交`commit`
--------------------------

    git cherry-pick commit
    

例子：

    git cherry-pick my_branch                                 # by branch name
    git cherry-pick 1e038f108a130831f108329b1083a8139813fabc  # by full hash
    git cherry-pick 1e038f10                                  # by partial hash
    

2\. 挑选_多个_提交
------------

请注意，您可以按您想要的任何顺序一次挑选_任意数量的提交哈希值__。_它们只会按照您指定的顺序一次应用一个。如果出现任何冲突，您必须一次解决一个问题，然后在完成后使用`git add my_file`then`git cherry-pick --continue`继续挑选过程。

    git cherry-pick commit1 commit2 commit3 commit4 commit5
    

3\. 挑选_一系列_提交
-------------

[我最初是从@Eric Darchis 在这里获得最多支持的答案中](https://stackoverflow.com/a/3933416/4561887)学习了这种风格的基础知识。

请注意，要挑选一系列_提交_，您必须指定开始和结束提交哈希，以及`..`它们之间的值。但是，在一系列提交中，不包括开始提交。因此，要包含它，您必须在开始提交_之前_指定提交。_指定前面_提交的语法是在提交_之后_放置`~`、`~1`或 ，如： ，这意味着`^`：“之前的提交”。`beginning_commit~``beginning_commit`

    # A. INCLUDING the beginning_commit
    git cherry-pick beginning_commit~..ending_commit
    # OR (same as above)
    git cherry-pick beginning_commit~1..ending_commit
    # OR (same as above)
    git cherry-pick beginning_commit^..ending_commit 
    
    # B. NOT including the beginning_commit
    git cherry-pick beginning_commit..ending_commit
    

_注意：_ `commit~`、`commit~1`和all 表示“_之前的_`commit^`一次提交”，或者换句话说：“之前的提交”。 `commit``commit`

要指定之前的_两次_`commit`提交，您可以使用如下语法：

    commit~~
    commit~2  # my preferred syntax
    commit^^
    

要指定之前的_三个_`commit`提交，您可以执行以下操作：

    commit~~~  
    commit~3   # my preferred syntax
    commit^^^
    

这不起作用：

    commit^3   # INVALID syntax
    

这_确实_有效，但这是一个非常特殊的情况。另请参阅我的问答：[在`git merge`\-style 工作流程中，仅显示合并之前某人在其 PR（拉取请求）功能分支中拥有的唯一提交](https://stackoverflow.com/q/77617436/4561887)：

    # valid on **merge commits** only
    commit^2   # this is the immediate **right** parent of the two parents 
               # involved in the merge (which made commit `commit`)
    
    # valid on any commits (gets the left parent of a merge commit, or 
    # the only parent of a non-merge commit)
    commit~    # and this is the immediate **left** parent of the two 
               # parents involved in the merge (which made commit `commit`)
    

要自己测试上述“先前提交语法”概念，最简单的方法是使用`git log`命令。前任：

    git log commit
    git log commit~
    git log commit~1
    git log commit^
    git log commit~~
    git log commit~5
    # etc.
    

4\. 挑选一系列同行的提交到您的分支上
--------------------

...当他们的分支`peer_branch`从您的分支的早期版本中分叉出来时`my_branch`。

### 快速总结

    # you cherry-pick all of their extra commits from their `peer_branch` onto 
    # your `my_branch` (note: the 3 dots below are very important!)
    
    git fetch origin peer_branch  # get their latest changes from the remote
    git checkout my_branch        # ensure you're on your branch
    # cherry-pick their range of commits
    git cherry-pick my_branch...origin/peer_branch  
    git log                       # review the commits you just chery-picked
    git push                      # push your changes to the remote
    

提交范围内 2 点和 3 点之间的差异非常显着。`git diff branch1...branch2`相当于`git diff $(git merge-base branch1 branch2) branch2`. `branch2`当您想要查看自 偏离 以来所做的更改`branch1`，而不是两个分支在当前状态下的差异时，这非常有用。请参阅此处和[此处](https://stackoverflow.com/questions/1670970/how-to-cherry-pick-multiple-commits/69472178#comment137438679_3933416)[的评论](https://stackoverflow.com/questions/7251477/what-are-the-differences-between-double-dot-and-triple-dot-in-git-dif/7252067#comment112851552_7252067)以及此处的答案：[What are the Differences between double-dot ".." and Triple-dot "..." in Git diff commit Ranges?](https://stackoverflow.com/q/7251477/4561887)[](https://stackoverflow.com/questions/1670970/how-to-cherry-pick-multiple-commits/69472178#comment137438679_3933416)[](https://stackoverflow.com/q/7251477/4561887)

### 完整的详细信息和工作流程演练

假设您正在开发功能分支`my_branch`，而您的同事希望帮助您进行一些更改以帮助您完成功能。您已经推`my_branch`送到名为 的远程`origin`。因此，他们将获取名为`my_branch`其本地计算机的远程分支，从中分叉出自己的名为 的分支`peer_brach`，然后推送到自己名为 的分支`peer_branch`。一旦他们这样做了，你就可以立即挑选他们添加的所有内容。该过程的第一部分如下所示：

    # **your peer** does this
    
    # peer fetches your branch named `my_branch` and forks their `peer_branch`
    # off of it
    
    # they fetch your latest work from remote `my_branch` into their locally-stored
    # remote-tracking "hidden" branch named `origin/my_branch`
    # (note: you can see all locally-stored remote-tracking "hidden" branches
    # with `git branch -r`)
    git fetch origin my_branch
    # create `peer_branch` as a fork off of `origin/my_branch`, and check it out
    git checkout -b peer_branch origin/my_branch
    
    # Now they can add their changes and commits and `git push` to remote `origin`
    # as their own `peer_branch` when done.
    

现在他们已经将所有更改推送到远程`origin`作为他们自己的名为 的分支`peer_branch`，您可以挑选他们添加到您的工作之上的_所有提交，如下所示：_

    # **you** do this to cherry-pick your peer's helpful changes they added to 
    # your work
    
    # you fetch their latest work from their branch named `peer_branch` on remote
    # `origin` into your locally-stored remote-tracking "hidden" branch named 
    # `origin/peer_branch` 
    # (note: you can see all locally-stored remote-tracking "hidden" branches
    # with `git branch -r`)
    git fetch origin peer_branch
    # ensure you are on `my_branch` (if you aren't already)
    git checkout my_branch
    # you cherry-pick all of their extra commits from their `peer_branch` onto 
    # your `my_branch` (note: the 3 dots here are very important!)
    git cherry-pick my_branch...origin/peer_branch
    
    git log                       # review the commits you just chery-picked
    git push                      # push your changes to the remote
    

为了您的理解，`cherry-pick`上面那个带有 3 个点的命令_完全等同_于这个更长的命令：

    git cherry-pick $(git merge-base my_branch origin/peer_branch)..origin/peer_branch
    

该部分查找branch和branch`git merge-base my_branch origin/peer_branch`之间的公共父提交哈希。这是他们从你的你的. 然后，您当然会挑选从该点到 ( ) 的最终提交_的提交范围_。`my_branch``origin/peer_branch``peer_branch``my_branch``..``origin/peer_branch`

要了解有关 3 点语法的更多信息，请参阅此处：[Git diff 提交范围中双点“..”和三点“...”之间的区别是什么？\[复制\]](https://stackoverflow.com/a/7252067/4561887)。有关 的帮助`git checkout -b new_branch from_branch`，请参阅我的答案：[从另一个分支在 git 中创建分支的各种方法](https://stackoverflow.com/a/63418267/4561887)

官方 Git 文档
---------

1.  [https://git-scm.com/docs/gitrevisions](https://git-scm.com/docs/gitrevisions) - 提到 git commit 3 点 ( `...`) 与 2 点范围语法、`^commit`("not" `commit`)、`commit^`( 的父级`commit`) 等。

更进一步
----

1.  还有一点需要知道： a`git rebase`只是一堆连续的`git cherry-pick`s。请参阅我的其他答案（[根据 Git，谁是“我们”，谁是“他们”？](https://stackoverflow.com/a/63911630/4561887)），其中我展示了我制作的 ASCII 绘图，其中显示了 a 的`git rebase`工作原理及其正在执行的操作。
2.  [Git diff 提交范围中的双点“..”和三点“...”有什么区别？\[复制\]](https://stackoverflow.com/a/7252067/4561887)
3.  [我对从另一个分支在 git 中创建分支的各种方法的](https://stackoverflow.com/a/63418267/4561887)回答[](https://stackoverflow.com/a/63418267/4561887)
4.  我的问答：[在`git merge`风格的工作流程中，仅显示合并之前某人在其 PR（拉取请求）功能分支中的唯一提交](https://stackoverflow.com/q/77617436/4561887)

或者所要求的一行：

    git rebase --onto a b f

How to cherry pick multiple commits

要为特定的 Git 提交生成补丁，你可以使用 `git format-patch` 命令。以下是一些常见的用法：

1. **生成最近的一个提交的补丁：**

   ```sh
   git format-patch -1
   ```

   `-1` 指的是最近的一个提交（HEAD）。这将会生成一个以提交哈希开始，后面跟着提交信息的`.patch`文件。

2. **生成特定提交的补丁：**

   首先，你需要知道提交的哈希值。可以使用 `git log` 查看提交历史并找到你想要生成补丁的特定提交的哈希值。然后使用：

   ```sh
   git format-patch -1 <commit-hash>
   ```

   替换 `<commit-hash>` 为实际的提交哈希值。

3. **生成一系列提交的补丁：**

   如果你想要生成一系列提交（比如说，从某个特定的提交开始到最新的提交），你可以这样做：

   ```sh
   git format-patch <commit-hash>^..
   ```

   这里 `<commit-hash>` 是序列中第一个提交的哈希值，`^` 表示该提交的父提交，两个点 `..` 表示到当前分支的最新提交。

4. **生成一个范围内所有提交的补丁：**

   如果你想要获取两个提交之间的所有补丁，可以使用：

   ```sh
   git format-patch <start-commit-hash>..<end-commit-hash>
   ```

   这会为从 `<start-commit-hash>` 到 `<end-commit-hash>` （不包含 `<start-commit-hash>`）之间的每一个提交生成一个补丁文件。

每个生成的补丁文件将包含一个单独提交的完整内容，这些文件可以应用到另一个仓库中，或者用于代码审查和其他目的。这些文件通常是以邮件的形式发送给其他开发者或者通过某些项目管理工具来共享。

尝试：

    git format-patch -<n> <rev>

例如：

    git format-patch -1 HEAD
    

该`-1`标志指示补丁中应包含多少提交：

> \-<n>
> 
>      从最上面的 <n> 次提交中准备补丁。

* * *

使用以下命令应用补丁：

    git am < file.patch
    

或者，您也可以通过以下方式申请（应该适用于包括 Windows 在内的所有操作系统）：

    git apply --verbose file.patch
    

或将显示失败的内容（如果有）`-v`。`--verbose`为您提供有关如何修复的线索。

用于从特定 SHA-1 哈希的最顶层 <n> 提交生成补丁：

    git format-patch -<n> <SHA-1> --stdout > <name_of_patch_file>.patch
    

单个补丁文件中头部的最后 10 个补丁：

    git format-patch -10 HEAD --stdout > 0001-last-10-commits.patch

假设您在提交 1 之后提交了提交 ID 2，您可以运行：

    git diff 2 1 > mypatch.diff
    

其中 2 和 1 是 SHA-1 哈希值。

这个命令（正如[@ _Naftuli Tzvi Kay_](https://stackoverflow.com/questions/6658313/generate-a-git-patch-for-a-specific-commit#comment21730708_6658352)已经建议的那样），

    git format-patch -1 HEAD
    

替换`HEAD`为特定的哈希或范围。

将为最新提交生成补丁文件，其格式类似于 Unix 邮箱格式。

> `-<n>`\- 从最上面的 <n> 次提交中准备补丁。

然后您可以通过以下方式以邮箱格式重新应用补丁文件：

    git am -3k 001*.patch
    

看：[`man git-format-patch`](http://linux.die.net/man/1/git-format-patch)。

git format-patch commit_Id~1..commit_Id  
    git apply patch-file-name
    

快速而简单的解决方案。

How can i generate a git patch for a specific commit?

当您想要从Git存储库中彻底删除某个目录时，您应该遵循以下步骤：

1. **删除本地目录**：
   首先，在您的本地工作副本中，您需要使用文件系统命令来删除目录。例如，在UNIX系统上，您可以使用`rm -rf`命令：

   ```sh
   rm -rf <directory_name>
   ```

2. **将更改暂存到Git**：
   删除了目录后，您需要告诉Git这个变化。为此，您应该使用`git add`命令将删除操作暂存起来，使用带有`-A`选项，该选项告诉Git考虑所有变化（包括文件删除）：

   ```sh
   git add -A
   ```

   或者，您可以只暂存已删除的目录：

   ```sh
   git add <directory_name>
   ```

3. **提交更改**：
   接下来，您需要提交您的更改。提交时应该提供一个合适的消息，说明您进行了哪些更改：

   ```sh
   git commit -m "Remove <directory_name> from the repository"
   ```

4. **从历史记录中删除**：
   如果目录在之前的历史记录中不存在，直接提交即可。但如果您希望从历史记录中彻底删除目录（例如，它可能包含敏感数据），您将需要使用更高级的工具，比如`git filter-branch`或`BFG Repo-Cleaner`。

    使用`filter-branch`：
   ```sh
   git filter-branch --force --index-filter \
   "git rm --cached --ignore-unmatch -r <directory_name>" \
   --prune-empty --tag-name-filter cat -- --all
   ```

   使用`BFG Repo-Cleaner`（一个更快且更容易使用的工具）：
   ```sh
   bfg --delete-folders <directory_name> --no-blob-protection
   ```

   请注意，这些操作会重写您的Git历史记录，这可能对其他人的存储库副本产生影响。这种操作应该非常小心地进行，并且确保团队中的每个人都了解这一点。

5. **推送更改到远程仓库**：
   一旦您提交了更改（并且如果需要，也清理了历史记录），您需要推送这些更改到远程仓库。如果您修改了历史记录，您可能需要使用`--force`（或者在Git 2.0和以上版本中使用`--force-with-lease`）来推送您的更改：

   ```sh
   git push origin --force --all
   ```

   如果您未修改历史记录，正常的推送命令就足够了：

   ```sh
   git push origin
   ```

请记住，在执行这样的操作时，团队中的每个成员都需要知道变更，因为这将影响他们的本地存储库。如果他们有基于被删除目录的未合并工作，可能会遇到冲突。

#### 从 Git 和本地删除目录

检查两个目录的“master”：

    git rm -r one-of-the-directories // This deletes from filesystem
    git commit . -m "Remove duplicated directory"
    git push origin <your-git-branch> (typically 'master', but not always)
    

#### 从 Git 中删除目录，但不是本地目录

要从 Git 中删除此目录，但不将其从文件系统（本地）中完全删除：

    git rm -r --cached myFolder

### 要仅从 git 存储库而不是从本地删除文件夹/目录，请尝试 3 个简单的命令。

* * *

**删除目录的步骤**

    git rm -r --cached FolderName
    git commit -m "Removed folder from repository"
    git push origin master
    

* * *

**在下次提交中忽略该文件夹的步骤**

> 要在下一次提交中忽略该文件夹，请在根文件夹（初始化 git 的主项目目录）中创建一个名为**.gitignore**的文件 ，并将该文件夹名称放入其中。您可以忽略任意数量的文件/文件夹

**.gitignore**文件将如下所示

    /FolderName
    

* * *

![删除目录](https://i.stack.imgur.com/mJYfF.png)

如果由于某种原因，karmakaze 所说的不起作用，您可以尝试使用文件系统浏览器（例如，在 Windows 文件资源管理器中）删除想要的目录。删除目录后，发出命令：  
`git add -A`  
and then  
`git commit -m 'deleting directory'`  
和 then  
`git push origin master`。

我之前已经提交了该文件夹，并且也想删除历史记录中的目录。

我做了以下事情：

将文件夹添加到`.gitignore`：

    echo Folder_Name/ >> .gitignore
    

从所有提交中删除：

    git filter-branch --index-filter 'git rm -rf --cached --ignore-unmatch Folder_Name/' --prune-empty --tag-name-filter cat -- --all
    

从旧提交中删除引用：

    git for-each-ref --format="%(refname)" refs/original/ | xargs -n 1 git update-ref -d
    

确保所有旧的引用被完全删除

    rm -Rf .git/logs .git/refs/original
    

执行垃圾收集

    git gc --prune=all --aggressive
    

将您的更改推送到在线存储库：

    git push
    

你已经完成了。

但是您可以使用以下命令将所有更改推送到所有分支：但是要小心这个命令！

    git push origin --all --force
    git push origin --tags --force
    

之后该文件夹已从 git 中删除，但并未从本地磁盘中删除。

你可以试试这个： **`git rm -rf <directory_name>`**

它将强制删除该目录。

How do i remove a directory from a git repository

要查看仅包含一个用户提交的git日志，您可以使用`git log`命令，并配合`--author`选项来指定作者名字。这样，Git 将会筛选出所有匹配指定作者名字的提交记录。命令的基本格式如下：

```bash
git log --author="用户名"
```

请将`"用户名"`替换为您想要查看提交记录的用户的真实姓名或邮箱地址的一部分。Git会展示出所有匹配该用户名片段的提交。

例如，如果您想要查看由用户John Doe提交的所有日志，您可以运行：

```bash
git log --author="John Doe"
```

如果您已知用户的电子邮箱，并且想要更精确地过滤，可以这样写：

```bash
git log --author=johndoe@example.com
```

此外，如果你想要的搜索更加精细化，可以使用正则表达式：

```bash
git log --author="^John"
```

上面的命令将会显示所有名字以"John"开头的作者的提交。

**例子：**

假设我参与了一个名为`example-project`的项目，并对这个项目做了很多贡献。项目经理想要查看我所有的提交记录，我的Git用户名是`Alex`。项目经理可以在项目的根目录打开终端或命令提示符，然后输入以下命令：

```bash
git log --author="Alex"
```

这将输出所有我作为作者的提交，包括提交哈希、提交信息、日期和时间等详细信息。项目经理可以通过这些信息来分析我的工作量和贡献内容。

这适用于 gitk `git log`和[gitk——](https://git-scm.com/docs/gitk)查看历史记录的两种最常见的方式。
您不需要使用全名：

```
git log --author="Jon"
```

将匹配“Jonathan Smith”所做的提交

```
git log --author=Jon
```

和

```
git log --author=Smith
```

也会起作用。如果不需要任何空格，引号是可选的。

**`--all`如果您打算搜索存储库中的所有分支而不仅仅是当前提交的祖先，请添加。**

还可以轻松匹配多个作者，因为正则表达式是此过滤器的基础机制。

因此，要列出 Jonathan 或 Adam 的提交，您可以这样做：

```
git log --author="$Adam$\|$Jon$"
```

为了使用[本问题中](https://stackoverflow.com/questions/406230/regular-expression-to-match-string-not-containing-a-word)提到的正则表达式排除特定作者或一组作者的提交，您可以将[负向前瞻](http://www.regular-expressions.info/lookaround.html)与开关结合使用 `--perl-regexp`：

```
git log --author='^(?!Adam|Jon).*$' --perl-regexp
```

或者，您可以通过使用和管道排除 Adam 创作的提交 `bash`：

```
git log --format='%H %an' | 
  grep -v Adam | 
  cut -d ' ' -f1 | 
  xargs -n1 git log -1
```

如果您想排除 Adam 提交的（但不一定是创作的）提交，请替换 `%an`为 `%cn`.

github上还有一个_秘密_方法...

您可以通过附加 param 在提交视图中按作者过滤提交`?author=github_handle`。例如，链接[https://github.com/dynjs/dynjs/commits/master?author=jingweno](https://github.com/dynjs/dynjs/commits/master?author=jingweno)显示了 Dynjs 项目的提交列表

```
git help log
```

显示 git log 的联机帮助页。按 / 搜索“author”，然后输入“author”，然后按 Enter。键入“n”几次即可进入相关部分，其中显示：

```
git log --author="username"
```

请注意，这将为您提供提交的作者，但在 Git 中，作者可以是与提交者不同的人。

```bash
git log --author="username" --pretty=format:"%h - %an, %ar : %s"
```

How can i view a git log of just one users commits?

当您要查询当前计算机上Git的全部全局配置时，您可以使用以下Git命令：

```bash
git config --global --list
```

这个命令会列出所有的全局配置，这些配置位于用户主目录下的`.gitconfig`文件中。例如，它可以显示用户的姓名和邮箱配置、差异检查工具、别名等全局设置。如果您想要看到某个特定的全局配置，可以使用以下命令：

```bash
git config --global user.name
git config --global user.email
```

这些命令分别会显示全局配置中设置的用户姓名和邮箱。

举个例子，如果我在我的机器上进行了一些全局设置，配置了我的用户名和邮箱，并为常用的命令设置了别名，那么执行 `git config --global --list` 命令后可能会得到如下输出：

```plaintext
user.name=John Doe
user.email=johndoe@example.com
alias.st=status
alias.co=checkout
alias.br=branch
alias.ci=commit
```

在这个输出中，我们可以看到用户的姓名是"John Doe"，邮箱是"johndoe@example.com"，并且设置了几个命令别名，比如用`st`代替`status`，用`co`代替`checkout`等。

您可以使用：

    git config --list
    

或者查看你的`~/.gitconfig`文件。本地配置将位于存储库的`.git/config`文件中。

使用：

    git config --list --show-origin
    

查看该设置的定义位置（全局、用户、存储库等...）

最短的，

    git config -l
    

显示所有继承的值：系统、全局和本地

> 如何编辑我的**全局**Git 配置？

简短回答：`git config --edit --global`

* * *

要了解 Git 配置，您应该知道：

> Git 配置变量可以存储在三个不同的级别。每个级别都会覆盖前一个级别的值。
> =====================================

**1.系统级别（适用于系统上的每个用户及其所有存储库）**

*   查看，`git config --list --system`（可能需要`sudo`）
*   设置，`git config --system color.ui true`
*   编辑系统配置文件，`git config --edit --system`

**2\. 全局级别（您（用户）个人特定的值）。**

*   查看，`git config --list --global`
*   设置，`git config --global user.name xyz`
*   编辑全局配置文件，`git config --edit --global`

**3\. 存储库级别（特定于该单个存储库）**

*   查看，`git config --list --local`
*   设置，`git config --local core.ignorecase true`（`--local`可选）
*   编辑存储库配置文件，`git config --edit --local`（`--local`可选）

> 如何查看**所有**设置？
> =============

*   运行`git config --list`，显示**系统**、**全局**和（如果在存储库内）**本地**配置
*   Run `git config --list --show-origin`，还显示每个配置项的原始文件

> 如何读取一项特定配置？
> ===========

*   例如，运行`git config user.name`以获取。`user.name`
*   您还可以指定选项`--system`, `--global`,`--local`来读取特定级别的该值。

* * *

参考：_[1.6 入门 - 首​​次 Git 设置](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup)_

git config --list
    

是一种方法。不过我通常只是敞开心扉`.gitconfig`。

从 Git [2.26.0](https://github.com/git/git/blob/v2.26.0/Documentation/RelNotes/2.26.0.txt)开始，您可以使用[`--show-scope`](https://github.blog/2020-03-22-highlights-from-git-2-26/#some-new-config-tricks)选项：

    git config --list --show-scope
    

输出示例：

    system  rebase.autosquash=true
    system  credential.helper=helper-selector
    global  core.editor='code.cmd' --wait -n
    global  merge.tool=kdiff3
    local   core.symlinks=false
    local   core.ignorecase=true
    

它可以与

*   `--local`用于项目配置、 `--global`用于用户配置、 `--system`用于所有用户配置
*   `--show-origin`显示确切的配置文件位置

How do i show my global git configuration

当您想要在 Git 的代码历史中搜索特定的关键词或模式时，可以使用 `git grep` 配合 `git log` 的一些参数来实现。以下是实现这个目的的一个基本步骤：

1. **使用 `git grep` 搜索工作目录中的内容：**

   若您只是想搜索当前工作目录中的文件，可以直接使用 `git grep` 命令。例如：

   ```shell
   git grep '搜索关键字'
   ```

2. **搜索历史提交中的内容：**

   如果您想搜索历史提交中的内容，可以使用 `git log` 的 `-p` 参数和 `grep` 命令组合起来。例如，搜索历史提交中包含“搜索关键字”的内容：

   ```shell
   git log -p -S'搜索关键字'
   ```

   这里的 `-p` 参数会显示每个提交的差异（即代码更改），而 `-S` 参数用于指定要搜索的字符串。`-S` 会查找添加或删除了指定字符串的那些提交。

3. **结合使用 `git log` 和外部的 `grep` 命令：**

   您也可以通过管道将 `git log` 的输出传递给外部的 `grep` 命令，这样可以利用 `grep` 的强大搜索能力。例如：

   ```shell
   git log -p | grep '搜索关键字'
   ```

   如果您想要更具体的信息，比如显示匹配到关键字的提交哈希，可以通过添加额外的参数来实现。例如：

   ```shell
   git log -p | grep -B 4 '搜索关键字'
   ```

   这里 `-B 4` 表示除了显示匹配行之外，还会显示匹配行之前的四行，这通常包括了提交信息。

4. **使用 `git log -G` 进行正则表达式搜索：**

   如果要进行更复杂的搜索，可以使用 `-G` 参数，后面跟上正则表达式：

   ```shell
   git log -p -G'regex'
   ```

5. **限定搜索的文件范围：**

   如果您只对特定类型的文件或特定的文件路径进行搜索，可以在 `git grep` 命令中指定文件路径或模式。例如，只搜索所有 `.c` 文件：

   ```shell
   git grep '搜索关键字' -- '*.c'
   ```

6. **搜索特定分支或标签中的内容：**

   如果您想搜索特定分支或标签中的内容，可以在 `git grep` 命令中指定分支或标签名。例如，在名为“feature-branch”的分支中搜索：

   ```shell
   git grep '搜索关键字' feature-branch
   ```

通过以上步骤，您可以灵活地搜索 Git 历史中的代码。记得替换 `'搜索关键字'` 和 `'regex'` 为您实际想要搜索的内容。

要搜索提交_内容_（即实际的源代码行，而不是提交消息等），您需要执行以下操作：

    git grep <regexp> $(git rev-list --all)
    

`git rev-list --all | xargs git grep <expression>`如果您遇到“参数列表太长”错误，它将起作用。

如果您想将搜索限制在某个子树（例如“lib/util”），您需要将其传递给子`rev-list`命令，`grep`并且：

    git grep <regexp> $(git rev-list --all -- lib/util) -- lib/util
    

这将 grep 遍历您的所有提交文本`regexp`。

在两个命令中传递路径的原因是因为`rev-list`将返回发生所有更改的修订列表`lib/util`，但您还需要传递 to`grep`以便它只在`lib/util`.

想象一下以下场景：可能会在返回的同一修订版中包含的其他文件上`grep`找到相同的内容（即使该修订版上的该文件没有更改）。`<regexp>``rev-list`

以下是搜索来源的一些其他有用方法：

在工作树中搜索与正则表达式 regexp 匹配的文本：

    git grep <regexp>
    

在工作树中搜索与正则表达式 regexp1 或 regexp2 匹配的文本行：

    git grep -e <regexp1> [--or] -e <regexp2>
    

在工作树中搜索与正则表达式 regexp1 和 regexp2 匹配的文本行，仅报告文件路径：

    git grep -l -e <regexp1> --and -e <regexp2>
    

在工作树中搜索具有与正则表达式 regexp1 匹配的文本行和与正则表达式 regexp2 匹配的文本行的文件：

    git grep -l --all-match -e <regexp1> -e <regexp2>
    

在工作树中搜索已更改的文本匹配模式行：

    git diff --unified=0 | grep <pattern>
    

搜索所有修订版本以查找与正则表达式 regexp 匹配的文本：

    git grep <regexp> $(git rev-list --all)
    

搜索 rev1 和 rev2 之间的所有修订版本以查找与正则表达式 regexp 匹配的文本：

    git grep <regexp> $(git rev-list <rev1>..<rev2>)

您应该使用 的[pickaxe ( `-S`)](https://git-scm.com/docs/git-log#Documentation/git-log.txt--Sltstringgt)选项[`git log`](http://git-scm.com/docs/git-log)。

要搜索`Foo`：

    git log -SFoo -- path_containing_change
    git log -SFoo --since=2009.1.1 --until=2010.1.1 -- path_containing_change
    

有关更多信息，请参阅[Git 历史记录 - 按关键字查找丢失的行。](https://stackoverflow.com/questions/2839253/git-history-find-lost-line-by-keyword/2839319#2839319)

`-S`（名为`pickaxe`）最初来自一个[`git diff`选项](https://github.com/git/git/commit/52e9578985fb636ec1d3f6cf794fdadd5ec896fc)（Git v0.99，2005 年 5 月）。然后`-S`( `pickaxe`)于 2006 年 5 月用 Git 1.4.0-rc1[移植到。`git log`](https://github.com/git/git/commit/582af688157607f05447cefce8d91b26eeaee39d)

* * *

正如[雅库布·纳伦布斯基 (Jakub Narębski)](https://stackoverflow.com/users/46058/jakub-narebski)评论的那样：

*   这**会查找引入或删除 实例的差异`<string>`**。它通常意味着“添加或删除带有‘Foo’的行的修订”。
    
*   该`--pickaxe-regex`选项允许您使用扩展的 POSIX 正则表达式而不是搜索字符串。示例（来自[`git log`](https://git-scm.com/docs/git-log#Documentation/git-log.txt--Gltregexgt)）：`git log -S"frotz\(nitfol" --pickaxe-regex`
    

* * *

正如[Rob](https://stackoverflow.com/users/601626/rob)评论的那样，此搜索区分大小写 - 他提出了有关如何搜索不区分大小写的[后续问题。](https://stackoverflow.com/questions/25384842/case-insensitive-git-pickaxe-search)

* * *

[嗨天使在](https://stackoverflow.com/users/2388257/hi-angel)[评论](https://stackoverflow.com/questions/2928584/how-to-grep-search-committed-code-in-the-git-history/2928721#comment131608633_2928721)中指出：

> 执行 a `git log -G<regexp> --branches --all`（与正则表达式`-G`相同）与[接受的执行](https://stackoverflow.com/a/2929502/6309)( ) 执行相同的操作，但速度快得多！`-S`[](https://stackoverflow.com/a/2929502/6309)`git grep <regexp> $(git rev-list --all)`
> 
> 接受的答案在我运行约 10 分钟后仍在搜索文本，而这个答案在约 4 秒后给出结果🤷‍♂️。这里的输出也更有用

我最喜欢的方法是使用`git log`'s`-G`选项（在版本 1.7.4 中添加）。

    -G<regex>
           Look for differences whose added or removed line matches the given <regex>.
    

`-G`和`-S`选项确定提交是否匹配的方式之间存在细微差别：

*   该`-S`选项本质上是计算提交之前和之后您的搜索在文件中匹配的次数。如果之前和之后的计数不同，则提交会显示在日志中。例如，这不会显示与您的搜索匹配的行被移动的提交。
*   使用该`-G`选项，如果您的搜索与添加、删除或更改的任何行匹配，则提交将显示在日志中。

以这次提交为例：

    diff --git a/test b/test
    index dddc242..60a8ba6 100644
    --- a/test
    +++ b/test
    @@ -1 +1 @@
    -hello hello
    +hello goodbye hello
    

因为在这次提交之前和之后文件中出现“hello”的次数是相同的，所以使用`-Shello`. 但是，由于匹配的行发生了更改`hello`，因此将使用 来显示提交`-Ghello`。

`git log`可以是跨所有分支搜索文本的更有效方法，特别是如果有很多匹配项，并且您希望首先查看更新的（相关）更改。

    git log -p --all -S 'search string'
    git log -p --all -G 'match regular expression'
    

这些日志命令列出添加或删除给定搜索字符串/正则表达式的提交，（通常）首先是最近的。该`-p`选项会导致在添加或删除模式的位置显示相关差异，以便您可以在上下文中查看它。

找到添加您要查找的文本的相关提交（例如 8beeff00d）后，找到包含该提交的分支：

    git branch -a --contains 8beeff00d

如果您想浏览代码更改（查看整个历史记录中给定单词实际更改的内容），请选择`patch`模式 - 我发现了一个非常有用的组合：

    git log -p
    # Hit '/' for search mode.
    # Type in the word you are searching.
    # If the first search is not relevant, hit 'n' for next (like in Vim ;) )

Git 的代码历史中搜索特定的关键词或模式时，可以使用 `git grep` 配合 `git log` 的一些参数来实现。以下是实现这个目的的一个基本步骤： 

1. **使用 `git grep` 搜索工作目录中的内容：**

   若您只是想搜索当前工作目录中的文件，可以直接使用 `git grep` 命令。例如：

   ```shell
   git grep '搜索关键字'
   ```
2. **搜索历史提交中的内容：**

   如果您想搜索历史提交中的内容，可以使用 `git log` 的 `-p` 参数和 `grep` 命令组合起来。例如，搜索历史提交中包含“搜索关键字”的内容：

   ```shell
   git log -p -S'搜索关键字'
   ```

   这里的 `-p` 参数会显示每个提交的差异（即代码更改），而 `-S` 参数用于指定要搜索的字符串。`-S` 会查找添加或删除了指定字符串的那些提交。
3. **结合使用 `git log` 和外部的 `grep` 命令：**

   您也可以通过管道将 `git log` 的输出传递给外部的 `grep` 命令，这样可以利用 `grep` 的强大搜索能力。例如：

   ```shell
   git log -p | grep '搜索关键字'
   ```

   如果您想要更具体的信息，比如显示匹配到关键字的提交哈希，可以通过添加额外的参数来实现。例如：

   ```shell
   git log -p | grep -B 4 '搜索关键字'
   ```

   这里 `-B 4` 表示除了显示匹配行之外，还会显示匹配行之前的四行，这通常包括了提交信息。
4. **使用 `git log -G` 进行正则表达式搜索：**

   如果要进行更复杂的搜索，可以使用 `-G` 参数，后面跟上正则表达式：

   ```shell
   git log -p -G'regex'
   ```
5. **限定搜索的文件范围：**

   如果您只对特定类型的文件或特定的文件路径进行搜索，可以在 `git grep` 命令中指定文件路径或模式。例如，只搜索所有 `.c` 文件：

   ```shell
   git grep '搜索关键字' -- '*.c'
   ```
6. **搜索特定分支或标签中的内容：**

   如果您想搜索特定分支或标签中的内容，可以在 `git grep` 命令中指定分支或标签名。例如，在名为“feature-branch”的分支中搜索：

   ```shell
   git grep '搜索关键字' feature-branch
   ```

通过以上步骤，您可以灵活地搜索 Git 历史中的代码。记得替换 `'搜索关键字'` 和 `'regex'` 为您实际想要搜索的内容。

How to grep search through committed code in the git history

在Git中，我们可以通过在命令行使用`git log`命令的不同参数来打印一个漂亮的分支图。这里有几种方法：

### 基本分支图

最简单的分支图可以使用如下命令生成：

```sh
git log --graph --oneline --all
```

- `--graph` 参数会显示ASCII图形表示的分支图。
- `--oneline` 参数将每个提交放在一行显示，这样的输出更为紧凑。
- `--all` 参数显示所有的分支，而不只是当前分支。

### 带有更多信息的分支图

如果你希望在分支图中显示更多信息，比如提交者的名字和提交的日期，可以使用：

```sh
git log --graph --oneline --all --decorate
```

- `--decorate` 参数会添加指向分支名、标签等的指针。

### 定制化的分支图

你还可以使用`--pretty=format:`来定制输出格式。例如：

```sh
git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --all
```

- 格式字符串可以定制颜色、提交哈希、分支名、提交信息、提交日期和作者等信息的显示方式。
- `%Cred`, `%Creset`, `%C(yellow)`, 等命令用于定制颜色。
- `%h` 显示缩略的提交哈希。
- `%d` 显示装饰器（分支名、标签）。
- `%s` 显示提交信息。
- `%cr` 显示相对时间（比如，“3 days ago”）。
- `%an` 显示作者名字。
- `--abbrev-commit` 缩短哈希长度。

### 使用别名

因为这些命令可能会变得很长，所以你可能想要在Git中为它们设置别名。例如，设置一个叫做`graph`的别名：

```sh
git config --global alias.graph "log --graph --oneline --all --decorate"
```

这样，以后你就可以简单地使用`git graph`来打印漂亮的分支图了。

### 示例

下面是一个直观的例子，展示了当你在具有几个分支的仓库中使用命令`git log --graph --oneline --all --decorate`时，可能会得到的输出：

```sh
*   e2a6f7b (HEAD -> master, origin/master, origin/HEAD) Merge pull request #2 from feature/xyz
|\  
| * 4e5c111 (feature/xyz) Added XYZ feature
| * 5f4e3d2 Improved XYZ feature
* | 9c0f3f9 Modified README
|/  
* c1f2e9e Initial commit
```

这是一个简单的树形结构，它将显示提交的顺序和分支之间的关系。每个`*`和`|`字符构成ASCII艺术，代表提交和分支。最左边的线表示当前分支的直接历史，而右边的线则代表其他分支的提交。

_更新：我已经针对_[Git](https://stackoverflow.com/questions/1838873/visualizing-branch-topology-in-git/34467298#34467298)_问题中的可视化分支拓扑发布了此答案的改进版本，因为它在那里更合适。出于历史（和代表，我承认）原因留下这个答案，尽管我真的很想删除它。_

**我的两分钱**：我通常在`~/.gitconfig`文件中放入两个别名：

    [alias]
    lg1 = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(auto)%d%C(reset)' --all
    lg2 = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold cyan)%aD%C(reset) %C(bold green)(%ar)%C(reset)%C(auto)%d%C(reset)%n''          %C(white)%s%C(reset) %C(dim white)- %an%C(reset)'
    lg = lg1
    

`git lg`/`git lg1`看起来像这样： ![git lg1](https://i.stack.imgur.com/K6RFN.png)

看起来`git lg2`像这样： ![git LG2](https://i.stack.imgur.com/39dMf.png)

* * *

（注意：这个问题现在有更多适用的答案，例如[fracz](https://stackoverflow.com/questions/1057564/pretty-git-branch-graphs/9074343#24107223)、[Jubos](https://stackoverflow.com/questions/1057564/pretty-git-branch-graphs/9074343#25468472)或[Harry Lee](https://stackoverflow.com/questions/1057564/pretty-git-branch-graphs/9074343#21116867)！）

这里的许多答案都很好，但对于那些只想要一个简单的一行到点答案而无需设置别名或任何额外内容的人来说，这里是：

    git log --all --decorate --oneline --graph
    

不是每个人都会`git log`一直这样做，但是当你需要它时，请记住：

> “**一只狗**” = git log -- **a** ll -- **d** ecorate -- **o** neline -- **graph**

[![在此输入图像描述](https://i.stack.imgur.com/ElVkf.jpg)](https://i.stack.imgur.com/ElVkf.jpg)

如果您输入

    git config --global alias.adog "log --all --decorate --oneline --graph"
    

在命令提示符下一次，您可以使用

    git adog
    

即使您关闭并重新打开它，也不会出现该提示。

对于文本输出，您可以尝试：

```
git log --graph --abbrev-commit --decorate --date=relative --all
```

或者：

```
git log --graph --oneline --decorate --all
```

或者：[这是](https://git.wiki.kernel.org/index.php/Aliases#Use_graphviz_for_display)用于绘制[DAG图的](https://en.wikipedia.org/wiki/Directed_acyclic_graph)[Graphviz](https://en.wikipedia.org/wiki/Graphviz)别名。[](https://en.wikipedia.org/wiki/Directed_acyclic_graph)

[Gitgraph.js](https://github.com/nicoespeon/gitgraph.js/)允许在没有存储库的情况下绘制漂亮的 Git 分支。只需编写一段 JavaScript 代码来配置您的分支并提交并在浏览器中呈现它。提供[交互式文档。](https://www.nicoespeon.com/gitgraph.js)

    var gitGraph = new GitGraph({
       template: "blackarrow",
       mode: "compact",
       orientation: "horizontal",
       reverseArrow: true
    });
    
    var master = gitGraph.branch("master").commit().commit();
    var develop = gitGraph.branch("develop").commit();
    master.commit();
    develop.commit().commit();
    develop.merge(master);
    

![使用 Gitgraph.js 生成的示例图](https://i.stack.imgur.com/OLmxz.png)

或者使用`metro`模板：

![GitGraph.js 地铁主题](https://i.stack.imgur.com/eE8dd.png)

或者使用提交消息、作者和标签：

![带有提交消息的 GitGraph](https://i.stack.imgur.com/k5Gdu.png)

[使用JSFiddle](http://jsfiddle.net/fracz/q76vj8ow/)进行测试。

[使用 @bsara 的Git Grapher](http://bsara.github.io/git-grapher/)生成它。

[构建在TikZ 和 PGF](http://www.ctan.org/pkg/pgf)之上，[`gitdags`](https://github.com/Jubobs/gitdags)是一个小型 LaTeX 软件包，可让您轻松生成矢量图形提交图等。

自动生成现有存储库的提交图_不是_目的[`gitdags`](https://github.com/Jubobs/gitdags)；它生成的图表仅用于_教育目的_。

我经常使用它来生成 Git 问题答案的图表，作为 ASCII 提交图的替代方案：

*   [如何在 master 上进行错误修复并将其集成到我不太稳定的分支中？](https://stackoverflow.com/questions/25933056/how-can-i-do-a-bugfix-on-master-and-integrate-it-into-my-less-stable-branches/25934341#25934341)
*   [git commit --amend 到底是如何工作的？](https://stackoverflow.com/questions/26050327/how-does-git-commit-amend-work-exactly/26050416#26050416)
*   [为什么在我运行“git checkout origin/<branch>”后，Git 告诉我“当前不在任何分支上”？](https://stackoverflow.com/questions/25670173/why-does-git-tell-me-not-currently-on-any-branch-after-i-run-git-checkout-ori/25670296#25670296)
*   [将master合并到分支和将分支合并到master有什么区别？](https://stackoverflow.com/questions/26384166/what-is-the-difference-between-merging-master-into-branch-and-merging-branch-int/26384695#26384695)
*   [Git rebase --preserve-merges 失败](https://stackoverflow.com/questions/25670519/git-rebase-preserve-merges-fails/25671230#25671230)

下面是一个此类图表的示例，展示了简单变基的效果：

![在此输入图像描述](https://i.stack.imgur.com/Tg7Kn.png)

    \documentclass{article}
    
    \usepackage{subcaption}
    \usepackage{gitdags}
    
    \begin{document}
    
    \begin{figure}
      \begin{subfigure}[b]{\textwidth}
        \centering
        \begin{tikzpicture}
          % Commit DAG
          \gitDAG[grow right sep = 2em]{
            A -- B -- { 
              C,
              D -- E,
            }
          };
          % Tag reference
          \gittag
            [v0p1]       % node name
            {v0.1}       % node text
            {above=of A} % node placement
            {A}          % target
          % Remote branch
          \gitremotebranch
            [origmaster]    % node name
            {origin/master} % node text
            {above=of C}    % node placement
            {C}             % target
          % Branch
          \gitbranch
            {master}     % node name and text 
            {above=of E} % node placement
            {E}          % target
          % HEAD reference
          \gitHEAD
            {above=of master} % node placement
            {master}          % target
        \end{tikzpicture}
        \subcaption{Before\ldots}
      \end{subfigure}
    
      \begin{subfigure}[b]{\textwidth}
        \centering
        \begin{tikzpicture}
          \gitDAG[grow right sep = 2em]{
            A -- B -- { 
              C -- D' -- E',
              {[nodes=unreachable] D -- E },
            }
          };
          % Tag reference
          \gittag
            [v0p1]       % node name
            {v0.1}       % node text
            {above=of A} % node placement
            {A}          % target
          % Remote branch
          \gitremotebranch
            [origmaster]    % node name
            {origin/master} % node text
            {above=of C}    % node placement
            {C}             % target
          % Branch
          \gitbranch
            {master}      % node name and text 
            {above=of E'} % node placement
            {E'}          % target
          % HEAD reference
          \gitHEAD
            {above=of master} % node placement
            {master}          % target
        \end{tikzpicture}
        \subcaption{\ldots{} and after \texttt{git rebase origin/master}}
      \end{subfigure}
      \caption{Demonstrating a typical \texttt{rebase}}
    \end{figure}
    
    \end{document}

How to output pretty git branch graphs?

如果在使用`git reset`时发生了错误，或者后来决定撤销此操作，可以通过以下方法恢复：

1. **使用`reflog`找到之前的HEAD位置：**
   
   在Git中，`reflog`记录了本地仓库头部（HEAD）的变动，包括分支切换和重置操作。首先可以通过`git reflog`查看最近的提交历史和HEAD的变动。

   ```bash
   git reflog
   ```
   
   这将显示一系列的操作，例如：

   ```
   1a410ef HEAD@{0}: reset: moving to HEAD^
   ab1afef HEAD@{1}: commit: a new commit message
   ...
   ```

   在这个例子中，`HEAD@{1}`表示`git reset`操作之前的HEAD位置。

2. **重置到`git reset`操作之前的提交：**
   
   使用`reflog`找到想要恢复的点后，可以通过`git reset`命令将HEAD重置到那个点。如果我们想要恢复到上面例子中的`HEAD@{1}`，可以执行：

   ```bash
   git reset --hard HEAD@{1}
   ```

   这会将当前的HEAD、索引和工作目录重置到`HEAD@{1}`的状态。

请注意，`--hard`选项会使工作目录中的所有未提交的更改丢失。如果想保留这些更改，可以使用`--soft`或者`--mixed`选项，具体选择取决于你想要的更改保留级别：

- `--soft`：重置HEAD到指定提交，但保留暂存区和工作目录。
- `--mixed`（默认）：重置HEAD和暂存区到指定提交，工作目录的更改将保留但不会暂存。

**例子：**

假设我不小心将我的HEAD重置到了两次提交之前，失去了我最近的工作。我可以这样恢复：

1. 查看`reflog`以找到最近的提交记录：

   ```bash
   git reflog
   ```

2. 假设输出显示我想要恢复的提交是`abc1234`，我可以执行：

   ```bash
   git reset --hard abc1234
   ```

   如果我想要保留工作目录中的更改，只恢复索引和HEAD，我可以使用：

   ```bash
   git reset --soft abc1234
   ```

在进行任何可能丢失数据的操作前，最好是先做一个备份，特别是在使用`--hard`选项时。这样可以确保不会无意中丢失工作成果。

### 简短回答：

    git reset 'HEAD@{1}'
    

### 长答案：

Git 保留所有引用更新的日志（例如，签出、重置、提交、合并）。您可以通过输入以下内容来查看它：

    git reflog
    

此列表中的某个位置是您丢失的提交。假设您刚刚输入`git reset HEAD~`并想要撤消它。我的转发日志如下所示：

    $ git reflog
    3f6db14 HEAD@{0}: HEAD~: updating HEAD
    d27924e HEAD@{1}: checkout: moving from d27924e0fe16776f0d0f1ee2933a0334a4787b4c
    [...]
    

第一行表示`HEAD`0个位置之前（换句话说，当前位置）是3f6db14；它是通过重置为 获得的`HEAD~`。第二行表示`HEAD`1 个位置之前（换句话说，重置之前的状态）是 d27924e。它是通过检查特定提交获得的（尽管现在这并不重要）。因此，要撤消重置，请运行`git reset HEAD@{1}`（或`git reset d27924e`）。

另一方面，如果您从那时起运行了一些其他命令来更新 HEAD，那么您想要的提交将不会位于列表的顶部，并且您需要搜索`reflog`.

最后一点：查看要`reflog`取消重置的特定分支（例如 master）可能更容易，而不是`HEAD`：

    $ git reflog show master
    c24138b master@{0}: merge origin/master: Fast-forward
    90a2bf9 master@{1}: merge origin/master: Fast-forward
    [...]
    

这应该比一般的噪音要少`HEAD reflog`。

不过，我会提出另一种选择。

    git reset ORIG_HEAD
    

`ORIG_HEAD`引用之前引用的提交`HEAD`。

我的情况略有不同，我做了`git reset HEAD~`三次。

要撤消它我必须做

    git reset HEAD@{3}
    

所以你应该能够做到

    git reset HEAD@{N}
    

但是如果你已经使用 git Reset 完成了

    git reset HEAD~3
    

你需要做

    git reset HEAD@{1}
    

_{N}_代表 reflog 中的操作数量，正如 Mark 在评论中指出的那样。

1.  用于`git reflog`获取所有参考更新。
    
2.  `git reset <id_of_commit_to_which_you_want_restore>`

答案大多数时候有效

    git reset 'HEAD@{1}'
    

答案每次都有效

    git reset --hard 'HEAD@{1}'
    

where`--hard`使得一切都和以前一样。

How do i undo git reset?

如果提交发生在过去 90 天内，则按日期执行此操作看起来像这样：

```
git show HEAD@{2013-02-25}:./fileInCurrentDirectory.txt
```

请注意，这 `HEAD@{2013-02-25}`意味着此存储库中的“HEAD 位于 2013-02-25”（使用[reflog](http://git-scm.com/docs/git-reflog)），而不是“历史记录中此分支中 2013-02-25 之前的最后一次提交”。

这意味着，默认情况下，此方法仅适用于过去 90 天内的历史记录。否则，您需要执行以下操作：

```
git show $(git rev-list -1 --before="2013-02-26" HEAD):./fileInCurrentDirectory.txt
```

您可以使用 `git show`存储库根目录的路径（`./`或 `../`相对路径）：

```
$ git show REVISION:path/to/file
```

替换 `REVISION`为您的实际修订（Git 提交 SHA、标记名称、分支名称、相对提交名称或在 Git 中标识提交的任何其他方式）。

`<repository-root>/src/main.c`例如，要查看4 次提交前的文件版本，请使用：

```
$ git show HEAD~4:src/main.c
```

即使在相对于当前目录的路径中，Windows 版 Git 也需要_正斜杠。

如果你喜欢 GUI，你可以使用 gitk：

1.  启动 gitk：
    
        gitk /path/to/file
        
    
2.  在屏幕顶部选择修订版本，例如按说明或日期。默认情况下，屏幕的下部显示该修订版的差异（对应于“补丁”单选按钮）。
    
3.  要查看所选版本的文件：
    
    *   单击“树”单选按钮。这将显示该修订版文件树的根。
    *   深入查看您的文件。

您还可以使用[命令](https://git-scm.com/docs/git-show)`commit hash`指定 a （通常也称为`commit ID`）。[`git show`](https://git-scm.com/docs/git-show)

* * *

### 简而言之

`git show <commitHash>:/path/to/file`

* * *

### 一步步

1.  显示给定文件的所有更改日志[`git log /path/to/file`](https://git-scm.com/book/en/v2/Git-Basics-Viewing-the-Commit-History)
2.  在显示的更改列表中，它显示了诸如`commit hash`（`commit 06c98...`06c98...是提交哈希）
3.  复制`commit hash`
4.  `git show <commitHash>:/path/to/file`使用`commit hash`步骤 3 和`path/to/file`步骤 1运行命令。

**注意：**`./`指定相对路径时添加似乎很重要，即`git show b2f8be577166577c59b55e11cfff1404baf63a84:./flight-simulation/src/main/components/nav-horiz.html`。

**_要快速查看文件与旧版本的差异：_**

> `git show -1 filename.txt`\> 与文件的最新版本进行比较
> 
> `git show -2 filename.txt`\> 与最后第二个修订版进行比较
> 
> `git show -3 fielname.txt` > 与最后第三次修订进行比较

所有问题