Gå till

Den här artikeln handlar om programmeringsförklaringen på högnivåspråk. För annan användning, se Goto (disambiguation) .
" GOTO "-tangenten på 1982 ZX Spectrum

Goto ( goto , GOTO , GO TO , GoTo , eller andra fallkombinationer, beroende på programmeringsspråket) är ett påstående som finns i många datorprogrammeringsspråk . Den utför en enkelriktad överföring av kontroll till en annan kodrad; däremot returnerar ett funktionsanrop normalt kontroll. Platserna som hoppade till identifieras vanligtvis med etiketter , även om vissa språk använder radnummer . På maskinkodsnivå är en goto en form av gren- eller hoppsats , i vissa fall kombinerat med en stackjustering. Många språk stöder goto- satsen, och många gör det inte (se § språkstöd ) .

Den strukturerade programsatsen bevisade att goto -satsen inte är nödvändig för att skriva program som kan uttryckas som flödesscheman ; någon kombination av de tre programmeringskonstruktionerna sekvens, urval/val och upprepning/iteration är tillräckliga för alla beräkningar som kan utföras av en Turing-maskin , med förbehållet att kodduplicering och ytterligare variabler kan behöva införas.

Tidigare har det förekommit en omfattande debatt inom akademi och industri om fördelarna med användningen av goto- uttalanden. Användning av goto var tidigare vanligt, men sedan tillkomsten av strukturerad programmering på 1960- och 1970-talen har användningen minskat avsevärt. Den primära kritiken är att kod som använder goto-satser är svårare att förstå än alternativa konstruktioner. Goto förblir i bruk i vissa vanliga användningsmönster , men alternativ används i allmänhet om de är tillgängliga. Debatter om dess (mer begränsade) användningsområden fortsätter inom den akademiska världen och i mjukvarubranschen.

Användande

goto etikett

Goto - satsen kombineras ofta med if-satsen för att orsaka en villkorlig överföring av kontroll.

OM skick DÅ gå till etikett

Programmeringsspråk inför olika restriktioner med avseende på destinationen för en goto -sats. Till exempel tillåter inte programmeringsspråket C ett hopp till en etikett som finns i en annan funktion, men hopp inom en enda anropskedja är möjliga med hjälp av setjmp/longjmp- funktionerna.

Kritik

Vid mötet före ALGOL som hölls 1959 tvivlade Heinz Zemanek uttryckligen på nödvändigheten av GOTO-uttalanden; vid den tiden ägnade ingen [ citat behövs ] uppmärksamhet åt hans anmärkning, inklusive Edsger W. Dijkstra , som senare blev den ikoniska motståndaren till GOTO. 1970- och 1980-talen såg en nedgång i användningen av GOTO-uttalanden till förmån för det strukturerade programmeringsparadigmet , där GOTO kritiserades för att leda till ohållbar spagettikod . Vissa för programmeringsstil , till exempel GNU Pascals kodningsstandarder, rekommenderar att man inte använder GOTO-satser. Böhm –Jacopini-beviset (1966) avgjorde inte frågan om huruvida strukturerad programmering skulle användas för mjukvaruutveckling, delvis för att konstruktionen var mer sannolikt att dölja ett program än att förbättra det eftersom dess tillämpning kräver introduktion av ytterligare lokala variabler. Det väckte dock en framträdande debatt bland datavetare, lärare, språkdesigners och applikationsprogrammerare som såg en långsam men stadig förskjutning bort från den tidigare allestädes närvarande användningen av GOTO. Den förmodligen mest kända kritiken mot GOTO är ett brev från 1968 av Edsger Dijkstra kallat " Gå till uttalande som anses skadligt" . I det brevet argumenterade Dijkstra för att obegränsade GOTO-uttalanden borde avskaffas från språk på högre nivå eftersom de komplicerade uppgiften att analysera och verifiera riktigheten av program (särskilt de som involverar loopar). Brevet i sig utlöste en debatt, inklusive ett "GOTO anses skadligt" anses skadligt" brev skickat till Communications of the ACM (CACM) i mars 1987, såväl som ytterligare svar från andra personer, inklusive Dijkstras On a Somewhat Disappointing Correspondence .

