From 33985af4dac58fdc3c9fcddfc582386e3505d8f7 Mon Sep 17 00:00:00 2001
From: "V. K" <cn007b@gmail.com>
Date: Wed, 8 Sep 2021 15:42:31 +0300
Subject: [PATCH] Added prefixes with purpose to find output result easier.
 (#391)

---
 .../string-formatting/string-formatting.go    | 46 +++++++++----------
 .../string-formatting/string-formatting.sh    | 46 +++++++++----------
 2 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/examples/string-formatting/string-formatting.go b/examples/string-formatting/string-formatting.go
index 958cb64..ba3704d 100644
--- a/examples/string-formatting/string-formatting.go
+++ b/examples/string-formatting/string-formatting.go
@@ -19,59 +19,59 @@ func main() {
 	// format general Go values. For example, this prints
 	// an instance of our `point` struct.
 	p := point{1, 2}
-	fmt.Printf("%v\n", p)
+	fmt.Printf("struct1: %v\n", p)
 
 	// If the value is a struct, the `%+v` variant will
 	// include the struct's field names.
-	fmt.Printf("%+v\n", p)
+	fmt.Printf("struct2: %+v\n", p)
 
 	// The `%#v` variant prints a Go syntax representation
 	// of the value, i.e. the source code snippet that
 	// would produce that value.
-	fmt.Printf("%#v\n", p)
+	fmt.Printf("struct3: %#v\n", p)
 
 	// To print the type of a value, use `%T`.
-	fmt.Printf("%T\n", p)
+	fmt.Printf("type: %T\n", p)
 
 	// Formatting booleans is straight-forward.
-	fmt.Printf("%t\n", true)
+	fmt.Printf("bool: %t\n", true)
 
 	// There are many options for formatting integers.
 	// Use `%d` for standard, base-10 formatting.
-	fmt.Printf("%d\n", 123)
+	fmt.Printf("int: %d\n", 123)
 
 	// This prints a binary representation.
-	fmt.Printf("%b\n", 14)
+	fmt.Printf("bin: %b\n", 14)
 
 	// This prints the character corresponding to the
 	// given integer.
-	fmt.Printf("%c\n", 33)
+	fmt.Printf("char: %c\n", 33)
 
 	// `%x` provides hex encoding.
-	fmt.Printf("%x\n", 456)
+	fmt.Printf("hex: %x\n", 456)
 
 	// There are also several formatting options for
 	// floats. For basic decimal formatting use `%f`.
-	fmt.Printf("%f\n", 78.9)
+	fmt.Printf("float1: %f\n", 78.9)
 
 	// `%e` and `%E` format the float in (slightly
 	// different versions of) scientific notation.
-	fmt.Printf("%e\n", 123400000.0)
-	fmt.Printf("%E\n", 123400000.0)
+	fmt.Printf("float2: %e\n", 123400000.0)
+	fmt.Printf("float3: %E\n", 123400000.0)
 
 	// For basic string printing use `%s`.
-	fmt.Printf("%s\n", "\"string\"")
+	fmt.Printf("str1: %s\n", "\"string\"")
 
 	// To double-quote strings as in Go source, use `%q`.
-	fmt.Printf("%q\n", "\"string\"")
+	fmt.Printf("str2: %q\n", "\"string\"")
 
 	// As with integers seen earlier, `%x` renders
 	// the string in base-16, with two output characters
 	// per byte of input.
-	fmt.Printf("%x\n", "hex this")
+	fmt.Printf("str3: %x\n", "hex this")
 
 	// To print a representation of a pointer, use `%p`.
-	fmt.Printf("%p\n", &p)
+	fmt.Printf("pointer: %p\n", &p)
 
 	// When formatting numbers you will often want to
 	// control the width and precision of the resulting
@@ -79,32 +79,32 @@ func main() {
 	// number after the `%` in the verb. By default the
 	// result will be right-justified and padded with
 	// spaces.
-	fmt.Printf("|%6d|%6d|\n", 12, 345)
+	fmt.Printf("width1: |%6d|%6d|\n", 12, 345)
 
 	// You can also specify the width of printed floats,
 	// though usually you'll also want to restrict the
 	// decimal precision at the same time with the
 	// width.precision syntax.
-	fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
+	fmt.Printf("width2: |%6.2f|%6.2f|\n", 1.2, 3.45)
 
 	// To left-justify, use the `-` flag.
-	fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
+	fmt.Printf("float4: |%-6.2f|%-6.2f|\n", 1.2, 3.45)
 
 	// You may also want to control width when formatting
 	// strings, especially to ensure that they align in
 	// table-like output. For basic right-justified width.
-	fmt.Printf("|%6s|%6s|\n", "foo", "b")
+	fmt.Printf("width3: |%6s|%6s|\n", "foo", "b")
 
 	// To left-justify use the `-` flag as with numbers.
-	fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
+	fmt.Printf("str4: |%-6s|%-6s|\n", "foo", "b")
 
 	// So far we've seen `Printf`, which prints the
 	// formatted string to `os.Stdout`. `Sprintf` formats
 	// and returns a string without printing it anywhere.
-	s := fmt.Sprintf("a %s", "string")
+	s := fmt.Sprintf("sprintf: a %s", "string")
 	fmt.Println(s)
 
 	// You can format+print to `io.Writers` other than
 	// `os.Stdout` using `Fprintf`.
-	fmt.Fprintf(os.Stderr, "an %s\n", "error")
+	fmt.Fprintf(os.Stderr, "io: an %s\n", "error")
 }
diff --git a/examples/string-formatting/string-formatting.sh b/examples/string-formatting/string-formatting.sh
index a1a7f6b..1218895 100644
--- a/examples/string-formatting/string-formatting.sh
+++ b/examples/string-formatting/string-formatting.sh
@@ -1,24 +1,24 @@
 $ go run string-formatting.go
-{1 2}
-{x:1 y:2}
-main.point{x:1, y:2}
-main.point
-true
-123
-1110
-!
-1c8
-78.900000
-1.234000e+08
-1.234000E+08
-"string"
-"\"string\""
-6865782074686973
-0x42135100
-|    12|   345|
-|  1.20|  3.45|
-|1.20  |3.45  |
-|   foo|     b|
-|foo   |b     |
-a string
-an error
+struct1: {1 2}
+struct2: {x:1 y:2}
+struct3: main.point{x:1, y:2}
+type: main.point
+bool: true
+int: 123
+bin: 1110
+char: !
+hex: 1c8
+float1: 78.900000
+float2: 1.234000e+08
+float3: 1.234000E+08
+str1: "string"
+str2: "\"string\""
+str3: 6865782074686973
+pointer: 0xc420014090
+width1: |    12|   345|
+width2: |  1.20|  3.45|
+float4: |1.20  |3.45  |
+width3: |   foo|     b|
+str4: |foo   |b     |
+sprintf: a string
+io: an error