Devolución verdadero o mensaje de error en Ruby

Question

Me pregunto si escribir funciones como esta se considera buena o mala forma.

def test(x) 
    if x == 1 
     return true 
    else 
     return "Error: x is not equal to one." 
    end 
end 

Y luego de usar que hacemos algo como esto:

result = test(1) 

if result != true 
    puts result 
end 

result = test(2) 

if result != true 
    puts result 
end 

Lo cual muestra el mensaje de error para la segunda llamada a prueba.

Estoy considerando hacer esto porque en un proyecto de rieles estoy trabajando dentro de mi código de controlador realizo llamadas a los métodos de instancia de un modelo y si algo sale mal quiero que el modelo devuelva el mensaje de error al controlador y el controlador toma ese mensaje de error y lo pone en el flash y redirige. Un poco como esta

def create 
    @item = Item.new(params[:item]) 

    if !@item.nil? 
     result = @item.save_image(params[:attachment][:file]) 

     if result != true 
      flash[:notice] = result 

      redirect_to(new_item_url) and return 
     end 

     #and so on... 

De esa manera no estoy construyendo los mensajes de error en el controlador, simplemente pasando a lo largo, porque realmente no quiero que el controlador se ocupa de lo que el método save_image sí hace justamente si o no funcionó.

Tiene sentido para mí, pero tengo curiosidad acerca de si esto se considera una forma buena o mala de escribir métodos o no. Tenga en cuenta que estoy preguntando esto en el sentido más general perteneciente principalmente al rubí, simplemente sucede que estoy haciendo esto en un proyecto de rieles, la lógica real del controlador realmente no es de mi incumbencia.

Answer 1

Diría que los métodos que devuelven diferentes tipos (por ejemplo, booleano vs. cadena vs. números) en diferentes circunstancias son una mala práctica.

Si tiene algún tipo de método de prueba que quiere volver detalles de por qué la prueba no ha pasado, entonces puede volver un par de valores (una Array) de la siguiente manera:

def test(x) 
    if x == 1 
     return true, "x is fine" 
    else 
     return false, "Error: x is not equal to one." 
    end 
end 

y luego escribir el sección de su código de controlador como:

valid, message = @item.save_image(params[:attachment][:file]) 

if !valid 
    flash[:notice] = message 
    redirect_to(new_item_url) and return 
end 

Si estamos hablando acerca de un método save_image que tendrá éxito la mayoría de las veces, pero puede fallar y que desea indicar este fracaso y la razón entonces yo usaría exceptions p. Ej.

def save_image(file) 
    raise "No file was specified for saving" if file.nil? 
    # carry on trying to save image 
end 

y luego el código de controlador sería a lo largo de las líneas de:

begin 
    result = @item.save_image(params[:attachment][:file]) 
rescue Exception => ex 
    flash[:notice] = ex.message 
    redirect_to(new_item_url) and return 
end