"Se um trabalhador quiser fazer bem o seu trabalho, ele deve primeiro afiar suas ferramentas." - Confúcio, "Os Analectos de Confúcio. Lu Linggong"
Primeira página > Programação > Implementando Breadcrumbs no React usando React Router v6

Implementando Breadcrumbs no React usando React Router v6

Publicado em 2024-11-06
Navegar:640

Implementing Breadcrumbs in React using React Router v6

Breadcrumbs são importantes no desenvolvimento de páginas da web, pois fornecem aos usuários uma maneira de acompanhar sua localização atual em nossa página da web e também auxiliam na navegação em nossa página da web.

Neste guia, implementaremos breadcrumbs no React usando react-router v6 e Bootstrap.

React-router v6 é uma biblioteca de roteamento usada em React e React Native para navegar em uma página da web ou aplicativo da web.

Nossa implementação usa Typescript, mas também pode ser facilmente usada para um projeto baseado em Javascript.

Configurando

Primeiro, vamos instalar o react-router-dom em nosso projeto se ele ainda não tiver sido instalado:

npm instalar react-router-dom

Ou alternativa, usando fio:

yarn adicionar react-router-dom

Vamos também instalar o bootstrap para estilizar nosso componente:

inicialização de instalação npm

Implementando nosso componente

Em seguida, criamos um componente Breadcrumbs.tsx que conterá a marcação para a localização atual e também incluirá a lógica necessária para determinar a localização atual em relação à localização raiz.

Vamos começar adicionando uma marcação simples para o componente:

 

O componente atualmente possui apenas um botão Voltar. Vamos adicionar uma implementação simples para o botão Voltar, de modo que, quando clicado, a página anterior seja carregada:

  const goBack = () => {
    window.history.back();
  };

O próximo passo será escrever uma função que usará a função matchRoutes para obter a rota atual e aplicar transformações para filtrar todas as rotas relacionadas à rota atual.
O matchRoute aceita uma matriz de objetos do tipo AgnosticRouteObject e retorna um AgnosticRouteMatch[] | null onde T é o tipo de objeto que passamos. Também é importante observar que o objeto deve conter uma propriedade chamada path.

Vamos primeiro declarar uma interface para nossa rota:


