Categorías
Python

Python Calidad Código: Herramientas y Buenas Prácticas

 

Tabla de Contenidos

  • ¿Cuál es el código de calidad?
  • Por qué código hace Calidad materia? No hace lo que se supone que doIT no contener defectos y problemsIt es difícil de leer, mantener o extender
  • No hace lo que se supone que hacer
  • Sí contiene defectos y los problemas
  • es difícil de leer, mantener o extender
  • Cómo mejorar Código Python QualityStyle GuidesLinters
  • guías de estilo
  • Linters
  • Cuando puedo comprobar mi código de Calidad? Como usted WriteBefore Usted pruebas de control En CodeWhen Operando
  • a medida que escribe
  • antes de la facturación Código
  • Cuando Ejecución de pruebas
  • Conclusión
  • no hace lo que se supone que hacer
  • Sí contiene defectos y problemas
  • es difícil de leer, mantener o extender
  • guías de estilo
  • Linters
  • a medida que escribe
  • antes de la facturación Código
  • al ejecutar Pruebas de

En este artículo, vamos a identificar el código Python de alta calidad y le mostramos cómo mejorar la calidad de su propio código.

Vamos a analizar y comparar las herramientas que puede utilizar para tomar su código al siguiente nivel. Si usted ha estado usando Python por un tiempo, o acaba de empezar, se puede beneficiar de las prácticas y herramientas dicho aquí.

¿Qué es el código de calidad?

supuesto que desea código de calidad, ¿quién no? Sin embargo, para mejorar la calidad del código, tenemos que definir lo que es.

Una rápida búsqueda en Google arroja muchos resultados que definen la calidad del código. Como resultado, el término puede significar muchas cosas diferentes para personas.

Una forma de tratar de definir la calidad del código es mirar en un extremo del espectro: código de alta calidad. Con suerte, puede ponerse de acuerdo sobre los siguientes identificadores de códigos de alta calidad:

  • Se hace lo que se supone que debe hacer.
  • No contiene defectos o problemas.
  • Es fácil de leer, mantener y extender.

Estos tres identificadores, aunque simplista, parece ser el acuerdo general. En un esfuerzo por ampliar estas ideas, nos dejó ahondar en qué cada uno materias en el ámbito de software.

¿Por qué el código de calidad de la agencia?

Para determinar qué código de alta calidad es importante, Vamos a revisar esos identificadores. Veremos lo que sucede cuando el código no cumple con ellos.

No hace lo que se supone que hacer requisitos

reuniones

es la base de cualquier producto, software o de otra manera. Hacemos software para hacer algo. Si, al final, no lo haga … así que definitivamente no es de alta calidad. Si no cumple con los requisitos básicos, es difícil incluso llamarlo baja calidad.

Que contiene defectos y problemas

Si algo está utilizando tiene problemas o le causa problemas, es probable que no lo llamaría de alta calidad. De hecho, si es bastante malo, es posible que deje de usar por completo.

En aras de no usar el software como un ejemplo, digamos que su vacío funciona muy bien en la alfombra regular. Se limpia todo el pelo polvo y gato. Una fatídica noche el gato golpea sobre una planta, derramando suciedad por todas partes. Cuando intenta utilizar la aspiradora para limpiar el montón de tierra, se rompe, arrojando la suciedad por todas partes.

mientras que el vacío trabajó bajo algunas circunstancias, no manejar de manera eficiente la carga extra de vez en cuando. Por lo tanto, usted no diría que es una aspiradora de alta calidad.

Ese es un problema que queremos evitar en nuestro código. Si las cosas se rompen en casos extremos y defectos causan un comportamiento no deseado, no tenemos un producto de alta calidad.

Es difícil de leer, mantener o extender

Imagínese esto: un cliente solicita una nueva característica. La persona que escribió el código original se ha ido. La persona que los ha reemplazado ahora tiene que tener sentido del código que ya está allí. Esa persona es usted.

Si el código es fácil de comprender, usted será capaz de analizar el problema y llegar a una solución mucho más rápida. Si el código es complejo y complicado, es probable que tome más tiempo y, posiblemente, hacer algunas suposiciones erróneas.

También es bueno si es fácil de agregar la nueva función sin alterar las características anteriores. Si el código es no fácil de extender, su nueva característica podría romper otras cosas.

Nadie quiere para estar en la posición en la que tienen que leer, mantener o ampliar el código de baja calidad. Esto significa que más dolores de cabeza y más trabajo para todos. bastante malo de

