You use slices to implement a stack or queue by yourself:

类型栈[]int
func (s Stack) Empty() bool { return len(s) == 0 }
func (s *Stack) Push(v int) { (*s) = append((*s), v) }
function (s *Stack) Pop() int {
	V:= (*s)[len(*s)-1]
	(*s) = (*s)[:len(*s)-1]
	return v
}

type Queue []int
func (q Queue) Empty() bool    { return len(q) == 0 }
func (q *Queue) Enqueue(v int) { (*q) = append((*q), v) }
function (q *Queue) Dequeue() int {
	v := (*q)[0]
	(*q) = (*q)[1:len(*q)]
	return v
}

函数main() {
	s:=栈{}
	s.Push(1)
	s.Push(2)
	fmt.Println(s.Pop())
	fmt.Println(s.Pop())
	fmt.Println(s.Empty())
	/ /输出:
	// 2
	// 1
	// true

	q:=队列{}
	q.排队(1)
	q.排队(2)
	fmt.Println(q.出列())
	fmt.Println(q.出列())
	fmt.Println(q.Empty())
	/ /输出:
	// 1
	// 2
	// true
}

上面的队列实现是正确的，但它不是最优的. There are better but lengthier implementations, like this one.

Occasionally, you would prefer the Go standard library’s 容器/列表 to implement them for their conciseness, genericity, and extra list data structure related operations:

Stack:= list.New()
stack.推迟(1)
stack.推迟(2)
fmt.Println(堆栈.Remove(堆栈.Back()))
fmt.Println(堆栈.Remove(堆栈.Back()))
fmt.Println(堆栈.Len() == 0)
/ /输出:
// 2
// 1
// true

队列:= list.New()
queue.推迟(1)
queue.推迟(2)
fmt.Println(队列.Remove(队列.Front()))
fmt.Println(队列.Remove(队列.Front()))
fmt.Println(队列.Len() == 0)
/ /输出:
// 1
// 2
// true

Although, 通常不鼓励使用它们，因为它们的性能较慢, compared to slices iteration pattern. Let’s compare the two following examples:

// Iterate through a list and print its contents.
对于e:= queue.Front(); e != nil; e = e.Next() {
    fmt.Println (e.Value)
}

对于_，e:= range queue {
    fmt.Println (e)
}

“一定要用一片.”, 戴夫·切尼

实现队列的另一种可能性是使用缓冲通道, 但这绝不是个好主意, because:

缓冲区大小在通道创建时确定，不能增加.
如果不从队列中检索下一个队列元素，就不可能看到它.
存在死锁的风险:“新手有时会尝试在单个程序中使用缓冲通道作为队列, lured by their pleasingly simple syntax, 但这是一个错误. Channels are deeply connected to goroutine scheduling, and without another goroutine receiving from the channel, 一个发送者——也许是整个程序——有可能永远被封锁. If all you need is a simple queue, make one using a slice.”, Brian Kernighan.