Automatisering og scripting med Python og JavaScript: praktiske eksempler til hverdagen

Automatisering og scripting i praksis

Automatisering betyder, at en gentagen opgave bliver udført automatisk af kode, så du sparer manuelt arbejde og får færre fejl. Scripting er den lille, fokuserede kode, der udfører opgaven, ofte i få linjer. I praksis kan det være alt fra at sortere filer til at samle tal fra et regneark og sende en mail med en rapport.

Hvis vi tager en helt konkret situation: Du downloader bilag, billeder og dokumenter hver dag, og din Downloads-mappe bliver hurtigt kaos. Manuel proces er, at du klikker rundt og flytter filer én for én. Et script kan kigge på filtyperne og flytte dem til de rigtige mapper. Automatisering er, når det script kører automatisk hver aften uden dig.

Det er nyttigt at tænke i et lille “modenheds-flow” for dine opgaver:

• Manuel proces: Du klikker, kopierer, indsætter, sorterer.
• Script: Du skriver et lille program, som gør det samme på kommando.
• Planlagt kørsel: Scriptet kører automatisk på faste tidspunkter.
• Overvågning: Du har logging og fejlmeldinger, så du opdager, når noget går galt.

De næste afsnit handler om at tage dine egne opgaver gennem de samme trin: finde egnede kandidater, vælge Python eller JavaScript, skrive et simpelt script og få det til at køre stabilt.

Hvad kan du automatisere med Python og JavaScript?

Du kan automatisere alt fra filsortering og påmindelser til API-udtræk, rapporter og browseropgaver. Python er ofte bedst til filer og data, mens JavaScript er stærkt til web og browserautomatisering. Det rigtige valg afhænger af, hvor opgaven starter, og hvilket system den skal køre i.

Her er typiske hverdagsopgaver, som er realistiske at angribe med små scripts:

• Filorganisering: Flytte billeder, PDF’er og dokumenter til mapper baseret på filtype, dato eller navn.
• Gentagne rapporter: Læse tal fra CSV eller Excel, lave en lille opsummering og gemme en ny fil eller sende en mail.
• Påmindelser og deadlines: Gennemgå en liste over opgaver eller regninger og sende en mail eller besked, når en dato nærmer sig.
• Morgenopdateringer: Hente vejr, nyheder eller data fra interne systemer via API og samle det i en kort status.
• E-mail automation: Udsende standardiserede beskeder, når en fil ændrer sig, når en mappe får nye filer, eller når en rapport er klar.
• Browser-checks: Åbne en side, logge ind, klikke sig hen til en bestemt visning og fx tage et screenshot.
• Web-API-opgaver: Hente data fra REST API’er (fx WeatherAPI, NewsAPI) og gemme dem lokalt eller i et regneark.
• SEO og overvågning: Måle fx load-tider, tjekke URL’er for fejl eller hente statistik fra en service.

For at gøre valget mere konkret kan du bruge denne mini-oversigt som pejlemærke:

Udgangspunktet er: ligger opgaven tæt på filer og data på din maskine eller server, så er Python ofte nemmest. Er den tæt på browseren og websider, så er JavaScript eller et no-code-værktøj typisk mere naturligt.

Python, JavaScript eller no-code: hvad skal du vælge?

Vælg typisk Python, hvis opgaven handler om filer, data, CSV, Excel eller servernære scripts. Vælg JavaScript, hvis automationen foregår i browseren eller tæt på web-API’er. Vælg no-code, hvis opgaven er standardiseret og skal sættes hurtigt op uden kode.

Det vigtigste er ikke sprogets “ry”, men hvor din opgave lever:

• Python er stærkt til at læse og skrive filer, arbejde med CSV/Excel, snakke med API’er og lave små rapporter. Syntaksen er relativt begyndervenlig, og du kan køre scripts direkte på din maskine eller en server.
• JavaScript (ofte via Node.js) trives i web-verdenen. Det er oplagt, når du skal snakke med web-API’er, automatisere browseren, lave små webværktøjer eller bygge et API, dine workflows kan kalde.
• No-code som Power Automate, Zapier, Make eller n8n er godt, når du mest vil forbinde to systemer og reagere på simple events: “når der kommer en mail”, “når en fil ligger i den her mappe”, “når en række oprettes i et ark”.