Es que usted tiene que tratar con el código de baja calidad, pero no pone a otra persona en la misma situación. Puede mejorar la calidad del código que se escribe.

Si trabaja con un equipo de desarrolladores, puede empezar a poner en métodos que aseguren la calidad del código mejor en general. Asumiendo que usted tiene su apoyo, por supuesto. Puede que tenga que ganar algunas personas más (no dude en enviar este artículo ).

Cómo mejorar Código Python Calidad

Hay algunas cosas a tener en cuenta en nuestro viaje de código de alta calidad. En primer lugar, este viaje no es uno de pura objetividad. Hay algunos sentimientos fuertes de lo que parece código de alta calidad similares.

Mientras todo el mundo se espera que puedan ponerse de acuerdo sobre los identificadores se mencionó anteriormente, la forma en que consiguen alcanzar es un camino subjetiva. Los temas más pertinaz por lo general surgen cuando se habla de la consecución de la legibilidad, el mantenimiento y extensibilidad.

Así que tener en cuenta que mientras que este artículo va a tratar de mantenerse objetivo en todas partes, hay un mundo muy dogmático-que hay cuando se trata de código.

Por lo tanto, vamos a empezar con el tema más obstinado: estilo de código.

guías de estilo

Ah, sí. La vieja pregunta: espacios o tabuladores?

Independientemente de su opinión personal sobre la forma de representar el espacio en blanco, es seguro asumir que al menos consistencia falta en el código.

Una guía de estilo sirve para el propósito de definir una forma coherente de escribir el código. Normalmente esto es todo estética, lo que significa que no cambia el resultado lógico del código. Si bien, algunas opciones de estilo no evitan errores lógicos comunes. guías

estilo sirven para ayudar a facilitar el objetivo de hacer el código fácil de leer, mantener y extender.

Por lo que va Python, hay una norma bien aceptada. Fue escrito, en parte, por el autor del propio lenguaje de programación Python.

PEP 8 ofrece convenciones de codificación para el código Python. Es bastante común para el código Python a seguir esta guía de estilo. Es un gran lugar para comenzar, puesto que ya está bien definido.

Una hermana Mejora Python Propuesta, PEP 257 describe las convenciones de las cadenas de documentación de Python, que son cadenas destinadas a los módulos de documentos, clases, funciones y métodos. Como un beneficio adicional, si docstrings son consistentes, existen herramientas capaces de generar documentación directamente desde el código.

Todas estas guías hacen es definir una forma de código de estilo. Pero, ¿cómo hacerlo cumplir? Y qué decir de los defectos y problemas en el código, ¿cómo se puede detectar esos? Ahí es donde entran en borra de.

Linters

¿Qué es una desfibradora?

En primer lugar, Hablemos de pelusa. Esos diminutos, pequeños defectos molestos que de alguna manera reciben toda la ropa. Ropa se ve y se siente mucho mejor sin toda esa pelusa. El código no es diferente. Pequeños errores, inconsistencias estilísticas, y la lógica peligrosa no hacen su sentir código grande.

Pero nosotros todos los errores maquillaje. No se puede esperar de si mismo para coger siempre a tiempo. los nombres de variables mal escritas, olvidando un corchete de cierre, de tabulación incorrecta en Python, llamando a una función con un número incorrecto de argumentos, la lista sigue y sigue. Borra de ayudar a identificar las áreas problemáticas.

Además, la mayoría de los editores y del IDE tiene la capacidad de funcionar en el borras de fondo a medida que escribe. Esto resulta en un entorno capaz de resaltado, subrayado, o identificar de otro modo las áreas problemáticas en el código antes de ejecutarlo. Es como una corrección ortográfica avanzada para el código. Se hace hincapié en cuestiones en las líneas onduladas de color rojo al igual que su procesador de textos favorito hace.

Linters analizar código para detectar diversas categorías de pelusa. Esas categorías se pueden definir ampliamente como la siguiente: errores

    Código

  • Código

  • con resultados potencialmente no deseadas
  • patrones de código peligroso
    Código

  • que no se ajusten a las convenciones definidas

También hay herramientas de análisis de código que proporcionan otros puntos de vista en el código. Si bien tal vez no borra de, por definición, estas herramientas se utilizan generalmente de lado a lado con borra de. Ellos también esperan mejorar la calidad del código.

Por último, hay herramientas para formatear automáticamente el código de alguna especificación. Estas herramientas automatizadas garantizan que nuestras mentes humanas inferiores no lo hacen meter la pata convenciones.

