One place for hosting & domains

      escribir

      Cómo escribir paquetes en Go


      Un paquete está compuesto por archivos de Go que se alojan en el mismo directorio y tienen la misma instrucción de paquetes al inicio. Puede incluir funcionalidad adicional de paquetes para hacer que tus programas sean más sofisticados. Algunos paquetes están disponibles a través de la biblioteca de Go Standard y, por lo tanto, se incluyen con su instalación de Go. Otros se pueden instalar con el comando go get de Go. También puede crear sus propios paquetes de Go creando archivos de Go en el mismo directorio en el que desee compartir el código, con la instrucción de paquete necesaria.

      A través de este tutorial, podrás escribir paquetes Go para utilizarlos en otros archivos de programación.

      Requisitos previos

      • Configurar un entorno de programación de Go siguiendo uno de los tutoriales de la serie Cómo instalar y configurar un entorno de programación local para Go. Cree su espacio de trabajo Go siguiendo el paso 5 en los tutoriales de entorno de programación local. Para seguir el ejemplo y las convenciones de nomenclatura de este artículo, lea la primera sección: Escribir e importar de paquetes.
      • Para ampliar su conocimiento de GOPATH, lea nuestro artículo Información sobre GOPATH.

      Escribir e importar paquetes

      Escribir un paquete es como escribir cualquier archivo de Go. Los paquetes pueden contener definiciones de funciones, tipos y variables que luego pueden utilizarse en otros programas de Go.

      Para crear un nuevo paquete, es necesario encontrarse en el espacio de trabajo de Go propio. Normalmente, esto se encuentra en gopath. Por ejemplo, en este tutorial daremos el nombre greet al paquete. Para hacer esto, creamos un directorio llamado greet en nuestro gopath, en el espacio de nuestro proyecto. Si nuestra organización fuera gopherguides y quisiéramos crear el paquete greet con la organización mientras usamos Github como nuestro repositorio de código, nuestro directorio tendría el siguiente aspecto:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
      

      El directorio greet se necuentra dentro del directorio gopherguides:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
                      └── greet
      

      Por último, podemos añadir el primer archivo en nuestro directorio. Se considera práctica frecuente que el archivo primary o entry point de un paquete lleve el nombre del directorio. En este caso, crearíamos un archivo llamado greet.go dentro del directorio greet:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
                      └── greet
                          └── greet.go
      

      Con el archivo creado, podemos comenzar a escribir el código propio que queramos volver a usar o compartir en proyectos. En este caso, crearemos una función llamada Hello que imprima Hello World.

      Abra su archivo greet.go en su editor de texto y añada el siguiente código:

      greet.go

      package greet
      
      import "fmt"
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Desglosaremos este primer archivo. En la primera línea de cada archivo se necesita el nombre del package en el que trabaje. Debido a que se encuentra en el paquete greet, utiliza la palabra package seguida del nombre del paquete:

      package greet
      

      Esto indicará al compilador que considere todo en el archivo como parte del paquete greet.

      Luego, declare cualquier otro paquete que deba usar con la instrucción import. Sólo usará uno en este archivo: fmt:

      import "fmt"
      

      Por último, cree la función Hello. Se usará el paquete fmt para imprimir Hello, World!:

      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Ahora que escribió el paquete greet, puede utilizarlo en cualquier otro paquete que cree. Crearemos un nuevo paquete en el que usará su paquete greet.

      Crearemos un paquete llamado example, lo cual significa que necesita un directorio llamado example. Cree este paquete en su organización gopherguides, para que la estructura de directorios tenga el siguiente aspecto:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
                          └── example
      

      Ahora que dispone del directorio para su nuevo paquete, puede crear el archivo de punto de entrada. Debido a que este será un programa ejecutable, es recomendable asignarle el nombre main.go:

      └── $GOPATH
          └── src
              └── github.com
                  └── gopherguides
                      └── example
                          └── main.go
      

      En su editor de texto, abra main.go y añada el siguiente código para invocar al paquete greet:

      main.go

      package main
      
      import "github.com/gopherguides/greet"
      
      func main() {
          greet.Hello()
      }
      

      Debido a que importará un paquete, debe invocar la función haciendo referencia al nombre del paquete en notación de punto. La notación de punto es la práctica de poner un punto . entre el nombre del paquete que usa y el recurso en ese paquete que quiere usar. Por ejemplo, en su paquete greet, tiene la función Hello como recurso. Si desea invocar ese recurso, debe utilizar la notación de punto de greet.Hello().

      Ahora, podrá abrir su terminal y ejecutar el programa en la línea de comandos:

      Cuando lo haga, verá el siguiente resultado:

      Output

      Hello, World!

      Para ver cómo puede usar variables en un paquete, añadiremos una definición variable en su archivo greet.go:

      greet.go

      package greet
      
      import "fmt"
      
      var Shark = "Sammy"
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Luego, abra su archivo main.go y añada la siguiente línea resaltada para invocar a la variable de greet.go en una función fmt.Println():

      main.go

      package main
      
      import (
          "fmt"
      
          "github.com/gopherguides/greet"
      )
      
      func main() {
          greet.Hello()
      
          fmt.Println(greet.Shark)
      }
      

      Una vez que ejecute el programa de nuevo:

      Obtendrá el siguiente resultado:

      Output

      Hello, World! Sammy

      Por último, también definiremos un tipo en el archivo greet.go. Crearás el tipo Octopus con los campos name y color, y una función que imprimirá los campos cuando se invoque:

      greet.go

      package greet
      
      import "fmt"
      
      var Shark = "Sammy"
      
      type Octopus struct {
          Name  string
          Color string
      }
      
      func (o Octopus) String() string {
          return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color)
      }
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Abra main.go para crear una instancia de ese tipo al final del archivo:

      main.go

      package main
      
      import (
          "fmt"
      
          "github.com/gopherguides/greet"
      )
      
      func main() {
          greet.Hello()
      
          fmt.Println(greet.Shark)
      
          oct := greet.Octopus{
              Name:  "Jesse",
              Color: "orange",
          }
      
          fmt.Println(oct.String())
      }
      

      Una vez que haya creado una instancia de tipo Octupus con oct := greet.Octopus, podrá acceder a las funciones y los campos del tipo dentro del espacio de nombres del archivo main.go. Esto le permite escribir oct.String() en la última línea sin invocar a greet. También podrías invocar uno de los campos de tipo como oct.Color sin hacer referencia al nombre del paquete greet.

      El método String del tipo Octopus utiliza la función fmt.Sprintf para crear una frase y muestra con returns el resultado, una cadena, al elemento de llamada (en este caso, su programa principal).

      Cuando ejecute el programa, verá el siguiente resultado:

      Output

      Hello, World! Sammy The octopus's name is "Jesse" and is the color orange.

      Al crear el método String en Octopus, accede a una alternativa reutilizable para imprimir información sobre su tipo personalizado. Si quiere cambiar el comportamiento de este método en el futuro, solo tiene que editarlo.

      Código exportado

      Posiblemente haya observado que todas las declaraciones del archivo de greet.go que invocó llevaban mayúsculas. Go no incluye, como otros lenguajes, el concepto de modificadores public, private o protected. La visibilidad externa se controla con mayúsculas. Los tipos, las variables, las funciones y otros elementos que empiezan con mayúsculas están disponibles de forma pública, fuera del paquete actual. Un símbolo visible fuera de su paquete se considera como exported.

      Si añade un nuevo método a Octopus llamado reset, puede invocarlo desde el interior del paquete greet, pero no desde su archivo main.go, que se encuentra fuera del paquete greet:

      greet.go

      package greet
      
      import "fmt"
      
      var Shark = "Sammy"
      
      type Octopus struct {
          Name  string
          Color string
      }
      
      func (o Octopus) String() string {
          return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color)
      }
      
      func (o *Octopus) reset() {
          o.Name = ""
          o.Color = ""
      }
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      
      

      Si intenta invocar reset desde el archivo main.go:

      main.go

      package main
      
      import (
          "fmt"
      
          "github.com/gopherguides/greet"
      )
      
      func main() {
          greet.Hello()
      
          fmt.Println(greet.Shark)
      
          oct := greet.Octopus{
              Name:  "Jesse",
              Color: "orange",
          }
      
          fmt.Println(oct.String())
      
          oct.reset()
      }
      

      Verá el siguiente error de compilación:

      Output

      oct.reset undefined (cannot refer to unexported field or method greet.Octopus.reset)

      Para aplicar export a la funcionalidad reset desde Octopus, use la R mayúscula en reset:

      greet.go

      package greet
      
      import "fmt"
      
      var Shark = "Sammy"
      
      type Octopus struct {
          Name  string
          Color string
      }
      
      func (o Octopus) String() string {
          return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color)
      }
      
      func (o *Octopus) Reset() {
          o.Name = ""
          o.Color = ""
      }
      
      func Hello() {
          fmt.Println("Hello, World!")
      }
      

      Como resultado, puede invocar a Reset desde su otro paquete sin obtener un error:

      main.go

      package main
      
      import (
          "fmt"
      
          "github.com/gopherguides/greet"
      )
      
      func main() {
          greet.Hello()
      
          fmt.Println(greet.Shark)
      
          oct := greet.Octopus{
              Name:  "Jesse",
              Color: "orange",
          }
      
          fmt.Println(oct.String())
      
          oct.Reset()
      
          fmt.Println(oct.String())
      }
      

      Ahora, si ejecuta el programa:

      Recibirá el siguiente resultado:

      Output

      Hello, World! Sammy The octopus's name is "Jesse" and is the color orange The octopus's name is "" and is the color .

      Al invocar Reset, eliminó toda la información de los campos Name y Color. Cuando invoque el método String, este no imprimirá nada donde normalmente aparecen Name y Color porque los campos ahora estarán vacíos.

      Conclusión

      Escribir un paquete de Go es lo mismo que escribir cualquier archivo de Go, pero insertarlo en otro directorio le permite aislar el código para que pueda reutilizarse desde cualquier lugar. En este tutorial, se abordó la forma de escribir las definiciones dentro de un paquete, se demostró la manera de usar esas definiciones en otro archivo de programación de Go y se explicaron las opciones para guardar el paquete a fin de acceder a él.



      Source link

      Cómo escribir instrucciones switch en Go


      Introducción

      Las instrucciones condicionales brindan a los programadores la capacidad indicar a sus programas que realicen una acción si una condición es verdadera y otra si la condición es falsa. Con frecuencia, nos conviene comparar alguna variable con múltiples valores posibles y realizar diferentes acciones en cada circunstancia. Es posible lograr esto utilizando solo instrucciones if. Sin embargo, escribir software no solo se trata de lograr que las cosas funcionen, sino también de comunicar su intención a usted mismo en el futuro y a otros desarrolladores. switch es una instrucción condicional alternativa útil para comunicar las acciones realizadas por sus programas de Go cuando se les presentan diferentes opciones.

      Todo lo que podamos escribir con la instrucción de switch también se puede escribir con instrucciones if. En este tutorial, veremos algunos ejemplos de lo que puede lograr la instrucción switch, las instrucciones if que sustituye y en que situaciones se aplica de forma más adecuada.

      Estructura de las instrucciones Switch

      Switch se utiliza comúnmente para describir las acciones efectuadas por un programa cuando a una variable se le asignan valores específicos. En el siguiente ejemplo se muestra la forma en que lograríamos esto usando instrucciones if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              if flav == "strawberry" {
                  fmt.Println(flav, "is my favorite!")
                  continue
              }
      
              if flav == "vanilla" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              if flav == "chocolate" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              fmt.Println("I've never tried", flav, "before")
          }
      }
      

      Esto generará el siguiente resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Dentro de main, definimos un slice de sabores de helado. Luego usaremos un for loop para iterarlos. Utilizamos tres instrucciones if para imprimir diferentes mensajes que indican preferencias por diferentes sabores de helado. Cada instrucción if debe usar la instrucción continue para detener la ejecución del bucle for, de modo que el mensaje predeterminado al final no se imprima para los sabores de helado preferidos.

      Al añadir nuevas preferencias de helado, debemos seguir agregando instrucciones if para manejar los nuevos casos. En los mensajes duplicados, como en el caso de “vanilla” y “chocolate”, deben estar duplicadas las instrucciones if. Para los futuros lectores de nuestro código (incluidos nosotros), la naturaleza repetitiva de las instrucciones if oculta la parte importante de lo que hacen, (cuando se compara la variable con varios valores y tomando y se toman diferentes acciones). Además, nuestro mensaje de reserva se distingue de los condicionales y hace que parezca que no está relacionado. La instrucción switch puede servirnos para organizar mejor esta lógica.

      La instrucción switch comienza con la palabra clave switch y le sigue, en su forma más básica, alguna variable contra la cual puedan realizarse comparaciones. A esto le sigue un par llaves ({}) en el que pueden aparecer varias_ cláusulas de caso_. Las cláusulas de caso describen las acciones que su programa de Go debe realizar cuando la variable proporcionada a la instrucción switch es igual al valor referido por las cláusulas de caso. El siguiente ejemplo convierte el ejemplo anterior para que utilice switch en lugar de varias instrucciones if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      El resultado es el mismo que el anterior:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Una vez más, definimos un segmento de sabores de helado en main y usamos la instrucción range para iterar cada sabor. Sin embargo, esta vez usamos una instrucción switch que examinará la variable flav. Utilizamos dos cláusulas case para indicar las preferencias. Ya no necesitamos las instrucciones continue porque la instrucción switch solo ejecutará una cláusula case. También podemos combinar la lógica duplicada de los condicionales “chocolate” y “vanilla” separando cada uno con una coma en la declaración de la cláusula case. La cláusula default sirve como cláusula general. Se ejecutará para cualquier sabor que no hayamos tenido en cuenta en el cuerpo de la instrucción switch. En este caso, “banana” hará que se ejecute default, con lo cual se imprimirá el mensaje I've never tried banana before.

      Esta forma simplificada de las instrucciones switch aborda el uso más común para ellas: comparar una variable con varias alternativas. También nos proporciona practicidad cuando queremos realizar la misma acción para varios valores diferentes y cualquier otra acción cuando no se cumple ninguna de las condiciones enumeradas al usar la palabra clave default.

      Cuando esta forma simplificada de switch resulta demasiado limitada, podemos usar una forma más general de la instrucción switch.

      Instrucciones generales de switch

      Las instrucciones switch son útiles para agrupar las colecciones de condicionales más complicadas a fin de mostrar que están de algún modo relacionadas. Esto se utiliza con mayor frecuencia al comparar una variable con un rango de valores, en lugar de valores específicos como en el ejemplo anterior. El siguiente ejemplo implementa un juego de adivinanzas usando instrucciones if que se podrían beneficiar con una instrucción switch:

      package main
      
      import (
          "fmt"
          "math/rand"
          "time"
      )
      
      func main() {
          rand.Seed(time.Now().UnixNano())
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              if guess > target {
                  fmt.Println("Too high!")
                  continue
              }
      
              if guess < target {
                  fmt.Println("Too low!")
                  continue
              }
      
              fmt.Println("You win!")
              break
          }
      }
      

      El resultado puede variar dependiendo del número aleatorio que seleccionó y de lo bien que se desempeñe en el juego. A continuación, se muestra el resultado de una sesión de ejemplo:

      Output

      Enter a guess: 10 Too low! Enter a guess: 15 Too low! Enter a guess: 18 Too high! Enter a guess: 17 You win!

      En nuestro juego de adivinanzas se requiere un número al azar para compararlas, por lo que usamos la función rand.Intn del paquete math/rand. A fin de asegurarnos de obtener valores diferentes para target cada vez que juguemos, usamos rand.Seed para aleatorizar el generador de números aleatorios según la hora actual. El argumento 100 en rand.Intn nos proporcionará un número dentro del rango de 0 a 100. Luego, usaremos un bucle for para comenzar a recopilar adivinanzas del jugador.

      La función fmt.Scanf nos proporciona un medio para leer las entradas del usuario en una variable que elijamos. Se requiere un verbo de cadena de formato que convierta la entrada del usuario al tipo que esperamos. Aquí %d significa que esperamos un int y pasamos la dirección de la variable guess de modo que fmt.Scanf pueda establecer esa variable. Después de manejar cualquier error de análisis, usamos dos instrucciones if para comparar la adivinanza del usuario con el valor target. El string que muestran, junto con bool, controla el mensaje que se presenta al jugador y si el juego se cerrará.

      Estas instrucciones if ocultan el hecho de que el rango de valores con los que se compara la variable están todos relacionados de alguna manera. También puede ser difícil, a simple vista, saber si faltó alguna parte del rango. En el siguiente ejemplo se vuelve a refactorizar el ejemplo anterior para usar una instrucción switch en su lugar:

      package main
      
      import (
          "fmt"
          "math/rand"
      )
      
      func main() {
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              switch {
              case guess > target:
                  fmt.Println("Too high!")
              case guess < target:
                  fmt.Println("Too low!")
              default:
                  fmt.Println("You win!")
                  return
              }
          }
      }
      

      Con esto, se mostrará un resultado similar al siguiente:

      Output

      Enter a guess: 25 Too low! Enter a guess: 28 Too high! Enter a guess: 27 You win!

      En esta versión del juego de adivinanzas, se sustituyó el bloque de instrucciones if por una instrucción switch. Se omite el argumento de la expresión de switch, ya que solo nos interesa recopilar los condicionales juntos utilizando switch. Cada cláusula case contiene una expresión diferente que compara guess con target. Como la primera vez que sustituimos las instrucciones if por switch, ya no necesitamos las instrucciones continue porque solo se ejecutará una cláusula case. Por último, la cláusula default se encarga del caso en el que guess == target, ya que cubrimos todos los demás valores posibles con las otras dos cláusulas case.

      En los ejemplos que vimos hasta el momento, se ejecutará exactamente una instrucción caso. De vez en cuando, es posible que desee combinar los comportamientos de varias cláusulas case. Las instrucciones switch proporcionan otra palabra clave para lograr este comportamiento.

      Fallthrough

      A veces, querrá volver a utilizar el código que otra cláusula case contiene. En estos casos, es posible solicitar que Go ejecute el cuerpo de la siguiente cláusula case enumerada usando la palabra clave fallthrough. En el siguiente ejemplo, se modifica nuestro ejemplo anterior de sabores de helado para reflejar con mayor precisión nuestro entusiasmo por el helado de fresa:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
                  fallthrough
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      Veremos el siguiente resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! strawberry is great! I've never tried banana before

      Como ya lo observamos antes, definimos un segmento string para representar los sabores e iterar este usando un bucle for. La instrucción switch aquí es idéntica a la que vimos antes, pero se agrega la clave fallthrough al final de la cláusula case para “strawberry”. Esto hará que Go ejecute el cuerpo de case “strawberry”:, imprimiendo primero la cadena strawberry is my favorite!. Cuando este encuentre fallthrough, ejecutará el cuerpo de la cláusula case siguiente. Esto hará que el cuerpo de case “vanilla”, “chocolate”: se ejecute e imprima strawberry is great!.

      Los desarrolladores de Go no utilizan la palabra clave fallthrough a menudo. Normalmente, la reutilización del código mediante fallthrough se puede obtener de mejor manera definiendo una función con el código común. Por estas razones, generalmente no se recomienda utilizar fallthrough.

      Conclusión

      Las instrucciones switch nos ayudan a transmitir, a otros desarrolladores que leen nuestro código, que una serie de comparaciones están de alguna manera relacionadas entre sí. Hacen que sea mucho más fácil añadir comportamientos diferentes cuando un nuevo caso se añade en el futuro y permite garantizar que cualquier cosa que se haya olvidado se maneje de manera adecuada también con cláusulas default. La próxima vez que tenga que escribir varias instrucciones if que impliquen todas la misma variable, intente reescribirla con una instrucción switch, le resultará más sencillo volver a trabajar cuando llegue el momento de considerar algún otro valor alternativo.

      Si desea obtener más información acerca del lenguaje de programación de Go, consulte toda la serie sobre Cómo realizar codificaciones en Go.



      Source link

      Cómo escribir su primer programa en Go


      Introducción

      El programa “Hello, World!” es un clásico y una tradición reconocida en la programación computacional. Se trata de un primer programa sencillo y completo para principiantes y es una buena alternativa para garantizar que su entorno se configure de manera adecuada.

      Este tutorial le servirá como guía para crear este programa en Go. Sin embargo, para hacer que el programa sea más interesante, modificará el programa tradicional “Hello, World!” a fin de que solicite al usuario su nombre. Luego usará el nombre en el saludo. Al completar el tutorial, obtendrá un programa que tendrá el siguiente aspecto cuando lo ejecute:

      Output

      Please enter your name. Sammy Hello, Sammy! I'm Go!

      Requisitos previos

      Antes de comenzar este tutorial, deberá disponer de un entorno de desarrollo local de Go configurado en su computadora. Puede configurarlo a través de uno de los siguientes tutoriales:

      Paso 1: Escribir el programa básico “Hello, World!”

      Para escribir el programa “Hello, World!”, abra un editor de texto de línea de comandos como nano y cree un nuevo archivo:

      Una vez que el archivo de texto se abra en la ventana del terminal, escribirá su programa:

      hello.go

      package main
      
      import "fmt"
      
      func main() {
        fmt.Println("Hello, World!")
      }
      

      Desglosaremos los diferentes componentes del código.

      package es una palabra clave de Go que define el paquete de código al que pertenece este archivo. Solo puede haber un paquete por carpeta y cada archivo .go debe declarar el mismo nombre de paquete en la parte superior de su archivo. En este ejemplo, el código pertenece al paquete main.

      import es una palabra clave de Go que indica al compilador de Go los demás paquetes que quiere usar en este archivo. Aquí, se importa el paquete fmt que viene con la biblioteca estándar. El paquete fmt proporciona funciones de formato e impresión que pueden ser útiles en el desarrollo.

      fmt.Println es una función de Go que se encuentra en el paquete fmt e indica a la computadora que imprima texto en la pantalla.

      Se sigue la función fmt.Println con una secuencia de caracteres, como “Hello, World!”, escrita entre comillas. Todos los caracteres que se encuentran entre comillas se conocen como cadenas. La función fmt.Println imprimirá estas cadenas en la pantalla cuando se ejecute el programa.

      Guarde y cierre nano escribiendo CTRL + X. Cuando se le pregunte si desea guardar el archivo, pulse Y.

      Ahora podrá probar su programa.

      Paso 2: Ejecutar un programa de Go

      Una vez que escriba su programa “Hello, World!”, estará listo para la ejecución. Usará el comando go, seguido del nombre del archivo que acaba de crear.

      El programa ejecutará y mostrará este resultado:

      Output

      Hello, World!

      Analizaremos lo que realmente sucedió.

      Los programas de Go deben compilarse antes de su ejecución. Cuando invoque a go run con el nombre de un archivo, en este caso hello.go, el comando go compilará la aplicación y luego ejecutará el binario resultante. Para los programas escritos en lenguajes de programación compilados, un compilador tomará el código fuente de un programa y generará otro tipo de código de bajo nivel (como el código de máquina) para producir un programa ejecutable.

      Las aplicaciones de Go requieren un paquete main y precisamente una función main() que sirva como punto de entrada para ellas. La función main no recibe argumentos ni muestra valores. En lugar de ello, indica al compilador de Go que el paquete debe compilarse como un paquete ejecutable.

      Una vez que este se compila, se ejecuta el código ingresando la función main() en el paquete main. Ejecuta la línea fmt.Println(“Hello, World!”) llamando a la función fmt.Println. El valor de la cadena de Hello, World! luego se pasa a la función. En este ejemplo, la cadena Hello, World! también se conoce como argumento porque es un valor que se pasa a un método.

      Las citas que están en ambos lados de Hello, World! no se imprimen en la pantalla porque se utilizan para indicar a Go dónde comienza y termina su cadena.

      Siguiendo este paso, creó un programa funcional “Hello, World!” con Go. En el siguiente paso, aprenderá a hacer que el programa sea más interactivo.

      Paso 3: Solicitar entradas del usuario

      Cada vez que ejecuta su programa, produce el mismo resultado. En este paso, puede agregar a su programa la función para que solicite el nombre del usuario. Luego usará el nombre de este en el resultado.

      En lugar de modificar su programa existente, cree uno nuevo llamado greeting.go con el editor nano:

      Primero, añada este código, el cual solicita al usuario que ingrese su nombre:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
      }
      

      Una vez más, utilice la función fmt.Println para imprimir texto en la pantalla.

      Añada ahora la línea resaltada para almacenar la entrada del usuario:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
      }
      

      La línea var name string creará una nueva variable usando la palabra clave var. Se asigna a la variable el nombre name y pertenece al tipo string.

      A continuación, añada la línea resaltada para capturar la entrada del usuario:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
        fmt.Scanln(&name)
      }
      

      El método fmt.Scanln indica a la computadora que espere una entrada del teclado que termine con una nueva línea o (n), carácter. Esto hace que el programa se detenga, lo cual permite que el usuario introduzca cualquier texto que desee. El programa se reanudará cuando el usuario presione la tecla ENTER en su teclado. Todas las pulsaciones de teclas, incluida la de la tecla ENTER, se capturan y se convierten en una cadena de caracteres.

      Le convendrá usar esos caracteres en el resultado de su programa, por lo que los guardará escribiéndolos en la variable de cadena llamada name. Go almacena esa cadena en la memoria de su computadora hasta que el programa termine de ejecutarse.

      Por último, añada la siguiente línea resaltada en su programa para imprimir el resultado:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
        fmt.Scanln(&name)
        fmt.Printf("Hi, %s! I'm Go!", name)
      }
      

      Esta vez, en lugar de usar de nuevo el método fmt.Println, empleará fmt.Println. La función fmt.Printf toma una cadena y al utilizar verbos especiales de impresión, (%s), inserta el valor de name en la cadena. Se requiere esto porque Go no admite la interpolación de cadenas, lo cual le permitiría tomar el valor asignado a una variable y disponerlo dentro de una cadena.

      Guarde y cierre nano presionando CTRL + X, y presione Y cuando se le pregunte si desea guardar el archivo.

      Ahora ejecute el programa. Se le solicitará su nombre; introdúzcalo y presione ENTER. Es posible que resultado no sea exactamente el que espera:

      Output

      Please enter your name. Sammy Hi, Sammy ! I'm Go!

      En lugar de Hi, Sammy! I'm Go!, hay una salto de línea inmediatamente después del nombre.

      El programa capturó todas sus pulsaciones de teclas, incluida la tecla ENTER que presionamos para indicar al programa que continúe. En una cadena, al presionar la tecla ENTER se crea un carácter especial que crea una nueva línea. El resultado del programa cumple exactamente con lo que usted indicó; muestra el texto que ingresó, incluida esa nueva línea. No es lo que esperaba del resultado, pero puede corregirlo con funciones adicionales.

      Abra el archivo greeting.go en su editor:

      Ubique la siguiente línea en su programa:

      greeting.go

      ...
      fmt.Scanln(&name)
      ...
      

      Añada la siguiente línea justo después de esta:

      greeting.go

      name = strings.TrimSpace(name)
      

      Esto utiliza la función TrimSpace, del paquete strings de la biblioteca estándar de Go, en la cadena que capturó con fmt.Scanln. La función strings.TrimSpace elimina todos los caracteres de espacio, incluidas las líneas nuevas, del inicio y del final de una cadena. En este caso, elimina el carácter de nueva línea al final de la cadena que se creó cuando presionó ENTER.

      Para usar el paquete strings deberá importarlo en la parte superior del programa.

      Ubique las siguientes líneas en su programa:

      greeting.go

      import (
          "fmt"
      )
      

      Añada la siguiente línea para importar el paquete strings:

      greeting.go

      import (
          "fmt"
        "strings"
      )
      

      Su programa ahora contendrá lo siguiente:

      greeting.go

      package main
      
      import (
              "fmt"
              "strings"
      )
      
      func main() {
          fmt.Println("Please enter your name.")
          var name string
          fmt.Scanln(&name)
          fmt.Printf("Hi, %s! I'm Go!", name)
          name = strings.TrimSpace(name)
      }
      

      Guarde y cierre nano. Presione CTRL + X y luego Y cuando se le solicite guardar el archivo.

      Ejecute el programa de nuevo:

      Esta vez, después de ingresar su nombre y presionar ENTER, obtendrá el resultado esperado:

      Output

      Please enter your name. Sammy Hi, Sammy! I'm Go!

      Ahora, contará con un programa de Go que obtiene entradas de un usuario y las imprime de vuelta en la pantalla.

      Conclusión

      A través de este tutorial, escribió un programa “Hello, World!” que obtiene entradas de un usuario, procesa el producto y muestra el resultado. Ahora que dispone de un programa básico con el que trabajará, intente ampliarlo. Por ejemplo, solicite el color favorito del usuario y haga que el programa diga que su color favorito es el rojo. Puede, incluso, intentar usar esta misma técnica para crear un programa sencillo de Mad-Lib.



      Source link