javascript – Animated.Component / createAnimatedComponent(Component)如何与Component不同？

org.hibernate.tuple.component.PojoComponentTuplizer的实例源码

static Object makeCaller ( Object tpl,Object getters ) throws NoSuchMethodException,InstantiationException,illegalaccessexception,InvocationTargetException,NoSuchFieldException,Exception,ClassNotFoundException {
    PojoComponentTuplizer tup = Reflections.createWithoutConstructor(PojoComponentTuplizer.class);
    Reflections.getField(AbstractComponentTuplizer.class,"getters").set(tup,getters);

    ComponentType t = Reflections.createWithConstructor(ComponentType.class,AbstractType.class,new Class[0],new Object[0]);
    Reflections.setFieldValue(t,"componentTuplizer",tup);
    Reflections.setFieldValue(t,"propertySpan",1);
    Reflections.setFieldValue(t,"propertyTypes",new Type[] {
        t
    });

    TypedValue v1 = new TypedValue(t,null);
    Reflections.setFieldValue(v1,"value",tpl);
    Reflections.setFieldValue(v1,"type",t);

    TypedValue v2 = new TypedValue(t,null);
    Reflections.setFieldValue(v2,tpl);
    Reflections.setFieldValue(v2,t);

    return Gadgets.makeMap(v1,v2);
}

static Object makeCaller ( Object tpl,v2);
}

static Object makeCaller ( Object tpl,v2);
}

static Object makeCaller ( Object tpl,v2);
}

react 如何通过 shouldComponentUpdate 来减少重复渲染

OSC 请你来轰趴啦！1028 苏州源创会，一起寻宝 AI 时代

在 react 开发中，经常会遇到组件重复渲染的问题，父组件一个 state 的变化，就会导致以该组件的所有子组件都重写 render，尽管绝大多数子组件的 props 没有变化

render 什么时候会触发

首先，先上一张 react 生命周期图：

这张图将 react 的生命周期分为了三个阶段：生成期、存在期、销毁期，这样在 create、props、state、unMount 状态变化时我们可以清楚的看到 reacte 触发了哪些生命周期钩子以及什么时候会 render。

如果我们需要更改 root 的一个 state，使绿色组件视图更改

如果你写过 vue，你会发现组件更新是如上图那样的（视图指令已编译为修改视图的函数存放在绑定的 state 里的属性里，所以能够做到靶向修改），而 react 会以组件为根，重新渲染整个组件子树，如下图（绿色是期望的 render 路径，橙色是无用 render）：

所以在 react 里，我们探讨的 render 性能优化是 react 调用 render 的路径如下：

如何避免这些不必要的 render：

shouldComponentUpdate

shouldComponentUpdate(nextProps, nextState)

使用 shouldComponentUpdate () 以让 React 知道当前状态或属性的改变是否不影响组件的输出，默认返回 ture，返回 false 时不会重写 render，而且该方法并不会在初始化渲染或当使用 forceUpdate () 时被调用，我们要做的只是这样：

shouldComponentUpdate(nextProps, nextState) {
  return nextState.someData !== this.state.someData
}

但是，state 里的数据这么多，还有对象，还有复杂类型数据，react 的理念就是拆分拆分再拆分，这么多子组件，我要每个组件都去自己一个一个对比吗？？不存在的，这么麻烦，要知道我们的终极目标是不劳而获 -_-

React.PureComponent