En alternativ synpunkt presenteras i Donald Knuths Structured Programming med go to Statements, som analyserar många vanliga programmeringsuppgifter och finner att i vissa av dem är GOTO den optimala språkkonstruktionen att använda. I The C Programming Language varnar Brian Kernighan och Dennis Ritchie för att goto är "oändligt oändligt missbrukbart", men föreslår också att det skulle kunna användas för felhanterare i slutet av funktionen och för avbrott på flera nivåer från loopar . Dessa två mönster kan hittas i många efterföljande böcker om C av andra författare; en inledande lärobok från 2007 noterar att felhanteringsmönstret är ett sätt att kringgå "bristen på inbyggd undantagshantering inom C-språket". Andra programmerare, inklusive Linux- kärndesignern och -kodaren Linus Torvalds eller mjukvaruingenjören och bokförfattaren Steve McConnell , protesterar också mot Dijkstras synpunkt och säger att GOTO kan vara en användbar språkfunktion som förbättrar programhastighet, storlek och kodtydlighet, men bara när används på ett förnuftigt sätt av en jämförbart förnuftig programmerare. Enligt datavetenskapsprofessorn John Regehr fanns det 2013 cirka 100 000 fall av goto i Linux-kärnkoden.

Andra akademiker intog en mer extrem synvinkel och hävdade att även instruktioner som brytning och retur från mitten av loopar är dålig praxis eftersom de inte behövs i Böhm–Jacopini-resultatet, och förespråkade därför att loopar skulle ha en enda utgångspunkt. Till exempel Bertrand Meyer i sin lärobok från 2009 att instruktioner som bryta och fortsätta "bara är det gamla goto i fårkläder". En något modifierad form av Böhm–Jacopini-resultatet tillåter dock undvikande av ytterligare variabler i strukturerad programmering, så länge som avbrott på flera nivåer från loopar är tillåtna. Eftersom vissa språk som C inte tillåter raster på flera nivåer via deras break- nyckelord, råder vissa läroböcker programmeraren att använda goto under sådana omständigheter. MISRA C 2004-standarden förbjuder goto , continue , såväl som flera retur- och break -satser. 2012 års upplaga av MISRA C-standarden nedgraderade förbudet mot att gå från "obligatoriskt" till "rådgivande" status; 2012 års utgåva har ytterligare en obligatorisk regel som förbjuder endast hopp bakåt men inte framåt med goto .

FORTRAN introducerade strukturerade programmeringskonstruktioner 1978, och i successiva revisioner skärptes de relativt lösa semantiska reglerna som styr tillåten användning av goto; det "utökade intervallet" där en programmerare kunde använda en GOTO för att gå in i och lämna en fortfarande körande DO-loop togs bort från språket 1978, och 1995 hade flera former av Fortran GOTO, inklusive Computed GOTO och Assigned GOTO, har tagits bort. Vissa allmänt använda moderna programmeringsspråk som Java och Python saknar GOTO-satsen – se språkstöd – även om de flesta ger ett sätt att bryta sig ur ett urval, eller antingen bryta sig ur eller gå vidare till nästa steg i en iteration. Synpunkten att det inte är önskvärt att störa kontrollflödet i kod kan ses i utformningen av vissa programmeringsspråk, till exempel Ada framhäver etikettdefinitioner visuellt med hjälp av vinkelparenteser .

Post 17.10 i comp.lang.c FAQ-listan tar upp frågan om GOTO-användning direkt, med angivande av

Programmeringsstil, liksom skrivstil, är något av en konst och kan inte kodifieras av oflexibla regler, även om diskussioner om stil ofta verkar kretsa uteslutande kring sådana regler. När det gäller goto-uttalandet har det länge observerats att obegränsad användning av gotos snabbt leder till ohållbar spagettikod. Ett enkelt, otänksamt förbud mot goto-satsen leder inte nödvändigtvis omedelbart till vacker programmering: en ostrukturerad programmerare är lika kapabel att konstruera en bysantinsk härva utan att använda några gotos (kanske ersätta konstigt kapslade loopar och booleska kontrollvariabler istället) . Många programmerare intar en måttlig hållning: goto's ska vanligtvis undvikas, men är acceptabla i ett fåtal väl begränsade situationer, om det behövs: som break-satser på flera nivåer, för att sammanföra vanliga åtgärder i en switch-sats, eller för att centralisera rensningsuppgifter i en funktion med flera felreturer. (...) Att blint undvika vissa konstruktioner eller följa regler utan att förstå dem kan leda till lika många problem som reglerna var tänkta att avvärja. Dessutom är många åsikter om programmeringsstil just det: åsikter. De kan vara starkt argumenterade och starkt kännbara, de kan backas upp av solida bevis och argument, men de motsatta åsikterna kan vara lika starkt kännbara, stödda och argumenterade. Det är vanligtvis meningslöst att dras in i "style wars", för i vissa frågor kan motståndare aldrig tyckas hålla med, eller hålla med om att inte hålla med, eller sluta argumentera.

