Implementation of golang slice copy

package main

import "fmt"

func main() {
	
	// Create a slice	originalSlice := []int{1, 2, 3, 4, 5}

	// Create shallow copy using the slice[:] operator	shallowCopy := originalSlice[:]
	shallowCopy2 := make([]int, len(shallowCopy))
	copy(shallowCopy2, originalSlice)

	// Modify the element of the original slice	originalSlice[0] = 100

	// Output original slices and shallow copies of slices	("Original Slice:", originalSlice)
	("Shallow Copy:", shallowCopy)
	("Shallow Copy2:", shallowCopy2)
}

func (sf *ServerSession) running(ctx , subcom []uint8) {
	var err error
	var bytesRead int

	defer func() {
		()

	}()
	go ()

	raw := make([]byte, tcpAduMaxSize)

	for {
		select {
		case <-():
			err = ("server active close")
			(err)
			return
		default:
		}

		err = (().Add())
		if err != nil {
			("set read tcp data time deadline error:", err)
		}
		count, err := (raw)

		if err != nil {
			if err !=  && err !=  || ((), "use of closed network connection") {
				return
			}

			if e, ok := err.(); ok && !() {
				return
			}

			if bytesRead == 0 && err ==  {
				err = ("remote client closed, %v", err)
				(err)
				return
			}
			// cnt >0 do nothing
			// cnt == 0 && err !=  continue do it next
		}
		adu := raw[:count]

		prodata := new(ProcessData)
		 = make([]byte, len(adu))
		copy(, adu)
		 = count
		 = subcom
		Prodatach <- prodata

	}
}

func (sf *ServerSession) prehandler() {
	for {
		select {
		case prodata := <-Prodatach:
			go (prodata)

		}
	}
}
func (sf *ServerSession) prerunhandler(prodata *ProcessData) {
	length := 
	adu := make([]byte, len())
	copy(adu, )
	subcom := 
	("run handler input1 out1 adu [% X] length is:%d\n", adu, length)
	//Maybe multiple data packets can be read out at once. Add processing method @20240704	//Use directly in the for loop	for length > 0 {
		headdata := adu[:gaHeaderSize]
		head1 := new(gadataHeader)
		buf1 := (headdata)
		err := (buf1, , head1)
		if err != nil {
			("ga server decode errr:", err)
		}
		("pre process packect SN:", )
		galength := int() + gaHeaderSize

		if galength <= len(adu) {
			adu1 := adu[:galength]
			("run handler input out adu [% X ],galength is:%d subcom is %d length is:%d\n", adu1, galength, subcom, length)
			(adu1, galength, subcom)
			adu = adu[galength:]
			length -= galength

		} else {
			("data length is %d, adu length is:%d\n", , len(adu))
			break
		}

	}
}
func (sf *ServerSession) runhandler(adu []byte, count int, subcom []uint8) {
	if count < gaHeaderSize {
		return
	}
	("run handler input adu [% X ],count is:%d subcom is %d", adu, count, subcom)
	// ("recive data [% x] count is % d \n", adu, count)
	head1 := new(gadataHeader)
	data := adu[:gaHeaderSize]
	buf1 := (data)
	err := (buf1, , head1)
	if err != nil {
		("ga server decode errr:", err)
	}
	("gaserver head sn:", )

	if !Find(subcom, ) {
		("subcom: %d is not in array %d \n", , subcom)
		return
	}
	// check head ProtocolIdentifier
	// if .Uint16(adu[2:]) != tcpProtocolIdentifier {
	// 	rdCnt, length = 0, tcpHeaderMbapSize
	// 	continue
	// }
	length := int() + gaHeaderSize
	if count == length {
		("start decode packet SN is:%d subcom is %d data length is:%d\n", , , )
		if err = (adu); err != nil {
			("gaserver decode error:", err)
			return
		}
	} else {
		("head data length: %d is not right %d \n", , count)
		///There are frequent problems here		("adu data is [% X] \n", adu)
	}
}
func Find(subcoms []uint8, subcom uint8) bool {
	for i := 0; i < len(subcoms); i++ {
		if subcoms[i] == subcom {
			return true
		}
	}
	return false
}