Was sind React-Komponenten höherer Ordnung? Wie wird eine Breadcrumb-Navigation erstellt?

Was sind React-Komponenten höherer Ordnung? Lassen Sie uns darüber sprechen, wie Sie React-Komponenten höherer Ordnung verwenden, um eine Breadcrumb-Navigation zu erstellen. Ich hoffe, dass dies für alle hilfreich ist!

Was sind React-Komponenten höherer Ordnung?

React-Komponenten höherer Ordnung verpacken die React-Komponenten, die geändert werden müssen, in Form von Funktionen höherer Ordnung und geben die verarbeiteten React-Komponenten zurück. React-Komponenten höherer Ordnung werden im React-Ökosystem sehr häufig verwendet, z. B. withRouter in react-router und connect in <code>react-redux und viele andere APIs werden auf diese Weise implementiert. react-router 中的 withRouter 以及 react-redux 中 connect 等许多 API 都是以这样的方式来实现的。

使用 React 高阶组件的好处

在工作中，我们经常会有很多功能相似，组件代码重复的页面需求，通常我们可以通过完全复制一遍代码的方式实现功能，但是这样页面的维护可维护性就会变得极差，需要对每一个页面里的相同组件去做更改。因此，我们可以将其中共同的部分，比如接受相同的查询操作结果、组件外同一的标签包裹等抽离出来，做一个单独的函数，并传入不同的业务组件作为子组件参数，而这个函数不会修改子组件，只是通过组合的方式将子组件包装在容器组件中，是一个无副作用的纯函数，从而我们能够在不改变这些组件逻辑的情况下将这部分代码解耦，提升代码可维护性。

自己动手实现一个高阶组件

前端项目里，带链接指向的面包屑导航十分常用，但由于面包屑导航需要手动维护一个所有目录路径与目录名映射的数组，而这里所有的数据我们都能从 react-router 的路由表中取得，因此我们可以从这里入手，实现一个面包屑导航的高阶组件。

首先我们看看我们的路由表提供的数据以及目标面包屑组件所需要的数据：

