Vakt (datavetenskap)

Inom datorprogrammering är en guard ett booleskt uttryck som måste utvärderas till sant om programexekveringen ska fortsätta i den aktuella grenen. Oavsett vilket programmeringsspråk som används är en guard-klausul , guard-kod eller guard-sats en kontroll av integritetsförutsättningar som används för att undvika fel under exekvering.

Används

Ett typiskt exempel är att kontrollera att en referens som ska bearbetas inte är null, vilket undviker nollpekarfel.

Andra användningsområden inkluderar att använda ett booleskt fält för idempotens (så efterföljande anrop är nops), som i dispose-mönstret . 

   

        
           
    
    
 public  string  Foo  (  sträng  användarnamn  )  {  if  (  användarnamn  ==  null  )  {  throw  new  ArgumentNullException  (  nameof  (  användarnamn  ),  "Användarnamn är null."  );  }  // Resten av metodkoden följer här...  }

Plattare kod med mindre kapsling

Skyddet ger en tidig utgång från en subrutin och är en vanlig avvikelse från strukturerad programmering , tar bort en nivå av kapsling och resulterar i plattare kod: ersätter om skydd { ... } med om inte skydd: retur; ... .

Att använda guard-klausuler kan vara en refactoring- teknik för att förbättra koden. I allmänhet är mindre kapsling bra, eftersom det förenklar koden och minskar kognitiv börda.

Till exempel i Python:


 
      
        
        
        
           
    
         


 
       
         
    
    
    
        # Den här funktionen har ingen guard-sats  def  f_noguard  (  x  ):  if  isinstance  (  x  ,  int  ):  #code  #code  #code  return  x  +  1  else  :  return  None  # Likvärdig funktion med en guard-sats. Observera att det mesta av koden är mindre indragen, vilket är bra   def  f_guard  (  x  ):  om  inte är  instans  (  x  ,  int  ):  return  Ingen  #kod  #kod  #kod  retur  x  +  1

Terminologi

Termen används med specifik betydelse i programmeringsspråken APL , Haskell , Clean , Erlang , occam , Promela , OCaml , Swift , Python från version 3.10 och Scala . [ citat behövs ] I Mathematica kallas vakter begränsningar . Vakter är det grundläggande konceptet i Guarded Command Language , ett språk i formella metoder . Skyddar kan användas för att utöka mönstermatchningen med möjligheten att hoppa över ett mönster även om strukturen matchar. Booleska uttryck i villkorliga uttalanden passar vanligtvis även denna definition av en vakt även om de kallas villkor .

Matematik

I följande Haskell-exempel sker skydden mellan varje par av "|" och "=":

 
    0  
    f  x  |  x  >  =  1  |  annars  =  0

Detta liknar respektive matematisk notation:

I det här fallet finns vakterna i "om" och "annat" klausulerna.

Flera vakter

Om det finns flera parallella vakter, prövas de normalt i topp-till-botten-ordning, och grenen på den som först passerar väljs. Vakterna i en lista över fall är vanligtvis parallella.

listuppfattningar är dock vakterna i serie, och om någon av dem misslyckas produceras inte listelementet. Detta skulle vara samma sak som att kombinera de separata väktarna med logiska OCH , förutom att det kan finnas andra listförståelsesatser bland väktarna.

Evolution

Ett enkelt villkorligt uttryck, som redan fanns i CPL 1963, har ett skydd mot första deluttryck och ett annat deluttryck att använda om det första inte kan användas. Några vanliga sätt att skriva detta: 

(x>0) -> 1/x; 0 x>0 ? 1/x: 0

Om det andra underuttrycket kan vara ytterligare ett enkelt villkorsuttryck, kan vi ge fler alternativ att prova innan den sista genomgången : 

(x>0) -> 1/x; (x<0) -> -1/x; 0

1966 hade ISWIM en form av villkorligt uttryck utan ett obligatoriskt fall-through-fall, vilket skilde guard från konceptet att välja antingen-eller. I fallet med ISWIM, om inget av alternativen kunde användas, skulle värdet vara undefined , vilket definierades för att aldrig beräknas till ett värde.

KRC , en "miniatyriserad version" av SASL (1976), var ett av de första programmeringsspråken som använde termen "vakt". Dess funktionsdefinitioner kan ha flera satser, och den som ska tillämpas valdes baserat på skydden som följde efter varje klausul: 

                     0
                fac  n  =  1  ,  n  =  =  n  *  fac  (  n  -  1  ),  n  >  0

Användning av vaktklausuler, och termen "vaktklausul", dateras åtminstone till Smalltalk- praxis på 1990-talet, som kodifierats av Kent Beck .

1996 antog Dyalog APL en alternativ ren funktionsstil där skyddet är den enda kontrollstrukturen. Detta exempel, i APL, beräknar pariteten för inmatningsnumret:


          
              
         paritet  ←  {  2  ∣  ⍵  :  'udda'  'jämn'  }

Mönsterskydd

Förutom ett skydd fäst vid ett mönster, kan mönsterskydd hänvisa till användningen av mönstermatchning i samband med ett skydd. I själva verket anses en matchning av mönstret betyda godkänt. Denna betydelse introducerades i ett förslag för Haskell av Simon Peyton Jones med titeln A new view of guards i april 1997 och användes i genomförandet av förslaget. Funktionen ger möjlighet att använda mönster i skydden av ett mönster.

Ett exempel i utökad Haskell:

    
       
       
    
  clunky  env  var1  var2  |  Just  val1  <-  lookup  env  var1  ,  Just  val2  <-  lookup  env  var2  =  val1  +  val2  -- ...andra ekvationer för clunky...

Detta skulle lyda: "Klumpigt för en miljö och två variabler, om uppslagningarna av variablerna från miljön producerar värden , är summan av värdena. ..." Liksom i listuppfattningar är skydden i serie, och om någon av dem misslyckas grenen tas inte.

Se även

externa länkar

Hämtad från " https://en.wikipedia.org/w/index.php?title=Guard_(computer_science)&oldid=1120914500 "