10 conseils pratiques pour écrire du code React plus propre
Cet article compile et partage 10 conseils pratiques pour écrire du code React plus simple. J'espère qu'il sera utile à tout le monde !
1. Abréviation JSX
Comment transmettre la vraie valeur aux accessoires donnés ? [Recommandations associées : Tutoriel vidéo Redis, Vidéo de programmation]
Dans l'exemple suivant, utilisez la prop showTitle
pour afficher le titre de l'application dans le composant de la barre de navigation : showTitle
在导航栏组件中显示应用的标题:
export default function App() { return ( <main> <Navbar showTitle={true} /> </main> ); } function Navbar({ showTitle }) { return ( <div> {showTitle && <h1>标题</h1>} </div> ) }
这里将 showTitle
显式设置为布尔值 true
,其实这是没必要的,因为组件上提供的任何 prop
都具有默认值 true
。因此只需要在调用组件时传递一个 showTitle
即可:
export default function App() { return ( <main> <Navbar showTitle /> </main> ); } function Navbar({ showTitle }) { return ( <div> {showTitle && <h1>标题</h1>} </div> ) }
另外,当需要传递一个字符串作为 props
时,无需使用花括号 {}
包裹,可以通过双引号包裹字符串内容并传递即可:
export default function App() { return ( <main> <Navbar title="标题" /> </main> ); } function Navbar({ title }) { return ( <div> <h1>{title}</h1> </div> ) }
2. 将不相关代码移动到单独的组件中
编写更简洁的 React 代码的最简单和最重要的方法就是善于将代码抽象为单独的 React 组件。
下面来看一个例子,应用中最上面会有一个导航栏,并遍历 posts
中的数据将文章标题渲染出来:
export default function App() { const posts = [ { id: 1, title: "标题1" }, { id: 2, title: "标题2" } ]; return ( <main> <Navbar title="大标题" /> <ul> {posts.map(post => ( <li key={post.id}> {post.title} </li> ))} </ul> </main> ); } function Navbar({ title }) { return ( <div> <h1>{title}</h1> </div> ); }
那我们怎样才能让这段代码更加清洁呢?我们可以抽象循环中的代码(文章标题),将它们抽离到一个单独的组件中,称之为 FeaturedPosts
。抽离后的代码如下:
export default function App() { return ( <main> <Navbar title="大标题" /> <FeaturedPosts /> </main> ); } function Navbar({ title }) { return ( <div> <h1>{title}</h1> </div> ); } function FeaturedPosts() { const posts = [ { id: 1, title: "标题1" }, { id: 2, title: "标题2" } ]; return ( <ul> {posts.map((post) => ( <li key={post.id}>{post.title}</li> ))} </ul> ); }
如你所见,在 App 组件中,通过其中的组件名称:Navbar
和 FeaturedPosts
// src/App.js import Navbar from './components/Navbar.js'; import FeaturedPosts from './components/FeaturedPosts.js'; export default function App() { return ( <main> <Navbar title="大标题" /> <FeaturedPosts /> </main> ); }
showTitle
est explicitement défini sur une valeur booléenne true
, ce qui n'est pas nécessaire puisque tout prop
fourni sur le composant a une valeur par défaut de vrai
. Il vous suffit donc de passer un showTitle
lors de l'appel du composant : // src/components/Navbar.js
export default function Navbar({ title }) {
return (
<div>
<h1>{title}</h1>
</div>
);
}
Copier après la connexionDe plus, lorsque vous devez passer une chaîne en tant que props
, il n'est pas nécessaire d'utiliser curl accolades { }
, vous pouvez placer le contenu de la chaîne entre guillemets doubles et le transmettre : // src/components/FeaturedPosts.js
export default function FeaturedPosts() {
const posts = [
{
id: 1,
title: "标题1"
},
{
id: 2,
title: "标题2"
}
];
return (
<ul>
{posts.map((post) => (
<li key={post.id}>{post.title}</li>
))}
</ul>
);
}
Copier après la connexion2 Déplacer le code non pertinent vers un composant séparé
// src/components/Navbar.js export default function Navbar({ title }) { return ( <div> <h1>{title}</h1> </div> ); }
// src/components/FeaturedPosts.js export default function FeaturedPosts() { const posts = [ { id: 1, title: "标题1" }, { id: 2, title: "标题2" } ]; return ( <ul> {posts.map((post) => ( <li key={post.id}>{post.title}</li> ))} </ul> ); }
.
Le moyen le plus simple et le plus important d'écrire du code React plus propre est de maîtriser l'abstraction de votre code en composants React distincts.
Regardons un exemple. Il y aura une barre de navigation en haut de l'application, et les données dans les posts
seront parcourues pour afficher le titre de l'article :
import React from 'react'; export default function FeaturedPosts() { const [posts, setPosts] = React.useState([]); React.useEffect(() => { fetch('https://jsonplaceholder.typicode.com/posts') .then(res => res.json()) .then(data => setPosts(data)); }, []); return ( <ul> {posts.map((post) => ( <li key={post.id}>{post.title}</li> ))} </ul> ); }
Alors, comment pouvons-nous faire ce code nettoyant ? Nous pouvons résumer le code dans la boucle (titres des articles) et les extraire dans un composant séparé, appelez-le FeaturedPosts
. Le code extrait est le suivant : import React from 'react';
export default function useFetchPosts() {
const [posts, setPosts] = React.useState([]);
React.useEffect(() => {
fetch('https://jsonplaceholder.typicode.com/posts')
.then(res => res.json())
.then(data => setPosts(data));
}, []);
return posts;
}
Copier après la connexionComme vous pouvez le voir, dans le composant App, vous pouvez le voir rapidement à travers les noms des composants : Navbar
et FeaturedPosts
Le rôle de la demande.
3. Créez des fichiers séparés pour chaque composantimport React from 'react'; export default function useFetchPosts() { const [posts, setPosts] = React.useState([]); React.useEffect(() => { fetch('https://jsonplaceholder.typicode.com/posts') .then(res => res.json()) .then(data => setPosts(data)); }, []); return posts; }
Dans l'exemple ci-dessus, nous avons implémenté trois composants dans un seul fichier. Si la logique des composants est petite, il n'y a aucun problème à les écrire. Cependant, si la logique des composants est plus complexe, la lisibilité du code écrit de cette manière sera très mauvaise. Pour rendre les fichiers de votre application plus lisibles, vous pouvez placer chaque composant dans un fichier distinct.
Cela nous aide à séparer les préoccupations dans notre application. Cela signifie que chaque fichier n'est responsable que d'un seul composant, et vous ne masquerez pas la source du composant si vous souhaitez le réutiliser dans votre application :
import useFetchPosts from '../hooks/useFetchPosts.js'; export default function FeaturedPosts() { const posts = useFetchPosts() return ( <ul> {posts.map((post) => ( <li key={post.id}>{post.title}</li> ))} </ul> ); }
import useFetchPosts from '../hooks/useFetchPosts.js'; export default function FeaturedPosts() { const posts = useFetchPosts() return ( <ul> {posts.map((post) => ( <li onClick={event => { console.log(event.target, 'clicked!'); }} key={post.id}>{post.title}</li> ))} </ul> ); }
import useFetchPosts from '../hooks/useFetchPosts.js'; export default function FeaturedPosts() { const posts = useFetchPosts() function handlePostClick(event) { console.log(event.target, 'clicked!'); } return ( <ul> {posts.map((post) => ( <li onClick={handlePostClick} key={post.id}>{post.title}</li> ))} </ul> ); }
De plus, en incluant chaque composant individuel dans son propre fichier, vous évitez a Le fichier devient trop volumineux.
4. Déplacez la fonction partagée dans un hook ReactDans le composant FeaturedPosts, supposons que vous souhaitiez obtenir des données d'article de l'API au lieu d'utiliser de fausses données. Vous pouvez utiliser l'API fetch pour y parvenir :
export default function App() { return ( <main style={{ textAlign: 'center' }}> <Navbar title="大标题" /> </main> ); } function Navbar({ title }) { return ( <div style={{ marginTop: '20px' }}> <h1 style={{ fontWeight: 'bold' }}>{title}</h1> </div> ) }
Mais que se passe-t-il si vous souhaitez effectuer cette requête de données sur plusieurs composants ?
Supposons qu'en plus du composant FeaturedPosts, il existe un autre composant nommé Posts qui contient les mêmes données. Nous devons copier la logique pour obtenir les données et la coller dans le composant. Pour éviter la duplication de code, vous pouvez définir un nouveau hook React, que vous pouvez appeler useFetchPosts : export default function App() {
const styles = {
main: { textAlign: "center" }
};
return (
<main style={styles.main}>
<Navbar title="大标题" />
</main>
);
}
function Navbar({ title }) {
const styles = {
div: { marginTop: "20px" },
h1: { fontWeight: "bold" }
};
return (
<div style={styles.div}>
<h1 style={styles.h1}>{title}</h1>
</div>
);
}
Copier après la connexion De cette façon, vous pouvez le réutiliser dans n'importe quel composant, y compris le composant FeaturedPosts :
export default function App() { const styles = { main: { textAlign: "center" } }; return ( <main style={styles.main}> <Navbar title="大标题" /> </main> ); } function Navbar({ title }) { const styles = { div: { marginTop: "20px" }, h1: { fontWeight: "bold" } }; return ( <div style={styles.div}> <h1 style={styles.h1}>{title}</h1> </div> ); }
export default function EditButton({ post }) { const user = useAuthUser(); const isPostAuthor = post.author.userId !== user && user.userId; return isPostAuthor ? <EditButton /> : null; }
. Une autre façon de simplifier vos composants consiste à supprimer autant de JavaScript que possible de JSX. Jetez un œil à l'exemple suivant :
export default function EditButton({ post }) { const user = useAuthUser(); const isPostAuthor = post.author.userId !== user?.userId; return isPostAuthor ? <EditButton /> : null; }
Ici, nous essayons de gérer l'événement click de l'article, et vous pouvez voir que notre JSX devient plus difficile à lire. Étant donné que la fonction est incluse en tant que fonction en ligne, cela obscurcit l'objectif de ce composant et ses fonctions associées. Comment résoudre ce problème ? Vous pouvez extraire la fonction en ligne contenant onClick dans une fonction de gestionnaire distincte et lui donner le nom handlePostClick. Cela rend JSX plus lisible :
export default function App() { return ( <Layout> <Routes /> </Layout> ); }
const App = () => ( <Layout> <Routes /> </Layout> ); export default App;
function PostList() { const posts = usePostData(); return posts.map(post => ( <PostListItem key={post.id} post={post} /> )) }
export default function EditButton({ post }) { const user = useAuthUser(); const isPostAuthor = post.author.userId !== user && user.userId; return isPostAuthor ? <EditButton /> : null; }
这段代码的问题是 user 可能是 undefined. 这就是为什么我们必须在尝试获取 userId 属性之前使用 && 运算符来确保 user 是一个对象。如果我要访问一个对象中的另一个对象,就不得不再包含一个 && 条件。 这会导致代码变得复杂、难以理解。
JavaScript 可选链运算符(?.)允许我们在访问属性之前检查对象是否存在。用它来简化上面的代码:
export default function EditButton({ post }) { const user = useAuthUser(); const isPostAuthor = post.author.userId !== user?.userId; return isPostAuthor ? <EditButton /> : null; }
这样将防止任何类型错误,并允许我们编写更清晰的条件逻辑。
8. 带括号的隐式返回
在 React 应用中可以使用 function 关键字的函数声明语法编写组件,也可以使用设置为变量的箭头函数。使用 function 关键字的组件必须在返回任何 JSX 之前使用 return 关键字。
export default function App() { return ( <Layout> <Routes /> </Layout> ); }
通过将返回的代码包裹在一组括号中,可以通过隐式返回(不使用 return 关键字)从函数返回多行 JavaScript 代码。
对于使用箭头函数的组件,不需要包含 return 关键字,可以只返回带有一组括号的 JSX。
const App = () => ( <Layout> <Routes /> </Layout> ); export default App;
此外,当使用 .map()
迭代元素列表时,还可以跳过 return
关键字并仅在内部函数的主体中使用一组括号返回 JSX。
function PostList() { const posts = usePostData(); return posts.map(post => ( <PostListItem key={post.id} post={post} /> )) }
9. 使用空值合并运算符
在 JavaScript 中,如果某个值是假值(如 null、undefined、0、''、NaN),可以使用 || 条件来提供一个备用值。
例如,在产品页面组件需要显示给定产品的价格,可以使用 || 来有条件地显示价格或显示文本“产品不可用”。
export default function ProductPage({ product }) { return ( <> <ProductDetails /> <span> {product.price || "产品不可用"} </span> </> ); }
现有的代码存在一个问题,如果商品的价格为0,也不会显示产品的价格而显示"产品不可用"。如果左侧为null
或者undefined
,而不是其他假值,就需要一个更精确的运算符来仅返回表达式的右侧。
这时就可以使用空值合并运算符,当左侧操作数为null或者 undefined 时,将返回右侧操作数。 否则它将返回其左侧操作数:
null ?? 'callback'; // "callback" 0 ?? 42; // 0
可以使用空值合并运算符来修复上面代码中的问题:
export default function ProductPage({ product }) { return ( <> <ProductDetails /> <span>{product.price ?? "产品不可用"} </> ); }
10. 使用三元表达式
在 React 组件中编写条件时,三元表达式是必不可少的,经常用于显示或隐藏组件和元素。
当然,我们用可以使用三元表达式和模板字符串来给 React 元素动态添加或删除类名。
export default function App() { const { isDarkMode } = useDarkMode(); return ( <main className={`body ${isDarkMode ? "body-dark" : "body-light"}`}> <Routes /> </main> ); }
这种条件逻辑也可以应用于任何 props:
export default function App() { const { isMobile } = useDeviceDetect(); return ( <Layout height={isMobile ? '100vh' : '80vh'}> <Routes /> </Layout> ); }
【推荐学习:javascript视频教程】
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

