L'importance d'écrire du code que les humains peuvent lire

Points clés

• L'intelligence d'abord: Le code très lisible améliore la maintenabilité et la collaboration, et l'écriture de code facile à comprendre et à modifier est cruciale.
• Gestion des fonctions et des fichiers: Utiliser des fonctions pour encapsuler le code réutilisable et diviser les fichiers volumineux en pièces plus petites et plus gérables pour simplifier la navigation et la compréhension.
• Convention de dénomination: Choisissez des noms clairs et descriptifs pour les fonctions et les variables pour améliorer la lisibilité et réduire le besoin de commentaires supplémentaires.
• Évitez la sur-optimisation: Bien que le code concis et optimisé soit attrayant, la lisibilité doit être priorisée lorsque l'impact des performances n'est pas significatif, car les moteurs JavaScript modernes sont très efficaces dans l'optimisation du code.
• Commentaires minutieux: Utilisez des commentaires pour expliquer "pourquoi" Faites cela, plutôt que "quoi faire", et gardez les commentaires pertinents et à jour pour aider à comprendre la logique du code non évidente.

Cet article a été examiné par Matt Burnett, Simon Codrington et Nilson Jacques. Merci à tous les évaluateurs de pairs SitePoint pour avoir obtenu le contenu de sitepoint à son meilleur!

Avez-vous déjà terminé un projet en un seul manche à la fois sans avoir à regarder à nouveau le code? Ni moi. Lorsque vous travaillez sur d'anciens projets, vous voudrez peut-être passer très peu ou pas de temps à déterminer le fonctionnement du code. Le code lisible est essentiel pour garder le produit entretenu et satisfaire vous et vos collègues ou collaborateurs.

Des exemples exagérés de code difficile à lire peuvent être trouvés dans le concours JS1K, dans le but d'écrire la meilleure application JavaScript en 1024 caractères ou moins, ainsi que JSF * CK (NSFW au fait), qui est Un style de programmation profond, utilisant seulement six caractères différents pour écrire du code JavaScript. La vérification du code sur ces sites vous fera vous demander ce qui se passe. Imaginez écrire du code comme celui-ci et essayer de corriger l'erreur après quelques mois.

Si vous parcourez régulièrement Internet ou créez des interfaces, vous savez peut-être qu'il est plus facile de quitter une grande forme volumineuse que de quitter une forme simple et petite. Il en va de même pour le code. Les gens peuvent préférer l'utiliser lorsqu'ils sont considérés comme plus faciles à lire et à utiliser. Au moins, cela vous empêchera de jeter votre ordinateur frustré.

Dans cet article, j'explorerai des conseils et des astuces pour rendre le code plus facile à lire, ainsi que des pièges à éviter.

Segmentation du code

persistent dans les analogies de la forme, la forme est parfois divisée en parties, ce qui le rend moins difficile. Le code peut faire de même. En le divisant en sections, les lecteurs peuvent sauter aux sections qui leur sont liées au lieu de lutter pour parcourir la jungle.

Cross-File

Depuis de nombreuses années, nous optimisons toutes sortes de choses pour le réseau. Les fichiers JavaScript ne font pas exception. En pensant à la minimisation et à la pré-HTTP / 2, nous enregistrons sur les demandes HTTP en combinant des scripts en un seul. Aujourd'hui, nous pouvons travailler comme nous le souhaitons et utilisons des coureurs de tâches comme Gulp ou Grunt pour traiter nos fichiers. Il est sûr de dire que nous pouvons programmer la façon dont nous aimons et laisser des optimisations (telles que des connexions) à l'outil.

// 从 API 加载用户数据
var getUsersRequest = new XMLHttpRequest();
getUsersRequest.open('GET', '/api/users', true);
getUsersRequest.addEventListener('load', function() {
    // 对用户执行某些操作
});

getUsersRequest.send();

//---------------------------------------------------
// 不同的功能从这里开始。也许
// 这是一个分成文件的时机。
//---------------------------------------------------

// 从 API 加载帖子数据
var getPostsRequest = new XMLHttpRequest();
getPostsRequest.open('GET', '/api/posts', true);
getPostsRequest.addEventListener('load', function() {
    // 对帖子执行某些操作
});

getPostsRequest.send();

fonction

La fonction

