go语言实现的memcache协议服务的方法_语言中心合作协议
刀豆文库小编猜你可能喜欢“语言中心合作协议”。
go语言实现的memcache协议服务的方法(（推荐15篇））由网友“无主”投稿提供，下面是小编为大家推荐的go语言实现的memcache协议服务的方法，欢迎大家分享。
篇1：go语言实现的memcache协议服务的方法
作者：小 字体：[增加 减小] 类型：
完整实例代码点击此处本站下载。
1. Go语言代码如下：
代码如下:
package memcachep
import (
\“bufio\”
\“fmt\”
\“io\”
\“strconv\”
\“strings\”
)
//mc请求产生一个request对象
type MCRequest struct {
//请求命令
Opcode CommandCode
//key
Key string
//请求内容
Value []byte
//请求标识
Flags int
//请求内容长度
Length int
//过期时间
Expires int64
}
//request to string
func (req *MCRequest) String string {
return fmt.Sprintf(\“{MCRequest pcode=%s, bodylen=%d, key=‘%s‘}\”,
req.Opcode, len(req.Value), req.Key)
}
//将socket请求内容 解析为一个MCRequest对象
func (req *MCRequest) Receive(r *bufio.Reader) error {
line, _, err := r.ReadLine()
if err != nil || len(line) == 0 {
return io.EOF
}
params := strings.Fields(string(line))
command := CommandCode(params[0])
switch command {
case SET, ADD, REPLACE:
req.Opcode = command
req.Key = params[1]
req.Length, _ = strconv.Atoi(params[4])
value := make([]byte, req.Length+2)
io.ReadFull(r, value)
req.Value = make([]byte, req.Length)
copy(req.Value, value)
case GET:
req.Opcode = command
req.Key = params[1]
RunStats[\“cmd_get\”].(*CounterStat).Increment(1)
case STATS:
req.Opcode = command
req.Key = \“\”
case DELETE:
req.Opcode = command
req.Key = params[1]
}
return err
}
2. Go语言代码：
代码如下:
package memcachep
import (
\“fmt\”
\“io\”
)
type MCResponse struct {
//命令
Opcoed CommandCode
//返回状态
Status Status
//key
Key string
//返回内容
Value []byte
//返回标识
Flags int
//错误
Fatal bool
}
//解析response 并把返回结果写入socket链接
func (res *MCResponse) Transmit(w io.Writer) (err error) {
switch res.Opcoed {
case STATS:
_, err = w.Write(res.Value)
case GET:
if res.Status == SUCCESS {
rs := fmt.Sprintf(\“VALUE %s %d %d\\r\\n%s\\r\\nEND\\r\\n\”, res.Key, res.Flags, len(res.Value), res.Value)
_, err = w.Write([]byte(rs))
} else {
_, err = w.Write([]byte(res.Status.ToString()))
}
case SET, REPLACE:
_, err = w.Write([]byte(res.Status.ToString()))
case DELETE:
_, err = w.Write([]byte(\“DELETED\\r\\n\”))
}
return
}
3. Go语言代码如下：
代码如下:
package memcachep
import (
\“fmt\”
)
type action func(req *MCRequest, res *MCResponse)
var actions = map[CommandCode]action{
STATS: StatsAction,
}
//等待分发处理
func waitDispatch(rc chan chanReq) {
for {
input := <-rc
input.response <- dispatch(input.request)
}
}
//分发请求到响应的action操作函数上去
func dispatch(req *MCRequest) (res *MCResponse) {
if h, ok := actions[req.Opcode]; ok {
res = &MCResponse{}
h(req, res)
} else {
return notFound(req)
}
return
}
//未支持命令
func notFound(req *MCRequest) *MCResponse {
var response MCResponse
response.Status = UNKNOWN_COMMAND
return &response
}
//给request绑定上处理程序
func BindAction(opcode CommandCode, h action) {
actions[opcode] = h
}
//stats
func StatsAction(req *MCRequest, res *MCResponse) {
res.Fatal = false
stats := \“\”
for key, value := range RunStats {
stats += fmt.Sprintf(\“STAT %s %s\\r\\n\”, key, value)
}
stats += \“END\\r\\n\”
res.Value = []byte(stats)
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇2：GO语言实现简单TCP服务的方法
作者：小小的我 字体：[增加 减小] 类型：转载
这篇文章主要介绍了GO语言实现简单TCP服务的方法,实例分析了Go语言实现TCP服务的技巧,需要的朋友可以参考下
本文实例讲述了GO语言实现简单TCP服务的方法，分享给大家供大家参考。具体实现方法如下：
代码如下:
package main
import (
\“net\”
\“fmt\”
)
var ( maxRead = 1100
msgStop = []byte(\“cmdStop\”)
msgStart = []byte(\“cmdContinue\”)
)
func main() {
hostAndPort := \“localhost:54321\”
listener := initServer(hostAndPort)
for {
conn, err := listener.Accept()
checkError(err, \“Accept: \”)
go connectionHandler(conn)
}
}
func initServer(hostAndPort string) *net.TCPListener {
serverAddr, err := net.ResolveTCPAddr(\“tcp\”, hostAndPort)
checkError(err, \“Resolving address:port failed: ‘\” + hostAndPort + \“‘\”)
listener, err := net.ListenTCP(\“tcp\”, serverAddr)
checkError(err, \“ListenTCP: \”)
println(\“Listening to: \”, listener.Addr().String())
return listener
}
func connectionHandler(conn net.Conn) {
connFrom := conn.RemoteAddr().String()
println(\“Connection from: \”, connFrom)
talktoclients(conn)
for {
var ibuf []byte = make([]byte, maxRead + 1)
length, err := conn.Read(ibuf[0:maxRead])
ibuf[maxRead] = 0 // to prevent overflow
switch err {
case nil:
handleMsg(length, err, ibuf)
default:
goto DISCONNECT
}
}
DISCONNECT:
err := conn.Close()
println(\“Closed connection:\” , connFrom)
checkError(err, \“Close:\” )
}
func talktoclients(to net.Conn) {
wrote, err := to.Write(msgStart)
checkError(err, \“Write: wrote \” + string(wrote) + \“ bytes.\”)
}
func handleMsg(length int, err error, msg []byte) {
if length > 0 {
for i := 0; ; i++ {
if msg[i] == 0 {
break
}
}
fmt.Printf(\“Received data: %v\”, string(msg[0:length]))
fmt.Println(\“ length:\”,length)
}
}
func checkError(error error, info string) {
if error != nil {
panic(\“ERROR: \” + info + \“ \” + error.Error()) // terminate program
}
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇3：Go语言单链表实现方法
作者：OSC首席键客 字体：[增加 减小] 类型：
1. singlechain.go代码如下：
代码如下:
//////////
//单链表 -- 线性表
package singlechain
//定义节点
type Node struct {
Data int
Next *Node
}
/*
* 返回第一个节点
* h 头结点
*/
func GetFirst(h *Node) *Node {
if h.Next == nil {
return nil
}
return h.Next
}
/*
* 返回最后一个节点
* h 头结点
*/
func GetLast(h *Node) *Node {
if h.Next == nil {
return nil
}
i := h
for i.Next != nil {
i = i.Next
if i.Next == nil {
return i
}
}
return nil
}
//取长度
func GetLength(h *Node) int {
var i int = 0
n := h
for n.Next != nil {
i++
n = n.Next
}
return i
}
//插入一个节点
//h: 头结点
//d:要插入的节点
//p:要插入的位置
func Insert(h, d *Node, p int) bool {
if h.Next == nil {
h.Next = d
return true
}
i := 0
n := h
for n.Next != nil {
i++
if i == p {
if n.Next.Next == nil {
n.Next = d
return true
} else {
d.Next = n.Next
n.Next = d.Next
return true
}
}
n = n.Next
if n.Next == nil {
n.Next = d
return true
}
}
return false
}
//取出指定节点
func GetLoc(h *Node, p int) *Node {
if p < 0 || p > GetLength(h) {
return nil
}
var i int = 0
n := h
for n.Next != nil {
i++
n = n.Next
if i == p {
return n
}
}
return nil
}
2. main.go代码如下：
代码如下:
package main
import \“fmt\”
import \“list/singlechain\”
func main {
//初始化一个头结点
var h singlechain.Node
//往链表插入10个元素
for i := 1; i <= 10; i++ {
var d singlechain.Node
d.Data = i
singlechain.Insert(&h, &d, i)
fmt.Println(singlechain.GetLoc(&h, i))
}
fmt.Println(singlechain.GetLength(&h))
fmt.Println(singlechain.GetFirst(&h))
fmt.Println(singlechain.GetLast(&h))
fmt.Println(singlechain.GetLoc(&h, 6))
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇4：Go语言实现简单留言板的方法
作者：不吃皮蛋 字体：[增加 减小] 类型：转载
代码如下:
package main
import (
// \“fmt\”
\“io\”
\“log\”
\“net/http\”
\“text/template\”
\“time\”
\“database/sql\”
\“github.com/ziutek/mymysql/godrv\”
)
// 留言结构
type Liuyan struct {
Id int
Name string
Content string
Time int
}
// 显示留言时间
func (l Liuyan) ShowTime() string {
t := time.Unix(int64(l.Time), 0)
return t.Format(\“-01-02 15:04:05\”)
}
func main() {
godrv.Register(\“SET NAMES utf8\”)
// 连接数据库
db, err := sql.Open(\“mymysql\”, \“tcp:127.0.0.1:3306*go/root/123456\”)
if err != nil {
panic(err)
}
defer db.Close()
// 准备模板
tpl, err := template.New(\“liuyanbook\”).Parse(html)
if err != nil {
panic(err)
}
// 显示留言页面 /
requestList := func(w http.ResponseWriter, req *http.Request) {
// 查询数据
rows, err := db.Query(\“select * from liuyan\”)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
// 获取数据
lys := []Liuyan{}
for rows.Next() {
ly := Liuyan{}
err := rows.Scan(&ly.Id, &ly.Name, &ly.Content, &ly.Time)
if nil != err {
log.Fatal(err)
}
lys = append(lys, ly)
}
// 显示数据
err = tpl.ExecuteTemplate(w, \“list\”, lys)
if err != nil {
log.Fatal(err)
}
}
// 留言页面 /liuyan
requestLiuyan := func(w http.ResponseWriter, req *http.Request) {
err := req.ParseForm()
if err != nil{
log.Fatal(err)
}
if \“POST\” == req.Method {
if len(req.Form[\“name\”]) < 1 {
io.WriteString(w, \“参数错误!\\n\”)
return
}
if len(req.Form[\“content\”]) < 1 {
io.WriteString(w, \“参数错误!\\n\”)
return
}
name := template.HTMLEscapeString(req.Form.Get(\“name\”))
content := template.HTMLEscapeString(req.Form.Get(\“content\”))
// sql语句
sql, err := db.Prepare(\“insert into liuyan(name, content, time) values(?, ?, ?)\”)
if err != nil {
log.Fatal(err)
}
defer sql.Close()
// sql参数,并执行
_, err = sql.Exec(name, content, time.Now().Unix())
if err != nil {
log.Fatal(err)
}
// 跳转
w.Header().Add(\“Location\”, \“/\”)
w.WriteHeader(302)
// 提示信息
io.WriteString(w, \“提交成功!\\n\”)
return
}
err = tpl.ExecuteTemplate(w, \“liuyan\”, nil)
if err != nil {
log.Fatal(err)
}
}
http.HandleFunc(\“/\”, requestList)
http.HandleFunc(\“/liuyan\”, requestLiuyan)
err = http.ListenAndServe(\“:12345\”, nil)
if err != nil {
log.Fatal(\“ListenAndServe: \”, err)
}
}
// 网页模板
var html string = `{{define \“list\”}}{{/* 留言列表页面 */}}
给我留言
{{range .}}
{{.Id}}{{.Name}}{{.Content}}{{.ShowTime}}
{{end}}
{{end}}
{{define \“liuyan\”}}{{/* 发布留言页面 */}}
姓名:
内容:
{{end}}
希望本文所述对大家的Go语言程序设计有所帮助，
篇5：Go语言的队列和堆栈实现方法
作者：不吃皮蛋 字体：[增加 减小] 类型：
golang,其实我的实现是利用container/list包实现的,其实container/list包很强大.
代码如下:
package main
import (
\“fmt\”
\“container/list\”
)
func main {
// 生成队列
l := list.New()
// 入队, 压栈
l.PushBack(1)
l.PushBack(2)
l.PushBack(3)
l.PushBack(4)
// 出队
i1 := l.Front()
l.Remove(i1)
fmt.Printf(\“%d\\n\”, i1.Value)
// 出栈
i4 := l.Back()
l.Remove(i4)
fmt.Printf(\“%d\\n\”, i1.Value)
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇6：Go语言实现Fibonacci数列的方法
作者：books1958 字体：[增加 减小] 类型：转载
这篇文章主要介绍了Go语言实现Fibonacci数列的方法,实例分析了使用递归和不使用递归两种技巧,并对算法的效率进行了对比,需要的朋友可以参考下
本文实例讲述了Go语言实现Fibonacci数列的方法，分享给大家供大家参考。具体如下：
Fibonacci数列:1,1,2,3,5,8,13,21,,, (即从第三项起，每一项的值都等于前两项之后)
第一种，使用递归：
代码如下:
func fibonacci(a int) int {
if a == 1 || a == 2 {
return 1
}
return fibonacci(a-1) + fibonacci(a-2)
}
第二种，不使用递归：
代码如下:
func fibonacci_version2(index int) int {
if index == 1 || index == 2 {
return 1
}
a, b := 1, 1
for i := 3; i <= index; i++ {
a, b = b, (a + b)
}
return a + b
}
经过检验，使用非递归算法的效率要远远高于递归算法，
希望本文所述对大家的Go语言程序设计有所帮助。
篇7：Go语言实现socket实例
作者：不吃皮蛋 字体：[增加 减小] 类型：
用golang不用他的net包还有什么意义,这里提供一个测试代码：
server.go 服务端:
代码如下:
package main
import (
\“fmt\”
\“log\”
\“net\”
\“bufio\”
)
func handleConnection(conn net.Conn) {
data, err := bufio.NewReader(conn).ReadString(‘\\n‘)
if err != nil {
log.Fatal(\“get client data error: \”, err)
}
fmt.Printf(\“%#v\\n\”, data)
fmt.Fprintf(conn, \“hello client\\n\”)
conn.Close
}
func main() {
ln, err := net.Listen(\“tcp\”, \“:6010\”)
if err != nil {
panic(err)
}
for {
conn, err := ln.Accept()
if err != nil {
log.Fatal(\“get client connection error: \”, err)
}
go handleConnection(conn)
}
}
client.go 客户端:
代码如下:
package main
import (
\“fmt\”
\“net\”
\“bufio\”
)
func main() {
conn, err := net.Dial(\“tcp\”, \“:6010\”)
if err != nil {
panic(err)
}
fmt.Fprintf(conn, \“hello server\\n\”)
data, err := bufio.NewReader(conn).ReadString(‘\\n‘)
if err != nil {
panic(err)
}
fmt.Printf(\“%#v\\n\”, data)
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇8：GO语言实现文件上传代码
本文给大家分享的是一则使用golang实现文件上传的代码，主要是使用os.Create创建文件，io.Copy来保存文件，思路非常清晰，这里推荐给大家，有需要的小伙伴参考下吧，
功能很简单，代码也很简洁，这里就不多废话了。
代码如下:
package main
import (
\“fmt\”
\“io\”
\“net/http\”
\“os\”
)
const (
upload_path string = \“./upload/\”
)
func helloHandle(w http.ResponseWriter, r *http.Request) {
io.WriteString(w, \“hello world!\”)
}
//上传
func uploadHandle(w http.ResponseWriter, r *http.Request) {
//从请求当中判断方法
if r.Method == \“GET\” {
io.WriteString(w, \“我的第一个页面
\”)
} else {
//获取文件内容 要这样获取
file, head, err := r.FormFile(\“file\”)
if err != nil {
fmt.Println(err)
return
}
defer file.Close()
//创建文件
fW, err := os.Create(upload_path + head.Filename)
if err != nil {
fmt.Println(\“文件创建失败\”)
return
}
defer fW.Close()
_, err = io.Copy(fW, file)
if err != nil {
fmt.Println(\“文件保存失败\”)
return
}
//io.WriteString(w, head.Filename+\“ 保存成功\”)
http.Redirect(w, r, \“/hello\”, http.StatusFound)
//io.WriteString(w, head.Filename)
}
}
func main() {
//启动一个http 服务器
http.HandleFunc(\“/hello\”, helloHandle)
//上传
http.HandleFunc(\“/image\”, uploadHandle)
err := http.ListenAndServe(\“:8080\”, nil)
if err != nil {
fmt.Println(\“服务器启动失败\”)
return
}
fmt.Println(\“服务器启动成功\”)
}
以上所述就是本文的全部内容了，希望大家能够喜欢，能够对大家学习go语言有所帮助，
篇9：go语言实现字符串base64编码的方法
作者：令狐不聪 字体：[增加 减小] 类型：
这篇文章主要介绍了go语言实现字符串base64编码的方法,实例分析了Go语言操作字符串的技巧及base64编码的使用技巧,需要的朋友可以参考下
本文实例讲述了go语言实现字符串base64编码的方法，分享给大家供大家参考。具体实现方法如下：
代码如下:
package main
import (
\“fmt\”
\“encoding/base64\”
)
func main {
var b bytes.Buffer
w := base64.NewEncoder(base64.URLEncoding, &b)
w.Write(data)
w.Close()
data := b.Bytes()
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇10：GO语言实现列出目录和遍历目录的方法
这篇文章主要介绍了GO语言实现列出目录和遍历目录的方法,涉及ioutil.ReadDir()与filepath.Walk()的应用,是非常实用的技巧,需要的朋友可以参考下
GO语言获取目录列表用 ioutil.ReadDir()，遍历目录用 filepath.Walk()，使用方法课参考本文示例。
具体示例代码如下：
代码如下:
package main
import (
\“fmt\”
\“io/ioutil\”
\“os\”
\“path/filepath\”
\“strings\”
)
//获取指定目录下的所有文件，不进入下一级目录搜索，可以匹配后缀过滤。
func ListDir(dirPth string, suffix string) (files []string, err error) {
files = make([]string, 0, 10)
dir, err := ioutil.ReadDir(dirPth)
if err != nil {
return nil, err
}
PthSep := string(os.PathSeparator)
suffix = strings.ToUpper(suffix) //忽略后缀匹配的大小写
for _, fi := range dir {
if fi.IsDir() { // 忽略目录
continue
}
if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) { //匹配文件
files = append(files, dirPth+PthSep+fi.Name())
}
}
return files, nil
}
//获取指定目录及所有子目录下的所有文件，可以匹配后缀过滤，
func WalkDir(dirPth, suffix string) (files []string, err error) {
files = make([]string, 0, 30)
suffix = strings.ToUpper(suffix) //忽略后缀匹配的大小写
err = filepath.Walk(dirPth, func(filename string, fi os.FileInfo, err error) error { //遍历目录
//if err != nil { //忽略错误
// return err
//}
if fi.IsDir() { // 忽略目录
return nil
}
if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) {
files = append(files, filename)
}
return nil
})
return files, err
}
func main() {
files, err := ListDir(\“D:\\\\Go\”, \“.txt\”)
fmt.Println(files, err)
files, err = WalkDir(\“E:\\\\Study\”, \“.pdf\”)
fmt.Println(files, err)
}
希望本文所述对大家的GO语言程序设计有所帮助。
篇11：GO语言实现的端口扫描器
这篇文章主要介绍了GO语言实现的端口扫描器分享,本文直接给出实现代码,代码中包含大量注释,需要的朋友可以参考下
代码如下:
//GO语言 实现端口扫描
//缺陷
//port 无法设置成全局变量不知道怎么设置的
//var l = list.New 这个是数组操作并不是消息队列 跟消息队列功能类似
//实现功能
//实现生成 IP段
//实现端口扫描
//实现参数传入
//写入文件到本地
//main.go 58.215.20.30 58.215.201.30 80
//文件名 开始IP 结束IP 扫描端口
//QQ29295842 希望认识更多的朋友技术交流
//QQ群367196336 go golang WEB安全开发
package main
import (
\“container/list\”
\“fmt\”
\“net\”
\“os\”
\“strconv\”
\“strings\”
\“time\”
)
func ip2num(ip string) int {
canSplit := func(c rune) bool { return c == ‘.‘ }
lisit := strings.FieldsFunc(ip, canSplit) //[58 215 20 30]
//fmt.Println(lisit)
ip1_str_int, _ := strconv.Atoi(lisit[0])
ip2_str_int, _ := strconv.Atoi(lisit[1])
ip3_str_int, _ := strconv.Atoi(lisit[2])
ip4_str_int, _ := strconv.Atoi(lisit[3])
return ip1_str_int<<24 | ip2_str_int<<16 | ip3_str_int<<8 | ip4_str_int
}
func num2ip(num int) string {
ip1_int := (num & 0xff000000) >> 24
ip2_int := (num & 0x00ff0000) >> 16
ip3_int := (num & 0x0000ff00) >> 8
ip4_int := num & 0x000000ff
//fmt.Println(ip1_int)
data := fmt.Sprintf(\“%d.%d.%d.%d\”, ip1_int, ip2_int, ip3_int, ip4_int)
return data
}
func gen_ip(Aip1 int, Aip2 int) {
index := Aip1
for index < Aip2 {
//fmt.Println(num2ip(index))
// 入队, 压栈
ip_data := num2ip(index)
//fmt.Println(ip_data)
l.PushBack(ip_data)
index++
}
}
func text_add(name string, data string) { //向文件中写入数据 text_add(\“file2.txt\”, \“qqqqqqqqqqqqqqqqqqqqqqq\”)
f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0x644)
if err != nil {
panic(err)
}
defer f.Close()
_, err = f.WriteString(data)
_, err = f.WriteString(\“\\r\\n\”)
if err != nil {
panic(err)
}
}
//text_add(\“file2.txt\”, \“qqqqqqqqqqqqqqqqqqqqqqq\”)
var l = list.New()
func socket_ip(host string, port string) bool {
var (
remote = host + \“:\” + port
)
tcpAddr, _ := net.ResolveTCPAddr(\“tcp4\”, remote) //转换IP格式
//fmt.Printf(\“%s\”, tcpAddr)
conn, err := net.DialTCP(\“tcp\”, nil, tcpAddr) //查看是否连接成功
if err != nil {
fmt.Printf(\“no==%s:%s\\r\\n\”, host, port)
return false
}
defer conn.Close()
fmt.Printf(\“ok==%s:%s\\r\\n\”, host, port)
return true
}
func for_ip(port string) {
now := time.Now()
year, mon, day := now.UTC().Date()
file_name := fmt.Sprintf(\“%d-%d-%d_%s\”, year, mon, day, port)
for { //死循环
if l.Len() <= 0 {
fmt.Println(\“跳出循环\”)
break //#跳出
}
// 出队 从前读取
i1 := l.Front()
l.Remove(i1)
IP, _ := i1.Value.(string)
if socket_ip(IP, port) {
//OK
//获取当前 日期作为文件名 在把IP写入进去
text_add(file_name+\“_ok.txt\”, IP)
} //else {
// text_add(file_name+\“_no.txt\”, IP)
// }
time.Sleep(time.Millisecond * 500) //纳秒为单位
}
}
func main() {
argsLen := len(os.Args)
//fmt.Println(argsLen)
if argsLen != 4 {
fmt.Println(\“main.go 58.215.20.30 58.215.201.30 80\”)
} else {
gen_ip(ip2num(os.Args[1]), ip2num(os.Args[2]))
for index := 0; index < 200; index++ {
go for_ip(os.Args[3])
}
for {
time.Sleep(1 * time.Second) //纳秒为单位
}
}
}
篇12：Go语言实现选择法排序实例
作者：不吃皮蛋 字体：[增加 减小] 类型：
代码如下:
package main
import \“fmt\”
func select_sort(a []int) {
len := len(a)
for i:=0; i < len-1; i++ {
k := i
j:= i + 1
for ; j < len; j++ {
if a[j] < a[k] { k = j }
}
if k != i {
a[i], a[k] = a[k], a[i]
}
}
}
func print_array(a []int) {
for i := 0; i < len(a) - 1; i++ {
fmt.Printf(\“%d, \”, a[i])
}
fmt.Print(a[len(a)-1])
}
func main() {
a := []int{1, 8, 5, 9, 4, 3, 6, 6}
print_array(a)
fmt.Printf(\“\\n\”)
select_sort(a)
print_array(a)
}
输入:
1, 8, 5, 9, 4, 3, 6, 6
输出:
1, 3, 4, 5, 6, 6, 8, 9
希望本文所述对大家的Go语言程序设计有所帮助，
篇13：go语言实现顺序存储的栈
作者：OSC首席键客 字体：[增加 减小] 类型：转载
这篇文章主要介绍了go语言实现顺序存储的栈,实例分析了Go语言实现顺序存储的栈的原理与各种常见的操作技巧,需要的朋友可以参考下
本文实例讲述了go语言实现顺序存储的栈，分享给大家供大家参考。具体如下：
1. sequence.go代码如下：
代码如下:
////////
// 顺序存储的栈
////////
package sequence
const MAXSIZE = 20
type Stack struct {
Data [MAXSIZE]int //存储栈元素
Top int //指向栈顶，总是指向顶部元素，空时为-1
}
//压栈
//d:栈元素
func (s *Stack) Push(d int) bool {
if s.Top+1 > MAXSIZE {
return false
}
s.Data[s.Top+1] = d
s.Top++
return true
}
//弹栈
func (s *Stack) Pop int {
if s.Top == -1 {
return 0
}
s.Data[s.Top] = 0
d := s.Data[s.Top]
s.Top--
return d
}
//取栈的容量
func (s *Stack) GetVol() int {
return len(s.Data)
}
//取栈的长度
func (s *Stack) GetLength() int {
c := s.Top + 1
return c
}
2. main.go代码如下：
代码如下:
package main
import (
\“fmt\”
\“stack/sequence\”
)
func main() {
//初始化一个栈
var s sequence.Stack
s.Top = -1
//压入10个元素
for i := 1; i <= 10; i++ {
s.Push(i)
}
fmt.Println(s)
fmt.Println(s.GetVol()) //容量
fmt.Println(s.GetLength()) //长度
//弹出一个元素
s.Pop()
s.Pop()
fmt.Println(s)
fmt.Println(s.GetVol()) //容量
fmt.Println(s.GetLength()) //长度
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇14：GO语言实现简单的目录复制功能
创建一个独立的 goroutine 遍历文件，主进程负责写入数据。程序会复制空目录，也可以设置只复制以 \“.xx\” 结尾的文件。
严格来说这不是复制文件，而是写入新文件。因为这个程序是创建新文件，然后写入复制数据的。我们一般的 copy 命令是不会修改文件的 ctime(change time) 状态的。
代码如下：
代码如下:
// 一个简单的目录复制程序：一个独立的 goroutine 遍历目录，主进程负责将数据写入新目录。
// -11-02 Bing.L
package main
import (
\“io\”
\“log\”
\“os\”
\“path/filepath\”
\“strings\”
)
type FileInfo struct {
RelPath string
Size int64
IsDir bool
Handle *os.File
}
//复制文件数据
func ioCopy(srcHandle *os.File, dstPth string) (err error) {
dstHandle, err := os.OpenFile(dstPth, os.O_CREATE|os.O_WRONLY, os.ModePerm)
if err != nil {
return err
}
defer srcHandle.Close()
defer dstHandle.Close()
_, err = io.Copy(dstHandle, srcHandle)
return err
}
//遍历目录，将文件信息传入通道
func WalkFiles(srcDir, suffix string, c chan<- *FileInfo) {
suffix = strings.ToUpper(suffix)
filepath.Walk(srcDir, func(f string, fi os.FileInfo, err error) error { //遍历目录
if err != nil {
log.Println(\“[E]\”, err)
}
fileInfo := &FileInfo{}
if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) { //匹配文件
if fh, err := os.OpenFile(f, os.O_RDONLY, os.ModePerm); err != nil {
log.Println(\“[E]\”, err)
} else {
fileInfo.Handle = fh
fileInfo.RelPath, _ = filepath.Rel(srcDir, f) //相对路径
fileInfo.Size = fi.Size()
fileInfo.IsDir = fi.IsDir()
}
c <- fileInfo
}
})
close(c) //遍历完成，关闭通道
}
//写目标文件
func WriteFiles(dstDir string, c <-chan *FileInfo) {
if err := os.Chdir(dstDir); err != nil { //切换工作路径
log.Fatalln(\“[F]\”, err)
}
for f := range c {
if fi, err := os.Stat(f.RelPath); os.IsNotExist(err) { //目标不存在
if f.IsDir {
if err := os.MkdirAll(f.RelPath, os.ModeDir); err != nil {
log.Println(\“[E]\”, err)
}
} else {
if err := ioCopy(f.Handle, f.RelPath); err != nil {
log.Println(\“[E]\”, err)
} else {
log.Println(\“[I] CP:\”, f.RelPath)
}
}
} else if !f.IsDir { //目标存在，而且源不是一个目录
if fi.IsDir() != f.IsDir { //检查文件名被目录名占用冲突
log.Println(\“[E]\”, \“filename conflict:\”, f.RelPath)
} else if fi.Size() != f.Size { //源和目标的大小不一致时才重写
if err := ioCopy(f.Handle, f.RelPath); err != nil {
log.Println(\“[E]\”, err)
} else {
log.Println(\“[I] CP:\”, f.RelPath)
}
}
}
}
}
func main() {
files_ch := make(chan *FileInfo, 100)
go WalkFiles(\“E:\\\\study\”, \“.doc\”, files_ch) //在一个独立的 goroutine 中遍历文件
WriteFiles(\“E:\\\\study.bak\”, files_ch)
}
希望本文所述对大家的GO语言程序设计有所帮助，
篇15：Go语言使用组合的方式实现多继承的方法
作者：books1958 字体：[增加 减小] 类型：转载
这篇文章主要介绍了Go语言使用组合的方式实现多继承的方法,实例分析了多继承的原理与使用组合方式来实现多继承的技巧,需要的朋友可以参考下
本文实例讲述了Go语言使用组合的方式实现多继承的方法，分享给大家供大家参考。具体实现方法如下：
在大多数面向对象的编程语言中多继承都是不支持的。因为在基于class的体系中，多继承极大地增加了编译器的复杂性。
Go语言使用组合的方式实现继承，因此也可以很简单的实现多继承。
代码如下:
//使用组合的方式实现多继承
type Phone struct{}
func (p *Phone) Call() string {
return \“Ring Ring\”
}
type Camera struct{}
func (c *Camera) TakeAPicture() string {
return \“Click\”
}
//多继承
type CameraPhone struct {
Camera
Phone
}
func structTest0803() {
cp := new(CameraPhone)
fmt.Println(\“Our new CameraPhone exhibits multiple behaviors ...\”)
fmt.Println(\“It exhibits behavior. of a Camera: \”, cp.TakeAPicture())
fmt.Println(\“It works like a Phone too: \”, cp.Call())
/*Output:
Our new CameraPhone exhibits multiple behaviors ...
It exhibits behavior. of a Camera: Click
It works like a Phone too: Ring Ring
*/
}
希望本文所述对大家的Go语言程序设计有所帮助，