WebSocket et JavaScript : technologies clés pour réaliser des systèmes de surveillance en temps réel Introduction : Avec le développement rapide de la technologie Internet, les systèmes de surveillance en temps réel ont été largement utilisés dans divers domaines. L'une des technologies clés pour réaliser une surveillance en temps réel est la combinaison de WebSocket et de JavaScript. Cet article présentera l'application de WebSocket et JavaScript dans les systèmes de surveillance en temps réel, donnera des exemples de code et expliquera leurs principes de mise en œuvre en détail. 1. Technologie WebSocket

PHP et Vue : une combinaison parfaite d'outils de développement front-end À l'ère actuelle de développement rapide d'Internet, le développement front-end est devenu de plus en plus important. Alors que les utilisateurs ont des exigences de plus en plus élevées en matière d’expérience des sites Web et des applications, les développeurs front-end doivent utiliser des outils plus efficaces et plus flexibles pour créer des interfaces réactives et interactives. En tant que deux technologies importantes dans le domaine du développement front-end, PHP et Vue.js peuvent être considérés comme une arme parfaite lorsqu'ils sont associés. Cet article explorera la combinaison de PHP et Vue, ainsi que des exemples de code détaillés pour aider les lecteurs à mieux comprendre et appliquer ces deux éléments.

