4 Simple Steps To Remove Map Keywork When Printing Golang

4 Simple Steps To Remove Map Keywork When Printing Golang

by

4 Simple Steps To Remove Map Keywork When Printing Golang

$title$

Many builders favor to make use of Map[string]interface{}. Nevertheless, once we wish to print out the results of the map, we are going to get a bunch of unreadable content material. Subsequently, we have to take away the map keywork when printing the map.

There are a number of methods to do that. A method is to make use of the fmt.Println() perform. The fmt.Println() perform will print the worth of the map, however it won’t print the map key. One other approach to take away the map keywork is to make use of the replicate.Worth.String() methodology. The replicate.Worth.String() methodology will return a string illustration of the worth of the map, however it won’t embody the map key.

Lastly, we will additionally use the encoding/json package deal to take away the map keywork. The encoding/json package deal can be utilized to encode and decode JSON knowledge. After we encode a map utilizing the encoding/json package deal, the map keywork might be faraway from the ensuing JSON knowledge.

Establish the Keywork to Take away

When printing a map utilizing the `fmt` package deal in Go, the default format consists of the sort assertion map[K]V. To take away this sort assertion, it’s good to specify a customized format string.

The format string is a sequence of verbs that decide how the worth is formatted. For maps, the `%v` verb is used to print the map’s contents. To take away the sort assertion, you should use the `%#v` verb as a substitute. The `#` flag suppresses the sort assertion and prints the map’s contents with out the `map[]` prefix.

Here is an instance of how one can use the `%#v` verb to take away the sort assertion when printing a map:

“`go
package deal primary

import “fmt”

func primary() {
m := map[string]int{“Alice”: 20, “Bob”: 25}
fmt.Printf(“%#vn”, m)
}
“`

Output:

“`
map[Alice:20 Bob:25]
“`

As proven within the output, the sort assertion `map[]` is eliminated when utilizing the `%#v` verb.

Use the Go Print Bundle

The Go print package deal supplies a number of capabilities to format and print knowledge. It may deal with varied knowledge varieties, together with maps. To suppress the map keywork when printing a map, you should use the next steps:

2. Use the Fprintf Operate

The Fprintf perform takes a author (reminiscent of os.Stdout) and a format string as its first two arguments. The format string specifies how the info must be formatted. To suppress the map key phrase, you should use the next format string:

“`go
fmt.Fprintf(os.Stdout, “%#vn”, m)
“`

The %#v specifier prints the map in a human-readable format, however with out the map key phrase. The ensuing output will appear to be this:

“`
map[key1:value1 key2:value2]
“`

Extra Notes

Listed below are some further notes to contemplate when utilizing the Fprintf perform:

Parameter Description
author The vacation spot to which the formatted knowledge might be written. It may be any sort that implements the io.Author interface, reminiscent of os.Stdout or a file.
format string A string that specifies how the info must be formatted. It may include format specifiers to manage the output.
knowledge The information to be formatted. It may be any sort, together with maps, slices, structs, and primitive values.

Make the most of the PageRanges Possibility

The `PageRanges` choice in Go’s `html/pdf` package deal provides a exact resolution to exclude particular pages from the printed output. This selection accepts a slice of web page ranges, the place every vary is outlined as a pair of integers representing the beginning and finish pages. Pages outdoors the required ranges are excluded from the PDF, whereas pages throughout the ranges are included.

For instance, to exclude solely the primary web page from a 5-page doc, use the next code:

“`go
pageRanges := [][2]int{{2, 5}}
pdf.Configure(pdf.PageRanges(pageRanges))
“`

This method supplies granular management over which pages to incorporate or exclude, permitting customers to create customized printing configurations tailor-made to their particular necessities. The flexibleness of the `PageRanges` choice makes it a flexible resolution for producing PDF printouts with personalized web page choice.

Customise Web page Margins

To regulate the margins across the printed output, you may specify the Margins subject within the PageSetup struct. The Margins subject takes a set of dimensions, every representing a facet of the web page. The margins are laid out in inches, with the next default values:

Facet Default Margin (inches)
High 1
Proper 1
Backside 1
Left 1

You may alter these margins to suit your particular printing wants. For instance, if you wish to enhance the highest margin to 1.5 inches, you’d set the High subject within the Margins struct to 1.5.

Right here is an instance of setting customized web page margins:

func examplePrintCustomMargins(w io.Author) error {
	doc := goxl.NewDocument("My Doc")
	web page := doc.AddPage()
	web page.SetPageSetup(&goxl.PageSetup{
		Margins: &goxl.Margins{
			High:    1.5,
			Proper:  0.5,
			Backside: 1,
			Left:   0.5,
		},
	})
	// Proceed including content material to the web page...
	if _, err := doc.Write(w); err != nil {
		return err
	}
	return nil
}

Manipulate Header and Footer Content material

You may arrange totally different header and footer configurations for every web page of your doc. Header and footer content material is managed independently of the prevailing structure.

Predefined Headers and Footers

There are some predefined headers and footers out there as constants:

Record of Predefined Headers and Footers

