¿Cuál es una forma (o patrón) limpia para hacer la verificación de parámetros de funciones?

Question

¿Hay algún patrón de diseño o forma limpia para hacer la verificación de parámetros de función/método (contra los valores permitidos)?

Actualmente, muchos de los códigos iniciales en mis funciones consisten en estos controles de parámetros (cadenas vacías, caracteres inválidos, identificador existente, ...) y, si es necesario, es un poco feo y ofusca el código 'real' de la función. Por lo general, mi código es algo como esto:

def my_function(p1,p2,p3,p4): 
    #check parameters 
    if p1 == '' 
     raise InvalidArgError('p1 can not be empty') 
    if p1 not in valid_list: 
     raise InvalidArgError('p1 does not exist') 
    if p2 < 0: 
     raise InvalidArgError('p2 can not be negative') 
    ... 

    #finally do something 
    p = p2+p3 

Para la solución, estoy pensando en la línea de decorators en Python.
Estoy usando Python, aunque supongo que una buena solución sería independiente del lenguaje.

Answer 1

Supongo que no realmente, no un uniforme manera de hacerlo.

personalmente aclaro que en mis funciones donde el código real empieza si hay un montón de comprobación de parámetros que hacer (ejemplo al azar):

def setpoint(x, y): 
    # checking for out of bounds 
    if x < 0 or x >= maxwidth: return false 
    if y < 0 or y >= maxheight: return false 

    # start function 
    map[x][y] = true 

Tal vez usted debería considerar la posibilidad de dividir las funciones en funciones más pequeñas, para extender la verificación de parámetros.

Answer 2

La única bastante lenguaje de cosas independientes que puedo imaginar en este momento es una especie de contrato de código para que pueda hacer cosas como:

func foo(param1, param2) 
{ 
    Contract.NotNull(param1) 
    Contract.IsIn(0, 100, param2) 
} 

Asumo que podría llegar a una implementación de algún tipo en la mayoría lenguajes de programación.

actualización

Microsoft is working on an implementation y hay a Java implementation.

Answer 3

Cada parámetro de un método representa una entidad. Debe haber algunas restricciones o suposiciones sobre los valores del argumento en función del cual funciona el método/toda la clase. Entonces escribo métodos para verificar la validez de esos parámetros.

void drawRectangle(int length, int width) { 
    if (isValidLength(length) == false || isValidWidth(width) == false) { 
     // log about invalid argument so that it can be easily traced for debugging 
     return; 
    } 

    // remaining code 
} 

boolean isValidLength(int length) { 
    if (value < 0 || value > 100) { 
     return false; 
    } 

    return true; 
} 

La ventaja es evitar el código duplicado. Si la verificación nula, la comprobación de rango se realiza para el mismo tipo de parámetro en varios métodos y, en algún momento más tarde, el rango para ese parámetro cambia debido a la modificación de requisitos, entonces los cambios se deben realizar en varios lugares. Por otro lado, si el control se realiza en un método separado, el alcance del cambio se reduce.