6 conseils pour écrire du code propre et de qualité

Résumé : En tant que développeur, il est important d'écrire du code propre, c'est pourquoi dans cet article l'auteur répertorie d'abord quelques avantages de l'écriture de code propre, puis propose 6 conseils pour écrire du code propre, pour les développeurs apprendre de. ...

Écrire du code propre n'est pas une tâche facile et nécessite d'essayer différentes techniques et pratiques. Le problème est qu'il existe tellement de pratiques et de techniques sur ce problème qu'il est difficile pour les développeurs de choisir, alors simplifiez un peu le problème. Dans cet article, nous discuterons d'abord de certains des avantages de l'écriture de code propre, puis nous discuterons de 6 conseils ou pratiques pour écrire le code propre le plus courant.

Voici le contenu du répertoire :

Avantages de l'écriture de code propre
1. Plus facile de démarrer et de poursuivre un projet
2. Propice à la formation des nouveaux membres de l'équipe
3. Facilitez le suivi des modèles de codage

Conseils pour écrire du code propre
1. Écrivez du code lisible
2. Utilisez des noms significatifs pour les variables, les fonctions et les méthodes
3. Laissez chaque fonction ou méthode n’effectuer qu’une seule tâche
4. Utilisez les commentaires pour expliquer le code
5. Maintenir la cohérence du style de code
6. Vérifiez régulièrement votre code

Quelques idées sur l'écriture de code propre

Avantages de l'écriture de code propre

Découvrez d'abord l'écriture de code propre, quelques avantages . L’un des principaux avantages est qu’un code propre réduit le temps passé à lire et à comprendre le code. Un code désordonné ralentira tout développeur et rendra son travail plus difficile. Plus le code est déroutant, plus les développeurs doivent consacrer du temps à le comprendre pleinement afin de pouvoir l'utiliser. Et si le code est trop compliqué, les développeurs peuvent décider d’arrêter de le lire et de l’écrire eux-mêmes à partir de zéro.

1． Plus facile de démarrer et de poursuivre un projet
Commençons par un exemple simple pour illustrer cette problématique. Disons que nous revenons à un projet précédent après une longue période, peut-être que pendant ce temps un client nous contacte pour effectuer un autre travail. Maintenant, imaginez si vous n'aviez pas écrit de code propre à l'époque, à quel point cela serait mauvais et déroutant après avoir vu le code pour la première fois. Vous pouvez également voir à quel point il est difficile de commencer à coder là où vous vous êtes arrêté.

Il faut donc maintenant consacrer plus de temps au projet car nous devons comprendre le code que nous avons écrit auparavant. Cela aurait pu être évité si du code propre avait été écrit dès le début, mais il faut désormais en payer le prix. De plus, l’ancien code est tellement compliqué et mauvais que nous pourrions décider de repartir de zéro. Les clients ne seront peut-être pas contents d’entendre cela.

D’un autre côté, le code propre n’a généralement pas ce problème. Supposons que l'exemple précédent soit le contraire et que le code précédent soit propre et élégant, combien de temps faudrait-il pour le comprendre ? Peut-être qu'il ne faudrait que quelques minutes de lecture du code pour comprendre comment tout fonctionne, et nous aurions pu écrire ? cela pendant un certain temps , donc l'énergie dépensée dans ce cas sera nettement inférieure à celle du premier cas, et en même temps, le client ne s'en souciera pas trop.

C'est le premier avantage de l'écriture de code propre, et cela s'applique non seulement à vos propres projets, mais également au travail d'autres développeurs. Un code propre permet de démarrer les choses plus rapidement, personne n'a besoin de passer des heures à se pencher sur le code, mais nous pouvons nous mettre directement au travail.

2. Propice à la formation des nouveaux employés de l'équipe
Un autre avantage de l'écriture de code propre est étroitement lié au premier avantage, c'est-à-dire qu'il peut le rendre plus facile et plus rapide pour les nouveaux employés. Utilisez le code à bon escient. Supposons que nous devions embaucher un développeur, combien de temps lui faudra-t-il pour comprendre le code et apprendre à l'utiliser ? Bien sûr, cela dépend de la situation. Si notre code est désordonné et mal écrit, elle devra passer plus de temps à apprendre le code. En revanche, si le code est propre, lisible et simple à comprendre, elle pourra commencer son travail plus rapidement.

