To use pointers or not to use in these situations?

I'm building a (deep parser?) and have two parts of the code, in each of those I have two ways to work with pointers:

The first part:

// The first way
struct User {
    client   http.Client,
    jar      cookiejar.Jar,
    username string,
    password string,
}
func NewUser(username, password string) *User {
    jar := cookiejar.New(nil)
    client := http.Client{ Jar: &jar }
    return &User{ username: username, password: password, client: client, jar: jar }
}

// The second way
struct User {
    client   &http.Client, //!
    jar      &cookiejar.Jar, //!
    username string,
    password string,
}
func NewUser(username, password string) *User {
    jar := &cookiejar.New(nil) //!
    client := &http.Client{ Jar: jar } //!
    return &User{ username: username, password: password, client: client, jar: jar } //!
}

(Changed lines have a comment //! in the end)

The second part:

func (u *User)process() {
    u.client.Get("https://example.com")
    fmt.Printf("%v", u.jar.Cookies("https://example.com"))
}

// The first way
users := make([]&User, 256)
// ... setting users
for user := range users {
    go user.process()
}

// The second way
users := make([]User, 256) //!
// ... setting users
for user := range users {
    go user.process()
}

Which way is better for each part and why?
Or is there an even better way to do all this?

The main point of using pointers in containers is that it when the container is copied, the pointed-to value is not copied. If the copying of an object is either not safe (like a mutex), or too expensive (like a large array), then it could be a good idea to use a pointer.

In your case, you are storing your users in a slice. It's important to remember with slices that any time you append on the slice, it may or may not copy the entire slice contents. This means that if you are ever to use append (or copy, or other methods of copying the values), your data type must be copy-safe: either by making the data type copy-safe in itself, or by using a pointer to it.

If there is no issue with copying the values, then you may as well use non-pointer values, as it will simplify your program:

• Zero-values will be usable (instead of nil)
• Fewer allocations required
• Simplify or eliminate constructor code

If your slice does not need to be copied (append or otherwise), and you only use User values by calling this process method which takes a pointer receiver, then no copies will occur and you have nothing to worry about.

If copies may occur then the question is: is your User struct copy-safe? Most likely, yes. The http.Client documentation doesn't have any specific note about not being copy-safe, so it would only be unsafe if you directly modify one of its fields.

Here's what a simplified version of your code might look like:

type User struct {
    client   http.Client
    username string
    password string
}


func (u *User) setup() {
    user.username = something
    user.password = something
    user.client.Jar, err := cookiejar.New(nil)
    if err != nil {
        // handle error somehow
    }
}

func (u *User) process() {
    // do some request
    fmt.Println(u.client.Jar.Cookies("https://example.com"))
}

func run() {
    users := make([]User, 256)
    for _, user := range users {
        user.setup()
        go user.process()
    }
    // do something ...
}

If you're unsure about if your User type is or will be copy-safe, you can simply change to slice of pointers and continue using pointer-receiver methods and you will be fine.

func run() {
    users := make([]*User, 256)
    for i := range users {
        users[i] = new(User)
        users[i].setup()
        go users[i].process()
    }
    // do something ...
}