@1kubator/my-first-app 中文文档教程

发布于 6年前 浏览 25 项目主页 更新于 3年前

这个项目是通过 Create React App 启动的。

您将在下面找到有关如何执行常见任务的一些信息。
您可以在此处<找到本指南的最新版本/a>。

Table of Contents

Updating to New Releases

Create React App 分为两个包:

  • create-react-app is a global command-line utility that you use to create new projects.
  • react-scripts is a development dependency in the generated projects (including this one).

您几乎不需要更新 create-react-app 本身:它将所有设置委托给 react-scripts

当您运行 create-react-app 时,它总是使用最新版本的 react-scripts 创建项目,因此您将获得新创建的所有新功能和改进应用程序自动。

要将现有项目更新为新版本的 react-scripts打开变更日志,找到您当前使用的版本(如果不确定,请检查此文件夹中的 package.json),然后应用更新版本的迁移说明。

在大多数情况下,在 package.json 中修改 react-scripts 版本并在此文件夹中运行 npm install 应该就足够了,但最好参考一下变更日志 潜在的重大变更。

我们承诺将重大更改保持在最低限度,以便您可以轻松升级 react-scripts

Sending Feedback

我们随时欢迎您的反馈

Folder Structure

创建后,您的项目应如下所示:

my-app/
  README.md
  node_modules/
  package.json
  public/
    index.html
    favicon.ico
  src/
    App.css
    App.js
    App.test.js
    index.css
    index.js
    logo.svg

对于要构建的项目,这些文件必须以准确的文件名存在

  • public/index.html is the page template;
  • src/index.js is the JavaScript entry point.

您可以删除或重命名其他文件。

您可以在 src 中创建子目录。 为了更快地重建,Webpack 只处理 src 中的文件。
您需要将任何 JS 和 CSS 文件放入 src,否则 Webpack 将看不到它们。

public/index.html 中只能使用 public 中的文件。
阅读下面的说明,了解如何使用来自 JavaScript 和 HTML 的资源。

但是,您可以创建更多顶级目录。
它们不会包含在生产版本中,因此您可以将它们用于文档之类的东西。

Available Scripts

在项目目录下,您可以运行:

npm start

以开发模式运行应用。
在浏览器中打开http://localhost:3000即可查看。

如果您进行编辑,页面将重新加载。
您还将在控制台中看到任何 lint 错误。

npm test

在交互式观看模式下启动测试运行程序。
有关详细信息,请参阅有关运行测试 的部分。

npm run build

将用于生产的应用构建到 build 文件夹。
它在生产模式下正确地捆绑了 React,并优化了构建以获得最佳性能。

构建被缩小并且文件名包含哈希值。
您的应用程序已准备好部署!

有关详细信息,请参阅有关部署 的部分。

npm run eject

注意:这是一个单向操作。 弹出后,您将无法返回!

如果您对构建工具和配置选择不满意,可以随时弹出。 此命令将从您的项目中删除单个构建依赖项。

相反,它会将所有配置文件和传递依赖项(Webpack、Babel、ESLint 等)直接复制到您的项目中,以便您可以完全控制它们。 除了 eject 之外的所有命令仍然有效,但它们将指向复制的脚本,因此您可以调整它们。 在这一点上,你是靠自己的。

您不必使用 eject。 精选的功能集适用于中小型部署,您不应该觉得必须使用此功能。 但是我们知道,如果您在准备好使用它时不能对其进行自定义,那么该工具将毫无用处。

Supported Browsers

默认情况下,生成的项目使用最新版本的 React。

您可以参考React 文档,了解有关支持的浏览器的更多信息。

Supported Language Features and Polyfills

该项目支持最新 JavaScript 标准的超集。
除了ES6语法特性,它还支持:

了解更多关于不同的提案阶段

虽然我们建议谨慎使用实验性提案,但 Facebook 在产品代码中大量使用了这些功能,因此我们打算提供 codemods 如果这些提议中的任何一个在未来发生变化。

请注意,该项目仅包含一些 ES6 polyfills

如果您使用任何其他 ES6+ 功能需要运行时支持(例如Array.from()Symbol),确保您手动包含适当的 polyfill,或者浏览器您的目标已经支持他们。

另请注意,使用一些较新的语法功能,如 for...of[...nonArrayValue] 会导致 Babel 发出依赖于 ES6 运行时功能的代码,并且可能无法正常工作没有 polyfill。 如有疑问,请使用 Babel REPL 查看任何特定语法的编译结果。

Syntax Highlighting in the Editor

要在您最喜欢的文本编辑器中配置语法突出显示,请前往相关的 Babel 文档页面并按照说明进行操作。 涵盖了一些最受欢迎的编辑器。

Displaying Lint Output in the Editor

注意:此功能适用于 react-scripts@0.2.0 及更高版本。
它也只适用于 npm 3 或更高版本。

一些编辑器,包括 Sublime Text、Atom 和 Visual Studio Code,为 ESLint 提供了插件。

它们不是 linting 所必需的。 您应该会在终端和浏览器控制台中看到 linter 输出。 但是,如果您希望 lint 结果直接出现在您的编辑器中,您可以执行一些额外的步骤。

您需要先为您的编辑器安装一个 ESLint 插件。 然后,将名为 .eslintrc 的文件添加到项目根目录:

{
  "extends": "react-app"
}

现在您的编辑器应该会报告 linting 警告。

请注意,即使您进一步编辑 .eslintrc 文件,这些更改也将仅影响编辑器集成。 它们不会影响终端和浏览器内的 lint 输出。 这是因为 Create React App 有意提供了一组最小的规则来发现常见错误。

如果您想为您的项目强制执行编码风格,请考虑使用 Prettier 而不是 ESLint 风格规则。

Debugging in the Editor

目前只有 Visual Studio CodeWebStorm

Visual Studio Code 和 WebStorm 支持使用 Create React App 进行开箱即用的调试。 这使您作为开发人员能够在不离开编辑器的情况下编写和调试 React 代码,最重要的是,它使您能够拥有持续的开发工作流程,其中上下文切换最少,因为您不必在工具之间切换。

Visual Studio Code

您需要拥有最新版本的 VS Code 和 VS Code Chrome 调试器扩展已安装。

然后将下面的代码块添加到您的 launch.json 文件中,并将其放入应用程序根目录中的 .vscode 文件夹中。

{
  "version": "0.2.0",
  "configurations": [{
    "name": "Chrome",
    "type": "chrome",
    "request": "launch",
    "url": "http://localhost:3000",
    "webRoot": "${workspaceRoot}/src",
    "sourceMapPathOverrides": {
      "webpack:///src/*": "${webRoot}/*"
    }
  }]
}

注意:如果您通过HOST 或 PORT 环境变量 进行了调整,URL 可能会有所不同。

通过运行 npm start 启动您的应用程序,然后通过按 F5 或单击绿色调试图标在 VS Code 中开始调试。 您现在可以编写代码、设置断点、更改代码以及调试新修改的代码——所有这些都来自您的编辑器。

VS 代码调试有问题? 请参阅他们的故障排除指南

WebStorm

你需要有 WebStormJetBrains IDE 支持 安装了 Chrome 扩展程序。

在 WebStorm 菜单 Run 中选择 Edit Configurations...。 然后单击 + 并选择 JavaScript Debug。 将 http://localhost:3000 粘贴到 URL 字段并保存配置。

注意:如果您通过HOST 或 PORT 环境变量 进行了调整,URL 可能会有所不同。

通过运行 npm start 启动您的应用,然后在 macOS 上按 ^D 或在 Windows 和 Linux 上按 F9 或单击绿色调试图标开始调试在网络风暴中。

与在 IntelliJ IDEA Ultimate、PhpStorm、PyCharm Pro 和 RubyMine 中调试应用程序的方式相同。

Formatting Code Automatically

Prettier 是一种自以为是的代码格式化程序,支持 JavaScript、CSS 和 JSON。 使用 Prettier,您可以自动格式化您编写的代码,以确保项目中的代码风格。 有关详细信息,请参阅 Prettier 的 GitHub 页面,并查看此 查看实际效果的页面

每当我们在 git 中进行提交时,为了格式化我们的代码,我们需要安装以下依赖项:

npm install --save husky lint-staged prettier

或者,您可以使用 yarn

yarn add husky lint-staged prettier
  • husky makes it easy to use githooks as if they are npm scripts.
  • lint-staged allows us to run scripts on staged files in git. See this blog post about lint-staged to learn more about it.
  • prettier is the JavaScript formatter we will run before commits.

现在我们可以通过在package.json 在项目根目录中。

