Verder dan opnemen: voorwaardelijke vertakkingen, lussen en variabelen in scripts

Macro’s die handelingen opnemen en afspelen, zijn de eenvoudigste manier om terugkerend werk te automatiseren. Een opgenomen macro heeft echter een fundamentele eigenschap: hij doet iedere keer exact hetzelfde. In de praktijk zijn er veel beslissingen waarbij het gedrag aan de situatie moet worden aangepast, zoals ‘plaats een bestelling als de voorraad nul is’ of ‘geef een waarschuwing als het totaal het budget overschrijdt’. Alleen opnemen kan zulke beslissingen niet verwerken.

Hier komen scripts om de hoek kijken. Daarmee kun je fundamentele programmeerelementen in je automatisering opnemen, zoals voorwaardelijke vertakkingen (‘als… dan…’), lussen (herhalingen) en variabelen (bakjes waarin waarden worden bewaard). Het woord ‘programmeren’ klinkt misschien intimiderend, maar deze elementen geven simpelweg vorm aan alledaagse beslissingen en zijn conceptueel helemaal niet moeilijk. Dit artikel legt op begrijpelijke wijze de drie pijlers van scripts uit als de volgende stap na het opnemen.

Voorwaardelijke vertakkingen (IF/ELSE): beslissingen laten nemen

Een voorwaardelijke vertakking is een mechanisme dat een bepaalde verwerking alleen uitvoert wanneer aan een voorwaarde is voldaan. Het IF-blok voert zijn inhoud alleen uit als de voorwaarde waar is; ELSE behandelt alle andere gevallen. Je kunt er bijvoorbeeld het volgende mee uitdrukken: ‘Als het woord “Fout” op het scherm staat, waarschuw dan de verantwoordelijke persoon. Ga anders direct naar de volgende stap.’

Als voorwaarde kun je een waarde op het scherm, de kleur van een specifieke pixel of een getal in een variabele gebruiken. Mensen doorlopen onbewust de hele reeks ‘naar het scherm kijken, de situatie beoordelen en de volgende actie kiezen’. Voorwaardelijke vertakkingen zijn precies bedoeld om die besluitvorming in de automatisering op te nemen. Nadat je ze eenmaal hebt geschreven, neemt de computer voortaan iedere keer de juiste beslissing voor je.

Lussen (LOOP): handelingen laten herhalen

Een lus is een mechanisme dat dezelfde verwerking meerdere keren herhaalt. Dit lijkt op het instellen van het ‘aantal keren afspelen’ van een macro, maar lussen in scripts zijn veel flexibeler. Naast een vast aantal, zoals ‘10 keer herhalen’, kun je afhankelijk van de situatie herhalen: ‘totdat de lijst geen rijen meer bevat’ of ‘totdat aan een bepaalde voorwaarde is voldaan’.

De echte kracht van lussen wordt zichtbaar bij het verwerken van grote hoeveelheden gegevens. Door de handeling ‘één gegevensitem verwerken’ in een lus te plaatsen, verandert die in ‘alle items in de lijst verwerken’. Of het nu om 100 of 1.000 items gaat, je schrijft de verwerking slechts voor één item; de lus doorloopt de rest automatisch. Een taak die handmatig uren zou kosten, hoef je met een lus maar één keer te schrijven en daarna hoef je alleen te wachten. Dit is het omslagpunt waarop automatisering niet langer minuten, maar uren bespaart.

Variabelen: waarden onthouden

Een variabele is een ‘doos’ waarin tijdens een proces tijdelijk een waarde wordt bewaard. Een teller (de hoeveelste keer), een bestandsnaam, een getal dat van het scherm is uitgelezen of een tussenresultaat van een berekening: als u zulke waarden in variabelen opslaat, kunt u ze in latere stappen opnieuw gebruiken. Een bewerking als ‘lees de waarde van een cel in een variabele en zet deze over naar een ander werkblad als de waarde hoger is dan 10.000’ wordt bijvoorbeeld uitgevoerd door variabelen en voorwaardelijke vertakkingen te combineren.

