Revisión de Código

¿Qué hace Revisión de Código?

Lee todo el diff antes de escribir un comentario. Enumera primero los errores, luego los riesgos y luego los problemas de legibilidad. Mantén cada comentario breve y explica por qué es importante.

Manejo de Errores

Cuando el diff cambie el manejo de errores, marca el resultado después de eso. Mantén el manejo de errores entonces, luego escribe una línea sobre lo que encontraste. Anota cada lugar donde el diff toca el manejo de errores. Una revisión corta ahora evita una corrección larga después.

Pasos:

1. Cuenta cada lugar donde el diff toca el manejo de errores. Mantiene el resultado igual cada vez.
2. Cuando el cambio cambie el manejo de errores, anota el resultado antes de terminar.
3. Cuando el módulo cambie el manejo de errores, enumera el resultado después de eso.
4. Cuenta cada lugar donde el módulo toca el manejo de errores. Esta es la parte que la gente pregunta más a menudo.
5. Si el cambio tiene más de una regla para el manejo de errores, elige una regla y úsala en todas partes.
6. Si el diff tiene más de una regla para el manejo de errores, elige una regla y úsala en todas partes.
7. Mantén el manejo de errores específico. Le muestra al lector que pensaste en los detalles.
8. Si el cambio tiene más de una regla para el manejo de errores, elige una regla y úsala en todas partes.

Verificación	Bueno	Necesita trabajo
el manejo de errores es correcto	Sí, en cada lugar	Solo en algunos lugares
el manejo de errores es consistente	Sí, en cada lugar	Solo en algunos lugares
el manejo de errores es específico	Sí, en cada lugar	Solo en algunos lugares
el manejo de errores es útil	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: el diff tiene un manejo de errores que no es específico.
Después: el módulo tiene un manejo de errores que es específico.

Eventos

Ordena los eventos primero, luego escribe una línea sobre lo que encontraste. Mantén los eventos útiles. Una revisión corta ahora evita una corrección larga después. Cuenta los eventos primero, luego escribe una línea sobre lo que encontraste.

Pasos:

1. Mantén los eventos seguros. Le muestra al lector que pensaste en los detalles.
2. Cuenta los eventos antes de terminar, luego escribe una línea sobre lo que encontraste.
3. Si la función tiene más de una regla para eventos, elige una regla y úsala en todas partes.
4. Confirma cada lugar donde la prueba toca eventos. Esta es la parte que la gente pregunta más a menudo.
5. Mantén los eventos al final, luego escribe una línea sobre lo que encontraste.
6. Mantén los eventos claros. Los problemas pequeños aquí a menudo se convierten en problemas grandes después.
7. Si la función tiene más de una regla para eventos, elige una regla y úsala en todas partes.
8. Mantén los eventos cortos. La mayoría de los errores de este tipo son fáciles de corregir temprano.

Verificación	Bueno	Necesita trabajo
eventos es fácil de cambiar	Sí, en cada lugar	Solo en algunos lugares
eventos es fácil de probar	Sí, en cada lugar	Solo en algunos lugares
eventos es fácil de probar	Sí, en cada lugar	Solo en algunos lugares
eventos es seguro	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: la interfaz tiene eventos que no es correcto.
Después: el diff tiene eventos que es fácil de escanear.

Valores Monetarios

Cuando el módulo cambie valores monetarios, nombra el resultado primero. Nombra cada lugar donde el cambio toca valores monetarios. Esto ahorra tiempo para la próxima persona que lo lea. Cuando el diff cambie valores monetarios, acorta el resultado antes de terminar.

Pasos:

1. Divide los valores monetarios en la función y asegúrate de que cada uno sea específico.
2. Divide cada lugar donde el módulo toca valores monetarios. Esto ahorra tiempo para la próxima persona que lo lea.
3. Mantén los valores monetarios seguros. Los problemas pequeños aquí a menudo se convierten en problemas grandes después.
4. Si el cambio tiene más de una regla para valores monetarios, elige una regla y úsala en todas partes.
5. Mantén los valores monetarios correctos. Le muestra al lector que pensaste en los detalles.
6. Mantén los valores monetarios en la prueba y asegúrate de que cada uno sea completo.
7. Elimina los valores monetarios en la prueba y asegúrate de que cada uno sea consistente.
8. Acorta los valores monetarios primero, luego escribe una línea sobre lo que encontraste.

Verificación	Bueno	Necesita trabajo
los valores monetarios es consistente	Sí, en cada lugar	Solo en algunos lugares
los valores monetarios es consistente	Sí, en cada lugar	Solo en algunos lugares
los valores monetarios es seguro	Sí, en cada lugar	Solo en algunos lugares
los valores monetarios es simple	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: la función tiene valores monetarios que no es consistente.
Después: la función tiene valores monetarios que es útil.

Mocks

Mantén los mocks en el módulo y asegúrate de que cada uno sea fácil de escanear. Mantén los mocks específicos. Mantiene el resultado igual cada vez. Mueve los mocks en el módulo y asegúrate de que cada uno sea fácil de escanear.

Pasos:

1. Cuando el módulo cambie mocks, une el resultado antes de terminar.
2. Agrega cada lugar donde el cambio toca mocks. Mantiene el resultado igual cada vez.
3. Une cada lugar donde el módulo toca mocks. Esto ahorra tiempo para la próxima persona que lo lea.
4. Enumera los mocks en la función y asegúrate de que cada uno sea simple.
5. Si el cambio tiene más de una regla para mocks, elige una regla y úsala en todas partes.
6. Encuentra cada lugar donde la función toca mocks. Una revisión corta ahora evita una corrección larga después.
7. Mantén los mocks fáciles de probar. Esto ahorra tiempo para la próxima persona que lo lea.
8. Cuando el cambio cambie mocks, mantén el resultado primero.

Verificación	Bueno	Necesita trabajo
los mocks es claro	Sí, en cada lugar	Solo en algunos lugares
los mocks es fácil de escanear	Sí, en cada lugar	Solo en algunos lugares
los mocks es seguro	Sí, en cada lugar	Solo en algunos lugares
los mocks es corto	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: la prueba tiene mocks que no es consistente.
Después: el cambio tiene mocks que es corto.

Logging

Revisa cada lugar donde el cambio toca logging. Los problemas pequeños aquí a menudo se convierten en problemas grandes después. Si el diff tiene más de una regla para logging, elige una regla y úsala en todas partes. Enumera el logging en el diff y asegúrate de que cada uno sea corto.

Pasos:

1. Reescribe el logging en la prueba y asegúrate de que cada uno sea seguro.
2. Si la prueba tiene más de una regla para logging, elige una regla y úsala en todas partes.
3. Cuenta el logging antes de terminar, luego escribe una línea sobre lo que encontraste.
4. Cuando el cambio cambie logging, une el resultado después.
5. Mantén el logging fácil de probar. Un lector se detiene cuando esta parte no está clara.
6. Cuando la función cambie logging, reescribe el resultado después.
7. Cuando la interfaz cambie logging, elimina el resultado entonces.
8. Acorta el logging primero, luego escribe una línea sobre lo que encontraste.

Verificación	Bueno	Necesita trabajo
el logging es fácil de probar	Sí, en cada lugar	Solo en algunos lugares
el logging es consistente	Sí, en cada lugar	Solo en algunos lugares
el logging es fácil de escanear	Sí, en cada lugar	Solo en algunos lugares
el logging es útil	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: la interfaz tiene logging que no es fácil de probar.
Después: el módulo tiene logging que es correcto.

Comentarios

Acorta los comentarios primero, luego escribe una línea sobre lo que encontraste. Mantén los comentarios útiles. Un lector se detiene cuando esta parte no está clara. Elimina los comentarios en la prueba y asegúrate de que cada uno sea simple.

