Log in
Sign up

Share & grow the world's code base!

Delve into a community where programmers unite to discover code snippets, exchange skills, and enhance their programming proficiency. With abundant resources and a supportive community, you'll find everything essential for your growth and success.

Create A New Account
6 snippets
  • montana
    Published:
    Go

    Check if a file exists or not in Go

    package main

import (
	"errors"
	"fmt"
	"os"
)

func main() {
	filePath := "file.txt"

	if _, err := os.Stat(filePath); errors.Is(err, os.ErrNotExist) {
		fmt.Println("file not exists")
	} else {
		fmt.Println("file exists")
	}
}

    To check if a certain file exists inside a given directory in Golang, the Stat() and isNotExists() functions from the os package can be used. The Stat() function is used to return a file information structure that describes the file.

    golang
    go
    1 Burnfires
    0
  • frodocoder
    Published:
    Go

    Example of using Go timers

    package main

import (
	"fmt"
	"time"
)

func main() {
	firstTimer := time.NewTimer(3 * time.Second)
	value := <-firstTimer.C // value is a current time

	fmt.Printf("first timer expired: %v\n", value) // the line printed 3 seconds after running code

	secondTimer := time.NewTimer(2 * time.Second)

	go func() {
		<-secondTimer.C
		fmt.Println("second timer expired") // the line is not printed because the second timer is stopped before expiration
	}()

	stop := secondTimer.Stop() // stop second timer before it expired

	if stop {
		fmt.Println("second timer is stopped")
	}
}

// $ go run timers.go
// first timer expired: 2024-02-09 22:32:57.570649221 +0700 +07 m=+3.002054417
// second timer is stopped

    Timers allow you to execute one event in the future. You tell the timer how long you want to wait and it provides a channel to be notified at that time. The first timer will wait for 3 seconds. <-firstTimer.C blocks the timer C channel until a message (current time) is sent indicating that the timer has expired. If you just want to wait, you can use time.Sleep. One reason a timer can be useful is that you can cancel the timer before it expires. The first timer expires 3s after the program starts, but the second is stopped before it expires.

    go
    golang
    timer
    1 Burnfires
    0
  • frodocoder
    Published:
    Go

    Atomic counters in Go

    package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

func main() {
	var atomicCounter, nonAtomicCounter uint64
	wg := sync.WaitGroup{}

	for i := 0; i < 50; i++ {
		wg.Add(1)

		go func() { // run 50 goroutines, each goroutine increases the counter 1000 times
			for c := 0; c < 1000; c++ {
				atomic.AddUint64(&atomicCounter, 1) // increase atomic counter
				nonAtomicCounter++ // increase non-atomic counter
			}

			wg.Done()
		}()
	}

	wg.Wait() // wait until all goroutines finish
	
	fmt.Println("atomic counter value:", atomicCounter)
	fmt.Println("non atomic counter value:", nonAtomicCounter)
}

// go run counters.go 
// atomic counter value: 50000
// non atomic counter value: 30648

    An example of using the sync/atomic package for atomic counters accessed by goroutines.

    go
    golang
    atomic
    1 Burnfires
    1
  • alexsib
    Published:
    Go

    Simple http server in Go

    package main

import (
    "fmt"
    "net/http"
)

func hello(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "Hello, World!\n")
}

func headers(w http.ResponseWriter, req *http.Request) {
    for name, headers := range req.Header {
        for _, h := range headers {
            fmt.Fprintf(w, "%v: %v\n", name, h)
        }
    }
}

func main() {
    http.HandleFunc("/hello", hello)
    http.HandleFunc("/headers", headers)

    http.ListenAndServe(":8080", nil) // run http server on port 8080
}

    Basic HTTP server using the net/http package. In the realm of net/http servers, a crucial concept involves handlers. These handlers implement http.Handler interface. A common method for creating a handler is to use http.HandlerFunc, applied to functions that have the required signature. Handlers receive a http.ResponseWriter and a http.Request as parameters. The response writer is employed to populate the HTTP response. Handlers can be registered on server routes by the http.HandleFunc function. This function configures the default router in the net/http package and accepts a function as its parameter. To start the http server, ListenAndServe is called with the specified port and handler. Passing nil as a second paramenter indicates using the default router we recently configured.

    go
    golang
    http
    0 Burnfires
    2
  • frodocoder
    Published:
    Go

    Example of using Go tickers

    package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(time.Second)
	fmt.Println("ticker is started")

	done := make(chan struct{})

	go func() {
		for {
			select {
			case <-done:
				return
			case t := <-ticker.C:
				fmt.Println("tick", t)
			}
		}
	}()

	time.Sleep(5 * time.Second)

	ticker.Stop()
	fmt.Println("ticker is stopped")

	time.Sleep(5 * time.Second)
	done <- struct{}{}
}

// go run tickers.go 
// ticker is started
// tick 2024-02-09 23:40:25.809616086 +0700 +07 m=+1.000091237
// tick 2024-02-09 23:40:26.809742343 +0700 +07 m=+2.000152938
// tick 2024-02-09 23:40:27.809804037 +0700 +07 m=+3.000214622
// tick 2024-02-09 23:40:28.809852444 +0700 +07 m=+4.000263029
// ticker is stopped
// tick 2024-02-09 23:40:29.809908932 +0700 +07 m=+5.000319557

    Tickers allow you to repeat actions at certain intervals. A Ticker holds a channel that delivers "ticks" of a clock at intervals. Tickers can be stopped in the same way as timers. When the ticker is stopped, it will no longer be able to accept values ​​into its channel.

    go
    ticker
    golang
    0 Burnfires
    0
  • frodocoder
    Published:
    Go

    Example of timeouts in Go

    package main

import (
	"fmt"
	"time"
)

func main() {
	first := make(chan string, 1)

	go func() {
		time.Sleep(2 * time.Second) // wait 2 seconds before send value to channel
		first <- "first result"     // send value to the channel
	}()

	select {
	case result := <-first:
		fmt.Println(result)
	case <-time.After(time.Second): // timeout occurs before the value is read from the first channel
		fmt.Println("first timeout")
	}

	second := make(chan string, 1)

	go func() {
		time.Sleep(time.Second)   // wait 1 second before send value to the channel
		second <- "second result" // send value to the channel
	}()

	select {
	case result := <-second: // the value from the channel is read before the timeout expires
		fmt.Println(result)
	case <-time.After(2 * time.Second):
		fmt.Println("second timeout")
	}
}

// $ go run timeouts.go 
// first timeout
// second result

    Timeouts are important for programs that connect to external resources or need to limit their execution time.

    go
    golang
    timeout
    0 Burnfires
    0
    • Add Snippet
    Snippets46
    Categories0
    Tags62
    Users3
    Popular snippets
    Related tags