Go调试利器，手把手入门dlv (上)

package main

import "fmt"

// dlv 调试器

func main() {
  nums := make([]int, 5)
  for i := 0; i < len(nums); i++ {
    nums[i] = i * i
  }
  fmt.Println(nums)
}

➜  Delve git:(master) ✗ dlv debug
Type 'help' for list of commands.
(dlv)

(dlv) help
The following commands are available:


Running the program:
    call ------------------------ Resumes process, injecting a function call (EXPERIMENTAL!!!)
    continue (alias: c) --------- Run until breakpoint or program termination.
    next (alias: n) ------------- Step over to next source line.
    rebuild --------------------- Rebuild the target executable and restarts it. It does not work if the executable was not built by delve.
    restart (alias: r) ---------- Restart process.
    step (alias: s) ------------- Single step through program.
    step-instruction (alias: si)  Single step a single cpu instruction.
    stepout (alias: so) --------- Step out of the current function.


Manipulating breakpoints:
    break (alias: b) ------- Sets a breakpoint.
    breakpoints (alias: bp)  Print out info for active breakpoints.
    clear ------------------ Deletes breakpoint.
    clearall --------------- Deletes multiple breakpoints.
    condition (alias: cond)  Set breakpoint condition.
    on --------------------- Executes a command when a breakpoint is hit.
    toggle ----------------- Toggles on or off a breakpoint.
    trace (alias: t) ------- Set tracepoint.
    watch ------------------ Set watchpoint.


Viewing program variables and memory:
    args ----------------- Print function arguments.
    display -------------- Print value of an expression every time the program stops.
    examinemem (alias: x)  Examine raw memory at the given address.
    locals --------------- Print local variables.
    print (alias: p) ----- Evaluate an expression.
    regs ----------------- Print contents of CPU registers.
    set ------------------ Changes the value of a variable.
    vars ----------------- Print package variables.
    whatis --------------- Prints type of an expression.


Listing and switching between threads and goroutines:
    goroutine (alias: gr) -- Shows or changes current goroutine
    goroutines (alias: grs)  List program goroutines.
    thread (alias: tr) ----- Switch to the specified thread.
    threads ---------------- Print out info for every traced thread.


Viewing the call stack and selecting frames:
    deferred --------- Executes command in the context of a deferred call.
    down ------------- Move the current frame down.
    frame ------------ Set the current frame, or execute command on a different frame.
    stack (alias: bt)  Print stack trace.
    up --------------- Move the current frame up.


Other commands:
    config --------------------- Changes configuration parameters.
    disassemble (alias: disass)  Disassembler.
    dump ----------------------- Creates a core dump from the current process state
    edit (alias: ed) ----------- Open where you are in $DELVE_EDITOR or $EDITOR
    exit (alias: quit | q) ----- Exit the debugger.
    funcs ---------------------- Print list of functions.
    help (alias: h) ------------ Prints the help message.
    libraries ------------------ List loaded dynamic libraries
    list (alias: ls | l) ------- Show source code.
    source --------------------- Executes a file containing a list of delve commands
    sources -------------------- Print list of source files.
    transcript ----------------- Appends command output to a file.
    types ---------------------- Print list of types


Type help followed by a command for full documentation.
(dlv)

(dlv) break main.main
Breakpoint 1 set at 0x10ad04a for main.main() ./delve.go:7

(dlv) bp
Breakpoint runtime-fatal-throw (enabled) at 0x1033f60 for runtime.throw() /usr/local/go/src/runtime/panic.go:982 (0)
Breakpoint unrecovered-panic (enabled) at 0x1034320 for runtime.fatalpanic() /usr/local/go/src/runtime/panic.go:1065 (0)
        print runtime.curg._panic.arg
Breakpoint 1 (enabled) at 0x10ad04a for main.main() ./delve.go:7 (0)

vars main
runtime.main_init_done = chan bool nil
runtime.mainStarted = false

(dlv) c
> main.main() ./delve.go:7 (hits goroutine(1):1 total:1) (PC: 0x10ad04a)
     2:
     3: import "fmt"
     4:
     5: // dlv 调试器
     6:
=>   7: func main() {
     8:         nums := make([]int, 5)
     9:
    10:         for i := 0; i < len(nums); i++ {
    11:                 nums[i] = i * i
    12:         }

(dlv) n
> main.main() ./delve.go:8 (PC: 0x10ad058)
     3: import "fmt"
     4:
     5: // dlv 调试器
     6:
     7: func main() {
=>   8:         nums := make([]int, 5)
     9:
    10:         for i := 0; i < len(nums); i++ {
    11:                 nums[i] = i * i
    12:         }
    13:

(dlv) args
(no args)
(dlv) locals
(no locals)

(dlv) n
> main.main() ./delve.go:10 (PC: 0x10ad083)
     5: // dlv 调试器
     6:
     7: func main() {
     8:         nums := make([]int, 5)
     9:
=>  10:         for i := 0; i < len(nums); i++ {
    11:                 nums[i] = i * i
    12:         }
    13:
    14:         fmt.Println(nums)
    15: }
(dlv) locals
nums = []int len: 5, cap: 5, [...]

(dlv) break delve.go:11
Breakpoint 2 set at 0x10ad0a2 for main.main() ./delve.go:11
(dlv) condition 2 i==3
(dlv) c
> main.main() ./delve.go:11 (hits goroutine(1):1 total:1) (PC: 0x10ad0a2)
     6:
     7: func main() {
     8:         nums := make([]int, 5)
     9:
    10:         for i := 0; i < len(nums); i++ {
=>  11:                 nums[i] = i * i
    12:         }
    13:
    14:         fmt.Println(nums)
    15: }

(dlv) locals
nums = []int len: 5, cap: 5, [...]
i = 3
(dlv) p nums
[]int len: 5, cap: 5, [0,1,4,0,0]