Her er en mere systematisk sammenligning:

Hvis du ender med JavaScript og fx vil bygge et lille API til din automation, kan du se på at lave et simpelt Express-API, som vist i denne guide om et lille Express API. Hvis du er på Python-siden og din scriptsamling vokser, er det værd at overveje at gå fra løse scripts til en lille app, som beskrevet i guiden om springet fra rodet Python-script til lille app.

Konkrete Python-eksempler til hverdagens opgaver

Python er særligt god til hverdagsautomatisering, når opgaven handler om filer, regneark, CSV, e-mail eller data fra API’er. Med få biblioteker kan du bygge små scripts, der sorterer, henter, sammenfatter og sender information videre automatisk.

1. Sorter din Downloads-mappe efter filtype

Problem: Downloads bliver et rod af billeder, PDF’er og ZIP-filer.

Idé: Et Python-script, der går mappen igennem og flytter filer til undermapper efter filtype.

Før: 500 filer i én mappe. Efter: billeder i Images/, dokumenter i Docs/, ZIP i Archives/.

Forenklet kodeidé:

import os
import shutil

DOWNLOADS = r"C:UsersdigDownloads"  # tilpas stien
MAP = {
    ".jpg": "Images",
    ".png": "Images",
    ".pdf": "Docs",
    ".docx": "Docs",
    ".zip": "Archives",
}

for filnavn in os.listdir(DOWNLOADS):
    sti = os.path.join(DOWNLOADS, filnavn)
    if not os.path.isfile(sti):
        continue
    ext = os.path.splitext(filnavn)[1].lower()
    if ext in MAP:
        target_dir = os.path.join(DOWNLOADS, MAP[ext])
        os.makedirs(target_dir, exist_ok=True)
        shutil.move(sti, os.path.join(target_dir, filnavn))

Fejlpunkter: Scriptet kan flytte filer, du egentlig ville have liggende. Start altid med en testmappe eller en kopi. Overvej at lave en “dry-run”, hvor scriptet kun printer, hvad det ville gøre.

2. Påmindelse om deadlines fra CSV

Problem: Du har en liste over opgaver eller regninger med deadlines, som du glemmer.

Idé: Læg dem i en CSV med kolonnerne navn, deadline og email, og lad et Python-script sende en mail, når noget er tæt på.

Eksempel på CSV (deadlines.csv):

navn,deadline,email
Elregning,2026-09-10,dig@example.com
Rapport til chef,2026-09-08,dig@example.com

Forenklet kodeidé (uden faktisk mail-opsætning):

import csv
from datetime import datetime, timedelta

NU = datetime.now().date()
VARSEL = 3  # dage før deadline