Vanliga användningsmönster

Även om den totala användningen av goto har minskat, finns det fortfarande situationer på vissa språk där en goto ger det kortaste och enklaste sättet att uttrycka ett programs logik (medan det är möjligt att uttrycka samma logik utan gotos, kommer motsvarande kod att vara längre och ofta svårare att förstå). På andra språk finns det strukturerade alternativ, särskilt undantag och tail calls.

Situationer där goto ofta är användbart inkluderar:

  • För att göra koden mer läsbar och lättare att följa
  • Att göra mindre program, och bli av med kodduplicering
  • Implementera en finita-tillståndsmaskin , med hjälp av en tillståndsövergångstabell och goto för att växla mellan tillstånd (i avsaknad av eliminering av svansanrop ), särskilt i automatiskt genererad C-kod. Till exempel, goto i den kanoniska LR-parsern .
  • Implementera flera nivåer break och fortsätt om det inte direkt stöds i språket; detta är ett vanligt idiom i C. Även om Java reserverar nyckelordet goto, implementerar det faktiskt inte det. Istället implementerar Java märkta break och märkta continu-satser. Enligt Java-dokumentationen var användningen av gotos för raster på flera nivåer den vanligaste (90 %) användningen av gotos i C. Java var inte det första språket som använde detta tillvägagångssätt – förbjöd goto, men gav uppehåll på flera nivåer – programmeringsspråket BLISS (närmare bestämt BLISS-11-versionen därav) föregick det i detta avseende.
  • Surrogat för en-nivå bryta eller fortsätta (försök igen) uttalanden när potentiell introduktion av ytterligare loopar kan felaktigt påverka kontrollflödet. Denna praxis har observerats i Netbsd -koden.
  • Felhantering (i avsaknad av undantag), särskilt rensningskod såsom resursallokering. C++ erbjuder ett alternativ till goto-satsen för detta användningsfall, vilket är: Resource Acquisition Is Initialization (RAII) genom att använda destruktörer eller genom att använda try and catch-undantag som används i undantagshantering . setjmp och longjmp är ett annat alternativ, och har fördelen av att kunna varva ner en del av samtalsstacken .
  • Lägger in stacken, t.ex. Algol, PL/I.
  • Specialiserade skriptspråk som fungerar på ett linjärt sätt, till exempel ett dialogsystem för videospel.

Dessa användningar är relativt vanliga i C, men mycket mindre vanliga i C++ eller andra språk med funktioner på högre nivå. Men att kasta och fånga ett undantag i en funktion kan vara utomordentligt ineffektivt på vissa språk; ett utmärkt exempel är Objective-C , där en goto är ett mycket snabbare alternativ.

äldre kod med dålig faktor, där att undvika en goto skulle kräva omfattande omfaktorisering eller kodduplicering . Till exempel, givet en stor funktion där endast viss kod är av intresse, tillåter en goto-sats en att hoppa till eller från endast den relevanta koden, utan att på annat sätt ändra funktionen. Denna användning anses vara kodlukt , men används då och då.

Alternativ

Strukturerad programmering

Den moderna begreppet subrutin uppfanns av David Wheeler när man programmerade EDSAC . För att implementera ett samtal och återvända på en maskin utan en subrutinanropsinstruktion använde han ett speciellt mönster av självmodifierande kod, känt som ett Wheeler-hopp . Detta resulterade i möjligheten att strukturera program med hjälp av välkapslade körningar av rutiner hämtade från ett bibliotek. Detta skulle inte ha varit möjligt med endast goto , eftersom målkoden, som hämtas från biblioteket, inte skulle veta var den skulle hoppa tillbaka till.

