golang,Code片段,代码实例,代码示例,代码片段库

golang 为http.client.get添加超时

为http.client.get添加超时

clentTimeout.go

var timeout = time.Duration(2 * time.Second)

func dialTimeout(network, addr string) (net.Conn, error) {
    return net.DialTimeout(network, addr, timeout)
}

func main() {
    transport := http.Transport{
        Dial: dialTimeout,
    }

    client := http.Client{
        Transport: &transport,
    }

    resp, err := client.Get("http://some.url")
}

golang 时间例

时间例

gowalker_time.go

import_path = time
 
[Time_Format]
// 当前时间
fmt.Printf("%v", time.Now().Format("2006-01-02 15:04:05"))

golang crossing.go

crossing.go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	datapath = "crossing.txt"
	datasize = 314159
)

func Merge(list, front, end []int) (count int) {
	l_i, f_i, e_i := 0, 0, 0
	for (f_i < len(front)) && (e_i < len(end)) {
		if front[f_i] > end[e_i] {
			list[l_i] = end[e_i]
			e_i++
			count += len(front) - f_i
		} else {
			list[l_i] = front[f_i]
			f_i++
		}
		l_i++
	}

	for ; f_i < len(front); f_i++ {
		list[l_i] = front[f_i]
		l_i++
	}
	for ; e_i < len(end); e_i++ {
		list[l_i] = end[e_i]
		l_i++
	}

	return count
}

func MergeSort(list []int) (count int) {
	length := len(list)
	if length < 2 {
		return count
	}
	front := make([]int, length/2)
	end := make([]int, length-length/2)
	copy(front, list[:length/2])
	copy(end, list[length/2:])

	count += MergeSort(front)
	count += MergeSort(end)
	count += Merge(list, front, end)

	return count
}

func main() {
	path := datapath
	if len(os.Args) > 1 {
		path = os.Args[1]
	}

	f, err := os.Open(path)
	if err != nil {
		panic(err)
	}

	list := make([]int, datasize, datasize)

	i := 0
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		n, err := strconv.Atoi(scanner.Text())
		if err != nil {
			panic(err)
		}
		list[i] = n
		i++
	}
	f.Close()

	count := MergeSort(list)
	fmt.Println("count = ", count)
}

golang crossing.go

crossing.go

package main

import (
	"fmt"
	"os"
	"bufio"
	"strconv"
)

const (
	datapath = "crossing.txt"
	datasize = 3141560
)

func main() {
	path := datapath

	f, err := os.Open(path)
	if err != nil {
		panic(err)
	}

	who   := make([]int, datasize, datasize)	// who is where index
	where := make([]int, datasize, datasize)	// where is who index
	scanner := bufio.NewScanner(f)

	datacnt := 1
	for scanner.Scan() {
		n, err := strconv.Atoi(scanner.Text())
		if err != nil {
			panic(err)
		}
		who[datacnt] = n
		where[who[datacnt]] = datacnt
		datacnt++
	}
	f.Close()

	fmt.Println("cnt =", datacnt)

	nCross := 0
	for i:=1; i<datacnt; i++ {
		curIdx := who[i]
		for j:=0; j<curIdx; j++ {
			if where[j] > i {
				nCross++
			}
		}
	}

	fmt.Println("cross =", nCross)
}

golang 使用golang构建Web应用程序的字段验证实例

使用golang构建Web应用程序的字段验证实例

verify.go

package verify

import (
	"regexp"
)

// 验证年龄是为数字
func Is_age(s string) bool {
	if m, _ := regexp.MatchString("^[0-9]+$", s); !m {
		return false
	}
	return true
}

// 验证中文
func Is_ch(s string) bool {
	if m, _ := regexp.MatchString("^[\\x{4e00}-\\x{9fa5}]+$", s); !m {
		return false
	}
	return true
}

// 验证英文
func Is_en(s string) bool {
	if m, _ := regexp.MatchString("^[a-zA-Z]+$", s); !m {
		return false
	}
	return true
}

// 验证email
func Is_email(s string) bool {
	if m, _ := regexp.MatchString(`^([\w\.\_]{2,10})@(\w{1,}).([a-z]{2,4})$`, s); !m {
		return false
	} else {
		return true
	}
}

// 验证手机号码
func Is_phone(s string) bool {
	if m, _ := regexp.MatchString(`^(1[3|4|5|8][0-9]\d{4,8})$`, s); !m {
		return false
	}
	return true
}

// 验证身份证号码
func Is_usercard(s string) bool {
	//验证15位身份证，15位的是全部数字
	if m, _ := regexp.MatchString(`^(\d{15})$`, s); !m {
		return false
	}

	//验证18位身份证，18位前17位为数字，最后一位是校验位，可能为数字或字符X。
	if m, _ := regexp.MatchString(`^(\d{17})([0-9]|X)$`, s); !m {
		return false
	}

	return true
}

golang golang构建简单的服务器，和静态文件

golang构建简单的服务器，和静态文件

webtest.go

package main

import (
	"io"
	"log"
	"net/http"
	"os"
)

func Hello(w http.ResponseWriter, r *http.Request) {
	io.WriteString(w, "hellow world!")
}