将以下行添加到 scripts 部分:

  "scripts": {
+   "precommit": "lint-staged",
    "start": "react-scripts start",
    "build": "react-scripts build",

接下来我们将一个 'lint-staged' 字段添加到 package.json,例如:

  "dependencies": {
    // ...
  },
+ "lint-staged": {
+   "src/**/*.{js,jsx,json,css}": [
+     "prettier --single-quote --write",
+     "git add"
+   ]
+ },
  "scripts": {

现在,每当您进行提交时,Prettier将自动格式化更改的文件。 您还可以运行 ./node_modules/.bin/prettier --single-quote --write "src/**/*.{js,jsx,json,css}" 来格式化整个项目首次。

接下来,您可能希望将 Prettier 集成到您喜欢的编辑器中。 阅读 Prettier GitHub 页面上有关编辑器集成 的部分。

Changing the Page <title>

您可以在生成的项目的 public 文件夹中找到源 HTML 文件。 您可以编辑其中的 </code> 标签,将标题从“React App”更改为其他任何内容。

请注意,通常您不会经常编辑 public 文件夹中的文件。 例如,添加样式表 是在不接触 HTML 的情况下完成的。

如果需要根据内容动态更新页面标题,可以使用浏览器< code>document.title API。 对于更复杂的场景,当你想从 React 组件更改标题时,你可以使用第三方库 React Helmet

如果您在生产中为您的应用程序使用自定义服务器并希望在将标题发送到浏览器之前修改标题,您可以按照 本节。 或者,您可以将每个页面预构建为静态 HTML 文件,然后加载 JavaScript 包,此处 对此进行了介绍。

Installing a Dependency

生成的项目包括 React 和 ReactDOM 作为依赖项。 它还包括 Create React App 使用的一组脚本作为开发依赖项。 您可以使用 npm 安装其他依赖项(例如 React Router):

npm install --save react-router

或者您可以使用 yarn

yarn add react-router

这适用于任何库,而不仅仅是 react-router< /代码>。

Importing a Component

由于 Babel,此项目设置支持 ES6 模块。
虽然您仍然可以使用 require()module.exports,但我们鼓励您使用 import 和 export 代替。

例如:

Button.js

import React, { Component } from 'react';

class Button extends Component {
  render() {
    // ...
  }
}

export default Button; // Don’t forget to use export default!

DangerButton.js

import React, { Component } from 'react';
import Button from './Button'; // Import a component from another file

class DangerButton extends Component {
  render() {
    return <Button color="red" />;
  }
}

export default DangerButton;

注意 默认导出和命名导出之间的区别。 这是错误的常见来源。

我们建议您在模块仅导出单个事物(例如,组件)时坚持使用默认导入和导出。 这就是您使用 export default Buttonimport Button from './Button' 时得到的结果。

命名导出对于导出多个函数的实用程序模块很有用。 一个模块最多可以有一个默认导出和任意多个命名导出。

了解有关 ES6 模块的更多信息:

Code Splitting

代码拆分允许您将代码拆分成小块,然后可以按需加载,而不是在用户可以使用之前下载整个应用程序。

此项目设置支持通过动态import()进行代码拆分。 它的提案处于第 3 阶段。import() 类函数形式采用模块名称作为参数并返回 Promise 始终解析为模块的命名空间对象。

这是一个示例:

moduleA.js

const moduleA = 'Hello';

export { moduleA };

App.js

import React, { Component } from 'react';

class App extends Component {
  handleClick = () => {
    import('./moduleA')
      .then(({ moduleA }) => {
        // Use moduleA
      })
      .catch(err => {
        // Handle failure
      });
  };

  render() {
    return (
      <div>
        <button onClick={this.handleClick}>Load</button>
      </div>
    );
  }
}

export default App;

这将使 moduleA.js 及其所有独特的依赖项成为一个单独的块,仅在用户单击“加载”按钮后才加载。

如果您愿意,也可以将它与 async / await 语法一起使用。

With React Router

如果您使用的是 React Router,请查看本教程了解如何使用代码拆分。 您可以在此处找到配套的 GitHub 存储库.

另请查看 React 文档中的 代码拆分 部分。

Adding a Stylesheet

此项目设置使用 Webpack 来处理所有资产。 Webpack 提供了一种自定义方式,可以将 import 的概念“扩展”到 JavaScript 之外。 要表达 JavaScript 文件依赖于 CSS 文件,您需要从 JavaScript 文件导入 CSS

Button.css

.Button {
  padding: 20px;
}

Button.js

import React, { Component } from 'react';
import './Button.css'; // Tell Webpack that Button.js uses these styles

class Button extends Component {
  render() {
    // You can use them as regular CSS styles
    return <div className="Button" />;
  }
}

React 不需要这样做,但很多人觉得这个功能很方便. 您可以在此处了解这种方法的好处。 但是,您应该意识到,与 Webpack 相比,这会降低您的代码对其他构建工具和环境的可移植性。

在开发中,以这种方式表达依赖关系允许您的样式在您编辑它们时即时重新加载。 在生产中,所有 CSS 文件将在构建输出中连接成一个缩小的 .css 文件。

如果您担心使用特定于 Webpack 的语义,您可以将所有 CSS 直接放入 src/index.css。 它仍然会从 src/index.js 导入,但如果您稍后迁移到不同的构建工具,您始终可以删除该导入。

Post-Processing CSS

此项目设置会缩小您的 CSS 并通过 Autoprefixer 自动为其添加供应商前缀,因此您无需担心。

例如,这:

.App {
  display: flex;
  flex-direction: row;
  align-items: center;
}

变成这样:

.App {
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
  -webkit-box-orient: horizontal;
  -webkit-box-direction: normal;
      -ms-flex-direction: row;
          flex-direction: row;
  -webkit-box-align: center;
      -ms-flex-align: center;
          align-items: center;
}

如果您出于某种原因需要禁用自动前缀,按照本节操作

Adding a CSS Preprocessor (Sass, Less etc.)

通常,我们建议您不要在不同的组件中重复使用相同的 CSS 类。 例如,不要在 组件中使用 .Button CSS 类,我们建议创建一个

遵循这条规则通常会使 CSS 预处理器变得不那么有用,因为混合和嵌套等功能被组件组合所取代。 但是,如果您觉得它有价值,您可以集成一个 CSS 预处理器。 在本演练中,我们将使用 Sass,但您也可以使用 Less 或其他替代方法。

首先,让我们安装 Sass 的命令行界面:

npm install --save node-sass-chokidar

或者您可以使用 yarn

yarn add node-sass-chokidar

然后在 package.json 中,将以下行添加到 scripts:

   "scripts": {
+    "build-css": "node-sass-chokidar src/ -o src/",
+    "watch-css": "npm run build-css && node-sass-chokidar src/ -o src/ --watch --recursive",
     "start": "react-scripts start",
     "build": "react-scripts build",
     "test": "react-scripts test --env=jsdom",

注意:要使用不同的预处理器,请根据预处理器的文档替换 build-csswatch-css 命令。

现在您可以将 src/App.css 重命名为 src/App.scss 并运行 npm run watch-css。 观察者将在 src 子目录中找到每个 Sass 文件,并在其旁边创建一个相应的 CSS 文件,在我们的例子中覆盖 src/App.css。 由于 src/App.js 仍然导入 src/App.css,因此样式成为应用程序的一部分。 您现在可以编辑 src/App.scsssrc/App.css 将重新生成。

要在 Sass 文件之间共享变量,您可以使用 Sass 导入。 例如,src/App.scss 和其他组件样式文件可以包含带有变量定义的@import "./shared.scss";

要在不使用相对路径的情况下导入文件,您可以将 --include-path 选项添加到 package.json 中的命令。

"build-css": "node-sass-chokidar --include-path ./src --include-path ./node_modules src/ -o src/",
"watch-css": "npm run build-css && node-sass-chokidar --include-path ./src --include-path ./node_modules src/ -o src/ --watch --recursive",

这将允许您进行导入,

@import 'styles/_colors.scss'; // assuming a styles directory under src/
@import 'nprogress/nprogress'; // importing a css file from the nprogress node module

如此时您可能希望从源代码管理中删除所有 CSS 文件,并将 src/**/*.css 添加到您的 .gitignore文件。 将构建产品保留在源代码控制之外通常是一种很好的做法。

作为最后一步,您可能会发现使用 npm start 自动运行 watch-css 很方便,并将 build-css 作为<代码>npm 运行构建。 您可以使用 && 运算符顺序执行两个脚本。 但是,没有跨平台的方式并行运行两个脚本,因此我们将为此安装一个包:

npm install --save npm-run-all

或者您可以使用 yarn

yarn add npm-run-all

然后我们可以更改 startbuild 脚本以包含 CSS 预处理器命令:

   "scripts": {
     "build-css": "node-sass-chokidar src/ -o src/",
     "watch-css": "npm run build-css && node-sass-chokidar src/ -o src/ --watch --recursive",
-    "start": "react-scripts start",
-    "build": "react-scripts build",
+    "start-js": "react-scripts start",
+    "start": "npm-run-all -p watch-css start-js",
+    "build-js": "react-scripts build",
+    "build": "npm-run-all build-css build-js",
     "test": "react-scripts test --env=jsdom",
     "eject": "react-scripts eject"
   }

现在运行 npm startnpm run build 也会构建 Sass 文件。

为什么 node-sass-chokidar

据报告,node-sass 存在以下问题:

  • node-sass --watch<据报道 /code> 在虚拟机或 docker 中使用时在某些情况下存在性能问题

  • 编译 #1939 node-sass 的无限样式

  • 被报告为具有在目录中检测新文件的问题 #1891

    node-sass-chokidar在这里使用,因为它解决了这些问题。

Adding Images, Fonts, and Files

在 Webpack 中,使用图像和字体等静态资源的方式与 CSS 类似。

您可以在 JavaScript 模块中导入文件。 这告诉 Webpack 将该文件包含在包中。 与 CSS 导入不同,导入文件会为您提供一个字符串值。 该值是您可以在代码中引用的最终路径,例如图像的 src 属性或 PDF 链接的 href

为了减少对服务器的请求数量,导入小于 10,000 字节的图像会返回 数据 URI 而不是路径。 这适用于以下文件扩展名:bmp、gif、jpg、jpeg 和 png。 由于 #1153,SVG 文件被排除在外。

这是一个示例:

import React from 'react';
import logo from './logo.png'; // Tell Webpack this JS file uses this image

console.log(logo); // /logo.84287d09.png

function Header() {
  // Import result is the URL of your image
  return <img src={logo} alt="Logo" />;
}

export default Header;

这确保了在构建项目时,Webpack 会将图像正确地移动到构建文件夹中,并为我们提供正确的路径。

这在 CSS 中也有效:

.Logo {
  background-image: url(./logo.png);
}

Webpack 在 CSS 中找到所有相关模块引用(它们以 ./ 开头)并将它们替换为编译包中的最终路径。 如果你输入错误或不小心删除了一个重要的文件,你会看到一个编译错误,就像你导入一个不存在的 JavaScript 模块一样。 编译包中的最终文件名由 Webpack 从内容哈希生成。 如果将来文件内容发生变化,Webpack 会在生产环境中为其赋予不同的名称,因此您无需担心资产的长期缓存。

请注意,这也是 Webpack 的自定义功能。

React 不需要它,但很多人喜欢它(React Native 对图像使用类似的机制)。
下一节将介绍另一种处理静态资产的方法。

Using the public Folder

注意:此功能适用于 react-scripts@0.5.0 及更高版本。

Changing the HTML

public 文件夹包含 HTML 文件,因此您可以对其进行调整,例如,设置页面标题。 包含编译代码的

Adding Assets Outside of the Module System

您还可以将其他资产添加到 public 文件夹。

请注意,我们通常鼓励您在 JavaScript 文件中导入 资产。 例如,请参阅添加样式表添加图像和字体< /a>。 这种机制提供了很多好处:

  • Scripts and stylesheets get minified and bundled together to avoid extra network requests.
  • Missing files cause compilation errors instead of 404 errors for your users.
  • Result filenames include content hashes so you don’t need to worry about browsers caching their old versions.

但是,有一个逃生口,您可以使用它在模块系统之外添加资产。

如果您将文件放入 public 文件夹,它不会被 Webpack 处理。 相反,它将被原封不动地复制到构建文件夹中。 要引用 public 文件夹中的资产,您需要使用一个名为 PUBLIC_URL 的特殊变量。

index.html 中,您可以这样使用它:

<link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico">

只有 public 文件夹中的文件才能通过 %PUBLIC_URL% 前缀访问。 如果您需要使用来自 srcnode_modules 的文件,您必须将其复制到那里以明确指定您打算将该文件作为构建的一部分。

当您运行 npm run build 时,Create React App 会将 %PUBLIC_URL% 替换为正确的绝对路径,这样即使您使用客户端路由或将其托管在一个非根 URL。

在 JavaScript 代码中,您可以将 process.env.PUBLIC_URL 用于类似目的:

render() {
  // Note: this is an escape hatch and should be used sparingly!
  // Normally we recommend using `import` for getting asset URLs
  // as described in “Adding Images and Fonts” above this section.
  return <img src={process.env.PUBLIC_URL + '/img/logo.png'} />;
}

请记住这种方法的缺点:

  • None of the files in public folder get post-processed or minified.
  • Missing files will not be called at compilation time, and will cause 404 errors for your users.
  • Result filenames won’t include content hashes so you’ll need to add query arguments or rename them every time they change.

When to Use the public Folder

通常我们建议导入 样式表、来自 JavaScript 的 图像和字体public 文件夹可用作许多不太常见情况的解决方法:

  • You need a file with a specific name in the build output, such as manifest.webmanifest.
  • You have thousands of images and need to dynamically reference their paths.
  • You want to include a small script like pace.js outside of the bundled code.
  • Some library may be incompatible with Webpack and you have no other option but to include it as a <script> tag.

请注意,如果您添加声明全局变量的

Using Global Variables

当您在 HTML 文件中包含定义全局变量的脚本并尝试在代码中使用这些变量之一时,linter 会抱怨,因为它看不到变量的定义。

您可以通过从 window 对象中显式读取全局变量来避免这种情况,例如:

const $ = window.$;

这表明您是故意使用全局变量而不是因为拼写错误。

或者,您可以通过在其后添加 // eslint-disable-line 来强制 linter 忽略任何行。

Adding Bootstrap

您不必将 React Bootstrap 与 React 一起使用,但它是一个用于将 Bootstrap 与 React 应用程序集成的流行库。 如果需要,可以按照以下步骤将其与 Create React App 集成:

从 npm 安装 React Bootstrap 和 Bootstrap。 React Bootstrap 不包含 Bootstrap CSS,因此也需要安装:

npm install --save react-bootstrap bootstrap@3

或者您可以使用 yarn

yarn add react-bootstrap bootstrap@3

src/index.js 的开头导入 Bootstrap CSS 和可选的 Bootstrap 主题 CSS 文件:

import 'bootstrap/dist/css/bootstrap.css';
import 'bootstrap/dist/css/bootstrap-theme.css';
// Put any other imports below so that CSS from your
// components takes precedence over default styles.

src/App.js 文件或您的自定义组件文件中导入所需的 React Bootstrap 组件:

import { Navbar, Jumbotron, Button } from 'react-bootstrap';

现在您可以在渲染中定义的组件层次结构中使用导入的 React Bootstrap 组件方法。 这是一个示例 App.js 使用 React Bootstrap 重做.

Using a Custom Theme

有时您可能需要调整 Bootstrap(或等效包)的视觉样式。
我们建议采用以下方法:

  • Create a new package that depends on the package you wish to customize, e.g. Bootstrap.
  • Add the necessary build steps to tweak the theme, and publish your package on npm.
  • Install your own theme npm package as a dependency of your app.

这是一个添加自定义 Bootstrap 的示例,遵循这些步骤.

Adding Flow

Flow 是一种静态类型检查器,可帮助您编写错误更少的代码。 查看此在 JavaScript 中使用静态类型的介绍,如果你是这个概念的新手。

Flow 的最新版本开箱即用地支持 Create React App 项目。

要将 Flow 添加到 Create React App 项目,请执行以下步骤:

  1. Run npm install --save flow-bin (or yarn add flow-bin).
  2. Add "flow": "flow" to the scripts section of your package.json.
  3. Run npm run flow init (or yarn flow init) to create a .flowconfig file in the root directory.
  4. Add // @flow to any files you want to type check (for example, to src/App.js).

现在您可以运行 npm run flow(或 yarn flow)来检查文件是否存在类型错误。 您可以选择使用像 Nuclide 这样的 IDE,以获得更好的集成体验。 未来我们计划将它更紧密地集成到 Create React App 中。

要了解有关 Flow 的更多信息,请查看其文档

Adding a Router

Create React App 没有规定特定的路由解决方案,但 React Router 是最流行的一种。

要添加它,请运行:

npm install --save react-router-dom

或者您可以使用 yarn

yarn add react-router-dom

要尝试它,请删除 src/App.js 中的所有代码并将其替换为其上的任何示例网站。 基本示例 是开始的好地方。

请注意,在部署应用之前,您可能需要配置生产服务器以支持客户端路由

Adding Custom Environment Variables

注意:此功能适用于 react-scripts@0.2.3 及更高版本。

您的项目可以使用在您的环境中声明的变量,就好像它们是在您的 JS 文件中本地声明的一样。 经过 默认情况下,您将为您定义 NODE_ENV,以及任何其他以开头的环境变量 <代码>REACT_APP_

环境变量在构建时嵌入。 由于 Create React App 生成静态 HTML/CSS/JS 包,它不可能在运行时读取它们。 要在运行时读取它们,您需要将 HTML 加载到服务器的内存中并在运行时替换占位符,就像此处描述的 。 或者,您可以在更改它们时随时在服务器上重建应用程序。

注意:您必须创建以 REACT_APP_ 开头的自定义环境变量。 除了 NODE_ENV 之外的任何其他变量都将被忽略,以避免意外暴露一个机器上可能具有相同名称的私钥。 更改任何环境变量都将要求您重新启动正在运行的开发服务器。

这些环境变量将在 process.env 上为您定义。 例如,拥有一个环境 名为 REACT_APP_SECRET_CODE 的变量将作为 process.env.REACT_APP_SECRET_CODE 在您的 JS 中公开。

还有一个名为 NODE_ENV 的特殊内置环境变量。 您可以从 process.env.NODE_ENV 读取它。 当您运行 npm start 时,它始终等于 'development',当您运行 npm test 时,它始终等于 ' test',当您运行 npm run build 来制作生产包时,它始终等于 'production'您不能手动覆盖 NODE_ENV这可以防止开发人员意外地将缓慢的开发构建部署到生产环境中。

这些环境变量可用于根据项目所在位置有条件地显示信息 部署或使用版本控制之外的敏感数据。

首先,您需要定义环境变量。 例如,假设您想使用一个定义的秘密 在

内的环境中:

render() {
  return (
    <div>
      <small>You are running this application in <b>{process.env.NODE_ENV}</b> mode.</small>
      <form>
        <input type="hidden" defaultValue={process.env.REACT_APP_SECRET_CODE} />
      </form>
    </div>
  );
}

在构建过程中,process.env.REACT_APP_SECRET_CODE 将替换为 REACT_APP_SECRET_CODE 的当前值环境变量。 请记住,NODE_ENV 变量将自动为您设置。

当您在浏览器中加载应用程序并检查 时,您会看到它的值设置为 abcdef,粗体文本将显示使用时提供的环境npm start

<div>
  <small>You are running this application in <b>development</b> mode.</small>
  <form>
    <input type="hidden" value="abcdef" />
  </form>
</div>

上面的表单正在从环境中寻找一个名为 REACT_APP_SECRET_CODE 的变量。 为了消费这个 值,我们需要在环境中定义它。 这可以通过两种方式完成:在您的 shell 中或在 一个 .env 文件。 在接下来的几节中将介绍这两种方式。

访问 NODE_ENV 对于有条件地执行操作也很有用:

if (process.env.NODE_ENV !== 'production') {
  analytics.disable();
}

当您使用 npm run build 编译应用程序时,缩小步骤将去除这种情况,并且生成的包会更小。

Referencing Environment Variables in the HTML

注意:此功能适用于 react-scripts@0.9.0 及更高版本。

您还可以在 public/index.html 中访问以 REACT_APP_ 开头的环境变量。 例如:

<title>%REACT_APP_WEBSITE_NAME%</title>

请注意,上一节中的注意事项适用:

  • Apart from a few built-in variables (NODE_ENV and PUBLIC_URL), variable names must start with REACT_APP_ to work.
  • The environment variables are injected at build time. If you need to inject them at runtime, follow this approach instead.

Adding Temporary Environment Variables In Your Shell

定义环境变量可能因操作系统而异。 同样重要的是要知道这种方式对于 shell 会话的生命周期。

Windows (cmd.exe)

set "REACT_APP_SECRET_CODE=abcdef" && npm start

(注意:变量分配需要引号以避免尾随空格。)

Windows (Powershell)

($env:REACT_APP_SECRET_CODE = "abcdef") -and (npm start)

Linux, macOS (Bash)

REACT_APP_SECRET_CODE=abcdef npm start

Adding Development Environment Variables In .env

注意:此功能适用于 react-scripts@0.5.0 及更高版本。

要定义永久环境变量,请在项目的根目录中创建一个名为 .env 的文件:

REACT_APP_SECRET_CODE=abcdef

注意:您必须创建以 REACT_APP_ 开头的自定义环境变量。 除了 NODE_ENV 之外的任何其他变量都将被忽略,以避免意外暴露机器上可能具有相同名称的私钥。 更改任何环境变量都将要求您重新启动正在运行的开发服务器。

.env 文件应该签入源代码管理(.env*.local 除外)。

What other .env files can be used?

注意:此功能适用于 react-scripts@1.0.0 及更高版本

  • .env: Default.
  • .env.local: Local overrides. This file is loaded for all environments except test.
  • .env.development, .env.test, .env.production: Environment-specific settings.
  • .env.development.local, .env.test.local, .env.production.local: Local overrides of environment-specific settings.

左边的文件比右边的文件有更高的优先级:

  • npm start: .env.development.local, .env.development, .env.local, .env
  • npm run build: .env.production.local, .env.production, .env.local, .env
  • npm test: .env.test.local, .env.test, .env (note .env.local is missing)

如果机器没有明确设置这些变量,这些变量将作为默认值。
请参阅 dotenv 文档了解更多详情。

注意:如果您正在为开发定义环境变量,您的 CI 和/或托管平台很可能需要 这些也定义了。 请参阅他们的文档如何执行此操作。 例如,请参阅 Travis CIHeroku

Expanding Environment Variables In .env

注意:此功能适用于 react-scripts@1.1.0 及更高版本。

扩展您机器上已有的变量以在您的 .env 文件中使用(使用 dotenv-expand) .

例如,要获取环境变量 npm_package_version

REACT_APP_VERSION=$npm_package_version
# also works:
# REACT_APP_VERSION=${npm_package_version}

或扩展当前 .env 文件的局部变量:

DOMAIN=www.example.com
REACT_APP_FOO=$DOMAIN/foo
REACT_APP_BAR=$DOMAIN/bar

Can I Use Decorators?

许多流行的库使用 decorators 在他们的文档中。
Create React App 目前不支持装饰器语法,因为:

  • It is an experimental proposal and is subject to change.
  • The current specification version is not officially supported by Babel.
  • If the specification changes, we won’t be able to write a codemod because we don’t use them internally at Facebook.

然而,在许多情况下,您可以在没有装饰器的情况下重写基于装饰器的代码。
请参考这两个线程:

Create React App 将在规范推进到稳定阶段时添加装饰器支持。

Fetching Data with AJAX Requests

React 没有规定特定的数据获取方法,但人们通常使用像 axios 这样的库或 fetch() API。 方便的是,Create React App 包含一个用于 fetch() 的 polyfill,因此您可以使用它而不必担心浏览器支持。

全局 fetch 函数允许轻松发出 AJAX 请求。 它接受一个 URL 作为输入并返回一个解析为 Response 对象的 Promise。 您可以在此处找到有关fetch 的更多信息。

该项目还包括一个 Promise polyfill,它提供了 Promises/A+ 的完整实现。 Promise 表示异步操作的最终结果,您可以在此处此处。 axios 和 fetch() 都在底层使用 Promises。 您还可以使用 async / await 语法来减少回调嵌套。

您可以在 React 网站上的常见问题条目 中了解有关从 React 组件发出 AJAX 请求的更多信息。

Integrating with an API Backend

这些教程将帮助您将您的应用程序与在另一个端口上运行的 API 后端集成, 使用 fetch() 访问它。

Node

查看本教程。 您可以在此处找到配套的 GitHub 存储库。

Ruby on Rails

查看本教程。 您可以在此处找到配套的 GitHub 存储库。

Proxying API Requests in Development

注意:此功能适用于 react-scripts@0.2.3 及更高版本。

人们通常使用与后端实现相同的主机和端口来提供前端 React 应用程序。
例如,部署应用程序后,生产设置可能如下所示:

/             - static server returns index.html with React app
/todos        - static server returns index.html with React app
/api/todos    - server handles any /api/* requests using the backend implementation

不需要需要此类设置。 但是,如果您确实有这样的设置,那么编写像fetch('/api/todos')这样的请求会很方便,而不用担心将它们重定向到另一个主机或开发过程中的端口。

要告诉开发服务器在开发过程中将任何未知请求代理到您的 API 服务器,请将 proxy 字段添加到您的 package.json,例如:

  "proxy": "http://localhost:4000",

这样,当您 < code>fetch('/api/todos') 在开发中,开发服务器将识别它不是静态资产,并将您的请求代理到 http://localhost:4000/api/todos 作为回退。 开发服务器将尝试将其Accept 标头中没有text/html 的请求发送到代理。

方便的是,这避免了 CORS 问题 和开发中这样的错误消息:

Fetch API cannot load http://localhost:4000/api/todos. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:3000' is therefore not allowed access. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.

保持在请注意,proxy 仅在开发中有效(使用 npm start),您需要确保像 /api/todos 这样的 URL指出生产中正确的事情。 您不必使用 /api 前缀。 任何没有 text/html 接受标头的无法识别的请求都将被重定向到指定的 proxy

proxy 选项支持 HTTP、HTTPS 和 WebSocket 连接。
如果 proxy 选项对您来说不够灵活,您也可以:

"Invalid Host Header" Errors After Configuring Proxy

当您启用 proxy 选项时,您选择了一个更严格的集合主机检查。 这是必要的,因为让后端对远程主机开放会使您的计算机容易受到 DNS 重新绑定攻击。 这篇文章这个问题

localhost 上开发时,这不会影响您,但如果您像 那样进行远程开发此处描述,启用 proxy 选项后,您将在浏览器中看到此错误:

无效的主机标头

要解决此问题,您可以在名为 的文件中指定公共开发主机.env.development 在项目的根目录中:

HOST=mypublicdevhost.com

如果您现在重新启动开发服务器并从指定的主机加载应用程序,它应该可以工作。

如果您仍有问题,或者如果您使用的是云编辑器等更奇特的环境,您可以通过向 .env.development.local 添加一行来完全绕过主机检查。 请注意,这很危险,会使您的机器暴露在恶意网站的远程代码执行之下:

# NOTE: THIS IS DANGEROUS!
# It exposes your machine to attacks from the websites you visit.
DANGEROUSLY_DISABLE_HOST_CHECK=true

我们不推荐这种方法。

Configuring the Proxy Manually

注意:此功能适用于 react-scripts@1.0.0 及更高版本。

如果 proxy 选项对您来说不够灵活,您可以按以下形式指定一个对象(在 package.json 中)。
您还可以指定任何配置值 http-proxy-middlewarehttp-proxy 支持。

{
  // ...
  "proxy": {
    "/api": {
      "target": "<url>",
      "ws": true
      // ...
    }
  }
  // ...
}

所有匹配此路径的请求都将是代理,无一例外。 这包括对 text/html 的请求,标准 proxy 选项不代理。

如果您需要指定多个代理,您可以通过指定额外的条目来实现。 匹配是正则表达式,因此您可以使用正则表达式来匹配多个路径。

{
  // ...
  "proxy": {
    // Matches any request starting with /api
    "/api": {
      "target": "<url_1>",
      "ws": true
      // ...
    },
    // Matches any request starting with /foo
    "/foo": {
      "target": "<url_2>",
      "ssl": true,
      "pathRewrite": {
        "^/foo": "/foo/beta"
      }
      // ...
    },
    // Matches /bar/abc.html but not /bar/sub/def.html
    "/bar/[^/]*[.]html": {
      "target": "<url_3>",
      // ...
    },
    // Matches /baz/abc.html and /baz/sub/def.html
    "/baz/.*/.*[.]html": {
      "target": "<url_4>"
      // ...
    }
  }
  // ...
}

