获取本地IP
package main
import (
"fmt"
"net"
)
func LocalIp() string {
addrs, err := net.InterfaceAddrs()
if err != nil {
fmt.Println(err)
}
var ip string = "localhost"
for _, address := range addrs {
if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
if ipnet.IP.To4() != nil {
ip = ipnet.IP.String()
}
}
}
return ip
}
func main() {
fmt.Println(LocalIp())
}
限制golang最大并发数
package main
import (
"fmt"
"time"
)
func main() {
var limit = make(chan int , 3) //限制最大并发数
for i:=1 ; i <= 30 ; i++ {
go func() {
limit <- 1
work()
<-limit
}()
}
select {}
}
func work() {
fmt.Println("work....")
time.Sleep(1 * time.Second)
}
golang最快响应
伪代码如下
package main
import (
"time"
"fmt"
)
func remoteWork1() string{
time.Sleep(time.Second * 5) //模拟响应时间
return "work1"
}
func remoteWork2() string{
time.Sleep(time.Second * 2) //模拟响应时间
return "work2"
}
func remoteWork3() string{
time.Sleep(time.Second * 3) //模拟响应时间
return "work3"
}
func main() {
ch := make(chan string )
go func() {
ch <- remoteWork1()
}()
go func() {
ch <- remoteWork2()
}()
go func() {
ch <- remoteWork3()
}()
fmt.Println(<-ch) //以空间换时间，某些特定场景试用
}
反射修改对象属性
package main
import (
"fmt"
"reflect"
"unsafe"
)
type TestObj struct {
name string
thisp this
field1 string
}
type this struct {
age []int
address string
}
func main() {
struct_ := &TestObj{name:"golang"}
field, _ := reflect.TypeOf(struct_).Elem().FieldByName("thisp")
field1Ptr := uintptr(unsafe.Pointer(struct_)) + field.Offset
*((*this)(unsafe.Pointer(field1Ptr))) = this{[]int{1,2,3} ,"suzhou"}
fmt.Println(struct_)
}
关于defer中坑的最佳解释
偶然在网上找到一份电子书《深入解析Go内核实现》（感谢作者）中有段关于解释defer执行原理的论述，真是言简意赅！
关键点：return xxx 不是一条原子指令！
defer坑如下：
package main
import "fmt"
func main() {
fmt.Println(f1())
fmt.Println(f2())
fmt.Println(f3())
}
func f1() (result int) {
defer func() {
result++
}()
return 0
}
func f2() (r int) {
t := 5
defer func() {
t = t + 5
}()
return t
}
func f3() (r int) {
defer func(r int) {
r = r + 5
}(r)
return 1
}
输出结果一次为：1,5,1
上述代码与下面的代码执行过程一致
package main
import (
"fmt"
)
func main() {
fmt.Println(ff1())
fmt.Println(ff2())
fmt.Println(ff3())
}
func ff1() (result int) {
result = 0
func(){
result++
}()
return
}
func ff2() (r int) {
t := 5
r = t
func(){
t = t + 5
}()
return
}
func ff3() (r int) {
r = 1
func (n int) {
n = n + 5
}(r)
return
}
该电子书中还有更多价值，值得深入研究的地方，大家可以自行下载参阅！
自定义迭代器
package main
import "fmt"
type agg struct {
contain []int
}
func (a *agg) getIter() IIterator {
i := new(Iterator)
i.aggs = a
return i
}
type IIterator interface {
hasNext() bool
next() bool
current() int
}
type Iterator struct {
cursor int
aggs *agg
}
func (i *Iterator) hasNext() bool {
if i.cursor + 1 > len(i.aggs.contain) {
return false
}else {
return true
}
}
func (i *Iterator) next() bool {
if i.cursor < len(i.aggs.contain) {
i.cursor++
return true
}
return false
}
func (i *Iterator) current() int {
return i.aggs.contain[i.cursor]
}
func main() {
a := new(agg)
a.contain = []int{1,2,3,4,5,66}
i := a.getIter()
for {
if i.hasNext() {
fmt.Println(i.current())
i.next()
} else {
break
}
}
}
