清除Service Worker的缓存通常涉及以下几个步骤：

1. **注销Service Worker**：
   - 打开浏览器的开发者工具。
   - 转到“Application”面板。
   - 在左侧边栏中找到“Service Workers”。
   - 点击“Unregister”以注销当前域名下的Service Worker。

2. **清除缓存**：
   - 在相同的“Application”面板中，找到“Cache Storage”。
   - 展开“Cache Storage”部分，列出所有的缓存。
   - 右键点击需要删除的缓存，选择“Delete”来清除缓存。

3. **使用代码清除缓存**：
   可以在Service Worker的脚本中编写代码来清除缓存。例如：

   ```javascript
   self.addEventListener('activate', event => {
     event.waitUntil(
       caches.keys().then(cacheNames => {
         return Promise.all(
           cacheNames.map(cacheName => {
             // 假设'v1'是你想要保留的缓存的版本
             if (cacheName !== 'v1') {
               console.log('Service Worker: 清除旧缓存', cacheName);
               return caches.delete(cacheName);
             }
           })
         );
       })
     );
   });
   ```

   上述代码会在Service Worker激活时运行，它会遍历所有的缓存，并删除那些版本不是`'v1'`的缓存。

除了这些步骤，重要的是确保在更新Service Worker脚本后，让用户的浏览器获取到最新的Service Worker文件。通常，这可以通过更改Service Worker文件的内容来实现，因为浏览器会检查文件内容是否有变化来决定是否需要安装新的Service Worker。

例如，如果我刚完成一个项目，需要更新Service Worker以及对应的缓存，我会更新Service Worker脚本，可能是修改内部的缓存策略或者版本标签，然后将修改后的脚本部署到服务器。这样用户下次访问时，浏览器会检测到Service Worker脚本的内容更新，触发安装新的Service Worker，并在activate事件中清除旧的缓存。

总的来说，清除Service Worker的缓存需要综合运用开发者工具和编写Service Worker代码的方式来实现。这对于保持应用的性能和确保用户获得最新内容非常重要。

If you know the cache name you can simply call [`caches.delete()`](https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage/delete) from anywhere you like in the worker:

    caches.delete(/*name*/);
    

And if you wanted to wipe all caches (and not wait for them, say this is a background task) you only need to [add this](https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage/keys):

    caches.keys().then(function(names) {
        for (let name of names)
            caches.delete(name);
    });

Use this to delete outdated caches:

    self.addEventListener('activate', function(event) {
      event.waitUntil(
        caches.keys().then(function(cacheNames) {
          return Promise.all(
            cacheNames.filter(function(cacheName) {
              // Return true if you want to remove this cache,
              // but remember that caches are shared across
              // the whole origin
            }).map(function(cacheName) {
              return caches.delete(cacheName);
            })
          );
        })
      );
    });

Typically you update the `CACHE_NAME` in your service workers JS file so your worker installs again:

    self.addEventListener('install', evt => {
      evt.waitUntil(
        caches.open(CACHE_NAME).then(cache => cache.addAll(inputs))
      )
    })
    

Alternatively, to _clear_ the cache for a PWA find the cache name:

    self.caches.keys().then(keys => { keys.forEach(key => console.log(key)) })
    

then run the following to delete it:

    self.caches.delete('my-site-cache')
    

Then refresh the page.

If you see any worker-related errors in the console after refreshing, you may also need to unregister the registered workers:

    navigator.serviceWorker.getRegistrations()
      .then(registrations => {
        registrations.forEach(registration => {
          registration.unregister()
        }) 
      })

The most elegant solution, with async/await:

    const cacheName = 'v2';
    
    self.addEventListener('activate', event => {
    // Remove old caches
      event.waitUntil(
        (async () => {
          const keys = await caches.keys();
          return keys.map(async (cache) => {
            if(cache !== cacheName) {
              console.log('Service Worker: Removing old cache: '+cache);
              return await caches.delete(cache);
            }
          })
        })()
      )
    })

This is the only code that worked for me. It is my adaptation of [Mozilla documentation](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Deleting_old_caches) :

    //Delete all caches and keep only one
    const cachNameToKeep = 'myCache';
    
    //Deletion should only occur at the activate event
    self.addEventListener('activate', event => {
        var cacheKeeplist = [cacheName];
        event.waitUntil(
            caches.keys().then( keyList => {
                return Promise.all(keyList.map( key => {
                    if (cacheKeeplist.indexOf(key) === -1) {
                        return caches.delete(key);
                    }
                }));
            })
    .then(self.clients.claim())); //this line is important in some contexts
    });

How to clear cache of service worker?

在Cypress中，等待某个元素消失可以通过多种方式来实现。最常用的方法是利用`.should()`断言连同`not.exist`或者`not.be.visible`，来等待元素从DOM中消失或不再可见。以下是几种方法的示例：

### 使用 `should('not.exist')`

如果你希望等待一个元素从DOM中彻底消失，你可以这样做：

```javascript
cy.get('.some-element').should('not.exist');
```

这会告诉Cypress一直等待，直到页面上不再存在带有`.some-element`类的元素。

### 使用 `should('not.be.visible')`

如果元素仍然存在于DOM中，但你希望它不可见（例如，通过CSS隐藏），可以使用：

```javascript
cy.get('.some-element').should('not.be.visible');
```

这会告诉Cypress等待，直到`.some-element`不再对用户可见。

### 使用 `wait` 结合 `should`

在某些情况下，如果后端操作需要时间，并且这个操作会导致元素消失，你可能需要结合使用`wait`和`should`命令：

```javascript
cy.wait('@yourApiCall');
cy.get('.some-element').should('not.exist');
```

这个例子中，`cy.wait('@yourApiCall')`会等待一个别名为`yourApiCall`的API调用完成。完成后，Cypress会继续等待`.some-element`元素消失。

### 注意事项

- 确保你的选择器是具体且唯一的。如果选择器不唯一（例如，页面上有多个相同的元素），Cypress可能会找到其他的元素，而不是你想要它等待消失的那个。

- 如果你的应用使用动画，那么可能需要增加一个超时时长，因为元素的消失可能不是立即发生的：

  ```javascript
  cy.get('.animated-element').should('not.be.visible', { timeout: 10000 });
  ```

  这会增加Cypress等待元素不可见的超时时长至10秒。

通过这些方法，你可以告诉Cypress等待一个元素消失，这是在自动化测试中常见的一个需求，特别是在测试具有异步行为的Web应用时。

How to wait for element to disappear in cypress

当您想要卸载 Service Worker 时，可以通过几个步骤来实现：

1. **开发者工具中卸载：**

   如果是在开发过程中，可以直接通过浏览器的开发者工具来卸载 Service Worker。以下以 Google Chrome 浏览器为例：

   - 打开需要卸载 Service Worker 的网站。
   - 按 `F12` 或者右键选择“检查”打开开发者工具。
   - 切换到“Application”标签页。
   - 在左侧边栏的“Service Workers”选项下，可以看到当前激活的 Service Worker。
   - 有一个 "Unregister" 的按钮，点击它可以卸载当前的 Service Worker。

2. **编程卸载：**

   如果您希望在网站上编程实现卸载 Service Worker，可以通过以下代码实现：

   ```javascript
   if ('serviceWorker' in navigator) {
     navigator.serviceWorker.getRegistrations().then(function(registrations) {
       for (let registration of registrations) {
         registration.unregister();
       }
     }).catch(function(error) {
       console.log('Service Worker 注销失败: ', error);
     });
   }
   ```

   上面的代码段会找到所有注册的 Service Worker，并逐个注销它们。

3. **清除浏览器数据：**

   另一种卸载 Service Worker 的方法是清除网站的浏览器数据，包括缓存和本地存储。

   - 在 Chrome 浏览器中，可以按 `Ctrl+Shift+Delete` 快捷键打开“清除浏览数据”对话框。
   - 选择“高级”选项卡，勾选“Cookie 和其他站点数据”以及“缓存的图片和文件”。
   - 点击“清除数据”。

   这将删除所有的 Service Worker，以及相关的缓存和数据。

4. **手动修改Service Worker代码：**

   可以在 Service Worker 的代码中添加一个自毁逻辑，当满足特定条件时，自动卸载自身。例如：

   ```javascript
   self.addEventListener('install', (event) => {
     if (someCondition) {
       self.skipWaiting(); // 忽略等待，立即激活
     }
   });

   self.addEventListener('activate', (event) => {
     if (someCondition) {
       self.registration.unregister().then(() => {
         return self.clients.matchAll();
       }).then((clients) => {
         clients.forEach(client => client.navigate(client.url)); // 刷新页面
       });
     }
   });
   ```

   在上述代码中，`someCondition` 是一个占位符，表示某个您决定卸载 Service Worker 的条件。当条件满足时，Service Worker 将自我注销，并刷新所有的客户端页面。

通过这些方法，您可以有效地卸载 Service Worker。不过需要注意的是，卸载后相关的缓存功能将不再可用，如果是用户的设备上执行卸载操作，可能会影响到网站的离线功能和加载性能。因此，在执行卸载操作之前，请确保这是您所期望的。

### Removing Service Workers Programmatically:

You can remove service workers programmatically like this:

    navigator.serviceWorker.getRegistrations().then(registrations => {
        for (const registration of registrations) {
            registration.unregister();
        } 
    });
    

Docs: [getRegistrations](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/getRegistrations), [unregister](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/unregister)

### Removing Service Workers Through The User Interface

You can also remove service workers under the Application tab in Chrome Devtools.

You can also go to the URL: **chrome://serviceworker-internals/** and unregister a serviceworker from there.

You can do this through **Chrome Developer Tool** as well as **Programatically**.

1.  Find all running instance or service worker by typing
    
    > **chrome://serviceworker-internals/**
    
    in a new tab and then select the serviceworker you want to unregister.
    
2.  Open Developer Tools (F12) and Select Application. Then Either
    
    > **Select Clear Storage -> Unregister service worker**
    
    or
    
    > **Select Service Workers -> Choose Update on Reload**
    
3.  Programatically
    

    if(window.navigator && navigator.serviceWorker) {
      navigator.serviceWorker.getRegistrations()
      .then(function(registrations) {
        for(let registration of registrations) {
          registration.unregister();
        }
      });
    }

Run code snippetHide results

Expand snippet

In Google Chrome, you can go to **Developer tools (F12) -> Application -> Service worker** and **unregister** the service workers from the list for that specific domain.