nous permet de créer des blocs de code réutilisables. Généralement, le contenu d'une fonction est en retrait, il est donc facile de voir les positions de début et de fin de la fonction. Une bonne habitude est de garder la fonction petite - 10 rangées ou moins. Il est également facile de comprendre ce qui se passe lorsque la fonction est appelée lorsque la fonction est nommée correctement. Nous présenterons la convention de dénomination plus tard.

// 从 API 加载用户数据
function getUsers(callback) {
    var getUsersRequest = new XMLHttpRequest();
    getUsersRequest.open('GET', '/api/users', true);
    getUsersRequest.addEventListener('load', function() {
        callback(JSON.parse(getUsersRequest.responseText));
    });

    getUsersRequest.send();
}

// 从 API 加载帖子数据
function getPosts(callback) {
    var getPostsRequest = new XMLHttpRequest();
    getPostsRequest.open('GET', '/api/posts', true);
    getPostsRequest.addEventListener('load', function() {
        callback(JSON.parse(getPostsRequest.responseText));
    });

    getPostsRequest.send();
}

// 由于命名正确，因此无需阅读实际函数即可轻松理解此代码
// getUsers(function(users) {
//     // 对用户执行某些操作
// });
// getPosts(function(posts) {
//     // 对帖子执行某些操作
// });

Nous pouvons simplifier le code ci-dessus. Notez que ces deux fonctions sont presque exactement les mêmes? Nous pouvons appliquer le principe «Ne vous répétez pas» (sec). Cela empêche la confusion.

function fetchJson(url, callback) {
    var request = new XMLHttpRequest();
    request.open('GET', url, true);
    request.addEventListener('load', function() {
        callback(JSON.parse(request.responseText));
    });

    request.send();
}

// 下面的代码仍然很容易理解
// 无需阅读上面的函数
fetchJson('/api/users', function(users) {
    // 对用户执行某些操作
});
fetchJson('/api/posts', function(posts) {
    // 对帖子执行某些操作
});

Et si nous voulons créer un nouvel utilisateur via une demande de poste? À ce stade, une option consiste à ajouter des paramètres facultatifs à la fonction, introduisant ainsi une nouvelle logique à la fonction, ce qui le rend trop complexe pour devenir une fonction. Une autre option consiste à créer une nouvelle fonction spécifiquement pour les demandes de poste, ce qui entraînera la duplication de code.

Nous pouvons obtenir les avantages des deux par la programmation orientée objet, ce qui nous permet de créer un objet à usage unique configurable tout en maintenant sa maintenabilité.

Remarque: Si vous avez besoin d'un débutant en JavaScript orienté objet, je recommande cette vidéo: le guide faisant autorité pour JavaScript orienté objet

Programmation orientée objet

Considérez les objets, communément appelés classes, qui sont un ensemble de fonctions de contexte. Un objet est idéal pour installer un fichier dédié. Dans notre exemple, nous pouvons construire un wrapper de base pour XMLHTTPRequest.

httprequest.js

function HttpRequest(url) {
    this.request = new XMLHttpRequest();

    this.body = undefined;
    this.method = HttpRequest.METHOD_GET;
    this.url = url;

    this.responseParser = undefined;
}

HttpRequest.METHOD_GET = 'GET';
HttpRequest.METHOD_POST = 'POST';

HttpRequest.prototype.setMethod = function(method) {
    this.method = method;
    return this;
};

HttpRequest.prototype.setBody = function(body) {
    if (typeof body === 'object') {
        body = JSON.stringify(body);
    }

    this.body = body;
    return this;
};

HttpRequest.prototype.setResponseParser = function(responseParser) {
    if (typeof responseParser !== 'function') return;

    this.responseParser = responseParser;
    return this;
};

HttpRequest.prototype.send = function(callback) {
    this.request.addEventListener('load', function() {
        if (this.responseParser) {
            callback(this.responseParser(this.request.responseText));
        } else {
            callback(this.request.responseText);
        }
    }, false);

    this.request.open(this.method, this.url, true);
    this.request.send(this.body);
    return this;
};

app.js

new HttpRequest('/users')
    .setResponseParser(JSON.parse)
    .send(function(users) {
        // 对用户执行某些操作
    });

new HttpRequest('/posts')
    .setResponseParser(JSON.parse)
    .send(function(posts) {
        // 对帖子执行某些操作
    });

