¿Cómo romper una larga línea de código en Golang?

Question

Viniendo de Python, no estoy acostumbrado a ver líneas de código de más de 80 columnas. Entonces cuando encuentro esto:

err := database.QueryRow("select * from users where user_id=?", id).Scan(&ReadUser.ID, &ReadUser.Name, &ReadUser.First, &ReadUser.Last, &ReadUser.Email)

Traté de romperlo a

err := database.QueryRow("select * from users where user_id=?", id) /
    .Scan(&ReadUser.ID, &ReadUser.Name, &ReadUser.First, &ReadUser.Last, &ReadUser.Email)

Pero consigo

 syntax error: unexpected /

También intenté simplemente romper la línea presionando enter y poner un punto y coma al final:

err := database.QueryRow("select * from users where user_id=?", id) 
.Scan(&ReadUser.ID, &ReadUser.Name, &ReadUser.First, &ReadUser.Last, &ReadUser.Email);

Pero de nuevo obtengo:

syntax error: unexpected .

Entonces, me pregunto cuál es la forma golangica de hacerlo.

Answer 1

Como se mencionó, esta es una cuestión de preferencia de estilo. Entiendo que los creadores de Go han sugerido un estilo basado en su experiencia del cual aprendo, pero también mantienen algo de mi propio estilo de mi experiencia.

A continuación se muestra cómo formatearía esto:

err := database.
  QueryRow("select * from users where user_id=?", id).
  Scan(
    &ReadUser.ID,
    &ReadUser.Name,
    &ReadUser.First,
    &ReadUser.Last,
    &ReadUser.Email,
  )

Answer 2

Es una cuestión de estilo, pero me gusta:

err := database.QueryRow(
    "select * from users where user_id=?", id,
).Scan(
    &ReadUser.ID, &ReadUser.Name, &ReadUser.First, &ReadUser.Last, &ReadUser.Email,
)

Answer 3

La forma más simple es simplemente dejar el operador ( . ) En la primera línea.

/ continuaciones de línea también se desaconsejan en muchas guías de estilo de python, podría envolver la expresión completa en parens si se mueve de ida y vuelta entre go y python ya que esta técnica funciona en ambos idiomas.

Answer 4

Primero algunos antecedentes. La gramática formal de Go usa punto y coma ";" como terminadores en muchas producciones, pero los programas Go pueden omitir la mayoría de ellos (y deberían tener una fuente más clara y fácil de leer; gofmt también elimina puntos y comas innecesarios).

La especificación enumera las reglas exactas. Espec .: punto y coma:

La gramática formal usa punto y coma ";" como terminadores en una serie de producciones. Los programas Go pueden omitir la mayoría de estos puntos y comas utilizando las siguientes dos reglas:

1. Cuando la entrada se divide en tokens, un punto y coma se inserta automáticamente en la secuencia de tokens inmediatamente después del token final de una línea si ese token es

   • un identifier
   • un integer , floating-point , imaginary , rune o literal de string
   • una de las keywords fallthrough , continue , fallthrough o return
   • uno de los operadores y delimitadores ++, -,),] o}

2. Para permitir que las declaraciones complejas ocupen una sola línea, se puede omitir un punto y coma antes de un cierre ")" o "}".

Entonces, como puede ver si inserta un carácter de nueva línea después del paréntesis ) , un punto y coma ; se insertará automáticamente y, por lo tanto, la siguiente línea no se tratará como la continuación de la línea anterior. Esto es lo que sucedió en su caso, por lo que la siguiente línea que comienza con .Scan(&ReadUser.ID,... le dará un error en tiempo de compilación, ya que esta sola (sin la línea anterior) es un error en tiempo de compilación : syntax error: unexpected .

Por lo tanto, puede romper su línea en cualquier punto que no entre en conflicto con las reglas enumeradas en el punto 1. anterior.

Por lo general, puede romper sus líneas después de una coma , después de abrir paréntesis, por ejemplo ( , [ , { y después de un punto . Que puede estar haciendo referencia a un campo o método de algún valor. También puede romper su línea después de operadores binarios (aquellos que requieren 2 operandos), por ejemplo:

i := 1 +
        2
fmt.Println(i) // Prints 3

Una cosa que vale la pena señalar aquí es que si tiene una estructura o corte o literal de mapa que enumera los valores iniciales, y desea romper la línea después de enumerar el último valor, debe poner una coma obligatoria , aunque este sea el último valor y no seguirán más, por ejemplo:

s := []int {
    1, 2, 3,
    4, 5, 6,  // Note it ends with a comma
}

Esto es para cumplir con las reglas de punto y coma, y ​​también para que pueda reorganizar y agregar nuevas líneas sin tener que ocuparse de agregar / quitar la coma final; por ejemplo, simplemente puede intercambiar las 2 líneas sin tener que eliminar y agregar una nueva coma:

s := []int {
    4, 5, 6,
    1, 2, 3,
}

Lo mismo se aplica al enumerar argumentos para una llamada a función:

fmt.Println("first",
    "second",
    "third",       // Note it ends with a comma
)