How to convert TypeScript interface to Go struct?

php editor Xinyi introduces you how to convert TypeScript interface into Go structure. When we develop using TypeScript on the front end, we often define interfaces to describe data structures. When developing in the backend using the Go language, these interfaces need to be converted into corresponding structures. This article will explain in detail how to convert from basic types, nested types, optional types, etc. Through the guidance of this article, you will be able to easily convert TypeScript interfaces into Go structures and improve development efficiency.

Question content

I'm trying to convert an object modeling tool built with typescript to go.

What I have in typescript is:

interface schematype {
  [key: string]: {
    type: string;
    required?: boolean;
    default?: any;
    validate?: any[];
    maxlength?: any[];
    minlength?: any[],
    transform?: function;
  };
};

class schema {
  private readonly schema;

  constructor(schema: schematype) {
    this.schema = schema;
  };

  public validate(data: object): promise<object> {
    // do something with data
    return data;
  };
};

So I can do this:

const itemschema = new schema({
  id: {
    type: string,
    required: true
  },
  createdby: {
    type: string,
    required: true
  }
});

My understanding of go only goes so far:

type SchemaType struct {
  Key       string // I'm not sure about this bit
  Type      string
  Required  bool
  Default   func()
  Validate  [2]interface{}
  Maxlength [2]interface{}
  Minlength [2]interface{}
  Transform func()
}

type Schema struct {
    schema SchemaType
}

func (s *Schema) NewSchema(schema SchemaType) {
    s.schema = schema
}

func (s *Schema) Validate(collection string, data map[string]interface{}) map[string]interface{} {
    // do something with data
    return data
}

I'm a bit stuck, mainly because of the dynamic "keys" in the schematype interface, and don't know how to replicate it in go...

Workaround

The [key string]: part means it is a dictionary with key type string. In go, this would be map[string]<some type></some>.

type schematype map[string]schematypeentry

type schematypeentry struct {
  type      string
  required  bool
  // ...
}

Alternatively, remove the schematype type and change schema:

type Schema struct {
    schema map[string]SchemaTypeEntry
}

Now, regarding the other fields, they look weird as you define them, and will most likely not work the way you show here.

default will be a value, not func() (a function that returns nothing). You don't know what type the value is, so the type should be interface {} or any (since go 1.18 - alias for interface {}).

transform - This could be a function that accepts a value, transforms it and returns a value - func(interface{}) interface{}

Not sure what minlength, maxlength and validate stand for in this context - not sure why they are arrays in javascript and how to determine them The length in go is exactly 2.

The above is the detailed content of How to convert TypeScript interface to Go struct?. For more information, please follow other related articles on the PHP Chinese website!