Perché Go ha una dichiarazione "goto"

Sono stato sorpreso di scoprire che Go ha una dichiarazione "goto" . Mi è sempre stato insegnato che le affermazioni "goto" sono una cosa del passato e malvagie perché occludono il flusso effettivo di un programma e che le funzioni oi metodi sono sempre un modo migliore per controllare il flusso.

Devo essermi perso qualcosa. Perché Google l'ha incluso?

Quando controlliamo effettivamente il codice sorgente della libreria standard Go, possiamo vedere dove le gotos sono effettivamente ben applicate.

Ad esempio, nel math/gamma.gofile, viene utilizzata l' gotoistruzione :

  for x < 0 {
    if x > -1e-09 {
      goto small
    }
    z = z / x
    x = x + 1
  }
  for x < 2 {
    if x < 1e-09 {
      goto small
    }
    z = z / x
    x = x + 1
  }

  if x == 2 {
    return z
  }

  x = x - 2
  p = (((((x*_gamP[0]+_gamP[1])*x+_gamP[2])*x+_gamP[3])*x+_gamP[4])*x+_gamP[5])*x + _gamP[6]
  q = ((((((x*_gamQ[0]+_gamQ[1])*x+_gamQ[2])*x+_gamQ[3])*x+_gamQ[4])*x+_gamQ[5])*x+_gamQ[6])*x + _gamQ[7]
  return z * p / q

small:
  if x == 0 {
    return Inf(1)
  }
  return z / ((1 + Euler*x) * x)
}

In gotoquesto caso, ci evita di introdurre un'altra variabile (booleana) usata solo per il flusso di controllo, controllata alla fine. In questo caso , l' gotoistruzione rende il codice effettivamente migliore da leggere e da seguire più facilmente (al contrario dell'argomento contro gotodi cui hai parlato).

Si noti inoltre che la gotodichiarazione ha un caso d'uso molto specifico. La specifica del linguaggio su goto afferma che non può saltare le variabili che entrano nello scope (che vengono dichiarate) e non può saltare in altri blocchi (di codice).

Goto è una buona idea quando nessuna delle funzionalità di controllo integrate fa esattamente quello che vuoi e quando puoi esprimere ciò che vuoi con un goto. (È un peccato in questi casi in alcune lingue quando non si dispone di goto. Si finisce per abusare di alcune funzionalità di controllo, utilizzare flag booleani o utilizzare altre soluzioni peggiori di goto.)

Se qualche altra funzione di controllo (usata in modo ragionevolmente ovvio) può fare quello che vuoi, dovresti usarla preferibilmente a goto. In caso contrario, sii audace e usa goto!

Infine vale la pena notare che il goto di Go ha alcune restrizioni progettate per evitare alcuni bug oscuri. Vedere queste limitazioni nelle specifiche.

Le dichiarazioni di Goto hanno ricevuto molto discredito dall'era del codice Spaghetti negli anni '60 e '70. Allora non c'era una metodologia di sviluppo software molto scarsa o nulla. Tuttavia i Goto non sono nativamente malvagi ma possono ovviamente essere usati in modo improprio e abusati da programmatori pigri o inesperti. Molti problemi con Gotos abusati possono essere risolti con processi di sviluppo come le revisioni del codice del team.

gotosono salti nello stesso modo tecnico di continue, breakereturn . Si potrebbe sostenere che queste sono affermazioni sono malvagie allo stesso modo, ma non lo sono.

Il motivo per cui il team Go ha incluso Gotos è probabilmente dovuto al fatto che si tratta di una primitiva comune di controllo del flusso. Inoltre, si spera, hanno concluso che lo scopo di Go esclude il fatto di non poter abusare di un linguaggio sicuro per gli idioti.