Configuring a WebSocket Proxy

设置 WebSocket 代理时,需要注意一些额外的注意事项。

如果您使用的是 Socket.io 之类的 WebSocket 引擎,则必须运行可用作代理目标的 Socket.io 服务器。 Socket.io 不适用于标准的 WebSocket 服务器。 具体来说,不要指望 Socket.io 与 websocket.org 回显测试 一起工作。

有一些很好的文档可用于设置 Socket.io 服务器

标准 WebSockets 与标准 WebSocket 服务器以及 websocket.org 回显测试一起工作。 您可以为服务器使用 ws 之类的库,使用 浏览器中的原生 WebSockets

无论哪种方式,您都可以在 package.json 中手动代理 WebSocket 请求:

{
  // ...
  "proxy": {
    "/socket": {
      // Your compatible WebSocket server
      "target": "ws://<socket_url>",
      // Tell http-proxy-middleware that this is a WebSocket proxy.
      // Also allows you to proxy WebSocket requests without an additional HTTP request
      // https://github.com/chimurai/http-proxy-middleware#external-websocket-upgrade
      "ws": true
      // ...
    }
  }
  // ...
}

Using HTTPS in Development

注意:此功能适用于 react-scripts@0.4.0 及更高版本。

您可能需要开发服务器通过 HTTPS 提供页面。 这可能有用的一个特殊情况是使用“代理”功能将请求代理到 API 服务器本身时服务 HTTPS。

