A brief explanation.

The reason you get that is because you are allowed to only use one of the two types of initializers and not both.

i.e. you can either use __field:value__ or __value.__

Using your example you either do

_field:value_

    t := T2{
        T2_Text: &quot;Test&quot;,
        T1: T1{T1_Text: &quot;Test&quot;},
    }

_or only values_

    t := T2{
        &quot;Test&quot;,
        T1{&quot;Test&quot;},
    }

Hope that explains the why


Missing the attribute name `T1` for assignment.

	t := T2{
		T2_Text: &quot;Test&quot;,
		T1:      T1{T1_Text: &quot;Test&quot;},
	}

P.S. Just moved @twotwotwo&#39;s comment to an answer.

How can I format the text of a placeholder in italics, but when someone writes inside the textbox, the text shouldn&#39;t be in italics.

code:

    &lt;input type=&quot;text&quot; id=&quot;search&quot; placeholder=&quot;Search&quot; style=&quot;font-style:italic&quot;&gt;

How can I place italic text only on placeholder but not whole input?

How to make only placeholder italics in input

I am having hard time parsing the arguments to subprocess.Popen.  I am trying to execute a script on my Unix server. The script syntax when running on shell prompt is as follows:
`/usr/local/bin/script hostname = &lt;hostname&gt; -p LONGLIST`. No matter how I try, the script is not running inside subprocess.Popen

The space before and after &quot;=&quot; is mandatory.

    import subprocess
    Out = subprocess.Popen([&#39;/usr/local/bin/script&#39;, &#39;hostname = &#39;, &#39;actual server name&#39;, &#39;-p&#39;, &#39;LONGLIST&#39;],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)

The above does not work.

And when I use shell=False, I get `OSError: [Errno 8] Exec format error`




OSError: [Errno 8] Exec format error

Why can I not create the following, with an anonymous field?

    type T1 struct {
    	T1_Text string
    }
    
    type T2 struct {
    	T2_Text string
    	T1
    }

used in func ..

    t := T2{
    	T2_Text: &quot;Test&quot;,
    	T1{T1_Text: &quot;Test&quot;},
    }


Gives me: mixture of field:value and value initializers?

mixture of field:value and value initializers

Why can I not create the following, with an anonymous field?
<pre><code class="hljs language-go">type T1 struct {
	T1_Text string
}

type T2 struct {
	T2_Text string
	T1
}
</code></pre>
used in func ..
<pre><code class="hljs language-css">t := T2{
	T2_Text: "Test",
	T1{T1_Text: "Test"},
}
</code></pre>
Gives me: mixture of field:value and value initializers?

I need to use `defer` to free allocations manually created using `C` library, but I also need to `os.Exit` with non 0 status at some point. The tricky part is that `os.Exit` skips any deferred instruction:

    package main
    
    import &quot;fmt&quot;
    import &quot;os&quot;
    
    func main() {
    
        // `defer`s will _not_ be run when using `os.Exit`, so
        // this `fmt.Println` will never be called.
        defer fmt.Println(&quot;!&quot;)
        // sometimes ones might use defer to do critical operations
        // like close a database, remove a lock or free memory
    
        // Exit with status code.
        os.Exit(3)
    }

Playground: http://play.golang.org/p/CDiAh9SXRM stolen from https://gobyexample.com/exit

So how to exit a go program honoring declared `defer` calls? Is there any alternative to `os.Exit`?

How to exit a go program honoring deferred calls?

And I can&#39;t seem to understand this kind of variable declaration:

    _, prs := m[&quot;example&quot;]

What exactly is &quot;`_,`&quot; doing and why have they declared a variable like this instead of

    prs := m[&quot;example&quot;]

(I found it as part of [Go by Example: Maps](https://gobyexample.com/maps))

What is &quot;_,&quot; (underscore comma) in a Go declaration?

It is very unclear for me in which case I would want to use a value receiver instead of always using a pointer receiver.   

To recap from the docs:

    type T struct {
    	a int
    }
    func (tv  T) Mv(a int) int         { return 0 }  // value receiver
    func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver

The **docs** also say &quot;For types such as basic types, slices, and small structs, a value receiver is very cheap so unless the semantics of the method requires a pointer, a value receiver is efficient and clear.&quot;

**First point** they docs say a value receiver is &quot;very cheap&quot;, but the question is whether it is cheaper than a pointer receiver. So I made a small benchmark [(code on gist)][1] which showed me, that pointer receiver is faster even for a struct that has only one string field. These are the results:

    // Struct one empty string property
    BenchmarkChangePointerReceiver  2000000000               0.36 ns/op
    BenchmarkChangeItValueReceiver  500000000                3.62 ns/op


    // Struct one zero int property
    BenchmarkChangePointerReceiver  2000000000               0.36 ns/op
    BenchmarkChangeItValueReceiver  2000000000               0.36 ns/op

_(Edit: Please note that second point became invalid in newer go versions, see comments.)_

**Second point** the docs say that a value receiver it is &quot;efficient and clear&quot; which is more a matter of taste, isn&#39;t it? Personally I prefer consistency by using the same thing everywhere. Efficiency in what sense? Performance wise it seems pointer are almost always more efficient. Few test-runs with one int property showed minimal advantage of Value receiver (range of 0.01-0.1 ns/op)

Can someone tell me a case where a value receiver clearly makes more sense than a pointer receiver? Or am I doing something wrong in the benchmark? Did I overlook other factors?


  [1]: https://gist.github.com/chrisport/f28674850ffc3d9238f8

Value receiver vs. pointer receiver

I need to get the current time in different time-zones. 

Currently I know that we can do the following:

	t := time.Now()
	fmt.Println(&quot;Location:&quot;, t.Location(), &quot;:Time:&quot;, t)
	utc, err := time.LoadLocation(&quot;America/New_York&quot;)
	if err != nil {
		fmt.Println(&quot;err: &quot;, err.Error())
	}
	fmt.Println(&quot;Location:&quot;, utc, &quot;:Time:&quot;, t.In(utc))


The LoadLocation name is taken to be a location name corresponding to a file in the IANA Time Zone database, such as &quot;America/New_York&quot;. 

Is there a simpler way to get the current time, if the country name, or the GMT offset is given e.g +530 for India?


Edit: I would also want to support Day light savings.


How to get the current timestamp in other timezones in Golang?

How slow is using type assertions / type switches in Go, as a method of run-time type discovery?

I&#39;ve heard that in C/C++ for example, discovering types at run time has bad performance. To bypass that, you usually add type members to classes, so you can compare against these instead of casting.

I haven&#39;t found a clear answer for this throughout the www.

Here&#39;s an example of what I&#39;m asking about - Is this considered *fast* when compared to other type checking methodologies (like mentioned above, or others I&#39;m not aware of)?

    func question(anything interface{}) {
        switch v := anything.(type) {
            case string:
                fmt.Println(v)
            case int32, int64:
                fmt.Println(v)
            case SomeCustomType:
                fmt.Println(v)
            default:
                fmt.Println(&quot;unknown&quot;)
        }
    }

Content Type	Original Author	Original Content on Stackoverflow
Question	Chris G.	View Question on Stackoverflow
Solution 1 - Go	Dee S	View Answer on Stackoverflow
Solution 2 - Go	wuliwong	View Answer on Stackoverflow

mixture of field:value and value initializers

Go Problem Overview

Go Solutions

Solution 1 - Go

Solution 2 - Go

OSError: [Errno 8] Exec format error

How to make only placeholder italics in input

Attributions