// 创建一个新用户
new HttpRequest('/user')
    .setMethod(HttpRequest.METHOD_POST)
    .setBody({
        name: 'Tim',
        email: 'info@example.com'
    })
    .setResponseParser(JSON.parse)
    .send(function(user) {
        // 对新用户执行某些操作
    });

La classe HttpRequest créée ci-dessus est désormais très configurable et peut être appliquée à bon nombre de nos appels API. Bien que l'implémentation (une série d'appels de méthode de chaîne) soit plus complexe, la fonctionnalité de la classe est facile à entretenir. L'équilibre entre l'implémentation et la réutilisabilité peut être difficile et spécifique au projet.

Le motif de conception est un excellent ajout lors de l'utilisation de la POO. Bien qu'ils n'améliorent pas la lisibilité par eux-mêmes, la cohérence va!

grammaire artificielle

Fichiers, fonctions, objets, ce ne sont que des lignes approximatives. Ils rendent votre code facile à scanner . Rendre le code plus facile à lire est un art plus méticuleux. Les moindres détails peuvent avoir un impact significatif. Par exemple, limiter la longueur de votre ligne à 80 caractères est une solution facile, généralement appliquée par l'éditeur via des lignes verticales. Mais il y en a plus! nom

La dénomination appropriée peut conduire à une reconnaissance instantanée sans trouver la valeur ou le rôle de la fonction.

Les fonctions utilisent généralement la nomenclature de chameaux. Cela aide généralement à commencer par un verbe puis le sujet.

// 从 API 加载用户数据
var getUsersRequest = new XMLHttpRequest();
getUsersRequest.open('GET', '/api/users', true);
getUsersRequest.addEventListener('load', function() {
    // 对用户执行某些操作
});

getUsersRequest.send();

//---------------------------------------------------
// 不同的功能从这里开始。也许
// 这是一个分成文件的时机。
//---------------------------------------------------

// 从 API 加载帖子数据
var getPostsRequest = new XMLHttpRequest();
getPostsRequest.open('GET', '/api/posts', true);
getPostsRequest.addEventListener('load', function() {
    // 对帖子执行某些操作
});

getPostsRequest.send();

Pour les noms de variables, essayez d'appliquer la méthode pyramide inversée. Le sujet est placé devant et les attributs sont placés à l'arrière.

// 从 API 加载用户数据
function getUsers(callback) {
    var getUsersRequest = new XMLHttpRequest();
    getUsersRequest.open('GET', '/api/users', true);
    getUsersRequest.addEventListener('load', function() {
        callback(JSON.parse(getUsersRequest.responseText));
    });

    getUsersRequest.send();
}

// 从 API 加载帖子数据
function getPosts(callback) {
    var getPostsRequest = new XMLHttpRequest();
    getPostsRequest.open('GET', '/api/posts', true);
    getPostsRequest.addEventListener('load', function() {
        callback(JSON.parse(getPostsRequest.responseText));
    });

    getPostsRequest.send();
}

// 由于命名正确，因此无需阅读实际函数即可轻松理解此代码
// getUsers(function(users) {
//     // 对用户执行某些操作
// });
// getPosts(function(posts) {
//     // 对帖子执行某些操作
// });

Il est également important de pouvoir faire la distinction entre les variables ordinaires et spéciales. Par exemple, les noms des constantes sont généralement écrits en majuscules et soulignés.

function fetchJson(url, callback) {
    var request = new XMLHttpRequest();
    request.open('GET', url, true);
    request.addEventListener('load', function() {
        callback(JSON.parse(request.responseText));
    });

    request.send();
}

// 下面的代码仍然很容易理解
// 无需阅读上面的函数
fetchJson('/api/users', function(users) {
    // 对用户执行某些操作
});
fetchJson('/api/posts', function(posts) {
    // 对帖子执行某些操作
});

Les classes utilisent généralement la nomenclature de camel, en commençant par des lettres majuscules.

function HttpRequest(url) {
    this.request = new XMLHttpRequest();

    this.body = undefined;
    this.method = HttpRequest.METHOD_GET;
    this.url = url;

    this.responseParser = undefined;
}

HttpRequest.METHOD_GET = 'GET';
HttpRequest.METHOD_POST = 'POST';

