从结构中删除元素，但仅用于此功能

So I have an Struct that holds data that has a AddedByUser which links to my User Struct.

What I want to be able to do it remove the UserLevel from the AddedByUser

Now I want to be able to do it from this function only, so using the json:"-" is not an option. That would remove it from all json output. I only want to remove it form this one function.

I should also say that these are Gorm models and when I have been trying to remove the 10 option (UserLevels) it only removes the outer data set not the UserLevel from all of the data.

{
    "ID": 1,
    "CreatedAt": "2019-01-08T16:33:09.514711Z",
    "UpdatedAt": "2019-01-08T16:33:09.514711Z",
    "DeletedAt": null,
    "UUID": "00000000-0000-0000-0000-000000000000",
    "Title": "title000",
    "Information": "info999",
    "EventDate": "2006-01-02T15:04:05Z",
    "AddedByUser": {
        "ID": 2,
        "CreatedAt": "2019-01-08T15:27:52.435397Z",
        "UpdatedAt": "2019-01-08T15:27:52.435397Z",
        "DeletedAt": null,
        "UUID": "b019df80-a7e4-4397-814a-795e7e84b4ca",
        "Firstname": "Me",
        "Surname": "admin",
        "Password": "....",
        "Email": "admin@email.co.uk",
        "UserLevel": {
            "ID": 0,
            "CreatedAt": "0001-01-01T00:00:00Z",
            "UpdatedAt": "0001-01-01T00:00:00Z",
            "DeletedAt": null,
            "LevelTitle": "",
            "UserLevel": null
        },

So this is what I have tried,

data := []models.MyData{}
data = append(data[0:2])

I have about 14 results, with out the append it loads all the results but with this is only loads two results. The idea was to remove either UpdateAt or Title. As I am not sure if the gorm model information is all 0 or if the slice sees them as 0,1,2,3,4 etc.

I have also tried to range over the slice of models, while I can access each of the sections, I can not seem to find a simple method to remove data by name from a struct? Maps seem to have that but not structs which I am not sure why?

Thanks.

UPDATE

This is the model I am using:

//Model
type MyData struct {
  gorm.Model
  UUID              uuid.UUID
  Title       string
  Information string
  EventDate       time.Time

  AddedByUser   Users `gorm:"ForeignKey:added_by_user_fk"`
  AddedByUserFK uint
 }

//Users Model
type Users struct {
  gorm.Model
  UUID      uuid.UUID
  Firstname string
  Surname   string
  Password  string
  Email     string

  UserLevel   UserLevels `gorm:"ForeignKey:user_level_fk" json:",omitempty"`
  UserLevelFK uint
}

As mentioned in the comments, you cannot remove fields from a struct value, because that would yield a value of a different type.

However, you can set fields to their zero value. Combined with the omitempty JSON tag, you can exclude fields from the JSON encoding. To make this work properly, you have to change the UserLevel field to a pointer type (otherwise you end up with empty objects in the JSON document).

Types shortened for brevity:

package main

import (
    "encoding/json"
    "fmt"
)

type MyData struct {
    Title       string
    AddedByUser Users
}

type Users struct {
    ID        int
    UserLevel *UserLevels `json:",omitempty"` // pointer type with omitempty
}

type UserLevels struct {
    LevelTitle string
}

func main() {
    var x MyData
    x.Title = "foo"
    x.AddedByUser.ID = 2
    x.AddedByUser.UserLevel = &UserLevels{}

    f(x)

    b, _ := json.MarshalIndent(x, "", "  ")
    fmt.Println("main:
" + string(b))
}

func f(x MyData) {
    // "unset" UserLevel. Since we are receiving a copy of MyData, this is
    // invisible to the caller.
    x.AddedByUser.UserLevel = nil

    b, _ := json.MarshalIndent(x, "", "  ")
    fmt.Println("f:
" + string(b))
}

// Output:
// f:
// {
//   "Title": "foo",
//   "AddedByUser": {
//     "ID": 2
//   }
// }
// main:
// {
//   "Title": "foo",
//   "AddedByUser": {
//     "ID": 2,
//     "UserLevel": {
//       "LevelTitle": ""
//     }
//   }
// }

Try it on the playground: https://play.golang.org/p/trUgnYamVOA

Alternatively, you can define new types that exclude the AddedByUser field. However, since this field isn't at the top level, this is a lot of work, and it's easy to forget to update those types when new fields are added to the original types.

If the field were at the top level, the compiler would do most of the work for you, because types that only differ in their field tags can be directly converted to one another:

type MyData struct {
    ID    int
    Title string
}

func main() {
    var x MyData
    x.ID = 1
    x.Title = "foo"

    f(x)
}

func f(x MyData) {
    type data struct { // same as MyData, except the field tags
        ID    int
        Title string `json:"-"`
    }

    b, _ := json.MarshalIndent(data(x), "", "  ")
    fmt.Println("main:
" + string(b))
}