Cuáles son mis opciones Linter Por Python?

Antes de ahondar en sus opciones, es importante reconocer que algunos “borra de” son sólo borra de múltiples envasados ​​muy bien juntos. Algunos ejemplos populares de esos combo-borra de son los siguientes:

Flake8 : Capaz de detectar tanto pelusa lógico y estilística. Se añade el estilo y la complejidad de los controles pycodestyle a la detección de pelusa lógica de pyflakes. Combina las siguientes borra de:

  • pyflakes
  • pycodestyle (anteriormente PEP8)
  • Mccabe

Pylama : Una herramienta de auditoría de código compuesto de un gran número de linters y otras herramientas para el análisis del código. Combina lo siguiente:

  • pycodestyle (anteriormente PEP8)
  • pydocstyle (anteriormente pep257)
  • pyflakes
  • Mccabe
  • Pylint
  • radón
  • gjslint

Aquí están algunos borra de stand-alone categorizados con descripciones breves:

y aquí están algunos análisis de código y herramientas de formato:

Comparando Python linters

Vamos a tener una mejor idea de lo borra de diferentes son capaces de atrapar y lo que las miradas de salida como. Para ello, me encontré con el mismo código a través de un puñado de diferentes borra de con la configuración predeterminada.

la RAN código que a través de las borras de está por debajo. Contiene diversas cuestiones lógicas y estilísticos: Código Python

con pelusa Mostrar / Ocultar

1 """
2 code_with_lint.py
3 Example Code with lots of lint!
4 """
5 import io
6 from math import *
7
8
9 from time import time
10
11 some_global_var = 'GLOBAL VAR NAMES SHOULD BE IN ALL_CAPS_WITH_UNDERSCOES'
12
13 def multiply(x, y):
14 """
15 This returns the result of a multiplation of the inputs
16 """
17 some_global_var = 'this is actually a local variable...'
18 result = x* y
19 return result
20 if result == 777:
21 print("jackpot!")
22
23 def is_sum_lucky(x, y):
24 """This returns a string describing whether or not the sum of input is lucky
25 This function first makes sure the inputs are valid and then calculates the
26 sum. Then, it will determine a message to return based on whether or not
27 that sum should be considered "lucky"
28 """
29 if x != None:
30 if y is not None:
31 result = x+y;
32 if result == 7:
33 return 'a lucky number!'
34 else:
35 return( 'an unlucky number!')
36
37 return ('just a normal number')
38
39 class SomeClass:
40
41 def __init__(self, some_arg, some_other_arg, verbose = False):
42 self.some_other_arg = some_other_arg
43 self.some_arg = some_arg
44 list_comprehension = [((100/value)*pi) for value in some_arg if value != 0]
45 time = time()
46 from datetime import datetime
47 date_and_time = datetime.now()
48 return

La comparación siguiente muestra las borras de I utilizados y su tiempo de ejecución para analizar el archivo de arriba. Debo señalar que estos no son todos totalmente comparables, ya que sirven para diferentes propósitos. Pyflakes, por ejemplo, no identifica errores estilísticos como Pylint hace.

Para las salidas de cada uno, ver las siguientes secciones.

Pylint

Pylint es una de las más antiguas borra de (circa 2006) y todavía está bien mantenido. Algunos podrían llamar a este software aguerrido. Ha sido el tiempo suficiente que los contribuyentes han fijado más grandes errores y están bien desarrolladas las funciones básicas.

Las quejas comunes contra Pylint son que es lento, demasiado detallado por defecto, y toma mucho de la configuración para que funcione de la manera deseada. Lentitud un lado, las otras quejas son algo así como un arma de doble filo. Verbosidad puede ser debido a la minuciosidad. Un montón de configuración pueden significar una gran cantidad de capacidad de adaptación a sus preferencias.

Sin más preámbulos, la salida después de ejecutar el código Pylint contra pelusa llena desde arriba:

