Variables en Golang: cómo usar las variables de Go

Las variables de Golang son explícitamente declaradas y utilizadas por el compilador para verificar la corrección de tipos de las llamadas a funciones. Variable es el nombre dado a la ubicación de la memoria para almacenar el valor de un tipo particular. Existen numerosas sintaxis para declarar variables en go. Una variable es una ubicación de almacenamiento con un tipo particular y un nombre asociado.

Variables de Golang

Go variable es un marcador de posición de la información que se puede cambiar en tiempo de ejecución. La variable nos permite recuperar y manipular la información almacenada.

Reglas para nombrar variables

1. Los nombres de las variables deben comenzar con una letra o un guión bajo (_). Y los nombres pueden contener las letras ' az ' o ' AZ ' o dígitos 0-9 y el carácter '_'.

AppDividend, apps, _dividend  // valid variable
123apps, '2appdividend      // invalid variable

2. Un nombre de variable no debe comenzar con un dígito.

11appdividend  // illegal variable

3. El nombre de la variable distingue entre mayúsculas y minúsculas.

apps and Apps are two different variables

4. No se permite el uso de palabras clave como nombre de variable.

5. No hay límite en la longitud del nombre de la variable, pero se recomienda utilizar una longitud óptima de 4 a 15 letras únicamente.

Declarar una sola variable

 

Uso de la palabra clave var:  en el lenguaje Go, las variables se crean utilizando la palabra clave var  de un tipo particular, conectado con el nombre y proporciona su valor inicial.

Sintaxis:

var variable_name type = expression

Puntos importantes:

1. En la sintaxis anterior, tanto el  tipo  como  la expresión = pueden eliminarse, pero no ambos pueden eliminarse en la declaración de una variable.
2. Si se elimina el tipo, el tipo de variable se determina mediante el valor de inicialización en la expresión.

El tipo de nombre var  es la sintaxis para declarar una sola variable.

package main

import "fmt"

func main() {
    var series string // variable declare
    fmt.Println(series)
}

La sentencia var series string declara la variable denominada series  de tipo  string . No hemos asignado ningún valor a la variable serie.

Si a una variable no se le asigna ningún valor, go la inicializa automáticamente con el valor vacío o 0 (si es un número entero) del tipo de variable. En este caso, a la serie se le asigna el valor vacío. Si la variable es un número entero, entonces se le asignará 0.

 

Si ejecuta el programa anterior, puede ver que el valor de la variable está vacío.

Declarar una variable con un valor inicial

Consulte el siguiente código.

// hello.go

package main

import "fmt"

func main() {
    var series string = "The Witcher"
    fmt.Println(series)
}

Producción

go run hello.go
The Witcher

Diferentes tipos de datos

Veamos un ejemplo donde declaramos diferentes variables de tipo de datos.

// hello.go

package main

import "fmt"

func main() {

    var game = 20
    var kgb = "Stranger In Moscow"
    var lockey = true

    fmt.Printf("The value of game is : %d\n",
        game)

    fmt.Printf("The type of game is : %T\n",
        game)

    fmt.Printf("The value of kgb is : %s\n",
        kgb)

    fmt.Printf("The type of kgb is : %T\n",
        kgb)

    fmt.Printf("The value of lockey is : %t\n",
        lockey)

    fmt.Printf("The type of lockey is : %T\n",
        lockey)

}

Producción

go run hello.go
The value of game is : 20
The type of game is : int
The value of kgb is : Stranger In Moscow
The type of kgb is : string
The value of lockey is : true
The type of lockey is : bool

Una variable se puede asignar a cualquier valor de su tipo de datos. En el programa anterior, al juego se le asigna un valor entero, KGB tiene un valor de cadena y lockey tiene un valor booleano.

Inferencia de tipos en Golang

Si la variable tiene un valor inicial, Go inferirá automáticamente el tipo de esa variable usando ese valor inicial. Por lo tanto, si la variable tiene un valor inicial,  se puede omitir el tipo en la declaración de la variable.

