# Struct - Methods vs Functions

### **¿Qué son las estructuras en Go?**&#x20;

En Go, una *struct* (estructura) es un tipo de dato compuesto que permite agrupar datos bajo una misma entidad, lo que resulta muy útil para representar entidades o conceptos que tienen múltiples atributos o propiedades. Las *structs* se utilizan para definir un tipo de datos personalizado con un conjunto de campos, cada uno con un nombre y un tipo específico.

Una *struct* en Go es similar a una clase en otros lenguajes orientados a objetos, pero Go no tiene herencia ni otras características de la programación orientada a objetos. En cambio, se enfoca en la composición mediante *structs* y *interfaces*, lo que hace que el lenguaje sea más simple y eficiente.

### **Definición de una Estructura**:

Las estructuras se definen usando la palabra clave `type` seguida del nombre de la estructura.

```go
type Persona struct {
    Nombre string
    Edad   int
}
```

### Creación de una Instancia de Estructura:

Puedes crear una instancia de la estructura y acceder a sus campos.

```go
func main() {
    p := Persona{Nombre: "Juan", Edad: 30}
    fmt.Println("Nombre:", p.Nombre)
    fmt.Println("Edad:", p.Edad)
}
```

### **Métodos**

Los métodos se asocian a tipos y tienen una firma similar a las funciones, pero tienen un receptor. ¿y cual es la diferencia entre método y función? ya la veré más abajo.&#x20;

```go
func (p Persona) Saludar() {
    fmt.Println("Hola, mi nombre es", p.Nombre)
}
```

Se puede llamar al método así:

```go
func main() {
    p := Persona{Nombre: "Juan", Edad: 30}
    p.Saludar() // Llama al método Saludar
}
```

### **Métodos con Punteros**:

Si deseas modificar el valor de la estructura desde el método, debes usar un puntero como receptor.

```go
func (p *Persona) CumplirAño() {
    p.Edad++
    p.Nombre = "Juancho"
}
```

Ahora bien...

### ¿Cual es la diferencia entre Método y Función? ¿Que es un receptor o receiver?

#### Diferencias entre Funciones y Métodos

**Definición**:

* **`Función`**: Es un bloque de código que realiza una tarea específica y puede ser llamada en cualquier parte del programa. No está asociada a ningún tipo en particular.
* **`Método`**: Es una función que está asociada a un tipo específico (generalmente una estructura). Los métodos se utilizan para operar sobre los datos de ese tipo.

**Sintaxis:**

* **Función:**

```go
func nombreFuncion(parametros) {
    // código
}
```

* **Método:**

```go
func (receptor Tipo) nombreMetodo(parametros) {
    // código
}
```

### ¿Qué es un Receptor (Receiver)?

* El **receptor** (o **receiver**) es el argumento que se pasa al método para que pueda acceder a los datos de la estructura a la que está asociado. Permite que el método opere sobre la instancia específica de la estructura.
* **Receptor** puede ser:
  * **Por valor**: Se pasa una copia de la estructura. Los cambios dentro del método no afectan a la estructura original.

```go
func (p Persona) Saludar() {
    // p es un receptor por valor
}        
```

* **Por puntero:** Se pasa una referencia a la estructura original. Los cambios dentro del método afectan a la estructura original.

```go
func (p *Persona) CumplirAnios() {
    // p es un receptor por puntero
}
```

### Ejemplo ilustrado:

```go
type Persona struct {
    Nombre string
    Edad   int
}

// Método por valor
func (p Persona) Saludar() {
    fmt.Println("Hola, mi nombre es", p.Nombre)
}

// Método por puntero
func (p *Persona) CumplirAño() {
    p.Edad++
}
```

* **`Saludar`** es un método que recibe una copia de `Persona`, así que si cambias algo en `p`, no afectará a la instancia original.
* **`CumplirAño`** recibe un puntero a `Persona`, por lo que cualquier cambio en `p.Edad` afectará a la estructura original.

Eso es todo, ahora si nospi :)&#x20;