with open("deadlines.csv", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        deadline = datetime.fromisoformat(row["deadline"]).date()
        if 0 <= (deadline - NU).days <= VARSEL:
            print(f"Send påmindelse om: {row['navn']} til {row['email']}")

Når du vil sende rigtige mails, kan du bruge smtplib eller koble til Outlook eller Gmail. Husk her at være opmærksom på spam-regler og ikke skyde mails afsted til andre uden samtykke.

3. Morgenrapport med vejrdata via API

Problem: Du tjekker alligevel vejr og evt. andre tal hver morgen.

Idé: Et script, der kalder et vejr-API (fx WeatherAPI), formaterer et kort tekstresumé og evt. gemmer det i en fil eller sender det som mail.

import os
import requests

API_KEY = os.getenv("WEATHER_API_KEY")
CITY = "Aalborg"

resp = requests.get(
    "https://api.weatherapi.com/v1/current.json",
    params={"key": API_KEY, "q": CITY, "lang": "da"},
    timeout=10,
)
resp.raise_for_status()
data = resp.json()

tekst = (
    f"Vejr i {CITY}: {data['current']['temp_c']}°C, "
    f"{data['current']['condition']['text']}"
)
print(tekst)

Bemærk: API-nøglen hentes fra en miljøvariabel, WEATHER_API_KEY, i stedet for at stå i koden. Hvis du ikke er vant til miljøvariabler, er der en god gennemgang i guiden om miljøvariabler og faldgruber.

4. Lille rapport fra CSV

Problem: Du får jævnligt en CSV-fil med salgstal, timeforbrug eller lignende, og skal hver gang udregne de samme summer.

Idé: Et script, der læser CSV’en, laver simple summer og gemmer en ny fil med få nøgletal.

import csv

TOTAL = 0

with open("salg.csv", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        TOTAL += float(row["belob"])

with open("salg_rapport.txt", "w", encoding="utf-8") as f:
    f.write(f"Samlet beløb: {TOTAL:.2f} kr")

Det er bevidst simpelt. Pointen er at vise, at du ikke behøver et stort BI-værktøj for at automatisere små, faste opgaver.

JavaScript-eksempler til browser- og webautomation

JavaScript er ofte bedst til automatisering, når opgaven foregår i browseren eller på en webside, især med Node.js, Puppeteer eller Playwright. Det gør sproget oplagt til web-API’er, navigation, test og automatiske browserhandlinger.

1. Hente data fra et web-API med fetch (browser)

Problem: Du vil hurtigt tjekke et simpelt API direkte i browseren eller bygge et lille dashboard.

Idé: Brug fetch til at hente JSON-data og vise et kort resultat.

<script>
async function hentVejr() {
  const resp = await fetch(
    "https://api.example.com/weather?city=Aalborg"
  );
  if (!resp.ok) {
    console.error("API-fejl", resp.status);
    return;
  }
  const data = await resp.json();
  console.log("Temperatur:", data.temp_c);
}

hentVejr();
</script>

Det her er mere et “ad hoc”-værktøj end fuld automation, men det er ofte sådan mange starter.

2. Automatiserede browserchecks med Node.js og Puppeteer

Problem: Du skal dagligt eller ugentligt tjekke, at en bestemt side loader korrekt, eller at et login stadig virker.

Idé: Et Node-script, der åbner Chromium i baggrunden, går til en URL, venter på et element og gemmer et screenshot.

// kræver: npm install puppeteer
const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto("https://din-side.dk/login", { waitUntil: "networkidle2" });

  // evt. udfyld loginformular her

  await page.waitForSelector(".dashboard-title", { timeout: 10000 });
  await page.screenshot({ path: "dashboard.png" });

  await browser.close();
})();

Det script kan du senere sætte til at køre planlagt, så du får et nyt screenshot hver morgen. Hvis du bevæger dig mere over i denne verden, er det værd at blive fortrolig med baggrundsjob og køer, som gennemgået i artiklen om baggrundsjob uden drama.

3. Lille webservice som automation-endpoint

Problem: Du vil kunne trigge en automation ude fra, fx fra et no-code-værktøj eller et andet system.

Idé: Lav et lille Node/Express-API med en POST-route som webhook-endpoint. No-code-flowet sender data hertil, og din kode gør resten.

const express = require("express");
const app = express();
app.use(express.json());

app.post("/webhook", (req, res) => {
  console.log("Data modtaget", req.body);
  // TODO: gør noget nyttigt her
  res.status(200).send("OK");
});

app.listen(3000, () => {
  console.log("Lytter på port 3000");
});

Hvis du vil bygge webhook-endpoints, der faktisk tåler genkørsler og fejl, er der en god gennemgang i artiklen om robuste webhook-endpoints og i guiden om at verificere webhook-signaturer.

Sådan får du scripts til at køre automatisk og stabilt

Et script bliver først rigtig nyttigt, når det kører automatisk på et fast tidspunkt og kan tåle fejl. Til det bruger man typisk cron på Linux/macOS, Windows Task Scheduler på Windows eller en workflow-platform som GitHub Actions til enklere job.

Grundideen er altid den samme:

1. Du har en kommandolinje, der kan køre dit script (fx python rapport.py).
2. Du fortæller et planlægningsværktøj, hvornår den kommando skal køres.
3. Du sørger for logging, så du kan se, hvad der skete.

Cron på Linux og macOS

På Linux og macOS er cron standarden for faste jobs.

Eksempel: kør et Python-script hver dag kl. 07:00:

0 7 * * * /usr/bin/python3 /home/dig/scripts/morgenrapport.py >> /home/dig/logs/morgenrapport.log 2>&1

Her bliver output og fejl skrevet til en logfil, så du kan fejlsøge senere. Cron og baggrundsjob er et større emne i sig selv, som er gennemgået mere detaljeret i artiklen om cron og baggrundsjob.

