Estoy aplicando TDD mientras creo mi proyecto, y estoy implementando muchas pruebas y verificaciones para mis funciones para asegurar que sus argumentos se ingresen correctamente.
No tengo ningún problema con esto, pero mi código comienza a verse congestionado con todas las comprobaciones de argumentos. ¿Es esta una práctica adecuada o la verificación de argumentos generalmente no se implementa de esta manera?
export default class Ship { constructor(shipLength) { if (typeof shipLength !== 'number') throw new Error('Length must be a number'); if (arguments.length !== 1) throw new Error('Must enter only 1 argument'); if (shipLength < 1) throw new Error('Length must be greater than 0'); if (shipLength % 1) throw new Error('Length must be an integer'); this.length = shipLength; this.hits = Array(this.length).fill(false); } hit(location) { if (typeof location !== 'number') throw new Error('Must be a number'); if (arguments.length !== 1) throw new Error('Can only accept one argument') if (location > this.length - 1) throw new Error('Must be within ship body'); if (location < 0) throw new Error('Cant be negative'); if (location % 1) throw new Error('Must be an integer'); this.hits[location] = true; } } import Ship from "../src/ship"; describe('Test that the constructor', () => { it('accepts only one parameter of type number', () => { expect(() => new Ship(3)).not.toThrow(); expect(() => new Ship(1,2,3)).toThrow(); expect(() => new Ship([1,2,3])).toThrow(); expect(() => new Ship('asd')).toThrow(); }); it('doesnt take < 1 as length', () => { expect(() => new Ship(0)).toThrow(); expect(() => new Ship(-1)).toThrow(); }); it('only accepts integers', () => { expect(() => new Ship(1.1)).toThrow(); }); it('sets the passed ship length', () => { expect(new Ship(3).length).toBe(3); }); it('creates a hit array', () => { expect(new Ship(3).hits).toEqual([false, false, false]); }) });Debe realizar la validación en tiempo de ejecución de los valores proporcionados por el usuario . Porque esos solo aparecen en tiempo de ejecución y los errores en ellos deben manejarse en tiempo de ejecución. Hacer esto para los valores que se pasan internamente en su código suele ser una exageración. Porque si bien esos errores aparecerán en el tiempo de ejecución, no puede hacer nada al respecto en el tiempo de ejecución; necesitas arreglarlos arreglando tu código. Por lo tanto, las comprobaciones en tiempo de ejecución de esos valores pueden ayudarlo a descubrir errores en su código, pero a costa de un código muy complicado; y ni siquiera se garantiza que lo ayude a descubrir fácilmente esos errores, si su código no toma ese camino en particular.
Lo que ayuda a descubrir este tipo de errores en el momento del desarrollo es un verificador de tipo estático como TypeScript . Usarlo a menudo tiene más sentido que estas comprobaciones de tipo de tiempo de ejecución.
No mire si el código está abrumado es una buena práctica si conduce a un código seguro que se ejecuta sin errores solamente
editar: claro, y podría usar algún tipo de biblioteca, pero de esta manera tiene acceso a lo que verifica y cómo lo verifica, lo que facilita la modificación posterior si es necesario.