为此,将 HTTPS 环境变量设置为 true,然后像往常一样使用 npm start 启动开发服务器:(

Windows (cmd.exe)

set HTTPS=true&&npm start

Windows (Powershell)

($env:HTTPS = $true) -and (npm start)

注意:缺少空格是有意的。)

Linux, macOS (Bash)

HTTPS=true npm start

请注意,服务器将使用自签名证书,因此您的网络浏览器几乎肯定会在访问该页面时显示警告。

Generating Dynamic <meta> Tags on the Server

由于 Create React App 不支持服务器渲染,您可能想知道如何使 标签动态化并反映当前 URL。 为了解决这个问题,我们建议在 HTML 中添加占位符,如下所示:

<!doctype html>
<html lang="en">
  <head>
    <meta property="og:title" content="__OG_TITLE__">
    <meta property="og:description" content="__OG_DESCRIPTION__">

然后,在服务器上,无论您使用的后端如何,您都可以将 index.html 读入内存并替换 __OG_TITLE__ __OG_DESCRIPTION__ 以及任何其他值取决于当前 URL 的占位符。 只需确保对插值进行清理和转义,以便它们可以安全地嵌入到 HTML 中!

如果使用 Node 服务器,甚至可以共享客户端和服务器之间的路由匹配逻辑。 然而,复制它在简单的情况下也能正常工作。

