Hace solo un par de días en Denver, la siguiente, ya quinta consecutiva, terminó la conferencia más grande sobre Go - GopherCon . En ese momento, el equipo de Go hizo una declaración importante : se publicaron borradores del diseño preliminar del nuevo manejo de errores y genéricos en Go 2, y todos están invitados a discutir.
Intentaré volver a contar en detalle la esencia de estos borradores en tres artículos.
Como muchos probablemente saben, el año pasado (también en GopherCon), el equipo de Go anunció que estaba recopilando informes ( informes de experiencia ) y sugerencias para resolver los principales problemas de Go, los puntos que fueron más criticados por las encuestas. Durante el año, todas las propuestas e informes fueron estudiados y considerados, y ayudaron a crear proyectos de diseños, que serán discutidos.
Entonces, comencemos con los borradores del nuevo mecanismo de manejo de errores .
Para comenzar, una pequeña digresión:
- Go 2 es un nombre condicional: todas las innovaciones serán parte del proceso normal de lanzamiento de las versiones de Go. Por lo tanto, aún se desconoce si será Go 1.34 o Go2. Python 2/3 script no será de hierro.
- Los borradores de diseño ni siquiera son propuestas , con las cuales comienza cualquier cambio en la biblioteca, el ajuste o el lenguaje Go. Este es el punto de partida para la discusión de diseño propuesta por el equipo de Go después de varios años de trabajo en estos temas. Todo lo que se describe en los borradores con un alto grado de probabilidad cambiará y, en el mejor de los casos, se hará realidad solo después de unos pocos lanzamientos (doy ~ 2 años).
¿Cuál es el problema con el manejo de errores en Go?
Go inicialmente tomó la decisión de utilizar la verificación de errores "explícito", a diferencia de la verificación "implícita" popular en otros idiomas: excepciones. El problema con la comprobación de errores implícita es cómo se describe en detalle en el artículo "Más limpio, más elegante y no más correcto" , que es muy difícil de entender visualmente si el programa se comporta correctamente en caso de ciertos errores.
Tome un ejemplo de un Go hipotético con excepciones:
func CopyFile(src, dst string) throws error {
r := os.Open(src)
defer r.Close()
w := os.Create(dst)
io.Copy(w, r)
w.Close()
}
, . : io.Copy w.Close , .
, Go :
func CopyFile(src, dst string) error {
r, err := os.Open(src)
if err != nil {
return err
}
defer r.Close()
w, err := os.Create(dst)
if err != nil {
return err
}
defer w.Close()
if _, err := io.Copy(w, r); err != nil {
return err
}
if err := w.Close(); err != nil {
return err
}
}
, , , – . , , – " ", - , , , .
, ( , , ..) , .
, Go . :
func CopyFile(src, dst string) error {
r, err := os.Open(src)
if err != nil {
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
defer r.Close()
w, err := os.Create(dst)
if err != nil {
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
if _, err := io.Copy(w, r); err != nil {
w.Close()
os.Remove(dst)
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
if err := w.Close(); err != nil {
os.Remove(dst)
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
}
, .
Go Go 2:
Go.
.
check(x,y,z) check errhandle – ,
check , handle ( handler, , . , return)
:
func CopyFile(src, dst string) error {
handle err {
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
r := check os.Open(src)
defer r.Close()
w := check os.Create(dst)
handle err {
w.Close()
os.Remove(dst) // ( check )
}
check io.Copy(w, r)
check w.Close()
return nil
}
, ( main). :
func main() {
hex, err := ioutil.ReadAll(os.Stdin)
if err != nil {
log.Fatal(err)
}
data, err := parseHexdump(string(hex))
if err != nil {
log.Fatal(err)
}
os.Stdout.Write(data)
}
:
func main() {
handle err {
log.Fatal(err)
}
hex := check ioutil.ReadAll(os.Stdin)
data := check parseHexdump(string(hex))
os.Stdout.Write(data)
}
, . :
func printSum(a, b string) error {
x, err := strconv.Atoi(a)
if err != nil {
return err
}
y, err := strconv.Atoi(b)
if err != nil {
return err
}
fmt.Println("result:", x + y)
return nil
}
:
func printSum(a, b string) error {
handle err { return err }
x := check strconv.Atoi(a)
y := check strconv.Atoi(b)
fmt.Println("result:", x + y)
return nil
}
:
func printSum(a, b string) error {
handle err { return err }
fmt.Println("result:", check strconv.Atoi(x) + check strconv.Atoi(y))
return nil
}
check handle.
Check
check ( ) , "" error, , . nil, check (handler), return .
:
v1, ..., vN := check <>
:
v1, ..., vN, vErr := <>
if vErr != nil {
<error result> = handlerChain(vn)
return
}
vErr error <error result> , .
,
foo(check <>)
:
v1, ..., vN, vErr := <>
if vErr != nil {
<error result> = handlerChain(vn)
return
}
foo(v1, ..., vN)
Check try
try check – /, , , Rust Swift try ( Rust ? ).
try :
data := try parseHexdump(string(hex))
:
data, err := parseHexdump(string(hex))
if err == ErrBadHex {
... special handling ...
}
try err
, try c . check/handle , check .
Handle
handle , "" (handler), , check. (return) . ( , return) ( func foo() (bar int, err error)).
, " " – , , , error , , . :
func handler(err error) error {...}
( , , – ).
– , . (check) , , . , , – . :
func process(user string, files chan string) (n int, err error) {
handle err { return 0, fmt.Errorf("process: %v", err) } // handler A
for i := 0; i < 3; i++ {
handle err { err = fmt.Errorf("attempt %d: %v", i, err) } // handler B
handle err { err = moreWrapping(err) } // handler C
check do(something()) // check 1: handler chain C, B, A
}
check do(somethingElse()) // check 2: handler chain A
}
check 1 C, B A – . check 2 A, C B for-.
, . if , (handle) ( ) , – , , :
type Error struct {
Func string
User string
Path string
Err error
}
func (e *Error) Error() string
func ProcessFiles(user string, files chan string) error {
e := Error{ Func: "ProcessFile", User: user}
handle err { e.Err = err; return &e } // handler A
u := check OpenUserInfo(user) // check 1
defer u.Close()
for file := range files {
handle err { e.Path = file } // handler B
check process(check os.Open(file)) // check 2
}
...
}
, handle defer, , , . – , . , handler B – defer , . Go defer/panic handle/check , , -.
– (.. return), - . .
(panic) , .
-
– (handle err {}). " -" (default handler). handle , , -, , check ( ; — zero values).
-:
func printSum(a, b string) error {
x := check strconv.Atoi(a)
y := check strconv.Atoi(b)
fmt.Println("result:", x + y)
return nil
}
Go , . - , , . , t.Helper() , :
func TestFoo(t *testing.T) {
handle err {
t.Helper()
t.Fatal(err)
}
for _, tc := range testCases {
x := check Foo(tc.a)
y := check Foo(tc.b)
if x != y {
t.Errorf("Foo(%v) != Foo(%v)", tc.a, tc.b)
}
}
}
(shadowing)
check (:=), err. handle/check .
defer/panic
(defer/panic handle/check) . .
handle defer (, , , ), handle/check defer-. :
func Greet(w io.WriteCloser) error {
defer func() {
check w.Close()
}()
fmt.Fprintf(w, "hello, world\n")
return nil
}
, .
Go – , . - "", , defer, break goto. , goto, , .
try, catch, ? , . , Go , check handle .
, handle catch , ( , (keywords) ).
Go2?
. Go, 2-3 , – . , 2-3 .
, , Go2 – . , Go – Go 1.20 . .
, ?
. / . , , , Go.
Go 2 – , if err != nil {} , handle/check?
, , if err , – , . , .
? , Go .
. , .
?
, , . , - . , , , , .
, ! ?
- Go2ErrorHandlingFeedback
- Go —
handle/check - -
- , ,
- / (
defer/panic)
? ?