Wanneer variabelen, voorwaardelijke vertakkingen en lussen samen worden gebruikt, nemen de mogelijkheden van automatisering enorm toe. ‘Gegevens lezen (variabelen), de verwerking aanpassen aan de inhoud (voorwaardelijke vertakkingen) en deze op alle items toepassen (lussen)’: alleen al met deze combinatie kan een aanzienlijk deel van het praktische werk worden uitgevoerd. Hier ligt de toegang tot ‘slimme automatisering’, die met eenvoudig opnemen en afspelen buiten bereik bleef.

Met foutafhandeling naar ‘automatisering die niet stopt’

Als u eenmaal vertrouwd bent met voorwaardelijke vertakkingen, lussen en variabelen, is ‘foutafhandeling’ het volgende dat u moet leren. Wanneer automatisering langdurig wordt ingezet, doen zich onvermijdelijk onverwachte situaties voor. De netwerkverbinding valt even weg, een bestand dat geopend zou moeten worden is niet te vinden of het scherm ziet er anders uit dan normaal. Een script dat hier niet op is voorbereid, stopt dan ter plekke volledig. Als het ’s nachts zonder toezicht wordt uitgevoerd, kan het werk tot de volgende ochtend stilliggen.

Hier komt het foutafhandelingsmechanisme TRY/CATCH van pas. Daarmee kunt u een werkwijze instellen waarbij een fout in het TRY-blok niet het hele proces stillegt, maar overschakelt naar de acties in het CATCH-blok, zoals de fout vastleggen, een melding versturen of alleen het betreffende item overslaan en doorgaan met het volgende. Zo ontstaat robuuste automatisering die alle overige items tot het einde verwerkt, ook als één item mislukt. U leert het script daarmee de voor mensen vanzelfsprekende reactie: ‘Als iets mislukt, leg het dan eerst vast en ga vervolgens verder.’

Veelgebruikte SCR-opdrachten leren kennen

De SCR-scripts van makuroku bevatten opdrachten die in de praktijk vaak worden gebruikt. U hoeft ze niet allemaal tegelijk te leren, maar als u weet wat ermee mogelijk is, ontstaan sneller ideeën als: ‘Dit kan waarschijnlijk ook worden geautomatiseerd.’ Laten we enkele kenmerkende opdrachten bekijken.

• • FIND_IMAGE / WAIT_IMAGE: elementen op het scherm aan de hand van een afbeelding zoeken of erop wachten
• • IF / ELSE / LOOP: voorwaardelijke vertakkingen en herhalingen
• • SET / ADD / SUB: waarden aan variabelen toewijzen en berekeningen uitvoeren
• • READ_FILE / WRITE_FILE: bestanden lezen en schrijven
• • HTTP_GET / POST: communicatie met externe diensten
• • NOTIFY / PROMPT: meldingen weergeven en gebruikersinvoer vragen

Door deze functies te combineren, kunt u geavanceerde automatiseringen realiseren die met een eenvoudige opname volstrekt onbereikbaar zijn, zoals ‘gegevens uit een bestand lezen, de verwerking afhankelijk van voorwaarden aanpassen, het resultaat naar een externe dienst sturen en melden dat het proces is voltooid’. Bovendien heeft elke opdracht een eenvoudige functie, waardoor ze niet moeilijk te leren zijn. Begin gewoon met de opdrachten die u nodig hebt en breid uw gereedschapskist geleidelijk uit.

Voorbeelden van automatisering met scripts

Door voorwaardelijke vertakkingen, lussen, variabelen en foutafhandeling te combineren, wordt automatisering mogelijk die ver buiten het bereik van een eenvoudige opname ligt. Laten we enkele concrete voorbeelden bekijken. Denk bijvoorbeeld aan de taak ‘alle bestanden in een map één voor één openen, de inhoud controleren en alleen de bestanden die aan de voorwaarden voldoen naar een andere map verplaatsen’. Dit kan door met een lus alle bestanden te doorlopen en ze met voorwaarden te selecteren. Sorteerwerk dat handmatig een uur zou kosten, is binnen enkele minuten klaar zodra het script eenmaal is geschreven.

