Golang

package main

import (

"fmt"

"math"

"runtime"

"strings"

"os"

"log"

/**

*Comentario

*multilínea

*en Go!

*/

type Fruta string

const(

MANZANA Fruta = "MANZANA"

PERA Fruta = "PERA"

PLATANO Fruta = "PLATANO"

UVA Fruta = "UVA"

func minimo(x, y int) int{

if x < y {
 return x

return y

type Saludo struct{

nombre string

func (s *Saludo) Saludar() {

fmt.Println("Welcome, ",s.nombre)

type Vertex struct {

X int

Y int

type Modelo struct{

nombre string

numero int

activado bool

type Directorio struct{

nombre string

longitud int

existe bool

}
func enumeraciones(){

var miFruta Fruta = MANZANA

fmt.Println("Fruta: ",miFruta)

switch opc:= miFruta; opc{

case MANZANA:

fmt.Println("$13.0")

case PERA:

fmt.Println("$10.0")

case PLATANO:

fmt.Println("$11.0")

case UVA:

fmt.Println("$23.0")

default:

fmt.Println("No hay registros")

func clases(){

fmt.Println("Vertex",Vertex{1, 2})

my_modelo := Modelo{ "MX-123", 11, true}

fmt.Println("Modelo",my_modelo)

mySaludo := Saludo{"Fernando"}

mySaludo.Saludar()

func archivos(){

var directorio string = "C:\\Directorio"

 fileStat, err := os.Stat(directorio)

if err != nil {

log.Fatal(err)

fmt.Println("Nombre:", fileStat.Name())

fmt.Println("Tamaño:", fileStat.Size())

fmt.Println("Permisos:", fileStat.Mode())

fmt.Println("Ultima modificacion:", fileStat.ModTime())

fmt.Println("Es directorio?: ", fileStat.IsDir())

var existe bool = fileStat!=nil

myDirectorio := Directorio{fileStat.Name(), int(fileStat.Size()),existe}

fmt.Println("Nombre archivo: ",myDirectorio.nombre)

fmt.Println("Longitud: ",myDirectorio.longitud)

fmt.Println("Existe?: ",myDirectorio.existe)

func triple(numero int) int {

return numero*3

func resta(x, y int) int {

return x - y

func swap (x, y string) (string, string){

 return y, x

func split(sum int) (x, y int) {

x = sum * 4/9

y = sum - x

return

func metodo() {

fmt.Println("***Metodo en Golang***")

var cadena string //""

var x, y, z int //0,0,0

var verdadero, falso bool//false, false

var real float32 //0.0

var naranja string ="Naranja"

cadena = "FERROCARRILERO"

x, y, z = 0, 1 , 2

verdadero, falso = false, true

real = 67.5

fmt.Printf("Cadena: %s\n",cadena)

fmt.Printf("x: %d, y: %d, z:%d \n",x,y,z)

fmt.Printf("verdadero: %t, falso: %t \n",verdadero,falso)

fmt.Printf("Real: %f \n",real)

fmt.Printf("Naranja = %s\n",naranja)
 //Declaración multiple

var(

x1, y1 int = 9, 21

c1, c2, c3 string = "A","X","T"

verdaderos bool = true

r1, r2 float64 = 9.777, 12.4300

fmt.Println("*** Tipos ***")

fmt.Printf("%d, %d\n",x1,y1)

fmt.Printf("%s, %s, %s\n",c1,c2,c3)

fmt.Printf("%t\n",verdaderos)

fmt.Printf("%f, %f\n",r1,r2)

//Conversiones

var entero int = 45

var flotante float64 = float64(entero)

fmt.Printf("Entero: %d\n",entero)

fmt.Printf("Flotante: %f\n",flotante)

func condicional(){

var verdadero bool

var numero int

numero = 33

if(numero >= 33){

verdadero = true
 }

if(verdadero){

fmt.Println("Es verdadero!!")

//Se usa := para ahorrarse la declaración de tipo

booleano := "true"

if(booleano == "true"){

fmt.Println("Concuerda con la cadena")

const PI = 3.1415

if(PI == 3.1415){

fmt.Println("Es el mismo valor!!")

switch os := runtime.GOOS; os {

case "darwin":

fmt.Println("OS X.")

case "linux":

fmt.Println("Linux.")

default:

fmt.Printf("Sistema operativo %s.\n", os)

os:="windows NT"

if("windows" == os){

fmt.Println("Es el sistema Windows")

 }else{

fmt.Println("No es un sistema Windows")

func arreglo(){

fmt.Println("*** Arreglo ***")

p := []int{2, 3, 5, 7, 11, 13}

fmt.Println("p ==", p)

for i := 0; i < len(p); i++ {

fmt.Printf("p[%d] == %d\n",

i, p[i])

func ciclos(){

fmt.Println("Ciclos:")

sum := 0

for i := 0; i < 10; i++ {

sum += i

fmt.Println(sum)

fmt.Println("**********************")

var cont int

cont = 1
 const MAX = 10

for ; cont < MAX ; {

cont += cont

fmt.Println(cont)

fmt.Printf("Total: %d\n",cont)

cont = 2

for cont < MAX {

cont += cont

fmt.Printf("Numero: %d\n",cont)

fmt.Printf("#Suma total: %d\n",cont)

suma := 1

const TAM = 1000

for suma < TAM {

suma += 20

fmt.Println(suma)

fmt.Printf("Total: %d\n",suma)

fmt.Println()

cont = 0

suma = 1

for cont < TAM {

suma += suma + (suma + cont)

cont += 1

fmt.Printf("%d\n",suma)

if suma > 700 {

 break

fmt.Println("Suma: ",suma)

func main() {

metodo()

condicional()

ciclos()

arreglo()

fmt.Printf("Hola, mundo\n")

fmt.Println("Feliz Dia ", math.Pi, "!!")

fmt.Printf("Ahora tu tienes %g problemas.",

math.Nextafter(2, 3))

fmt.Printf("\nTriple de 5 es %d", triple(5))

fmt.Printf("\nResta de 4 y 6 nos da: %d \n",resta(4,6))

m, n := swap("Ciao","Arrivaderci")

fmt.Println(m, n)

fmt.Println(split(17))

clases()

cadenas()

archivos()

args := os.Args

if len(args) > 0{

arg := args[1]

fmt.Println("Hola, ",arg);
 }else{

fmt.Println("Hola, Golang!!")

enumeraciones()

func cadenas(){

var cad1 string = "EL CURIOSO CASO DEL DOCTOR JOB."

var longitud int = len(cad1)

fmt.Printf("Cadena = %s , Longitud = %d \n",cad1,longitud)

if cad1 == "EL CURIOSO CASO DEL DOCTOR JON."{

fmt.Println("No son identicas")

}else{

fmt.Println("Son identicas")

if strings.EqualFold(cad1,"EL CURIOSO CASO DEL DOCTOR JOB.") {

fmt.Println("Son iguales!!")

if strings.Contains(strings.ToLower(cad1),"o"){

fmt.Printf("No. de letras o en la cadena:

%d\n",strings.Count(strings.ToLower(cad1),"o"))

fmt.Println(strings.Split(cad1," "))