func main() {

	// ServeHTTP fun
	http.HandleFunc("/", Hello)

	// 静态文件 os 绝对路径
	wd, err := os.Getwd() // 当前路径
	if err != nil {
		log.Fatal(err)
	}

	// 前缀去除 ;列出dir
	http.Handle("/static/",
		http.StripPrefix("/static/",
			http.FileServer(http.Dir(wd))))

	err = http.ListenAndServe(":4000", nil)
	if err != nil {
		log.Fatal(err)
	}
}

golang Go（Golang）中的并发安全SET数据结构

Go（Golang）中的并发安全SET数据结构

set.go

// A very simple example about how to use concurrent-safe SETs (using string as keys) in GO
package main

import (
  "fmt"
	"sync"
)

type Set struct {
	m map[string]bool
	sync.RWMutex
}

func New() *Set {
	return &Set{
		m: make(map[string]bool),
	}
}

func main() {
	// Initialize our Set
	s := New()

	// Add example items
	s.Add("item1")
	s.Add("item1") // duplicate item
	s.Add("item2")
	fmt.Printf("%d items\n", s.Len())

	// Clear all items
	s.Clear()
	if s.IsEmpty() {
		fmt.Printf("0 items\n")
	}

	s.Add("item2")
	s.Add("item3")
	s.Add("item4")

	// Check for existence
	if s.Has("item2") {
		fmt.Println("item2 does exist")
	}

	// Remove some of our items
	s.Remove("item2")
	s.Remove("item4")
	fmt.Println("list of all items:", s.List())
}

// Add add
func (s *Set) Add(item string) {
	s.Lock()
	defer s.Unlock()
	s.m[item] = true
}

// Remove deletes the specified item from the map
func (s *Set) Remove(item string) {
	s.Lock()
	defer s.Unlock()
	delete(s.m, item)
}

// Has looks for the existence of an item
func (s *Set) Has(item string) bool {
	s.RLock()
	defer s.RUnlock()
	_, ok := s.m[item]
	return ok
}

// Len returns the number of items in a set.
func (s *Set) Len() int {
	return len(s.List())
}

// Clear removes all items from the set
func (s *Set) Clear() {
	s.Lock()
	defer s.Unlock()
	s.m = make(map[string]bool)
}

// IsEmpty checks for emptiness
func (s *Set) IsEmpty() bool {
	if s.Len() == 0 {
		return true
	}
	return false
}

// Set returns a slice of all items
func (s *Set) List() []string {
	s.RLock()
	defer s.RUnlock()
	list := make([]string, 0)
	for item := range s.m {
		list = append(list, item)
	}
	return list
}

golang chansync_receive.go

chansync_receive.go

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func f(msg string, n int) chan string {
	ch := make(chan string)
	go func() {
		for i:=0; i<n; i++ {
			ch <- msg + " please!"
		}
		wg.Done()
	}()
	return ch
}

func main() {
	wg.Add(3)
	ch1 := f("beer", 4)
	ch2 := f("juice", 2)
	ch3 := f("water", 1)
	done := make(chan bool)

	go func() {
		wg.Wait()
		done <- true
	}()

	L:
	for {
		select {
		case msg := <-ch1:
			fmt.Println(msg)
		case msg := <-ch2:
			fmt.Println(msg)
		case msg := <-ch3:
			fmt.Println(msg)
		case <-done:
			break L
		}
	}
	fmt.Println("exit")
}

golang chansync_waitgroup.go

chansync_waitgroup.go

package main

import (
	"fmt"
	"sync"
)

func f(msg string, n int) chan string {
	ch := make(chan string)
	go func() {
		for i:=0; i<n; i++ {
			ch <- msg + " please!"
		}
		close(ch)
	}()
	return ch
}

func main() {
	ch1 := f("beer", 4)
	ch2 := f("juice", 2)
	ch3 := f("water", 1)

	var wg sync.WaitGroup

	reporter := func(ch chan string) {
		defer wg.Done()
		for msg := range ch {
			fmt.Println(msg)
		}
	}

	wg.Add(3)
	go reporter(ch1)
	go reporter(ch2)
	go reporter(ch3)
	wg.Wait()

	fmt.Println("exit")
}

golang chansync_select.go

chansync_select.go

package main

import (
	"fmt"
)

func f(msg string, n int) (chan string, chan bool) {
	ch := make(chan string)
	done := make(chan bool)
	go func() {
		for i:=0; i<n; i++ {
			ch <- msg + " please!"
		}
		done <- true
	}()
	return ch, done
}

func main() {
	ch1, done1 := f("beer",  4)
	ch2, done2 := f("juice", 2)
	ch3, done3 := f("water", 1)

	count := 0
	L:
	for {
		select {
		case msg := <-ch1:
			fmt.Println(msg)
		case msg := <-ch2:
			fmt.Println(msg)
		case msg := <-ch3:
			fmt.Println(msg)
		case <-done1:
			count++
		case <-done2:
			count++
		case <-done3:
			count++
		}
		if (count > 2) {
			break L
		}
	}
	fmt.Println("exit")
}