Si una variable se declara usando la sintaxis  var nombre = valor inicial , Golang inferirá automáticamente el tipo de esa variable a partir de un valor inicial. Go entenderá el tipo de variables inicializadas.

Consulte el siguiente código.

// hello.go

package main

import "fmt"

func main() {

    var game = 20
    fmt.Printf("The value of game is : %d\n",
        game)

    fmt.Printf("The type of game is : %T\n",
        game)
}

En el código anterior, hemos definido una variable = 20, lo que significa que la variable del juego tiene un tipo entero porque 20 es un valor entero, por lo que no necesitamos definir su tipo de datos explícitamente.

Múltiples declaraciones de variables

Se pueden declarar múltiples variables en una sola declaración en Go.

La var nombre1, tipo nombre2 = valorinicial1, valorinicial2  es la sintaxis para la declaración de variables múltiples de Golang.

Consulte el siguiente código.

// hello.go

package main

import "fmt"

func main() {

    var game, set = 1, 2
    fmt.Printf("The value of game is : %d\n",
        game)

    fmt.Printf("The value of set is : %d\n",
        set)
}

Producción

go run hello.go
The value of game is : 1
The value of set is : 2

Si no se define un valor inicial para las variables de juego y conjunto, tendrán asignado 0 como valor inicial.

// hello.go

package main

import "fmt"

func main() {

    var game, set int
    fmt.Printf("The value of game is : %d\n",
        game)

    fmt.Printf("The value of set is : %d\n",
        set)
}

Producción

go run hello.go
The value of game is : 0
The value of set is : 0

Declaración de variable corta de Golang

Golang también proporciona otra forma concisa de declarar variables. Esto se conoce como declaración abreviada y utiliza el  operador := .

Las variables locales que se declaran e inicializan en las funciones se declaran mediante una declaración de variable breve.

La declaración abreviada requiere valores iniciales para todas las variables en el lado izquierdo de la asignación.

Consulte la sintaxis de declaración de variable corta.

variable_name:= expression

Consulte el siguiente código.

// hello.go

package main

import "fmt"

func main() {

    askingPrice := 100
    payingPrice := 50
    fmt.Println("Asking Price is", askingPrice, "Paying price is", payingPrice)
}

Producción

go run hello.go
Asking Price is 100 Paying price is 50

La mayoría de las variables locales se declaran e inicializan mediante declaraciones de variables cortas debido a su brevedad y flexibilidad.

La declaración de variables var se utiliza para aquellas variables locales que necesitan un tipo explícito que difiera de la expresión del inicializador o para aquellas variables cuyos valores se asignan más tarde, y el valor inicializado no es importante.

Usando una declaración de variable corta, puede declarar múltiples variables en una sola declaración.

La sintaxis abreviada solo se puede usar cuando al menos una de las variables en el lado izquierdo de := se declara por primera vez. Consulte el siguiente código.

// hello.go

package main

import "fmt"

func main() {
    el, mike := 11, 21
    fmt.Println("el is", el, "mike is", mike)
    mike, kb := 10, 19
    fmt.Println("mike is", mike, "kb is", kb)
    mike, kb = 30, 46
    fmt.Println("changed mike is", mike, "kb is", kb)
}

Producción

go run hello.go
el is 11 mike is 21
mike is 10 kb is 19
changed mike is 30 kb is 46

Declaración de múltiples variables cortas

Consulte el siguiente código.

// hello.go

package main

import "fmt"

func main() {

    name, series, age := "Millie", "Stanger Things", 16
    fmt.Println("Name is", name)
    fmt.Println("Series is", series)
    fmt.Println("Age is", age)
}

Producción

go run hello.go
Name is Millie
Series is Stanger Things
Age is 16