Lors des entretiens de développement front-end, les questions courantes couvrent un large éventail de sujets, notamment les bases HTML/CSS, les bases JavaScript, les frameworks et les bibliothèques, l'expérience du projet, les algorithmes et les structures de données, l'optimisation des performances, les requêtes inter-domaines, l'ingénierie front-end, les modèles de conception et les nouvelles technologies et tendances. Les questions de l'intervieweur sont conçues pour évaluer les compétences techniques du candidat, son expérience en matière de projet et sa compréhension des tendances du secteur. Par conséquent, les candidats doivent être parfaitement préparés dans ces domaines pour démontrer leurs capacités et leur expertise.

Tutoriel JavaScript : Comment obtenir le code d'état HTTP, des exemples de code spécifiques sont requis Préface : Dans le développement Web, l'interaction des données avec le serveur est souvent impliquée. Lors de la communication avec le serveur, nous devons souvent obtenir le code d'état HTTP renvoyé pour déterminer si l'opération a réussi et effectuer le traitement correspondant en fonction de différents codes d'état. Cet article vous apprendra comment utiliser JavaScript pour obtenir des codes d'état HTTP et fournira quelques exemples de codes pratiques. Utilisation de XMLHttpRequest

JavaScript et WebSocket : Construire un système efficace de prévisions météorologiques en temps réel Introduction : Aujourd'hui, la précision des prévisions météorologiques revêt une grande importance pour la vie quotidienne et la prise de décision. À mesure que la technologie évolue, nous pouvons fournir des prévisions météorologiques plus précises et plus fiables en obtenant des données météorologiques en temps réel. Dans cet article, nous apprendrons comment utiliser la technologie JavaScript et WebSocket pour créer un système efficace de prévisions météorologiques en temps réel. Cet article démontrera le processus de mise en œuvre à travers des exemples de code spécifiques. Nous