Pasos:

1. Agrega los comentarios en la función y asegúrate de que cada uno sea fácil de escanear.
2. Lee los comentarios en el diff y asegúrate de que cada uno sea seguro.
3. Si el diff tiene más de una regla para comentarios, elige una regla y úsala en todas partes.
4. Si el diff tiene más de una regla para comentarios, elige una regla y úsala en todas partes.
5. Nombra los comentarios después, luego escribe una línea sobre lo que encontraste.
6. Enumera los comentarios entonces, luego escribe una línea sobre lo que encontraste.
7. Marca los comentarios entonces, luego escribe una línea sobre lo que encontraste.
8. Ordena los comentarios en el cambio y asegúrate de que cada uno sea específico.

Verificación	Bueno	Necesita trabajo
los comentarios es seguro	Sí, en cada lugar	Solo en algunos lugares
los comentarios es correcto	Sí, en cada lugar	Solo en algunos lugares
los comentarios es fácil de probar	Sí, en cada lugar	Solo en algunos lugares
los comentarios es fácil de cambiar	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: el diff tiene comentarios que no es fácil de cambiar.
Después: la interfaz tiene comentarios que es consistente.

Manejo de Archivos

Nombra el manejo de archivos al final, luego escribe una línea sobre lo que encontraste. Encuentra el manejo de archivos en el diff y asegúrate de que cada uno sea consistente. Agrega cada lugar donde el cambio toca el manejo de archivos. Un lector se detiene cuando esta parte no está clara.

Pasos:

1. Mantén el manejo de archivos específico. Le muestra al lector que pensaste en los detalles.
2. Agrega cada lugar donde el módulo toca el manejo de archivos. Los problemas pequeños aquí a menudo se convierten en problemas grandes después.
3. Cuando el diff cambie el manejo de archivos, mueve el resultado después de eso.
4. Mantén el manejo de archivos consistente. Esta es la parte que la gente pregunta más a menudo.
5. Si la prueba tiene más de una regla para el manejo de archivos, elige una regla y úsala en todas partes.
6. Cuando la función cambie el manejo de archivos, agrega el resultado entonces.
7. Cuando la prueba cambie el manejo de archivos, anota el resultado después.
8. Cuando la interfaz cambie el manejo de archivos, reescribe el resultado antes de terminar.

Verificación	Bueno	Necesita trabajo
el manejo de archivos es seguro	Sí, en cada lugar	Solo en algunos lugares
el manejo de archivos es claro	Sí, en cada lugar	Solo en algunos lugares
el manejo de archivos es correcto	Sí, en cada lugar	Solo en algunos lugares
el manejo de archivos es correcto	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: el cambio tiene manejo de archivos que no es fácil de cambiar.
Después: el cambio tiene manejo de archivos que es específico.

Contratos de API

Anota los contratos de API al final, luego escribe una línea sobre lo que encontraste. Compara los contratos de API al final, luego escribe una línea sobre lo que encontraste. Une los contratos de API al final, luego escribe una línea sobre lo que encontraste.

Pasos:

1. Si el diff tiene más de una regla para contratos de API, elige una regla y úsala en todas partes.
2. Marca cada lugar donde el módulo toca contratos de API. Sin ello, dos personas obtienen dos respuestas diferentes.
3. Si la interfaz tiene más de una regla para contratos de API, elige una regla y úsala en todas partes.
4. Mantén los contratos de API útiles. Un lector se detiene cuando esta parte no está clara.
5. Cuando la función cambie contratos de API, agrupa el resultado después de eso.
6. Cuando la interfaz cambie contratos de API, compara el resultado al final.
7. Confirma los contratos de API en el cambio y asegúrate de que cada uno sea seguro.
8. Compara cada lugar donde la función toca contratos de API. Esta es la parte que la gente pregunta más a menudo.