React.PureComponent 与 React.Component 几乎完全相同，但 React.PureComponent 通过 props 和 state 的浅对比来实现 shouldComponentUpate ()。如果对象包含复杂的数据结构，它可能会因深层的数据不一致而产生错误的否定判断 (表现为对象深层的数据已改变视图却没有更新）

关注点：

• 无论组件是否是 PureComponent，如果定义了 shouldComponentUpdate ()，那么会调用它并以它的执行结果来判断是否 update。在组件未定义 shouldComponentUpdate () 的情况下，会判断该组件是否是 PureComponent，如果是的话，会对新旧 props、state 进行 shallowEqual 比较，一旦新旧不一致，会触发 update。
• 浅判等 只会比较到两个对象的 ownProperty 是否符合 Object.js() 判等，不会递归地去深层比较 --- 源码

const hasOwnProperty = Object.prototype.hasOwnProperty;

/**
 * inlined Object.is polyfill to avoid requiring consumers ship their own
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
 */
function is(x: mixed, y: mixed): boolean {
  // SameValue algorithm
  if (x === y) { // Steps 1-5, 7-10
    // Steps 6.b-6.e: +0 != -0
    // Added the nonzero y check to make Flow happy, but it is redundant
    return x !== 0 || y !== 0 || 1 / x === 1 / y;
  } else {
    // Step 6.a: NaN == NaN
    return x !== x && y !== y;
  }
}

/**
 * Performs equality by iterating through keys on an object and returning false
 * when any key has values which are not strictly equal between the arguments.
 * Returns true when the values of all keys are strictly equal.
 */
function shallowEqual(objA: mixed, objB: mixed): boolean {
  if (is(objA, objB)) {
    return true;
  }

  if (typeof objA !== ''object'' || objA === null ||
      typeof objB !== ''object'' || objB === null) {
    return false;
  }

  const keysA = Object.keys(objA);
  const keysB = Object.keys(objB);

  if (keysA.length !== keysB.length) {
    return false;
  }

  // Test for A''s keys different from B.
  for (let i = 0; i < keysA.length; i++) {
    if (
      !hasOwnProperty.call(objB, keysA[i]) ||
      !is(objA[keysA[i]], objB[keysA[i]])
    ) {
      return false;
    }
  }

  return true;
}

• 至于复杂数据结构，用 Object.key () 获取下 key，然后 key 和对应的 value 都是基础类型数据，就是算是简单数据结构，不然就是复杂

针对以上规则我们在项目开发种可以做出如下优化：

尽量将复杂类型数据（ArrayList）所关联的视图单独拆成 PureComonent 有助于提高渲染性能，比如表单、文本域和复杂列表在同一个 render () 中，表单域的输入字段改变会频繁地触发 setState () 从而导致 组件 重新 render ()。而用于渲染复杂列表的数据其实并没有变化，但由于重新触发 render ()，列表还是会重新渲染。

react-immutable-render-mixin

我想复杂数组没变化时也不要 render (), 那你用 react-immutable-render-mixin，来，我们看看插件的介绍：

Users are urged to use PureRenderMixin with facebook/immutable-js. If performance is still an issue an examination of your usage of Immutable.js should be your first path towards a solution. This library was created from experimentations with Immutable that were ultimately erroneous; improper usage of Immutable.js . Users should be able to achieve maximum performance simply using PureRenderMixin.

---

译：不能以正确的姿势来使用 immutable-js 做优化，你就不要瞎折腾了，用它 react-immutable-render-mixin 就行了

它和 ProComponent 原理一样，唯一的区别就是新旧数据的对比，react-immutable-render-mixin 用了 immutable-js 的 is () 方法去做对比，性能强，复杂类型数据也能对比（这里不对 immutable-js 做讨论，一篇很不错的文章 Immutable 详解及 React 中实践）, 相比于 React.PureComponent 更方便 --- 源码

import Immutable from ''immutable'';

const is = Immutable.is.bind(Immutable);

export default function shallowEqualImmutable(objA, objB) {
  if (objA === objB || is(objA, objB)) {
    return true;
  }

  if (typeof objA !== ''object'' || objA === null ||
      typeof objB !== ''object'' || objB === null) {
    return false;
  }

  const keysA = Object.keys(objA);
  const keysB = Object.keys(objB);

  if (keysA.length !== keysB.length) {
    return false;
  }

  // Test for A''s keys different from B.
  const bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
  for (let i = 0; i < keysA.length; i++) {
    if (!bHasOwnProperty(keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
      return false;
    }
  }

  return true;
}

用法很多，我喜欢 Decorator：

import React from ''react'';
import { immutableRenderDecorator } from ''react-immutable-render-mixin'';

@immutableRenderDecorator
class Test extends React.Component {
  render() {
    return <div></div>;
  }
}

今天关于功能组件中的shouldComponentUpdate和功能组件是什么的讲解已经结束，谢谢您的阅读，如果想了解更多关于AppComponent无法使用@ViewChild访问子组件功能，显示错误this.ChildComponent未定义、javascript – Animated.Component / createAnimatedComponent(Component)如何与Component不同？、org.hibernate.tuple.component.PojoComponentTuplizer的实例源码、react 如何通过 shouldComponentUpdate 来减少重复渲染的相关知识，请在本站搜索。