designades högnivåspråk som Pascal kring stöd för strukturerad programmering , som generaliserades från subrutiner (även kända som procedurer eller funktioner) mot ytterligare kontrollstrukturer som:

Dessa nya språkmekanismer ersatte motsvarande flöden som tidigare skulle ha skrivits med goto s och if s. Flervägsförgrening ersätter "beräknad goto" där instruktionen att hoppa till bestäms dynamiskt (villkorligt).

Under vissa förhållanden är det möjligt att eliminera lokala go to-satser för äldre program genom att ersätta dem med multilevel loop exit-satser.

Undantag

Ytterligare information: Undantagshantering

I praktiken ger en strikt efterlevnad av den grundläggande trestrukturmallen för strukturerad programmering mycket kapslad kod, på grund av oförmåga att lämna en strukturerad enhet i förtid, och en kombinatorisk explosion med ganska komplexa programtillståndsdata för att hantera alla möjliga förhållanden.

Två lösningar har allmänt antagits: ett sätt att lämna en strukturerad enhet i förtid, och mer generella undantag – i båda fallen går dessa upp i strukturen, återställer kontrollen till omslutande block eller funktioner, men hoppar inte till godtyckliga kodplatser. Dessa är analoga med användningen av en retursats i icke-terminal position – inte strikt strukturerad, på grund av tidig exit, men en mild uppmjukning av begränsningarna för strukturerad programmering. I C, bryt och fortsätt tillåt en att avsluta en loop eller fortsätta till nästa iteration utan att kräva en extra while eller if -sats. På vissa språk är pauser på flera nivåer också möjliga. För att hantera exceptionella situationer lades specialiserade undantagshanteringskonstruktioner till, som try / catch / finally i Java.

Undantagshanteringsmekanismerna för kast-fångst kan också lätt missbrukas för att skapa opåverkade kontrollstrukturer, precis som goto kan missbrukas.

Svansanrop

Huvudartikel: Tail call

I ett dokument som levererades till ACM-konferensen i Seattle 1977, sammanfattade Guy L. Steele debatten om GOTO och strukturerad programmering, och observerade att proceduranrop i efterhand av en procedur mest optimalt kan behandlas som en direkt överföring av kontroll till den anropade proceduren, vilket vanligtvis eliminerar onödiga stackmanipulationsoperationer. Eftersom sådana "svansanrop" är mycket vanliga i Lisp , ett språk där proceduranrop är allestädes närvarande, minskar denna form av optimering avsevärt kostnaden för ett proceduranrop jämfört med GOTO som används på andra språk. Steele hävdade att dåligt implementerade procedursamtal hade lett till en konstgjord uppfattning om att GOTO var billig jämfört med proceduranropet. Steele hävdade vidare att "i allmänhet kan proceduranrop med fördel betraktas som GOTO-satser som också skickar parametrar och kan kodas enhetligt som maskinkod JUMP-instruktioner", med maskinkodstackmanipuleringsinstruktionerna "ansågs vara en optimering (snarare än vice versa). !)". Steele citerade bevis för att väl optimerade numeriska algoritmer i Lisp kunde exekvera snabbare än kod som producerats av då tillgängliga kommersiella Fortran-kompilatorer eftersom kostnaden för ett proceduranrop i Lisp var mycket lägre. I Scheme , en Lisp-dialekt utvecklad av Steele med Gerald Jay Sussman , är optimering av svansanrop obligatorisk.

Även om Steeles artikel inte introducerade mycket som var nytt för datavetenskap, åtminstone som det praktiserades vid MIT, visade det utrymmet för optimering av procedursamtal, vilket gjorde de modularitetsfrämjande egenskaperna hos procedurer till ett mer trovärdigt alternativ till då vanliga kodningsvanor för stora monolitiska procedurer med komplexa interna kontrollstrukturer och omfattande tillståndsdata. Speciellt förvandlade tail call-optimeringarna som diskuterades av Steele proceduren till ett trovärdigt sätt att implementera iteration genom enkel svansrekursion (svansrekursion som anropar samma funktion). Vidare tillåter optimering av svansanrop ömsesidig rekursion av obegränsat djup, under antagande av svansanrop – detta tillåter överföring av kontroll, som i finita tillståndsmaskiner , vilket annars vanligtvis åstadkommes med goto-satser.

Coroutiner

Huvudartikel: Coroutine

Coroutiner är en mer radikal uppmjukning av strukturerad programmering, som tillåter inte bara flera exitpunkter (som i returer i icke-svansposition), utan också flera ingångspunkter, liknande goto-satser. Coroutiner är mer begränsade än goto, eftersom de bara kan återuppta en Coroutine som körs vid specifika punkter – som fortsätter efter en avkastning – snarare än att hoppa till en godtycklig punkt i koden. En begränsad form av koroutiner är generatorer , som är tillräckliga för vissa ändamål. Ännu mer begränsade är nedläggningar – subrutiner som upprätthåller tillstånd (via statiska variabler ), men inte exekveringsposition. En kombination av tillståndsvariabler och strukturerad kontroll, särskilt en övergripande switch-sats, kan tillåta en subrutin att återuppta exekvering vid en godtycklig punkt på efterföljande anrop, och är ett strukturerat alternativ till goto-satser i frånvaro av coroutiner; detta är ett vanligt idiom i till exempel C.

Fortsättningar

Huvudartikel: Fortsättning

En fortsättning liknar en GOTO genom att den överför kontrollen från en godtycklig punkt i programmet till en tidigare markerad punkt. En fortsättning är mer flexibel än GOTO på de språk som stöder den, eftersom den kan överföra kontrollen från den aktuella funktionen, något som en GOTO inte kan göra i de flesta strukturerade programmeringsspråk. I de språkimplementationer som upprätthåller stackramar för lagring av lokala variabler och funktionsargument, innebär exekvering av en fortsättning justering av programmets anropsstack utöver ett hopp. Longjmp -funktionen i programmeringsspråket C är ett exempel på en escape-fortsättning som kan användas för att escape den aktuella kontexten till en omgivande . Common Lisp GO-operatorn har också denna stack-avvecklingsegenskap, trots att konstruktionen är lexikalt omfång , eftersom etiketten som ska hoppa till kan refereras från en stängning .

I Schema kan fortsättningar till och med flytta kontrollen från ett yttre sammanhang till ett inre om så önskas. Denna nästan obegränsade kontroll över vilken kod som exekveras härnäst gör komplexa kontrollstrukturer som koroutiner och kooperativ multitasking relativt lätt att skriva.

Meddelandet passerar

Huvudartikel: Meddelande passerar

I icke-processmässiga paradigm är goto mindre relevant eller helt frånvarande. Ett av huvudalternativen är meddelandeöverföring , vilket är av särskild betydelse vid samtidig beräkning , interprocesskommunikation och objektorienterad programmering . I dessa fall har de enskilda komponenterna inte godtycklig överföring av kontroll, men den övergripande kontrollen kan schemaläggas på komplexa sätt, till exempel via preemption . De inflytelserika språken Simula och Smalltalk var bland de första som introducerade begreppen meddelanden och objekt. Genom att kapsla in tillståndsdata reducerade objektorienterad programmering mjukvarans komplexitet till interaktioner (meddelanden) mellan objekt.

Variationer

Det finns ett antal olika språkkonstruktioner under klassen goto -satser.

Beräknad GOTO och tilldelad GOTO

Se även: Grenbord

I Fortran hoppar en beräknad GOTO till en av flera etiketter i en lista, baserat på värdet av ett uttryck. Ett exempel är goto (20,30,40) i . Den ekvivalenta konstruktionen i C är switch-satsen och i nyare Fortran är en CASE- sats det rekommenderade syntaktiska alternativet. BASIC hade ett "On GoTo" -uttalande som uppnådde samma mål, men i Visual Basic stöds inte längre denna konstruktion.

I versioner före Fortran 95 hade Fortran även en tilldelad goto- variant som överför kontrollen till en satsetikett (radnummer) som lagras i (tilldelad till) en heltalsvariabel. Att hoppa till en heltalsvariabel som inte hade tilldelats var tyvärr möjligt, och var en stor källa till buggar som involverade tilldelade gotos. Fortran assign -satsen tillåter endast att ett konstant (befintligt) radnummer tilldelas heltalsvariabeln. Det var dock möjligt att av misstag behandla denna variabel som ett heltal därefter, till exempel öka det, vilket resulterade i ospecificerat beteende vid goto -tidpunkten. Följande kod visar beteendet hos goto i när rad i är ospecificerad: 

      
      
      
   tilldela  200  till  i  i  =  i  +  1  goto  i  ! ospecificerat beteende   200  skriv  (  *  ,  *  )  "detta är ett giltigt radnummer"

Flera C-kompilatorer implementerar två icke-standardiserade C/C++-tillägg relaterade till gotos som ursprungligen introducerades av gcc . GNU-tillägget gör att adressen till en etikett i den aktuella funktionen kan erhållas som ett tomrum* med den unära, prefixet etikettvärdesoperator && . Goto-instruktionen utökas också för att tillåta att hoppa till ett godtyckligt void* -uttryck. Denna C-förlängning hänvisas till som en beräknad goto i dokumentationen av C-kompilatorerna som stöder den; dess semantik är en överordnad mängd av Fortrans tilldelade goto, eftersom det tillåter godtyckliga pekaruttryck som goto-mål, medan Fortrans tilldelade goto inte tillåter godtyckliga uttryck som hoppmål. Som med standard goto i C tillåter GNU C-tillägget att målet för den beräknade goto endast finns i den aktuella funktionen. Försök att hoppa utanför den aktuella funktionen resulterar i ospecificerat beteende.

Vissa varianter av BASIC stöder också en beräknad GOTO i den mening som används i GNU C, dvs där målet kan vara vilket radnummer som helst, inte bara ett från en lista. Till exempel, i MTS BASIC skulle man kunna skriva GOTO i*1000 för att hoppa till raden numrerad 1000 gånger värdet av en variabel i (som kan representera ett valt menyalternativ, till exempel).

PL/I -etikettvariabler uppnår effekten av beräknade eller tilldelade GOTO s.

ÄNDRA

Fram till 1985 års ANSI COBOL- standard hade ALTER-satsen som kunde användas för att ändra destinationen för en befintlig GO TO, som måste vara i ett stycke för sig. Funktionen, som möjliggjorde polymorfism , fördömdes ofta och användes sällan.

Perl GÅ TILL

I Perl finns en variant av goto -satsen som inte alls är en traditionell GOTO-sats. Den tar ett funktionsnamn och överför kontroll genom att effektivt ersätta ett funktionsanrop med ett annat (ett svansanrop ): den nya funktionen kommer inte att återgå till GOTO, utan istället till den plats från vilken den ursprungliga funktionen anropades.

Emulerade GOTO

Det finns flera programmeringsspråk som inte stöder GOTO som standard. Genom att använda GOTO-emulering är det fortfarande möjligt att använda GOTO i dessa programmeringsspråk, om än med vissa begränsningar. Man kan emulera GOTO i Java, JavaScript och Python.

PL/I-etikettvariabler

PL/I har datatypen LABEL , som kan användas för att implementera både "tilldelad goto" och "beräknad goto." PL/I tillåter förgreningar från det aktuella blocket. En anropande procedur kan skicka en etikett som ett argument till en anropad procedur som sedan kan avslutas med en gren. Värdet på en etikettvariabel inkluderar adressen till en stackram, och en goto ut ur blocket öppnar stacken. 

 /* Detta implementerar motsvarigheten till */ /* den tilldelade goto */ declare where label; där = någonstans;  gå vart;  ... någonstans: /* uttalande */ ;  ...  
 /* Detta implementerar motsvarigheten till */ /* den beräknade goto */ declare where (5) label; förklara inx fixat;  där (1) = abc;  där (2) = xyz;  ... goto where(inx);  ... abc: /* uttalande */ ;  ... xyz: /* uttalande */ ;  ...

Ett enklare sätt att få ett likvärdigt resultat är att använda en etikettkonstant-array som inte ens behöver en explicit deklaration av en variabel av LABEL -typ: 

/* Detta implementerar motsvarigheten till */ /* den beräknade goto */ deklarera inx fixat; ... goto where(inx); ... where(1): /*-sats */ ; ... where(2): /* sats */ ; ...

MS/DOS GÅ TILL

I en DOS- batchfil dirigerar Goto körningen till en etikett som börjar med ett kolon. Målet för Goto kan vara en variabel. 

 
 

         
 


 


 


 @  echo  off  SET  D8str  =  %date%  SET  D8dow  =  %D8str:~0,3%  FÖR  %%  D  in  (  mån onsdag fre  )  gör  om  "  %%  D"  ==  "  %D8dow%  "  gå till  SHOP%%D  echo  Idag är   %D8dow%  inte en shoppingdag.  goto  end  :  SHOPmon  echo  köp pizza till lunch - måndag är pizzadagen.  goto  end  :  SHOPWed  echo  köp Calzone att ta med hem - idag är det onsdag.  goto  end  :  SHOPFri  echo  köp Seltzer ifall någon vill ha en kalorifri drink.  :  slut

Språkstöd

Många språk stöder goto -påståendet, och många gör det inte. I Java är goto ett reserverat ord , men det är oanvändbart, även om den kompilerade file.class genererar GOTOs och LABELs . Python har inte stöd för goto, även om det finns flera skämtmoduler som tillhandahåller det. Det finns ingen goto-sats i Seed7 och dolda gotos som break- och continue-satser är också utelämnade. I PHP fanns det inget inbyggt stöd för goto förrän version 5.3 (bibliotek var tillgängliga för att emulera dess funktionalitet).

Programmeringsspråket C# har fått . Det tillåter dock inte att hoppa till en etikett utanför den nuvarande omfattningen, vilket gör den betydligt mindre kraftfull och farlig än goto i andra programmeringsspråk. Den gör också etiketter för case och standardsatser , vars omfattning är den omslutande switch-satsen ; goto case eller goto default används ofta som en explicit ersättning för implicit fallthrough, vilket C# inte tillåter.

PL /I- programmeringsspråket har en GOTO-sats som lindar upp stacken för en överföring utanför blocket och tillåter inte en överföring till ett block utifrån.

Andra språk kan ha sina egna separata nyckelord för explicita genombrott, som kan betraktas som en version av goto som är begränsad till detta specifika syfte. Till exempel använder Go fallthrough och tillåter inte implicit fallthrough alls, medan Perl 5 använder next för explicit fallthrough som standard, men tillåter också att ställa in implicit fallthrough som standardbeteende för en modul.

De flesta språk som har goto-uttalanden kallar det så, men i de första dagarna av datoranvändning användes andra namn. Till exempel, i MAD användes TRANSFER TO-satsen. APL använder en högerpekande pil, → för goto.

C har goto, och det används ofta i olika idiom, som diskuterats ovan.

Funktionella programmeringsspråk som Scheme har i allmänhet inte goto, utan använder istället fortsättningar.

Se även

Anteckningar

  • Fronczak, Edward J.; Lubbers, Clark E. (september 1974). MTS, Michigan terminalsystem . University of Michigan Computing Center. UOM:39015034770076.
  •   Geisler, Sandra (2011). C Allt-i-ett skrivbordsreferens för dummies . John Wiley & Sons. s. 217–220. ISBN 978-1-118-05424-6 .
  • Hindle, Richie (1 april 2004). "goto för Python" . Entrian Solutions . Hertford, Storbritannien: Entrian Solutions Ltd. Hämtad 2021-11-10 .
  •   McConnell, Steve (december 2004). Code Complete: A Practical Handbook of Software Construction, andra upplagan (andra upplagan). Microsoft Press. ISBN 978-0735619678 .
  •   Meyer, Bertrand (2009). Touch of Class: Lär dig programmera väl med objekt och kontrakt . Springer Science & Business Media. sid. 189. ISBN 978-3-540-92144-8 .
  • Perl-syntaxmanual (2021). Gå till (Rapportera) . Hämtad 2021-11-14 .
  • PHP-manual (2021). "goto" . PHP . Hämtad 2021-11-13 .
  • z/OS 2.5.0 i IBM Documentation (2021). "Computed goto-sats (IBM-tillägg)" . IBM . Hämtad 2021-11-13 . Det här dokumentet beskriver syntax, semantik och IBM z/OS® XL C/C++-implementering av programmeringsspråken C och C++. För en allmän C- eller C++-standardreferens, se cppreference.com.
Hämtad från " https://en.wikipedia.org/w/index.php?title=Goto&oldid=1137600618 "