[![Screenshot](https://i.stack.imgur.com/RtV2C.png)](https://i.stack.imgur.com/RtV2C.png)

This method is effective in development mode of a site and mostly they run on `localhost` which is you may need for other project's development.

FYI, in case you are using MacOS **Safari** browser, there is one way to forcibly unregister a service worker (steps and images for Safari 12.1):

1.  Safari > Preferences... > Privacy > Manage Website Data… [![Safari Preferences : Privacy](https://i.stack.imgur.com/yiEbw.png)](https://i.stack.imgur.com/yiEbw.png)
    
2.  Enter domain name (ex. 'localhost'), click "Remove" [![Safari Preferences : Privacy : manage website data](https://i.stack.imgur.com/am2s2.png)](https://i.stack.imgur.com/am2s2.png)
    

**Note:** In addition to service workers, this also will erase all caches, cookies, and databases for this domain.

How do i uninstall a service worker

在Cypress中等待某个元素消失，我们通常会用到`.should('not.exist')`断言。这将会让Cypress重试断言直到它通过为止，即直到元素不再存在于DOM中。这是一个非常实用的特性，尤其是当进行异步操作，例如等待一个加载指示器消失之后再进行下一步操作。

例如，假设您有一个加载指示器，它在异步操作期间在页面上显示，操作完成后消失。加载指示器的HTML元素可能是这样的：

```html
<div id="loading-indicator">Loading...</div>
```

当您想要在测试中等待这个加载指示器消失时，可以这样编写Cypress代码：

```javascript
// 等待加载指示器消失
cy.get('#loading-indicator').should('not.exist');
```

这段代码会获取ID为`loading-indicator`的元素，并断言它应该不存在。Cypress会不断尝试这个断言，直到默认的超时时间（通常是4秒，但是可以通过配置进行修改）结束，如果在这段时间内元素消失了，测试就会继续进行。如果元素没有在超时时间内消失，测试将会失败。

此外，如果需要等待某个元素不可见（即它仍然存在于DOM中，但是不再是可见状态），可以使用`.should('not.be.visible')`断言。

例如，如果加载指示器变成了不可见状态，但没有从DOM中移除，可以这样做：

```javascript
// 等待加载指示器不可见
cy.get('#loading-indicator').should('not.be.visible');
```

这两种方法允许你在Cypress测试中处理元素消失的情况，确保在断言和操作之间有适当的同步。

IMHO the cleanest way is not to use waits nor timeouts with get, this is kinda an antipattern.

I would recommend to use [Cypress waitUntil](https://www.npmjs.com/package/cypress-wait-until) command and use something like:

     cy.waitUntil(function() {
      return cy.get('element').should('not.exist');
     })
    

or depending on the app code you can use `not.be.visible`.

`cypress-wait-until` did not work for me. I just used the basic:

    cy.get('.ant-drawer-body').should('not.exist');
    

It waits automatically.

If you specifically need to wait, you could use the [`wait()`](https://docs.cypress.io/api/commands/wait.html) function of cypress before making an assertion, and provide the amount of time to wait before timeout.

But note, this is an anti-pattern as you can find in the docs:

> You almost never need to wait for an arbitrary period of time. There are always better ways to express this in Cypress.

That said, if your loading indicator is bound to some network request, you can wait for them to finish before making an assertion. This could be achieved with something like [this](https://docs.cypress.io/api/commands/wait.html#Alias) example:

    // Wait for the route aliased as 'getAccount' to respond
    // without changing or stubbing its response
    cy.server()
    cy.route('/accounts/*').as('getAccount')
    cy.visit('/accounts/123')
    cy.wait('@getAccount').then((xhr) => {
      // we can now access the low level xhr
      // that contains the request body,
      // response body, status, etc
    })
    

More info about waiting for requests could be found [here](https://docs.cypress.io/guides/guides/network-requests.html#Waiting).

Also, make sure that you really want to use `.should('not.exist')` and not `.should('not.be.visible')`.

Loading spinner implementations often just hide the element rather than removing it from the DOM. Hence, `should("not.exist")` won't work for them.

`cy.get("element").should("not.be.visible")` is the right approach in such cases (as [Diogo's answer](https://stackoverflow.com/questions/53672387/how-to-wait-for-element-to-disappear-in-cypress#answer-53673043) already hinted).

`.findByTestId('loading-spinner-data-testid').should('not.be.visible')`

This works in a similar context for me.

As of `"@testing-library/cypress": "^5.3.1",`

Just make sure you give your spinner component a data-testid attribute.

`<LoadingSpinner data-testid='loading-spinner-data-testid'>`

How to wait for element to disappear in cypress?

在 Cypress 中，可以通过多种方式访问 `baseURL` 的值。`baseURL` 是在 Cypress 的配置文件中指定的，通常用来表示应用的根地址，这样就可以在测试中仅仅使用相对路径。以下是访问 `baseURL` 的几种方法：

1. **通过 `cy.visit()` 使用相对路径**:
   当您在 `cy.visit()` 使用相对路径时，Cypress 会自动将 `baseURL` 作为前缀添加到路径中。例如，如果您设置了 `baseURL` 为 `https://example.com`，您可以这样使用：

   ```javascript
   cy.visit('/page'); // 实际访问的 URL 将是 https://example.com/page
   ```

2. **通过 Cypress 配置命令**:
   您可以使用 `Cypress.config()` 函数访问当前的配置，包括 `baseURL`。例如：

   ```javascript
   const baseURL = Cypress.config('baseUrl');
   console.log(baseURL); // 输出配置文件中设置的 baseURL
   ```

3. **在测试中动态设置**:
   如果你需要在测试执行过程中动态地更改 `baseURL`，你也可以使用 `Cypress.config()` 方法：

   ```javascript
   Cypress.config('baseUrl', 'https://newexample.com');
   // 之后的 cy.visit('/') 会访问 https://newexample.com/
   ```

4. **环境变量**:
   还可以通过设置环境变量的方式来覆盖配置文件中的 `baseURL`。在命令行中运行 Cypress 时，使用 `CYPRESS_BASE_URL` 环境变量：

   ```shell
   CYPRESS_BASE_URL=https://anotherexample.com npx cypress open
   ```

   在测试中，`baseURL` 会被设置为 `https://anotherexample.com`。

作为一个实际的例子，假设我们在测试中需要访问一个登录页面，而这个页面的路径是 `/login`。我们的 `baseURL` 配置为 `https://example.com`，我们可以编写以下的 Cypress 测试代码：

```javascript
describe('Login Page Test', () => {
  it('should visit the login page', () => {
    // 直接使用相对路径，Cypress 会自动使用 baseURL
    cy.visit('/login');
    
    // 做一些登录页面的断言...
  });
  
  it('should dynamically get the baseURL and construct the full URL', () => {
    // 获取 baseURL
    const baseURL = Cypress.config('baseUrl');
    
    // 使用获取的 baseURL 构造完整的 URL 并访问
    cy.visit(`${baseURL}/login`);
    
    // 做一些登录页面的断言...
  });
});
```

在第一个测试用例中，我直接使用 `cy.visit('/login')`，Cypress 自动加上了 `baseURL`。在第二个测试用例中，我首先获取 `baseURL` 的值，然后手动构造了完整的 URL 来访问登录页面。这两种方式都可以根据测试的需要选择使用。

You can use the [`Cypress.config()`](https://docs.cypress.io/api/cypress-api/config#Syntax) command.

To get `baseUrl` value use `Cypress.config().baseUrl` or `Cypress.config('baseUrl')`.

`cy.visit('/')` will visit the baseUrl if you have it defined in your Cypress e2e config. ([Source](https://docs.cypress.io/api/commands/visit#Syntax))

How to access the value of baseURL in Cypress

在Cypress中，要在所有测试运行之前执行一些公共代码，我们通常使用`before`或`beforeEach`钩子。`before`钩子在测试文件中的所有测试运行之前执行一次，而`beforeEach`钩子则在每个测试用例运行之前都会执行。

这里有个示例：

如果您想在所有测试前只执行一次某些代码，您可以在测试文件的顶层使用`before`钩子：

```javascript
// 在所有测试前只执行一次
before(() => {
  // 这里可以放置你的公共代码，比如：
  // 登录操作
  cy.login('username', 'password'); // 假设你有一个封装好的登录命令
  // 设置测试数据或者环境
  cy.setupTestData();
});
```

如果需要在每个测试用例之前执行代码，可以使用`beforeEach`钩子：

```javascript
// 在每个测试用例之前都执行
beforeEach(() => {
  // 这里可以放置你的公共代码，比如：
  // 每次都要确保从登陆页面开始
  cy.visit('/login'); // 访问登录页面
  // 你可能需要清除浏览器的localStorage或cookies
  cy.clearLocalStorage();
  cy.clearCookies();
  // 每个测试用例都需要的初始化操作
  cy.initializeTestContext();
});
```

这些钩子应该放在你的测试文件顶部，通常在描述测试套件的`describe`块外面或里面。将它们放在`describe`块外面意味着它们会在该文件中定义的所有`describe`块之前运行。放在`describe`块内部，则只会影响该`describe`块中的测试用例。

另外，如果你有多个测试文件，并且希望有一些代码在这些测试文件中的每个文件执行前都运行一次，你可以使用Cypress的`support`文件夹中的`index.js`文件。在那里放置的代码会在每个测试文件执行前运行。

例如，在`cypress/support/index.js`文件中：

```javascript
// 这将在每个测试文件之前执行一次
before(() => {
  // 公共初始化代码，比如设置API服务器的状态
  cy.initializeApiServer();
});

// 这将在每个测试文件的每个测试用例之前执行
beforeEach(() => {
  // 通用的每个测试用例前的逻辑，比如登录
  cy.loginToApplication();
});
```

记得在使用这些钩子时要注意它们的作用域和执行顺序，以确保测试环境的正确设置。

**Short answer:** You can write your login command in a `before` hook within the `supportFile` ([the file that is loaded automatically before your other spec files](https://on.cypress.io/configuration#Folders-Files)). This `before` hook will run before any of the code in your other test files.

* * *

**Recommendations:** That being said, this approach leaves little flexibility for variation in your individual test files that you may want in the future like:

*   What if you want to seed the database differently for one test?
*   What if you want to log in as a different user with different permissions?
*   What if you need to do something in `onBeforeLoad` once?

I would recommend just having the login command in a `before` hook in each individual spec file.

I would also _further_ recommend having your login command in a `beforeEach` hook to [avoid sharing _any_ state in between tests](https://docs.cypress.io/guides/references/best-practices.html#Having-tests-rely-on-the-state-of-previous-tests).

Now in **Cypress v12** the appropriate way to do this is with the [Before Run API](https://docs.cypress.io/api/plugins/before-run-api).

**cypress.config.js**

    const { defineConfig } = require('cypress')
    
    module.exports = defineConfig({
      // setupNodeEvents can be defined in either
      // the e2e or component configuration
      e2e: {
        setupNodeEvents(on, config) {
          on('before:run', (details) => {
            /* code that needs to run before all specs */
          })
        },
        experimentalInteractiveRunEvents: true,   // use for cypress open mode
      },
    })

describe('Hooks', function() {
        before(function() {
            // runs once before all tests in the block
        })
    })
    

[https://docs.cypress.io/guides/core-concepts/writing-and-organizing-tests.html#Hooks](https://docs.cypress.io/guides/core-concepts/writing-and-organizing-tests.html#Hooks)

I would login before EACH test because there could be things that happen in a previous test that affects the results of the current test. With a fresh login, you're starting with a clean state every time. If you want to test a "chain" of unrelated actions (action A THEN action B), then write that as a separate test, but have basic functionality in individual tests.

    describe('/page'), () => {
      beforeEach(() => {
        cy.login()        // custom command that handles login w/o UI
        cy.visit('/page') // go to the page you are testing
      })
    
      // tests
    })
    

You should include a beforeEach block in every test file. This block should login and navigate to the page in question.

`cypress/support/e2e.ts`

    before(() => {
      // do stuff
    })
    

Use `before` to run 1-time before every test or use `beforeEach`. to run before each individual test.

How can I execute code before all tests suite with Cypress?

在 Koa 中实现文件下载功能通常涉及以下几个步骤：

1. **处理请求**：首先，你需要定义一个路由和对应的处理函数来处理下载请求。
2. **文件定位**：处理函数中需要定位到要下载的文件在服务器上的路径。
3. **设置响应头**：为了通知浏览器这是一个文件下载响应，需要设置适当的 `Content-Disposition` 和 `Content-Type` 响应头。
4. **发送文件**：最后，使用 Koa 的响应对象来发送文件内容回客户端。

以下是一个简单的例子，演示了如何在 Koa 应用程序中实现文件下载功能：

```js
const Koa = require('koa');
const send = require('koa-send');
const path = require('path');
const app = new Koa();

// 定义一个路由用于处理下载请求
app.use(async (ctx) => {
    // 假设我们要下载的文件名是固定的
    const fileName = 'example.txt';

    // 设置文件的完整路径
    const filePath = path.join(__dirname, 'public', fileName);

    // 设置响应头
    ctx.set('Content-Disposition', `attachment; filename=${fileName}`);
    ctx.set('Content-Type', 'application/octet-stream');

    // 发送文件内容作为响应
    await send(ctx, filePath, { root: __dirname });
});

app.listen(3000, () => {
    console.log('Server running on http://localhost:3000');
});
```

在这个例子中，当客户端向服务器发送请求时，Koa 应用程序会通过 `koa-send` 模块来发送位于 `public` 目录下的 `example.txt` 文件。`Content-Disposition` 响应头被设置为 `attachment`，以及文件的名称，这样浏览器就知道它应该提示用户保存文件而不是直接在浏览器中显示文件的内容。`Content-Type` 被设置为 `application/octet-stream`，这是一个通用的二进制文件类型，告诉浏览器这是一个二进制文件。

请注意，这个例子中的文件名是硬编码的，但在实践中，你可能需要根据请求动态地确定文件名和路径。此外，你还可能需要处理诸如文件不存在、权限不足等潜在错误情况。

For anyone else who sees this in the future, it's worth mentioning that there is a built in `attachment` method on the `response` object that you can use to set the `Content-Disposition` to `attachment` with a specified filename. So you can do this:

    this.attachment('hello.txt')
    

And it would be the same thing as the following:

    this.set('Content-disposition', 'attachment; filename=hello.txt')
    

* * *

For Koa 2:

    ctx.attachment('hello.txt')

You should be able to simple set `this.body` to the file stream

    this.body = fs.createReadStream(__dirname + '/test.zip');
    

then set the response headers as appropriate.

    this.set('Content-disposition', 'attachment; filename=' + filename);
    this.set('Content-type', mimetype);

Browser default behaviour is to display the file, not to download it. To enforce download you need to do this:

    this.header("Content-Type", "application/force-download")
    this.header('Content-disposition', 'attachment; filename=' + filename);

Bit of a different file download example with error checking, using Node with Koa 2. I am not sure if it is necessary to destroy the stream afterwards as described here [https://github.com/jshttp/content-disposition#options](https://github.com/jshttp/content-disposition#options)

    router.get('/downloads/:version/:file', async function(ctx) {
      const fileName = `${__dirname}/downloads/${ctx.params.version}/${ctx.params.file}`;
      try {
        if (fs.existsSync(fileName)) {
          ctx.body = fs.createReadStream(fileName);
          ctx.attachment(fileName);
        } else {
          ctx.throw(400, "Requested file not found on server");
        }
      } catch(error) {
        ctx.throw(500, error);
      }  
    });
    

In browser sample: [https://myserver.com/downloads/1.0.0/CoolAppFile.zip](https://myserver.com/downloads/1.0.0/CoolAppFile.zip)

How to achieves file download with koa?

`koa-body`和`koa-bodyparser`都是针对Koa框架的中间件，用于处理HTTP请求体（body），但它们之间有一些关键的区别：

### koa-bodyparser
- **限制性**：`koa-bodyparser`较为简单，主要用于解析JSON和表单提交的数据。
- **功能**：它将解析好的body放置于`ctx.request.body`中。
- **文件上传**：`koa-bodyparser`不支持文件上传功能；它不能处理`multipart/form-data`类型的请求体，这意味着它不适用于文件上传的场景。
- **定制性**：它的定制性较弱，主要针对常见的`content-type`进行解析。

### koa-body
- **功能性**：`koa-body`是一个更全面的解决方案，它不仅支持JSON和表单数据的解析，还支持文件上传。
- **文件上传**：它可以处理`multipart/form-data`类型的请求体，因此可以用于文件上传；在处理文件上传时，`koa-body`会将上传的文件放置在`ctx.request.files`中。
- **定制性**：`koa-body`提供了更多的定制选项，如文件大小限制、文件类型限制等，给予开发者较大的灵活性。
- **依赖**：`koa-body`可能会有更多外部依赖，因为它需要处理更多类型的数据，包括文件的临时存储。

### 使用场景举例

**koa-bodyparser使用场景：**
如果您正在构建一个API服务，该服务只接受JSON格式的数据或简单的表单数据，使用`koa-bodyparser`就足够了。例如，您有一个用户登录的端点，它接受一个用户名和密码作为表单提交，这种情况下`koa-bodyparser`是合适的。

```javascript
const Koa = require('koa');
const bodyParser = require('koa-bodyparser');

const app = new Koa();

app.use(bodyParser());

app.use(async ctx => {
  const { username, password } = ctx.request.body;
  // 处理登录逻辑
  ctx.body = '登录成功';
});

app.listen(3000);
```

**koa-body使用场景：**
如果您的应用需要更复杂的数据处理，如文件上传（例如用户头像上传），则需要使用`koa-body`。

```javascript
const Koa = require('koa');
const koaBody = require('koa-body');

const app = new Koa();

app.use(koaBody({ multipart: true }));

app.use(async ctx => {
  const { files, fields } = ctx.request;
  // files 有上传的文件
  // fields 有其他表单字段
  // 处理上传逻辑
  ctx.body = '文件上传成功';
});

app.listen(3000);
```

综上所述，选择哪个中间件取决于您的应用场景。如果您只需要处理JSON或URL编码的表单数据，`koa-bodyparser`可能更简单且更适合。如果您需要处理包括文件上传在内的更复杂数据类型，那么`koa-body`会是更好的选择。

### \[New answer\]

`koa-body` now support koa version 2. The main difference now remains about file payload parsing. The `koa-bodyparser` cannot parse files, i.e. `multipart/form-data`.

### \[Old answer\]

Oh, I got it.

[https://github.com/koajs/koa/wiki](https://github.com/koajs/koa/wiki)

koa-body supports koa v1, koa-bodyparser supports koa v2.

And former can parse file, but later can't.

Thanks.

Both are Koa body parser middleware. I recently faced an issue where I wanted to handle file upload and there comes the main difference.

Koa-body supports -- koa, urlencoded, multipart, json, body, parser, form and

koa-bodyparser supports -- json, urlencoded, koa, body.

So if you are looking for file uploading features , go ahead with koa-body or koa-better-body (which has more wider scopes)

[Here is detailed reference](https://npmcompare.com/compare/koa-better-body,koa-body,koa-bodyparser)

Whats the difference between koa body vs koa bodyparser

在 Koa.js 中为所有响应添加自定义 header，通常可以通过中间件的方式实现。在 Koa 中，中间件是处理 HTTP 请求和响应的函数，它们按照添加的顺序被执行。为了给所有响应加上自定义 header，我们可以创建一个中间件，并将其放在其他所有中间件之前。

下面是一个如何实现这一功能的示例：

```javascript
const Koa = require('koa');
const app = new Koa();

// 自定义 header 的中间件
app.use(async (ctx, next) => {
    // 在这里设置自定义 header
    ctx.set('X-Custom-Header', 'YourCustomHeaderValue');

    // 调用下一个中间件
    await next();

    // 如果你还需要在响应后执行一些操作，可以在此处添加代码
});

// 其他中间件
// ...

// 一个简单的响应示例
app.use(async ctx => {
    ctx.body = 'Hello World';
});

app.listen(3000);
```

上面的代码中，我们定义了一个中间件，它通过 `ctx.set` 方法设置了自定义的 header `X-Custom-Header`。在调用 `await next()` 之后，当前中间件会暂停执行，直到下游的中间件处理完毕后才可能继续执行（如果有需要在响应后执行的操作）。

在上面的例子中，如果你想要为所有响应设置多个自定义 header，你可以重复使用 `ctx.set` 方法，如下所示：

```javascript
app.use(async (ctx, next) => {
    ctx.set('X-Custom-Header-One', 'ValueOne');
    ctx.set('X-Custom-Header-Two', 'ValueTwo');
    // ...设置更多的 header

    await next();
});
```

还有一点需要注意的是，如果你想要覆盖 Koa 默认的某些 header，比如 `Content-Type` 或 `Content-Length`，你可能需要在响应体被设置之后再覆盖它们，因为 Koa 会基于响应体来自动设置这些 header。

确保自定义的 header 不与 HTTP 规范中的标准 header 冲突，并且符合你的应用程序的安全策略。

下面的代码可以实现何对所有的请求响应设置Header   

```
app.use(async (ctx, next) => {
  ctx.set('Access-Control-Allow-Origin', '*');
  ctx.set('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
  ctx.set('Access-Control-Allow-Methods', 'POST, GET, PUT, DELETE, OPTIONS');
  await next();
});
```

How do i set headers to all responses in koa js?

在 Koa.js 中，可以通过请求对象（`ctx.request`）访问客户端的 IP 地址。最直接的方法是使用 `ctx.request.ip` 属性。但在实际部署中，很多应用会放在代理（如 Nginx）后面，这时直接获取的 IP 可能是代理服务器的 IP。为了获取实际的客户端 IP，通常会通过 `X-Forwarded-For` 请求头来获取。

这里有一个简单的例子说明如何在 Koa.js 中获取客户端的真实 IP 地址：

```javascript
const Koa = require('koa');
const app = new Koa();

// Trust proxy headers
app.proxy = true;

app.use(async ctx => {
  // 获取真实客户端 IP 地址
  const clientIp = ctx.request.ip;

  // 如果使用了代理，那么可以通过以下方式获取真实 IP
  // const xForwardedFor = ctx.request.header['x-forwarded-for'];
  // const realClientIp = xForwardedFor ? xForwardedFor.split(',')[0] : clientIp;

  ctx.body = `Your IP address is: ${clientIp}`;
});

app.listen(3000, () => {
  console.log('Server is running on http://localhost:3000');
});
```

在上面的代码中：

- `app.proxy = true;` 告诉 Koa 信任代理头信息（比如 `X-Forwarded-For`），这通常在应用部署在代理之后时设置。
- `ctx.request.ip` 用于获取请求的 IP 地址。若设置了 `app.proxy = true;`，Koa 会自动考虑 `X-Forwarded-For` 头信息。
- 我们注释掉的两行代码显示了如何手动从 `X-Forwarded-For` 头信息中提取客户端的真实 IP。这可能在不同的部署设置中有所不同，因为有些代理会添加多个 IP 地址到 `X-Forwarded-For`。

确保在生产环境中谨慎设置 `app.proxy = true;`，因为它会信任请求头中的 IP 地址。只有当您确信代理是可信的并且已正确配置时，才应该这样做。错误地信任代理头信息可能会导致安全问题。

**Koa 1:**

Assuming you have no reverse proxy in place, you can use `this.request.ip` like this:

    router.get('/admin.html', function *(next) {
        const clientIP = this.request.ip;
        this.body = `Hello World ${clientIP}`;
    });
    

This feature is documented in the [request](https://github.com/koajs/koa/blob/master/docs/api/request.md) documentation. You can always access said `request` object as `this.request`.

If you have a reverse proxy in place, you'll always get the IP address of the reverse proxy. In this case, it's more tricky: In the reverse proxy configuration, you need to add a special header, e.g. `X-Orig-IP` with the original client IP.

Then, you can access it in koa with:

    const clientIp = this.request.headers["X-Orig-IP"];
    

**Koa 2:**

The approach is quite similar, only the syntax is slightly different:

    router.get('/', async (ctx, next) => {
        const clientIP = ctx.request.ip;
        ctx.body = `Hello World ${clientIP}`;
    })

If you add `app.proxy=true` you can still use `request.ip` without having to worry about the IP headers.

I had the same problem but resolved it by using this module found on NPM `request-ip`

in koa it can be simply used `userIp = requestIp.getClientIp(ctx.request)`

The user ip is determined by the following order:

    X-Client-IP
    X-Forwarded-For (Header may return multiple IP addresses in the format: "client IP, proxy 1 IP, proxy 2 IP", so we take the the first one.)
    CF-Connecting-IP (Cloudflare)
    Fastly-Client-Ip (Fastly CDN and Firebase hosting header when forwared to a cloud function)
    True-Client-Ip (Akamai and Cloudflare)
    X-Real-IP (Nginx proxy/FastCGI)
    X-Cluster-Client-IP (Rackspace LB, Riverbed Stingray)
    X-Forwarded, Forwarded-For and Forwarded (Variations of #2)
    req.connection.remoteAddress
    req.socket.remoteAddress
    req.connection.socket.remoteAddress
    req.info.remoteAddress
    

If an IP address cannot be found, it will return null.

Get client ip in koa js

在Koa中使用Koa Router处理路由时，您可以通过`ctx.query`或`ctx.querystring`对象访问查询字符串参数。`ctx`是Koa的上下文对象，它封装了请求和响应对象。

下面是如何获取查询字符串参数的步骤和示例：

### 步骤 1: 引入Koa及Koa Router
首先，您需要安装并引入Koa以及Koa Router模块。

```javascript
const Koa = require('koa');
const Router = require('@koa/router');

const app = new Koa();
const router = new Router();
```

### 步骤 2: 使用路由中间件处理查询参数
然后，创建一个路由并在回调函数中访问查询参数。

```javascript
router.get('/some-path', (ctx) => {
  // 获取查询参数
  const queryParams = ctx.query;
  
  // 对查询参数做一些处理
  // ...

  ctx.body = {
    message: '查看查询参数',
    queryParams
  };
});

// 应用路由中间件
app.use(router.routes()).use(router.allowedMethods());
```

在以上示例中，当有请求发送到`/some-path`时，我们通过`ctx.query`获取了查询参数，这是一个对象，其中包含了请求中的所有查询字符串参数。如果请求的URL是`/some-path?name=John&age=30`，那么`ctx.query`将是`{ name: 'John', age: '30' }`。

### 步骤 3: 启动Koa应用

```javascript
const port = 3000;
app.listen(port, () => {
  console.log(`Server is running on http://localhost:${port}`);
});
```

### 示例

如果你收到一个GET请求，URL是这样的：`http://localhost:3000/some-path?user=alice&token=123`，你可以这样获取这些参数：

```javascript
router.get('/some-path', (ctx) => {
  const user = ctx.query.user;  // alice
  const token = ctx.query.token; // 123
  
  // ... 根据业务逻辑处理这些参数
  
  ctx.body = {
    message: '获取到的用户信息',
    user,
    token
  };
});
```

这样，你就可以根据业务需求处理这些参数了，比如验证token的有效性，查找用户信息等。

总结一下，通过Koa Router获取查询字符串参数是直接通过上下文对象`ctx`的`query`属性来实现的，它为您提供了一个包含所有查询参数的对象，非常直观和方便。

According to the docs there should be a `ctx.request.query` that is the query string items represented as an object.

You can use `ctx.query` (or long-hand `ctx.request.query`)

`app.use( (ctx) => console.log(ctx.query) )`

How to get query string params in koa router?

`cherry-pick` 是 Git 版本控制系统中的一个功能，它的作用是允许用户选择一个或多个其他分支上的提交（commits），并将这些提交复制到当前分支上。这样做的主要原因通常是因为这些提交包含了对特定问题的修复或者是某个特定功能的实现，而这些是当前分支所需要的。

使用 `cherry-pick` 的情况通常包括：

1. **修复紧急问题**：当在一个分支上发现了一个紧急问题并且此问题已经在另一个分支上被解决了，可以使用 `cherry-pick` 将这个修复迅速应用到当前分支上，而不必合并整个分支的所有更改。

2. **代码回滚**：在某些情况下，如果一次提交导致了问题，而这个问题在后续的提交中得到了解决，可以使用 `cherry-pick` 来选择性地将修复的提交应用到当前分支上。

3. **功能挑选**：在开发过程中，可能某个功能先在一个分支上实现，但是需要将其应用到另一个分支上。如果这两个分支不方便直接合并，可以使用 `cherry-pick` 来单独挑选该功能的提交。

4. **代码整理**：有时在多个分支上可能有很多临时或实验性的提交，当需要清理历史或重新组织提交时，可以使用 `cherry-pick` 来选择性地将有效的提交整合到一个新的分支上。

使用 `cherry-pick` 的命令格式如下：

```bash
git cherry-pick <commit-hash>
```

其中 `<commit-hash>` 是想要复制的提交的哈希值。

这里有一个具体的例子：假设我们有两个分支，`main` 和 `feature`。在 `feature` 分支上有一个提交（假设哈希值是 `abc1234`），这个提交修复了一个严重的 bug。现在，我们希望将这个修复迅速应用到 `main` 分支上，但我们不想合并整个 `feature` 分支的所有更改。我们可以在 `main` 分支上执行以下命令：

```bash
git checkout main
git cherry-pick abc1234
```

这样，`abc1234` 这个提交就被复制到了 `main` 分支上，而 `main` 分支上的其他代码保持不变。这是一个高效且精确地管理代码更改的方式。然而，需要注意的是，如果在不同分支之间 `cherry-pick` 被复制的提交，可能会遇到冲突，这时就需要手动解决这些冲突。

Cherry-picking in Git means choosing a commit from one branch and applying it to another.

This contrasts with other ways such as `merge` and `rebase` which normally apply many commits to another branch.

It's also possible to [cherry-pick multiple commits](https://stackoverflow.com/questions/1670970/how-to-cherry-pick-multiple-commits) but `merge` is the preferred way over cherry-picking.

1.  Make sure you are on the branch you want to apply the commit to.
    
        git switch master
        
    
2.  Execute the following:
    
        git cherry-pick <commit-hash>
        
    

N.B.:

1.  If you cherry-pick from a public branch, you should consider using
    
        git cherry-pick -x <commit-hash>
        
    
    This will generate a standardized commit message. This way, you (and your co-workers) can still keep track of the origin of the commit and may avoid merge conflicts in the future.
    
2.  If you have notes attached to the commit they do not follow the cherry-pick. To bring them over as well, You have to use:
    
        git notes copy <from> <to>
        
    

Additional links:

*   [git official guide page](http://git-scm.com/docs/git-cherry-pick)
*   [git cherry-pick guide](https://acompiler.com/git-cherry-pick/)

This quote is taken from: [Version Control with Git](https://rads.stackoverflow.com/amzn/click/com/1449316387)

> Using git cherry-pick The command git cherry-pick commit applies the changes introduced by the named commit on the current branch. It will introduce a new, distinct commit. **Strictly speaking, using git cherry-pick doesn’t alter the existing history within a repository; instead, it adds to the history. As with other Git operations that introduce changes via the process of applying a diff, you may need to resolve conflicts to fully apply the changes from the given commit** . The command git cherry-pick is typically used to introduce particular commits from one branch within a repository onto a different branch. A common use is to forward- or back-port commits from a maintenance branch to a development branch.

    $ git checkout rel_2.3
    $ git cherry-pick dev~2 # commit F, below
    

before: ![before](https://i.stack.imgur.com/R4nfN.png)

after: ![after](https://i.stack.imgur.com/23fCh.png)

Also, here is a very nice in action video tutorial about it: [Youtube: Introduction to Git cherry-pick](https://www.youtube.com/watch?v=-ndmel-4wsk)

Cherry picking in Git is designed to apply some commit from one branch into another branch. It can be done if you eg. made a mistake and committed a change into wrong branch, but do not want to merge the whole branch. You can just eg. revert the commit and cherry-pick it on another branch.

To use it, you just need `git cherry-pick hash`, where `hash` is a commit hash from other branch.

For full procedure see: [http://technosophos.com/2009/12/04/git-cherry-picking-move-small-code-patches-across-branches.html](http://technosophos.com/2009/12/04/git-cherry-picking-move-small-code-patches-across-branches.html)

I prepared step-by-step illustrations what _cherry-pick_ does — and an _animation of these illustrations_ (near the end).

1.  Before cherry-picking  
    (we are going to do a _cherry-pick_ of the commit `L` from the branch `feature`): [![An image showing the state of a Git repository before cherry-picking. On the master branch, there are five commits, A through E. A second branch, labeled 'feature', contains four commits and diverges at commit B. The 'feature' commits are labeled K through N, with L in the middle.](https://i.stack.imgur.com/x1R6o.jpg)](https://i.stack.imgur.com/x1R6o.jpg)

* * *

2.  Starting the command `git cherry-pick feature~2`  
    (`feature~2` is the 2nd commit before  
    `feature`, i.e. the commit `L`): [![This image shows the result of a cherry-pick operation taking the L commit out of the feature branch, and placing it after the E commit on the master branch.](https://i.stack.imgur.com/H1NDD.jpg)](https://i.stack.imgur.com/H1NDD.jpg)

* * *

3.  After performing the command (`git cherry-pick feature~2`): [![The master branch now contains a commit, called L', or L-prime. The feature branch is unchanged.](https://i.stack.imgur.com/LpDH8.jpg)](https://i.stack.imgur.com/LpDH8.jpg)

* * *

The same animated: [![An animation of the above steps.](https://i.stack.imgur.com/j2D9C.gif)](https://i.stack.imgur.com/j2D9C.gif)

* * *

_Note:_

The commit `L'` is _from the user's point of view (commit = snapshot)_ the exact copy of the commit `L`.

Technically (internally), it's a _new, different_ commit (because e.g. `L` contains a pointer to `K` (as its parent), while `L'` contains a pointer to `E`).

**Short example of situation, when you need cherry pick**

> Consider following scenario. You have two branches.
> 
> a) **release1** - This branch is going to your customer, but there are still some bugs to be fixed.
> 
> b) **master** - Classic master branch, where you can for example add functionality for release2.

**NOW**: You fix something in **release1**. Of course you need this fix also in **master**. And that is a typical use-case for cherry picking. So cherry pick in this scenario means that you take a commit from **release1** branch and include it into the **master** branch.

What does cherry picking a commit with git mean

在 React 或 JavaScript 的上下文中，这三个点被称作扩展运算符（spread operator）。扩展运算符有几种不同的用途：

1. **复制对象或数组**：
   扩展运算符可以用来创建对象或数组的浅拷贝。比如，如果我们有一个数组 `arr = [1, 2, 3]`，使用扩展运算符可以创建一个新的数组 `newArr = [...arr]`，这里 `newArr` 将是 `arr` 的一个拷贝，但是是一个新的实例。

   示例代码如下：
   ```javascript
   const originalArray = [1, 2, 3];
   const newArray = [...originalArray]; // newArray: [1, 2, 3]
   ```

2. **合并对象或数组**：
   扩展运算符可以用来合并两个或多个对象（或数组）。这在 React 的状态管理中特别有用，因为经常需要创建新的状态对象，而不是修改现有的状态。

   示例代码如下：
   ```javascript
   const obj1 = { a: 1, b: 2 };
   const obj2 = { b: 3, c: 4 };
   const mergedObject = { ...obj1, ...obj2 }; // mergedObject: { a: 1, b: 3, c: 4 }
   ```

   可以看到，如果有重复的键，后面的对象会覆盖前面的。

3. **函数参数展开**：
   当一个函数期望收到多个参数，而不是一个数组时，扩展运算符可以用来将一个数组'展开'为单独的参数。

   示例代码如下：
   ```javascript
   function sum(a, b, c) {
     return a + b + c;
   }
   const numbers = [1, 2, 3];
   const result = sum(...numbers); // 等同于 sum(1, 2, 3)
   ```

在 React 组件中，扩展运算符经常用来传递 `props`。例如，如果你有一个 `props` 对象，你想将它传递给子组件，你可以使用扩展运算符来传递整个 `props` 对象。

示例代码如下：
```javascript
const MyComponent = (props) => {
  return <ChildComponent {...props} />;
};
```

通过上述方法，`ChildComponent` 将接收到 `MyComponent` 中所有的 `props`，而无需逐一列出它们。这使得组件间的 `props` 传递更加灵活和简洁。

That's [_property spread notation_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax). It was added in ES2018 (spread for arrays/iterables was earlier, ES2015), but it's been supported in React projects for a long time via transpilation (as "[JSX spread attributes](https://reactjs.org/docs/jsx-in-depth.html#spread-attributes)" even though you could do it elsewhere, too, not just attributes).

`{...this.props}` _spreads out_ the "own" enumerable properties in `props` as discrete properties on the `Modal` element you're creating. For instance, if `this.props` contained `a: 1` and `b: 2`, then

    <Modal {...this.props} title='Modal heading' animation={false}>
    

would be the same as

    <Modal a={this.props.a} b={this.props.b} title='Modal heading' animation={false}>
    

But it's dynamic, so whatever "own" properties are in `props` are included.

Since `children` is an "own" property in `props`, spread will include it. So if the component where this appears had child elements, they'll be passed on to `Modal`. Putting child elements between the opening tag and closing tags is just syntactic sugar — the good kind — for putting a `children` property in the opening tag. Example:

Show code snippet

    class Example extends React.Component {
      render() {
        const { className, children } = this.props;
        return (
          <div className={className}>
          {children}
          </div>
        );
      }
    }
    ReactDOM.render(
      [
        <Example className="first">
          <span>Child in first</span>
        </Example>,
        <Example className="second" children={<span>Child in second</span>} />
      ],
      document.getElementById("root")
    );

    .first {
      color: green;
    }
    .second {
      color: blue;
    }

    <div id="root"></div>
    
    <script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.6.3/umd/react.production.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.6.3/umd/react-dom.production.min.js"></script>

Run code snippetHide results

Expand snippet

Spread notation is handy not only for that use case, but for creating a new object with most (or all) of the properties of an existing object — which comes up a lot when you're updating state, since you can't modify state directly:

    this.setState(prevState => {
        return {foo: {...prevState.foo, a: "updated"}};
    });
    

That replaces `this.state.foo` with a new object with all the same properties as `foo` except the `a` property, which becomes `"updated"`:

Show code snippet

    const obj = {
      foo: {
        a: 1,
        b: 2,
        c: 3
      }
    };
    console.log("original", obj.foo);
    // Creates a NEW object and assigns it to `obj.foo`
    obj.foo = {...obj.foo, a: "updated"};
    console.log("updated", obj.foo);

    .as-console-wrapper {
      max-height: 100% !important;
    }

Run code snippetHide results

Expand snippet

`...` are called **spread attributes** which, as the name represents, it allows an expression to be expanded.

    var parts = ['two', 'three'];
    var numbers = ['one', ...parts, 'four', 'five']; // ["one", "two", "three", "four", "five"]
    

And in this case (I'm going to simplify it).

    // Just assume we have an object like this:
    var person= {
        name: 'Alex',
        age: 35 
    }
    

This:

    <Modal {...person} title='Modal heading' animation={false} />
    

is equal to

    <Modal name={person.name} age={person.age} title='Modal heading' animation={false} />
    

So in short, it's a **neat** short-cut, _we can say_.

The three dots represent the **spread operator** in [ES6](https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_%E2%80%93_ECMAScript_2015). It allows us to do quite a few things in JavaScript:

1.  **Concatenate arrays**
    
         var shooterGames = ['Call of Duty', 'Far Cry', 'Resident Evil'];
         var racingGames = ['Need For Speed', 'Gran Turismo', 'Burnout'];
         var games = [...shooterGames, ...racingGames];
        
         console.log(games)  // ['Call of Duty', 'Far Cry', 'Resident Evil',  'Need For Speed', 'Gran Turismo', 'Burnout']
        
    
2.  **Destructuring an array**
    
           var shooterGames = ['Call of Duty', 'Far Cry', 'Resident Evil'];
           var [first, ...remaining] = shooterGames;
           console.log(first); //Call of Duty
           console.log(remaining); //['Far Cry', 'Resident Evil']
        
    
3.  **Combining two objects**
    
         var myCrush = {
           firstname: 'Selena',
           middlename: 'Marie'
         };
        
         var lastname = 'my last name';
        
         var myWife = {
           ...myCrush,
           lastname
         }
        
         console.log(myWife); // {firstname: 'Selena',
                              //   middlename: 'Marie',
                              //   lastname: 'my last name'}
        
    

There's another use for the three dots which is known as **Rest Parameters** and it makes it possible to take all of the arguments to a function in as one array.

4.  **Function arguments as array**
    
          function fun1(...params) {
        
          }

`...` (three dots in JavaScript) is called the Spread Syntax or Spread Operator. This allows an iterable such as an **array** expression or **string** to be expanded or an **object** expression to be expanded wherever placed. This is not specific to React. It is a JavaScript operator.

All these answers here are helpful, but I want to list down the mostly used practical Use Cases of the [Spread Syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax) (Spread Operator).

**1\. Combine Arrays (Concatenate Arrays)**

There are a [variety of ways to combine arrays](https://davidwalsh.name/combining-js-arrays), but the spread operator allows you to place this at any place in an array. If you'd like to combine two arrays and place elements at any point within the array, you can do as follows:

    var arr1 = ['two', 'three'];
    var arr2 = ['one', ...arr1, 'four', 'five'];
    
    // arr2 = ["one", "two", "three", "four", "five"]
    

**2\. Copying Arrays**

When we wanted a copy of an array, we used to have the [`Array.prototype.slice()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) method. But, you can do the same with the spread operator.

    var arr = [1,2,3];
    var arr2 = [...arr];
    // arr2 = [1,2,3]
    

**3\. Calling Functions without Apply**

In ES5, to pass an array of two numbers to the `doStuff()` function, you often use the [`Function.prototype.apply()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply) method as follows:

    function doStuff (x, y, z) {}
    var args = [0, 1, 2];
    
    // Call the function, passing args
    doStuff.apply(null, args);
    

However, by using the spread operator, you can pass an array into the function.

    doStuff(...args);
    

**4\. Destructuring Arrays**

You can use destructuring and the rest operator together to extract the information into variables as you'd like them:

    let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
    console.log(x); // 1
    console.log(y); // 2
    console.log(z); // { a: 3, b: 4 }
    

**5\. Function Arguments as Rest Parameters**

ES6 also has three dots (`...`) which indicates a rest parameter that collects all remaining arguments of a function into an array.

    function f(a, b, ...args) {
      console.log(args);
    }
    
    f(1, 2, 3, 4, 5); // [3, 4, 5]
    

**6\. Using Math Functions**

Any function where spread is used as the argument can be used by functions that can accept any number of arguments.

    let numbers = [9, 4, 7, 1];
    Math.min(...numbers); // 1
    

**7\. Combining Two Objects**

You can use the spread operator to combine two objects. This is an easy and cleaner way to do it.

    var carType = {
      model: 'Toyota',
      yom: '1995'
    };
    
    var carFuel = 'Petrol';
    
    var carData = {
      ...carType,
      carFuel
    }
    
    console.log(carData);
    // {
    //  model: 'Toyota',
    //  yom: '1995',
    //  carFuel = 'Petrol'
    // }
    

**8\. Separate a String into Separate Characters**

You can use the spread operator to spread a string into separate characters.

    let chars = ['A', ...'BC', 'D'];
    console.log(chars); // ["A", "B", "C", "D"]
    

You can think of more ways to use the Spread Operator. What I have listed here are the popular use cases of it.

The three dots in JavaScript are the **spread / rest operator**.

**Spread operator**

The [spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator) allows an expression to be expanded in places where multiple arguments are expected.

    myFunction(...iterableObj);
    
    [...iterableObj, 4, 5, 6]
    
    [...Array(10)]
    

**Rest parameters**

The [rest](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/rest_parameters) parameter syntax is used for functions with a variable number of arguments.

    function(a, b, ...theArgs) {
      // ...
    }
    

The spread / rest operator for arrays was introduced in [ES6](https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_%E2%80%93_ECMAScript_2015). There's a State 2 [proposal](https://github.com/sebmarkbage/ecmascript-rest-spread) for object spread / rest properties.

TypeScript also supports the spread syntax and can transpile that into older versions of ECMAScript with minor [issues](https://github.com/Microsoft/TypeScript/issues/8856).

What are these three dots in React doing?

在 Next.js 中，您通常会处理图片和文本上传到服务器的情况。通常，您会使用一个表单来收集用户输入的文本和图片，然后发送一个 HTTP 请求（通常是 POST 请求）到您的 API 路径。

以下是一个示例流程，说明如何同时上传图片和文本：

1. **创建一个带有文件输入和文本输入的表单**：用户可以在表单中填写文本信息并选择图片文件。

2. **使用 `FormData` API 为上传创建数据**：在客户端，您可以使用 `FormData` API 来构建表单数据对象。这允许您将文本和文件数据组合在一起。

3. **发送带有图片和文本的请求**：使用 `fetch` 或任何其他 HTTP 客户端从客户端发送带有表单数据的 POST 请求到服务器。

4. **服务器端接收处理**：在服务器端，您需要有一个 API 路径来接收这个请求。在 Next.js 中，您可以在 `pages/api` 目录中创建一个 API 路由处理这个请求。

5. **存储文件和文本**：在服务器端，您可以使用像 `multer` 这样的中间件来处理图片文件的上传，并将文本数据存储在数据库中。

下面是一个基本的代码示例，说明了如何在 Next.js 应用程序中进行操作。

#### 前端代码 (React 组件)

```jsx
import React, { useState } from 'react';

function UploadForm() {
    const [file, setFile] = useState(null);
    const [text, setText] = useState('');

    const handleFileChange = (e) => {
        setFile(e.target.files[0]);
    };

    const handleTextChange = (e) => {
        setText(e.target.value);
    };

    const handleSubmit = async (e) => {
        e.preventDefault();

        // 创建 FormData 对象
        const formData = new FormData();
        formData.append('image', file);
        formData.append('text', text);

        // 发送请求到 /api/upload API 路径
        const response = await fetch('/api/upload', {
            method: 'POST',
            body: formData,
        });

        // ...处理响应...
    };

    return (
        <form onSubmit={handleSubmit}>
            <input type="text" value={text} onChange={handleTextChange} />
            <input type="file" onChange={handleFileChange} />
            <button type="submit">Upload</button>
        </form>
    );
}

export default UploadForm;
```

#### 后端代码 (Next.js API 路径 `/pages/api/upload.js`)

```javascript
import nextConnect from 'next-connect';
import multer from 'multer';

const upload = multer({ dest: 'uploads/' }); // 配置 multer，定义文件存储位置

const apiRoute = nextConnect({
    // 处理任何其他 HTTP 方法
    onNoMatch(req, res) {
        res.status(405).json({ error: `Method ${req.method} Not Allowed` });
    },
});

// 处理单个文件上传，文件字段名为 'image'
apiRoute.use(upload.single('image'));

apiRoute.post((req, res) => {
    const { text } = req.body; // 这是上传的文本数据
    const { file } = req; // 这是上传的文件信息

    // 处理文本和文件存储...

    res.status(200).json({ message: 'File uploaded successfully' });
});

export default apiRoute;
```

这个简单的例子展示了如何在 Next.js 应用中处理同时上传图片和文本的情况。前端使用 `FormData` 收集用户输入，而后端使用 `next-connect` 和 `multer` 中间件来处理 `multipart/form-data` 类型的请求。您可能还需要进一步处理存储逻辑，例如将文件保存到云存储服务，或者将文本数据存储到数据库中。

Your current frontend code attempts to send form data as JSON, which is not suitable for file uploads. Instead, you should use `FormData` to handle both files and text. Here is how you can modify your `handleSubmit`:

    async function handleSubmit(e: React.FormEvent<HTMLFormElement>) {
        e.preventDefault();
        
        // Initialize FormData
        const formData = new FormData(e.currentTarget); // Assuming 'e.currentTarget' is your form
        // Append additional data if necessary
        // formData.append('key', 'value');
    
        const res = await fetch("/api/articles", {
          method: "POST",
          body: formData, // Send formData directly without JSON.stringify
          // Remove 'content-type': 'application/json' header since it's not JSON anymore
        });
    
        if (!res.ok) {
          throw new Error("failed to create ticket.");
        }
    
        router.refresh();
        router.push("/");
    }
    

`POST` function parameters are incorrect. Next.js API routes should take `req` (the request object) and `res` (the response object) as parameters. Reading form data on the server side in Next.js should use `next-connect` or a similar middleware because Next.js does not natively parse `FormData` on the server side.

Install `next-connect` and `formidable`:

    npm install next-connect formidable
    

Modify your API route to correctly handle `FormData`:

    import nextConnect from 'next-connect';
    import { promises as fs } from 'fs';
    import path from 'path';
    import formidable from 'formidable';
    import Post from '@/app/(model)/post';
    
    const apiRoute = nextConnect({
      onError(error, req, res) {
        res.status(501).json({ error: `Sorry something Happened! ${error.message}` });
      },
      onNoMatch(req, res) {
        res.status(405).json({ error: `Method '${req.method}' Not Allowed` });
      },
    });
    
    apiRoute.post(async (req, res) => {
      const form = new formidable.IncomingForm();
      form.uploadDir = "./public/uploads";
      form.keepExtensions = true;
      form.parse(req, async (err, fields, files) => {
        if (err) {
          res.status(500).json({ error: 'Something went wrong during the file upload' });
          return;
        }
        // Process the file, save to your desired location
        const file = files.file; // This depends on the 'name' attribute in your form
        const postData = fields; // Your text fields
        // Move or use the file as needed
        const newPath = path.join(form.uploadDir, file.originalFilename);
        await fs.rename(file.filepath, newPath);
        // Save your postData into the database
        await Post.create(postData);
        res.status(201).json({ message: 'Post created successfully' });
      });
    });
    
    export const config = {
      api: {
        bodyParser: false, // Disabling bodyParser is important here
      },
    };
    
    export default apiRoute;

How do i upload an image and some texts in nextjs typescript

在JavaScript中，要在客户端使用`file-type`来检测文件类型，首先需要引入`file-type`这个库。这个库可以帮助我们读取文件的二进制数据，并分析这些数据来确定文件的实际类型。以下是如何使用`file-type`库检测文件类型的步骤：

1. 安装`file-type`库。如果你在使用的是现代前端项目，可能会使用npm或yarn来安装。可以运行以下命令来安装它：

```bash
npm install file-type
# 或者
yarn add file-type
```

2. 引入`file-type`模块。在你的JavaScript模块中，你可以使用import导入file-type。

```javascript
import fileType from 'file-type';
```

3. 读取文件。在浏览器中，通常我们可以通过`<input type="file">`来让用户选择文件，然后使用`FileReader` API读取这个文件的二进制数据。

4. 使用`file-type`库来检测文件类型。`file-type`接受一个`Buffer`或`Uint8Array`，并返回一个包含文件类型信息的对象。

以下是一个完整的示例，展示了如何在浏览器中使用`file-type`来检测用户选择的文件类型：

```html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>File Type Detection</title>
</head>
<body>

<input type="file" id="fileInput">

<script type="module">
    import fileType from 'file-type/browser';

    document.getElementById('fileInput').addEventListener('change', async (event) => {
        const file = event.target.files[0];
        if (!file) {
            console.log("No file selected!");
            return;
        }

        const arrayBuffer = await file.arrayBuffer();
        const typedArray = new Uint8Array(arrayBuffer);

        const result = await fileType.fromBuffer(typedArray);

        if (result) {
            console.log(`File type: ${result.mime}`);
            console.log(`File extension: ${result.ext}`);
        } else {
            console.log("Could not determine the file type.");
        }
    });
</script>

</body>
</html>
```

上面的代码中，我们首先在HTML文件中创建了一个文件输入元素。然后在JavaScript模块中，我们引入了`file-type`的浏览器版本，并为文件输入元素添加了`change`事件监听器。当用户选择文件时，我们读取这个文件的内容，将其转换为`Uint8Array`，然后使用`file-type`的`fromBuffer`方法分析这个数组，最终输出文件的类型信息。

需要注意的是，`file-type`版本更新可能会带来API的变化，因此在使用时需要参考当时最新的官方文档。

Finally got this working. In case anyone else is stuck on this, here's an explanation (apologies for the lack of brevity - probably this should be a blog post...).

To flesh out the use case a bit further, I'm using [Uppy](https://uppy.io/) to allow users to upload files to an AWS S3 bucket. The way this works is that, when the user uploads a file, Uppy makes a call to my server where an AWS pre-signed URL is generated and passed back to the client. The client then uses that pre-signed URL to upload the file directly to the S3 bucket, bypassing the server, such that the file doesn't pass through the server at any point.

The problem I was attempting to solve was that files missing an extension ended up uploaded with the content / MIME type set as "application/octet", because it seems the browser, Uppy, and S3 all rely on the file extension to decide the file type (rather than parsing the so-called "magic bytes" of the file), and if the file extension is missing, AWS defaults to "application/octet". This causes issues when users attempt to open the file, as they are not handled correctly (i.e. a png file without an extension and with an "application/octet" content / MIME type opens a download dialog rather than being previewed, etc.). I also want to validate the MIME type / file type in cases even where the extension exists so that I can exclude certain types of files, and so the files get handled appropriately when they are later downloaded (where the MIME type will again be validated) if an incorrect file extension is used.

I use the "file-type" NPM module to determine the mimetype server side, and that's straight forward enough, but changing the file's content type / MIME type when generating the AWS pre-signed URL is not enough to fix the problem - it still gets uploaded as "application/octet". I wanted to use the same module client side so we get the exact same results on the client as on the server, and needed in any case to determine the MIME type and set it accordingly pre-upload but post-pre-signed URL. I had no idea how to do this (i.e. use "file-type" client side - the meat of my question).

I finally gave up on Webpack - nothing I tried worked. So I switched to Browserify, and the sample browser code at the "file-type" repository worked at once! So then I was left trying to figure out how to pass a function through Browserify to use in the client side code.

This proved impossible for me - I couldn't figure out how to pass the asynchronous IIFE through to my code. So instead, I moved my Uppy code into the code I pass to Browserify:

    // Get the dependency, which we've added to node via "npm install file-type":
    const FileType = require('file-type/browser');
    
    // When the user adds a file for upload to Uppy...
    uppy.on('file-added', (file) => {
        
        // 1. Create a filereader:
        const filereader = new FileReader();
        
        filereader.onloadend = function(evt) {
            
            // 4. Once the filereader has successfully finished reading the file...
            if (evt.target.readyState === FileReader.DONE) {
                
                // Get the unsigned 8 bit int8Array (ie Uint8Array) of the 600 bytes (this looks like '[119,80,78,71...]'):
                const uint = new Uint8Array(evt.target.result);
           
                // Determine the mime type using the "file-type" NPM package:
                (async () => {
                    
                    // Pass in our 600 bytes ("uint"):
                    const fileType = await FileType.fromBuffer(uint);
                
                    console.log(fileType); // outputs => {ext: 'jpg', mime: 'image/jpeg'}
                    
                    // Do some validation here...
                    
                    //
                    
                    //  Assign the results to the file for upload - we're done!:
                    file.extension = fileType.ext;
                    file.meta.type = fileType.mime;
                    file.type = fileType.mime;
                })();
            }
        }
        
        // 2. Grab the first 600 bytes of the file for mime type analysis server side - most mime
        // types use the first few bytes, but some (looking at you, Microsoft...) start at the 
        // 513th byte; ISO CD files start at the 32,770th byte, so we'll ignore those rather than 
        // send that much data for each file - users of this system certainly aren't expected to 
        // upload ISO CD files! Also, some .zip files may start their identifying bytes at the 
        // 29,153nd byte - we ignore those too (mostly, .zip files start at the first, 31st, or 527th byte).
        const blob = file.data.slice(0, 600);        
        
        // 3. Start reading those 600 bytes...continues above at 'filereader.onloadend':
        filereader.readAsArrayBuffer(blob);
    })
    

That all goes into a file I call "index.js" and then, having installed Browserify at the command line via "npm install -g browserify", I use this at the command line to create the file ("main.js") I link to in my client side code:

    browserify index.js -o main.js

How to use file type npm module client side

在React中，如果您想要在某些情况下（例如，当内容更新时）将`div`滚动到底部，可以通过编程方式操作DOM来实现。以下是几种可以实现这个需求的方法：

### 使用`ref`和DOM方法

您可以通过React的`ref`属性获得DOM元素的直接引用，并使用原生的DOM方法来滚动到底部。这可以通过设置`scrollTop`来实现，`scrollTop`应该等于`scrollHeight`减去`clientHeight`。

```jsx
import React, { useRef, useEffect } from 'react';

function ChatComponent() {
  const messagesEndRef = useRef(null);

  const scrollToBottom = () => {
    messagesEndRef.current.scrollIntoView({ behavior: "smooth" });
  };

  useEffect(scrollToBottom, []); // 如果希望在组件首次渲染时滚动到底部，可以添加空数组作为依赖项

  return (
    <div style={{ overflowY: 'auto', height: '500px' }}>
      {/* 消息内容 */}
      <div>{/* ... */}</div>
      {/* 用于滚动的元素 */}
      <div ref={messagesEndRef} />
    </div>
  );
}
```

这里，`useEffect`用于在组件的生命周期内在适当的时刻触发滚动行为。

### 使用`scrollTop`和`scrollHeight`

如果您想要更直接控制滚动位置，可以直接设置`scrollTop`属性：

```jsx
import React, { useRef, useEffect } from 'react';

function ScrollToBottomComponent() {
  const divRef = useRef(null);

  const scrollToBottom = () => {
    const scrollHeight = divRef.current.scrollHeight;
    const height = divRef.current.clientHeight;
    const maxScrollTop = scrollHeight - height;
    divRef.current.scrollTop = maxScrollTop > 0 ? maxScrollTop : 0;
  };

  useEffect(scrollToBottom, []); // 依据实际情况，可能需要添加其他依赖项，如消息数组

  return (
    <div ref={divRef} style={{ overflowY: 'auto', height: '500px' }}>
      {/* 消息内容 */}
      {/* ... */}
    </div>
  );
}
```

在这个例子中，我们在`useEffect`中调用`scrollToBottom`函数，这会在组件渲染后立即将`div`滚动到底部。

### 自动滚动处理新消息

如果您的`div`包含一个聊天界面，您可能希望在新消息到来时自动滚动到底部。这可以通过在`useEffect`中跟踪消息数组的变化来实现：

```jsx
import React, { useRef, useEffect } from 'react';

function AutoScrollToBottomComponent({ messages }) {
  const divRef = useRef(null);

  useEffect(() => {
    if (divRef.current) {
      const { scrollHeight, clientHeight } = divRef.current;
      divRef.current.scrollTop = scrollHeight - clientHeight;
    }
  }, [messages]); // 当消息数组改变时触发滚动

  return (
    <div ref={divRef} style={{ overflowY: 'auto', height: '300px' }}>
      {messages.map((message, index) => (
        <div key={index}>{message}</div>
      ))}
    </div>
  );
}
```

在这个例子中，每当传入组件的`messages`数组发生变化时，`useEffect`钩子就会执行，导致`div`自动滚动到底部。

以上就是在React中将`div`滚动到底部的几种方法。您可以根据您应用的具体需求选择适合的实现方式。

As Tushar mentioned, you can keep a dummy div at the bottom of your chat:

    render () {
      return (
        <div>
          <div className="MessageContainer" >
            <div className="MessagesList">
              {this.renderMessages()}
            </div>
            <div style={{ float:"left", clear: "both" }}
                 ref={(el) => { this.messagesEnd = el; }}>
            </div>
          </div>
        </div>
      );
    }
    

and then scroll to it whenever your component is updated (i.e. state updated as new messages are added):

    scrollToBottom = () => {
      this.messagesEnd.scrollIntoView({ behavior: "smooth" });
    }
    
    componentDidMount() {
      this.scrollToBottom();
    }
    
    componentDidUpdate() {
      this.scrollToBottom();
    }
    

I'm using the standard [Element.scrollIntoView](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView) method here.

I just want to update the answer to match the new `React.createRef()` [method](https://reactjs.org/docs/refs-and-the-dom.html), but it's basically the same, just have in mind the `current` property in the created ref:

    class Messages extends React.Component {
    
      const messagesEndRef = React.createRef()
    
      componentDidMount () {
        this.scrollToBottom()
      }
      componentDidUpdate () {
        this.scrollToBottom()
      }
      scrollToBottom = () => {
        this.messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
      }
      render () {
        const { messages } = this.props
        return (
          <div>
            {messages.map(message => <Message key={message.id} {...message} />)}
            <div ref={this.messagesEndRef} />
          </div>
        )
      }
    }
    

UPDATE:

Now that hooks are available, I'm updating the answer to add the use of the `useRef` and `useEffect` hooks, the real thing doing the magic (React refs and `scrollIntoView` DOM method) remains the same:

    import React, { useEffect, useRef } from 'react'
    
    const Messages = ({ messages }) => {
    
      const messagesEndRef = useRef(null)
    
      const scrollToBottom = () => {
        messagesEndRef.current?.scrollIntoView({ behavior: "smooth" })
      }
    
      useEffect(() => {
        scrollToBottom()
      }, [messages]);
    
      return (
        <div>
          {messages.map(message => <Message key={message.id} {...message} />)}
          <div ref={messagesEndRef} />
        </div>
      )
    }
    

Also made a (very basic) codesandbox if you wanna check the behaviour [https://codesandbox.io/s/scrolltobottomexample-f90lz](https://codesandbox.io/s/scrolltobottomexample-f90lz)

Do not use [`findDOMNode`](https://github.com/yannickcr/eslint-plugin-react/issues/678) ["because it blocks certain improvements in React in the future"](https://github.com/jsx-eslint/eslint-plugin-react/issues/678#issue-165177220)

Class components with ref
=========================

    class MyComponent extends Component {
      componentDidMount() {
        this.scrollToBottom();
      }
    
      componentDidUpdate() {
        this.scrollToBottom();
      }
    
      scrollToBottom() {
        this.el.scrollIntoView({ behavior: 'smooth' });
      }
    
      render() {
        return <div ref={el => { this.el = el; }} />
      }
    }
    

Function components with hooks:
===============================

    import React, { useRef, useEffect } from 'react';
    
    const MyComponent = () => {
      const divRef = useRef(null);
    
      useEffect(() => {
        divRef.current.scrollIntoView({ behavior: 'smooth' });
      });
    
      return <div ref={divRef} />;
    }

Thanks to @enlitement

we should avoid using `findDOMNode`, we can use `refs` to keep track of the components

    render() {
      ...
    
      return (
        <div>
          <div
            className="MessageList"
            ref={(div) => {
              this.messageList = div;
            }}
          >
            { messageListContent }
          </div>
        </div>
      );
    }
    
    
    
    scrollToBottom() {
      const scrollHeight = this.messageList.scrollHeight;
      const height = this.messageList.clientHeight;
      const maxScrollTop = scrollHeight - height;
      this.messageList.scrollTop = maxScrollTop > 0 ? maxScrollTop : 0;
    }
    
    componentDidUpdate() {
      this.scrollToBottom();
    }
    

reference:

*   [https://facebook.github.io/react/docs/react-dom.html#finddomnode](https://facebook.github.io/react/docs/react-dom.html#finddomnode)
*   [https://www.pubnub.com/blog/2016-06-28-reactjs-chat-app-infinite-scroll-history-using-redux/](https://www.pubnub.com/blog/2016-06-28-reactjs-chat-app-infinite-scroll-history-using-redux/)

The easiest and best way I would recommend is.
----------------------------------------------

_My ReactJS version: 16.12.0_

* * *

> For Class Components
> --------------------

**HTML structure** inside `render()` function

        render()
            return(
                <body>
                    <div ref="messageList">
                        <div>Message 1</div>
                        <div>Message 2</div>
                        <div>Message 3</div>
                    </div>
                </body>
            )
        )
    

`scrollToBottom()` function which will get reference of the element. and scroll according to `scrollIntoView()` function.

      scrollToBottom = () => {
        const { messageList } = this.refs;
        messageList.scrollIntoView({behavior: "smooth", block: "end", inline: "nearest"});
      }
    

and call the above function inside `componentDidMount()` and `componentDidUpdate()`

* * *

> For Functional Components (Hooks)
> ---------------------------------

Import `useRef()` and `useEffect()`

    import { useEffect, useRef } from 'react'
    

Inside your export function, (same as calling a `useState()`)

    const messageRef = useRef();
    

And let's assume you have to scroll when page load,

    useEffect(() => {
        if (messageRef.current) {
          messageRef.current.scrollIntoView(
            {
              behavior: 'smooth',
              block: 'end',
              inline: 'nearest'
            })
        }
      })
    

OR if you want it to trigger once an action performed,

    useEffect(() => {
      if (messageRef.current) {
        messageRef.current.scrollIntoView(
          {
            behavior: 'smooth',
            block: 'end',
            inline: 'nearest'
          })
      }
    },
    [stateVariable])
    

And Finally, to your **HTML structure**

    return(
        <body>
            <div ref={messageRef}> // <= The only different is we are calling a variable here
                <div>Message 1</div>
                <div>Message 2</div>
                <div>Message 3</div>
            </div>
        </body>
    )
    

for more explanation about `Element.scrollIntoView()` visit [developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView)

More detailed explanation in Callback refs visit [reactjs.org](https://reactjs.org/docs/refs-and-the-dom.html#callback-refs)

How to scroll to bottom in react?

如何检测 iframe 中的 404 错误？,在 HTML 中嵌入 `<iframe>` 通常用于在当前页面中加载另一页面。但是，当尝试加载的页面不存在或出现问题时（如返回 404 错误），默认情况下，浏览器不会提供直接的方法来检测这种错误。不过，我们可以使用一些技巧来尝试检测 `<iframe>` 中的 404 错误。

以下是一种可能的方法，使用 JavaScript 来检测 `<iframe>` 中的加载错误：

```javascript
window.addEventListener('load', function() {
  var iframe = document.getElementById('my-iframe');
  iframe.addEventListener('load', function() {
    try {
      // 尝试获取 iframe 的内容，可能会因同源策略而失败
      var iframeDoc = iframe.contentDocument || iframe.contentWindow.document;

      // 检查页面是否真的加载了，通过检测 body 是否存在
      if (iframeDoc.body && iframeDoc.body.innerHTML.trim().length > 0) {
        // 页面正常加载
      } else {
        // 页面没有正常加载，可能是 404 或其他错误页面
        console.error('Iframe load failed.');
      }
    } catch (e) {
      // 同源策略错误，无法读取 iframe 的内容
      console.error('Cross-origin iframe detected. Unable to read the contents.');
    }
  });

  // 可以尝试通过设置 iframe 的 src 属性来加载页面
  iframe.src = 'https://example.com/some-page.html';
});
```

请注意，由于浏览器的同源策略（Same-Origin Policy），如果 `<iframe>` 加载的页面不是同源的，JavaScript 将无法访问 `<iframe>` 中的内容。这意味着上面的代码在跨域的情况下无法工作，并且会在控制台中抛出错误。

如果你有控制 iframe 内容页面的权限，你可以考虑在那个页面中使用 JavaScript 来发送一个消息回父页面，告知它页面已经成功加载。这可以通过 `window.postMessage` 方法完成。父页面监听这些消息，如果没有收到预期的消息，就可以假设页面加载失败了（可能是 404 或其他错误）。

这是一个简单的使用 `window.postMessage` 的示例：

父页面:

```javascript
window.addEventListener('message', function(event) {
  // 确保消息是从你的 iframe 页面发送的
  if (event.origin === 'https://example.com') {
    if (event.data === 'loadSuccess') {
      console.log('iframe loaded successfully');
    }
  }
}, false);

var iframe = document.getElementById('my-iframe');
iframe.src = 'https://example.com/some-page.html';
```

iframe 内容页面:

```javascript
// 在内容页面加载完成时发送消息
window.onload = function() {
  // 发送消息到父页面
  window.parent.postMessage('loadSuccess', '*');
};
```

请确保在实际环境中替换 `'*'` 为父页面的源（例如 `'https://parent-website.com'`），以提高安全性。这样可以防止向任意的接收者发送消息。

状态仅存在于响应标头中。
------------

404 页面正在处理[HTTP 状态代码](http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml)，该状态代码仅包含在服务器发送到浏览器的响应中，但不包含在javascript 可以访问的实际 DOM`window`和对象中。`document`这意味着，虽然您当然可以收集状态代码并采取适当的操作，但您只能在 javascript 接收响应时执行此操作，例如使用 jQuery.ajax [() 请求](https://stackoverflow.com/questions/17863062/detect-http-301-status-code-from-javascript)或[XmlHttRequest 来加载“iframe”](https://stackoverflow.com/a/10419343/1589379)。

### 希望404页面遵循404标准。

如果上述方法不可行，则唯一的其他可能性可能是检查标题和/或 H 标签中的“ 404 ”。虽然这肯定不太理想（我很想看到“404，找不到电影，电影。”），但这是您唯一的其他选择。

    $('#iframe').load(function (e) {
        var iframe = $("#iframe")[0];
    
        if ( iframe.innerHTML() ) {
            // get and check the Title (and H tags if you want)
            var ifTitle = iframe.contentDocument.title;
            if ( ifTitle.indexOf("404")>=0 ) {
                // we have a winner! probably a 404 page!
            }
        } else {
            // didn't load
        }
    });

假设这是你的 html

    <html>
        <head></head>
        <body>
          <iframe id="iframe"></iframe>
        </body>
     </html>
    

有两种场景

1.  您的 iframe 的 src 与您的页面来源位于同一域中。
    
        Ex : page url www.example.com and iframe's src www.example.com/iframe
        
    
    您可以使用 jQuery ajax 请求来检查资源是否可用
    
           $(function() {
                $.ajax({
                    type : "HEAD",
                    async : true,
                    url : "www.example.com/iframe"
                })
                .success(function() {
                    $("#iframe").attr("src", "www.example.com/iframe");
                })
                .error(function(){
                   // Handle error perhaps a failover url
                })
            });
        
    
2.  您的 iframe 的 src 未指向您的页面来源的同一域。
    
        Ex : Page url www.example.com and iframe's src www.otherdomain.com/iframe
        
    
    [现在，由于跨源政策，](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS)浏览器将不允许您从 javascript 代码发出跨站点请求。解决方法是发出[jsonp 请求](https://en.wikipedia.org/wiki/JSONP)。
    
        $(function() {
            $.ajax({
                url: "www.otherdomain.com/iframe",
                dataType: "jsonp",
                timeout: 5000,
        
                success: function () {
                    $("#iframe").attr("src", "www.otherdomain.com/iframe");
                },
                error: function (parsedjson) {
                    if(parsedjson.status == "200") {
                        $("#iframe").attr("src", "www.otherdomain.com/iframe");
                    } else {
                        // Handle error
                    }
                }
            });
        });

How to detect an error 404 in an iframe?

在 Flutter 中，您通常会使用 `Color` 类来表示颜色，它接受一个 ARGB 整数作为参数。十六进制颜色字符串通常表示为 RGB 或 ARGB 格式，例如 `"#RRGGBB"` 或 `"#AARRGGBB"`，这里的 `AA` 是可选的，并表示透明度（alpha channel）。

为了使用十六进制颜色字符串，您需要将它转换成 Flutter 的 `Color` 对象。下面是如何做到这一点的步骤：

1. 如果字符串不包含透明度（即长度为 6 个字符，如 `"#RRGGBB"`），您需要在字符串前面添加 `"0xFF"` 表示完全不透明。
2. 使用 Dart 的 `int.parse` 函数将十六进制字符串转换为整数。
3. 创建一个 `Color` 对象并传入转换后的整数值。

下面是一个例子：

```dart
String hexColorStr = "#34A853"; // 一个示例颜色字符串，不带透明度
String hexColorStrWithAlpha = "#FF34A853"; // 这个字符串包括透明度（FF 表示完全不透明）

// 如果不包含透明度值，添加“0xFF”来使用完全不透明的颜色
hexColorStr = "0xFF" + hexColorStr.substring(1);

// 将颜色字符串转换成十六进制整数并创建 Color 对象
Color color = Color(int.parse(hexColorStr));

// 如果包括透明度值，直接解析
Color colorWithAlpha = Color(int.parse(hexColorStrWithAlpha.substring(1), radix: 16));

// 现在可以在 Flutter 中使用这个颜色了，例如:
Container(
  color: color, // 或者用 colorWithAlpha
  child: ...
);
```

请注意，在 Dart 中，十六进制数是以 `"0x"` 开头的，因此我们在解析时需要去掉字符串中的 `"#"` 并替换为 `"0x"`（或者直接添加 `"0xFF"` 作为不透明度前缀）。

以上就是在 Flutter 中使用十六进制颜色字符串的一种方法。

在 Flutter 中，**[`Color`类](https://api.flutter.dev/flutter/dart-ui/Color-class.html)**只接受_**整数**作为参数_，或者可以使用命名构造函数[`fromARGB`](https://api.flutter.dev/flutter/dart-ui/Color/Color.fromARGB.html)和[`fromRGBO`](https://api.flutter.dev/flutter/dart-ui/Color/Color.fromRGBO.html)。

所以我们只需要将字符串转换`#b74093`为整数值即可。此外，我们还需要尊重始终需要指定的**不透明度。**  
`255`（完全）不透明度由十六进制值表示`FF`。这已经给我们留下了**`0xFF`**。现在，我们只需要像这样附加颜色字符串：

    const color = const Color(0xffb74093); // Second `const` is optional in assignments.
    

字母可以选择大写或不大写：

    const color = const Color(0xFFB74093);
    

* * *

如果您想使用_不透明度百分比值，您可以_[用此表](https://gist.github.com/creativecreatorormaybenot/8710f6f752f6a0f2cae13abb538f0e8e#hex-opacity-values)`FF`中的值替换第一个值（也适用于其他颜色通道）。[](https://gist.github.com/creativecreatorormaybenot/8710f6f752f6a0f2cae13abb538f0e8e#hex-opacity-values)

扩展类
---

[从 Dart 开始`2.6.0`，您可以为该类创建一个`extension`](https://stackoverflow.com/a/58288266/6509751)`Color`允许您使用十六进制颜色字符串来创建对象的for类`Color`：

    extension HexColor on Color {
      /// String is in the format "aabbcc" or "ffaabbcc" with an optional leading "#".
      static Color fromHex(String hexString) {
        final buffer = StringBuffer();
        if (hexString.length == 6 || hexString.length == 7) buffer.write('ff');
        buffer.write(hexString.replaceFirst('#', ''));
        return Color(int.parse(buffer.toString(), radix: 16));
      }
    
      /// Prefixes a hash sign if [leadingHashSign] is set to `true` (default is `true`).
      String toHex({bool leadingHashSign = true}) => '${leadingHashSign ? '#' : ''}'
          '${alpha.toRadixString(16).padLeft(2, '0')}'
          '${red.toRadixString(16).padLeft(2, '0')}'
          '${green.toRadixString(16).padLeft(2, '0')}'
          '${blue.toRadixString(16).padLeft(2, '0')}';
    }
    

该方法也可以在or`fromHex`中声明，因为需要显式指定名称才能使用它，但扩展对于该方法很有用，可以隐式使用。这是一个例子：`mixin``class``HexColor``toHex`

    void main() {
      final Color color = HexColor.fromHex('#aabbcc');
    
      print(color.toHex());
      print(const Color(0xffaabbcc).toHex());
    }
    

### 使用十六进制字符串的缺点

这里的许多其他答案都展示了如何`Color`从十六进制字符串动态创建 a ，就像我上面所做的那样。然而，这样做意味着颜色不能是`const`.  
理想情况下，您可以按照我在本答案第一部分中解释的方式分配颜色，这在大量实例化颜色时更有效，这通常是 Flutter 小部件的情况。

该类`Color`需要一个 ARGB 整数。_由于您尝试将其与RGB_值一起使用，因此请将其表示为_int_并添加前缀`0xff`.

    Color mainColor = Color(0xffb74093);
    

* * *

如果您对此感到烦恼并且仍然希望使用字符串，您可以扩展`Color`并添加一个字符串构造函数

    class HexColor extends Color {
      static int _getColorFromHex(String hexColor) {
        hexColor = hexColor.toUpperCase().replaceAll("#", "");
        if (hexColor.length == 6) {
          hexColor = "FF" + hexColor;
        }
        return int.parse(hexColor, radix: 16);
      }
    
      HexColor(final String hexColor) : super(_getColorFromHex(hexColor));
    }
    

用法

    Color color1 = HexColor("b74093");
    Color color2 = HexColor("#b74093");
    Color color3 = HexColor("#88b74093"); // If you wish to use ARGB format

如果你想使用格式为#123456的颜色的十六进制代码，那么这很容易做到。创建一个 Color 类型的变量并为其分配以下值。

    Color myHexColor = Color(0xff123456)
    
    // Here you notice I use the 0xff and that is the opacity or transparency
    // of the color and you can also change these values.
    

使用 myHexColor 就可以开始了。

如果要直接从十六进制代码更改颜色的不透明度，请将_0xff中的__ff_值更改为下表中的相应值。（或者你可以使用

    myHexColor.withOpacity(0.2)
    

这是更简单的方法。0.2 是平均 20% 不透明度）

### 十六进制不透明度值

    100% — FF
    
    95% — F2
    
    90% — E6
    
    85% — D9
    
    80% — CC
    
    75% — BF
    
    70% — B3
    
    65% — A6
    
    60% — 99
    
    55% — 8C
    
    50% — 80
    
    45% — 73
    
    40% — 66
    
    35% — 59
    
    30% — 4D
    
    25% — 40
    
    20% — 33
    
    15% — 26
    
    10% — 1A
    
    5% — 0D
    
    0% — 00

**如何在 Flutter 中使用十六进制颜色代码#B74093**

只需从十六进制颜色代码中删除该`#`符号，并在 Color 类中添加 0xFF 和颜色代码：

`#b74093``Color(0xffb74093)`在 Flutter 中将会变成

`#B74093``Color(0xFFB74093)`在 Flutter 中将会变成

in`ff or FF`定义`Color(0xFFB74093)`不透明度。

**[Dartpad 中所有不透明度类型的十六进制颜色示例](https://dartpad.dev/d1b1bcd13e74d0296a32e15c437aab84?)**

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

简单的方法：

    String color = yourHexColor.replaceAll('#', '0xff');
    

用法：

    Container(
      color: Color(int.parse(color)),
    )

How do i use hexadecimal color strings in flutter?

在 JavaScript 中等待 iframe 内容加载完成，一般有几种常用的方法，分别是使用 `load` 事件、`DOMContentLoaded` 事件和轮询 `document.readyState` 属性。以下是对这些方法的详细解释和示例：

### 使用 `load` 事件

`load` 事件在 iframe 的所有内容（包括图像、脚本文件等）加载完成后触发。监听 iframe 的 `load` 事件是最简单直接的方法：

```javascript
var iframe = document.getElementById('myIframe');
iframe.onload = function() {
    console.log('Iframe 完全加载完成');
    // 在这里执行其他操作
};
```

或者使用 `addEventListener` 方法：

```javascript
var iframe = document.getElementById('myIframe');
iframe.addEventListener('load', function() {
    console.log('Iframe 完全加载完成');
    // 在这里执行其他操作
});
```

### 使用 `DOMContentLoaded` 事件

如果你只关心 iframe 的文档内容（不包括像图片这样的资源），可以使用 `DOMContentLoaded` 事件。这个事件在文档被完全加载和解析后立即触发，不需要等待样式表、图片和子框架的加载完成。

```javascript
var iframe = document.getElementById('myIframe');
iframe.addEventListener('load', function() {
    var iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
    iframeDocument.addEventListener('DOMContentLoaded', function() {
        console.log('Iframe 的 DOM 内容加载完成');
        // 在这里执行其他操作
    });
});
```

### 轮询 `document.readyState`

如果上述事件不适用于你的特定情况（例如，你无法保证能够在 `DOMContentLoaded` 触发之前设置事件监听器），你还可以通过轮询检查 iframe 的 `document.readyState` 属性：

```javascript
var iframe = document.getElementById('myIframe');
var iframeDocument = iframe.contentDocument || iframe.contentWindow.document;

function checkIframeLoaded() {
    // 检查 iframe 的 document 是否加载完成
    if (iframeDocument.readyState === 'complete' || iframeDocument.readyState === 'interactive') {
        console.log('Iframe 内容加载完成');
        // 在这里执行其他操作
    } else {
        // 如果没有加载完成，再次检查
        setTimeout(checkIframeLoaded, 100);
    }
}

checkIframeLoaded();
```

### 总结
根据您的具体需求，可以选择监听 `load` 事件来等待所有资源加载完毕，或者使用 `DOMContentLoaded` 事件等待 DOM 内容渲染完毕，或者不断轮询 `document.readyState` 属性来确定加载状态。在实际应用中，您可以根据 iframe 中内容的具体情况和您希望执行操作的时机来选择最合适的方法。

首先，我相信你应该影响`src`iframe 的属性，而不是`location`. 其次，挂钩 iframe 的`load`事件来执行更改：

    var myIframe = document.getElementById('righttop');
    myIframe.addEventListener("load", function() {
      this.contentWindow.document.notesform.ID_client.value = Client;
    });
    myIframe.src = 'timesheet_notes.php';
    

再次强调，这一切都假设您指的是**i**框架，而不是框架集。

我想你可以很容易地用 jQuery 来做到这一点... [jQuery Home](http://www.jquery.com) 只需将页面挂接到 jQuery `$ function ()`... 例如

    $(document).ready(function() { 
        $('iframe').load(function() { 
           // write your code here....
        });
    });
    

快速查看此处的文件上传器示例： [Using iframes for multiple file uploads...](http://sushantp.wordpress.com/2009/05/11/using-iframes-for-multiple-file-uploads-and-using-jquery-to-communicate-between-main-document-and-iframes/)

iFrame 可以动态加载元素，使用它们的最佳选择是使用递归：

     $('iframe').ready(function() {
       var triggerMeAgainIfNeeded = function() {
          setTimeout(function() {
              var neededElm = $('.someElementThatLoadedAfterIframe');
               if (neededElm.length > 0) {
                 // do your job
               } else {
                 triggerMeAgainIfNeeded();
               }
           }, 10);
       }
    });

尝试这个简单的解决方案：

    const myIframe = document.querySelector('iframe[name="my-iframe"]');
    const waitForMyIframeToReload = () => (new Promise(resolve => myIframe.addEventListener('load', () => resolve())));
    myIframe.contentWindow.location.reload(true);
    await waitForSdiIframeToReload();
    console.log('I executed after the iframe loaded'));

    <html>
      <body style="height: 100%; width: 100%;">
        <iframe name="my-iframe" src="https://platform.twitter.com/widgets/tweet_button.html" style="height: 100%; width: 100%;"></iframe>
      </body>
    </html>

运行代码片段Hide results

展开片段

How to wait for iframe to load in javascript

在检测`iframe`开始加载新URL时，通常会用到JavaScript中的事件监听器。以下是一些方法，可以用来监测`iframe`何时开始加载新的URL：

### 方法1：使用 `onload` 事件

要检测`iframe`是否完成了新URL的加载，可以监听`iframe`的`onload`事件。但是，它只能告诉我们`iframe`什么时候加载完成，并不能直接告诉我们何时开始。不过，我们可以在设置新的`src`属性之前初始化一些操作，来模拟“开始加载”的检测：

```javascript
var iframe = document.getElementById('myIframe');

// 当`iframe`开始加载新URL时执行的函数
function onIframeStartLoad() {
    console.log('开始加载新的URL...');
}

// 当`iframe`完成加载新URL时执行的函数
function onIframeLoad() {
    console.log('新的URL加载完成');
}

// 监听`iframe`的`onload`事件
iframe.onload = onIframeLoad;

// 更改`iframe`的`src`属性以开始加载新的URL
iframe.src = 'https://example.com'; // 在设置`src`之前，我们知道加载即将开始
onIframeStartLoad(); // 手动调用开始加载的函数
```

### 方法2：使用 `addEventListener` 方法

我们可以使用`addEventListener`来给`iframe`添加`load`事件监听器，这更适合现代浏览器和动态事件管理：

```javascript
var iframe = document.getElementById('myIframe');

iframe.addEventListener('load', function() {
    console.log('新的URL加载完成');
});

// 在更改`iframe`的`src`之前，我们可以执行某些操作
console.log('开始加载新的URL...');
iframe.src = 'https://example.com';
```

### 方法3：使用 `MutationObserver`

如果您希望检测`iframe`的`src`属性何时被改变（而不一定是加载完成），可以使用`MutationObserver`。这允许您监视DOM更改，例如属性的改变：

```javascript
var iframe = document.getElementById('myIframe');
var observer = new MutationObserver(function(mutations) {
    mutations.forEach(function(mutation) {
        if (mutation.type === 'attributes' && mutation.attributeName === 'src') {
            console.log('iframe src 属性改变，新的URL开始加载');
        }
    });
});

observer.observe(iframe, {
    attributes: true // 配置观察者只观察属性的变动
});

// 更改`iframe`的`src`属性
iframe.src = 'https://example.com';
```

### 方法4：使用 `beforeunload` 事件

在一些特定的情况下，你可能想要在原有页面即将卸载时检测到`iframe`开始加载新页面的行为。在这种情况下，可以使用`beforeunload`事件：

```javascript
var iframe = document.getElementById('myIframe');

iframe.contentWindow.onbeforeunload = function() {
    console.log('iframe 即将开始加载新页面');
};

// 更改`iframe`的`src`属性
iframe.src = 'https://example.com';
```

请注意，这种方法可能会受到跨域政策的限制，因为它需要访问`iframe`的`contentWindow`对象。

总结一下，通常来说，我们可以通过监听`iframe`的`load`事件或者使用`MutationObserver`来检测`iframe`何时开始加载新的URL。确保在设置新的`src`属性之前进行必要的操作，可以帮助我们定位到加载的开始时机。在实际的应用中，选择哪种方法取决于具体的需求和场景。

我找到了一个更好的解决方案，如果 iframe 和容器页面同源，则不必将额外的代码放入内部页面：

    <iframe src="same-origin.com" onload="content_finished_loading(this)"></iframe>
    <script>
        var indicator = document.querySelector('.loading-indicator');
        var content_start_loading = function() {
            indicator.style.display = 'block';
        };
    
        var content_finished_loading = function(iframe) {
            indicator.style.display = 'none';
            // inject the start loading handler when content finished loading
            iframe.contentWindow.onunload = content_start_loading;
        };
    </script>

我想出了以下解决方案 - 这是唯一可能的，因为我们控制 iframe 内容和主机窗口的内容

在 iframe 内，我们将以下脚本添加到页面页脚（所有页面都使用相同的模板，因此这是对单个文件的更改）

    <script>
    window.onunload = function() {
        // Notify top window of the unload event
        window.top.postMessage('iframe_change', '*');
    };
    </script>
    

在主机窗口内，我们添加此脚本来监视 iframe 状态

    function init_content_monitor() {
        var content = jQuery('.iframe');
    
        // The user did navigate away from the currently displayed iframe page. Show an animation
        var content_start_loading = function() {
            alert ('NOW: show the animation');
        }
    
        // the iframe is done loading a new page. Hide the animation again
        var content_finished_loading = function() {
            alert ('DONE: hide the animation');
        }
    
        // Listen to messages sent from the content iframe
        var receiveMessage = function receiveMessage(e){
            var url = window.location.href,
                url_parts = url.split("/"),
                allowed = url_parts[0] + "//" + url_parts[2];
    
            // Only react to messages from same domain as current document
            if (e.origin !== allowed) return;
            // Handle the message
            switch (e.data) {
                case 'iframe_change': content_start_loading(); break;
            }
        };
        window.addEventListener("message", receiveMessage, false);
    
        // This will be triggered when the iframe is completely loaded
        content.on('load', content_finished_loading);
    }

所有问题