Modificadores de acceso en funciones y Structs

En mi caso (que lo quise probar manual) tuve mucho el problema “package *** is not in GOROOT (/usr/local/go/src/***)”. Lo resolví con go mod init así solito, en la raíz de la carpeta del proyecto

Me toco investigar este tema porque no entendí lo de los módulos espero les sirva:

Anteriormente en GO se tenía que trabajar el código dentro del GOPATH. Este GOPATH es una de las variables de entorno que declaramos al principio del curso (export GOPATH=$HOME/go) y no es más que la ruta a nuestro entorno de trabajo en donde encontraremos/crearemos la carpeta source que es donde trabajamos todo nuestro código.

Afortunadamente desde la versión 1.11 podemos realizar nuestros proyectos de Go desde donde queramos gracias a los módulos.

Veamos un ejemplo.

Cree un proyecto llamando 0.0-fundamentals en la siguiente ruta /home/est14/my-own-path/15-go-course/0.0-fundamentals como se puede apreciar estoy fuera de mi GOPATH (/home/est14/go/source).

Ahora cree mi go.mod aquí, en la raíz de 0.0-fundamentals con el siguiente comando.

go mod init est14/0.0-fundamentals 

Esto me creo el archivo go.mod con el siguiente contenido :

module est14/0.0-fundamentals

go 1.16  // Esta es la version de Go

Luego cree un archivo llamado main.go, al mismo nivel de este cree un directorio llamado greetings, dentro de greetings cree un archivo llamado greetings.go y finalmente cree una función llamada Hola.

Mi estructura quedo asi:

├── go.mod
├── greetings
│ └── greetings.go // Aquí cree mi funcion Hola
└── main.go

Ahora mi intención era traer la función llamada Hola que estaba en greetings.go a mi archivo main.go y eso lo hice importando mi paquete “est14/0.0-fundamentals/grettings”

//Este es el contenido de mi archivo main.go
package main

import (
	"est14/0.0-fundamentals/grettings"
	
)

func main() {

	greetings.Hola()
	
}

Y listo finalmente pude importar mi paquete y utilizar mi función Hola. Hay mucho detrás de todo esto y sería bueno detenerse un poco aquí ir por un helado luego leer un poco de documentación y seguir 😉.

Aqui como resolvi el tema del paquete:

go run src/main.go

https://faun.pub/golang-package-management-using-go-modules-d3c929900114

Para resolver el problema de cannot find package “mypackage” in any of…

Pueden intentar importarlo de la siguiente manera

import (
	"fmt"
	mypackage "./mypackage"
)

Go modules nos puede ayudar a evitar un poco el $GOPATH, basta con ejecutar en caso en la carpeta “src”:

go mod init "elnombrequequieras"

Y poder usar lo que derive de el, mas información:

go modules

En mi caso solucione el proble del GOROOT deshabilitando el mod al modificar una variable de entorno de la siguiente forma

go env -w GO111MODULE=off

✅ Esto me funcionó para resolver el problema al importar y compilar el src/main.go (estoy usando go 1.15.13) . Teniendo la siguiente estructura en mi proyecto:

learngo
└── src
    ├── main.go
    └── race
        └── car.go

1. Inicié un module en la carpeta raíz del proyecto, en mi caso es learngo, con el siguiente comando:

$ go mod init learngo 

Entonces aparecerá un archivo go.mod. El proyecto quedó así:

learngo
├── go.mod
└── src
    ├── main.go
    └── race
        └── car.go

1. Luego en src/main.go importé la struct CarPublic así:

package main

import (
	"fmt"
	"goplatzi/src/race"
)

func main() {
	var mycar race.CarPublic

	mycar.Brand = "BENTLEY"
	fmt.Println(mycar)
}

🐹 De esta forma VSCode dejó de marcar errores de importación y logre ejecutar el main usando:

$ go run src/main.go

En mi caso con el go mod init en la carpeta donde esta el src para importalo ya no fue necesario poner
"curso_golang_platzi/src/mypackage" sino que solo fue con
"curso_golang_platzi/mypackage", usando Go 1.16.4

Solo un pequegno comentario. El no lo menciono durante el video pero este tema aclararia la pregunta de videos anteriores de por que las funciones fmt.Print* comienzan con P mayuscula.

For anyone that want to complie a project in D:\ drive, follow the next steps.

Maybe will need to create a project outside the GOPATH and create packages, but they will not compile outside the GOPATH, to solve that problem, follow the next steps:

1. Inisde the root directory of the project (the first folder), create a go module with the next command:

   // Create a go module
   go mod init <module name>
   
   // For example
   go mod init gobasic
   

   A file called go.mod will be created. It will contain the next lines of code:

   module <module name> // Example gobasic
   go 1.17 // Go version
   

2. Create a new directory to save the package file that will import the struct in the main file. Execute:

   mkdir <directory name> && cd <directory name>
   
   // For example
   mkdir mypackage && cd mypackage
   

3. Create the file of the struc inside the new folder. The struct file must have the first line the name of the directory (folder). For example:

   // The first line must be the name of the directory
   package <directory name created> // For example, mypackage
   
   // Go will ask for the next commen with the name of the struct
   // CarPublic, it's a good practice to make a description
   type CarPublic struct {
   	Brand string
   	Year uint16
   }
   

4. Return to the root director of the project.

5. In the main file import the package with the next lines of code

   import <name of the module from of go mod init>/<directory of the package to import>
   

6. For example the code of the main file will be:

   package main
   
   import (
   	"fmt"
   	pk "gobasic/mypackage"
   )
   
   func main() {
   
   	var myCar pk.CarPublic
   	myCar.Brand = "Ferrari"
   	fmt.Println(myCar)
   }
   

   1. Execute the main file.

al instalarlo go con snap en ubuntu al tratar de usar la exportacion de paquetes me presente con un detalle de “package *** is not in GOROOT (/usr/local/go/src/***)”. lo que hice fue ejecutar este copmando go env -w GO111MODULE=off todavia investigo para que es, pero con eso me funciono si alguien puede comentar mas a profundidad de que se trata ese comando seria bueno

si usan intellij esta configuracion les puede servir 😄![](

Gracias Juan Camilo por el aporte, se arreglo el problema de :

package curso_golang_platzi/src/mypackage is not in GOROOT (/usr/local/go/src/curso_golang_platzi/src/mypackage)
sin necesidad de editar “go env”, GO111MODULE=" "

La carpeta raiz, es donde esta el “src” donde tienes “main.go”, por si eres principiante y rapdio lo ubiques
…/curso_golang_platzi/src
ejecutas :
go mod init

• El nombre del paquete es el nombre de la carpeta.

• Si el nombre inicia con mayúscula, será de acceso público. de lo contrario será de acceso privado.

Cuando hay problema en la ruta de los paquetes asociados a GOROOT o GOPATH, tambien se puede solucionar con:

go env -w GO111MODULE=off

Esta parte del curso necesita una actualizacion o una aclaracion urgente

No todos estamos usando la misma carpeta que el, en ese caso, tendremos problemas con los import, ya que por defecto, este busca en los archivos de instalacion de go.

Para solucionar esto, hay que usar en la raiz del proyecto

go mod init ruta/modulo

En mi caso, lo cree como test/acceso, asi que el comando queda

go mod init test/acceso

esto creara un archivo go.mod

module test/acceso

go 1.17

module test/acceso es el nombre del modulo que le dimos al comando, guardalo

Luego, supongamos que tengo una carpeta llamada myPackage, y dentro tiene un archivo car.go como este

package car

// CarPublic car con acceso publico
type CarPublic struct {
	Brand string
	Year  int
}

Nota que el package aqui es car, guardalo tambien

Los archivos dentro de la misma carpeta DEBEN tener pertenecer al mismo package

Para usar este archivo, le damos la siguiente ruta al import

"nombre_modulo/ruta"

En mi caso, seria

import (
	"fmt"
	 "test/acceso/myPackage"
)

Para llamarla usa el nombre del paquete, seguido de lo que necesites usar

var newCar car.CarPublic

Tambien podemos usar un alias

import (
	"fmt"
	carPackage "test/acceso/myPackage"
)
//...
var newCar carPackage.CarPublic

Hola!
Si a alguno le aparece “package XXX is not in GOROOT” deben poner en la terminal:

go env -w GO111MODULE=off

para modificar la variable que genera errores debido a una versión anterior a 1.11 del lenguaje

Espero sirva.

Al inicio del curso, espero no errar, el instructor empezo a trabajar en el GOPATH de su máquina local.

Yo acabo de recrear el ejemplo usando el valor de la variable GOPATH que se creó por defecto. Utilizé la misma estructura del ejemplo y no me presento error.

Pueden ver si les creo un GOPATH por default mediante go env | grep GOPATH y recrear la estrcutura de directorios del ejemplo: (Ruta o valor de la variable GOPATH)/src/curso_golang_platzi/(Aqui los archivos y directorios del vídeo) .

Por eso creo que a algunos les da error al generar el subpaquete mypackage estando fuera de la GOPATH , dado que al estar fuera de esa ruta se necesita utilizar módulos para el reconocimiento de los subdirectorios/suboaquetes que se crean a partir de la raiz del proyecto.

Al momento tengo de version go 1.17.3 y yo no inicialize ni configure la variable GOPATH, se generó por default con el valor que apunta en $HOME/go.

Saludos a todos y espero sirva de algo a alguien.

Me salía error diciendo src/main.go:4:2: package curso_golang_platzi/src/mypackage is not in GOROOT (/usr/local/go/src/curso_golang_platzi/src/mypackage)

Lo solucioné gracias a @Jonathan Camilo Bernal Aldana colocando el siguiente comando en la terminal:

go env -w GO111MODULE=off

La importación de paquetes tampoco me funcionó usando el GOPATH, lo que hice fue crear una nueva carpeta en mi escritorio llamada go, luego inicialicé el modulo con go mod init go. Luego, cree un subdirectorio llamado mypackage y dentro de este cree un nuevo subdirectorio llamado test (mas que nada para saber si es posible llamar funciones que se encuentran dentro de varios subdirectorios)

Aquí el resultado!

Espero les sea de utilidad

La importación de paquetes tampoco me funcionó usando el GOPATH, lo que hice fue crear una nueva carpeta en mi escritorio llamada go, luego inicialicé el modulo con go mod init go. Luego, cree un subdirectorio llamado mypackage y dentro de este cree un nuevo subdirectorio llamado test (mas que nada para saber si es posible llamar funciones que se encuentran dentro de varios subdirectorios)

Aquí el resultado

Espero les sea de utilidad

El problema de las importaciones lo arregle agregando las variables de entorno de Go

😎

Genial

no me funcionó como en el video, por si les funciona de esta manera

import (
	pkg "./Mypackage"
	"fmt"
)

Primer curso en el que he tenido tantos problemas, la extension de go no funciona y ahora no me permite hacer el import, a sido mas googlear que prestar atencion a las clases, desafortunadamente

Tuve muchos problemas con el GOROOT, en los comentarios vi que nos recomendaron crear el modulo en la raíz de la carpeta del proyecto con el comando go mod init, sin embargo, si no se desea crear el modulo se puede usar el comando:
GO111MODULE=off go run main.go
Donde “main.go” es el nombre del archivo que se va a ejecutar

Yo tengo dividida mi compu en 2 discos: el del sistema que es C: un disco ssd y un D: disco noramal.
Las carpetas de instalacion de GO estan en C y las del proyecto en D:
Para solucionar el missmatch del paquete solo le di go mod init rutaejemplo dentro de la consola bash de VS code. Para que funcione el cambio tienes que esperar a que la extension te marque un requerimeinto de upgrade o instalacion. Te va a aparecer como la tipica barra de notificacion de VS Code.
A partir de ahi ya todo jala chido. Evidentemente mi ruta de acceso al paquete es rutaejemplo/acceso
Salu2

No me pide que ponga los comentarios en mypackage, capaz es otra version.

El nombre del paquete siempre debe ser el de la carpeta?