Een ander voorbeeld is bewaking waarbij ‘regelmatig gegevens van een website worden opgehaald, met de vorige waarde worden vergeleken en bij een wijziging een melding wordt gegeven’. Ook dit is iets waar scripts bijzonder geschikt voor zijn. De gegevens worden via HTTP opgehaald, vergeleken met de vorige waarde die in een variabele is opgeslagen, waarna een voorwaarde bij een wijziging een melding activeert. Door dit te combineren met geplande uitvoering ontstaat een bewakingssysteem dat geen enkele verandering mist, zonder dat u iets hoeft te doen.

Dergelijke automatisering lijkt op het eerste gezicht misschien moeilijk, maar elk afzonderlijk element — lussen, voorwaardelijke vertakkingen, variabelen, communicatie en meldingen — is eenvoudig. Het moeilijke is ‘alles tegelijk begrijpen’, niet ‘de elementen één voor één combineren’. Begin bijvoorbeeld alleen met voorwaarden, daarna alleen met lussen, en breid uw kennis geleidelijk uit vanuit de elementen die u nodig hebt. Voor u het weet, kunt u zelf behoorlijk geavanceerde automatiseringen bouwen.

Het is belangrijk om niet meteen naar een perfect script te streven. Maak eerst een minimale versie die werkt, voer die daadwerkelijk uit en verbeter vervolgens stap voor stap wat nog niet goed gaat. makuroku heeft een debuggingfunctie die de regel die op dat moment wordt uitgevoerd in realtime markeert. Zo kunt u tijdens het verbeteren visueel controleren ‘waar u nu bent en wat er gebeurt’. Proberen, corrigeren en opnieuw proberen — die herhaling is de snelste manier om scripts onder de knie te krijgen.

Tips om scripts leesbaar te houden

Een script is niet voorgoed klaar zodra het is geschreven; vaak wordt het later opnieuw bekeken en aangepast. Door tijdens het schrijven al op ‘leesbaarheid’ te letten, maakt u het uzelf in de toekomst veel gemakkelijker. Er zijn hiervoor enkele handige tips. Geef variabelen allereerst betekenisvolle namen. Gebruik in plaats van ‘x’ of ‘a’ namen zoals ‘totaalbedrag’ of ‘doelbestandsnaam’, die duidelijk maken wat ze bevatten. Zo begrijpt u ook later meteen wat de verwerking moet doen.

Voeg vervolgens opmerkingen toe aan elk logisch verwerkingsblok. Zelfs korte notities zoals ‘vanaf hier gegevens ophalen’ of ‘hier het bedrag controleren’ maken de algemene stroom van het script gemakkelijker te volgen. Het is ook nuttig om complexe verwerking over meerdere kleine scripts te verdelen. Een verzameling korte scripts die per taak zijn ingedeeld, is gemakkelijker aan te passen en opnieuw te gebruiken dan één enorm script. Het geheim van scripts die lang meegaan, is ze te schrijven met de vraag: ‘Kan mijn toekomstige zelf dit lezen en begrijpen?’

Scripts debuggen

Bij het schrijven van scripts gebeurt het onvermijdelijk dat iets niet werkt zoals verwacht. Het rustig achterhalen van de oorzaak heet ‘debuggen’. De basis van debuggen is vaststellen ‘tot waar alles correct werkt en vanaf welk punt het gedrag van de verwachting afwijkt’. makuroku heeft een functie die de regel die wordt uitgevoerd in realtime markeert, en een PRINT-uitvoer die tussenwaarden op het scherm toont. Zo kunt u de oorzaak zoeken terwijl u visueel controleert ‘waar u nu bent en wat er gebeurt’.

