Golang and not working function bytes.Contains()

I have strange problem with function bytes.Contains(b, subslice []byte) bool. It doesn't find characters in byte array which was received in function (c *IPConn) Read(b []byte) (int, error). Application is a simple server.
So I have byte array, which was received via server to variable buf

buf := make([]byte, 1024)
Len, err := c.conn.Read(buf)
// below received content in buf
//{"abc":[{"b":5,"bca":14,"xyz":0}]}{"abc":[{"b":7,"hjk":14,"qwe":0}]}

Now I wanted use below function to find }{ characters in array buf

if bytes.Contains(buf, []byte(`}{`) != false {
    fmt.Printf("I got you")
}

But function always return false. Why ?

I did some experiment in my program as below:

worker := []byte('{"abc":[{"b":5,"bca":14,"xyz":0}]}{"abc":[{"b":7,"hjk":14,"qwe":0}]}')

// try find }{

if bytes.Contains(worker, []byte(`}{`) != false {
    fmt.Printf("I got you")
}

is CORRECT !!! I do not understand this... because it fallows that contents must be different between data which was received via server, and data form usually attachment in program.

Do you actually check err and Len after c.conn.Read(buf) finishes?

The chief flaw in your program (as presented) is that you're using buf to search for data while the read operation on your socket is free to return successfuuly after receiving any number of bytes between 1 and 1024, and return with an error after receiving any number of bytes between 0 and 1024.

So, you must do two things:

• Check for error;
• To access the actual data available at the beginning of the buffer after the read operation ends you have to use the actual length of data, Len.

To do the latter, you usually construct a new slice:

data := buf[:Len]

And then use the data variable:

if bytes.Contains(data, []byte("}{")) {
   ...
}

If you don't do this, you might easily access stale data in your buffer — that is, the data left there from the previous call to c.conn.Read(buf).

If you'll think of the situation a bit more, you'll see that nothing guarantees that the next call to Read() on your socket will bring the }{ sequence into the buffer, and you have to be prepared for accumulating your data: that is,

1. Each call to Read() should add its Len bytes to the number of bytes in the buffer to consider by your code.

   This means that if the Nth read operation failed to provide the data you're looking for, the (N+1)th operation must put its bytes right after the last byte of the previous read operation; in Go, this typically means constructing another slice for that next read operation.

2. You should use the total current number of accumulated bytes to search for "}{".

Please consider starting with this book to grasp the basics of networking programming (with Go specifics).

As you can see, properly dealing with this task looks complicated.
So why not let Go do buffering itself?

You could restate your algorythm like this:

1. Read the input data until a } character is found. Accumulate this data.

2. Once } is found, read the next character and if it's a {, we've found the spot we're interested in.

   Otherwise return to step (1).

This is doable using bytes.Buffer and its methods:

• ReadBytes(delim byte) — for reading up to a } byte.
• ReadByte() — for reading a single byte to check if a { follows.
• UnreadByte(c byte) — for putting the byte back into the buffer if it's not a { following }.

Now let's look at your problem from a more general perspective.
The data you've presented in your example looks like a series of JSON objects to me. So why are you trying to apply some low-tech approach for finding boundaries between those objects instead of just using JSON decoder to decode your data right away or at least properly skip over objects in the stream?

There is a problem with you code missing some brackets etc. This seems to work :

package main

import (
	"bytes"
	"fmt"
)

const data = `{"abc":[{"b":5,"bca":14,"xyz":0}]}{"abc":[{"b":7,"hjk":14,"qwe":0}]}`

func main() {

	buf := []byte(data)
	fmt.Printf("buf = %s\n", string(buf))

	if bytes.Contains(buf, []byte("}{")) {
		fmt.Printf("I got you\n")
	}

}

There may be an encoding problem receiving the data in your connected application, thats a tricky one to show and I have resorted to printing the hex vals of received data on occasion to really see what came across the wire.

EDIT :

Try to print out the received data like this :

for _, b := range buf {
	fmt.Printf("%X ", b)
}

And then compare with the test data to see if there are differences, this is as you say the only place it could go wrong ?