Windows Task Scheduler

På Windows bruger du typisk Task Scheduler:

• Opret en ny opgave.
• Vælg trigger (fx “Daily” kl. 07:00).
• Vælg “Start a program” og peg på python.exe som program.
• Sæt scriptstien som argument, fx C:scriptsmorgenrapport.py.

Sørg for at teste opgaven ved at køre den manuelt fra Task Scheduler, før du stoler på den.

GitHub Actions og lignende

Hvis din kode allerede ligger på GitHub, kan du bruge GitHub Actions til at køre scripts på tidsplan. Det er især oplagt til scripts, der skal køre i et mere “devops”-agtigt setup sammen med test og deployment. En introduktion til, hvordan et lille CI-setup kan gøre livet nemmere, finder du i artiklen om lille CI, stor forskel.

Gør driften robust: logging, retry og dry-run

Når et script kører uden dig, har du brug for synlige spor:

• Logging: Skriv vigtige hændelser og fejl til en logfil. Det er svært at overdrive, hvor meget det hjælper. Hvis du vil lidt dybere, er guiden om logs vs mavefornemmelse værd at læse.
• Retry logic: Hvis du kalder API’er, bør du have en kontrolleret genforsøgsmekanisme ved midlertidige fejl. Gør det med omtanke, ellers kan du overbelaste et API. Der er en konkret case i artiklen om et retry-loop, der gik galt.
• Dry-run: Tilføj en tilstand, hvor scriptet kun fortæller, hvad det ville gøre, uden at ændre data. Godt til nye scripts eller store ændringer.

Sikkerhed, API-nøgler og vedligehold

API-nøgler, passwords og tokens bør aldrig ligge direkte i koden. Brug miljøvariabler, giv kun de nødvendige rettigheder, og log fejl, så et script kan fejle synligt uden at udsætte data eller hemmeligheder.

Må ikke: hardcode secrets

En klassisk fejl er at skrive noget i stil med:

API_KEY = "1234567890-super-hemmelig"

og tjekke filen ind i GitHub. I det øjeblik koden ligger offentligt, er nøglen kompromitteret. Selv private repositories eller delte mappe-strukturer kan være et problem.

I stedet bør du:

• Lægge nøgler i miljøvariabler (WEATHER_API_KEY, SMTP_PASSWORD osv.).
• Brug konfigurationsfiler, der ikke commit’es (fx .env) og hold dem uden for versionkontrol.
• Begrænse rettigheder: en API-nøgle bør kun kunne det, der er nødvendigt.

Hvis du er i tvivl om, hvor dine nøgler bør bo, er artiklen om at gemme API-nøgler korrekt en god tjekliste. For webapps er der ekstra faldgruber, som er beskrevet i artiklen om at undgå tilfældig token-opbevaring.

Adgang, data og backups

Når scripts får lov at læse eller ændre data, er det værd at være konservativ:

• Kør scripts med så få rettigheder som muligt (mindst privilegium).
• Tag backup eller arbejd på kopier, især i starten.
• Log ændringer, så du kan se, hvad scriptet gjorde, hvis noget går galt.

Hvis scriptet arbejder mod en database eller et fælles system, og I er flere i et team, er det værd at have styr på migrations- og ændringsprocesser. Det er et større emne, som gennemgås i artiklen om database-migrationer i teams.

Rate limits og eksterne API’er

Mange API’er har grænser for, hvor ofte du må kalde dem. Hvis du laver et script, der skyder for hårdt, kan du få fejl eller i værste fald blive blokeret.

Gode vaner er:

• Læse dokumentationen for rate limits og tilbageoff-strategier.
• Indbygge små pauser (sleep), hvis du skal igennem mange kald.
• Logge, når du får 429 eller lignende “too many requests”-fejl.

Hvis du vil forstå rate limiting mere praktisk, er der en jordnær gennemgang i artiklen om rate limiting i praksis.

Typiske fejl og hvordan du undgår dem

De mest almindelige fejl i små scripts er forkerte filstier, manglende pakker, permissions, API-timeouts og data i et uventet format. De undgås bedst med tydelig inputvalidering, logging, test på kopier og en enkel retry-mekanisme.

