Feda /dev/ - No Javascript allowed

#52921 hindidev

Gentes que sabéis de Go

Estoy viendo mucho esto en el proyecto nuevo y tengo mis dudas. Tengo este struct:

type Thing struct {
    Name  string
    Amount   int
}

Y para crear una instancia (sé que no es una instancia pero no sé cómo llamarlo) tengo esto:

func NewThing(name string, amount int) *Thing {
    return &Thing{name, amount}
}

¿Esto se consideran buenas prácticas? ¿Y por qué declaro que NewThing() devuelve un puntero si está devolviendo la dirección de memoria?

#52926 por ser tú va con GPT4
Sí, el patrón que estás describiendo es considerado una buena práctica en Go, especialmente cuando se trata de la creación de instancias de estructuras. Este patrón se conoce como "constructor" por analogía con otros lenguajes de programación orientados a objetos, aunque Go no es un lenguaje orientado a objetos en el sentido tradicional. La función NewThing actúa como un constructor porque encapsula la inicialización de la estructura Thing.

Hay varias razones por las que este patrón es considerado una buena práctica:

1. Encapsulamiento: Permite encapsular la lógica de inicialización de una estructura. Esto es útil si la creación de la estructura implica pasos adicionales de configuración o validación más allá de simplemente asignar valores a sus campos.

2. Consistencia: Ayuda a mantener la consistencia en la forma en que se crean e inicializan las instancias. Esto es particularmente útil en proyectos grandes donde múltiples desarrolladores trabajan en el mismo código.

3. Flexibilidad para cambios futuros: Si en el futuro necesitas cambiar la forma en que se inicializan las instancias de Thing, puedes hacerlo en un solo lugar (dentro de NewThing) en lugar de buscar y modificar cada instancia donde creaste un Thing directamente.

En cuanto a tu pregunta sobre por qué NewThing() devuelve un puntero (*Thing) en lugar de una instancia de Thing directamente, hay varias razones para esto también:

1. Eficiencia: Devolver un puntero evita copiar toda la estructura cada vez que se crea una nueva instancia. Esto puede ser especialmente importante para estructuras grandes.

2. Mutabilidad: Al devolver un puntero, cualquier modificación hecha a la instancia devuelta se refleja en todas las referencias a esa instancia. Si devolvieras una copia de la estructura (es decir, un valor en lugar de un puntero), cada modificación solo afectaría a esa copia local, lo que podría no ser el comportamiento deseado.

3. Consistencia con el manejo de estructuras en Go: Es común en Go usar punteros a estructuras para permitir la mutabilidad y evitar copias innecesarias.

Finalmente, cuando dices que NewThing() "está devolviendo la dirección de memoria", es una forma de hablar sobre lo que ocurre bajo el capó. En Go, cuando usas el operador & delante de una estructura, estás obteniendo el puntero a la memoria donde se almacena esa estructura. Así que sí, técnicamente NewThing() devuelve un puntero a la dirección de memoria donde se ha creado y almacenado la nueva instancia de Thing.

PD: si alguien puede podría estar bien comparar respuestas, no me he molestado en hacer ningún prompt.

#52929 no entiendo muy bien la pregunta, estas devolviendo un puntero

#52933 A mí mientras me lo explique bien explicado...

#52937MTX_Anubis:

con &Thing le dices que devuelva la dirección de memoria

Esa parte la entiendo. Pero entonces estoy devolviendo una dirección, no un objeto.

#52937MTX_Anubis:

Lo que estarías devolviendo entonces es el valor porque le estarías diciendo que haga la indirección y acceda al contenido

¿Y no es eso lo que quiero hacer? Pregunto sin ironías. Si devuelvo

#52938

type Thing struct {
	Name   string
	Amount int
}

func NewThing(name string, amount int) *Thing {
	return &Thing{name, amount}
}

func modifier(t *Thing) {
	t.Amount = 20
}

func modifier2(t Thing) {
	t.Amount = 30
}

func main() {
	myVar := NewThing("thing1", 10)
	fmt.Printf("myVar (ptr) %v %T\n", myVar, myVar)
	fmt.Printf("myVar (struct) %v %T\n", *myVar, *myVar)
	fmt.Printf("myVar (ptr address) %v %T\n", &myVar, &myVar)

modifier(myVar)
fmt.Println(myVar.Amount)

modifier2(*myVar)
fmt.Println(myVar.Amount)
}

output

myVar (ptr) &{thing1 10} *main.Thing
myVar (struct) {thing1 10} main.Thing
myVar (ptr address) 0xc000072540 **main.Thing
20
20

lo que estas devolviendo en "NewThing" es un puntero al struct Thing

en este caso, la funcion modifier modifica el struct original
y la funcion modifier2 modifica el struct que le llega por parametro, que al no ser un puntero, es una copia del struct original

Yo no creo que eso sea una buena practica, al contrario, creo que esta mal.

Me refiero al "constructor".

Creo que es algo que se ha portado de los Javeros y demás fperos que venían de lenguajes orientados a objetos.

Pa que quieres:

name := "foo"
bar := 10
t := NewThing(name, amount)

Si puedes hacer:

name := "foo"
bar := 10
t0 := Thing{name, amount}
t1 := &Thing{name, amount}

no?? un poquito tonto

#52942desu:

Creo que es algo que se ha portado de los Javeros y demás fperos que venían de lenguajes orientados a objetos.

Es que me sonaba justo a eso, lo veía un smell de querer picar OOP en un lenguaje no OOP, pero como aquí todo el mundo lo usa tenía mis dudas.

#52941 Lo entiendo, pero es la hostia de antiintuitivo declarar un tipo de return y devolver otra cosa.

#52938Kaledros:

Esa parte la entiendo. Pero entonces estoy devolviendo una dirección, no un objeto.

una dirección y un objeto es lo mismo, según tu definición y como supongo que tu lo entiendes, lo que pasa es que cuando accedes a la dirección, los lenguajes tienen syntax sugar para ahorrarte la derrefencia.

si tu en tu lenguaje (voy a hacer pseudo go, pero te vale para Java, PHP, lo que quieras) tienes:

struct Thing {
 name: string
 value: int
}

fun NewThing() *Thing {
   ...
}

y quieres modificar un valor haces esto:

 t := NewThing()
 t.name = "new name"

ese . y esa sintaxis es una convención generalizada. realmente haces:

 t := NewThing()
 (*t).name = "new name"

de la misma manera cuando tienes esto:

func (t Thing) foo() { }
func (t Thing) bar() { }

cuando lo llamas asi:

t.foo()
t.bar()

realmente estas haciendo:

(*t).foo()
(*t).bar()

como es algo tan común, el compilador lo hace por ti.