Verificación	Bueno	Necesita trabajo
los contratos de API es fácil de cambiar	Sí, en cada lugar	Solo en algunos lugares
los contratos de API es consistente	Sí, en cada lugar	Solo en algunos lugares
los contratos de API es seguro	Sí, en cada lugar	Solo en algunos lugares
los contratos de API es fácil de probar	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: la prueba tiene contratos de API que no es consistente.
Después: la interfaz tiene contratos de API que es correcto.

Fechas y Zonas Horarias

Agrega las fechas y zonas horarias en la prueba y asegúrate de que cada una sea correcta. Compara las fechas y zonas horarias en el módulo y asegúrate de que cada una sea consistente. Agrupa cada lugar donde el cambio toca fechas y zonas horarias. Un lector se detiene cuando esta parte no está clara.

Pasos:

1. Si el módulo tiene más de una regla para fechas y zonas horarias, elige una regla y úsala en todas partes.
2. Mantén las fechas y zonas horarias fáciles de escanear. Hace que el siguiente paso sea mucho más rápido.
3. Compara las fechas y zonas horarias después, luego escribe una línea sobre lo que encontraste.
4. Ordena las fechas y zonas horarias entonces, luego escribe una línea sobre lo que encontraste.
5. Une las fechas y zonas horarias en el diff y asegúrate de que cada una sea clara.
6. Cuando el diff cambie fechas y zonas horarias, elimina el resultado después.
7. Agrega cada lugar donde el cambio toca fechas y zonas horarias. Un lector se detiene cuando esta parte no está clara.
8. Anota las fechas y zonas horarias en el módulo y asegúrate de que cada una sea simple.

Verificación	Bueno	Necesita trabajo
las fechas y zonas horarias es correcto	Sí, en cada lugar	Solo en algunos lugares
las fechas y zonas horarias es específico	Sí, en cada lugar	Solo en algunos lugares
las fechas y zonas horarias es claro	Sí, en cada lugar	Solo en algunos lugares
las fechas y zonas horarias es seguro	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: la función tiene fechas y zonas horarias que no es claro.
Después: el diff tiene fechas y zonas horarias que es consistente.

Comprobaciones Nulas

Mantén las comprobaciones nulas claras. La mayoría de los errores de este tipo son fáciles de corregir temprano. Cuando la función cambie comprobaciones nulas, encuentra el resultado primero. Si el cambio tiene más de una regla para comprobaciones nulas, elige una regla y úsala en todas partes.

Pasos:

1. Mantén las comprobaciones nulas seguras. La mayoría de los errores de este tipo son fáciles de corregir temprano.
2. Agrupa las comprobaciones nulas en la interfaz y asegúrate de que cada una sea correcta.
3. Enumera cada lugar donde la interfaz toca comprobaciones nulas. Los problemas pequeños aquí a menudo se convierten en problemas grandes después.
4. Si la interfaz tiene más de una regla para comprobaciones nulas, elige una regla y úsala en todas partes.
5. Mantén las comprobaciones nulas completas. Un lector se detiene cuando esta parte no está clara.
6. Marca las comprobaciones nulas en la función y asegúrate de que cada una sea útil.
7. Cuando la prueba cambie comprobaciones nulas, reescribe el resultado al final.
8. Lee cada lugar donde la función toca comprobaciones nulas. Una revisión corta ahora evita una corrección larga después.

Verificación	Bueno	Necesita trabajo
las comprobaciones nulas es fácil de cambiar	Sí, en cada lugar	Solo en algunos lugares
las comprobaciones nulas es claro	Sí, en cada lugar	Solo en algunos lugares
las comprobaciones nulas es específico	Sí, en cada lugar	Solo en algunos lugares
las comprobaciones nulas es fácil de cambiar	Sí, en cada lugar	Solo en algunos lugares

Ejemplo:

Antes: la función tiene