Usando una declaración de variable corta, puede declarar múltiples variables de diferentes tipos en una sola declaración. La expresión determina el tipo de estas variables.

En Golang, podemos declarar una variable sin un valor inicial, con un valor inicial, con sintaxis abreviada o directamente asignar el valor al valor sin declarar una variable.

What is GEEK

Buddha Community

What's new in the go 1.15

Go announced Go 1.15 version on 11 Aug 2020. Highlighted updates and features include Substantial improvements to the Go linker, Improved allocation for small objects at high core counts, X.509 CommonName deprecation, GOPROXY supports skipping proxies that return errors, New embedded tzdata package, Several Core Library improvements and more.

As Go promise for maintaining backward compatibility. After upgrading to the latest Go 1.15 version, almost all existing Golang applications or programs continue to compile and run as older Golang version.

#go #golang #go 1.15 #go features #go improvement #go package #go new features

Go-web-workshop: Build Web Applications with Go on App Engine

Building Web Applications with Go

Welcome, gopher! You're not a gopher? Well, this workshop is for gophers, or people that use the Go programming language. But fear not if you've never written any Go before! I'd recommend you learn the basics for the language first with the Go tour.

This workshop has been run a couple of times with an instructor leading. The goal of this repo is to make it as easy as possible for individuals to follow the content by themselves. If you get stuck at any point, feel free to file issues asking questions.

Setting up your workspace

To go through this you will need the following:

1. You have installed the Go Programming Language.
2. You have set up a GOPATH by following the How to Write Go Code tutorial.
3. You are somewhat familiar with the basics of Go. (The Go Tour is a pretty good place to start)
4. You have a Google account and you have installed the Google Cloud SDK.

Contents

There's a lot to say about how to build web applications, in Go or any other language. But we only have one day so we won't try to cover too much. Instead we'll cover the basics, so you'll be able to explore other solutions and frameworks later.

The workshops is divided in eleven sections:

• 0: Hello world
• 1: Web Clients
• 2: Web servers
• 3: Input validation and status codes
• 4: Deploying to App Engine
• 5: Hello, HTML
• 6: JSON encoding and decoding
• 7: Durable storage with Cloud Datastore
• 8: Retrieving remote resources with urlfetch
• 9: What is Memcache and how to use it from App Engine
• 10: Congratulations!

Resources

These are places where you can find more information for Go:

• golang.org
• godoc.org, where you can find the documentation for any package.
• The Go Programming Language Blog

My favorite aspect of Go is its community, and you are now part of it too. Welcome!

As a newcomer to the Go community you might have questions or get blocked at some point. This is completely normal, and we're here to help you. Some of the places where gophers tend to hang out are:

• The Go Forum
• #go-nuts IRC channel at Freenode
• Gophers’ community on Slack (signup here for an account).
• @golang and #golang on Twitter.
• Go+ community on Google Plus.
• Go user meetups
• golang-nuts mailing list
• Go community Wiki

Disclaimer

This is not an official Google product (experimental or otherwise), it is just code that happens to be owned by Google.

Author: Campoy
Source Code: https://github.com/campoy/go-web-workshop 
License: Apache-2.0 license

#go #golang #web 

“Go Has Indeed Become The Language Of Cloud Infrastructure“ - Rob Pike

Introduction

We spoke to Rob Pike, the co-author of the Go programming language, about a career spanning four decades, the evolution of Go over the last ten years, and into the future.

The Interview

Evrone: Unlike many developers today, you started your career decades ago at Bell Labs. What’s been the biggest change in the way we develop software that you can think of, given your rare perspective?

**Rob: **The scale is much bigger today. Not just of the computers and the network, but the programs themselves. All of Unix version 6 (circa 1975) fits comfortably on a single RK05 disk pack, which has just over 2MB of storage, with lots of room left over for user software. And that was a fine computing environment, or at least seemed like one at the time. Although I can, of course, explain much of the growth, it is astonishing and perhaps not all of it is justified.

