patterns

Author: coolpest

behavioral/Interpreter/interpreter.go

@@ -0,0 +1,91 @@
+package Interpreter
+
+import "strings"
+
+type Expression interface {
+	Interpret(variables map[string]Expression) int
+}
+
+type Integer struct {
+	integer int
+}
+
+func (n *Integer) Interpret(variables map[string]Expression) int{
+	return n.integer
+}
+
+type Plus struct {
+	leftOperand Expression
+	rightOperand Expression
+}
+
+func (p *Plus)  Interpret(variables map[string]Expression) int{
+	return p.leftOperand.Interpret(variables) + p.rightOperand.Interpret(variables)
+}
+
+func (e *Evaluator) Interpret(context map[string]Expression) int  {
+	return e.syntaxTree.Interpret(context)
+}
+
+type Variable struct {
+	name string
+}
+
+type Node struct {
+	value interface{}
+	next *Node
+}
+
+type Stack struct {
+	top *Node
+	size int
+}
+
+func (s *Stack) Push(value interface{}) {
+	s.top= &Node{
+		value: value,
+		next:  s.top,
+	}
+	s.size++
+}
+
+func (v *Variable)  Interpret(variables map[string]Expression) int{
+	value,found := variables[v.name]
+	if !found{
+		return 0
+	}
+	return value.Interpret(variables)
+}
+
+func (s *Stack) Pop() interface{}  {
+	if s.size==0{
+		return nil
+	}
+	value:= s.top.value
+	s.top=s.top.next
+	s.size--
+	return value
+}
+
+type Evaluator struct {
+	syntaxTree Expression
+}
+
+
+
+func NewEvaluator(expression string) *Evaluator{
+	expressionStack := new(Stack)
+	for _,token := range strings.Split(expression," "){
+		switch token {
+		case "+":
+			right := expressionStack.Pop().(Expression)
+			left := expressionStack.Pop().(Expression)
+			subExpression := &Plus{left,right}
+			expressionStack.Push(subExpression)
+		default:
+			expressionStack.Push(&Variable{token})
+		}
+	}
+	syntaxTree := expressionStack.Pop().(Expression)
+	return &Evaluator{syntaxTree:syntaxTree}
+}

behavioral/Interpreter/interpreter_test.go

@@ -0,0 +1,17 @@
+package Interpreter
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestInterpreter(t *testing.T) {
+	expression := "w x z +"
+	sentence := NewEvaluator(expression)
+	variables := make(map[string]Expression)
+	variables["w"] = &Integer{6}
+	variables["x"] = &Integer{10}
+	variables["z"] = &Integer{41}
+	result := sentence.Interpret(variables)
+	assert.Equal(t, 51,result)
+}

behavioral/Mediator/mediator.go

@@ -0,0 +1,63 @@
+package Mediator
+
+import "fmt"
+
+type Mediator interface {
+	Communicate(who string)
+}
+
+type WildStallion interface{
+	SetMediator(mediator Mediator)
+}
+
+type Bill struct {
+	mediator Mediator
+}
+
+func (b *Bill) SetMediator(mediator Mediator){
+	b.mediator=mediator
+}
+
+func (b *Bill) Respond(){
+	fmt.Println( "Bill: What?")
+	b.mediator.Communicate("Bill")
+}
+
+type Ted struct {
+	mediator Mediator
+}
+
+func (t *Ted) Talk(){
+	fmt.Println("Ted: Bill?")
+	t.mediator.Communicate("Ted")
+}
+
+func (t *Ted) SetMediator(mediator Mediator){
+	t.mediator=mediator
+}
+
+func(t *Ted) Respond(){
+	fmt.Println("Ted: Strange things are afoot at the Circle K.")
+}
+
+type ConcreteMediator struct {
+	Bill
+	Ted
+}
+
+func NewMediator() *ConcreteMediator{
+	mediator:=&ConcreteMediator{}
+	mediator.Bill.SetMediator(mediator)
+	mediator.Ted.SetMediator(mediator)
+	return mediator
+}
+
+func (m *ConcreteMediator) Communicate(who string)  {
+	if who=="Ted"{
+		m.Bill.Respond()
+	}else{
+		m.Ted.Respond()
+	}
+}
+
+