HttpRequest.prototype.setMethod = function(method) {
    this.method = method;
    return this;
};

HttpRequest.prototype.setBody = function(body) {
    if (typeof body === 'object') {
        body = JSON.stringify(body);
    }

    this.body = body;
    return this;
};

HttpRequest.prototype.setResponseParser = function(responseParser) {
    if (typeof responseParser !== 'function') return;

    this.responseParser = responseParser;
    return this;
};

HttpRequest.prototype.send = function(callback) {
    this.request.addEventListener('load', function() {
        if (this.responseParser) {
            callback(this.responseParser(this.request.responseText));
        } else {
            callback(this.request.responseText);
        }
    }, false);

    this.request.open(this.method, this.url, true);
    this.request.send(this.body);
    return this;
};

Un petit détail est l'abréviation. Certains choisissent de capitaliser l'abréviation, tandis que d'autres choisissent de s'en tenir à la nomenclature Camel. L'utilisation du premier peut rendre plus difficile l'identification d'abréviations ultérieures.

simplicité et optimisation

Dans de nombreuses bases de code, vous pouvez rencontrer un code "spécial" pour réduire le nombre de caractères ou améliorer les performances de votre algorithme.

Le code unique est un exemple de code concis. Malheureusement, ils comptent généralement sur des astuces ou une syntaxe obscure. Les opérateurs ternaires imbriqués vus ci-dessous sont un exemple courant. Bien qu'il soit concis, il peut également prendre une ou deux secondes pour comprendre son effet par rapport à une déclaration IF normale. Soyez prudent avec les raccourcis de syntaxe.

new HttpRequest('/users')
    .setResponseParser(JSON.parse)
    .send(function(users) {
        // 对用户执行某些操作
    });

new HttpRequest('/posts')
    .setResponseParser(JSON.parse)
    .send(function(posts) {
        // 对帖子执行某些操作
    });

// 创建一个新用户
new HttpRequest('/user')
    .setMethod(HttpRequest.METHOD_POST)
    .setBody({
        name: 'Tim',
        email: 'info@example.com'
    })
    .setResponseParser(JSON.parse)
    .send(function(user) {
        // 对新用户执行某些操作
    });

La micro-optimisation est une optimisation des performances et a généralement peu d'impact. Dans la plupart des cas, ils ne sont pas aussi faciles à lire que les équivalents à basse performance.

function getApiUrl() { /* ... */ }
function setRequestMethod() { /* ... */ }
function findItemsById(n) { /* ... */ }
function hideSearchForm() { /* ... */ }

Les compilateurs JavaScript sont très bons pour optimiser le code pour nous, et ils s'améliorent constamment. À moins que la différence entre le code non optimisé et le code optimisé ne soit évidente (généralement après des milliers ou des millions d'opérations), il est recommandé de choisir un code plus facile à lire.

non-code

C'est ironique, mais une meilleure façon de garder le code lisible est d'ajouter une syntaxe qui ne sera pas exécutée. Appelons cela non-code.

espace

Je suis presque sûr que chaque développeur a eu d'autres développeurs à la fournir, ou à la vérification du code compressé pour un certain site Web - code où la plupart des espaces sont supprimés. Il peut être assez surprenant de rencontrer cela pour la première fois. Dans différents domaines des arts visuels, tels que la conception et la typographie, les espaces vierges sont aussi importants que le remplissage. Vous devez trouver un équilibre délicat entre les deux. Les perceptions de cet équilibre varient selon l'entreprise, l'équipe et les développeurs. Heureusement, certaines règles sont généralement reconnues par :

une expression par ligne,

• le contenu du bloc en retrait,
• Des ruptures de ligne supplémentaires peuvent être utilisées pour séparer les sections de code.
toute autre règle doit être discutée avec toute personne avec qui vous travaillez. Quel que soit le style de code avec lequel vous êtes d'accord, la cohérence est essentielle.

Commentaires

var element = document.getElementById('body'),
    elementChildren = element.children,
    elementChildrenCount = elementChildren.length;

// 定义一组颜色时，我在变量前加“color”前缀
var colorBackground = 0xFAFAFA,
    colorPrimary = 0x663399;

// 定义一组背景属性时，我使用 background 作为基准
var backgroundColor = 0xFAFAFA,
    backgroundImages = ['foo.png', 'bar.png'];