Certains diront peut-être que ce n'est pas un problème car d'autres développeurs peuvent l'aider. Bien sûr, c’est exact, mais l’aide ne devrait prendre que peu de temps, deux ou trois fois ou un jour ou deux, et non deux ou trois semaines. La décision d'embaucher un autre développeur a donc été prise pour accélérer notre travail, et non pour le ralentir ou passer plus de temps à l'aider à apprendre à coder.

Lorsque nous nous efforçons d'écrire du code propre, d'autres apprendront de nous, et il sera plus facile de faire de même et d'écrire du code propre. Bien entendu, il faut encore prévoir du temps pour aider chaque nouveau développeur à apprendre et à comprendre le code. Bien sûr, je parle de jours et non de semaines. De plus, un code propre aidera l’équipe à intégrer davantage de développeurs et les aidera en même temps à comprendre le code. En termes simples, plus le code est simple, plus il est facile à interpréter et moins il y aura de malentendus.

3． Plus facile à suivre des modèles de codage
Une chose à retenir est que comprendre et apprendre à utiliser le code est la même chose. Cependant, ce n’est qu’un début et nous devons également nous assurer que les développeurs sont prêts à suivre notre modèle de codage. Bien sûr, il est plus facile d’atteindre cet objectif avec du code propre qu’avec du code compliqué. Ceci est important car l’équipe souhaite non seulement écrire du code propre, mais également maintenir ce modèle au fil du temps, ce qui nécessite également une réflexion à long terme.

De plus, que se passe-t-il si le développeur ne suit pas le modèle de codage actuel ? Ce problème peut généralement être résolu tout seul ? Supposons qu'il y ait un groupe de personnes travaillant sur la même base de code et que l'une d'entre elles commence à s'écarter du style standard. Le reste de l’équipe poussera alors ce développeur à suivre le standard. Elle suivra les conseils car elle ne veut pas quitter le groupe.

Il existe également une situation dans laquelle un développeur convainc le reste de l'équipe d'adopter et de suivre son modèle de codage. C'est certainement une bonne chose si les développeurs proposent des modèles de codage plus propres et conduisant à de meilleurs résultats. En effet, écrire et maintenir du code propre ne signifie pas que toute opportunité de l'améliorer doit être ignorée. Je pense qu'il faut toujours maintenir une attitude améliorable envers la pratique actuelle et travailler dur pour trouver des opportunités d'amélioration.

Donc, si un développeur s'écarte du modèle actuel et que son modèle est meilleur, alors il pourrait être approprié pour nous d'effectuer le changement. Nous ne devrions donc pas ignorer les pratiques de codage des autres avant d’essayer d’autres modèles, et nous devrions continuer à rechercher des possibilités d’amélioration. Enfin, le troisième scénario. Le promoteur a décidé de ne pas adopter nos pratiques ni de nous convaincre d'adopter les siennes. Car elle va décider de quitter l’équipe.

Conseils pour écrire du code propre

Maintenant, en plus de discuter des avantages de l'écriture de code propre, il est également temps d'apprendre quelques techniques pour nous aider à atteindre cet objectif. Comme vous le verrez ci-dessous, le code propre se compose et suit quelques méthodes. Ces méthodes rendent le code plus propre, plus lisible, plus facile à comprendre et plus simple. Bien entendu, il n’est pas nécessaire de mettre en œuvre toutes les méthodes, il suffit de mettre en œuvre et de suivre une ou deux mesures pour obtenir des résultats positifs.

1. Écrire du code lisible
Il est vrai que le code écrit sera interprété par la machine, mais cela ne signifie pas que la lisibilité et l'intelligibilité du code doivent être ignorées, car dans le futur il y aura toujours une autre personne qui utilisera le code que nous avons écrit. Même si nous rendons notre code inaccessible aux autres, nous pourrons peut-être le récupérer à l'avenir. Pour ces raisons, il est dans notre intérêt de rendre notre code facile à lire et à comprendre. Alors comment y parvenir ?

Le moyen le plus simple est d'utiliser des espaces. Vous pouvez réduire votre code avant de le publier, mais il n'est pas nécessaire de lui donner un aspect miniaturisé. Utilisez plutôt l'indentation, les nouvelles lignes et les lignes vides pour rendre la structure de votre code plus lisible. Lorsque vous décidez d'emprunter cette voie, votre code devient beaucoup plus lisible et compréhensible. Ensuite, regarder le code permet de le comprendre plus facilement. Regardons deux exemples simples.
Code :