1. Fil- og sti-fejl

Symptomer: FileNotFoundError i Python, eller at scriptet “intet gør”.

Årsager: Flyttet mapper, ændret filnavn, forskel på relative og absolutte stier.

Løsning: Print de stier, du arbejder med, og test på en enkelt fil. Brug absolutte stier, når det giver mening, og kontroller med os.path.exists(), før du ændrer noget.

2. Manglende pakker eller forkerte versioner

Symptomer: ModuleNotFoundError (Python) eller Cannot find module (Node).

Løsning: Sørg for at installere afhængigheder (pip install ..., npm install ...). For Python er det en god idé at bruge virtuelle miljøer, som gennemgås i guiden om at tæmme Python-kaos med venv.

3. Rettighedsproblemer

Symptomer: Fejl som “Permission denied” eller mislykkede filoperationer.

Løsning: Kør scriptet med passende rettigheder, undgå at køre alt som administrator, og test i mapper, hvor du ved, at du har fuld kontrol.

4. Uventet dataformat

Symptomer: KeyError i Python, undefined i JS, eller fejl ved parsing af CSV/JSON.

Løsning: Log et lille uddrag af data, før du arbejder videre. Antag aldrig, at API’et eller CSV’en altid vil se ud på samme måde. Tjek for nøgler med in-check og håndter manglende felter.

5. API-timeouts og ustabile netværk

Symptomer: Tidsudløb, 5xx-fejl, eller at scriptet bare “dør” halvvejs.

Løsning: Sæt tidsgrænser (timeout), fang exceptions, og implementer kontrollerede genforsøg med backoff. Undgå uendelige loops eller for aggressiv retry, som beskrevet i casen om retry-loopet (linket ovenfor).

Brug AI som ekstra hjælper

Hvis du sidder fast i en fejlbesked eller skal oversætte en idé til konkret kode, kan værktøjer som ChatGPT hjælpe, især når du giver klare eksempler på input og ønsket output. Der er en samling praktiske tips i guiden om effektive AI-prompts til kodning og debugging.

Hvornår giver no-code mere mening end kode?

No-code er ofte det bedste valg, når processen er enkel, standardiseret og ikke kræver speciallogik. Hvis du bare skal flytte data mellem to systemer, sende en mail eller trigge en handling, kan Power Automate, Zapier, Make eller n8n være hurtigere end egen kode.

Typiske no-code-kandidater:

• “Når der kommer en mail med vedhæftet fil, læg filen i denne OneDrive-mappe.”
• “Når der laves en ny række i et Google Sheet, send en Slack-besked.”
• “Når en formular på websitet udfyldes, opret en sag i et CRM-system.”

Her giver det sjældent mening at skrive og drifte egne scripts, hvis standardværktøjer allerede gør det stabilt.

Kode giver mere mening, når:

• Logikken er kompleks eller meget specifik for din forretning.
• Du skal have præcis kontrol over ydeevne, fejl, retry, logging osv.
• Du vil kunne versionere, teste og dele løsningen som “rigtig” software.

Det er helt legitimt at starte i no-code og først gå over til Python eller JavaScript, når begrænsningerne begynder at gøre ondt. Det vigtigste er, at du ved, hvorfor du vælger det ene eller det andet.

Sådan kommer du selv videre

Den korteste vej fra idé til stabil automation er typisk:

1. Vælg én konkret, gentagen opgave, du er træt af.
2. Beslut om den er mest “fil/data” (Python), “web/browser” (JavaScript) eller ren integration (no-code).
3. Lav et første script, der kun løser kernen af problemet.
4. Tilføj logging og en simpel dry-run.
5. Sæt det til at køre planlagt med cron eller Task Scheduler.
6. Forbedr gradvist, når du ser, hvor det fejler i virkeligheden.

Hvis du vil gøre dine Python-scripts mere app-agtige, kan du kigge på guiden om at gå fra rodet script til lille app. Og hvis du når dertil, hvor dine automatiseringer skal køre på en server, er det værd at overveje hosting og opsætning, som diskuteret i artiklen om at vælge den rigtige hostingløsning.

Uanset valg af værktøj er målet det samme: du vil bruge mindre tid på gentagelser og mere tid på det arbejde, som faktisk kræver din hjerne.