// 上下文可以改变一切
var headerBackgroundColor = 0xFAFAFA,
    headerTextColor = 0x663399;

Comme les espaces, les commentaires peuvent être un excellent moyen de fournir un peu d'espace pour votre code et vous permettent également d'ajouter des détails à votre code. Assurez-vous d'ajouter un commentaire à afficher:

Interprétation et argumentation de codes non évidents,

• Correction des erreurs ou des exceptions résolues et des sources disponibles.

Toutes les correctifs ne sont pas évidents. L'ajout d'informations supplémentaires peut clarifier beaucoup:

var URI_ROOT = window.location.href;

// 从 API 加载用户数据
var getUsersRequest = new XMLHttpRequest();
getUsersRequest.open('GET', '/api/users', true);
getUsersRequest.addEventListener('load', function() {
    // 对用户执行某些操作
});

getUsersRequest.send();

//---------------------------------------------------
// 不同的功能从这里开始。也许
// 这是一个分成文件的时机。
//---------------------------------------------------

// 从 API 加载帖子数据
var getPostsRequest = new XMLHttpRequest();
getPostsRequest.open('GET', '/api/posts', true);
getPostsRequest.addEventListener('load', function() {
    // 对帖子执行某些操作
});

getPostsRequest.send();

Document en ligne

Lors de la rédaction d'un logiciel orienté objet, des documents en ligne, comme les commentaires ordinaires, peuvent fournir un espace de respiration pour le code. Ils aident également à clarifier l'objectif et les détails d'un attribut ou d'une méthode. De nombreux IDE les utilisent pour les invites et les outils de document générés les utilisent également! Quelle que soit la raison, rédiger un document est une excellente pratique.

// 从 API 加载用户数据
function getUsers(callback) {
    var getUsersRequest = new XMLHttpRequest();
    getUsersRequest.open('GET', '/api/users', true);
    getUsersRequest.addEventListener('load', function() {
        callback(JSON.parse(getUsersRequest.responseText));
    });

    getUsersRequest.send();
}

// 从 API 加载帖子数据
function getPosts(callback) {
    var getPostsRequest = new XMLHttpRequest();
    getPostsRequest.open('GET', '/api/posts', true);
    getPostsRequest.addEventListener('load', function() {
        callback(JSON.parse(getPostsRequest.responseText));
    });

    getPostsRequest.send();
}

// 由于命名正确，因此无需阅读实际函数即可轻松理解此代码
// getUsers(function(users) {
//     // 对用户执行某些操作
// });
// getPosts(function(posts) {
//     // 对帖子执行某些操作
// });

Problème de rappel

Les événements

et les appels asynchrones sont des caractéristiques puissantes de JavaScript, mais cela rend généralement le code plus difficile à lire.

Les appels asynchrones sont généralement fournis à l'aide de rappels. Parfois, vous voulez les exécuter dans l'ordre, ou attendre que tous les appels asynchrones soient prêts.

function fetchJson(url, callback) {
    var request = new XMLHttpRequest();
    request.open('GET', url, true);
    request.addEventListener('load', function() {
        callback(JSON.parse(request.responseText));
    });

    request.send();
}

// 下面的代码仍然很容易理解
// 无需阅读上面的函数
fetchJson('/api/users', function(users) {
    // 对用户执行某些操作
});
fetchJson('/api/posts', function(posts) {
    // 对帖子执行某些操作
});

