Rule of three (computer programming) (original) (raw)
三次法则（rule of three）是代码重构的一条经验法则，涉及到当代码片段出现重复时，如何决定是否用一个新的子程序替代之的标准。三次法则的要求是，允许按需直接复制粘贴代码一次，但如果相同的代码片段重复出现三次以上的时候，将其提取出来做成一个子程序就势在必行。马丁·福勒在《重构》一书中介绍了三次法则，并认为这一法则是Don Roberts所提出。 在编程中，由于会提高代码维护的难度，直接复制代码段的习惯并不好；具体来说，当有代码片段需要变更时，代码维护者就必须找出程序中所有与之相同的代码片段，并都进行修改，但这一过程易出差错，而且也常会带来许多麻烦。相对的，如果代码只在一个地方出现，修改起来就容易多了。 这一法则在代码量（即行数）较少（甚至只有一行）的时候还有另一种形式的应用，例如：如果你想调用一个函数，并在调用失败的时候再尝试调用一次，那使用两处调用亦可；但若你想在放弃尝试前至少尝试5次（注意，这里的5符合>=3的要求)，那就应该将其写成循环形式，使代码中只有一个。 诚如所言，
| Property | Value |
|---|---|
| dbo:abstract | La regla de tres ("Tres strikes y tú refactorizas" ) es una regla práctica de refactorización de código para decidir cuándo se deben refactorizar piezas de código similares para evitar la duplicación. Establece que dos instancias de código similar no requieren refactorización, pero cuando se usa un código similar tres veces, debe extraerse en un nuevo procedimiento. La regla fue popularizada por Martin Fowler en Refactoring y atribuida a Don Roberts. La duplicación se considera una mala práctica en la programación porque dificulta el mantenimiento del código. Cuando la regla codificada en un fragmento de código replicado cambia, quien mantiene el código tendrá que cambiarlo en todos los lugares correctamente. Sin embargo, elegir un diseño apropiado para evitar la duplicación podría beneficiarse de más ejemplos para ver patrones.. Al intentar una refactorización prematura se corre el riesgo de seleccionar una abstracción incorrecta, lo que puede resultar en un código peor a medida que surgen nuevos requisitos y eventualmente tendrá que ser refactorizado nuevamente. La regla implica que el costo de mantenimiento ciertamente supera el costo de refactorización y un posible mal diseño cuando hay tres copias, y puede o no puede ser si solo hay dos copias. (es) Rule of three ("Three strikes and you refactor") is a code refactoring rule of thumb to decide when similar pieces of code should be refactored to avoid duplication. It states that two instances of similar code do not require refactoring, but when similar code is used three times, it should be extracted into a new procedure. The rule was popularised by Martin Fowler in Refactoring and attributed to Don Roberts. Duplication is considered a bad practice in programming because it makes the code harder to maintain. When the rule encoded in a replicated piece of code changes, whoever maintains the code will have to change it in all places correctly. However, choosing an appropriate design to avoid duplication might benefit from more examples to see patterns in. Attempting premature refactoring risks selecting a wrong abstraction, which can result in worse code as new requirements emerge and will eventually need to be refactored again. The rule implies that the cost of maintenance certainly outweighs the cost of refactoring and potential bad design when there are three copies, and may or may not if there are only two copies. (en) La règle de trois est une règle empirique de refactorisation de code pour décider quand des morceaux de code similaires doivent être refactorisés pour éviter la duplication de code. Cette règle indique que deux instances de code similaire ne nécessitent pas de refactorisation, mais lorsqu'un code similaire est utilisé trois fois, il doit être extrait dans une nouvelle procédure. La règle a été popularisée par Martin Fowler dans Refactoring et attribuée à Don Roberts. La duplication est considérée comme une mauvaise pratique en programmation car elle rend le code plus difficile à maintenir. Lorsque la règle codée dans un morceau de code répliqué change, celui qui gère le code devra le changer correctement à tous les endroits. Cependant, le choix d'une conception appropriée pour éviter la duplication pourrait bénéficier de plus d'exemples pour voir les modèles. Tenter une refactorisation prématurée risque de sélectionner une mauvaise abstraction, ce qui peut entraîner un code pire lorsque de nouvelles exigences émergent et devront éventuellement être à nouveau refactorisées. La règle implique que le coût de la maintenance l'emporte certainement sur le coût de la refactorisation et une mauvaise conception potentielle lorsqu'il y a trois copies, et peut-être ou non s'il n'y a que deux copies. (fr) In programmazione, la regola del tre è una regola empirica di refactoring, secondo la quale un programma deve essere soggetto a refactoring se una stessa porzione di codice è riutilizzata almeno tre volte nel programma. In tal caso, tale porzione di codice deve essere estratta in una nuova procedura. La regola originale è attribuita a Don Roberts ed è stata resa popolare da Martin Fowler. In accordo col principio DRY, la duplicazione di codice è generalmente considerata una cattiva pratica di programmazione, in quanto rende più difficile e costosa la manutenzione, aumentando la dimensione del codice e richiedendo modifiche ripetute in diverse parti del programma nel caso una parte del codice duplicato debba essere modificata. Il refactoring prematuro, tuttavia, può a sua volta avere un costo dovuto al fatto che, in mancanza di sufficienti esempi d'uso, l'astrazione usata nel refactoring potrebbe non essere sufficientemente generica, richiedendo refactoring addizionale in seguito. (it) 三次法则（rule of three）是代码重构的一条经验法则，涉及到当代码片段出现重复时，如何决定是否用一个新的子程序替代之的标准。三次法则的要求是，允许按需直接复制粘贴代码一次，但如果相同的代码片段重复出现三次以上的时候，将其提取出来做成一个子程序就势在必行。马丁·福勒在《重构》一书中介绍了三次法则，并认为这一法则是Don Roberts所提出。 在编程中，由于会提高代码维护的难度，直接复制代码段的习惯并不好；具体来说，当有代码片段需要变更时，代码维护者就必须找出程序中所有与之相同的代码片段，并都进行修改，但这一过程易出差错，而且也常会带来许多麻烦。相对的，如果代码只在一个地方出现，修改起来就容易多了。 这一法则在代码量（即行数）较少（甚至只有一行）的时候还有另一种形式的应用，例如：如果你想调用一个函数，并在调用失败的时候再尝试调用一次，那使用两处调用亦可；但若你想在放弃尝试前至少尝试5次（注意，这里的5符合>=3的要求)，那就应该将其写成循环形式，使代码中只有一个。 诚如所言， (zh) Правило трьох є емпіричним правилом рефакторингу, яке вказує коли код, що дублюється, слід замінити на підпрограму. Відповідно до правила, код може мати копію, але коли той самий код використовується тричі, він повинен бути перенесений в окрему процедуру. Це правило було введене Мартіном Фаулером і приписується Дону Робертсу. Дублювання в програмуванні є поганою практикою, тому що це робить код негнучким. Однак, рефакторинг коду для виключення дублювання займає багато часу, який може бути витрачений на інші завдання. Але коли код повторюється тричі, і його потрібно змінити, його доведеться змінювати у всіх місцях. Цей процес вразливий до помилок і часто призводить до проблем. Якщо код існує тільки в одному місці, то він може бути легко змінений лише в цьому місці. Правило припускає, що ціна підтримки, безумовно, перевищує ціну рефакторингу, коли є три копії коду, і можливо перевищує (або ні), якщо є дві копії. Це правило, зазвичай, застосовується тільки до невеликого числа рядків коду або навіть окремих рядків коду. Наприклад, якщо програма викликає функцію, а потім викликає її знову, коли сталася помилка при першому виклику, то мати два місця виклику функції є прийнятним. Однак, якщо функцію потрібно викликати п'ять разів, перш ніж згенерувати помилку, то в такому випадку всі виклики повинні бути замінені на цикл з тілом, яке містить один виклик. (uk) |
| dbo:wikiPageID | 15267164 (xsd:integer) |
| dbo:wikiPageLength | 1944 (xsd:nonNegativeInteger) |
| dbo:wikiPageRevisionID | 1112772368 (xsd:integer) |
| dbo:wikiPageWikiLink | dbr:Rule_of_thumb dbr:Don't_repeat_yourself dbc:Computer_programming_folklore dbr:Copy-and-paste_programming dbc:Programming_principles dbr:Code_refactoring dbr:Martin_Fowler_(software_engineer) dbr:Software_maintenance dbr:Code_duplication |
| dbp:wikiPageUsesTemplate | dbt:For dbt:Reflist |
| dcterms:subject | dbc:Computer_programming_folklore dbc:Programming_principles |
| gold:hypernym | dbr:Code |
| rdf:type | yago:Abstraction100002137 yago:Cognition100023271 yago:Concept105835747 yago:Content105809192 yago:Guidepost105848541 yago:Idea105833840 yago:PsychologicalFeature100023100 dbo:Film yago:Rule105846054 yago:WikicatProgrammingRulesOfThumb |
| rdfs:comment | 三次法则（rule of three）是代码重构的一条经验法则，涉及到当代码片段出现重复时，如何决定是否用一个新的子程序替代之的标准。三次法则的要求是，允许按需直接复制粘贴代码一次，但如果相同的代码片段重复出现三次以上的时候，将其提取出来做成一个子程序就势在必行。马丁·福勒在《重构》一书中介绍了三次法则，并认为这一法则是Don Roberts所提出。 在编程中，由于会提高代码维护的难度，直接复制代码段的习惯并不好；具体来说，当有代码片段需要变更时，代码维护者就必须找出程序中所有与之相同的代码片段，并都进行修改，但这一过程易出差错，而且也常会带来许多麻烦。相对的，如果代码只在一个地方出现，修改起来就容易多了。 这一法则在代码量（即行数）较少（甚至只有一行）的时候还有另一种形式的应用，例如：如果你想调用一个函数，并在调用失败的时候再尝试调用一次，那使用两处调用亦可；但若你想在放弃尝试前至少尝试5次（注意，这里的5符合>=3的要求)，那就应该将其写成循环形式，使代码中只有一个。 诚如所言， (zh) La regla de tres ("Tres strikes y tú refactorizas" ) es una regla práctica de refactorización de código para decidir cuándo se deben refactorizar piezas de código similares para evitar la duplicación. Establece que dos instancias de código similar no requieren refactorización, pero cuando se usa un código similar tres veces, debe extraerse en un nuevo procedimiento. La regla fue popularizada por Martin Fowler en Refactoring y atribuida a Don Roberts. (es) La règle de trois est une règle empirique de refactorisation de code pour décider quand des morceaux de code similaires doivent être refactorisés pour éviter la duplication de code. Cette règle indique que deux instances de code similaire ne nécessitent pas de refactorisation, mais lorsqu'un code similaire est utilisé trois fois, il doit être extrait dans une nouvelle procédure. La règle a été popularisée par Martin Fowler dans Refactoring et attribuée à Don Roberts. (fr) Rule of three ("Three strikes and you refactor") is a code refactoring rule of thumb to decide when similar pieces of code should be refactored to avoid duplication. It states that two instances of similar code do not require refactoring, but when similar code is used three times, it should be extracted into a new procedure. The rule was popularised by Martin Fowler in Refactoring and attributed to Don Roberts. (en) In programmazione, la regola del tre è una regola empirica di refactoring, secondo la quale un programma deve essere soggetto a refactoring se una stessa porzione di codice è riutilizzata almeno tre volte nel programma. In tal caso, tale porzione di codice deve essere estratta in una nuova procedura. La regola originale è attribuita a Don Roberts ed è stata resa popolare da Martin Fowler. (it) Правило трьох є емпіричним правилом рефакторингу, яке вказує коли код, що дублюється, слід замінити на підпрограму. Відповідно до правила, код може мати копію, але коли той самий код використовується тричі, він повинен бути перенесений в окрему процедуру. Це правило було введене Мартіном Фаулером і приписується Дону Робертсу. (uk) |
| rdfs:label | Regla de tres (programación informática) (es) Règle de trois (programmation informatique) (fr) Regola del tre (programmazione) (it) Rule of three (computer programming) (en) 三次法则 (程序设计) (zh) Правило трьох (інформатика) (uk) |
| owl:sameAs | freebase:Rule of three (computer programming) wikidata:Rule of three (computer programming) dbpedia-es:Rule of three (computer programming) dbpedia-fr:Rule of three (computer programming) dbpedia-hu:Rule of three (computer programming) dbpedia-it:Rule of three (computer programming) dbpedia-uk:Rule of three (computer programming) dbpedia-zh:Rule of three (computer programming) https://global.dbpedia.org/id/4uLg7 |
| prov:wasDerivedFrom | wikipedia-en:Rule_of_three_(computer_programming)?oldid=1112772368&ns=0 |
| foaf:isPrimaryTopicOf | wikipedia-en:Rule_of_three_(computer_programming) |
| is dbo:wikiPageDisambiguates of | dbr:Rule_of_three |
| is dbo:wikiPageRedirects of | dbr:Rule_of_three_(programming) |
| is dbo:wikiPageWikiLink of | dbr:Don't_repeat_yourself dbr:Duplicate_code dbr:Rule_of_three dbr:Rule_of_three_(programming) |
| is foaf:primaryTopic of | wikipedia-en:Rule_of_three_(computer_programming) |