No config file found, using default configuration
************* Module code_with_lint
W: 23, 0: Unnecessary semicolon (unnecessary-semicolon)
C: 27, 0: Unnecessary parens after 'return' keyword (superfluous-parens)
C: 27, 0: No space allowed after bracket
return( 'an unlucky number!')
^ (bad-whitespace)
C: 29, 0: Unnecessary parens after 'return' keyword (superfluous-parens)
C: 33, 0: Exactly one space required after comma
def __init__(self, some_arg, some_other_arg, verbose = False):
^ (bad-whitespace)
C: 33, 0: No space allowed around keyword argument assignment
def __init__(self, some_arg, some_other_arg, verbose = False):
^ (bad-whitespace)
C: 34, 0: Exactly one space required around assignment
self.some_other_arg = some_other_arg
^ (bad-whitespace)
C: 35, 0: Exactly one space required around assignment
self.some_arg = some_arg
^ (bad-whitespace)
C: 40, 0: Final newline missing (missing-final-newline)
W: 6, 0: Redefining built-in 'pow' (redefined-builtin)
W: 6, 0: Wildcard import math (wildcard-import)
C: 11, 0: Constant name "some_global_var" doesn't conform to UPPER_CASE naming style (invalid-name)
C: 13, 0: Argument name "x" doesn't conform to snake_case naming style (invalid-name)
C: 13, 0: Argument name "y" doesn't conform to snake_case naming style (invalid-name)
C: 13, 0: Missing function docstring (missing-docstring)
W: 14, 4: Redefining name 'some_global_var' from outer scope (line 11) (redefined-outer-name)
W: 17, 4: Unreachable code (unreachable)
W: 14, 4: Unused variable 'some_global_var' (unused-variable)
...
R: 24,12: Unnecessary "else" after "return" (no-else-return)
R: 20, 0: Either all return statements in a function should return an expression, or none of them should. (inconsistent-return-statements)
C: 31, 0: Missing class docstring (missing-docstring)
W: 37, 8: Redefining name 'time' from outer scope (line 9) (redefined-outer-name)
E: 37,15: Using variable 'time' before assignment (used-before-assignment)
W: 33,50: Unused argument 'verbose' (unused-argument)
W: 36, 8: Unused variable 'list_comprehension' (unused-variable)
W: 39, 8: Unused variable 'date_and_time' (unused-variable)
R: 31, 0: Too few public methods (0/2) (too-few-public-methods)
W: 5, 0: Unused import io (unused-import)
W: 6, 0: Unused import acos from wildcard import (unused-wildcard-import)
...
W: 9, 0: Unused time imported from time (unused-import)

Tenga en cuenta que he condensada º es con puntos suspensivos para líneas similares. Es un poco para tomar, pero no es una gran cantidad de pelusa en º es código.

Tenga en cuenta que Pylint prefijos cada una de las áreas problemáticas con una R, C, W, E o F, lo que significa:

  • [R] EFactor para una “buena práctica” violación métrica
  • [C] onvención para el estándar de codificación violación
  • [W] Arning para los problemas estilísticos, o problemas de programación menores
  • [E] rror por cuestiones de programación importantes (es decir, lo más probable error)
  • [F] Atal de errores que impidieron su posterior procesamiento

La lista anterior es directamente desde la guía del usuario Pylint.

pyflakes

pyflakes “hace una promesa sencilla: nunca se quejará de estilo, y tratará muy, muy duro para no emitir falsos positivos”. Esto significa que pyflakes no le dirá acerca docstrings faltantes o nombres de argumentos que no se ajusten a un estilo de nomenclatura. Se centra en cuestiones de códigos lógicos y errores potenciales.

La ventaja aquí es la velocidad. Pyflakes se ejecuta en una fracción del tiempo Pylint toma.

de salida después de correr contra el código de pelusa llena desde arriba:

code_with_lint.py:5: 'io' imported but unused
code_with_lint.py:6: 'from math import *' used; unable to detect undefined names
code_with_lint.py:14: local variable 'some_global_var' is assigned to but never used
code_with_lint.py:36: 'pi' may be undefined, or defined from star imports: math
code_with_lint.py:36: local variable 'list_comprehension' is assigned to but never used
code_with_lint.py:37: local variable 'time' (defined in enclosing scope on line 9) referenced before assignment
code_with_lint.py:37: local variable 'time' is assigned to but never used
code_with_lint.py:39: local variable 'date_and_time' is assigned to but never used

La desventaja aquí es que el análisis de esta salida puede ser un poco más difícil. Los diversos problemas y los errores no están etiquetados o organizados por tipo. Dependiendo de cómo se utiliza esta, que no puede haber un problema en absoluto.

pycodestyle (anteriormente PEP8)

Se utiliza para comprobar algunas convenciones de estilo de PEP8. convenciones de nombres no se comprueban y tampoco lo son las cadenas de documentación. Los errores y las advertencias que hace la captura se clasifican en esta tabla.

