javascript - React中箭头函数的正确使用

Question

我将 ReactJS 与 Babel 和 Webpack 一起使用，并使用 ES6 以及 proposed class fields对于箭头函数。我知道箭头函数使事情更有效率 not recreating the functions each render类似于构造函数中绑定(bind)的工作方式。但是，我不能 100% 确定我是否正确使用了它们。以下是我在三个不同文件中的代码的简化部分。

我的代码:

主要.js

prevItem = () => {
    console.log("Div is clicked")
}

render(){
    return (
         <SecondClass prevItem={this.prevItem} />
    )
}

SecondClass.js

<ThirdClass type="prev" onClick={()=>this.props.prevItem()} />

ThirdClass.js

<div onClick={()=>{this.props.onClick()}}>Previous</div>

问题:

我上面的代码是否正确使用了箭头功能？我注意到对于 SecondClass.js 我也可以使用:

<ThirdClass type="prev" onClick={this.props.prevItem} />

由于我在原始函数定义中使用了 ES6 箭头函数，因此一种方法或另一种方法之间有区别吗？还是我应该一直使用箭头语法直到最后一个 div？

Answer 1

I understand that arrow functions make things more efficient by not recreating the functions each time they are referred to

This is not true .

箭头函数以词法方式处理 this 上下文，其中“普通”函数执行此操作 dynamically .我写了关于 the this key word in depth如果您需要更多相关信息。

在您的两个内联箭头函数示例中，您都在每个render 上创建了一个新的函数实例。
这将在每个渲染器上创建并传递一个新实例

onClick={() => {}}

在第 3 个示例中，您只有一个实例。
这仅传递对已存在实例的引用

onClick={this.myHandler}

---

至于箭头函数作为类字段的好处(有一个 小缺点，我会在答案的底部发布)，如果你有一个需要访问当前的普通函数处理程序 类的实例通过 this:

myHandler(){
  //  this.setState(...)
}

您需要将其显式绑定(bind)到类。
最常见的方法是在 constructor 中执行它，因为它只运行一次:

constructor(props){
  super(props);
  this.myHandler = this.myHandler.bind(this);
}

如果您使用箭头函数作为处理程序，则不需要将其绑定(bind)到类，因为如上所述，箭头函数使用词法this 的上下文:

myHandler = () => {
  //  this.setState(...)
}

对于这两种方法，您将使用这样的处理程序:

<div onClick={this.myHandler}></div> 

采用这种方法的主要原因:

<div onClick={() => this.myHandler(someParameter)}></div>

如果您想将参数传递给已传递的 native event 旁边的处理程序，这意味着您想要向上传递一个参数。

如前所述，这将在每个渲染器上创建一个新的函数实例。
(对此有更好的方法，请继续阅读)。

此类用例的运行示例:

class App extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      items: [{ name: 'item 1', active: false }, { name: 'item 2', active: true }],
    }
  }
  toggleITem = (itemName) => {
    this.setState(prev => {
      const nextState = prev.items.map(item => {
        if (item.name !== itemName) return item;
        return {
          ...item,
          active: !item.active
        }
      });
      return { items: nextState };
    });
  }
  render() {
    const { items } = this.state;
    return (
      <div>
        {
          items.map(item => {
            const style = { color: item.active ? 'green' : 'red' };
            return (
              <div
                onClick={() => this.toggleITem(item.name)}
                style={style}
              >
                {item.name}
              </div>
          
          )})
        }
      </div>
    );
  }
}

ReactDOM.render(<App />, document.getElementById('root'));

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

更好的方法是创建组件组合。
您可以创建一个包装相关标记的子组件，将拥有自己的处理程序，并将 data 和 handler 作为来自父级的 Prop 。

然后，子组件将调用它从父组件获得的处理程序，并将 data 作为参数传递。

带子组件的运行示例:

class Item extends React.Component {
  onClick = () => {
    const { onClick, name } = this.props;
    onClick(name);
  }
  render() {
    const { name, active } = this.props;
    const style = { color: active ? 'green' : 'red' };
    return (<div style={style} onClick={this.onClick}>{name}</div>)
  }
}

class App extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      items: [{ name: 'item 1', active: false }, { name: 'item 2', active: true }],
    }
  }
  toggleITem = (itemName) => {
    this.setState(prev => {
      const nextState = prev.items.map(item => {
        if (item.name !== itemName) return item;
        return {
          ...item,
          active: !item.active
        }
      });
      return { items: nextState };
    });
  }
  render() {
    const { items } = this.state;
    return (
      <div>
        {
          items.map(item => {
            return <Item {...item} onClick={this.toggleITem} />
          })
        }
      </div>
    );
  }
}

ReactDOM.render(<App />, document.getElementById('root'));

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

类字段的缺点:
正如我提到的，类字段有一个小缺点。
类方法和类字段的区别在于，类字段附加到类(构造函数)的实例。
其中类方法和对象附加到原型(prototype)。

因此，如果您拥有大量此类实例，您可能会受到性能影响。

给定这个代码块:

class MyClass {
  myMethod(){}  
  myOtherMethod = () => {}
}

babel 会将其转译为:

var _createClass = function() {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }
  return function(Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

var MyClass = function() {
  function MyClass() {
    _classCallCheck(this, MyClass);

    this.myOtherMethod = function() {};
  }

  _createClass(MyClass, [{
    key: "myMethod",
    value: function myMethod() {}
  }]);

  return MyClass;
}();