Toen ik jong was, midden in de 8-bit revolutie, was BASIC de taal waarin hobbyisten leerden programmeren. Vrijwel iedere 'thuiscomputer' in die tijd werd geleverd zonder operating system, maar met BASIC in ROM aanwezig. Feitelijk diende BASIC meteen ook als OS. In die tijd werden in BASIC al behoorlijk professionele programma's geschreven, maar de puristen vonden het maar niks. En de reden daarvoor was in feite één commando: GO TO. Eventueel mocht je ook nog een hekel hebben aan GO SUB, maar het was vooral GO TO waar met enige walging over werd gesproken. 

 Als je 'netjes' programmeert heb je geen GO TO nodig. Gebruik je het wel, dan zit je binnen de kortste keren met onleesbare spaghetti. Om daar een heel simpel en gezocht voorbeeld van te geven, dit mag in BASIC:

10 CLS: REM maak het scherm leeg
20 PRINT “Dit is het eerste bericht”
30 GOTO 60
40 PRINT “Dit is het laatste bericht”
50 END
60 PRINT “Dit is het middelste bericht”
70 GOTO 40

Het is heel simpel, en nog goed te volgen, maar de volgorde waarin commando's worden uitgevoerd is nu al een gekke knoop. Laat dit in honderdvoud op een groot programma los en de rapen zijn gaar.

In 'mooie' talen als Pascal of C werd dit zwaar ontmoedigd en in moderne talen als Python of PHP is dit nog steeds niet echt normaal. Maar het kan wel. De structuur van een functie main(), zelf geschreven functies, commando-blokken tussen { en } is allemaal mooi, maar C staat wel degelijk sprongen toe. En soms zijn ze ook gewoon echt nodig. De twee netste varianten zijn continue en break. Continue gebruik je in een loop om de rest van het opdrachtblok over te slaan en direct naar de laatste accolade van dat blok te springen. Dus bijvoorbeeld:

int i=0;
while(i++<10)
{
     if(i==5) continue;
     printf(“%d\n”,i);
}

Zal een cijferreeks tonen, maar de 5 wordt overgeslagen.

Met break spring je volledig uit een loop, of uit een switch. Bij die laatste is het meestal ook echt nodig, omdat een switch anders werkt dan je wellicht verwacht: nadat een waarde is gevonden worden alle opdrachten daarna uitgevoerd, ook die bij een andere waarde horen. Met een break voorkom je dat. Dus zo gebeurt wat je zou verwachten:

int i=3; 

switch(i)
{
     case 1:
          doe_iets();
          break;
     case 3:
          doe_iets_anders();
          break;
     default:
          doe_dit_dan();
          break;
}

Zonder de break zouden hier de laatste twee functies beiden worden uitgevoerd.

Maar de echte boosdoener voor mensen die van netjes programmeren houden, is de goto. In C kan je bijvoorbeeld dit doen:

int main()
{
     int i=5;
     printf(“\nZou i gelijk zijn aan 5?\n”);
     if(i==5)goto label_i5;
     printf(“Nee, i is niet gelijk aan 5!\n”);
     goto label_einde;

     label_i5:
          printf(“Ja, i is gelijk aan 5!\n”); 

label_einde:

return 0;
}

Is dat handig? Nee. Is het lelijk? Jazeker. Maar het kan, en soms zal het wel handig zijn.

Op GitHub staat de source van sprongen.c, waarmee zowel switch als break, als goto nauwkeurig worden gedemonstreerd.