// Badconst userData=
[{userId: 1, userName: 'Anthony Johnson', memberSince: '08-01-2017', fluentIn: [ 'English', 'Greek', 'Russian']},
{userId: 2, userName: 'Alice Stevens', memberSince: '02-11-2016', fluentIn: [ 'English', 'French', 'German']},
{userId: 3, userName: 'Bradley Stark', memberSince: '29-08-2013', fluentIn: [ 'Czech', 'English', 'Polish']},
{userId: 4, userName: 'Hirohiro Matumoto', memberSince: '08-05-2015', fluentIn: [ 'Chinese', 'English', 'German', 'Japanese']}];
// Betterconst userData = [
  {
    userId: 1,
    userName: 'Anthony Johnson',
    memberSince: '08-01-2017',
    fluentIn: [      'English',      'Greek',      'Russian'
    ]
  }, {
    userId: 2,
    userName: 'Alice Stevens',
    memberSince: '02-11-2016',
    fluentIn: [      'English',      'French',      'German'
    ]
  }, {
    userId: 3,
    userName: 'Bradley Stark',
    memberSince: '29-08-2013',
    fluentIn: [      'Czech',      'English',      'Polish'
    ]
  }, {
    userId: 4,
    userName: 'Hirohiro Matumoto',
    memberSince: '08-05-2015',
    fluentIn: [      'Chinese',      'English',      'German',      'Japanese'
    ]
  }
];

Code :

// Badclass 
CarouselLeftArrow extends Component{
render(){
return ( <a href="#" className="carousel__arrow carousel__arrow--left" onClick={this.props.onClick}> <span className="fa fa-2x fa-angle-left"/> </a> );}};
// Betterclass 
CarouselLeftArrow extends Component {
  render() {    return (
      <a
        href="#"
        className="carousel__arrow carousel__arrow--left"
        onClick={this.props.onClick}
      >
        <span className="fa fa-2x fa-angle-left" />
      </a>
    );
  }
};

2．为变量、函数和方法使用有意义的名称 
来看一看第二个技巧，它将帮助我们编写可理解和干净的代码。这个技巧是关于变量、函数和方法的有意义的名称。“有意义的”是什么意思?有意义的名字是描述性足够多的名字，而不仅仅是编写者自己才能够理解的变量、函数或方法。换句话说，名称本身应该根据变量、函数或方法的内容和使用方式来定义。 
代码：

// Badconst fnm = ‘Tom’;
const lnm = ‘Hanks’const x = 31;
const l = lstnm.length;const boo = false;
const curr = true;const sfn = ‘Remember the name’;
const dbl = [‘1984’, ‘1987’, ‘1989’, ‘1991’].map((i) => {  
return i * 2;
});
// Betterconst firstName = ‘Tom’;
const lastName = ‘Hanks’const age = 31;
const lastNameLength = lastName.length;
const isComplete = false;const isCurrentlyActive = true;
const songFileName = ‘Remember the name’;
const yearsDoubled = [‘1984’, ‘1987’, ‘1989’, ‘1991’].map((year) => {  
return year * 2;
});

然而需要注意的是，使用描述性名称并不意味着可以随意使用任意多个字符。一个好的经验则是将名字限制在3或4个单词。如果需要使用超过4个单词，说明这个函数或方法需要同时执行很多的任务，所以应该简化代码，只使用必要的字符。

3.让一个函数或方法只执行一个任务 
当开始编写代码时，使用的函数和方法看起来就像一把瑞士军刀，几乎可以处理任何事情，但是很难找到一个好的命名。另外，除了编写者，几乎没有人知道函数是用来做什么的以及该如何使用它。有时我就会遇到这些问题，我在这方面做的很不好。

然后，有人提出了一个很好的建议：让每个函数或方法只执行一个任务。这个简单的建议改变了一切，帮助我写出了干净的代码，至少比以前更干净了。从那以后，其他人终于能够理解我的代码了，或者说，他们不需要像以前一样花很多时间去读懂代码了，功能和方法也变得更好理解。在相同的输入下，总是能产生相同的输出，而且，命名也变得容易得多。

如果你很难找到函数和方法的描述性名称，或者需要编写冗长的指令以便其他人可以使用，那请考虑这个建议，让每个函数或方法只执行一个任务。如果你的功能和方法看起来像瑞士军刀一样无所不能，那请你执行这个方法，相信我，这种多才多艺不是一种优势。这是一个相当不利的情况，可能会产生事与愿违的结果。

附注:这种让每一个函数或方法只执行一项任务的做法被称为保持纯函数。这种编码实践来自于函数式编程的概念。如果你想了解更多，我推荐阅读《So You Want to be a Functional Programmer series[4]》。 
代码：

