ejemplos - estructuras en c++ pdf

¿Cómo imprimir las variables de estructura en la consola?

Question

¿Cómo puedo imprimir (en la consola) la Id , el Title , el Name , etc. de esta estructura en Golang?

type Project struct {
    Id int64 `json:"project_id"`
    Title string `json:"title"`
    Name string `json:"name"`
    Data Data `json:"data"`
    Commits Commits `json:"commits"`
}

Answer 1

Creo que sería mejor implementar un larguero personalizado si desea algún tipo de salida formateada de una struct

por ejemplo

package main

    import "fmt"

    type Project struct {
        Id int64 `json:"project_id"`
        Title string `json:"title"`
        Name string `json:"name"`
    }

    func (p Project) String() string {
        return fmt.Sprintf("{Id:%d, Title:%s, Name:%s}", p.Id, p.Title, p.Name)
    }

    func main() {
        o := Project{Id: 4, Name: "hello", Title: "world"}
        fmt.Printf("%+v/n", o)
    }

Answer 2

Cuando tenga estructuras más complejas, es posible que deba convertir a JSON antes de imprimir:

// Convert structs to JSON.
data, err := json.Marshal(myComplexStruct)
fmt.Printf("%s/n", data)

Fuente: https://gist.github.com/tetsuok/4942960

Answer 3

Me gusta la litter .

De su readme:

type Person struct {
  Name   string
  Age    int
  Parent *Person
}

litter.Dump(Person{
  Name:   "Bob",
  Age:    20,
  Parent: &Person{
    Name: "Jane",
    Age:  50,
  },
})

Sdump es bastante útil en las pruebas:

func TestSearch(t *testing.T) {
  result := DoSearch()

  actual := litterOpts.Sdump(result)
  expected, err := ioutil.ReadFile("testdata.txt")
  if err != nil {
    // First run, write test data since it doesn''t exist
        if !os.IsNotExist(err) {
      t.Error(err)
    }
    ioutil.Write("testdata.txt", actual, 0644)
    actual = expected
  }
  if expected != actual {
    t.Errorf("Expected %s, got %s", expected, actual)
  }
}

Answer 4

Otra forma es crear una función llamada toString que tome estructura, formatee los campos como desee.

import (
    "fmt"
)

type T struct {
    x, y string
}

func (r T) toString() string {
    return "Formate as u need :" + r.x + r.y
}

func main() {
    r1 := T{"csa", "ac"}
    fmt.Println("toStringed : ", r1.toString())
}

Answer 5

Para imprimir el nombre de los campos en una estructura:

fmt.Printf("%+v/n", yourProject)

Del paquete fmt :

al imprimir estructuras, el indicador más ( %+v ) agrega nombres de campo

Eso supone que tienes una instancia de Project (en '' yourProject '')

El artículo JSON y Go proporcionará más detalles sobre cómo recuperar los valores de una estructura JSON.

Esta página de ir de ejemplo proporciona otra técnica:

type Response2 struct {
  Page   int      `json:"page"`
  Fruits []string `json:"fruits"`
}

res2D := &Response2{
    Page:   1,
    Fruits: []string{"apple", "peach", "pear"}}
res2B, _ := json.Marshal(res2D)
fmt.Println(string(res2B))

Eso imprimiría:

{"Página": 1, "Frutas": ["manzana", "melocotón", "pera"]}

{"page":1,"fruits":["apple","peach","pear"]}

Si no tiene ninguna instancia, entonces necesita usar la reflexión para mostrar el nombre del campo de una estructura dada, como en este ejemplo .

type T struct {
    A int
    B string
}

t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()
typeOfT := s.Type()

for i := 0; i < s.NumField(); i++ {
    f := s.Field(i)
    fmt.Printf("%d: %s %s = %v/n", i,
        typeOfT.Field(i).Name, f.Type(), f.Interface())
}

Answer 6

Quiero recomendar a go-spew , que de acuerdo con su github "Implementa una impresora bastante bonita para las estructuras de datos de Go para ayudar en la depuración"

go get -u github.com/davecgh/go-spew/spew

ejemplo de uso:

package main

import (
    "github.com/davecgh/go-spew/spew"
)

type Project struct {
    Id      int64  `json:"project_id"`
    Title   string `json:"title"`
    Name    string `json:"name"`
    Data    string `json:"data"`
    Commits string `json:"commits"`
}

func main() {

    o := Project{Name: "hello", Title: "world"}
    spew.Dump(o)
}

salida:

(main.Project) {
 Id: (int64) 0,
 Title: (string) (len=5) "world",
 Name: (string) (len=5) "hello",
 Data: (string) "",
 Commits: (string) ""
}

Answer 7

Quiero recomendar el programa de idioma Stuct Example GO con un ejemplo de tipo de estructura.

package main import ( "fmt" ) func main() { type Salary struct{ Basic, HRA, TA float64 } type Employee struct{ FirstName, LastName, Email string Age int MonthlySalary []Salary } e := Employee{ FirstName: "Mark", LastName: "Jones", Email: "[email protected]", Age: 25, MonthlySalary: []Salary{ Salary{ Basic:15000.00, HRA:5000.00, TA:2000.00, }, Salary{ Basic:16000.00, HRA:5000.00, TA:2100.00, }, Salary{ Basic:17000.00, HRA:5000.00, TA:2200.00, }, }, } fmt.Println(e.FirstName,e.LastName) fmt.Println(e.Age) fmt.Println(e.Email) fmt.Println(e.MonthlySalary[0]) fmt.Println(e.MonthlySalary[1]) fmt.Println(e.MonthlySalary[2]) }

Answer 8

Recomiendo usar Pretty Printer Library . En eso puedes imprimir cualquier estructura muy fácilmente.

1. Instalar biblioteca

   https://github.com/kr/pretty

o

go get github.com/kr/pretty

Ahora haz esto en tu código.

package main

import (
fmt
github.com/kr/pretty
)

func main(){

type Project struct {
    Id int64 `json:"project_id"`
    Title string `json:"title"`
    Name string `json:"name"`
    Data Data `json:"data"`
    Commits Commits `json:"commits"`
}

fmt.Printf("%# v", pretty.Formatter(Project)) //It will print all struct details

fmt.Printf("%# v", pretty.Formatter(Project.Id)) //It will print component one by one.

}

También puede obtener la diferencia entre los componentes a través de esta biblioteca y mucho más. También puedes echar un vistazo a los Docs biblioteca aquí.

Answer 9

Sin usar bibliotecas externas y con nueva línea después de cada campo:

log.Println(
            strings.Replace(
                fmt.Sprintf("%#v", post), ", ", "/n", -1))

Answer 10

También hay go-render , que maneja la recursión del puntero y un montón de ordenación de claves para los mapas de cadena e int.

Instalación:

go get github.com/luci/go-render/render

Ejemplo:

type customType int
type testStruct struct {
        S string
        V *map[string]int
        I interface{}
}

a := testStruct{
        S: "hello",
        V: &map[string]int{"foo": 0, "bar": 1},
        I: customType(42),
}

fmt.Println("Render test:")
fmt.Printf("fmt.Printf:    %#v/n", a)))
fmt.Printf("render.Render: %s/n", Render(a))

Que imprime:

fmt.Printf:    render.testStruct{S:"hello", V:(*map[string]int)(0x600dd065), I:42}
render.Render: render.testStruct{S:"hello", V:(*map[string]int){"bar":1, "foo":0}, I:render.customType(42)}

Answer 11

Visita here para ver el código completo. Aquí también encontrará un enlace para un terminal en línea donde se puede ejecutar el código completo y el programa representa cómo extraer la información de la estructura (nombre del campo, su tipo y valor). A continuación se muestra el fragmento de programa que solo imprime los nombres de los campos.

package main

import "fmt"
import "reflect"

func main() {
    type Book struct {
        Id    int
        Name  string
        Title string
    }

    book := Book{1, "Let us C", "Enjoy programming with practice"}
    e := reflect.ValueOf(&book).Elem()

    for i := 0; i < e.NumField(); i++ {
        fieldName := e.Type().Field(i).Name
        fmt.Printf("%v/n", fieldName)
    }
}

/*
Id
Name
Title
*/

Answer 12

mi 2centa sería usar json.MarshalIndent - sorprendido de que esto no se sugiera, ya que es el más sencillo. por ejemplo:

func prettyPrint(i interface{}) string {
    s, _ := json.MarshalIndent(i, "", "/t")
    return string(s)
}

sin deps externos y resultados en salida bien formateada.

Answer 13

fmt.Println("%+v", structure variable)

Una mejor manera de hacer esto sería crear una constante global para la cadena "% + v" en un paquete llamado "commons" (tal vez) y usarla en cualquier parte del código.

//In commons package
const STRUCTURE_DATA_FMT = "%+v"

//In your code everywhere
fmt.Println(commons.STRUCTURE_DATA_FMT, structure variable)

Answer 14

p = Project{...}
fmt.Printf("%+v", p)
fmt.Printf("%#v", p) //with type