Voor effectief debuggen deelt u het proces eerst op in kleine onderdelen en controleert u de werking onderdeel voor onderdeel. Als u alles in één keer probeert af te ronden, wordt het lastig om te bepalen waar het probleem optreedt. Schrijf steeds een klein stukje, voer het regelmatig uit en ga pas verder nadat u hebt bevestigd dat het correct werkt. Deze gestage herhaling leidt uiteindelijk tot de snelste en betrouwbaarste manier om scripts te maken. Zelfs wanneer er een fout optreedt, hoeft debuggen niet eng te zijn als u die fout ziet als een aanwijzing voor ‘wat u moet corrigeren’.

Aanbevolen volgorde om scripts te leren

Hier volgt een richtlijn voor de volgorde waarin u de verschillende scriptelementen kunt leren. Begin uiteraard met voorwaardelijke vertakkingen (IF/ELSE). Beslissingen in de vorm ‘als …, dan …’ vormen de basis van elke automatisering. Daarna komen lussen (LOOP). Herhaalde verwerking is bijzonder doeltreffend bij grote hoeveelheden gegevens. Zodra u deze twee onderdelen beheerst, kunt u al veel taken automatiseren die met alleen een opname niet mogelijk waren.

Daarna zijn de variabelen aan de beurt. Een mechanisme om waarden te bewaren maakt in combinatie met voorwaarden en lussen flexibelere verwerking mogelijk. Als u dit beheerst, kunt u foutafhandeling (TRY/CATCH) leren. Voor langdurige uitvoering zonder toezicht is een mechanisme onmisbaar dat niet stopt wanneer er onderweg iets mislukt. Tot slot hoeft u gespecialiseerde opdrachten voor bijvoorbeeld bestandsbewerkingen, HTTP-communicatie en OCR pas te leren wanneer u ze voor uw doel nodig hebt.

Het is belangrijk dat u niet alles in één keer probeert te leren. Wanneer u tijdens uw werk denkt: ‘Het zou handig zijn als dit kon’, zoekt u de bijbehorende functie op en probeert u die te gebruiken. Deze manier van ‘leren omdat het nodig is’ zorgt er uiteindelijk voor dat de kennis het beste blijft hangen. In plaats van een leerboek vanaf het begin door te nemen, ontwikkelt u meer praktische vaardigheden door uw huidige werkzaamheden te automatiseren en gaandeweg de benodigde onderdelen te leren.

Scripts kunnen op het eerste gezicht moeilijk lijken, maar elk afzonderlijk onderdeel is eenvoudig en u kunt ze zeker onder de knie krijgen door ze stap voor stap te leren. Zodra dat lukt, wordt het aantal taken dat u kunt automatiseren enorm veel groter. Begin met een opname en zet uw eerste stap in de wereld van scripts door daar één voorwaardelijke vertakking aan toe te voegen.

Moeiteloos overstappen van opnames naar scripts

Juist wie denkt dat scripts moeilijk zijn, moet weten dat het niet nodig is om met een leeg document te beginnen. In makuroku kunt u eerst handelingen via de GUI opnemen en de macro daarna omzetten in een bewerkbaar SCR-script. U beschikt dus vanaf het begin over een werkend raamwerk. Vervolgens hoeft u alleen de benodigde onderdelen aan te passen, bijvoorbeeld door een te herhalen gedeelte in een LOOP te plaatsen of IF toe te voegen waar een beslissing nodig is.

Bovendien wordt de syntaxis tijdens het typen gecontroleerd, zodat schrijffouten onmiddellijk worden gemeld. Er is ook een debuggingfunctie die de regel die wordt uitgevoerd in realtime markeert, zodat u direct kunt zien ‘waar het proces nu mee bezig is’. Dankzij deze ondersteuning verloopt de overgang van opnames naar scripts heel geleidelijk. Maak eerst via een opname het raamwerk en voeg daarna stap voor stap voorwaarden en lussen toe. Met deze aanpak kunnen zelfs mensen zonder programmeerervaring zelf praktische automatiseringen maken. Met makuroku kunt u al deze functies gratis uitproberen.