Standardströmmar

Den här artikeln handlar om standard I/O-filbeskrivningar. För System V-strömmar, se STRÖMAR .

I datorprogrammering är standardströmmar sammankopplade in- och utkommunikationskanaler mellan ett datorprogram och dess miljö när det börjar köras. De tre in-/utgångsanslutningarna (I/O) kallas standardingång ( stdin ), standardutgång ( stdout ) och standardfel ( stderr ). Ursprungligen skedde I/O via en fysiskt ansluten systemkonsol (ingång via tangentbord, utgång via monitor), men standardströmmar abstraherar detta. När ett kommando exekveras via ett interaktivt skal är strömmarna vanligtvis anslutna till textterminalen som skalet körs på, men kan ändras med omdirigering eller en pipeline . Mer generellt ärver en underordnad process standardströmmarna från sin överordnade process .

Ansökan

Standardströmmarna för input, output och fel

Användare känner i allmänhet till standardströmmar som in- och utgångskanaler som hanterar data som kommer från en inmatningsenhet, eller som skriver data från applikationen. Data kan vara text med valfri kodning, eller binära data . I många moderna system omdirigeras standardfelströmmen för ett program till en loggfil, vanligtvis för felanalysändamål.

Strömmar kan användas för att kedja applikationer, vilket innebär att utgångsströmmen från ett program kan omdirigeras för att vara ingångsströmmen till en annan applikation. I många operativsystem uttrycks detta genom att lista programnamnen, separerade av det vertikala strecket, av denna anledning ofta kallat pipeline- tecknet . Ett välkänt exempel är användningen av en pagineringsapplikation , såsom mer , som ger användaren kontroll över visningen av utgångsströmmen på skärmen.

Bakgrund

I de flesta operativsystem som gick före Unix , var programmen tvungna att uttryckligen ansluta till lämpliga in- och utgångsenheter. OS-specifika krångligheter gjorde att detta blev en tråkig programmeringsuppgift. På många system var det nödvändigt att få kontroll över miljöinställningar, komma åt en lokal filtabell, bestämma den avsedda datamängden och hantera hårdvaran korrekt i fallet med en hålkortsläsare , magnetbandsenhet , diskenhet , linjeskrivare , korthålslagare , eller interaktiv terminal.

En av Unix flera banbrytande framsteg var abstrakta enheter , som tog bort behovet av ett program för att veta eller bry sig om vilken typ av enheter det kommunicerade med [ citat behövs ] . Äldre operativsystem tvingade på programmeraren en poststruktur och ofta icke-ortogonal datasemantik och enhetskontroll. Unix eliminerade denna komplexitet med konceptet med en dataström: en ordnad sekvens av databyte som kan läsas till slutet av filen . Ett program kan också skriva bytes efter önskemål och behöver inte, och kan inte lätt deklarera deras antal eller gruppering.

Ett annat Unix-genombrott var att automatiskt associera ingång och utdata till terminaltangentbord respektive terminaldisplay, som standard [ citat behövs ] - programmet (och programmeraren) gjorde absolut ingenting för att etablera ingång och utdata för ett typiskt in-process-output-program ( om den inte valde ett annat paradigm). Däremot krävde tidigare operativsystem vanligtvis något – ofta komplext – jobbkontrollspråk för att upprätta anslutningar, eller så måste motsvarande börda orkestreras av programmet. [ citat behövs ]

Eftersom Unix tillhandahöll standardströmmar, var Unix C runtime-miljön tvungen att stödja det också. Som ett resultat ger de flesta C runtime-miljöer (och C:s avkomlingar ), oavsett operativsystem, motsvarande funktionalitet.

Standardingång (stdin)

Standardingång är en ström från vilken ett program läser sina indata. Programmet begär dataöverföringar med hjälp av läsoperationen . Inte alla program kräver streamingång. Till exempel dir- och ls -programmen (som visar filnamn som finns i en katalog) ta kommandoradsargument , men utföra sina operationer utan någon strömdatainmatning.

Om den inte omdirigeras ärvs standardindata från den överordnade processen. I fallet med ett interaktivt skal, är det vanligtvis associerat med tangentbordet .

Filbeskrivningen för standardinmatning är 0 (noll) ; POSIX < unistd.h> -definitionen är STDIN_FILENO ; motsvarande C <stdio.h> -variabel är FILE* stdin ; på liknande sätt är C++ <iostream> -variabeln std::cin .

Standardutgång (stdout)

Standardutdata är en ström till vilken ett program skriver sina utdata. Programmet begär dataöverföring med skrivoperationen . Alla program genererar inte utdata. Till exempel för filbyte (som ibland kallas mv , move eller ren ) tyst vid framgång.

Om den inte omdirigeras ärvs standardutdata från den överordnade processen. I fallet med ett interaktivt skal är det vanligtvis textterminalen som initierade programmet.

Filbeskrivningen för standardutdata är 1 (ett) ; POSIX < unistd.h> -definitionen är STDOUT_FILENO ; motsvarande C <stdio.h> -variabel är FILE* stdout ; på samma sätt är C++ <iostream> -variabeln std::cout .

Standardfel (stderr)

Standardfel är en annan utdataström som vanligtvis används av program för att mata ut felmeddelanden eller diagnostik. Det är en ström oberoende av standardutdata och kan omdirigeras separat.

Detta löser semi-predikatproblemet , vilket gör att utdata och fel kan särskiljas, och är analogt med en funktion som returnerar ett par värden – se Semi-predikatproblem: Multi-valued return . Den vanliga destinationen är textterminalen som startade programmet för att ge den bästa chansen att synas även om standardutdata omdirigeras (så inte lätt observeras). Till exempel, utdata från ett program i en pipeline omdirigeras till inmatning av nästa program eller en textfil, men fel från varje program går fortfarande direkt till textterminalen så att de kan granskas av användaren i realtid.

Det är acceptabelt och normalt att rikta standardutmatning och standardfel till samma destination, såsom textterminalen. Meddelanden visas i samma ordning som programmet skriver dem, om inte buffring är inblandad. Till exempel, i vanliga situationer är standardfelströmmen obuffrad men standardutgångsströmmen är linjebuffrad; i det här fallet kan text som skrivits till standardfel senare visas på terminalen tidigare, om standardutgångsströmbufferten ännu inte är full.

Filbeskrivningen för standardfel definieras av POSIX som 2 (två) ; rubrikfilen <unistd.h> tillhandahåller symbolen STDERR_FILENO ; motsvarande C <stdio.h> -variabel är FILE* stderr . C++ <iostream> -standardhuvudet tillhandahåller två variabler associerade med denna ström: std::cerr och std::clog , den förra är obuffrad och den senare använder samma buffringsmekanism som alla andra C++-strömmar.

Skal i Bourne -stil tillåter att standardfel omdirigeras till samma destination som standardutdata riktas till 

2>&1

csh -stil-skal tillåter att standardfel omdirigeras till samma destination som standardutdata riktas till att använda 

>&

Standardfel lades till i Unix på 1970-talet efter att flera bortkastade fotosättningskörningar slutade med att felmeddelanden typsattes istället för att visas på användarens terminal.

Tidslinje

1950-talet: Fortran

Fortran har motsvarigheten till Unix-filbeskrivningar: Enligt konvention använder många Fortran-implementationer enhetsnummer UNIT=5 för stdin, UNIT=6 för stdout och UNIT=0 för stderr. I Fortran-2003 standardiserades den inneboende ISO_FORTRAN_ENV -modulen för att inkludera de namngivna konstanterna INPUT_UNIT , OUTPUT_UNIT och ERROR_UNIT för att portabelt specificera enhetsnumren. 


      
        
         
         
       ! FORTRAN 77 exempel   PROGRAM  HUVUDHELTAL  NUMMER  LÄS  (  ENHET  =  5  ,  *  )  NUMMER  SKRIV  (  ENHET  =  6  ,  '(A,I3)'  )  '  NUMMER ÄR: '  ,  NUMMER  SLUT 



  
  
    
    
     
 ! Fortran 2003 exempelprogram   huvudanvändning  iso_fortran_env  implicit  inget  heltal  ::  nummer  läs  (  enhet  =  INPUT_UNIT  ,  *  )  nummer  skriv  (  enhet  =  OUTPUT_UNIT  ,  '(a,i3)' ) '  Numret  är  : '  ,  nummer  slutprogram

1960: ALGOL 60

ALGOL 60 kritiserades för att inte ha någon standardfilåtkomst. [ citat behövs ]

1968: ALGOL 68

ALGOL 68 :s in- och utmatningsfaciliteter kallades gemensamt för transput. Koster samordnade definitionen av transputstandarden . Modellen inkluderade tre standardkanaler: stå i , stå ut och stå tillbaka .

Exempel 
# ALGOL 68 exempel # main:( VERKLIGT nummer; getf(stand in,($g$,nummer)); printf(($"Numret är: "g(6,4)"ELLER "$,nummer)); # ELLER # putf(sticker ut,($" Tal är: "g(6,4)"!"$,nummer)); newline(sticker ut) )
Inmatning: Produktion: 
3,14159
 
Antalet är: +3.142 ELLER Antalet är: +3.142!

1970-talet: C och Unix

I programmeringsspråket C är standardinmatnings-, utdata- och felströmmarna kopplade till de befintliga Unix-filbeskrivningarna 0, 1 respektive 2. I en POSIX - miljö bör < unistd.h > definitionerna STDIN_FILENO , STDOUT_FILENO eller STDERR_FILENO användas istället för magiska siffror . Filpekare stdin , stdout och stderr finns också.

Ken Thompson (designer och implementerare av det ursprungliga Unix-operativsystemet) modifierade sorteringen i version 5 Unix för att acceptera "-" som representerande standardindata, som spred sig till andra verktyg och blev en del av operativsystemet som en specialfil i version 8 . Diagnostik var en del av standardutdata genom version 6 , varefter Dennis M. Ritchie skapade konceptet standardfel.

1995: Java

I Java hänvisas till standardströmmarna av System.in (för stdin), System.out (för stdout) och System.err (för stderr). 

     
     
           
            
           
           
          
        
          
    
 public  static  void  main  (  String  args  []  )  {  try  {  BufferedReader  br  =  new  BufferedReader  (  new  InputStreamReader  (  System  .  in  ));  Sträng  s  =  br  .  readLine  ();  dubbelt  nummer  =  Dubbelt  .  parseDouble  (  s  );  System  .  ut  .  println  (  "Numret är:"  +  nummer  );  }  catch  (  Undantag  e  )  {  System  .  fel  .  println  (  "Fel:"  +  e  .  getMessage  ());  }  }

2000-talet: .NET

I C# och andra .NET -språk refereras standardströmmarna till av System.Console.In (för stdin), System.Console.Out (för stdout) och System.Console.Error (för stderr). Grundläggande läs- och skrivfunktioner för stdin- och stdout-strömmarna är också tillgängliga direkt via klassen System.Console (t.ex. System.Console.WriteLine() kan användas istället för System.Console.Out.WriteLine() ).

System.Console.In , System.Console.Out och System.Console.Error är System.IO.TextReader (stdin) och System.IO.TextWriter (stdout, stderr) objekt, som endast tillåter åtkomst till de underliggande standardströmmarna på en textbas. Full binär åtkomst till standardströmmarna måste utföras genom System.IO.Stream - objekten som returneras av System.Console.OpenStandardInput() , System.Console.OpenStandardOutput() respektive System.Console.OpenStandardError() . 


    

     
           
           
         
         0

    
        
        
       
        
       
        
    

     
 // C# exempel  public  static  int  Main  (  string  []  args  )  {  try  {  string  s  =  System  .  Konsol  .  I  .  ReadLine  ();  dubbelt  tal  =  dubbelt  .  Parse  (  s  );  System  .  Konsol  .  Ut  .  WriteLine  (  "Numret är: {0:F3}",  nummer  )  ;  återvända  ;  // If Parse() kastade ett undantag  }  catch  (  ArgumentNullException  )  {  System  .  Konsol  .  Fel  .  WriteLine  (  "Inget nummer angavs!"  );  }  catch  (  FormatException  )  {  System  .  Konsol  .  Fel  .  WriteLine  (  "Det angivna värdet är inte ett giltigt nummer!" )  ;  }  catch  (  OverflowException  )  {  System  .  Konsol  .  Fel  .  WriteLine  (  "Det angivna numret är för stort!" )  ;  }  retur  -  1  ;  } 



    
    
             
             
         
         0

    
       
        
       
        
       
        
     

     
 ' Visual Basic .NET exempel  Public  Function  Main  ()  Som  heltal  Prova  Dim  s  As  String  =  System  .  Konsol  .  [  In  ]  .  ReadLine  ()  Dim  nummer  As  Double  =  Double  .  Analysera  (  s  )  System  .  Konsol  .  Ut  .  WriteLine  (  "Number är: {0:F3}",  nummer  )  Return  '  If Parse() gav ett undantag  Catch  ex  As  System  .  ArgumentNullException  System  .  Konsol  .  [  Fel  ]  .  WriteLine  (  "Inget nummer angavs!"  )  Catch  ex2  As  System  .  FormatException  System  .  Konsol  .  [  Fel  ]  .  WriteLine (  "  Det angivna värdet är inte ett giltigt nummer!"  )  Catch  ex3  As  System  .  OverflowException  System  .  Konsol  .  [  Fel  ]  .  WriteLine  (  "Det angivna numret är för stort!  "  )  Avsluta  Försök  Återgå  -  1  Slutfunktion

När man tillämpar klassen System.Diagnostics.Process kan man använda instansegenskaperna StandardInput , StandardOutput och StandardError för den klassen för att komma åt processens standardströmmar.

2000 - : Python (2 eller 3)

Följande exempel visar hur man omdirigerar standardinmatningen både till standardutgången och till en textfil.


 


  
  

   
  0
   
      
    
          
    
          
        



   #!/usr/bin/env python  import  sys  # Spara nuvarande stdout så att vi kan återställa sys.stdout  # efter att vi har slutfört vår omdirigering  stdin_fileno  =  sys  .  stdin  stdout_fileno  =  sys  .  stdout  # Omdirigera sys.stdout till filen  sys  .  stdout  =  öppen  (  'myfile.txt'  ,  'w'  )  ctr  =  för  inps  i  stdin_fileno  :  ctrs  =  str  (  ctr  )  # Skriver ut till den omdirigerade stdout ()  sys  .  stdout  .  skriv  (  ctrs  +  ") detta är till den omdirigerade --->"  +  inps  +  '  \n  '  )  # Skriver ut till den faktiska sparade stdout-hanteraren  stdout_fileno  .  skriv  (  ctrs  +  ") detta är till den faktiska --->"  +  inps  +  '  \n  '  )  ctr  =  ctr  +  1  # Stäng filen  sys  .  stdout  .  close  ()  # Återställ sys.stdout till vår gamla sparade filhanterare  sys  .  stdout  =  stdout_fileno

GUI

Grafiska användargränssnitt (GUI) använder sig inte alltid av standardströmmarna; de gör när GUI:er är omslag av underliggande skript och/eller konsolprogram, till exempel Synaptic pakethanteraren GUI, som omsluter apt-kommandon i Debian och/eller Ubuntu. GUI:er skapade med skriptverktyg som Zenity och KDialog av KDE -projektet använder stdin, stdout och stderr, och är baserade på enkla skript snarare än ett komplett GUI programmerat och kompilerat i C/C++ med Qt , GTK eller annan motsvarande proprietär widget ramverk.

Tjänster -menyn , som implementerad på NeXTSTEP och Mac OS X , är också analog med standardströmmar. På dessa operativsystem kan grafiska applikationer tillhandahålla funktionalitet genom en systemomfattande meny som fungerar på det aktuella valet i GUI, oavsett i vilken applikation.

Vissa GUI-program, främst på Unix, skriver fortfarande felsökningsinformation till standardfel. Andra (som många Unix-mediaspelare) kan läsa filer från standardinmatning. Populära Windows-program som öppnar ett separat konsolfönster utöver sina GUI-fönster är emulatorerna pSX och DOSBox .

GTK-server kan använda stdin som kommunikationsgränssnitt med ett tolkat program för att realisera ett GUI.

Common Lisp Interface Manager- paradigmet "presenterar" GUI-element som skickas till en utökad utgångsström.

Se även

Källor

externa länkar

Hämtad från " https://en.wikipedia.org/w/index.php?title=Standard_streams&oldid=1081663161 "