de salida después de correr contra el código de pelusa llena desde arriba:

code_with_lint.py:13:1: E302 expected 2 blank lines, found 1
code_with_lint.py:15:15: E225 missing whitespace around operator
code_with_lint.py:20:1: E302 expected 2 blank lines, found 1
code_with_lint.py:21:10: E711 comparison to None should be 'if cond is not None:'
code_with_lint.py:23:25: E703 statement ends with a semicolon
code_with_lint.py:27:24: E201 whitespace after '('
code_with_lint.py:31:1: E302 expected 2 blank lines, found 1
code_with_lint.py:33:58: E251 unexpected spaces around keyword / parameter equals
code_with_lint.py:33:60: E251 unexpected spaces around keyword / parameter equals
code_with_lint.py:34:28: E221 multiple spaces before operator
code_with_lint.py:34:31: E222 multiple spaces after operator
code_with_lint.py:35:22: E221 multiple spaces before operator
code_with_lint.py:35:31: E222 multiple spaces after operator
code_with_lint.py:36:80: E501 line too long (83 > 79 characters)
code_with_lint.py:40:15: W292 no newline at end of file

Lo bueno de este resultado es que la pelusa se etiqueta por categoría. Usted puede optar por ignorar ciertos errores si no se preocupan de adherirse a una convención específica también.

pydocstyle (anteriormente pep257)

muy similar a pycodestyle, excepto que en lugar de comprobar contra las convenciones de estilo de código PEP8, comprueba docstrings contra las convenciones de PEP257. Salida

después de correr contra el código de pelusa llena desde arriba:

code_with_lint.py:1 at module level:
D200: One-line docstring should fit on one line with quotes (found 3)
code_with_lint.py:1 at module level:
D400: First line should end with a period (not '!')
code_with_lint.py:13 in public function `multiply`:
D103: Missing docstring in public function
code_with_lint.py:20 in public function `is_sum_lucky`:
D103: Missing docstring in public function
code_with_lint.py:31 in public class `SomeClass`:
D101: Missing docstring in public class
code_with_lint.py:33 in public method `__init__`:
D107: Missing docstring in __init__

Una vez más, como pycodestyle, etiquetas pydocstyle y categoriza los diversos errores que encuentre. Y la lista no entre en conflicto con cualquier cosa de pycodestyle ya que todos los errores tienen el prefijo D para una cadena de documentación. Una lista de estos errores se puede encontrar aquí.

Código

Sin pelusa

Se puede ajustar el código previamente pelusa llena basándose en la salida de la desfibradora y usted va a terminar con algo como lo siguiente: Código Python

Sin pelusa Mostrar / Ocultar

1 """Example Code with less lint."""
2
3 from math import pi
4 from time import time
5 from datetime import datetime
6
7 SOME_GLOBAL_VAR = 'GLOBAL VAR NAMES SHOULD BE IN ALL_CAPS_WITH_UNDERSCOES'
8
9
10 def multiply(first_value, second_value):
11 """Return the result of a multiplation of the inputs."""
12 result = first_value * second_value
13
14 if result == 777:
15 print("jackpot!")
16
17 return result
18
19
20 def is_sum_lucky(first_value, second_value):
21 """
22 Return a string describing whether or not the sum of input is lucky.
23
24 This function first makes sure the inputs are valid and then calculates the
25 sum. Then, it will determine a message to return based on whether or not
26 that sum should be considered "lucky".
27 """
28 if first_value is not None and second_value is not None:
29 result = first_value + second_value
30 if result == 7:
31 message = 'a lucky number!'
32 else:
33 message = 'an unlucky number!'
34 else:
35 message = 'an unknown number! Could not calculate sum...'
36
37 return message
38
39
40 class SomeClass:
41 """Is a class docstring."""
42
43 def __init__(self, some_arg, some_other_arg):
44 """Initialize an instance of SomeClass."""
45 self.some_other_arg = some_other_arg
46 self.some_arg = some_arg
47 list_comprehension = [
48 ((100/value)*pi)
49 for value in some_arg
50 if value != 0
51 ]
52 current_time = time()
53 date_and_time = datetime.now()
54 print(f'created SomeClass instance at unix time: {current_time}')
55 print(f'datetime: {date_and_time}')
56 print(f'some calculated values: {list_comprehension}')
57
58 def some_public_method(self):
59 """Is a method docstring."""
60 pass
61
62 def some_other_public_method(self):
63 """Is a method docstring."""
64 pass

