code review 2310041: Effective Go: update for new http interface.

doc/effective_go.html

 <!-- Effective Go -->
 
 <h2 id="introduction">Introduction</h2>
 
 <p>
 Go is a new language.  Although it borrows ideas from
 existing languages,
 it has unusual properties that make effective Go programs
 different in character from programs written in its relatives.
 A straightforward translation of a C++ or Java program into Go
@@ skipping 1860 matching lines @@
 set up.  Here's a trivial but complete implementation of a handler to
 count the number of times the
 page is visited.
 </p>
 <pre>
 // Simple counter server.
 type Counter struct {
     n int
 }
 
-func (ctr *Counter) ServeHTTP(c http.ResponseWriter, req *http.Request) {

[rsc1, 2010/09/29 18:02:58]

Probably change all the c to w.

+func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
     ctr.n++
-    fmt.Fprintf(c, "counter = %d\n", ctr.n)
-}
-</pre>
-<p>
-(Keeping with our theme, note how <code>Fprintf</code> can print to an HTTP connection.)

[rsc1, 2010/09/29 18:02:58]

to a ResponseWriter.

+    fmt.Fprintf(w, "counter = %d\n", ctr.n)
+}
+</pre>
+<p>
+(Keeping with our theme, note how <code>Fprintf</code> can print to an
+<code>http.ResponseWriter</code>.)
 For reference, here's how to attach such a server to a node on the URL tree.
 <pre>
 import "http"
 ...
 ctr := new(Counter)
 http.Handle("/counter", ctr)
 </pre>
 <p>
 But why make <code>Counter</code> a struct?  An integer is all that's needed.
 (The receiver needs to be a pointer so the increment is visible to the caller.)
 </p>
 <pre>
 // Simpler counter server.
 type Counter int
 
-func (ctr *Counter) ServeHTTP(c http.ResponseWriter, req *http.Request) {
+func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
     *ctr++
-    fmt.Fprintf(c, "counter = %d\n", *ctr)
+    fmt.Fprintf(w, "counter = %d\n", *ctr)
 }
 </pre>
 <p>
 What if your program has some internal state that needs to be notified that a page
 has been visited?  Tie a channel to the web page.
 </p>
 <pre>
 // A channel that sends a notification on each visit.
 // (Probably want the channel to be buffered.)
 type Chan chan *http.Request
 
-func (ch Chan) ServeHTTP(c http.ResponseWriter, req *http.Request) {
+func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
     ch &lt;- req
-    fmt.Fprint(c, "notification sent")
+    fmt.Fprint(w, "notification sent")
 }
 </pre>
 <p>
 Finally, let's say we wanted to present on <code>/args</code> the arguments
 used when invoking the server binary.
 It's easy to write a function to print the arguments.
 </p>
 <pre>
 func ArgServer() {
     for i, s := range os.Args {
         fmt.Println(s)
     }
 }
 </pre>
 <p>
 How do we turn that into an HTTP server?  We could make <code>ArgServer</code>
 a method of some type whose value we ignore, but there's a cleaner way.
 Since we can define a method for any type except pointers and interfaces,
 we can write a method for a function.
 The <code>http</code> package contains this code:
 </p>
 <pre>
 // The HandlerFunc type is an adapter to allow the use of
 // ordinary functions as HTTP handlers.  If f is a function
 // with the appropriate signature, HandlerFunc(f) is a
 // Handler object that calls f.
 type HandlerFunc func(ResponseWriter, *Request)
 
 // ServeHTTP calls f(c, req).
-func (f HandlerFunc) ServeHTTP(c ResponseWriter, req *Request) {
-    f(c, req)
+func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
+    f(w, req)
 }
 </pre>
 <p>
 <code>HandlerFunc</code> is a type with a method, <code>ServeHTTP</code>,
 so values of that type can serve HTTP requests.  Look at the implementation
 of the method: the receiver is a function, <code>f</code>, and the method
 calls <code>f</code>.  That may seem odd but it's not that different from, say,
 the receiver being a channel and the method sending on the channel.
 </p>
 <p>
 To make <code>ArgServer</code> into an HTTP server, we first modify it
 to have the right signature.
 </p>
 <pre>
 // Argument server.
-func ArgServer(c http.ResponseWriter, req *http.Request) {
+func ArgServer(w http.ResponseWriter, req *http.Request) {
     for i, s := range os.Args {
-        fmt.Fprintln(c, s)
+        fmt.Fprintln(w, s)
     }
 }
 </pre>
 <p>
 <code>ArgServer</code> now has same signature as <code>HandlerFunc</code>,
 so it can be converted to that type to access its methods,
 just as we converted <code>Sequence</code> to <code>IntArray</code>
 to access <code>IntArray.Sort</code>.
 The code to set it up is concise:
 </p>
@@ skipping 816 matching lines @@
 
 func main() {
     flag.Parse()
     http.Handle("/", http.HandlerFunc(QR))
     err := http.ListenAndServe(*addr, nil)
     if err != nil {
         log.Exit("ListenAndServe:", err)
     }
 }
 
-func QR(c http.ResponseWriter, req *http.Request) {
-    templ.Execute(req.FormValue("s"), c)
+func QR(w http.ResponseWriter, req *http.Request) {
+    templ.Execute(req.FormValue("s"), w)
 }
 
 func UrlHtmlFormatter(w io.Writer, v interface{}, fmt string) {
     template.HTMLEscape(w, []byte(http.URLEscape(v.(string))))
 }
 
 
 const templateStr = `
 &lt;html&gt;
 &lt;head&gt;
@@ skipping 72 matching lines @@
 <pre>
 verifying implementation
 type Color uint32
 ····
 // Check that Color implements image.Color and image.Image
 var _ image.Color = Black
 var _ image.Image = Black
 </pre>
 -->