Pre-Rendering into Static HTML Files

如果您使用静态托管服务提供商托管您的构建,您可以使用react-snapshotreact-snap 为应用程序中的每个路由或相关链接生成 HTML 页面。 当 JavaScript 包加载后,这些页面将无缝地变为活动状态或“水化”。

也有机会在静态托管之外使用它,以在生成和缓存路由时减轻服务器的压力。

预呈现的主要好处是,无论您的 JavaScript 包是否成功下载,您都可以通过 HTML 负载获取每个页面的核心内容。 它还增加了应用程序的每个路由被搜索引擎选中的可能性。

您可以在此处详细了解零配置预渲染(也称为快照)

Injecting Data from the Server into the Page

与上一节类似,您可以在注入全局变量的 HTML 中保留一些占位符,例如:

<!doctype html>
<html lang="en">
  <head>
    <script>
      window.SERVER_DATA = __SERVER_DATA__;
    </script>

然后,在服务器上,您可以在发送响应之前将 __SERVER_DATA__ 替换为真实数据的 JSON . 然后客户端代码可以读取 window.SERVER_DATA 来使用它。 确保 在发送之前清理 JSON给客户端,因为它使您的应用容易受到 XSS 攻击。

Running Tests

注意:此功能适用于 react-scripts@0.3.0 及更高版本。
阅读迁移指南以了解如何启用它在较旧的项目中!