Django est un framework d'application Web écrit en Python qui met l'accent sur un développement rapide et des méthodes propres. Bien que Django soit un framework Web, pour répondre à la question de savoir si Django est un front-end ou un back-end, vous devez avoir une compréhension approfondie des concepts de front-end et de back-end. Le front-end fait référence à l'interface avec laquelle les utilisateurs interagissent directement, et le back-end fait référence aux programmes côté serveur. Ils interagissent avec les données via le protocole HTTP. Lorsque le front-end et le back-end sont séparés, les programmes front-end et back-end peuvent être développés indépendamment pour mettre en œuvre respectivement la logique métier et les effets interactifs, ainsi que l'échange de données.

Qu'est-ce que l'ESM front-end ? Des exemples de code spécifiques sont requis. Dans le développement front-end, ESM fait référence à ECMAScriptModules, une méthode de développement modulaire basée sur la spécification ECMAScript. ESM apporte de nombreux avantages, tels qu'une meilleure organisation du code, l'isolation entre les modules et la réutilisabilité. Cet article présentera les concepts de base et l'utilisation d'ESM et fournira quelques exemples de code spécifiques. Le concept de base d'ESM Dans ESM, nous pouvons diviser le code en plusieurs modules, et chaque module expose certaines interfaces pour que d'autres modules puissent

Introduction à la méthode d'obtention du code d'état HTTP en JavaScript : Dans le développement front-end, nous devons souvent gérer l'interaction avec l'interface back-end, et le code d'état HTTP en est une partie très importante. Comprendre et obtenir les codes d'état HTTP nous aide à mieux gérer les données renvoyées par l'interface. Cet article explique comment utiliser JavaScript pour obtenir des codes d'état HTTP et fournit des exemples de code spécifiques. 1. Qu'est-ce que le code d'état HTTP ? Le code d'état HTTP signifie que lorsque le navigateur lance une requête au serveur, le service