behavioral/Mediator/mediator_test.go

@@ -0,0 +1,9 @@
+package Mediator
+
+import "testing"
+
+func TestMediator(t *testing.T) {
+	mediator:=NewMediator()
+	mediator.Ted.Talk()
+
+}

behavioral/Memento/memento.go

@@ -0,0 +1,37 @@
+package Memento
+
+type Memento struct {
+	state int
+}
+
+func NewMemento(value int) *Memento {
+	return &Memento{value}
+}
+
+type Number struct {
+	value int
+}
+
+func NewNUmber(value int) *Number {
+	return &Number{value: value}
+}
+
+func (n *Number) Double() {
+	n.value = 2 * n.value
+}
+
+func (n *Number) Half() {
+	n.value /= 2
+}
+
+func (n *Number) Value() int {
+	return n.value
+}
+
+func (n *Number) CreateMemento() *Memento{
+	return NewMemento(n.value)
+}
+
+func (n *Number) ReinstateMemento(memento *Memento){
+	n.value=memento.state
+}

behavioral/Memento/memento_test.go

@@ -0,0 +1,11 @@
+package Memento
+
+import "testing"
+
+func TestMemento(t *testing.T) {
+	n:= NewNUmber(10)
+	n.Double()
+	memento:=n.CreateMemento()
+	n.Half()
+	n.ReinstateMemento(memento)
+}

behavioral/State/state.go

@@ -0,0 +1,63 @@
+package State
+
+import "fmt"
+
+type State interface {
+	On(m *Machine)
+	Off(m *Machine)
+}
+
+type Machine struct {
+	current State
+}
+
+func NewMachine() *Machine{
+	return &Machine{NewOFF()}
+}
+
+func (m *Machine) setCurrent(s State){
+	m.current=s
+}
+
+func (m *Machine) On(){
+	m.current.On(m)
+}
+
+func (m *Machine) Off() {
+	m.current.Off(m)
+}
+
+type ON struct {
+
+}
+
+func NewON() State {
+	return &ON{}
+}
+
+func (o *ON) On(m *Machine){
+	fmt.Println("已经开启")
+}
+
+func (o *ON) Off(m *Machine){
+	fmt.Println("从On的状态到Off")
+	m.setCurrent(NewOFF())
+}
+
+type OFF struct {
+
+}
+
+func NewOFF() State{
+	return &OFF{}
+}
+
+func (o *OFF) On(m *Machine){
+	fmt.Println("从OFF的状态到ON")
+	m.setCurrent(NewON())
+}
+
+func (o *OFF) Off(m *Machine){
+	fmt.Println("已经关闭")
+}
+

behavioral/State/state_test.go

@@ -0,0 +1,11 @@
+package State
+
+import "testing"
+
+func TestState(t *testing.T) {
+	machine := NewMachine()
+	machine.Off()
+	machine.On()
+	machine.On()
+	machine.Off()
+}

behavioral/Strategy/strategry.go

@@ -0,0 +1,46 @@
+package strategy
+
+import "fmt"
+
+type Strategy interface {
+	Execute()
+}
+
+type strategyA struct {
+
+}
+
+func (s *strategyA) Execute(){
+	fmt.Println("A plan executed.")
+}
+
+func NewStrategyA() Strategy{
+	return &strategyA{}
+}
+
+type strategyB struct {
+
+}
+func (s *strategyB) Execute(){
+	fmt.Println("B plan executed.")
+}
+
+func NewStrategyB() Strategy {
+	return &strategyB{}
+}
+
+type Context struct {
+	strategy Strategy
+}
+
+func NewContext() *Context{
+	return &Context{}
+}
+
+func (c *Context) SetStrategy(strategy Strategy){
+	c.strategy=strategy
+}
+
+func (c *Context) Execute(){
+	c.strategy.Execute()
+}

behavioral/Strategy/strategy_test.go

@@ -0,0 +1,14 @@
+package strategy
+
+import "testing"
+
+func TestContext_Execute(t *testing.T) {
+	strategyA:= NewStrategyA()
+	c:=NewContext()
+	c.SetStrategy(strategyA)
+	c.Execute()
+
+	strategyB := NewStrategyB()
+	c.SetStrategy(strategyB)
+	c.Execute()
+}