Promesse Object a été introduit dans ES2015 (également connu sous le nom d'ES6) pour résoudre les deux problèmes. Il vous permet d'aplatir les demandes asynchrones imbriquées.

function HttpRequest(url) {
    this.request = new XMLHttpRequest();

    this.body = undefined;
    this.method = HttpRequest.METHOD_GET;
    this.url = url;

    this.responseParser = undefined;
}

HttpRequest.METHOD_GET = 'GET';
HttpRequest.METHOD_POST = 'POST';

HttpRequest.prototype.setMethod = function(method) {
    this.method = method;
    return this;
};

HttpRequest.prototype.setBody = function(body) {
    if (typeof body === 'object') {
        body = JSON.stringify(body);
    }

    this.body = body;
    return this;
};

HttpRequest.prototype.setResponseParser = function(responseParser) {
    if (typeof responseParser !== 'function') return;

    this.responseParser = responseParser;
    return this;
};

HttpRequest.prototype.send = function(callback) {
    this.request.addEventListener('load', function() {
        if (this.responseParser) {
            callback(this.responseParser(this.request.responseText));
        } else {
            callback(this.request.responseText);
        }
    }, false);

    this.request.open(this.method, this.url, true);
    this.request.send(this.body);
    return this;
};

Bien que nous ayons introduit un autre code, il est plus facile à expliquer correctement. Vous pouvez en savoir plus sur la promesse ici: JavaScript devient asynchrone (et grand)

es6 / es2015

Si vous comprenez la spécification ES2015, vous avez peut-être remarqué que tous les exemples de code de cet article sont des versions plus anciennes (sauf les objets Promise). Bien que ES6 nous offre des fonctionnalités puissantes, il y a encore des problèmes avec la lisibilité.

La syntaxe de flèche gras définit une fonction qui hérite de la valeur de cela à partir de sa portée parentale. Du moins, c'est pourquoi il a été conçu. Il est également tentant de l'utiliser pour définir des fonctions régulières.

new HttpRequest('/users')
    .setResponseParser(JSON.parse)
    .send(function(users) {
        // 对用户执行某些操作
    });

new HttpRequest('/posts')
    .setResponseParser(JSON.parse)
    .send(function(posts) {
        // 对帖子执行某些操作
    });

// 创建一个新用户
new HttpRequest('/user')
    .setMethod(HttpRequest.METHOD_POST)
    .setBody({
        name: 'Tim',
        email: 'info@example.com'
    })
    .setResponseParser(JSON.parse)
    .send(function(user) {
        // 对新用户执行某些操作
    });

Un autre exemple est le reste et la syntaxe répandue.

function getApiUrl() { /* ... */ }
function setRequestMethod() { /* ... */ }
function findItemsById(n) { /* ... */ }
function hideSearchForm() { /* ... */ }

Je veux dire, la spécification ES2015 introduit de nombreuses syntaxes utiles mais obscures, parfois déroutantes, qui facilitent la mauvaise utilisation dans un code unique. Je ne veux pas empêcher que ces fonctionnalités d'être utilisées. J'espère encourager la prudence à les utiliser.

Conclusion

À chaque étape du projet, n'oubliez pas de garder le code lisible et maintenable. Tout, des systèmes de fichiers aux petits choix de syntaxe, est important. Surtout dans une équipe, il est difficile de toujours appliquer toutes les règles. La révision du code peut aider, mais il y a encore de la place pour une erreur humaine. Heureusement, il existe des outils qui peuvent vous aider à le faire!

• jshint - un vérificateur de langue javascript pour garder le code sans erreur
• idiomatique - une norme de style de code populaire, mais vous pouvez déviation de
• EditorConfig - Définit le style de code à travers les éditeurs

En plus des outils de qualité et de style de code, il existe des outils qui peuvent rendre n'importe quel code plus facile à lire. Essayez différents thèmes de mise en évidence de la syntaxe, ou essayez d'utiliser un minimap pour voir un aperçu descendant du script (atome, supports).

Que pensez-vous de l'écriture de code lisible et maintenable? J'aimerais entendre vos pensées dans les commentaires ci-dessous.

FAQ sur le code lisible

Pourquoi le code doit-il être facile à lire pour les humains?

La lisibilité du code est cruciale pour les raisons suivantes. Tout d'abord, cela rend le code plus facile à comprendre, à déboguer et à maintenir. Lorsque le code est lisible, il est plus facile pour d'autres développeurs de comprendre le rôle du code, ce qui est particulièrement important dans des environnements collaboratifs. Deuxièmement, le code très lisible est plus susceptible d'être correct. Si les développeurs peuvent facilement comprendre le code, il est peu probable qu'ils introduisent des erreurs lors de la modification du code. Enfin, le code très lisible est plus facile à tester. Si le code est clair et concis, il est plus facile de déterminer ce qui doit être testé et comment le tester.

Qu'est-ce qui rend les langages de programmation faciles à lire?

La langue est considérée comme facile à lire si elle a une syntaxe claire et concise, utilise des identificateurs significatifs et contient des commentaires qui expliquent l'effet du code. Les langages de haut niveau comme Python et Ruby sont souvent considérés comme faciles à lire car ils utilisent une syntaxe de type anglais et permettent des noms de variables descriptifs clairs. Cependant, il est également possible d'améliorer la lisibilité des langues de bas niveau comme C ou Java grâce à de bonnes pratiques de codage telles que l'indentation cohérente, l'utilisation des espaces et les annotations complètes.

Comment la fonction réduit-elle la quantité de code?

La fonction

peut réduire considérablement la quantité de code en permettant aux développeurs de le réutiliser. Au lieu d'écrire le même code plusieurs fois, écrivez une fonction une fois, puis appelez-le lorsque vous devez effectuer une tâche spécifique. Cela rend non seulement le code plus court et plus facile à lire, mais rend également le code plus facile à maintenir et à déboguer, car tous les modifications ne doivent être apportées qu'en un seul endroit.

Quelle est la différence entre le code machine et les langues de haut niveau?

Le code machine est le langage de programmation de plus bas niveau composé d'un code binaire qui peut être exécuté directement par le processeur central d'un ordinateur (CPU). Les langues de haut niveau, en revanche, sont plus proches des langues humaines et nécessitent qu'ils soient convertis en code machine par un compilateur ou un interprète avant l'exécution. Les langues de haut niveau sont souvent plus faciles à lire et à écrire, et elles fournissent plus d'abstraction avec le matériel, ce qui les rend plus faciles à porter entre différents types de machines.

Comment fonctionnent les interprètes et les compilateurs?

Les interprètes et les compilateurs sont des outils pour convertir les langages de haut niveau en code machine. L'interprète traduit et exécute le code ligne par ligne, ce qui permet un codage interactif et un débogage. Cependant, cela peut être plus lent que la compilation du code. D'un autre côté, le compilateur convertit l'intégralité du programme en code machine avant l'exécution, ce qui peut augmenter la vitesse d'exécution. Cependant, toutes les erreurs de code ne peuvent être découvertes qu'après la compilation du programme entier.

Qu'est-ce que le langage d'assemblage?

Le langage d'assemblage est un langage de programmation de bas niveau qui utilise du code mnémonique pour représenter les instructions de code machine. Chaque langue d'assemblage est spécifique à une architecture informatique spécifique. Bien qu'il soit plus facile à lire que le code machine, il est toujours plus difficile de lire et d'écrire que les langues de haut niveau. Cependant, il permet un contrôle direct du matériel, ce qui est très utile dans certains cas.

Comment améliorer la lisibilité du code?

Il existe plusieurs façons d'améliorer la lisibilité du code. Ces méthodes incluent l'utilisation de variables significatives et de noms de fonction, de mettre en œuvre le code de manière cohérente, de séparer différentes parties du code avec des espaces et de contenir des commentaires qui expliquent le rôle du code. Il est également important de suivre les conventions et les meilleures pratiques du langage de programmation que vous utilisez.

quel rôle les annotations jouent-elles dans la création du code lisible?

Les commentaires jouent un rôle crucial pour rendre le code lisible. Ils fournissent une explication de la fonction du code, les raisons pour lesquelles certaines décisions sont prises et le fonctionnement des pièces de code complexes. Cela peut être très utile pour les autres développeurs qui ont besoin de comprendre et d'utiliser votre code. Cependant, il est important de rendre les commentaires concis et pertinents et de les mettre à jour lorsque le code change.

Comment le code hautement lisible affecte-t-il la collaboration?

Le code très lisible facilite considérablement la collaboration. Lorsque le code est facile à lire, il est plus facile pour les autres développeurs de comprendre et de s'engager dans des contributions. Ceci est particulièrement important dans les grands projets où plusieurs développeurs travaillent sur différentes parties de la base de code. Le code lisible facilite également l'obtention de nouveaux membres de l'équipe dans le groupe car ils peuvent rapidement comprendre ce que fait le code et comment il fonctionne.

Comment le code très lisible affecte-t-il la qualité du logiciel?

Le code très lisible peut considérablement améliorer la qualité du logiciel. Lorsque le code est facile à lire, il est plus facile de repérer et de corriger les erreurs et de s'assurer que le code fait ce qu'il devrait faire. Il facilite également le maintien et l'amélioration du logiciel au fil du temps, car il illustre clairement le rôle de chaque partie du code. Cela peut conduire à des logiciels plus fiables, efficaces et plus puissants.

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!