Create React App 使用 Jest 作为其测试运行器。 为了准备这次整合,我们进行了[重大改造](https:/

This project was bootstrapped with Create React App.

Below you will find some information on how to perform common tasks.
You can find the most recent version of this guide here.

Table of Contents

Updating to New Releases

Create React App is divided into two packages:

  • create-react-app is a global command-line utility that you use to create new projects.
  • react-scripts is a development dependency in the generated projects (including this one).

You almost never need to update create-react-app itself: it delegates all the setup to react-scripts.

When you run create-react-app, it always creates the project with the latest version of react-scripts so you’ll get all the new features and improvements in newly created apps automatically.

To update an existing project to a new version of react-scripts, open the changelog, find the version you’re currently on (check package.json in this folder if you’re not sure), and apply the migration instructions for the newer versions.

In most cases bumping the react-scripts version in package.json and running npm install in this folder should be enough, but it’s good to consult the changelog for potential breaking changes.

We commit to keeping the breaking changes minimal so you can upgrade react-scripts painlessly.

Sending Feedback

We are always open to your feedback.

Folder Structure

After creation, your project should look like this:

my-app/
  README.md
  node_modules/
  package.json
  public/
    index.html
    favicon.ico
  src/
    App.css
    App.js
    App.test.js
    index.css
    index.js
    logo.svg

For the project to build, these files must exist with exact filenames:

  • public/index.html is the page template;
  • src/index.js is the JavaScript entry point.

You can delete or rename the other files.

You may create subdirectories inside src. For faster rebuilds, only files inside src are processed by Webpack.
You need to put any JS and CSS files inside src, otherwise Webpack won’t see them.

Only files inside public can be used from public/index.html.
Read instructions below for using assets from JavaScript and HTML.

You can, however, create more top-level directories.
They will not be included in the production build so you can use them for things like documentation.

Available Scripts

In the project directory, you can run:

npm start

Runs the app in the development mode.
Open http://localhost:3000 to view it in the browser.

The page will reload if you make edits.
You will also see any lint errors in the console.

npm test

Launches the test runner in the interactive watch mode.
See the section about running tests for more information.

npm run build

Builds the app for production to the build folder.
It correctly bundles React in production mode and optimizes the build for the best performance.

The build is minified and the filenames include the hashes.
Your app is ready to be deployed!

See the section about deployment for more information.

npm run eject

Note: this is a one-way operation. Once you eject, you can’t go back!

If you aren’t satisfied with the build tool and configuration choices, you can eject at any time. This command will remove the single build dependency from your project.

Instead, it will copy all the configuration files and the transitive dependencies (Webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except eject will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own.

You don’t have to ever use eject. The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it.

Supported Browsers

By default, the generated project uses the latest version of React.

You can refer to the React documentation for more information about supported browsers.

Supported Language Features and Polyfills

This project supports a superset of the latest JavaScript standard.
In addition to ES6 syntax features, it also supports:

Learn more about different proposal stages.

While we recommend using experimental proposals with some caution, Facebook heavily uses these features in the product code, so we intend to provide codemods if any of these proposals change in the future.

Note that the project only includes a few ES6 polyfills:

If you use any other ES6+ features that need runtime support (such as Array.from() or Symbol), make sure you are including the appropriate polyfills manually, or that the browsers you are targeting already support them.

Also note that using some newer syntax features like for...of or [...nonArrayValue] causes Babel to emit code that depends on ES6 runtime features and might not work without a polyfill. When in doubt, use Babel REPL to see what any specific syntax compiles down to.

Syntax Highlighting in the Editor

To configure the syntax highlighting in your favorite text editor, head to the relevant Babel documentation page and follow the instructions. Some of the most popular editors are covered.

Displaying Lint Output in the Editor

Note: this feature is available with react-scripts@0.2.0 and higher.
It also only works with npm 3 or higher.

Some editors, including Sublime Text, Atom, and Visual Studio Code, provide plugins for ESLint.

They are not required for linting. You should see the linter output right in your terminal as well as the browser console. However, if you prefer the lint results to appear right in your editor, there are some extra steps you can do.

You would need to install an ESLint plugin for your editor first. Then, add a file called .eslintrc to the project root:

{
  "extends": "react-app"
}

Now your editor should report the linting warnings.

Note that even if you edit your .eslintrc file further, these changes will only affect the editor integration. They won’t affect the terminal and in-browser lint output. This is because Create React App intentionally provides a minimal set of rules that find common mistakes.

If you want to enforce a coding style for your project, consider using Prettier instead of ESLint style rules.

Debugging in the Editor

This feature is currently only supported by Visual Studio Code and WebStorm.

Visual Studio Code and WebStorm support debugging out of the box with Create React App. This enables you as a developer to write and debug your React code without leaving the editor, and most importantly it enables you to have a continuous development workflow, where context switching is minimal, as you don’t have to switch between tools.

Visual Studio Code

You would need to have the latest version of VS Code and VS Code Chrome Debugger Extension installed.

Then add the block below to your launch.json file and put it inside the .vscode folder in your app’s root directory.

{
  "version": "0.2.0",
  "configurations": [{
    "name": "Chrome",
    "type": "chrome",
    "request": "launch",
    "url": "http://localhost:3000",
    "webRoot": "${workspaceRoot}/src",
    "sourceMapPathOverrides": {
      "webpack:///src/*": "${webRoot}/*"
    }
  }]
}

Note: the URL may be different if you've made adjustments via the HOST or PORT environment variables.

Start your app by running npm start, and start debugging in VS Code by pressing F5 or by clicking the green debug icon. You can now write code, set breakpoints, make changes to the code, and debug your newly modified code—all from your editor.

Having problems with VS Code Debugging? Please see their troubleshooting guide.

WebStorm

You would need to have WebStorm and JetBrains IDE Support Chrome extension installed.

In the WebStorm menu Run select Edit Configurations.... Then click + and select JavaScript Debug. Paste http://localhost:3000 into the URL field and save the configuration.

Note: the URL may be different if you've made adjustments via the HOST or PORT environment variables.

Start your app by running npm start, then press ^D on macOS or F9 on Windows and Linux or click the green debug icon to start debugging in WebStorm.

The same way you can debug your application in IntelliJ IDEA Ultimate, PhpStorm, PyCharm Pro, and RubyMine.

Formatting Code Automatically

Prettier is an opinionated code formatter with support for JavaScript, CSS and JSON. With Prettier you can format the code you write automatically to ensure a code style within your project. See the Prettier's GitHub page for more information, and look at this page to see it in action.

To format our code whenever we make a commit in git, we need to install the following dependencies:

npm install --save husky lint-staged prettier

Alternatively you may use yarn:

yarn add husky lint-staged prettier
  • husky makes it easy to use githooks as if they are npm scripts.
  • lint-staged allows us to run scripts on staged files in git. See this blog post about lint-staged to learn more about it.
  • prettier is the JavaScript formatter we will run before commits.

Now we can make sure every file is formatted correctly by adding a few lines to the package.json in the project root.

Add the following line to scripts section:

  "scripts": {
+   "precommit": "lint-staged",
    "start": "react-scripts start",
    "build": "react-scripts build",

Next we add a 'lint-staged' field to the package.json, for example:

  "dependencies": {
    // ...
  },
+ "lint-staged": {
+   "src/**/*.{js,jsx,json,css}": [
+     "prettier --single-quote --write",
+     "git add"
+   ]
+ },
  "scripts": {

Now, whenever you make a commit, Prettier will format the changed files automatically. You can also run ./node_modules/.bin/prettier --single-quote --write "src/**/*.{js,jsx,json,css}" to format your entire project for the first time.

Next you might want to integrate Prettier in your favorite editor. Read the section on Editor Integration on the Prettier GitHub page.

Changing the Page <title>

You can find the source HTML file in the public folder of the generated project. You may edit the <title> tag in it to change the title from “React App” to anything else.

Note that normally you wouldn’t edit files in the public folder very often. For example, adding a stylesheet is done without touching the HTML.

If you need to dynamically update the page title based on the content, you can use the browser document.title API. For more complex scenarios when you want to change the title from React components, you can use React Helmet, a third party library.

If you use a custom server for your app in production and want to modify the title before it gets sent to the browser, you can follow advice in this section. Alternatively, you can pre-build each page as a static HTML file which then loads the JavaScript bundle, which is covered here.

Installing a Dependency

The generated project includes React and ReactDOM as dependencies. It also includes a set of scripts used by Create React App as a development dependency. You may install other dependencies (for example, React Router) with npm:

npm install --save react-router

Alternatively you may use yarn:

yarn add react-router

This works for any library, not just react-router.

Importing a Component

This project setup supports ES6 modules thanks to Babel.
While you can still use require() and module.exports, we encourage you to use import and export instead.

For example:

Button.js

import React, { Component } from 'react';

class Button extends Component {
  render() {
    // ...
  }
}

export default Button; // Don’t forget to use export default!

DangerButton.js

import React, { Component } from 'react';
import Button from './Button'; // Import a component from another file

class DangerButton extends Component {
  render() {
    return <Button color="red" />;
  }
}

export default DangerButton;

Be aware of the difference between default and named exports. It is a common source of mistakes.

We suggest that you stick to using default imports and exports when a module only exports a single thing (for example, a component). That’s what you get when you use export default Button and import Button from './Button'.

Named exports are useful for utility modules that export several functions. A module may have at most one default export and as many named exports as you like.

Learn more about ES6 modules:

Code Splitting

Instead of downloading the entire app before users can use it, code splitting allows you to split your code into small chunks which you can then load on demand.

This project setup supports code splitting via dynamic import(). Its proposal is in stage 3. The import() function-like form takes the module name as an argument and returns a Promise which always resolves to the namespace object of the module.

Here is an example:

moduleA.js

const moduleA = 'Hello';

export { moduleA };

App.js

import React, { Component } from 'react';

class App extends Component {
  handleClick = () => {
    import('./moduleA')
      .then(({ moduleA }) => {
        // Use moduleA
      })
      .catch(err => {
        // Handle failure
      });
  };

  render() {
    return (
      <div>
        <button onClick={this.handleClick}>Load</button>
      </div>
    );
  }
}

export default App;

This will make moduleA.js and all its unique dependencies as a separate chunk that only loads after the user clicks the 'Load' button.

You can also use it with async / await syntax if you prefer it.

With React Router

If you are using React Router check out this tutorial on how to use code splitting with it. You can find the companion GitHub repository here.

Also check out the Code Splitting section in React documentation.

Adding a Stylesheet

This project setup uses Webpack for handling all assets. Webpack offers a custom way of “extending” the concept of import beyond JavaScript. To express that a JavaScript file depends on a CSS file, you need to import the CSS from the JavaScript file:

Button.css

.Button {
  padding: 20px;
}

Button.js

import React, { Component } from 'react';
import './Button.css'; // Tell Webpack that Button.js uses these styles

class Button extends Component {
  render() {
    // You can use them as regular CSS styles
    return <div className="Button" />;
  }
}

This is not required for React but many people find this feature convenient. You can read about the benefits of this approach here. However you should be aware that this makes your code less portable to other build tools and environments than Webpack.

In development, expressing dependencies this way allows your styles to be reloaded on the fly as you edit them. In production, all CSS files will be concatenated into a single minified .css file in the build output.

If you are concerned about using Webpack-specific semantics, you can put all your CSS right into src/index.css. It would still be imported from src/index.js, but you could always remove that import if you later migrate to a different build tool.

Post-Processing CSS

This project setup minifies your CSS and adds vendor prefixes to it automatically through Autoprefixer so you don’t need to worry about it.

For example, this:

.App {
  display: flex;
  flex-direction: row;
  align-items: center;
}

becomes this:

.App {
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
  -webkit-box-orient: horizontal;
  -webkit-box-direction: normal;
      -ms-flex-direction: row;
          flex-direction: row;
  -webkit-box-align: center;
      -ms-flex-align: center;
          align-items: center;
}

If you need to disable autoprefixing for some reason, follow this section.

Adding a CSS Preprocessor (Sass, Less etc.)

Generally, we recommend that you don’t reuse the same CSS classes across different components. For example, instead of using a .Button CSS class in <AcceptButton> and <RejectButton> components, we recommend creating a <Button> component with its own .Button styles, that both <AcceptButton> and <RejectButton> can render (but not inherit).

Following this rule often makes CSS preprocessors less useful, as features like mixins and nesting are replaced by component composition. You can, however, integrate a CSS preprocessor if you find it valuable. In this walkthrough, we will be using Sass, but you can also use Less, or another alternative.

First, let’s install the command-line interface for Sass:

npm install --save node-sass-chokidar

Alternatively you may use yarn:

yarn add node-sass-chokidar

Then in package.json, add the following lines to scripts:

   "scripts": {
+    "build-css": "node-sass-chokidar src/ -o src/",
+    "watch-css": "npm run build-css && node-sass-chokidar src/ -o src/ --watch --recursive",
     "start": "react-scripts start",
     "build": "react-scripts build",
     "test": "react-scripts test --env=jsdom",

Note: To use a different preprocessor, replace build-css and watch-css commands according to your preprocessor’s documentation.

Now you can rename src/App.css to src/App.scss and run npm run watch-css. The watcher will find every Sass file in src subdirectories, and create a corresponding CSS file next to it, in our case overwriting src/App.css. Since src/App.js still imports src/App.css, the styles become a part of your application. You can now edit src/App.scss, and src/App.css will be regenerated.

To share variables between Sass files, you can use Sass imports. For example, src/App.scss and other component style files could include @import "./shared.scss"; with variable definitions.

To enable importing files without using relative paths, you can add the --include-path option to the command in package.json.

"build-css": "node-sass-chokidar --include-path ./src --include-path ./node_modules src/ -o src/",
"watch-css": "npm run build-css && node-sass-chokidar --include-path ./src --include-path ./node_modules src/ -o src/ --watch --recursive",

This will allow you to do imports like

@import 'styles/_colors.scss'; // assuming a styles directory under src/
@import 'nprogress/nprogress'; // importing a css file from the nprogress node module

At this point you might want to remove all CSS files from the source control, and add src/**/*.css to your .gitignore file. It is generally a good practice to keep the build products outside of the source control.

As a final step, you may find it convenient to run watch-css automatically with npm start, and run build-css as a part of npm run build. You can use the && operator to execute two scripts sequentially. However, there is no cross-platform way to run two scripts in parallel, so we will install a package for this:

npm install --save npm-run-all

Alternatively you may use yarn:

yarn add npm-run-all

Then we can change start and build scripts to include the CSS preprocessor commands:

   "scripts": {
     "build-css": "node-sass-chokidar src/ -o src/",
     "watch-css": "npm run build-css && node-sass-chokidar src/ -o src/ --watch --recursive",
-    "start": "react-scripts start",
-    "build": "react-scripts build",
+    "start-js": "react-scripts start",
+    "start": "npm-run-all -p watch-css start-js",
+    "build-js": "react-scripts build",
+    "build": "npm-run-all build-css build-js",
     "test": "react-scripts test --env=jsdom",
     "eject": "react-scripts eject"
   }

Now running npm start and npm run build also builds Sass files.

Why node-sass-chokidar?

node-sass has been reported as having the following issues:

  • node-sass --watch has been reported to have performance issues in certain conditions when used in a virtual machine or with docker.

  • Infinite styles compiling #1939

  • node-sass has been reported as having issues with detecting new files in a directory #1891

    node-sass-chokidar is used here as it addresses these issues.

Adding Images, Fonts, and Files

With Webpack, using static assets like images and fonts works similarly to CSS.

You can import a file right in a JavaScript module. This tells Webpack to include that file in the bundle. Unlike CSS imports, importing a file gives you a string value. This value is the final path you can reference in your code, e.g. as the src attribute of an image or the href of a link to a PDF.

To reduce the number of requests to the server, importing images that are less than 10,000 bytes returns a data URI instead of a path. This applies to the following file extensions: bmp, gif, jpg, jpeg, and png. SVG files are excluded due to #1153.

Here is an example:

import React from 'react';
import logo from './logo.png'; // Tell Webpack this JS file uses this image

console.log(logo); // /logo.84287d09.png

function Header() {
  // Import result is the URL of your image
  return <img src={logo} alt="Logo" />;
}

export default Header;

This ensures that when the project is built, Webpack will correctly move the images into the build folder, and provide us with correct paths.

This works in CSS too:

.Logo {
  background-image: url(./logo.png);
}

Webpack finds all relative module references in CSS (they start with ./) and replaces them with the final paths from the compiled bundle. If you make a typo or accidentally delete an important file, you will see a compilation error, just like when you import a non-existent JavaScript module. The final filenames in the compiled bundle are generated by Webpack from content hashes. If the file content changes in the future, Webpack will give it a different name in production so you don’t need to worry about long-term caching of assets.

Please be advised that this is also a custom feature of Webpack.

It is not required for React but many people enjoy it (and React Native uses a similar mechanism for images).
An alternative way of handling static assets is described in the next section.

Using the public Folder

Note: this feature is available with react-scripts@0.5.0 and higher.

Changing the HTML

The public folder contains the HTML file so you can tweak it, for example, to set the page title. The <script> tag with the compiled code will be added to it automatically during the build process.

Adding Assets Outside of the Module System

You can also add other assets to the public folder.

Note that we normally encourage you to import assets in JavaScript files instead. For example, see the sections on adding a stylesheet and adding images and fonts. This mechanism provides a number of benefits:

  • Scripts and stylesheets get minified and bundled together to avoid extra network requests.
  • Missing files cause compilation errors instead of 404 errors for your users.
  • Result filenames include content hashes so you don’t need to worry about browsers caching their old versions.

However there is an escape hatch that you can use to add an asset outside of the module system.

If you put a file into the public folder, it will not be processed by Webpack. Instead it will be copied into the build folder untouched. To reference assets in the public folder, you need to use a special variable called PUBLIC_URL.

Inside index.html, you can use it like this:

<link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico">

Only files inside the public folder will be accessible by %PUBLIC_URL% prefix. If you need to use a file from src or node_modules, you’ll have to copy it there to explicitly specify your intention to make this file a part of the build.

When you run npm run build, Create React App will substitute %PUBLIC_URL% with a correct absolute path so your project works even if you use client-side routing or host it at a non-root URL.

In JavaScript code, you can use process.env.PUBLIC_URL for similar purposes:

render() {
  // Note: this is an escape hatch and should be used sparingly!
  // Normally we recommend using `import` for getting asset URLs
  // as described in “Adding Images and Fonts” above this section.
  return <img src={process.env.PUBLIC_URL + '/img/logo.png'} />;
}

Keep in mind the downsides of this approach:

  • None of the files in public folder get post-processed or minified.
  • Missing files will not be called at compilation time, and will cause 404 errors for your users.
  • Result filenames won’t include content hashes so you’ll need to add query arguments or rename them every time they change.

When to Use the public Folder

Normally we recommend importing stylesheets, images, and fonts from JavaScript. The public folder is useful as a workaround for a number of less common cases:

  • You need a file with a specific name in the build output, such as manifest.webmanifest.
  • You have thousands of images and need to dynamically reference their paths.
  • You want to include a small script like pace.js outside of the bundled code.
  • Some library may be incompatible with Webpack and you have no other option but to include it as a <script> tag.

Note that if you add a <script> that declares global variables, you also need to read the next section on using them.

Using Global Variables

When you include a script in the HTML file that defines global variables and try to use one of these variables in the code, the linter will complain because it cannot see the definition of the variable.

You can avoid this by reading the global variable explicitly from the window object, for example:

const $ = window.$;

This makes it obvious you are using a global variable intentionally rather than because of a typo.

Alternatively, you can force the linter to ignore any line by adding // eslint-disable-line after it.

Adding Bootstrap

You don’t have to use React Bootstrap together with React but it is a popular library for integrating Bootstrap with React apps. If you need it, you can integrate it with Create React App by following these steps:

Install React Bootstrap and Bootstrap from npm. React Bootstrap does not include Bootstrap CSS so this needs to be installed as well:

npm install --save react-bootstrap bootstrap@3

Alternatively you may use yarn:

yarn add react-bootstrap bootstrap@3

Import Bootstrap CSS and optionally Bootstrap theme CSS in the beginning of your src/index.js file:

import 'bootstrap/dist/css/bootstrap.css';
import 'bootstrap/dist/css/bootstrap-theme.css';
// Put any other imports below so that CSS from your
// components takes precedence over default styles.

Import required React Bootstrap components within src/App.js file or your custom component files:

import { Navbar, Jumbotron, Button } from 'react-bootstrap';

Now you are ready to use the imported React Bootstrap components within your component hierarchy defined in the render method. Here is an example App.js redone using React Bootstrap.

Using a Custom Theme

Sometimes you might need to tweak the visual styles of Bootstrap (or equivalent package).
We suggest the following approach:

  • Create a new package that depends on the package you wish to customize, e.g. Bootstrap.
  • Add the necessary build steps to tweak the theme, and publish your package on npm.
  • Install your own theme npm package as a dependency of your app.

Here is an example of adding a customized Bootstrap that follows these steps.

Adding Flow

Flow is a static type checker that helps you write code with fewer bugs. Check out this introduction to using static types in JavaScript if you are new to this concept.

Recent versions of Flow work with Create React App projects out of the box.

To add Flow to a Create React App project, follow these steps:

  1. Run npm install --save flow-bin (or yarn add flow-bin).
  2. Add "flow": "flow" to the scripts section of your package.json.
  3. Run npm run flow init (or yarn flow init) to create a .flowconfig file in the root directory.
  4. Add // @flow to any files you want to type check (for example, to src/App.js).

Now you can run npm run flow (or yarn flow) to check the files for type errors. You can optionally use an IDE like Nuclide for a better integrated experience. In the future we plan to integrate it into Create React App even more closely.

To learn more about Flow, check out its documentation.

Adding a Router

Create React App doesn't prescribe a specific routing solution, but React Router is the most popular one.

To add it, run:

npm install --save react-router-dom

Alternatively you may use yarn:

yarn add react-router-dom

To try it, delete all the code in src/App.js and replace it with any of the examples on its website. The Basic Example is a good place to get started.

Note that you may need to configure your production server to support client-side routing before deploying your app.

Adding Custom Environment Variables

Note: this feature is available with react-scripts@0.2.3 and higher.

Your project can consume variables declared in your environment as if they were declared locally in your JS files. By default you will have NODE_ENV defined for you, and any other environment variables starting with REACT_APP_.

The environment variables are embedded during the build time. Since Create React App produces a static HTML/CSS/JS bundle, it can’t possibly read them at runtime. To read them at runtime, you would need to load HTML into memory on the server and replace placeholders in runtime, just like described here. Alternatively you can rebuild the app on the server anytime you change them.

Note: You must create custom environment variables beginning with REACT_APP_. Any other variables except NODE_ENV will be ignored to avoid accidentally exposing a private key on the machine that could have the same name. Changing any environment variables will require you to restart the development server if it is running.

These environment variables will be defined for you on process.env. For example, having an environment variable named REACT_APP_SECRET_CODE will be exposed in your JS as process.env.REACT_APP_SECRET_CODE.

There is also a special built-in environment variable called NODE_ENV. You can read it from process.env.NODE_ENV. When you run npm start, it is always equal to 'development', when you run npm test it is always equal to 'test', and when you run npm run build to make a production bundle, it is always equal to 'production'. You cannot override NODE_ENV manually. This prevents developers from accidentally deploying a slow development build to production.

These environment variables can be useful for displaying information conditionally based on where the project is deployed or consuming sensitive data that lives outside of version control.

First, you need to have environment variables defined. For example, let’s say you wanted to consume a secret defined in the environment inside a <form>:

render() {
  return (
    <div>
      <small>You are running this application in <b>{process.env.NODE_ENV}</b> mode.</small>
      <form>
        <input type="hidden" defaultValue={process.env.REACT_APP_SECRET_CODE} />
      </form>
    </div>
  );
}

During the build, process.env.REACT_APP_SECRET_CODE will be replaced with the current value of the REACT_APP_SECRET_CODE environment variable. Remember that the NODE_ENV variable will be set for you automatically.

When you load the app in the browser and inspect the <input>, you will see its value set to abcdef, and the bold text will show the environment provided when using npm start:

<div>
  <small>You are running this application in <b>development</b> mode.</small>
  <form>
    <input type="hidden" value="abcdef" />
  </form>
</div>

The above form is looking for a variable called REACT_APP_SECRET_CODE from the environment. In order to consume this value, we need to have it defined in the environment. This can be done using two ways: either in your shell or in a .env file. Both of these ways are described in the next few sections.

Having access to the NODE_ENV is also useful for performing actions conditionally:

if (process.env.NODE_ENV !== 'production') {
  analytics.disable();
}

When you compile the app with npm run build, the minification step will strip out this condition, and the resulting bundle will be smaller.

Referencing Environment Variables in the HTML

Note: this feature is available with react-scripts@0.9.0 and higher.

You can also access the environment variables starting with REACT_APP_ in the public/index.html. For example:

<title>%REACT_APP_WEBSITE_NAME%</title>

Note that the caveats from the above section apply:

  • Apart from a few built-in variables (NODE_ENV and PUBLIC_URL), variable names must start with REACT_APP_ to work.
  • The environment variables are injected at build time. If you need to inject them at runtime, follow this approach instead.

Adding Temporary Environment Variables In Your Shell

Defining environment variables can vary between OSes. It’s also important to know that this manner is temporary for the life of the shell session.

Windows (cmd.exe)

set "REACT_APP_SECRET_CODE=abcdef" && npm start

(Note: Quotes around the variable assignment are required to avoid a trailing whitespace.)

Windows (Powershell)

($env:REACT_APP_SECRET_CODE = "abcdef") -and (npm start)

Linux, macOS (Bash)

REACT_APP_SECRET_CODE=abcdef npm start

Adding Development Environment Variables In .env

Note: this feature is available with react-scripts@0.5.0 and higher.

To define permanent environment variables, create a file called .env in the root of your project:

REACT_APP_SECRET_CODE=abcdef

Note: You must create custom environment variables beginning with REACT_APP_. Any other variables except NODE_ENV will be ignored to avoid accidentally exposing a private key on the machine that could have the same name. Changing any environment variables will require you to restart the development server if it is running.

.env files should be checked into source control (with the exclusion of .env*.local).

What other .env files can be used?

Note: this feature is available with react-scripts@1.0.0 and higher.

  • .env: Default.
  • .env.local: Local overrides. This file is loaded for all environments except test.
  • .env.development, .env.test, .env.production: Environment-specific settings.
  • .env.development.local, .env.test.local, .env.production.local: Local overrides of environment-specific settings.

Files on the left have more priority than files on the right:

  • npm start: .env.development.local, .env.development, .env.local, .env
  • npm run build: .env.production.local, .env.production, .env.local, .env
  • npm test: .env.test.local, .env.test, .env (note .env.local is missing)

These variables will act as the defaults if the machine does not explicitly set them.
Please refer to the dotenv documentation for more details.

Note: If you are defining environment variables for development, your CI and/or hosting platform will most likely need these defined as well. Consult their documentation how to do this. For example, see the documentation for Travis CI or Heroku.

Expanding Environment Variables In .env

Note: this feature is available with react-scripts@1.1.0 and higher.

Expand variables already on your machine for use in your .env file (using dotenv-expand).

For example, to get the environment variable npm_package_version:

REACT_APP_VERSION=$npm_package_version
# also works:
# REACT_APP_VERSION=${npm_package_version}

Or expand variables local to the current .env file:

DOMAIN=www.example.com
REACT_APP_FOO=$DOMAIN/foo
REACT_APP_BAR=$DOMAIN/bar

Can I Use Decorators?

Many popular libraries use decorators in their documentation.
Create React App doesn’t support decorator syntax at the moment because:

  • It is an experimental proposal and is subject to change.
  • The current specification version is not officially supported by Babel.
  • If the specification changes, we won’t be able to write a codemod because we don’t use them internally at Facebook.

However in many cases you can rewrite decorator-based code without decorators just as fine.
Please refer to these two threads for reference:

Create React App will add decorator support when the specification advances to a stable stage.

Fetching Data with AJAX Requests

React doesn't prescribe a specific approach to data fetching, but people commonly use either a library like axios or the fetch() API provided by the browser. Conveniently, Create React App includes a polyfill for fetch() so you can use it without worrying about the browser support.

The global fetch function allows to easily makes AJAX requests. It takes in a URL as an input and returns a Promise that resolves to a Response object. You can find more information about fetch here.

This project also includes a Promise polyfill which provides a full implementation of Promises/A+. A Promise represents the eventual result of an asynchronous operation, you can find more information about Promises here and here. Both axios and fetch() use Promises under the hood. You can also use the async / await syntax to reduce the callback nesting.

You can learn more about making AJAX requests from React components in the FAQ entry on the React website.

Integrating with an API Backend

These tutorials will help you to integrate your app with an API backend running on another port, using fetch() to access it.

Node

Check out this tutorial. You can find the companion GitHub repository here.

Ruby on Rails

Check out this tutorial. You can find the companion GitHub repository here.

Proxying API Requests in Development

Note: this feature is available with react-scripts@0.2.3 and higher.

People often serve the front-end React app from the same host and port as their backend implementation.
For example, a production setup might look like this after the app is deployed:

/             - static server returns index.html with React app
/todos        - static server returns index.html with React app
/api/todos    - server handles any /api/* requests using the backend implementation

Such setup is not required. However, if you do have a setup like this, it is convenient to write requests like fetch('/api/todos') without worrying about redirecting them to another host or port during development.

To tell the development server to proxy any unknown requests to your API server in development, add a proxy field to your package.json, for example:

  "proxy": "http://localhost:4000",

This way, when you fetch('/api/todos') in development, the development server will recognize that it’s not a static asset, and will proxy your request to http://localhost:4000/api/todos as a fallback. The development server will only attempt to send requests without text/html in its Accept header to the proxy.

Conveniently, this avoids CORS issues and error messages like this in development:

Fetch API cannot load http://localhost:4000/api/todos. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:3000' is therefore not allowed access. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.

Keep in mind that proxy only has effect in development (with npm start), and it is up to you to ensure that URLs like /api/todos point to the right thing in production. You don’t have to use the /api prefix. Any unrecognized request without a text/html accept header will be redirected to the specified proxy.

The proxy option supports HTTP, HTTPS and WebSocket connections.
If the proxy option is not flexible enough for you, alternatively you can:

"Invalid Host Header" Errors After Configuring Proxy

When you enable the proxy option, you opt into a more strict set of host checks. This is necessary because leaving the backend open to remote hosts makes your computer vulnerable to DNS rebinding attacks. The issue is explained in this article and this issue.

This shouldn’t affect you when developing on localhost, but if you develop remotely like described here, you will see this error in the browser after enabling the proxy option:

Invalid Host header

To work around it, you can specify your public development host in a file called .env.development in the root of your project:

HOST=mypublicdevhost.com

If you restart the development server now and load the app from the specified host, it should work.

If you are still having issues or if you’re using a more exotic environment like a cloud editor, you can bypass the host check completely by adding a line to .env.development.local. Note that this is dangerous and exposes your machine to remote code execution from malicious websites:

# NOTE: THIS IS DANGEROUS!
# It exposes your machine to attacks from the websites you visit.
DANGEROUSLY_DISABLE_HOST_CHECK=true

We don’t recommend this approach.

Configuring the Proxy Manually

Note: this feature is available with react-scripts@1.0.0 and higher.

If the proxy option is not flexible enough for you, you can specify an object in the following form (in package.json).
You may also specify any configuration value http-proxy-middleware or http-proxy supports.

{
  // ...
  "proxy": {
    "/api": {
      "target": "<url>",
      "ws": true
      // ...
    }
  }
  // ...
}

All requests matching this path will be proxies, no exceptions. This includes requests for text/html, which the standard proxy option does not proxy.

If you need to specify multiple proxies, you may do so by specifying additional entries. Matches are regular expressions, so that you can use a regexp to match multiple paths.

{
  // ...
  "proxy": {
    // Matches any request starting with /api
    "/api": {
      "target": "<url_1>",
      "ws": true
      // ...
    },
    // Matches any request starting with /foo
    "/foo": {
      "target": "<url_2>",
      "ssl": true,
      "pathRewrite": {
        "^/foo": "/foo/beta"
      }
      // ...
    },
    // Matches /bar/abc.html but not /bar/sub/def.html
    "/bar/[^/]*[.]html": {
      "target": "<url_3>",
      // ...
    },
    // Matches /baz/abc.html and /baz/sub/def.html
    "/baz/.*/.*[.]html": {
      "target": "<url_4>"
      // ...
    }
  }
  // ...
}

Configuring a WebSocket Proxy

When setting up a WebSocket proxy, there are a some extra considerations to be aware of.

If you’re using a WebSocket engine like Socket.io, you must have a Socket.io server running that you can use as the proxy target. Socket.io will not work with a standard WebSocket server. Specifically, don't expect Socket.io to work with the websocket.org echo test.

There’s some good documentation available for setting up a Socket.io server.

Standard WebSockets will work with a standard WebSocket server as well as the websocket.org echo test. You can use libraries like ws for the server, with native WebSockets in the browser.

Either way, you can proxy WebSocket requests manually in package.json:

{
  // ...
  "proxy": {
    "/socket": {
      // Your compatible WebSocket server
      "target": "ws://<socket_url>",
      // Tell http-proxy-middleware that this is a WebSocket proxy.
      // Also allows you to proxy WebSocket requests without an additional HTTP request
      // https://github.com/chimurai/http-proxy-middleware#external-websocket-upgrade
      "ws": true
      // ...
    }
  }
  // ...
}

Using HTTPS in Development

Note: this feature is available with react-scripts@0.4.0 and higher.

You may require the dev server to serve pages over HTTPS. One particular case where this could be useful is when using the "proxy" feature to proxy requests to an API server when that API server is itself serving HTTPS.

To do this, set the HTTPS environment variable to true, then start the dev server as usual with npm start:

Windows (cmd.exe)

set HTTPS=true&&npm start

Windows (Powershell)

($env:HTTPS = $true) -and (npm start)

(Note: the lack of whitespace is intentional.)

Linux, macOS (Bash)

HTTPS=true npm start

Note that the server will use a self-signed certificate, so your web browser will almost definitely display a warning upon accessing the page.

Generating Dynamic <meta> Tags on the Server

Since Create React App doesn’t support server rendering, you might be wondering how to make <meta> tags dynamic and reflect the current URL. To solve this, we recommend to add placeholders into the HTML, like this:

<!doctype html>
<html lang="en">
  <head>
    <meta property="og:title" content="__OG_TITLE__">
    <meta property="og:description" content="__OG_DESCRIPTION__">

Then, on the server, regardless of the backend you use, you can read index.html into memory and replace __OG_TITLE__, __OG_DESCRIPTION__, and any other placeholders with values depending on the current URL. Just make sure to sanitize and escape the interpolated values so that they are safe to embed into HTML!

If you use a Node server, you can even share the route matching logic between the client and the server. However duplicating it also works fine in simple cases.

Pre-Rendering into Static HTML Files

If you’re hosting your build with a static hosting provider you can use react-snapshot or react-snap to generate HTML pages for each route, or relative link, in your application. These pages will then seamlessly become active, or “hydrated”, when the JavaScript bundle has loaded.

There are also opportunities to use this outside of static hosting, to take the pressure off the server when generating and caching routes.

The primary benefit of pre-rendering is that you get the core content of each page with the HTML payload—regardless of whether or not your JavaScript bundle successfully downloads. It also increases the likelihood that each route of your application will be picked up by search engines.

You can read more about zero-configuration pre-rendering (also called snapshotting) here.

Injecting Data from the Server into the Page

Similarly to the previous section, you can leave some placeholders in the HTML that inject global variables, for example:

<!doctype html>
<html lang="en">
  <head>
    <script>
      window.SERVER_DATA = __SERVER_DATA__;
    </script>

Then, on the server, you can replace __SERVER_DATA__ with a JSON of real data right before sending the response. The client code can then read window.SERVER_DATA to use it. Make sure to sanitize the JSON before sending it to the client as it makes your app vulnerable to XSS attacks.

Running Tests

Note: this feature is available with react-scripts@0.3.0 and higher.
Read the migration guide to learn how to enable it in older projects!

Create React App uses Jest as its test runner. To prepare for this integration, we did a [major revamp](https:/

更多

友情链接

    我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
    原文