10.functions

// Sample program to show how functions can return multiple values while using
// named and struct types.
package main

import (
    "encoding/json"
    "fmt"
)

// user is a struct type that declares user information.
type user struct {
    Id   int
    Name string
}

// retrieveUser retrieves the user document for the specified
// user and returns a pointer to a user type value.
// retrieveUser检索指定的用户文档。
//用户返回一个指向用户类型值的指针。
func retrieveUser(name string) (*user, error) {
    // Make a call to get the user in a json response.
    r, err := getUser(name)
    if err != nil {
        return nil, err
    }

    // Unmarshal the json document into a value of
    // the user struct type.
    var u user
    err = json.Unmarshal([]byte(r), &u)
    return &u, err
}

// GetUser simulates a web call that returns a json
// document for the specified user.
// GetUser模拟返回json的web调用。
//指定用户的文件。
func getUser(name string) (string, error) {
    response := `{"id":1432, "name":"sally"}`
    return response, nil
}

func main() {
    // Retrieve the user profile.
    u, err := retrieveUser("sally")

    if err != nil {
        fmt.Println(err)
        return
    }

    // Display the user profile.
    fmt.Printf("%+v\n", *u)
}

/*
{Id:1432 Name:sally}

*/

// Sample program to show how we can use the blank identifier to
// ignore return values.
// 示例程序演示如何使用空白标识符。
// 忽略返回值。
package main

import (
    "encoding/json"
    "errors"
    "fmt"
)

// user is a struct type that  declares user information.
type user struct {
    ID   int
    Name string
}

// updateStats provIDes update stats.
type updateStats struct {
    Modified int
    Duration float64
    Success  bool
    Message  string
}

func main() {
    // Declare and initialize a value of type user.
    u := user{
        ID:   1432,
        Name: "Betty",
    }

    // Update the user Name. Don‘t care about the update stats. 更新用户名。不要在意更新stats。
    if _, err := updateUser(&u); err != nil {
        fmt.Println(err)
        return
    }

    // Display the update was Successful.
    fmt.Println("Updated user record for ID", u.ID)
}

// updateUser updates the specified user document.
func updateUser(u *user) (*updateStats, error) {
    // response simulates a JSON response.
    response := `{"Modified":1, "Duration":0.005, "Success" : true, "Message": "updated"}`

    // Unmarshal the json document into a value of
    // the userStats struct type.
    var us updateStats
    if err := json.Unmarshal([]byte(response), &us); err != nil {
        return nil, err
    }

    // Check the update status to verify the update
    // was Successful.
    if us.Success != true {
        return nil, errors.New(us.Message)
    }

    return &us, nil

}

/*
Updated user record for ID 1432
*/

// From Spec:
// a short variable declaration may redeclare variables provided they
// were originally declared earlier in the same block with the same
// type, and at least one of the non-blank variables is new.

// Sample program to show some of the mechanics behind the
// short variable declaration operator redeclares.
//从规范:
//一个简短的变量声明可以重新声明提供的变量。
//最初是在同一块区域以相同的方式声明的。
//类型，至少其中一个非空变量是新的。

//示例程序展示了一些背后的机制。
//短期变量声明操作符声明。

package main

import "fmt"

// user is a struct type that declares user information.
type user struct {
    id   int
    name string
}

func main() {
    // Declare the error variable.
    var err1 error

    // The short variable declaration operator will
    // declare u and redeclare err1.
    u, err1 := getUser()
    if err1 != nil {
        return
    }
    fmt.Println(u) // &{1432 Tomcat}

    // The short variable declaration operator will
    // redeclare u and declare err2.
    u, err2 := getUser()
    if err2 != nil {
        return
    }

    fmt.Println(u)
    // &{1432 Tomcat}

}

// getUser returns a pointer of type user.
func getUser() (*user, error) {
    return &user{1432, "Tomcat"}, nil
}

// Sample program to show how anonymous functions and closures work.
package main

import "fmt"

func main() {
    var n int
    // Declare an anonymous function and call it.
    func() {
        fmt.Println("Direct:", n)
    }()
    /*
        Direct: 0
    */

    // Declare an anonymous function and assign it to a variable.
    f := func() {
        fmt.Println("Variable:", n)
    }

    // Call the anonymous function through the variable.
    f()
    /*
        Variable: 0
    */

    // Defer the call to the anonymous function till after main returns. 在主返回之后，将调用延迟到匿名函数。
    defer func() {
        fmt.Println("Defer 1:", n)
    }()

    // Set the value of n to 3 before the return.
    n = 3

    // Call the anonymous function through the variable.
    f()

    // Defer the call to the anonymous function till after main returns.
    defer func() {
        fmt.Println("Defer 2:", n)
    }()

}

/*  说明后进先执行 从下往上
Direct: 0
Variable: 0
Variable: 3
Defer 2: 3
Defer 1: 3
*/

// Sample program to show how to recover from panics.
package main

import (
    "fmt"
    "runtime"
)

func main() {

    // Call the testPanic function to run the test.
    if err := testPanic(); err != nil {
        fmt.Println("Error:", err)
    }
}

// testPanic simulates a function that encounters a panic to
// test our catchPanic function.
func testPanic() (err error) {

    // Schedule the catchPanic function to be called when
    // the testPanic function returns.
    defer catchPanic(&err)

    fmt.Println("Start Test")

    // Mimic a traditional error from a function.
    err = mimicError("1")

    // Trying to dereference a nil pointer will cause the
    // runtime to panic.
    var p *int
    *p = 10

    fmt.Println("End Test")
    return err
}

// catchPanic catches panics and processes the error.
func catchPanic(err *error) {

    // Check if a panic occurred.
    if r := recover(); r != nil {
        fmt.Println("PANIC Deferred")

        // Capture the stack trace.
        buf := make([]byte, 10000)
        runtime.Stack(buf, false)
        fmt.Println("Stack Trace:", string(buf))

        // If the caller wants the error back provide it.
        if err != nil {
            *err = fmt.Errorf("%v", r)
        }
    }
}

// mimicError is a function that simulates an error for
// testing the code.
func mimicError(key string) error {
    return fmt.Errorf("Mimic Error : %s", key)
}

/*
Start Test
PANIC Deferred
Stack Trace: goroutine 1 [running]:
main.catchPanic(0xc04202bf08)
*/

// Declare a struct type to maintain information about a user. Declare a function
// that creates value of and returns pointers of this type and an error value. Call
// this function from main and display the value.
//
// Make a second call to your function but this time ignore the value and just test
// the error value.

//声明一个结构类型以维护有关用户的信息。声明一个函数
//它会创建并返回该类型的指针和错误值。调用
//该函数从main函数中显示值。

//再次调用你的函数，但这一次忽略值，只测试。
//错误的值。
package main

import "fmt"

// user represents a user in the system.
type user struct {
    name  string
    email string
}

// newUser creates and returns pointers of user type values.
func newUser() (*user, error) {
    return &user{"Bill", "bill@ardanlabs.com"}, nil
}

func main() {

    // Create a value of type user.
    u, err := newUser()
    if err != nil {
        fmt.Println(err)
        return
    }

    // Display the value.
    fmt.Println(*u)

    // Call the function and just check the error on the return.
    _, err = newUser()
    if err != nil {
        fmt.Println(err)
        return
    }

}

/*
{Bill bill@ardanlabs.com}
*/