// 这里展示的是 react-router4 的route示例
let routes = [
  {
    breadcrumb: '一级目录',
    path: '/a',
    component: require('../a/index.js').default,
    items: [
      {
        breadcrumb: '二级目录',
        path: '/a/b',
        component: require('../a/b/index.js').default,
        items: [
          {
            breadcrumb: '三级目录1',
            path: '/a/b/c1',
            component: require('../a/b/c1/index.js').default,
            exact: true,
          },
          {
            breadcrumb: '三级目录2',
            path: '/a/b/c2',
            component: require('../a/b/c2/index.js').default,
            exact: true,
          },
      }
    ]
  }
]

// 理想中的面包屑组件
// 展示格式为 a / b / c1 并都附上链接
const BreadcrumbsComponent = ({ breadcrumbs }) => (
  <div>
    {breadcrumbs.map((breadcrumb, index) => (
      <span key={breadcrumb.props.path}>
        <link to={breadcrumb.props.path}>{breadcrumb}</link>
        {index < breadcrumbs.length - 1 && <i> / </i>}
      </span>
    ))}
  </div>
);

这里我们可以看到，面包屑组件需要提供的数据一共有三种，一种是当前页面的路径，一种是面包屑所带的文字，一种是该面包屑的导航链接指向。

其中第一种我们可以通过 react-router 提供的 withRouter 高阶组件包裹，可使子组件获取到当前页面的 location 属性，从而获取页面路径。

后两种需要我们对 routes 进行操作，首先将 routes 提供的数据扁平化成面包屑导航需要的格式，我们可以使用一个函数来实现它。

/**
 * 以递归的方式展平react router数组
 */
const flattenRoutes = arr =>
  arr.reduce(function(prev, item) {
    prev.push(item);
    return prev.concat(
      Array.isArray(item.items) ? flattenRoutes(item.items) : item
    );
  }, []);

之后将展平的目录路径映射与当前页面路径一同放入处理函数，生成面包屑导航结构。

export const getBreadcrumbs = ({ flattenRoutes, location }) => {
  // 初始化匹配数组match
  let matches = [];

  location.pathname
    // 取得路径名，然后将路径分割成每一路由部分.
    .split('?')[0]
    .split('/')
    // 对每一部分执行一次调用`getBreadcrumb()`的reduce.
    .reduce((prev, curSection) => {
      // 将最后一个路由部分与当前部分合并，比如当路径为 `/x/xx/xxx` 时，pathSection分别检查 `/x` `/x/xx` `/x/xx/xxx` 的匹配，并分别生成面包屑
      const pathSection = `${prev}/${curSection}`;
      const breadcrumb = getBreadcrumb({
        flattenRoutes,
        curSection,
        pathSection,
      });

      // 将面包屑导入到matches数组中
      matches.push(breadcrumb);

      // 传递给下一次reduce的路径部分
      return pathSection;
    });
  return matches;
};

然后对于每一个面包屑路径部分，生成目录名称并附上指向对应路由位置的链接属性。

const getBreadcrumb = ({ flattenRoutes, curSection, pathSection }) => {
  const matchRoute = flattenRoutes.find(ele => {
    const { breadcrumb, path } = ele;
    if (!breadcrumb || !path) {
      throw new Error(
        'Router中的每一个route必须包含 `path` 以及 `breadcrumb` 属性'
      );
    }
    // 查找是否有匹配
    // exact 为 react router4 的属性，用于精确匹配路由
    return matchPath(pathSection, { path, exact: true });
  });

  // 返回breadcrumb的值，没有就返回原匹配子路径名
  if (matchRoute) {
    return render({
      content: matchRoute.breadcrumb || curSection,
      path: matchRoute.path,
    });
  }

  // 对于routes表中不存在的路径
  // 根目录默认名称为首页.
  return render({
    content: pathSection === '/' ? '首页' : curSection,
    path: pathSection,
  });
};

之后由 render 函数生成最后的单个面包屑导航样式。单个面包屑组件需要为 render 函数提供该面包屑指向的路径 path, 以及该面包屑内容映射content 这两个 props。

/**
 *
 */
const render = ({ content, path }) => {
  const componentProps = { path };
  if (typeof content === 'function') {
    return <content {...componentProps} />;
  }
  return <span {...componentProps}>{content}</span>;
};

有了这些功能函数，我们就能实现一个能为包裹组件传入当前所在路径以及路由属性的 React 高阶组件了。传入一个组件，返回一个新的相同的组件结构，这样便不会对组件外的任何功能与操作造成破坏。

const BreadcrumbsHoc = (
  location = window.location,
  routes = []
) => Component => {
  const BreadComponent = (
    <Component
      breadcrumbs={getBreadcrumbs({
        flattenRoutes: flattenRoutes(routes),
        location,
      })}
    />
  );
  return BreadComponent;
};
export default BreadcrumbsHoc;

调用这个高阶组件的方法也非常简单，只需要传入当前所在路径以及整个 react router 生成的 routes 属性即可。
至于如何取得当前所在路径，我们可以利用 react router 提供的 withRouter 函数，如何使用请自行查阅相关文档。
值得一提的是，withRouter 本身就是一个高阶组件，能为包裹组件提供包括 location 属性在内的若干路由属性。所以这个 API 也能作为学习高阶组件一个很好的参考。

withRouter(({ location }) =>
  BreadcrumbsHoc(location, routes)(BreadcrumbsComponent)
);

Q&A

• 如果react router 生成的 routes 不是由自己手动维护的，甚至都没有存在本地，而是通过请求拉取到的，存储在 redux 里，通过 react-redux 提供的 connect 高阶函数包裹时，路由发生变化时并不会导致该面包屑组件更新。使用方法如下：

function mapStateToProps(state) {
  return {
    routes: state.routes,
  };
}

connect(mapStateToProps)(
  withRouter(({ location }) =>
    BreadcrumbsHoc(location, routes)(BreadcrumbsComponent)
  )
);

---

这其实是 connect 函数的一个bug。因为 react-redux 的 connect 高阶组件会为传入的参数组件实现 shouldComponentUpdate 这个钩子函数，导致只有 prop 发生变化时才触发更新相关的生命周期函数(含 render)，而很显然，我们的 location 对象并没有作为 prop 传入该参数组件。

官方推荐的做法是使用 withRouter 来包裹 connect 的 return value

Vorteile der Verwendung von React-Komponenten höherer Ordnung🎜🎜🎜Bei der Arbeit haben wir oft viele Seitenanforderungen mit ähnlichen Funktionen und wiederholten Komponentencodes. Normalerweise können wir das Die Funktion wird durch vollständiges Kopieren des Codes implementiert, die Wartbarkeit der Seite wird jedoch extrem schlecht und die gleichen Komponenten auf jeder Seite müssen geändert werden. Daher können wir die gemeinsamen Teile extrahieren, z. B. das Akzeptieren derselben Abfrageoperationsergebnisse, das Umschließen derselben Beschriftung außerhalb der Komponente usw., eine separate Funktion erstellen und verschiedene Geschäftskomponenten als Unterkomponentenparameter und diese Funktion übergeben Die Unterkomponente wird nicht geändert, sondern die Unterkomponente wird durch Kombination in die Containerkomponente eingeschlossen. Es handelt sich um eine reine Funktion ohne Nebenwirkungen, sodass wir diesen Teil des Codes entkoppeln und verbessern können, ohne die Logik dieser Komponenten zu ändern die Wartbarkeit des Codes. 🎜

🎜Implementieren Sie selbst eine höherwertige Komponente🎜🎜🎜In Front-End-Projekten wird die Breadcrumb-Navigation mit Links sehr häufig verwendet, da die Breadcrumb-Navigation jedoch eine manuelle Wartung erfordert of all Ein Array von Zuordnungen zwischen Verzeichnispfaden und Verzeichnisnamen. Alle Daten hier können aus der Routing-Tabelle von react-router abgerufen werden, sodass wir von hier aus mit der Implementierung einer übergeordneten Komponente beginnen können Breadcrumb-Navigation. 🎜🎜Werfen wir zunächst einen Blick auf die von unserer Routing-Tabelle bereitgestellten Daten und die von der Ziel-Breadcrumb-Komponente benötigten Daten: 🎜

withRouter(
  connect(mapStateToProps)(({ location, routes }) =>
    BreadcrumbsHoc(location, routes)(BreadcrumbsComponent)
  )
);

🎜Hier können wir sehen, dass es drei Arten von Daten gibt, die die Breadcrumb-Komponente bereitstellen muss, eine davon der aktuelle Seitenpfad, einer ist der Text, der im Breadcrumb enthalten ist, und der andere ist der Navigationslink des Breadcrumbs. 🎜🎜Zunächst können wir das von React-Router bereitgestellte High-Order-Komponentenpaket withRouter verwenden, das es der Unterkomponente ermöglicht, das Standortattribut der aktuellen Seite und damit den Seitenpfad abzurufen. 🎜🎜Für die beiden letztgenannten müssen wir zunächst die von den Routen bereitgestellten Daten in das für die Breadcrumb-Navigation erforderliche Format reduzieren. 🎜rrreee🎜Fügen Sie dann die abgeflachte Verzeichnispfadzuordnung und den aktuellen Seitenpfad in die Verarbeitungsfunktion ein, um eine Breadcrumb-Navigationsstruktur zu generieren. 🎜rrreee🎜Generieren Sie dann für jeden Breadcrumb-Pfadteil den Verzeichnisnamen und fügen Sie ein Linkattribut hinzu, das auf den entsprechenden Routing-Speicherort verweist. 🎜rrreee🎜Dann generiert die Renderfunktion den endgültigen einzelnen Breadcrumb-Navigationsstil. Eine einzelne Breadcrumb-Komponente muss der Renderfunktion die beiden Requisiten path, auf die der Breadcrumb verweist, und die Breadcrumb-Inhaltszuordnung content bereitstellen. 🎜rrreee🎜Mit diesen Funktionen können wir eine React-Komponente höherer Ordnung implementieren, die den aktuellen Pfad und die Routing-Eigenschaften an die umhüllte Komponente übergeben kann. Übergeben Sie eine Komponente und geben Sie eine neue und identische Komponentenstruktur zurück, sodass keine Funktionen und Vorgänge außerhalb der Komponente beschädigt werden. 🎜rrreee🎜Die Methode zum Aufrufen dieser höherwertigen Komponente ist ebenfalls sehr einfach. Sie müssen nur den aktuellen Pfad und das vom gesamten react router generierte routes-Attribut übergeben .
Um den aktuellen Pfad zu erhalten, können wir die von react router bereitgestellte Funktion withRouter verwenden. Informationen zur Verwendung finden Sie in der entsprechenden Dokumentation.
Es ist erwähnenswert, dass withRouter selbst eine Komponente höherer Ordnung ist, die mehrere Routing-Attribute bereitstellen kann, einschließlich des Attributs location für die umhüllte Komponente. Daher kann diese API auch als gute Referenz zum Erlernen von Komponenten höherer Ordnung verwendet werden. 🎜rrreee

Fragen und Antworten🎜

• 🎜Wenn react router routes generiert code> wird von mir nicht manuell gepflegt, er existiert nicht einmal lokal, sondern wird durch Anfragen gezogen und in Redux über den von <code>react-redux bereitgestellten connect gespeichert > Wann In eine Funktion höherer Ordnung eingebunden, führen Änderungen an der Route nicht dazu, dass die Breadcrumb-Komponente aktualisiert wird. Die Verwendung ist wie folgt: 🎜

rrreee

---

🎜Dies ist tatsächlich ein 🎜Fehler🎜 der Funktion connect. Da die Verbindungskomponente hoher Ordnung von React-Redux die Hook-Funktion ShouldComponentUpdate für die eingehende Parameterkomponente implementiert, werden die aktualisierungsbezogenen Lebenszyklusfunktionen (einschließlich Rendern) nur ausgelöst, wenn sich die Requisite und natürlich unser Standort ändert Das Objekt wird nicht als prop an die Parameterkomponente übergeben. 🎜🎜Der offiziell empfohlene Ansatz besteht darin, withRouter zu verwenden, um den Rückgabewert von connect zu umschließen🎜

withRouter(
  connect(mapStateToProps)(({ location, routes }) =>
    BreadcrumbsHoc(location, routes)(BreadcrumbsComponent)
  )
);

其实我们从这里也可以看出，高阶组件同高阶函数一样，不会对组件的类型造成任何更改，因此高阶组件就如同链式调用一样，可以任意多层包裹来给组件传入不同的属性，在正常情况下也可以随意调换位置，在使用上非常的灵活。这种可插拔特性使得高阶组件非常受React生态的青睐，很多开源库里都能看到这种特性的影子，有空也可以都拿出来分析一下。

Das obige ist der detaillierte Inhalt vonWas sind React-Komponenten höherer Ordnung? Wie wird eine Breadcrumb-Navigation erstellt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!