Description
html2pdf.HDefault Default header
html2pdf.HNo No header
html2pdf.HTopLeft Header containing solely the web page quantity (prime left)
html2pdf.HTopCenter Header containing solely the web page quantity (prime heart)
html2pdf.HTopRight Header containing solely the web page quantity (prime proper)
html2pdf.FDefault Default footer
html2pdf.FNo No footer

You may assign one of many predefined headers or footers to a web page:

import (
    "bytes"
    "fmt"

    "github.com/SebastiaanKlippert/go-wkhtmltopdf"
)

func primary() {
    pdfg, err := wkhtmltopdf.NewPDFGenerator()
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    web page := wkhtmltopdf.NewPage("https://github.com/SebastiaanKlippert/go-wkhtmltopdf")
    web page.FooterRight.Contents = wkhtmltopdf.FDefault

    pdfg.AddPage(web page)

    pdfg.PageSize.Set("A4")

    pdfBytes, err := pdfg.CreatePDF()
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    _ = bytes.NewReader(pdfBytes)
}

You can even outline customized header or footer content material utilizing HTML:

    headerContent := `
My Customized Header
`

    web page.HeaderLeft.Contents = headerContent

Leverage the CSS Type Attribute

The CSS type attribute supplies an efficient methodology to hide map keywork when printing. To attain this, apply the ‘show’ property to the ‘none’ worth for the factor containing the map keywork. This motion renders the factor invisible throughout the printing course of whereas sustaining its visibility on the display screen. Implementing this resolution entails the next steps:

1. Establish the Ingredient

Find the HTML factor that encloses the map keywork. This factor usually possesses a category or ID attribute that distinguishes it from different web page parts.

2. Outline the CSS Rule

Within the CSS stylesheet, create a rule that targets the recognized factor. Use the ‘show’ property to set the worth to ‘none’ for the ‘print’ media sort.

3. Instance

Contemplate the next CSS rule:

CSS
.map-keywork { show: none; print; }

This rule specifies that any HTML factor with the category ‘map-keywork’ might be hidden when the doc is printed.

4. Apply the CSS Rule

Be sure that the CSS rule is utilized to the net web page. This may be achieved by linking an exterior stylesheet or embedding the CSS guidelines straight into the HTML doc.

5. Check the Answer

Preview the net web page and confirm that the map keywork is seen on the display screen. Subsequently, print the doc to verify that the keywork is hidden.

Use Exterior HTML and CSS Recordsdata

You can even use exterior HTML and CSS information to outline the styling of your printed doc. This may be helpful if you wish to use a shared template or type throughout a number of print jobs.

9. Utilizing CSS to Disguise Parts

You should use CSS to cover parts that you do not wish to seem on the printed web page. For instance, you would possibly wish to cover the map legend or different parts which can be solely helpful when viewing the map on-line. To do that, you may add the next CSS to your stylesheet:

CSS Description
.element-to-hide { show: none; } Hides the factor with the category element-to-hide

You can even use the visibility property to cover parts. Nevertheless, this can nonetheless render the factor on the web page, so it might not be the most suitable choice if you wish to save ink and paper.

To cover parts utilizing the visibility property, you may add the next CSS to your stylesheet:

CSS Description
.element-to-hide { visibility: hidden; } Hides the factor with the category element-to-hide

Apply Web page Orientation Settings

To vary the orientation of your print job, observe these steps:

  1. From the House tab, click on the Web page Setup button.
  2. Within the Web page Setup dialog field, click on the Paper Measurement tab.
  3. Within the Orientation part, choose the specified orientation.
  4. Click on OK to save lots of your modifications.

Portrait Orientation

Portrait orientation is the default orientation for many printers. It’s taller than it’s vast, and is right for printing paperwork which can be primarily text-based.

Panorama Orientation

Panorama orientation is wider than it’s tall, and is right for printing paperwork which can be primarily image-based or that require a wider structure.

Orientation Advisable for
Portrait Textual content-based paperwork, letters, résumés
Panorama Picture-based paperwork, spreadsheets, displays

How To Take away Map Kepwork When Printing Golang

Map keys are printed in Go by default, and there’s no built-in approach to take away them. Nevertheless, there are just a few methods to work round this.

A method is to make use of a customized print perform. The next code defines a print perform that solely prints the values of a map:

“`go
func PrintValues(m map[string]interface{}) {
for _, v := vary m {
fmt.Println(v)
}
}
“`

This perform can be utilized to print a map with out its keys:

“`go
m := map[string]interface{}{
“title”: “John Doe”,
“age”: 30,
}

PrintValues(m)
“`

Output:

“`
John Doe
30
“`

Folks Additionally Ask

How To Print Map Keys And Values In Golang?

To print map keys and values, you should use the next syntax:

“`go
for ok, v := vary m {
fmt.Println(ok, v)
}
“`

It will print the keys and values of the map within the following format:

“`
key1 value1
key2 value2
“`

How To Print Solely Keys Of A Map In Golang?

To print solely the keys of a map, you should use the next syntax:

“`go
for ok := vary m {
fmt.Println(ok)
}
“`

It will print the keys of the map within the following format:

“`
key1
key2
“`

How To Print Solely Values Of A Map In Golang?

To print solely the values of a map, you should use the next syntax:

“`go
for _, v := vary m {
fmt.Println(v)
}
“`

It will print the values of the map within the following format:

“`
value1
value2
“`