Ese código es pelusa libre de acuerdo con los linters anteriores. Mientras que la lógica misma es en su mayoría sin sentido, se puede ver que, como mínimo, la consistencia se hace cumplir.

En el caso anterior, nos encontramos borra de después de escribir todo el código. Sin embargo, esa no es la única manera de ir sobre la comprobación de la calidad del código.

Cuando puedo comprobar mi código de Calidad?

Puede comprobar la calidad de su código:

  • Como lo escribe
  • Cuando se comprueba en
  • Cuando se está ejecutando sus pruebas útil disponer de borra de
  • de

que se ejecute en contra de su código de frecuencia. Si la automatización y la coherencia no están allí, es fácil para un equipo grande o proyecto para perder de vista el objetivo y comenzar a crear código de calidad inferior. Ocurre lentamente, por supuesto. Algunos lógica mal escrito o tal vez algo de código con el formato que no coincide con el código vecina. Con el tiempo, todo lo que se acumula pelusa. Con el tiempo, puede quedar atascado con algo que de errores, difícil de leer, difícil de solucionar, y un dolor de mantener.

Para evitar esto, el control de calidad de código a menudo!

a medida que escribe

Se puede utilizar como borras de escribir código, pero la configuración de su entorno para hacerlo puede llevar algo de trabajo extra. Por lo general es una cuestión de encontrar el plugin para el IDE o editor de elección. De hecho, la mayoría de los entornos de desarrollo ya habrán borra de construida en

Aquí hay algo de información general sobre Python pelusa de varios editores:.

  • sublime texto
  • Código VS
  • Atom
  • Vim
  • Emacs

antes de la facturación código

Si está usando Git, ganchos Git se puede configurar para ejecutar sus borras de antes de comprometerse. Otros sistemas de control de versiones tienen métodos similares para ejecutar secuencias de comandos antes o después de algún tipo de acción en el sistema. Puede utilizar estos métodos para bloquear cualquier nuevo código que no cumple con los estándares de calidad.

Si bien esto puede parecer drástico, obligando a cada bit de código a través de una proyección de pelusa es un paso importante para garantizar la calidad continua. La automatización de que el cribado en la puerta de entrada a su código puede ser la mejor manera de evitar el código de pelusa llena.

Cuando Ejecución de pruebas

También puede colocar directamente en borra de cualquier sistema que puede usar para la integración continua. Las borras de se pueden configurar a fallar la acumulación si el código no cumple con los estándares de calidad.

Una vez más, esto puede parecer una medida drástica, sobre todo si ya hay un montón de errores de borra en el código existente. Para combatir esto, algunos sistemas de integración continua le permitirá la opción de no solamente la acumulación si el nuevo código aumenta el número de errores de borra que ya estaban presentes. De esa manera usted puede comenzar a mejorar la calidad sin tener que hacer toda una reescritura de su base de código existente.

Conclusión

código de alta calidad hace lo que tiene que hacer sin romperse. Es fácil de leer, mantener y extender. Que funciona sin problemas o defectos y está escrito para que sea más fácil para la siguiente persona para trabajar.

Con suerte no hace falta decir que usted debe esforzarse por tener tal código de alta calidad. Afortunadamente, existen métodos y herramientas para ayudar a mejorar la calidad del código. guías

estilo va a dar consistencia a su código. PEP8 es un gran punto de partida para Python. Linters le ayudarán a identificar las áreas problemáticas y contradicciones. Puede utilizar borra de todo el proceso de desarrollo, incluso la automatización de ellas al código pelusa llena de bandera antes de que llegue demasiado lejos.

Tener quejan de borra de estilo también evita la necesidad de discusiones durante las revisiones de código de estilo. Algunas personas pueden encontrar más fácil para recibir comentarios espontáneos de estas herramientas en lugar de un miembro del equipo. Además, algunos miembros del equipo no pueden querer estilo “nitpick” durante las revisiones de código. Borra de evitar la política, a ahorrar tiempo, y se quejan de cualquier inconsistencia.

Además, todas las borras de mencionadas en este artículo tiene varias opciones de línea de comandos y configuraciones que le permiten adaptar la herramienta a su gusto. Puede ser tan estricto o tan floja como desee, que es una cosa importante a realizar.

Mejorar la calidad del código es un proceso. Usted puede tomar medidas para mejorar sin rechazando por completo todo el código no conformes. La conciencia es un gran primer paso. Solo se necesita una persona, al igual que, a primera cuenta de lo importante código de alta calidad es.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *