Lees (procedure)

Leest voor getypte bestanden de bestandscomponent in een variabele.
- Leest voor tekstbestanden een of meer waarden
in een of meer variabelen

Aankondiging

getypte bestanden

Procedure lezen (F, V1 [, V2, ..., Vn]);

Tekstbestanden

Procedure Lezen ([Var F: Tekst;] V1 [, V2, ..., Vn]);

Modus

Windows, echt, beveiligd

Opmerkingen

Voor stringvariabelen:

Lezen leest alle tekens tot (maar niet inclusief) de volgende einde-lijnmarkering of tot Eof(F) wordt True. Lezen gaat niet naar de volgende regel na het lezen. Als de resulterende string langer is dan de maximale lengte van de stringvariabele, wordt deze afgekapt. Na de eerste Read, wordt bij elke volgende Read-aanroep de end-of-line-markering weergegeven en wordt een tekenreeks met lengte nul geretourneerd.

Gebruik meerdere aanroepen van ReadLn om meerdere tekenreekswaarden te lezen.

Wanneer de optie is ingeschakeld Uitgebreide syntaxis, de Lees procedure kan lezen null-terminated strings naar op null gebaseerde tekenreeksen.

Voor variabelen zoals Geheel getal of Echt:

Lezen slaat spaties, tabs of einde-lijnmarkeringen over die voorafgaan aan een numerieke regel. Als de numerieke tekenreeks niet overeenkomt met het verwachte formaat, treedt een I / O-fout op, anders krijgt de variabele de resulterende waarde. De volgende Read begint met een spatie, tab of einde-lijnmarkering die de numerieke reeks beëindigde.

zie ook

Voorbeeld

gebruikt Crt, Dos;

var
F: Tekst;
Ch: Char;

beginnen
(Haal de bestandsnaam van de opdrachtregel)
Toewijzen (F, ParamStr (1));
Resetten (F);
terwijl niet EOF (F) doen
beginnen
Lezen (F, Ch);
Schrijf (Ch); (We tonen de inhoud van het bestand op het scherm)
einde;
einde.

Net als bij de uitvoerinstructies, zijn de lees- en readln-instructies ingebouwde oproepinstructies. procedures voor het invoeren van informatie.

Operators read (read) en readln, die afkomstig zijn van de twee Engelse woorden read en line (string) worden in programma's gebruikt om informatie in het computergeheugen in te voeren en " uitlezingen"waarden naar een variabele.

Laten we eens kijken naar het werk van deze operators en procedures voor het invoeren van informatie.

Ons programma heeft een readln (a) routine. Tijdens het uitvoeren van het programma, bij het tegenkomen van de readln-instructie, zal de computer pauzeren in afwachting van het invoeren van informatie. Nadat we de waarde van de variabele a - 16 met het toetsenbord hebben ingevoerd, wijst de computer deze waarde toe aan de variabele a, d.w.z. zal het naar geheugenlocatie a sturen en de uitvoering van het programma voortzetten. Dit proces noemen we " door te lezen"waarden naar een variabele.

Dus de lees- en leesprocedures "lezen" de waarden van de variabelen en wijzen ze toe aan de variabelen die erin zijn geschreven.

Er kunnen meerdere van dergelijke variabelen zijn, dan worden ze in deze operatoren geschreven, gescheiden door komma's, bijvoorbeeld:

lezen (a, b, c, n, g, j, i), readln (e, f, k, p, d), enz.

Wat is het verschil tussen read- en readln-procedures?

De leesprocedure vereist op zichzelf de invoer of uitvoer van informatie in één regel, en de leesprocedure maakt het op zichzelf mogelijk om informatie vanaf het begin van een nieuwe regel in en uit te voeren.

Bijvoorbeeld:

In het programma: schrijf ("Voer de waarden van a en b in"); lees (a, b);

schrijven ("Informatie op één regel invoeren");

Wanneer dit deel van het programma wordt uitgevoerd, wordt alles wat in de eerste schrijfopdracht is geschreven op het scherm weergegeven, vervolgens staat de cursor op dezelfde regel en wacht de computer tot de waarden van a en b zijn worden ingevoerd. Laten we hun waarden invoeren - 2 en 3, en ze scheiden met een spatie of, met andere woorden, door een spatie. Daarna wordt de informatie die in de volgende schrijfopdracht is geschreven, op dezelfde regel weergegeven.

Op het scherm:

Voer waarden in voor a en b 2 3 Voer informatie op één regel in

In een programma:

writeln ("Voer de waarden a, b en c in); readln (a, b, c);

writeln ("Invoer en uitvoer van informatie vanaf het begin van de regel");

Op het scherm:

Voer de waarden a, b en c . in

Invoer en uitvoer van informatie vanaf het begin van een regel

Rekenkundige bewerkingen met gehele getallen. Integer variabelen. Echte type

In de Pascal-taal worden gehele getallen gebruikt, waaronder alle natuurlijke getallen die worden gevormd tijdens het tellen van objecten: 1, 2, 3, 4, 5, 6, ...; negatieve getallen: ..., -6, -5, -4, -3, -2, -1 en het getal nul: 0. Gehele getallen vormen de volgende reeks:

6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, ...

Pascal accepteert een reeks gehele getallen van -32768 tot 32767.

Variabelen die integer-waarden aannemen, worden in de beschrijvingssectie geschreven met het opgegeven integer-type.

Bijvoorbeeld: var a, b, c, a1, b34, nomb: integer;

Waarden van een ander type dan deze variabelen in één programma kan niet worden toegewezen.

Rekenkundige bewerkingen met gehele getallen en gehele variabelen in Pascal

Het "_" teken betekent een spatie. Spaties tussen variabelenamen en de bewerkingsnaam (div) zijn vereist. (Komt uit de Engelse divisie - divisie).

Rest van a gedeeld door b. a_mod_b

Thema: Invoer uitvoer. Lees (Readln), Schrijf (Writeln) verklaringen. De eenvoudigste lineaire programma's.

Laten we het probleem oplossen door elk van onze acties tussen accolades te plaatsen. Bedenk dat de opmerking niet wordt waargenomen door de computer, maar we hebben deze nodig om beter te begrijpen hoe het programma werkt.

Taak ... Schrijf een programma dat het scherm leegmaakt en het product berekent van twee door de gebruiker opgegeven getallen.

Om de actie van een programma beter te begrijpen, typt u het op uw computer en test u de actie. Beantwoord de vragen:

• waarom heette het programma Proizv2?
• Waarom heb je de Crt-module in de sectie Uses geplaatst?
• wat is het doel van de variabelen number1, number2, rezult?
• van welk type zijn deze variabelen? wat betekent het?
• Als we de variabelen number1 en number2 toekennen aan respectievelijk de waarden 5 en 7, welke regel zal de computer dan produceren bij het uitvoeren van de laatste Write-procedure? Schrijf het op in je notitieboekje.
• in welke regels wordt de gebruiker om de waarden van de variabelen gevraagd?
• in welke regel komt de vermenigvuldiging van getallen voor?
• wat doet de toewijzingsoperator in dit programma?

Oefening ... Wijzig het programma zodat het de gebruiker om een ​​andere variabele vraagt ​​en het product van drie getallen uitvoert.

Verklaringen schrijven en schrijven

We hebben de Write- en WriteLn-operatoren al gebruikt, maar we moeten dieper ingaan op de regels voor het gebruik van deze operatoren.

Schrijven is een operator die wordt gebruikt om informatie op het scherm weer te geven. De WriteLn-operator voert dezelfde actie uit, maar aangezien deze ook het einde Ln (regel) heeft, verplaatst hij, nadat hij het gewenste bericht op het scherm heeft weergegeven, de cursor bovendien naar de volgende regel.

Algemene vorm:
Schrijven (lijst met uitdrukkingen)
WriteLn (lijst met uitdrukkingen)

De Write- en WriteLn-procedures worden niet alleen gebruikt om het resultaat weer te geven, maar ook om verschillende berichten of verzoeken weer te geven. Hiermee kunt u een dialoog voeren met de gebruiker, hem vertellen wanneer hij waarden moet invoeren, wanneer hij een resultaat krijgt, wanneer hij een fout heeft gemaakt, enz.

Als u bijvoorbeeld de WriteLn-procedure uitvoert ('Gevonden nummer', a), wordt een regel tussen apostrofs afgedrukt en wordt de waarde van de variabele a weergegeven.

Het WriteLn-statement kan zonder parameters worden gebruikt. In dit geval wordt een regel met spaties afgedrukt en wordt de cursor naar een andere regel verplaatst. Soms hebben we het nodig voor een betere perceptie van data-invoer.

Lees en ReadLn-operators

Laten we niet vergeten dat het belangrijkste doel van een computer is om menselijke arbeid te besparen. Daarom is het noodzakelijk om een ​​mogelijkheid te bieden, nadat je een programma hebt geschreven, het opnieuw kunt gebruiken, elke keer dat je verschillende gegevens invoert. Deze flexibiliteit in de taal wordt geboden door de Read- en ReadLn-statements. Deze operators voeren informatie in via het toetsenbord.

Algemene vorm:
Lezen (variabel, variabel ...)
ReadLn (variabel, variabel ...)

De procedure Lezen verwacht dat de tussen haakjes vermelde waarden worden ingevoerd. De ingevoerde gegevens dienen door spaties van elkaar te worden gescheiden. De toewijzing van waarden vindt beurtelings plaats.

Als bijvoorbeeld de waarden 53 en X worden ingevoerd, wordt bij het uitvoeren van de instructie Read (a, b) het nummer 53 toegewezen aan de variabele a en de letter X aan de variabele X. Bovendien wordt in om een ​​noodsituatie te voorkomen, moet u het gegevenstype correct bepalen in de sectie Var; in ons geval a: geheel getal en b: char.

Er zijn geen speciale verschillen in lezen en schrijven in het gebruik van de Read- en ReadLn-operatoren. Vaak wordt de ReadLn-procedure zonder parameters gebruikt aan het einde van het programma om te vertragen: voordat op een toets wordt gedrukt het resultaat van de uitvoering van het programma blijft op het scherm. Dit is erg handig voor het analyseren van de resultaten.

Opmerking ... Let bij het instellen van de schermvertraging op de vorige invoer. Als de gegevens zijn opgevraagd via de Read-procedure, is er geen vertraging.

Laten we een probleem oplossen waarin we alle mogelijke toepassingen van deze procedures zullen overwegen.

Taak ... Zoek het gemiddelde van drie getallen.

Opmerking ... Om het gemiddelde van meerdere getallen te vinden, tel je deze getallen bij elkaar op en deel je de som door het aantal van deze getallen.

Typ de tekst van de opgave en overweeg zorgvuldig elke regel. De naam van het Srednee-programma weerspiegelt de inhoud van de taak. Laten we het er trouwens over eens zijn dat de naam van het programma en de naam van het bestand dat dit programma bevat hetzelfde zijn. Vervolgens komt de aansluiting van de Crt-module. In de Var-sectie worden Eerste, Tweede en Derde beschreven als variabelen van een geheel getal en Sum is van het reële type. Het bedieningsgedeelte begint met de standaard ClrScr-schermroutine (Clear Screen) die u in de Crt-module vindt. Vervolgens tonen we bij de Write-opdracht de melding 'Voer het eerste nummer in', waarna de gebruiker het nummer moet invoeren.

Nu moet de computer de ingevoerde tekens lezen en in de First-variabele plaatsen, dit zal gebeuren wanneer het volgende ReadLn (First)-statement wordt uitgevoerd. Vervolgens vragen we met behulp van de Write-instructie de waarden van nog twee getallen op en lezen deze in de tweede en derde variabelen. Vervolgens berekenen we hun som en wijzen het resulterende getal toe aan de variabele Sum. Om het gemiddelde te vinden, moet je het resulterende getal nu delen door 3 en het resultaat opslaan in een variabele.

Het is helemaal niet nodig om een ​​andere variabele te declareren om het resultaat op te slaan. Je kunt, net als in ons programma, de waarde van de Sum-variabele delen door 3 en het resultaat opnieuw toewijzen aan dezelfde Sum-variabele. Nu kunt u het resultaat van berekeningen op het scherm weergeven met behulp van de schrijfprocedure. Ten slotte zal de laatste ReadLn-routine onze uitvoer naar het scherm vertragen totdat een toets wordt ingedrukt.

Druk op de toetsen +... Vul de waarden van variabelen 5, 7 en 12 in, je ziet het volgende op het scherm:

Het gemiddelde van 5, 7 en 12 is 8,00

Kijk goed naar deze regel en vergelijk deze met de regel voor het uitvoeren van het resultaat in ons programma. Test het programma nog een paar keer voor verschillende variabele waarden.

Kies samen met de docent de op te lossen problemen uit de volgende lijst:

1. Voer twee cijfers a en b in. Gebruik de toewijzingsoperator om hun waarden uit te wisselen:
   a) een tussenvariabele gebruiken (x: = a; a: = b; b: = x);
   b) zonder een tussenvariabele te gebruiken (a: = a-b; b: = a + b; a: = b-a).
2. Schrijf een programma dat de gebruiker om een ​​geheel getal, een reëel getal, een willekeurig teken en een tekenreeks vraagt, en druk vervolgens alles op één regel af.
3. Geef uw achternaam, voornaam en patroniem weer, en twee regels later - uw geboortedatum.
4. Schrijf een programma om een ​​van de vormen met sterretjes af te drukken:
   a) Kerstbomen (meerdere kerstbomen);
   b) sneeuwvlokken (meerdere sneeuwvlokken);
   c) een huis, bijvoorbeeld

   *
   * *
   * *
   ***********
   * *
   * *
   * *
   * *
   ***********

5. Stel uw visitekaartje samen.

   
   * Ivanov Sergej *
   * Proletarskaja 74 vierkante meter. 55 *
   * Telefoon 45-72-88 *
   *******************************

6. Stel een dialoog op tussen de gebruiker en de computer over een willekeurig onderwerp.
   Een machine stelt bijvoorbeeld twee vragen: "Wat is uw naam?" hoe oud ben je?"; na het invoeren van de naam (Anton) en het nummer (15) verschijnt op het scherm "Ja ... Over 50 jaar word je 65 jaar en je naam zal niet Anton zijn, maar opa Anton"
7. Vraag de gebruiker om twee getallen en geef het resultaat van de som, het verschil, het product en het quotiënt van deze getallen weer met een volledig antwoord.
8. Vraag de gebruiker om twee getallen en geef het resultaat van een gehele deling en de rest van een gehele deling weer in de vorm van een tabel. Als u bijvoorbeeld de nummers 5 en 3 invoert, moet het scherm de volgende tabel weergeven:

   **************************
   * X * Y * div * mod *
   **************************
   * 5 * 3 * 1 * 2 *
   **************************

9. Schrijf een programma dat om de naam van een dier en een nummer vraagt, en dan een zin weergeeft als "Een eekhoorn eet 10 paddenstoelen" (als je het woord "eekhoorn" en het cijfer 10 invoert).
10. Organiseer een dialoog tussen de verkoper (computer) en de koper (gebruiker) bij de aankoop van een product volgens het volgende schema: het product aanbieden tegen een bepaalde prijs, het bedrag van het gekochte product opvragen, het bedrag bepalen en weergeven dat de koper moet betalen voor de aankoop.

De leesinstructie is bedoeld voor het invoeren van de waarden van variabelen (initiële data) vanaf het toetsenbord. In het algemeen ziet de instructie er als volgt uit:

lezen (variabele !, variabele2, ... variabele

Hier zijn voorbeelden van het schrijven van een leesverklaring:

Lees een); lezen (Cena, Kol);

Wanneer de read-instructie wordt uitgevoerd, gebeurt het volgende:

1. Het programma pauzeert zijn werk en wacht tot de vereiste gegevens op het toetsenbord zijn getypt en de toets wordt ingedrukt .

2. Na het indrukken van de toets de ingevoerde waarde wordt toegewezen aan de variabele die in de verklaring wordt genoemd.

Bijvoorbeeld, als resultaat van het uitvoeren van de instructie

Lezen (Tempérât);

en typ regel 21, de waarde van Tempérât is 21.

Met één leesopdracht kunt u de waarden van verschillende variabelen ophalen. In dit geval moeten de ingevoerde cijfers op één regel worden getypt en gescheiden door spaties. Als het type variabelen a, b en c bijvoorbeeld reëel is, dan als resultaat van het uitvoeren van de read (a, b, c); en toetsenbordinvoerreeks:

4.5 23 0.17

de variabelen hebben de volgende waarden: a = 4,5; b = 23, o; c = 0,17.

Als de regel meer getallen bevat dan de variabelen die zijn opgegeven in de leesopdracht, wordt de rest van de regel verwerkt door de volgende leesopdracht. Bijvoorbeeld als gevolg van het uitvoeren van de instructies:

Lees (a, B); lees (C);

en toetsenbordinvoerreeks

10 25 18

variabelen krijgen de volgende waarden: a = 10, b = 25. Lees instructie (C); toewijzen aan de variabele met de waarde 18.

De readln-instructie verschilt van de readln-instructie doordat na het selecteren van het volgende nummer van de regel die is ingevoerd met het toetsenbord en het toewijzen aan de laatste variabele uit de lijst van de readln-instructie, de rest van de regel verloren gaat en de volgende lees- of readln instructie vereist nieuwe invoer.

Bijvoorbeeld als resultaat van het uitvoeren van de instructie:

Leesln (a, B); lees (C);

en het typen van de string

10 25 18

de variabelen krijgen de volgende waarden: a = 10, b = 25. Daarna wacht het programma op het invoeren van een nieuw nummer om het aan de variabele c toe te kennen.

Elke lees- of leesinstructie moet worden voorafgegaan door een schrijfinstructie om de gebruiker te vertellen welke gegevens het programma van hem verwacht. Een fragment van het programma voor het berekenen van de kosten van een aankoop kan er bijvoorbeeld als volgt uitzien:

Writeln ("Voer de originele gegevens in."); schrijven ("Productprijs:"); lees (Sepa); schrijven ("Hoeveelheid in de batch:"); lees (Kol); schrijven ("Korting:"); lezen (Skidka);

Als het type gegevens dat met het toetsenbord is ingevoerd niet overeenkomt of niet kan worden geconverteerd naar het type variabelen waarvan de namen zijn opgegeven in de read (readln)-instructie, crasht het programma (instructies die volgen op lezen worden niet uitgevoerd) en er wordt een bericht weergegeven op het scherm over fouten.

De programmeertaal Pascal gebruikt instructies zoals read en readLn. Wat zijn ze?

Wat is een gelezen verklaring?

Deze instructie is bedoeld om invoer vanaf het pc-toetsenbord te geven van verschillende waarden van variabelen met behulp van de Pascal-taal. Het schema van het gebruik van de overwogen instructie ziet er eenvoudig uit: zoals lezen ("variabele waarde").

In de praktijk wordt de leesinstructie gebruikt om ervoor te zorgen dat bepaalde gegevens uit een bestand worden gelezen en vervolgens worden de waarden die uit de bijbehorende gegevens worden opgehaald, toegewezen aan de variabelen die worden opgegeven bij het aanroepen van de procedure.

Als de gebruiker een fout maakt bij het invoeren van gegevens, deze komen niet overeen met het type variabelen dat in de instructie wordt weerspiegeld, stopt het programma met het uitvoeren van de opdrachten. In dit geval verschijnt er een bericht op het pc-scherm dat er een fout is opgetreden in de toepassing.

Als de programmeur meerdere leesinstructies gebruikt, worden de gegevens op de een of andere manier op één regel ingevoerd. De volgende sprong is alleen mogelijk als de huidige regel eindigt. U kunt echter informatie die op een andere regel is geplaatst, lezen met behulp van de readLn-instructie. Laten we de kenmerken ervan in meer detail bekijken.

Wat is de readLn instructie?

De essentie van de readLn instructie is om in het programma een voorwaarde te stellen waaronder:

• elk nummer dat in de tekenreeks wordt ingevoerd, wordt door de instructie aan de laatste variabele toegewezen;
• de rest van de regel wordt niet verwerkt door het programma, terwijl de volgende instructie nieuwe invoer vereist.

U kunt dus de instructie invoeren:

leesLn (C, D); lees (E);

En als u daarna een rij 1 2 3 vanaf het toetsenbord invoert, dan krijgt de variabele C de waarde 1, D - 2. Maar het programma zal pas een bepaalde waarde aan de variabele E toewijzen als de gebruiker een nieuw nummer invoert.

Net als in het geval van de leesinstructie, wordt het programma afgesloten als de gebruiker het gegevenstype onjuist invoert met de opdracht readLn, en wordt er een foutmelding weergegeven.

Vergelijking

Het belangrijkste verschil tussen readLn en read is dat de eerste procedure het programma inhoudt om naar de bestandsregel te springen die volgt op die waarin de instructies zijn geschreven. Met de tweede procedure kan het programma de gegevens op de volgende regel lezen, alleen met toestemming van de gebruiker - als hij op Enter drukt.

In de praktijk wordt de readLn-instructie meestal gebruikt om een ​​vertraging te bieden tussen het resultaat van de uitvoering van de toepassing en de overgang naar de volgende instructie. De bijbehorende vertraging duurt totdat de gebruiker op Enter drukt.

Nadat we hebben vastgesteld wat het verschil is tussen readLn en lezen in Pascal-taal, laten we de conclusies in de tabel vastleggen.