You can use %% for literal %

    %%	a literal percent sign; consumes no value

https://golang.org/pkg/fmt/

I&#39;m using Linux mint and using the vi command to create text files, now that I created a text file and saved it. How do I get back into to edit the text file again? 

    vi helloWorld.txt




How to edit a text file in my terminal

I&#39;m writing a library, which has a predefined set of values for an enum. 
Let say, my enum looks as below.

    public enum EnumClass {
        FIRST(&quot;first&quot;),
        SECOND(&quot;second&quot;),
        THIRD(&quot;third&quot;);
    
        private String httpMethodType;
    
    }

Now the client, who is using this library may need to add few more values. Let say, the client needs to add `CUSTOM_FIRST` and `CUSTOM_SECOND`. This is not overwriting any existing values, but makes the enum having 5 values.

After this, I should be able to use something like `&lt;? extends EnumClass&gt;` to have 5 constant possibilities.


What would be the best approach to achieve this?

How to enable enum inheritance

If I wanted to do the following:

    fmt.Printf(&quot;Escape this -&gt; %v... Do not escape this -&gt; %v&quot;, &quot;Unescaped&quot;)

How could I escape the first occurrence of `%v`? 

`\%v` doesn&#39;t seem to work. Any ideas?

Escape Variables with Printf

If I wanted to do the following:
<pre><code class="hljs language-perl">fmt.Printf("Escape this -> %v... Do not escape this -> %v", "Unescaped")
</code></pre>
How could I escape the first occurrence of <code>%v</code>?
<code>\%v</code> doesn't seem to work. Any ideas?

I have a custom type which internally has a slice of data.

Is it possible, by implementing some functions or an interface that the range operator needs, to iterate (using range) over my custom type?

In Go is it possible to iterate over a custom type?

There are many cases using **nil** in golang. For example:

    func (u *URL) Parse(ref string) (*URL, error) {
   		refurl, err := Parse(ref)
   		if err != nil {
   			return nil, err
   		}
   		return u.ResolveReference(refurl), nil
    }

but we can&#39;t use it like this:

    var str string //or var str int
    str = nil

the golang compiler will throw a `can&#39;t use nil as type string in assignment ` error.

Looks like `nil` can only be used for a pointer of struct and interface. If that is the case, then **what does it mean?**
and **when we use it to compare to the other object, how do they compare, in other words, how does golang determine one object is nil**?

**EDIT:For example, if an interface is nil, its type and value must be nil at the same time. How does golang do this?**

What does nil mean in golang?

From the documentation on [log.Fatalln()](https://golang.org/pkg/log/#Fatalln):


&gt; func Fatalln(v ...interface{}) Fatalln is equivalent to Println()
&gt; followed by a call to os.Exit(1).

The [source code](https://golang.org/src/log/log.go) for Fatalln:

       310	// Fatalln is equivalent to Println() followed by a call to os.Exit(1).
       311	func Fatalln(v ...interface{}) {
       312		std.Output(2, fmt.Sprintln(v...))
       313		os.Exit(1)
       314	}

It seems the main difference is whether or not the error is recoverable (since you can recover a panic) - is there anything more significantly different between these? 

Panic&#39;s interface [definition](https://golang.org/src/builtin/builtin.go?h=func+panic) is:

   

       215	// The panic built-in function stops normal execution of the current
       216	// goroutine. When a function F calls panic, normal execution of F stops
       217	// immediately. Any functions whose execution was deferred by F are run in
       218	// the usual way, and then F returns to its caller. To the caller G, the
       219	// invocation of F then behaves like a call to panic, terminating G&#39;s
       220	// execution and running any deferred functions. This continues until all
       221	// functions in the executing goroutine have stopped, in reverse order. At
       222	// that point, the program is terminated and the error condition is reported,
       223	// including the value of the argument to panic. This termination sequence
       224	// is called panicking and can be controlled by the built-in function
       225	// recover.
       226	func panic(v interface{})

It appears panic does not return anything.

Is that the primary difference? Otherwise, they seem to perform the same function in an application, assuming the panic is not recovered.

What are the differences in outcome for panic vs log.Fatalln()?

The program [available on The Go Playground][2] reads

    package main
    
    import &quot;fmt&quot;
    
    func main() {
    	var name string = nil
    	fmt.Println(name)
    }

and yields an error

    prog.go:6: cannot use nil as type string in assignment


I understand [`&quot;&quot;` is the &quot;zero value&quot; for strings][1]. I don&#39;t understand why I cannot assign `nil` to my `string`.

  [1]: https://tour.golang.org/basics/12
  [2]: https://play.golang.org/p/2gLydmLeHf

Why can&#39;t a string be nil in Go?

I set my GOPATH to

    /Users/me/dev/go

and I have

    /Users/me/dev/go/src/client1
    /Users/me/dev/go/src/client2
    /Users/me/dev/go/src/client3

and also

    /Users/me/dev/client1/rails_project
    /Users/me/dev/client2/php_project
    etc.

I don&#39;t like how in my root dev folder I&#39;m forced to have this general &quot;go&quot; dir that holds many different client&#39;s go projects.



Content Type	Original Author	Original Content on Stackoverflow
Question	Ari Seyhun	View Question on Stackoverflow
Solution 1 - Go	YOU	View Answer on Stackoverflow

Escape Variables with Printf

Go Problem Overview

Go Solutions

Solution 1 - Go

How to enable enum inheritance

How to edit a text file in my terminal

Attributions