exportar interface IRoute { nome: sequência; caminho: string; //Importante }
export interface IRoute {
  name: string;
  path: string; //Important
}
Vamos então declarar nossas rotas:


rotas const: IRoute[] = [ { caminho: '/home', nome: 'Casa' }, { caminho: '/home/sobre', nome: 'Sobre' }, { caminho: '/usuários', nome: 'Usuários' }, { caminho: '/usuários/:id', nome: 'Usuário' }, { caminho: '/usuários/:id/configurações/editar', name: 'Editar configurações do usuário' } ];
export interface IRoute {
  name: string;
  path: string; //Important
}
Também declaramos uma variável para manter o gancho useLocation e também outra para manter nossa localização atual no estado:


const location = useLocation(); const [migalhas, setCrumbs] = useState([]);
export interface IRoute {
  name: string;
  path: string; //Important
}
A seguir, vamos implementar nossa função:


const getPaths = () => { const allRoutes = matchRoutes(rotas, localização); const matchedRoute = allRoutes? allRoutes[0] : null; deixe a localização atual: IRoute[] = []; if (Rotacorrespondente) { breadcrumbs = rotas .filter((x) => matchedRoute.route.path.includes(x.path)) .map(({caminho, ...rest }) => ({ caminho: Object.keys(matchedRoute.params).length ? Object.keys(matchedRoute.params).reduce( (caminho, param) => path.replace(`:${param}`, matchedRoute.params[param] as string), caminho) : caminho, ...descansar, })); } setCrumbs(migalhas de pão); };
export interface IRoute {
  name: string;
  path: string; //Important
}
Aqui, primeiro obtemos todas as rotas que correspondem à localização atual:

const allRoutes = matchRoutes(rotas, localização);

Em seguida, fazemos uma verificação rápida para ver se algum resultado é retornado e pegamos o primeiro:

const matchedRoute = allRoutes? allRoutes[0] : null;

Em seguida, filtramos todas as rotas que correspondem à rota atual:

rotas.filter((x) => matchedRoute.route.path.includes(x.path))

Então vamos usar o resultado para criar um novo array que verifica se o caminho tem parâmetros e então troca rotas dinâmicas pelo valor de params:


.map(({caminho, ...rest }) => ({ caminho: Object.keys(matchedRoute.params).length ? Object.keys(matchedRoute.params).reduce( (caminho, param) => path.replace(`:${param}`, matchedRoute.params[param] como string), caminho ) : caminho, ...descansar, }));
export interface IRoute {
  name: string;
  path: string; //Important
}
Isso garante que se declararmos uma rota como /users/:id/edit nas rotas e o id for passado como 1, obteremos /users/1/edit.

Em seguida, vamos chamar nossa função em um useEffect para que ela seja executada sempre que nossa localização mudar:


useEffect(() => { getPaths(); }, [localização]);
export interface IRoute {
  name: string;
  path: string; //Important
}
Feito isso, podemos então usar as migalhas em nossa marcação:


{crumbs.map((x: IRoute, chave: número) => migalhas.length === chave 1? (
  • {x.name}
  • ) : (
  • {x.nome}
  • ) )}
    export interface IRoute {
      name: string;
      path: string; //Important
    }
    
    Aqui, exiba todas as migalhas com seus links, exceto a última que exibe apenas o nome.

    Com isso, agora temos nosso componente BreadCrumbs.tsx completo:


    importar {useEffect, useState} de 'react'; importar {Link, matchRoutes, useLocation} de 'react-router-dom'; interface de exportação IRoute { nome: sequência; caminho: string; } rotas const: IRoute[] = [ { caminho: '/home', nome: 'Casa', }, { caminho: '/home/sobre', nome: 'Sobre', }, { caminho: '/usuários', nome: 'Usuários', }, { caminho: '/usuários/:id/editar', name: 'Editar usuários por ID', }, ]; const pão ralado = () => { const localização = useLocation(); const [migalhas, setCrumbs] = useState([]); // const rotas = [{ caminho: '/membros/:id' }]; const getPaths = () => { const allRoutes = matchRoutes(rotas, localização); const matchedRoute = allRoutes? allRoutes[0] : null; deixe a localização atual: IRoute[] = []; if (Rotacorrespondente) { breadcrumbs = rotas .filter((x) => matchedRoute.route.path.includes(x.path)) .map(({caminho, ...rest }) => ({ caminho: Object.keys(matchedRoute.params).length ? Object.keys(matchedRoute.params).reduce( (caminho, param) => path.replace(`:${param}`, matchedRoute.params[param] como string), caminho ) : caminho, ...descansar, })); } setCrumbs(migalhas de pão); }; useEffect(() => { getPaths(); }, [localização]); const voltar = () => { janela.history.back(); }; retornar (
    ); }; exportar breadcrumbs padrão;
    export interface IRoute {
      name: string;
      path: string; //Important
    }
    
    Podemos então usar o componente em qualquer parte da nossa aplicação, preferencialmente no layout.

    Conclusão

    Vimos como implementar um componente de localização atual simples que podemos adicionar ao nosso aplicativo para melhorar a navegação e a experiência do usuário.

    Links úteis

    https://stackoverflow.com/questions/66265608/react-router-v6-get-path-pattern-for-current-route

    https://medium.com/@mattywilliams/generating-an-automatic-breadcrumb-in-react-router-fed01af1fc3, no qual esta postagem se inspira.

    Declaração de lançamento Este artigo foi reproduzido em: https://dev.to/bayo99/implementing-breadcrumbs-in-react-using-react-router-v6-363o?1 Se houver alguma violação, entre em contato com [email protected] para excluir isto
    Tutorial mais recente Mais>

    Isenção de responsabilidade: Todos os recursos fornecidos são parcialmente provenientes da Internet. Se houver qualquer violação de seus direitos autorais ou outros direitos e interesses, explique os motivos detalhados e forneça prova de direitos autorais ou direitos e interesses e envie-a para o e-mail: [email protected]. Nós cuidaremos disso para você o mais rápido possível.

    Copyright© 2022 湘ICP备2022001581号-3