// Examples of pure functionsfunction subtract(x, y) {
    return x - y;
}function multiply(x, y) {
    return x * y;
}// Double numbers in an arrayfunction doubleArray(array) {
  return array.map(number => number * 2)
}

4．更容易遵循编码模式 
不管多么努力地为变量、函数和方法想出有意义的名字，代码仍然不可能完全清晰易懂，还有一些思路需要进行解释。问题可能不是代码很难理解或使用，相反，其他人可能不理解为什么要实现这个函数或方法，或者为什么要以特定的方式创建它。意思是，创建函数或方法的意图还不清楚。

有时可能不得不采用非传统的方法来解决问题，因为没有足够的时间来想出更好的解决方案，这也很难用代码来解释。所以，通过代码注释可以帮助解决这个问题，也可以帮助我们向其他人解释为什么写了这个方法，为什么要用这种特定的方式来写，那么其他人就不必猜测这些方法或函数的用途了。

更重要的是，当我们使用注来解释代码后，其他人可能会找到一个更好的方法来解决这个问题并改进代码。这是有可能的，因为他们知道问题是什么，以及期望的结果是什么。如果不知道这些信息，其他人就很难创建更好的解决方案，或者他们可能不会去尝试，因为他们认为没有必要去修改创建者自己的想法。

因此，每当自己决定使用一些快速修复或非传统的方法时，要用注释来解释为什么这么做。最好是用一两行注释来解释，而不用别人来猜测。

Cela dit, nous ne devons utiliser les commentaires que lorsque cela est nécessaire et ne pas expliquer un mauvais code. Écrire des commentaires sans fin n’aidera pas à transformer un mauvais code en code propre. Si le code est mauvais, le problème doit être résolu en améliorant le code, et non en ajoutant des instructions sur la façon de l'utiliser. Écrire du code propre est plus important.

5． Maintenir la cohérence du style de codage
Lorsque nous avons une méthode ou un style de codage spécifique que nous aimons, nous l'utiliserons toujours partout. Mais ce n'est pas une bonne idée d'utiliser différents styles de codage dans différents projets, et il n'est pas possible de revenir naturellement au code précédent, il faut donc encore un certain temps pour comprendre le style de codage utilisé dans le projet.

Le meilleur moyen est de choisir une méthode de codage et de s'y tenir dans tous les projets. De cette façon, il sera plus facile de revenir à l’ancien code. Bien sûr, essayer de nouvelles façons de coder est une bonne chose et nous aide à trouver de meilleures façons de faire notre travail. Mais il est préférable d'essayer différents styles de codage sur différents projets ou exercices de laboratoire plutôt que sur le projet principal.

De plus, lorsque l'on décide de faire des expériences, il faut les essayer plusieurs fois et prendre le temps de les faire à fond. Vous ne devez le mettre en œuvre que si vous êtes vraiment convaincu que vous l’aimez et que vous êtes à l’aise avec cela. Et lorsque vous décidez de le faire, il est préférable de l'appliquer à tous les projets. Oui, cela prend du temps, et cela nous oblige aussi à réfléchir correctement.

6. Vérifiez votre code

C'est le dernier conseil. Il ne s’agit pas seulement d’écrire du code propre, mais il y a aussi le dernier travail à effectuer, qui consiste à maintenir un code propre. Nous devrions vérifier le code régulièrement et essayer de l'améliorer. Sinon, si notre ancien code n’est pas revu et mis à jour, il deviendra rapidement obsolète, tout comme nos appareils. Si vous souhaitez conserver votre code en parfait état, vous devez le mettre à jour régulièrement.

Il en va de même pour le code que vous utilisez quotidiennement. Le code deviendra plus complexe et déroutant, cela doit donc être évité et le code doit rester propre. La seule façon d’y parvenir est de revoir régulièrement notre code. En d’autres termes, nous devons le conserver. Pour les projets qui ne vous intéressent plus dans le futur, cela n'est peut-être pas nécessaire, mais pour d'autres, la maintenance du code fait partie du travail.

Quelques réflexions sur l'écriture de code propre

Les six pratiques discutées aujourd'hui ne sont peut-être pas les plus efficaces, ni les plus importantes, mais ce sont celles que les développeurs expérimentés utilisent le plus souvent. mentionné, c'est pourquoi je les ai choisis. J'espère que ces pratiques ou conseils vous aideront à commencer à écrire du code propre. Maintenant, comme pour toute chose, le plus important est de commencer. Alors, choisissez au moins un conseil et essayez-le.

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!