#golang #golang-api #golang-tools #golang-website #rob-pike #interview-transcript-go #latest-tech-stories #cloud-infrastructure-and-go

Secure HTTPS servers in Go

In this article, we are going to look at some of the basic APIs of the http package to create and initialize HTTPS servers in Go.

(source: unsplash.com)

In the “Simple Hello World Server” lesson, we learned about net/http package, how to create routes and how [ServeMux](https://golang.org/pkg/net/http/#ServeMux) works. In the “Running multiple HTTP servers” lesson, we learned about [Server](https://golang.org/pkg/net/http/#Server) structure and how to run multiple HTTP servers concurrently.

In this lesson, we are going to create an HTTPS server using both Go’s standard server configuration and custom configuration (using [_Server_](https://golang.org/pkg/net/http/#Server) structure). But before this, we need to know what HTTPS really is?

HTTPS is a big topic of discussion in itself. Hence while writing this lesson, I published an article just on “How HTTPS works?”. I advise you to read this lesson first before continuing this article. In this article, I’ve also described the encryption paradigm and SSL certificates generation process.

---

If we recall the simplest HTTP server example from previous lessons, we only need http.``[ListenAndServe](https://golang.org/pkg/net/http/#ListenAndServe) function to start an HTTP server and http.``[HandleFunc](https://golang.org/pkg/net/http/#HandleFunc) to register a response handler for a particular endpoint.

(https://play.golang.org/p/t3sOenOYAzS)

In the example above, when we run the command go run server.go , it will start an HTTP server on port 9000. By visiting http://localhost:9000 URL in a browser, you will be able to see a Hello World! message on the screen.

(http://localhost:9000)

As we know, the nil argument to ListenAndServe() call invokes Go to use the [DefaultServeMux](https://golang.org/pkg/net/http/#DefaultServeMux) response multiplexer, which is the default instance of ServeMux structure provided globally by the Go. The HandleFunc() call adds a response handler for a specific route on the multiplexer instance.

The http.ListenAndServe() call uses the Go’s standard HTTP server configuration, however, in the previous lesson, how we can customize a server using [Server](https://golang.org/pkg/net/http/#Server) structure type.

To start an HTTPS server, all we need do is to call ServerAndListenTLS method with some configuration. Just like ServeAndListen method, this method is available on both the http package and the Server structure.

The http.``[ServeAndListenTLS](https://golang.org/pkg/net/http/#ListenAndServeTLS) method uses the Go’s standard server implementation, however, both [Server](https://golang.org/pkg/net/http/#Server) instance and Server.``[ServeAndListenTLS](https://golang.org/pkg/net/http/#Server.ListenAndServeTLS) method can be configured for our needs.

#go-programming-language #go #golang-tutorial #go-programming #golang

Gopher-reading-list: A Curated Selection Of Blog Posts on Go

Gopher Reading List

中文版

Here is a reading list of blog posts about Go. It aspires to include only the most useful and relevant material that anyone writing Go should eventually read. By definition, the list is a work in progress.

Rather than being comprehensive, the list is a curated selection fixed at 200 entries.

Go is growing fast and so are the number of blog posts about it. If an interested reader knows of a great post not on this list, please open an issue with a link to the post. Not every blog post linked in an issue will make its way into the list. Nonetheless, the issue list (both open and closed) is a good source of additional reading material.

NOTE: Any new additions will need to replace something else on the list to keep it at a fixed length.

Start Here

• Why should you learn Go?
• An Intro to Go for non-Go developers
• How to Write Go Code
• A Tour of Go
• Frequently Asked Questions
• Go by Example
• Go 101

See Go Books for a list of books, both free and paid.

Beginner

Some basics

• Understand Go pointers in less than 800 words or your money back
• Don't fear the pointer
• Channel Axioms
• Golang channels tutorial
• Common Gotchas in Go
• 50 Shades of Go: Traps, Gotchas, and Common Mistakes for New Golang Devs
• Slices from the ground up
• 6 Tips for Using Strings in Go
• Go Defer Simplified with Practical Visuals
• How to Use Go Interfaces
• Different Ways to Initialize Go structs

Worth reading, again and again

• Effective Go
• Visualizing Concurrency in Go
• Strings, bytes, runes and characters in Go
• Arrays, slices (and strings): The mechanics of 'append'

Organization and Style

• Practical Go: Real world advice for writing maintainable Go programs
• Less is exponentially more
• Go Proverbs
• Code Review Comments
• Idiomatic Go
• Error handling and Go
• Go's Error Handling is Elegant
• Working with Errors in Go 1.13
• Simple Go project layout with modules
• Structuring Tests in Go
• Standard Package Layout
• Packages as layers, not groups
• Structuring Applications in Go
• Style guideline for Go packages
• Package names

Web

• Creating My First Web Application with Go
• Making a RESTful JSON API in Go
• Serving Static Sites with Go
• An Intro To Templates in Go
• JSON APIs Are Just Web Applications
• Writing middleware in #golang and how Go makes it so much fun
• Go and JSON
• Accessing data in Go
• How to Use //go:embed

Concurrency

• Learning Go's Concurrency Through Illustrations
• Go’s append is not always thread safe

Go Modules

• Introduction to Go modules
• Using Go Modules
• Modules Part 01: Why And What

Intermediate

Code Design

• Go best practices, six years in
• Aspects of a good Go library
• Solid Go Design
• Go for Industrial Programming
• Why you shouldn't use func main in Go
• Failure is your Domain
• What “accept interfaces, return structs” means in Go
• Pitfalls of context values and how to avoid or mitigate them in Go
• How to organize the go struct, in order to save memory
• Loose Coupling in Go lang
• Self-referential functions and the design of options
• Functional Options for Friendly APIs
• Functional Options on Steroids
• Object Oriented Inheritance in Go
• Error handling in Upspin

Concurrency

• Concurrency Patterns
• Stopping goroutines
• Make Ctrl+C cancel the context.Context
• How to correctly use context.Context in Go 1.7
• Using contexts to avoid leaking goroutines
• Go Concurrency Patterns: Pipelines and cancellation
• Tutorial: Synchronizing State with Mutexes in Go
• Context and Cancellation of goroutines
• Dancing with Go's Mutexes
• GoRoutines, Channels, and Proper Exits
• How to Block Forever in Go
• Mutex Profile
• Sane Concurrency with Go
• Error handling patterns in Go
• Does the race detector catch all data races?
• Interesting ways of using Go channels
• The underutilized usefulness of sync.Once
• Code Review Checklist: Go concurrency
• The Pros of Conds

Testing

• Testing Web Apps in Go
• An Introduction to Testing in Go
• 5 simple tips and tricks for writing unit tests in #golang
• 5 Advanced Testing Techniques in Go
• Interfaces and Composition for Effective Unit Testing in Golang
• Go Testing Technique: Testing JSON HTTP Requests
• Acceptance Testing Go Web Applications with Cookies
• Testing Your (HTTP) Handlers in Go
• Learn Go with tests
• Lesser-Known Features of Go Test
• When Writing Unit Tests, Don’t Use Mocks

Web

• Go for Cloud
• Exposing Go on the Internet
• The complete guide to Go net/http timeouts
• HTTP(S) Proxy in Golang in less than 100 lines of code
• Write a Kubernetes-ready service from zero step-by-step
• A brief intro of TCP keep-alive in Go’s HTTP implementation
• Go JSON Cookbook
• Build a Web Crawler in Go
• Your pprof is showing: IPv4 scans reveal exposed net/http/pprof endpoints:
• HTTP Request Contexts & Go
• Using Object-Oriented Web Servers in Go
• Handle HTTP Request Errors in Go
• Go json.Decoder Considered Harmful
• Building High Performance APIs In Go Using gRPC And Protocol Buffers
• Don't use Go's default HTTP client (in production)
• Writing an API Client in Go
• Seeking around in an HTTP object
• Using Functions Inside Go Templates
• Writing a Data Mapper in Go without an ORM
• Practical Persistence in Go: Organising Database Access
• How I write Go HTTP services after seven years
• Make resilient Go net/http servers using timeouts, deadlines and context cancellation
• Life of an HTTP request in a Go server
• Gotchas in the Go Network Packages Defaults
• Graceful shutdown of a TCP server in Go

Tools

• An Overview of Go's Tooling
• Go tooling essentials
• Profiling Go Programs
• Go Tooling in Action
• Statically compiling Go programs

Trivia

• 10 things you (probably) don't know about Go
• Advanced Go Tips And Tricks
• Golang slices gotcha

Diagnostics

• Diagnostics
• Profiling Go
• Five things that make Go fast
• Debugging Go Applications using Delve

Language

• Golang: pass by pointer vs pass by value
• There is no pass-by-reference in Go
• Variadic functions in Go
• Function Types in Go (golang)
• research!rsc: Go Data Structures
• The Relationship Between Interfaces and Reflection
• When to Use Generics in Go?
• An Introduction to Generics

Miscellaneous

• Always Be Closing
• Don't defer Close() on writable files
• How to Use go:generate
• Writing worker queues, in Go
• Job Queues in Go - OpsDash
• Reading files in Go
• Vanity Go Import Paths
• Tags in Golang
• Handling Errors from Deferred Functions in Go
• Why Go modules are faster than GOPATH

Advanced

Low Level Concerns

• The Go Memory Model
• Go's work-stealing scheduler
• The Go scheduler
• Illustrated Tales of Go Runtime Scheduler
• Go: Asynchronous Preemption
• Go Assembly by Example
• Address Alignments in Go
• Hacking the Scheduler
• Scheduling In Go - Part II
• Anatomy of a function call in Go
• Scheduler Tracing in Go
• unsafe.Pointer and system calls
• Type-Unsafe Pointers
• Looking at your program’s structure in Go 1.7
• Managing Syscall Overhead with crypto/rand
• Optimized abs() for int64 in Go
• Go: Introduction to the Escape Analysis

Performance

• Allocation Efficiency in High-Performance Go Services
• Handling 1 Million Requests per Minute with Go
• Go code refactoring : the 23x performance hunt
• A Million WebSockets and Go
• go-perfbook
• Simple techniques to optimise Go programs
• High Performance Go Workshop
• Reducing Memory Allocations in Golang

Garbage Collection

• Getting to Go: The Journey of Go's Garbage Collector
• Avoiding high GC overhead with large heaps
• Golang's Real-time GC in Theory and Practice
• How to Optimize Garbage Collection in Go
• Garbage Collection in Go

Concurrency

• Advanced Go Concurrency Patterns
• The X-Files: Avoiding Concurrency Boilerplate with golang.org/x/sync
• Golang lock-free values with atomic.Value
• Share Memory by Communicating
• Concurrency is not parallelism
• Go Concurrency Patterns: Context
• Go Concurrency Patterns: Timing out, moving on
• Concurrency, Goroutines and GOMAXPROCS
• Locking in crypto/rand
• Stateful locks in Go

JSON Encoding and Decoding

• Advanced Encoding and Decoding Techniques
• Custom JSON Marshalling in Go

Miscellaneous

• Text normalization in Go
• Minimal Perfect Hash Functions
• Go Experience Report for Generics: Google metrics API
• go-internals
• go-fuzz github.com/arolek/ase
• Property-based testing in Go
• Monkey Patching in Go

Download Details:

Author: Enocom
Source Code: https://github.com/enocom/gopher-reading-list 
License: Apache-2.0 license

#go #golang #reading