精华内容
下载资源
问答
  • React中文文档.zip

    2019-08-13 16:48:56
    react中文文档
  • react docs in Chinese | react中文文档翻译
  • React中文文档 打算把React官方文档翻译一遍,主要是为了让知识更系统些。 翻译过程中可能会加入一点自己的理解。文档可在查看。 主要是这几大块,会持续更新。 快速开始 高级指南 参考文档 官方博客 如果您有发现...
  • React 是 JavaScript 构建大型,高性能 Web 应用的首选。在 Facebook 和 Instagram 中都能很好的应用。kindle React 中文文档.epub
  • react中文文档 https://doc.react-china.org 二. react英文文档 https://reactjs.org 三.react Github https://github.com/facebook/react 四. react中文社区 http://react-china.org/ 五.React Router中文...

    一. react中文文档

    https://doc.react-china.org

    二. react英文文档

    https://reactjs.org

    三.react Github

    https://github.com/facebook/react

    四. react中文社区

    http://react-china.org/

    五.React Router中文文档

    https://react-guide.github.io/react-router-cn/

    六.ant design

    https://ant.design/index-cn

    七.阿里的react组件库

    https://github.com/react-component

    八. ECMAScript 6入门(ES6)

    http://es6.ruanyifeng.com/

    九.webpack官方中文文档

    https://doc.webpack-china.org/concepts/

    十.JavaScript语言参考及API文档

    https://developer.mozilla.org/zh-CN/docs/Web/JavaScript

    http://www.runoob.com/jsref/jsref-obj-array.html

    http://www.css88.com/archives/8405

    https://zeekat.nl/articles/constructors-considered-mildly-confusing.html

    http://www.javascripttutorial.net/javascript-prototype/

    http://wiki.jikexueyuan.com/list/javascript/

    https://medium.com/@peterchang_82818/javascripter-%E5%BF%85%E9%A0%88%E7%9F%A5%E9%81%93%E7%9A%84%E7%B9%BC%E6%89%BF%E5%9B%A0%E5%AD%90-prototype-prototype-proto-object-class-inheritace-nodejs-%E7%89%A9%E4%BB%B6-%E7%B9%BC%E6%89%BF-54102240a8b4

    https://msdn.microsoft.com/library/ff877835(v=vs.94).aspx

    十一. NPM

    https://www.npmjs.com

    https://www.npmjs.com.cn/

    十二.react-router 在线文档及github地址

    https://reacttraining.com/react-router/web/guides/basic-components

    https://github.com/ReactTraining/react-router

    十三. nodejs在线中文文档

    http://nodejs.cn/ 

    十四.nodejs 英文原版文档

    https://nodejs.org/en/

    十五. html-webpack-plugin

    https://github.com/jantimon/html-webpack-plugin

    十六.  V8引擎官方文档

    https://developers.google.com/v8/intro

    十七. KOA

    https://chenshenhai.github.io/koa2-note/note/project/start.html

    https://koa.bootcss.com/#introduction

    https://github.com/demopark/koa-docs-Zh-CN

    展开全文
  • React中文文档.docx

    2020-09-08 10:33:13
    许多人使用React作为MVC架构的V层。 尽管React并没有假设过你的其余技术栈, 但它仍可以作为一个小特征轻易地在已有项目中使用 React为了更高超的性能而使用虚拟DOM作为其不同的实现。 它同时也可以由服务端Node.js...
  • 点击进入——React中文文档 JSX及元素渲染 React 是一个 JavaScript 库 。 const element = <h1>Hello, world!</h1>; 考虑一下这个变量的声明,它既不是字符串也不是HTML,这就是 JSX ,它是 ...

    快速入门

    点击进入——React中文文档


    JSX及元素渲染

    1. React 是一个 JavaScript 库

    2. const element = <h1>Hello, world!</h1>; 考虑一下这个变量的声明,它既不是字符串也不是HTML,这就是 JSX ,它是 JavaScrip 的一种扩展语法。我们推荐在 React 中使用这种语法来描述 UI 信息,它具有 JavaScrip 的全部能力,可以生成React “元素”。

    3. 比起 HTML,JSX 更接近于 JavaScript,所以 React DOM 使用驼峰(camelCase)属性命名约定,而不是HTML属性名称。 例如,class 在JSX中变为classNametabindex 变为 tabIndex

    4. 元素(Elements)是 React 应用中最小的构建部件,它是构成组建的“材料”,一个元素用于描述你在将在屏幕上看到的内容,例如:const element = <h1>Hello, world</h1>;

    5. React 元素是 不可突变(immutable) 的,一旦你创建了一个元素, 就不能再修改其子元素或任何属性。一个元素就像电影里的一帧: 它表示在某一特定时间点的 UI 。更新 UI 的唯一方法是创建一个新的元素, 并将其传入ReactDOM.render() 方法。但实际上,大多数 React 应用只会调用 ReactDOM.render() 一次。更新UI更多的是通过与 状态(state)生命周期 挂钩来实现的。

    组件(Components) 和 属性(Props)

    1. 组件名称总是以大写字母开始

    2. 组件必须返回一个单独的根元素。

    3. function sum(a, b) { return a + b; },这种函数称为 “ 纯函数 ” ,因为它们不会试图改变它们的输入,并且 对于同样的输入,始终可以得到相同的结果 。 反之, 以下是非纯函数, 因为它改变了自身的输入值: function withdraw(account, amount) { account.total -= amount; }

    4. 所有 React 组件都必须是 纯函数,并禁止修改其自身 props 。

    状态(State) 和 生命周期

    1. this.props 由 React 本身设定, 而 this.state 具有特殊的含义,但如果需要存储一些不用于视觉输出的内容,则可以手动向类中添加额外的字段。 如果在 render() 方法中没有被引用, 它不应该出现在 state

    2. 关于 setState() 有三件事是你应该知道的:

    • 不要直接修改 state(状态)

      例如,这样将不会重新渲染一个组件:this.state.comment = 'Hello';

      正确的做法是用 setState() 来修改 statethis.setState({comment: 'Hello'});

    • state(状态) 更新可能是异步的

      React 为了优化性能,有可能会将多个 setState() 调用合并为一次更新。因为 this.propsthis.state 可能是异步更新的,你不能依赖他们的值计算下一个state(状态)。

      例如, 以下代码可能导致 counter(计数器)更新失败:

      // 错误
      this.setState({
        counter: this.state.counter + this.props.increment,
      });
      复制代码

      要弥补这个问题,使用另一种 setState() 的形式,它 接受一个函数而不是一个对象 。这个函数将接收 前一个状态 作为 第一个参数 ,应用 更新时的 props 作为 第二个参数

      // 正确
      this.setState((prevState, props) => ({
        counter: prevState.counter + props.increment
      }));
      复制代码
    • state(状态)更新会被合并

      当你调用 setState() , React 将合并你提供的对象到当前的状态中。

    • 数据向下流动

      如果把组件树想像为 props(属性) 的瀑布,所有组件的 state(状态) 就如同一个额外的水源汇入主流,且只能随着主流的方向向下流动。

      任何 state(状态) 始终由某个特定组件所有,并且从该 state(状态) 导出的任何数据 或 UI 只能影响树中 “下方” 的组件。

    处理事件

    1. 通过 React 元素处理事件跟在 DOM 元素上处理事件非常相似。但是有一些语法上的区别:
    • React 事件使用驼峰命名,而不是全部小写。

    • 通过 JSX , 你传递一个函数作为事件处理程序,而不是一个字符串。

    • 在 React 中你不能通过返回 false 来阻止默认行为。必须明确调用 preventDefault 。例如,对于纯 HTML ,要阻止链接打开一个新页面的默认行为,可以这样写:

      <a href="#" onclick="console.log('The link was clicked.'); return false">
        Click me
      </a>
      复制代码

      在 React 中, 应该这么写:

      function ActionLink() {
        function handleClick(e) {
          e.preventDefault();
          console.log('The link was clicked.');
        }
      
        return (
          <a href="#" onClick={handleClick}>
            Click me
          </a>
        );
      }
      复制代码

    条件渲染

    1. 在 React 中,你可以创建不同的组件封装你所需要的行为。然后,只渲染它们之中的一些,取决于你的应用的状态。 React 中的条件渲染就和在 JavaScript 中的条件语句一样 。使用 JavaScript 操作符如 if 或者条件操作符来创建渲染当前状态的元素,并且让 React 更新匹配的 UI 。

      虽然声明一个变量并使用一个 if 语句是一个有条件地渲染组件的好方法,有时你可能想要使用一个更简短的语法。在 JSX 中有几种内联条件的方法,如下所述。

      • 使用逻辑 && 操作符的内联 if 用法

        例如当数组arr不为空时渲染组件 <ShowMessages> ,可以写成

        { 
            arr.length>0 &&
            <ShowMessages>
        }
        复制代码

        它可以正常运行,因为在 JavaScript 中, true && expression 总是会评估为 expression ,而 false && expression 总是执行为 false 。 因此,如果条件为 true ,则 && 后面的元素将显示在输出中。 如果是 false,React 将会忽略并跳过它

      • 使用条件操作符的内联 If-Else

        另一个用于条件渲染元素的内联方法是使用 JavaScript 的条件操作符 If-Else 或者是三目运算符 condition ? true : false

      还要记住,无论何时何地,当条件变得太复杂时,可能是提取组件的好时机

    2. 防止组件渲染

      在极少数情况下,您可能希望组件隐藏自身,即使它是由另一个组件渲染的。为此,返回 null 而不使其渲染输出

      例如在如下代码中:

      //方法一:
      function WarningBanner(props) {
        if (!props.warn) {
          return null;
        }
        return (
          <div className="warning">
            Warning!
          </div>
        );
      }
      
      class Page extends React.Component {
        constructor(props) {
          super(props);
          this.state = {showWarning: true}
          this.handleToggleClick = this.handleToggleClick.bind(this);
        }
      
        handleToggleClick() {
          this.setState(prevState => ({
            showWarning: !prevState.showWarning
          }));
        }
        
        render() {
          return (
            <div>
              <WarningBanner warn={this.state.showWarning} />
              <button onClick={this.handleToggleClick}>
                {this.state.showWarning ? 'Hide' : 'Show'}
              </button>
            </div>
          );
        }
      }
      
      ReactDOM.render(
        <Page />,
        document.getElementById('root')
      );
      复制代码

      Hide按钮可以控制 Warning div 的显示隐藏。 同样,以下代码也能达到相同效果:

      //方法二:
      class Page extends React.Component {
        constructor(props) {
          super(props);
          this.state = {showWarning: true}
          this.handleToggleClick = this.handleToggleClick.bind(this);
        }
      
        handleToggleClick() {
          this.setState(prevState => ({
            showWarning: !prevState.showWarning
          }));
        }
        
        render() {
          return (
            <div>
              <div className="warning" style={{display:this.state.showWarning?'':'none'}}>
                Warning!
              </div>
              <button onClick={this.handleToggleClick}>
                {this.state.showWarning ? 'Hide' : 'Show'}
              </button>
            </div>
          );
        }
      }
      
      ReactDOM.render(
        <Page />,
        document.getElementById('root')
      );
      复制代码

      这里没有把 Warning div 当做组件抽离出来,虽然也能达到相同的效果,但是使用 display 只是控制了 Warning div 的显示隐藏,不论如何,Warning div 其实都已经在页面加载了,消耗了资源;而第一种方法返回 null ,却是完完全全的控制了 Warning div 的加载,性能上更胜一筹。

      PS:从组件的 render 方法返回 null 不会影响组件生命周期方法的触发。 例如, componentWillUpdatecomponentDidUpdate 仍将被调用。

    列表(Lists) 和 键(Keys)

    1. 首先,先来看一段代码:

      const numbers = [1, 2, 3, 4, 5];
      const listItems = numbers.map((numbers) =>
        <li>{numbers}</li>
      );
      
      ReactDOM.render(
        <ul>{listItems}</ul>,
        document.getElementById('root')
      );
      复制代码

      这段代码显示从 1 到 5 的数字列表。

      当运行上述代码时,虽然会正确显示出列表,但是会收到一个警告:a key should be provided for list items(应该为列表元素提供一个键)。当创建元素列表时,“key” 是一个你需要包含的特殊字符串属性。 键(Keys) 帮助 React 标识哪个项被修改、添加或者移除了 。数组中的 每一个元素 都应该有一个 唯一不变 的键(Keys)来标识。挑选 key 最好的方式是使用一个在它的同辈元素中不重复的标识字符串。多数情况你可以使用数据中的 ID 作为 keys;当要渲染的列表项中没有稳定的 IDs 时,你可以使用数据项的索引值作为 key 的最后选择,例如:

      const numbers = [1, 2, 3, 4, 5];
      const listItems = numbers.map((numbers,index) =>
        <li key={index}>{numbers}</li>
      );
      
      ReactDOM.render(
        <ul>{listItems}</ul>,
        document.getElementById('root')
      );
      复制代码
    2. 使用 keys 提取组件 keys 只在数组的上下文中存在意义。例如,如果你提取 一个 ListItem 组件,应该把 key 放置在数组处理的 <ListItem /> 元素中,不能放在 ListItem 组件自身中的 <li> 根元素上。

      例如:

      function ListItem(props) {
        const value = props.value;
        return (
          // 错误!不需要在这里指定 key:
          <li key={value.toString()}>
            {value}
          </li>
        );
      }
      
      function NumberList(props) {
        const numbers = props.numbers;
        const listItems = numbers.map((number) =>
          // 错误!key 应该在这里指定:
          <ListItem value={number} />
        );
        return (
          <ul>
            {listItems}
          </ul>
        );
      }
      
      const numbers = [1, 2, 3, 4, 5];
      ReactDOM.render(
        <NumberList numbers={numbers} />,
        document.getElementById('root')
      );
      复制代码

      一个好的经验准则是:元素中调用 map() 需要 keys

    3. keys同辈元素中必须是唯一

      在数组中使用的 keys 必须在它们的同辈之间唯一。然而它们并不需要全局唯一。我们可以在操作两个不同数组的时候使用相同的 keys。

    表单(Forms)

    1. 受控组件(Controlled Components)

      在 HTML 中,表单元素如 <input><textarea><select> 表单元素通常保持自己的状态,并根据用户输入进行更新。而在 React 中,可变状态一般保存在组件的 state(状态) 属性中,并且只能通过 setState() 更新。

      我们可以通过使 React 的 state 成为 “单一数据源原则” 来结合这两个形式。然后渲染表单的 React 组件也可以控制在用户输入之后的行为。这种形式,其 值由 React 控制的输入表单元素 称为“ 受控组件 ”。

      例如,如果我们想在提交时记录名称,我们可以将表单写为受控组件:

      class NameForm extends React.Component {
        constructor(props) {
          super(props);
          this.state = {value: ''};
        }
      
        handleChange(event) {
          this.setState({value: event.target.value});
        }
      
        handleSubmit(event) {
          alert('A name was submitted: ' + this.state.value);
          event.preventDefault();
        }
      
        render() {
          return (
            <form onSubmit={this.handleSubmit.bind(this)}>
              <label>
                Name:
                <input type="text" value={this.state.value} onChange={this.handleChange.bind(this)} />
              </label>
              <input type="submit" value="Submit" />
            </form>
          );
        }
      }
      
      ReactDOM.render(
        <NameForm />,
        document.getElementById('root')
      );
      复制代码

      设置表单元素的value属性之后,其显示值将由 this.state.value 决定,以满足React状态的同一数据理念。每次键盘敲击之后会执行 handleChange 方法以更新React状态,显示值也将随着用户的输入改变。

      由于 value 属性设置在我们的表单元素上,显示的值总是 this.state.value,以满足 state 状态的同一数据理念。由于 handleChange 在每次敲击键盘时运行,以更新 React state(状态),显示的值将更新为用户的输入。

      对于受控组件来说,每一次 state(状态) 变化都会伴有相关联的处理函数。这使得可以直接修改或验证用户的输入。

    2. 处理多个输入元素

      当您需要处理多个受控的 input 元素时,您可以为每个元素添加一个 name 属性,并且让处理函数根据 event.target.name 的值来选择要做什么。而不必写多个 onChange 函数

      例如:

      class Reservation extends React.Component {
        constructor(props) {
          super(props);
          this.state = {
            isGoing: true,
            numberOfGuests: 2
          };
      
          this.handleInputChange = this.handleInputChange.bind(this);
        }
      
        handleInputChange(event) {
          const target = event.target;
          const value = target.type === 'checkbox' ? target.checked : target.value;
          const name = target.name;
      
          this.setState({
            [name]: value
          });
        }
      
        render() {
          return (
            <form>
              <label>
                Is going:
                <input
                  name="isGoing"
                  type="checkbox"
                  checked={this.state.isGoing}
                  onChange={this.handleInputChange} />
              </label>
              
              <label>
                Number of guests:
                <input
                  name="numberOfGuests"
                  type="number"
                  value={this.state.numberOfGuests}
                  onChange={this.handleInputChange} />
              </label>
            </form>
          );
        }
      }
      
      ReactDOM.render(
        <Reservation />,
        document.getElementById('root')
      );
      复制代码

      handleInputChange() 方法中,注意我们如何使用ES6计算的属性名称语法来更新与给定输入名称相对应的 state(状态) 键:

      const name = target.name;
      
      this.setState({
        [name]: value
      });
      复制代码

    状态提升(Lifting State Up)

    1. 在一个 React 应用中,对于任何可变的数据都应该循序“单一数据源”原则。通常情况下,state 首先被添加到需要它进行渲染的组件。然后,如果其它的组件也需要它,你可以提升状态到它们最近的祖先组件。你应该依赖 从上到下的数据流向 ,而不是试图在不同的组件中同步状态。

      提升状态相对于双向绑定方法需要写更多的“模板”代码,但是有一个好处,它可以更方便的找到和隔离 bugs。由于任何 state(状态) 都 “存活” 在若干的组件中,而且可以分别对其独立修改,所以发生错误的可能大大减少。另外,你可以实现任何定制的逻辑来拒绝或者转换用户输入。

      如果某个东西可以从 props(属性) 或者 state(状态) 得到,那么它可能不应该在 state(状态) 中。

      状态提升:子组件要渲染的数据不定义在自身 state 中,而是定义在最近的公共父组件中。该数据由父组件通过 props 传递给子组件。当子组件发生改变时,触发父组件的 onChange() 方法,父组件更改 state ,引起子组件数据改变,从而达到A子组件数据变化时B子组件数据跟着变化的效果。)

    组合 VS 继承(Composition vs Inheritance)

    1. 如果要在组件之间重用非 U I功能,我们建议将其提取到单独的 JavaScript 模块中。组件可以导入它并使用该函数,对象或类,而不扩展它。

    React 的编程思想

    1. 如何拆分组件呢?

      其实只需要像拆分一个新方法或新对象一样的方式即可。一个常用的技巧是 单一职责原则 ,即一个组件理想情况下只处理一件事。如果一个组件持续膨胀,就应该将其拆分为多个更小的组件中。


    写在最后:强烈建议自己读一遍 React中文文档 (有些翻译错误,不影响阅读,有能力可以去读原版。 O(∩_∩)O哈哈~)

    展开全文
  • React中文文档之Thinking in React

    千次阅读 2016-11-17 23:19:30
    Thinking in React - 思考React 在我们看来,React是使用js来创建大的、速度快的web应用的...在这个文档中,我们将带领你穿越,使用React来构建搜索产品数据表的整个思维过程 Start With A Mock - 以一个模拟开
    Thinking in React - 思考React
    在我们看来,React是使用js来创建大的、速度快的web应用的首选方式。它已经在Facebook和Instagram表现的非常好。
    React众多伟大部分之一是:创建应用时,它是如何让你思考的。在这个文档中,我们将带领你穿越,使用React来构建搜索产品数据表的整个思维过程


    Start With A Mock - 以一个模拟开始
    想象一下,我们已经有一个JSON API和来自我们设计师的一个模拟。我们的设计显然不是很好,因为模拟看起来就像下面这样:

    我们的JSON API返回一些数据,如下:
    		[
    		  	{category: "Sporting Goods", price: "$49.99", stocked: true, name: "Football"},
    		  	{category: "Sporting Goods", price: "$9.99", stocked: true, name: "Baseball"},
    		  	{category: "Sporting Goods", price: "$29.99", stocked: false, name: "Basketball"},
    		  	{category: "Electronics", price: "$99.99", stocked: true, name: "iPod Touch"},
    		  	{category: "Electronics", price: "$399.99", stocked: false, name: "iPhone 5"},
    		  	{category: "Electronics", price: "$199.99", stocked: true, name: "Nexus 7"}
    		];
    

    Step 1: Break The UI Into A Component Hierarchy - 第一步:打破UI,成为一个组件层次结构
    你将做的第一件事情是,在模拟环境下给每个组件(和子组件)周围画上方框,并给定它们名称。如果你正在和一个设计师合作,他们可能已经做了这个,因此去和他们交流!他们的PS的图层名可能就是你的React组件名称。
    但是你怎么知道哪些应该是组件?当你决定创建一个新函数或对象(创建组件的2种方式:函数和对象)时,就参考下面这些相同的技巧。技巧之一是:单一职责原则,这就是,一个组件原则上制作一件事。如果它逐渐扩展了,就应该被拆分为更细的组件。
    由于我们经常展示一个JSON数据模型给用户,你将发现:如果你的模型被正确地建立,你的UI(也就是组件结构)也将很好的映射。这是因为UI和数据模型倾向于支持同样的信息架构,这意味着拆分UI为组件的工作总是琐碎的。我们要做的就是:将UI拆分成准确代表部分数据模型的一个个组件。

    这里你将看到,在我们简单的应用中有5个组件,我们用斜体表示代表组件的数据。
    1.FilterableProductTable(橙色):包含整个示例
    2.SearchBar(蓝色):接收所有的用户输入
    3.ProductTable(绿色):基于用户输入,展示和过滤数据集合
    4.ProductCategoryRow(青绿色):展示每个分类头
    5.ProductRow(红色):展示每个产品的详情
    如果你在看 'ProductTable' 组件,你将发现表头(包含 'Name' 和 'Price' 标签)不是它自己的组件。这是一个偏好问题,关于是否这样使用存在争论。针对这个例子,我们留下它作为 'ProductTable' 组件的一部分,因为它是渲染 'data' 集合的一部分,是 'ProductTable' 组件的职责(之前说过:组件单一职责原则)。然而,如果这个表头变的复杂(例如:如果我们增加了字段排序功能),制作一个 'ProductTableHeader' 组件可能更有意义。
    现在,我们已经在模拟环境中确定了我们的组件,让我们将它们排列成一个层级结构:
    		FilterableProductTable
    			SearchBar
    			ProductTable
    				ProductCategoryRow
    				ProductRow

    Step 2: Build A Static Version in React - 第二步:在React中构建一个静态版本
    class ProductCategoryRow extends React.Component {
      render() {
        return <tr><th colSpan="2">{this.props.category}</th></tr>;
      }
    }
    
    class ProductRow extends React.Component {
      render() {
        var name = this.props.product.stocked ?
          this.props.product.name :
          <span style={{color: 'red'}}>
            {this.props.product.name}
          </span>;
        return (
          <tr>
            <td>{name}</td>
            <td>{this.props.product.price}</td>
          </tr>
        );
      }
    }
    
    class ProductTable extends React.Component {
      render() {
        var rows = [];
        var lastCategory = null;
        this.props.products.forEach(function(product) {
          if (product.category !== lastCategory) {
            rows.push(<ProductCategoryRow category={product.category} key={product.category} />);
          }
          rows.push(<ProductRow product={product} key={product.name} />);
          lastCategory = product.category;
        });
        return (
          <table>
            <thead>
              <tr>
                <th>Name</th>
                <th>Price</th>
              </tr>
            </thead>
            <tbody>{rows}</tbody>
          </table>
        );
      }
    }
    
    class SearchBar extends React.Component {
      render() {
        return (
          <form>
            <input type="text" placeholder="Search..." />
            <p>
              <input type="checkbox" />
              {' '}
              Only show products in stock
            </p>
          </form>
        );
      }
    }
    
    class FilterableProductTable extends React.Component {
      render() {
        return (
          <div>
            <SearchBar />
            <ProductTable products={this.props.products} />
          </div>
        );
      }
    }
    
    
    var PRODUCTS = [
      {category: 'Sporting Goods', price: '$49.99', stocked: true, name: 'Football'},
      {category: 'Sporting Goods', price: '$9.99', stocked: true, name: 'Baseball'},
      {category: 'Sporting Goods', price: '$29.99', stocked: false, name: 'Basketball'},
      {category: 'Electronics', price: '$99.99', stocked: true, name: 'iPod Touch'},
      {category: 'Electronics', price: '$399.99', stocked: false, name: 'iPhone 5'},
      {category: 'Electronics', price: '$199.99', stocked: true, name: 'Nexus 7'}
    ];
     
    ReactDOM.render(
      <FilterableProductTable products={PRODUCTS} />,
      document.getElementById('container')
    );

    现在,你已经有了你的组件层级结构,是时候实现你的应用了。建立一个版本的最简单的方式是:定义数据模型和渲染UI,但是它们之间没有任何交互。最好解耦这些过程,因为构建一个静态版本需要大量的键入,而且不用思考;而添加交互则需要大量思考,并不需要很多的键入。我们会看到这是为什么。
    为了构建你应用的一个静态版本,来渲染你的数据模型,你想要构建组件,这些组件重用其他组件,并通过 'props' 来传递数据。'props' 是从父传递给子数据的一种方式。如果你熟悉 'state' 概念,构建静态版本时,千万不要使用 'state'!'state' 仅用于交互,也就是,数据随着时间改变。由于这是一个静态版本,你不需要 'state'。
    你可以自上而下,或自下而上构建静态版本。就是说,你可以从层级结构的顶层开始构建组件(FilterableProductTable),也可以从层级结构的底层开始构建组件(ProductRow)。在更简单的例子中,通常自上而下建立更简单,在大的项目中,自下而上建立则更简单一点。
    在这个步骤的最后,你将有一个可重用的组件库,用来渲染你的数据模型。这些组件仅有 'render()' 方法,因为这是你应用的一个静态版本。在层级结构顶层的组件(FilterableProductTable)将你的数据模型,定义为 'props' 属性。如果你修改了数据模型,并再次调用了 'ReactDOM.render()',UI将被更新。查看UI如何更新,以及哪些地方进行了修改,是很简单的。因为没有什么复杂的东西。React的 'one-way data flow'(也称作 'one-way binding'),使得一切都模块化,并且运行的最快。
    一个小插曲:
    在React中,有2种数据模型:'props' 和 'state'。理解2者的不同很关键;如果不确定2者的不同,可查看之前文档中的解释。

    Step 3: Identify The Minimal (but complete) Representation Of UI State - 第三步:确定表示UI状态的最小(但是完整的)集合
    为了使你的用户界面交互,你需要能够触发对你的底层数据模型的修改。React使用 'state' 让这个变的很容易。
    为了正确构建应用程序,首先你需要考虑应用需要的可变的 'state' 状态的最小集合。关键是 'DRY':Don't Repeat Yourself(不要重复)。找出你应用所需的状态的绝对的最小集合,并计算所有你需要的东西。例如,你正在构建一个 'TODO' 列表,那就仅定义一个 'TODO' 列表条目的数组;不要为计数定义一个单独的 'state' 变量。替代的,当你想渲染 'TODO' 个数时,直接使用 'TODO' 数组的长度。
    考虑我们示例应用的所有数据。我们有:
    1.产品的原始列表
    2.用户已经输入的搜索内容
    3.多选框的值
    4.产品的筛选列表
    让我们依次讨论,找出哪个应该被定义为 'state'。简单地问3个问题,关于每个数据:
    1.它是否通过父组件的 'props' 传递?如果是,它可能不应该被定义为 'state'。
    2.它是否随着时间保持不变?如果是,它可能不应该被定义为 'state'。
    3.在你的组件中,它能不能基于其他 'state' 或 'props' 来计算?如果是,它可能不应该被定义为 'state'。
    产品的原始列表,作为一个 'props' 被传入,因此不是 'state'。搜索内容和多选框,貌似可被定义为 'state',因为它们随着时间改变,并且不能通过其他一切来计算。最后,产品的筛选列表不是 'state',因为:它可以通过原始的产品列表和搜索文本或多选框的值,来计算。
    因此最终,我们的 'state' 是:
    1.用户已经输入的搜索内容
    2.多选框的值


    Step 4: Identify Where Your State Should Live - 第四步:识别 'state' 应该位于哪里
    class ProductCategoryRow extends React.Component {
      render() {
        return (<tr><th colSpan="2">{this.props.category}</th></tr>);
      }
    }
    
    class ProductRow extends React.Component {
      render() {
        var name = this.props.product.stocked ?
          this.props.product.name :
          <span style={{color: 'red'}}>
            {this.props.product.name}
          </span>;
        return (
          <tr>
            <td>{name}</td>
            <td>{this.props.product.price}</td>
          </tr>
        );
      }
    }
    
    class ProductTable extends React.Component {
      render() {
        var rows = [];
        var lastCategory = null;
        this.props.products.forEach((product) => {
          if (product.name.indexOf(this.props.filterText) === -1 || (!product.stocked && this.props.inStockOnly)) {
            return;
          }
          if (product.category !== lastCategory) {
            rows.push(<ProductCategoryRow category={product.category} key={product.category} />);
          }
          rows.push(<ProductRow product={product} key={product.name} />);
          lastCategory = product.category;
        });
        return (
          <table>
            <thead>
              <tr>
                <th>Name</th>
                <th>Price</th>
              </tr>
            </thead>
            <tbody>{rows}</tbody>
          </table>
        );
      }
    }
    
    class SearchBar extends React.Component {
      render() {
        return (
          <form>
            <input type="text" placeholder="Search..." value={this.props.filterText} />
            <p>
              <input type="checkbox" checked={this.props.inStockOnly} />
              {' '}
              Only show products in stock
            </p>
          </form>
        );
      }
    }
    
    class FilterableProductTable extends React.Component {
      constructor(props) {
        super(props);
        this.state = {
          filterText: '',
          inStockOnly: false
        };
      }
    
      render() {
        return (
          <div>
            <SearchBar
              filterText={this.state.filterText}
              inStockOnly={this.state.inStockOnly}
            />
            <ProductTable
              products={this.props.products}
              filterText={this.state.filterText}
              inStockOnly={this.state.inStockOnly}
            />
          </div>
        );
      }
    }
    
    
    var PRODUCTS = [
      {category: 'Sporting Goods', price: '$49.99', stocked: true, name: 'Football'},
      {category: 'Sporting Goods', price: '$9.99', stocked: true, name: 'Baseball'},
      {category: 'Sporting Goods', price: '$29.99', stocked: false, name: 'Basketball'},
      {category: 'Electronics', price: '$99.99', stocked: true, name: 'iPod Touch'},
      {category: 'Electronics', price: '$399.99', stocked: false, name: 'iPhone 5'},
      {category: 'Electronics', price: '$199.99', stocked: true, name: 'Nexus 7'}
    ];
    
    ReactDOM.render(
      <FilterableProductTable products={PRODUCTS} />,
      document.getElementById('container')
    );
    


    我们已经定义了应用 'state' 的最小集合。接下来,我们需要定义,哪些组件使这些状态改变(哪些组件拥有这些 'state',也就是 'state' 定义在哪个组件内)。
    记住:React中,数据是随着组件层级结构自上而下的单向数据流。可能不会马上明确哪个组件应该拥有哪些 'state'。这往往是新手理解中最具挑战性的一部分,因此通过下面的步骤来弄明白它:
    1.对于应用程序的每个 'state':
    1>识别基于 'state' 的每个组件(哪些组件需要state)
    2>寻找一个拥有这些 'state' 的公共组件(层级结构中,所有需要 'state' 的组件的一个公共父组件)
    3>公共组件或在层级结构上,更高层次上的另一个组件,应该拥有 'state'
    4>如果你不能找到一个组件,拥有这个 'state',创建一个新组件仅仅为了拥有这个 'state',并且将这个新组件添加到公共组件的上层。
    2.让我们针对我们的应用来使用这个策略:
    1>'ProductTable' 需要基于 'state' 来过滤产品列表,'SearchBar' 需要基于 'state' 来展示 '搜索文本state' 和 '多选框state' 
    2>拥有这些 'state' 的公共组件是 'FilterableProductTable'
    3>概念上,'过滤文本' 和 '多选框值' 这2个 'state' 位于 'FilterableProductTable' 组件上,是有意义的。
    我们已经决定我们的state位于 'FilterableProductTable' 组件。首先,添加一个属性:this.state = {filterText: '', inStockOnly: false} 到 'FilterableProductTable' 的 'constructor' 方法,表示应用的初始化 'state'。接着,传递 'filterText' 和 'inStockOnly' 给 'ProductTable' 和 'SearchBar' 组件,作为它们的属性。最后,使用这些属性,在 'ProductTable' 来过滤行,以及在 'SearchBar' 中设置表单字段的值。
    你可以看到你的应用将如何工作:设置 'filterText' 为 'ball',并刷新你的应用。你将看到数据表正确的更新了。


    Step 5: Add Inverse Data Flow - 第五步:添加一个反向数据流
    class ProductCategoryRow extends React.Component {
      render() {
        return (<tr><th colSpan="2">{this.props.category}</th></tr>);
      }
    }
    
    class ProductRow extends React.Component {
      render() {
        var name = this.props.product.stocked ?
          this.props.product.name :
          <span style={{color: 'red'}}>
            {this.props.product.name}
          </span>;
        return (
          <tr>
            <td>{name}</td>
            <td>{this.props.product.price}</td>
          </tr>
        );
      }
    }
    
    class ProductTable extends React.Component {
      render() {
        var rows = [];
        var lastCategory = null;
        this.props.products.forEach((product) => {
          if (product.name.indexOf(this.props.filterText) === -1 || (!product.stocked && this.props.inStockOnly)) {
            return;
          }
          if (product.category !== lastCategory) {
            rows.push(<ProductCategoryRow category={product.category} key={product.category} />);
          }
          rows.push(<ProductRow product={product} key={product.name} />);
          lastCategory = product.category;
        });
        return (
          <table>
            <thead>
              <tr>
                <th>Name</th>
                <th>Price</th>
              </tr>
            </thead>
            <tbody>{rows}</tbody>
          </table>
        );
      }
    }
    
    class SearchBar extends React.Component {
      constructor(props) {
        super(props);
        this.handleChange = this.handleChange.bind(this);
      }
      
      handleChange() {
        this.props.onUserInput(
          this.refs.filterTextInput.value,
          this.refs.inStockOnlyInput.checked
        );
      }
      
      render() {
        return (
          <form>
            <input
              type="text"
              placeholder="Search..."
              value={this.props.filterText}
              ref="filterTextInput"
              onChange={this.handleChange}
            />
            <p>
              <input
                type="checkbox"
                checked={this.props.inStockOnly}
                ref="inStockOnlyInput"
                onChange={this.handleChange}
              />
              {' '}
              Only show products in stock
            </p>
          </form>
        );
      }
    }
    
    class FilterableProductTable extends React.Component {
      constructor(props) {
        super(props);
        this.state = {
          filterText: '',
          inStockOnly: false
        };
        
        this.handleUserInput = this.handleUserInput.bind(this);
      }
    
      handleUserInput(filterText, inStockOnly) {
        this.setState({
          filterText: filterText,
          inStockOnly: inStockOnly
        });
      }
    
      render() {
        return (
          <div>
            <SearchBar
              filterText={this.state.filterText}
              inStockOnly={this.state.inStockOnly}
              onUserInput={this.handleUserInput}
            />
            <ProductTable
              products={this.props.products}
              filterText={this.state.filterText}
              inStockOnly={this.state.inStockOnly}
            />
          </div>
        );
      }
    }
    
    
    var PRODUCTS = [
      {category: 'Sporting Goods', price: '$49.99', stocked: true, name: 'Football'},
      {category: 'Sporting Goods', price: '$9.99', stocked: true, name: 'Baseball'},
      {category: 'Sporting Goods', price: '$29.99', stocked: false, name: 'Basketball'},
      {category: 'Electronics', price: '$99.99', stocked: true, name: 'iPod Touch'},
      {category: 'Electronics', price: '$399.99', stocked: false, name: 'iPhone 5'},
      {category: 'Electronics', price: '$199.99', stocked: true, name: 'Nexus 7'}
    ];
    
    ReactDOM.render(
      <FilterableProductTable products={PRODUCTS} />,
      document.getElementById('container')
    );

    到目前为止,我们已经创建了一个应用,。现在是时候以另一种方式支持数据流:在层级结构中的深层表单组件,需要在 'FilterableProductTable' 中更新 'state'。
    React的数据流很明确,使得理解你的应用程序是如何工作的变的很容易,但相比于传统的双向数据绑定,它确实需要输入更多。
    在示例中的当前版本中,如果你尝试输入或者勾选多选框,你将看到React会忽略你的输入。这是故意的,因为我们输入的值,总是等于从 'FilterableProductTable' 传入的 'state' 值。
    让我们思考我们想要发生什么。我们想要确保:每当用户更改了表单,我们更新 'state' 来反映用户输入。因为组件仅应该更新它们自己的 'state', 'FilterableProductTable' 将传递一个回调函数给 'SearchBarla',来触发 'state' 更新。我们可以在表单元素上,使用 'onChange' 事件来通知它。通过 'FilterableProductTable' 传递的回调,将调用 'setState()' 方法,应用将被更新。
    虽然这听起来很复杂,但它确实只是几行代码。而且贯穿整个应用中,你的数据是如何流动,是很明确的。


    And That's It - 这就是它
    希望,通过这篇教程让你知道,使用React如何来创建组件和应用。虽然相比于你之前使用过的其他类库,React可能需要写更多,但是记住:代码的阅读远比书写更重要,并且阅读通过React创建的模块化、清晰的代码是极其容易的。当你开始建立大型的组件库时,你将会欣赏这个明确化和模块化,重用性代码,你的代码行将减少!
    展开全文
  • 现在还没去看懂的有 context HOC 集成JQ等dom操作库,这个之前确实没玩过 render prop

    现在还没去看懂的有

    context

    HOC

    集成JQ等dom操作库,这个之前确实没玩过

    render prop

     

    展开全文
  • React中文文档之Forms

    2016-11-17 23:07:55
    Forms - 表单 在React中,HTML表单元素同其他DOM元素,有点不同。因为表单元素天生具备一些内部的...在React中,如果你想要这种行为,它默认就起作用。但是大多数情况,使用js函数来处理表单的提交,以及对用户输入的
  • 元素是React应用的最小构建块 一个元素描述了你想要在屏幕上看到的内容: const element = Hello, world; 不同于浏览器的DOM元素,React元素是普通对象,而且易于创建。React DOM很小心将React元素更新为匹配的DOM...
  • React元素的事件处理同DOM元素的事件处理非常相似。 有一些语法不同: 1.React事件使用 'camelCase-驼峰式' 命名,而不是 'lowercase-小写字母' 2.使用JSX,传递一个函数作为事件处理,而不是字符串 例如: HTML代码...
  • React中,你可以创建唯一的组件,来封装你需要的行为。之后,你可以仅仅渲染它们中的一些,这取决于你应用的状态。 React中的有条件的渲染,同JS中有条件的渲染的工作方式相同。使用JS操作符,例如:if 或者 '...
  • introducing JSX 思考下面的变量声明: ...在React中,我们推荐使用它来描述UI应该是什么样子。JSX可能看着像一个模板语言,但是它具有js的所有能力。 JSX产生 React元素。在下一章节,我们将探讨将它们渲染为D
  • class Reservation extends React.Component { constructor(props) { super(props); this.state = { isGoing: true, numberOfGuests: 2, val...
  • 开关按钮制作 ...import React from 'react'; import ReactDOM from 'react-dom'; class Toggle extends React.Component { constructor(props) { super(props); this.state = {isToggle...
  • import React from 'react'; import ReactDOM from 'react-dom'; function formatDate(date) { return date.toLocaleDateString(); } const comment = { date: new Date(), text: ...
  • 1.函数试组件 import React from 'react'; import ReactDOM from 'react-dom'; function Clock(props){ return( <div> <h1>Hello, world!</h1> ...
  • import React from 'react'; import ReactDOM from 'react-dom'; class LoginControl extends React.Component { constructor(props) { super(props); this.handleLoginClick = t...
  • 开始React的最简单的方式是使用 '在 CodePen 的 hello world 实例代码'。你不需要安装任何东西;你仅仅需要在另一个页签打开它,并跟随我们的示例。如果你更想使用一个本地的开发环境,查看安装小节。 最小的React...
  • React有一个强大的组合模型,并且我们推荐使用组合来代替继承,在组件间重复使用代码。 在这一章节,我们将考虑React新手开发者经常碰到的几个关于继承的问题,并展示我们如何使用组合来解决这些问题。 ...
  • 它们接收任意的输入(被称为 'props'),并返回React元素,用以描述应该在屏幕上显示的内容。 Functional and Class Components - 函数式组件和类组件 定义一个组件的最简单方式是写一个js函数:
  • class Welcome extends React.Component { render() { return <h1>Hello, {this.props.name}; } } function Welcome(props) { return <h1>Hello, {props.name}; } const element = ; ReactDOM.render( ...
  • TemperatureInput extends React.Component { constructor(props) { super(props); this .handleChange = this .handleChange.bind( this ); } handleChange(e) { this .props.onTemperatureChange(e....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 988
精华内容 395
关键字:

react中文文档