Tägliche Notizen mit Vorlagen, Calendar & Templater

In diesem Kapitel wirst du die spezielle Notiz‑Art „Tägliche Notizen“ kennenlernen. Obsidian bietet dafür eine eingebaute Erweiterung, die sich sinnvoll mit zwei externen Plugins sowie mit Dataview‑Abfragen ergänzen lässt, um ein komfortables Tagebuch/Journal zu führen.

#Was sind „Tägliche Notizen“

Die „Täglichen Notizen“ zeigen besonders gut, wie flexibel Obsidian ist. Du kannst sie sehr strukturiert wie ein Journal gestalten oder ganz frei wie ein Tagebuch führen. Neben dieser Offenheit lassen sich die Notizen auch praktisch einsetzen, etwa um Aufgaben zu erfassen oder automatisch alle offenen Punkte anzuzeigen. In der Praxis werden sie oft genutzt, um den Tag zu planen und am Abend zu reflektieren. Am besten legst du dafür eine eigene Vorlage und einen eigenen Ordner an. Gesteuert wird dies über die Erweiterung „Tägliche Notizen“.

#Vorbereitungen

Bevor du die Erweiterung „Tägliche Notizen“ aktivierst, erstelle einen neuen Ordner, in dem die Notizen automatisch gespeichert werden sollen. In meinem Beispiel‑Vault habe ich ihn 97 Tägliche Notizen genannt.

Außerdem solltest du eine Vorlage erstellen und im Vorlagen‑Ordner ablegen. Hier ein Beispiel für eine typische Vorlage für eine solche tägliche Notiz. Nenne die Vorlage Tägliche Notiz

---
erstellt: {{date}}
tags:
  - daily
  - logbuch
notizen_typ: täglich 
stimmung: neutral   # sehr_gut / gut / neutral / schlecht
zufriedenheit:      # 1–10
---

## Aufgaben

- [ ] Platzhalter

## Termine

- 09:00 – Stand-up Meeting
- 14:00 – Review mit Team

## Notizen

- 
- 

## Ideen / Beobachtungen

- 
- 

## Rückblick

Im Frontmatter kannst du beliebige persönliche Parameter erfassen – hier dienen „Stimmung“ (sehr_gut / gut / neutral / schlecht) und „Zufriedenheit“ mit dem Tag (Skala 1–10) als Beispiele. Du könntest aber ebenso Schlafstunden, Schrittzahl oder andere Gesundheits- und Leistungsdaten aufnehmen, um sie später z.B. mit der Dataview-Erweiterung auszuwerten zu können.

Nachdem du Ordner und Vorlage angelegt hast, aktiviere die Erweiterung und konfiguriere die Einstellungen für die „Tägliche Notizen.“

#Einstellungen für Tägliche Notizen

Zunächst musst du die Obsidian-Erweiterung „Tägliche Notizen“ (1) in den Einstellungen aktivieren (2) und auf das Zahnrad klicken, um zu den Erweiterungseinstellungen zu gelangen.

In den Optionen der „Tägliche Notizen“-Erweiterung legst du über das Datumsformat (1) fest, wie die Notizen bei ihrer Erstellung benannt werden. Das vorgegebene ISO 8601-Format hat den Vorteil, dass die Dateien im Datei-Explorer alphabetisch korrekt nach Datum sortiert werden.

In der Option „Neuer Dateispeicherort“ (2) legst du den Ordner fest, in dem deine „Tägliche Notiz“ abgelegt werden soll. In der Beispiel-Vault, ist das 97 Tägliche Notizen. Der dritte Eintrag definiert die Vorlage, die verwendet werden soll, hier tägst du  98 Vorlagen/Tägliche Notiz ein. Mit der vierten Option kannst du einstellen, dass immer automatisch eine „Tägliche Notiz“ angelegt, wenn du Obsidian startest.

#Erste tägliche Notiz erstellen

Du könntest das Erstellen einer täglichen Notiz, wie im vorherigen Kapitel beschrieben, auch in der QuickAdd-Erweiterung definieren. Allerdings bietet Obsidian bereits eine eingebaute Funktion für die Erstellung der täglichen Notiz an, und die notwendigen Einstellungen hast du bereits vorgenommen. Daher kannst du nun mit ⌘-P oder Ctrl-P das Befehlsfeld aufrufen und im Eingabefeld täg eingeben:

Mit Return oder einem Klick auf die Zeile „Tägliche Notizen: Heutige Notiz öffnen“ wird – falls vorhanden – die heutige „Tägliche Notiz“ geöffnet oder, falls sie noch nicht existiert, neu erstellt. Pro Tag kann es es nur eine „Tägliche Notiz“ geben!

Die Notiz sollte dann so aussehen:

#Die Calendar-Erweiterung

Für die Installation öffnest du wieder die Obsidian Einstellungen und die Option „Externe Erweiterungen“ (2). Danach klickst du auch den „Durchsuchen“-Button (2)

Eine praktische Erweiterung im Umgang mit den täglichen Notizen ist die Calendar-Erweiterung. Diese externe Erweiterung muss zunächst installiert werden. Danach bietet sie eine Kalenderübersicht im rechten Side-Panel, in der du einfach die Notizen für einen bestimmten Tag öffnen oder, wenn sie noch nicht vorhanden ist, erstellen kannst.

Für die Installation der Calendar-Erweiterung öffnest du wieder die Obsidian-Einstellungen und die Option „Externe Erweiterungen“ (1). Danach klickst du auf den „Durchsuchen“-Button (2).

In das Suchfeld gibst du „Calen“ ein und wählst die „Calendar-Erweiterung“ von Liam Cain aus.

Im folgenden Dialog installierst und aktivierst du die Erweiterung und navigierst zu den Optionen.

Folgende Einstellungen sind möglich:

• Words per dot (1): Unterhalb des Datums wird mit Punkten visualisiert, wie lang die Notiz ist. Der Eintrag hier bestimmt, für wie viele Wörter ein Punkt steht.
• Start week on (2): Legt den Wochentag fest, an dem die Woche startet. In Deutschland ist das offiziell der Montag.
• Confirm before creating a new note (3): Wenn diese Option aktiv ist, wirst du vor der Erstellung einer neuen täglichen Notiz gefragt, ob du dies wirklich möchtest. Da im Kalender höchstens durch einen versehentlichen Klick eine neue Notiz erstellt wird, die nicht gewünscht war, aber ansonsten nichts kaputt gehen kann, habe ich diese Option deaktiviert.
• Show week number (4): Falls du auch in Wochen denkst, kannst du den Kalender so einstellen, dass auch die Wochennummer angezeigt wird. Du kannst dann weitere Einstellungen vornehmen, da beim Klick auf die Wochennummer die Erweiterung eine entsprechende Notiz für die entsprechende Woche erstellt. Nach dem Aktivieren kannst du die weitere Einstellungen machen, um einen speziellen Ordner und eine Vorlage zuzuordnen.
• Override locale (5): Mit dieser Option kannst du die Sprache des Kalenders umschalten.

Wenn du nun alle Einstellungen vorgenommen hast, schließe den Dialog und öffne das rechte Side-Panel. Falls bei der Installation nichts schiefgegangen ist, sollte nun in der Toolbar des Side-Panels ein neues Icon (1) erscheinen. Falls nicht, kannst du versuchen, den Kalender über die Befehlspalette aufzurufen. Dafür gibst du dort Calendar: Open View ein. Wenn keine Calendar-Funktionen angezeigt werden, prüfe, ob die Erweiterung noch aktiviert ist.

Wie schon erwähnt, werden Tage mit einer täglichen Notiz mit Punkten visualisiert (2). Der heutige Tag (3) – im Bild der 11.08.2025 – wird leicht grau angezeigt. Ein Klick auf ein Datum öffnet oder erstellt die Notiz für das entsprechende Datum. Das < HEUTE > oben rechts dient der Navigation: Monat zurück, auf den aktuellen Monat und Monat vor. Du kannst auch tägliche Notizen in der Vergangenheit oder Zukunft durch einen Klick auf das entsprechende Datum erstellen.

Mit diesen Einstellungen hast du alles, was du brauchst, um tägliche Notizen zu erstellen und zu verwalten.

#Tägliche Notizen als Aufgaben‑Tracker

Tägliche Notizen sind auch ein guter Ort, um einen Überblick über aktuelle Aufgaben zu behalten. In der oben vorgeschlagenen Vorlage für die „Täglichen Notizen“ hast du bereits einen Abschnitt „Aufgaben“, in dem du einfach Aufgaben ergänzen kannst, die du erledigen musst.

Damit du in jeder neuen täglichen Notiz direkt siehst, welche Aufgaben noch offen sind, kannst du die Vorlage entsprechend anpassen und einen weiteren Abschnitt hinzufügen:

## Offene Aufgabe
```dataview
TASK
FROM ""
WHERE !completed
AND !contains(file.folder, "98 Vorlagen")
SORT file.name ASC
```

Mit dieser Dataview-Abfrage werden dir alle offenen Aufgaben im gesamten Vault aufgelistet:

Du kannst an dieser Stelle direkt eine Aufgabe als erledigt markieren, wodurch sie sofort aus dieser Übersicht verschwindet. Mit einem Klick auf den Aufgabentext öffnest du die Notiz, in der die Aufgabe erstellt wurde und kannst sie dann dort bearbeiten.

In der Liste werden dir allerdings alle offenen Aufgabe aus dem gesamten Vault gelistet. Nur der Ordner 98 Vorlagen ist ausgenommen (AND !contains(file.folder, "98 Vorlagen"), da in der Vorlage Tägliche Notizen auch eine offene Aufgabe als Platzhalter definiert ist, die nicht unbedingt in der Übersicht gelistet werden soll.

Du kannst die Abfrage natürlich auch nur auf die Aufgaben beschränken, die du in den „Täglichen Notizen“ angelegt hast:

## Offene Aufgaben
```dataview
TASK
FROM "97 Tägliche Notizen"
WHERE !completed
SORT file.name ASC
```

#Übersichten und Dataview‑Beispiele"

Zwei weitere Dataview‑Abfragen in diesem Abschnitt geben dir einen Überblick, welche Notizen an dem Tag, den die Notiz repräsentiert, erstellt oder modifiziert wurden.

Da du mit der Calendar‑Erweiterung an Tagen in der Vergangenheit oder Zukunft für einen Tag eine Notiz anlegen kannst, ist die Referenz für den Tag nicht das file.cdate (also das Erstellungsdatum der Datei), sondern der Name, der der Datums­konvention (YYYY-MM-DD) entspricht:

### Heute erstellt

```dataview
LIST
WHERE dateformat(file.cday, "YYYY-MM-DD") = dateformat(date(this.file.name), "YYYY-MM-DD")
```

```

Übersetzt heißt das:

Zeige alle Notizen, deren Erstellungsdatum (file.cday) im Format YYYY-MM-DD gleich dem Namen dieser Notiz (this.file.name) ist, nachdem dieser in ein Datumsformat konvertiert wurde: dateformat(date(this.file.name), "YYYY-MM-DD").

Das file.cday sollte eigentlich immer gleich bleiben. Du kannst auch statt des file.cday die Frontmatter-Eigenschaft erstellt abfragen, wenn du sie in deinen Notizen definiert hast:

```dataview
LIST WHERE dateformat(date(erstellt), "YYYY-MM-DD") = dateformat(date(this.file.name), "YYYY-MM-DD")

```

Du kannst auch eine Liste erstellen, die alle Notizen zeigt, deren Änderungsdatum (file.mday) mit dem Datum der täglichen Notiz übereinstimmt. Das bedeutet, dass alle Dateien gelistet werden, deren Eigenschaft  file.mday gleich dem Namen der täglich Notiz ist. Allerdings werden Notizen, die an diesem Tag geändert wurden, später erneut bearbeitet wurden und deshalb nicht mehr in der Liste auftauchen, weil ihr Änderungsdatum sich geändert hat. Also er ist nicht unbedingt eine Möglichkeit nachzuvollziehen an welchen Notizen du an dem Tag gearbeitet hast.

Trotzdem hier der Dataview Aufruf:

```dataview
LIST
WHERE dateformat(file.mday, "YYYY-MM-DD") = dateformat(date(this.file.name), "YYYY-MM-DD")
```

#Viele Wege führen nach Rom

Mit QuickAdd stößt du im Zusammenhang mit den „Täglichen Notizen“ und der Calendar-Erweiterung an Grenzen, denn QuickAdd wird nur aktiv, wenn du eine neue Notiz direkt über QuickAdd erstellst. Das passiert jedoch nicht, wenn du im Kalender auf einen bestimmten Tag klickst.

Um dieses Problem zu umgehen, kannst du eine weitere Erweiterung nutzen: Templater. Auch Templater muss in diesem Fall gestartet werden, aber in den Einstellungen gibt es eine Option, die dafür sorgt, dass Templater bei der Erstellung neuer Notizen automatisch aktiv wird.

Obwohl sich beide Erweiterungen funktional stark überschneiden, eignet sich QuickAdd – wie der Name schon sagt – eher für die schnelle und interaktive Erfassung von neuen Notizen über das Befehls-Panel oder Hotkeys und ist stärker auf Workflows ausgelegt. Templater hingegen unterstützt vor allem die Automatisierung ohne Benutzerinteraktion. Außerdem ermöglicht Templater die Nutzung dynamischer Inhalte wie Datum und Uhrzeit, Dateinamen, Frontmatter-Bearbeitung, Abfragen auf andere Notizen oder Loops bei der Notizerstellung.

In diesem Kapitel stelle ich dir neben den grundlegenden Funktionen von Templater auch ein kleines Beispiel-Skript vor. Wie bei den anderen Erweiterungen werde ich in einem späteren Kapitel dann detaillierter auf die Einstellungen und Möglichkeiten eingehen.

#Templater: Installation und Einstellungen

Für die Installation öffnest du die Obsidian-Einstellungen und wählst „Externe Erweiterungen“. Klicke auf „Durchsuchen“ und suche nach „Templater“. Nach der Installation und Aktivierung öffnest du die Optionen. Dort siehst du dann folgendes Bild:

Unter „Template folder location“ (1) gibst du den Ordner an, in dem deine Vorlagen liegen – im Beispiel ist das 98 Vorlagen. Die Option „Syntax highlight on desktop“ (2) kannst du deaktivieren, falls dir der Templater-Code in den Notizen zu bunt erscheint. Mit „Trigger Templater on new file creation“ (3) sorgst du dann dafür, dass Templater bei jeder neuen Notiz automatisch ausgeführt wird.

Die Einstellung „Enable Folder Templates“ (4) sorgt dafür, dass Notizen, die, z.B. mit über das Kontext-Menü, in einem bestimmten Ordner erstellt werden, automatisch mit der passenden Vorlage (5) versehen werden. Das kann zu doppelten Vorlagen führen, wenn du etwa über QuickAdd eine Notiz für eine neue Stadt anlegst: QuickAdd fügt bereits die Vorlage 98 Vorlagen/Ort hinzu, und Templater legt dieselbe Vorlage nochmal drauf. Das stört nicht, führt aber zu einem kurzen Flackern, bevor die Notiz angezeigt wird. Ob du für jeden Ordner eine Vorlage definieren willst, zeigt sich mit der Zeit. Aber für das nächste Beispiel ist die Zuordnung des Ordners „Tägliche Notizen“ mit der Vorlage 98 Vorlagen/Tägliche Notiz wichtig.

#Tägliche Notizen mit Templater erweitern

Mit der Templater-Erweiterung kannst du deine „Täglichen Notizen“ deutlich erweitern und automatisieren. So wird aus einem einfachen Ort zum schnellen Festhalten von tagesbezogenen Informationen ein mächtiges Werkzeug, das dir nicht nur hilft, Aufgaben zu verwalten, sondern auch die Navigation zwischen den Notizen erleichtert und dynamische Inhalte automatisch einfügt.

Eine Möglichkeit in zwischen den „Tägliche Notizen“ zu navigieren, neben dem Kalender im rechten Side-Panel, ist eine kleine Navigationsleiste, die dir auch noch das Datum der täglichen Notiz weniger technisch anzeigt:

Wenn du die Notiz des Vortages sehen möchtest, klickst du auf „Vortag“. Im Beispiel ist die Notiz für den nächsten Tag noch nicht angelegt, wird aber nach dem Klick auf „Folgetag“ automatisch erstellt. Dabei erhält die Notiz zwar als Namen das Datum des Folgetags, aber das Meta-Datum file.cday bekommt das aktuelle Erstellungsdatum. Dies solltest du bei der Arbeit mit täglichen Notizen berücksichtigen.

Die Navigationsleiste lässt sich mit der Templater-Erweiterung relativ leicht realisieren:

[[97 Tägliche Notizen/<% moment(tp.file.title, "YYYY-MM-DD").subtract(1, "days").format("YYYY-MM-DD") %> | ← Vortag]] | **<% moment(tp.file.title, "YYYY-MM-DD").format("dddd, DD. MMMM YYYY") %>** | [[97 Tägliche Notizen/<% moment(tp.file.title, "YYYY-MM-DD").add(1, "days").format("YYYY-MM-DD") %> | Folgetag →]]

Das sieht komplizierter aus, als es ist. Wichtig ist, dass du wie oben beschrieben, als Format für den Namen der Täglichen Notizen, das Datums-Format YYYY-MM-DDfestgelegt hast.

Als erstes wird er Link zu dem „Vortag“ zusammengebaut: [[97 Tägliche Notizen/<% moment(tp.file.title, "YYYY-MM-DD").add(-1, "days").format("YYYY-MM-DD") %> | ← Vortag]]

Normalerweise reicht für den Verweis auf eine Notiz in Obsidian der Name ohne Pfad aus. Da die „Tägliche Notiz“ vom Vortag jedoch im entsprechenden Ordner angelegt werden soll, falls sie noch nicht existiert, wird der gesamte Pfad aus dem Ordnernamen 97 Tägliche Notizen und dem Namen der aktiven „Täglichen Notiz“ zusammengesetzt. Der Name der Notiz nach dem Schema YYYY-MM-DD wird dabei mit Hilfe der Templater-Erweiterung definiert:

• <% ... %>: Ist der Inline-Templater-Ausdruck, der dafür sorgt, dass der Code zwischen den Klammern ausführt und das Ergebnis als Text in die Notiz einfügt wird:
• moment(): Diese Funktion wandet Text in ein Datumsobjekt um, auf dem dann Methoden zur Datumsberechnung angewandt werden können.
• tp.file.title: Dieser Aufruf übergibt den Namen der aktuellen Notiz an die moment()-Funktion.
• .subtract(1, "days"): Diese Methode, wird das erzeugte Datumsobjekt angewandt und setz dieses um einen Tag zurück.
• format("YYYY-MM-DD"): Konvertiert das Ergebnis zurück in einen Text und gibt diesen aus.

Der so entstandene Pfad wird nun zusammen mit dem Text ← Vortag als Link in die Notiz geschrieben, entsprechend der Markdown-Syntax für Links: [[Notizname | Anzeigetext]]. Das Zeichen | nach dem Link ist ein Textbestandteil, der visuell den Link zum „Vortag“ vom Datum der aktiven Notiz trennt.

Nun folgt ein Templater-Ausdruck, der den Notiznamen wieder in ein Datumsobjekt umwandelt und dieses mit der Methode .format fett (**) ausgibt: <% moment(tp.file.title, "YYYY-MM-DD").format("dddd, DD. MMMM YYYY") %>

Falls du mit der Datumsangabe im Stil von YYYY-MM-DD zufrieden bist, kannst du auch den Dateinamen direkt ausgeben, also einfach <% tp.file.title %> ausgeben.

Am Schluss wird der Link auf den „Folgetag“ genauso zusammengebaut wie der zum „Vortag“, nur dass hier die Methode .add(1, "days") verwendet wird.

Wenn du diesen Code in die Vorlage Tägliche Notiz im Ordner Vorlage einfügst, wird bei dem Erstellen einer neuen täglichen Notiz diese Navigationsleiste eingefügt. Wie du diese bei älteren tägliche Notizen ergänzen kannst, zeige ich im übernächsten Abschnitt.

Ein kleines Problem gibt es noch, für das ich im Moment keine Erklärung habe: Der Wert der Notiz-Eigenschaft erstellt im Frontmatter der Vorlage muss geändert werden, da sie sonst beim Erstellen einer neuen Notiz über diese Navigation nicht mit dem aktuellen Datum belegt wird. Hierbei kollidieren wahrscheinlich verschiedene Ansätze, eine „Tägliche Notiz“ anzulegen. Die folgende Änderung nutzt ebenfalls einen Templater Inline-Ausdruck und funktioniert:

erstellt: <% tp.date.now("YYYY-MM-DD") %>

#Das aktuelle Wetter automatisch einfügen

Templater bietet dir auch die Möglichkeit, bei der Erstellung einer Notiz komplexere JavaScript-Skripte auszuführen oder Kommandos auf Betriebssystemebene zu starten. Bei beiden Ansätzen solltest du jedoch genau wissen, was du tust.

Aber zunächst geht es nochmals in die Einstellungen der Templater-Erweiterung:

Unter dem Punkt (1) im obigen Bild kannst du einen Ordner definieren, in dem du komplexere Templater-JavaScript-Skripte ablegen kannst. Diese Option kannst du zunächst ignorieren; in einem späteren Kapitel gehe ich darauf ein.

Die Option „Enable user system command function“ eröffnet dir die Möglichkeit, Kommandos auf Systemebene auszuführen und das Ergebnis in eine Notiz einzufügen. Wenn du diese Option aktiviert hast (natürlich nachdem du die Warnung gelesen hast), solltest du noch deine bevorzugte Shell angeben. Auf dem Mac ist der Standard /bin/zsh. Bei Linux wird ebenfalls der bevorzugte Shell-Pfad eingetragen. Unter Windows funktioniert das Ganze ebenfalls; genauere Informationen findest du unter diesem Link: Tutorial on executing system commands ....

Als Beispiel möchte ich das aktuelle Wetter abrufen und in die tägliche Notiz einfügen. Dazu nutze ich den Service wttr.in. Im Terminal würde ein Aufruf, z. B. für Heidelberg, so aussehen:

 $ curl 'wttr.in/Heidelberg?format=4' 

Heidelberg: ⛈ 🌡️+31°C 🌬️↗20km/h

Mehr Informationen zu den Aufruf-Parametern und Ausgabeformaten findest du hier. So kannst du, falls dein Provider dir eine IP-Adresse zuweist, die mit deinem Wohnort verknüpft ist, dir die Angabe des Ortes sparen:

curl 'wttr.in?format=4'

Das hat den Vorteil, dass z.B. auf Reisen immer das lokale Wetter angezeigt in die Notiz eingefügt wird.

Um das Ergebnis der Abfrage bei der Erstellung einer neuen täglichen Notiz einzufügen, muss der Befehl in den Einstellungen als Templater-Funktion definiert werden:

In Zeile (1) gibst du der Funktion einen Namen und definierst die Funktion. Mit einem Klick auf den Button „Add new user function“ wird die Funktion übernommen und steht anschließend zur Verfügung.

Wenn du nun folgenden Ausdruck in die Vorlage der täglichen Notiz einfügst, wird bei der Erstellung der Notiz das aktuelle Wetter eingefügt:

`<% tp.user.wetter() %>`

So sollte der gesamte Kopfbereich der Vorlage nun aussehen:

---
erstellt: <% tp.date.now("YYYY-MM-DD") %>
tags:
  - daily
  - logbuch
stimmung:
zufriedenheit:
---

[[97 Tägliche Notizen/<% moment(tp.file.title, "YYYY-MM-DD").subtract(1, "days").format("YYYY-MM-DD") %> | ← Vortag]] | **<% moment(tp.file.title, "YYYY-MM-DD").format("dddd, DD. MMMM YYYY") %>** | [[97 Tägliche Notizen/<% moment(tp.file.title, "YYYY-MM-DD").add(1, "days").format("YYYY-MM-DD") %> | Folgetag →]]

<% tp.user.wetter() %>

Und das Ergebnis, wenn eine neue Notiz angelegt wurde:

Allerdings hat dieses Vorgehen einige Probleme:

1. Es werden die Wetterbedingungen für den Moment des Aufrufs abgerufen, was für „Tägliche Notizen“, die in der Vergangenheit oder Zukunft liegen, keinen Sinn macht.
2. Da du wahrscheinlich zu verschiedenen Zeitpunkten eine neue tägliche Notiz erstellst, sind die Wetterdaten nicht unbedingt vergleichbar.
3. Es kann vorkommen, dass der Ort nicht richtig gefunden wird. In diesem Fall hilft es, die Geo-Koordinaten statt des Stadtnamens anzugeben, z. B. curl 'wttr.in/49.3988,8.6724?format=4'.
4. Der Dienst ist nicht immer erreichbar.
5. Obsidian muss für den Aufruf in einer Umgebung laufen, die den Zugriff auf die Kommandozeile zulässt, was z. B. unter iOS nicht möglich ist.

Trotz all dieser Probleme ist dies ein gutes Beispiel für die Möglichkeiten, die Templater mit der Einbindung von Skripten bietet.

#Manuelles Einfügen von Vorlagen mit Templater

Was kannst du machen, wenn du einen Templater-Befehl, wie die Navigationsleiste oder die Wetter-Info, in Notizen einfügen möchtest, die noch mit der Vorgängerversion der Vorlage erstellt wurden, die diese Aufrufe noch nicht enthalten?

Fangen wir zunächst mit dem Wetter an. Dazu erstellst du eine neue Vorlage mit dem Namen Wetter im Ordner 98 Vorlagen. Am besten öffnest du das Kontextmenü auf dem Ordnersymbol und erstellst so eine neue Notiz ohne Frontmatter-Eigenschaften. In diese Vorlage kopierst du die oben definierte Wetter-Funktion.

Die Notiz soll dann so aussehen:

Positioniere den Eingabe-Cursor z.B. am Anfang des Inhaltsbereiches und öffne die Befehl-Palette (⌘-P). Nun gibst du den Befehl Templater: Open insert template modalein und wählst das Template Wetter aus. Damit wird an der Cursor-Position das die Wetter-Zeile eingefügt.

Vielleicht ist dir auch schon aufgefallen, dass im linken Panel ein neues Icon angezeigt wird, nachdem du die Templater-Erweiterung aktiviert hast. Es sieht so aus:

#<%

Statt über die Befehls-Palette kannst du auch auf dieses Icon klicken und dort Wetter auswählen, womit die Wetter-Zeile in eine Notiz eingefügt wird.

Über dieses Icon werden alle Templates an der aktuellen Cursor-Position eingefügt, was für die meisten dort aufgelisteten Templates nur Sinn, macht wenn eine leere Notiz um den Inhalt einer Vorlage, wie zum Beispiel die für Sehenswürdigkeiten erhalten soll.

#Wetter auf Knopfdruck einfügen

Trage nun die „Wetter“-Vorlage in den Templater-Einstellungen unter den Optionen Templater hotkeys (1) in das Eingabefeld (2) ein:

Mit einem Klick auf das kleine + (3) kannst du ein Tastenkürzel definieren, das den Befehl ausführt. Nach dem Klick wechselst du automatisch zu den Einstellungen für die Tastenkürzel:

Hier gibst du im Suchfeld temp ein und klickst in der Zeile „Templater: Insert Wetter“ (1) erneut auf das + (2).

Aus dem grauen Feld mit dem Text „Leer“ wird ein blaues Feld mit dem Text „Tastenkürzel klicken“. Wenn du nun eine Tastenkombination drückst, z. B. auf dem Mac ⌘⌥W, kannst du nun mit diesem Tastenkürzel dann an jeder Position in einer Notiz die Wetter-Infos einfügen.

#Die Navigationsleiste schnell einfügen

Mit der gleichen Methode kannst du schnell die Navigationsleiste für in täglichen Notizen einfügen, in denen diese Leiste noch fehlt.

Dazu erstellst du wieder eine neue Vorlage im Ordner 98 Vorlagen, die keinen weiteren Inhalt haben sollte. Nenne diese z. B. Navigation und setzte den Teil aus der Vorlage Tägliche Notiz ein, in der die Navigation definiert ist:

[[97 Tägliche Notizen/<% moment(tp.file.title, "YYYY-MM-DD").subtract(1, "days").format("YYYY-MM-DD") %> | ← Vortag]] | **<% moment(tp.file.title, "YYYY-MM-DD").format("dddd, DD. MMMM YYYY") %>** | [[97 Tägliche Notizen/<% moment(tp.file.title, "YYYY-MM-DD").add(1, "days").format("YYYY-MM-DD") %> | Folgetag →]]

Nun gehst du genauso vor wie bei der Wetter-Vorlage. Du kannst wieder ein Tastenkürzel wählen oder die Navigation über das Templater-Icon oder die Befehlspalette starten, womit die Navigationsleiste eingefügt wird. Wichtig: Das funktioniert natürlich nur bei Notizen, deren Name ein Datum im Format YYYY-MM-DD hat.

#Aktuelles Datum einfügen

Ein weiteres Beispiel ist das Einfügen des aktuellen Datums. Dazu erstellst du eine Vorlage mit dem Namen heute und fügst den folgenden Befehl ein:

<% tp.date.now("DD.MM.YYYY") %>

Auch diese Vorlage kannst du in den Templater-Einstellungen unter der Option Template hotkeys eintragen und mit einem Tastaturkürzel versehen. So kannst du immer auf Tastendruck das aktuelle Datum in eine Notiz einfügen. Das Datumsformat kannst du frei wählen; im Beispiel ist es die Schreibweise „20.08.2025“.

Mit diesem Vorgehen kannst du auch größere Textblöcke oder komplexe Markdown-Definitionen einfügen. Oder auch ganze Skripte ablaufen lassen, was ich nun am Ende dieses Kapitel als Ausblick zeigen möchte.

#JavaScript‑Skripte mit Templater ausführen

**Hinweis: Ich bin kein professioneller Software-Entwickler und habe den folgenden Code mit Unterstützung von ChatGPT erstellt. Obwohl ich ihn selbst nutze, kann ich keine Garantie für Sicherheit oder optimale Umsetzung geben. Nutze den Code daher auf eigene Verantwortung und sichere deine Vault vorher unbedingt.*

Stelle dir vor, du möchtest neue Eigenschaften in das Frontmatter einiger Notizen hinzufügen. Das kannst du manuell machen oder mit Hilfe von JavaScript und Templater.

Dazu kannst du ein kleines Skript in JavaScript innerhalb einer Vorlage definieren oder das Skript in einer JavaScript‑Datei in einem definierten Ordner ablegen und diese Datei dann aufrufen.

Hier verwende ich die erste Variante, also ein JavaScript‑Skript in einer Vorlage zu speichern und dieses mit Templater auszuführen. Die andere Variante werde ich in einem späteren Kapitel besprechen.

Die Idee ist, diese Vorlage einzufügen, während die Notiz aktiv ist, deren Frontmatter um eine oder mehrere Eigenschaften ergänzt werden soll — jedoch nur, wenn diese Eigenschaften noch nicht vorhanden sind.

Das fertige Skript sieht so aus:

<%*
const file = app.workspace.getActiveFile();
if (!file) {
  new Notice("⚠️ Keine aktive Notiz!");
  return;
}

// gewünschte Default-Properties
const props = {
  "qualität": 0,
  "wichtigkeit": 0,
  "bearbeitet": false
};

// Dateiinhalt lesen
let content = await app.vault.read(file);

// Fall 1: Noch kein Frontmatter vorhanden
if (!content.startsWith("---")) {
  const frontmatter = Object.entries(props)
    .map(([k, v]) => `${k}: ${v}`).join("\n");
  const newContent = `---\n${frontmatter}\n---\n${content}`;
  await app.vault.modify(file, newContent);
  new Notice("✅ Frontmatter hinzugefügt.");
  return;
}

// Fall 2: Frontmatter existiert → fehlende Keys ergänzen
const parts = content.split("---");
const yaml = parts[1].trim().split("\n");
const keys = yaml.map(line => line.split(":")[0].trim());

let updated = false;
for (const [key, value] of Object.entries(props)) {
  if (!keys.includes(key)) {
    yaml.push(`${key}: ${value}`);
    updated = true;
  }
}

if (updated) {
  const newContent = `---\n${yaml.join("\n")}\n---${parts.slice(2).join("---")}`;
  await app.vault.modify(file, newContent);
  new Notice("✅ Fehlende Eigenschaften hinzugefügt.");
} else {
  new Notice("✅ Alle Eigenschaften waren schon vorhanden.");
}
%>

Bevor du das Skript erstellst, solltest du es dir vorher anschauen und verstehen, was dieses Skript macht!

#Was macht das Skript?

• Das Skript ergänzt die aktive Notiz um im Skript definierte Eigenschafts-/Wert‑Paare.
• Falls in der Notiz kein Frontmatter vorhanden ist, wird eins mit allen Eigenschafts-/Wert‑Paaren erstellt.
• Ist bereits ein Frontmatter vorhanden, prüft das Skript, ob eine oder mehrere der gewünschten Eigenschaften fehlen, und fügt diese ggf. hinzu.
• Wenn die Eigenschaften bereits vorhanden sind, ändert das Skript die Notiz nicht.
• Vorhandene Eigenschafts-/Wert‑Paare werden nicht überschrieben — es werden nur fehlende ergänzt.

Die Eigenschaften, die in dem Beispiel hinzugefügt werden sollen:

qualität: 0
wichtigkeit: 0
bearbeitet: false

#Schritt-für-Schritt-Erklärung

#Aktive Notiz ermitteln

const file = app.workspace.getActiveFile();
if (!file) { new Notice("⚠️ Keine aktive Notiz!"); return; }

• Zuerst wird die aktuell geöffnete Notiz in die Konstante file als Objekt geladen. Dieses Objekt enthält u. a. den Namen der Notiz, den Pfad und Dateisystem‑Metadaten, aber noch nicht den Inhalt.
• Wenn keine Notiz geöffnet ist, hat file den Wert null; dann zeigt Obsidian die Meldung "⚠️ Keine aktive Notiz!" und das Skript beendet sich.

#Gewünschte Felder festlegen

const props = {
  "qualität": 0,
  "wichtigkeit": 0,
  "bearbeitet": false
};

• Hier legst du die Eigenschaften fest, um die das Frontmatter ggf. erweitert werden soll. Die Konstante props ist kein String, sondern ein Objekt — das ist für die spätere Einfügeroutine wichtig.
• Du kannst die Liste anpassen, indem du weitere Eigenschaften hinzufügst oder löschst; achte darauf, dass alle Zeilen bis auf die letzte mit einem Komma enden.

So könntest du z.B. die Liste der zu ergänzenden Eigenschaften um den statusund lektoriertergänzen:

  const props = {
    "qualität": 0,
    "wichtigkeit": 0,
    "bearbeitet": false,
    "status": "offen",
    "lektoriert": false
  };

#Lesen des Inhalts der Notiz

let content = await app.vault.read(file);

• An dieser Stelle liest das Skript den Inhalt der Notiz als String in die Variable content.

#Prüfen, ob Frontmatter vorhanden ist

if (!content.startsWith("---")) { ... }

• Die Methode startsWith("---") gibt true zurück, wenn der Inhalt der Notiz mit --- beginnt. Das Skript geht dann davon aus, dass ein Frontmatter folgt, was nicht zwingend der Fall sein muss. In einem solchen seltenen Fall solltest du das Skript nicht ausführen oder die Erkennung des Frontmatters robuster gestalten.
• Damit der If‑Zweig ausgeführt wird, der den Fall „kein Frontmatter“ behandelt, muss das Ergebnis von startsWith negiert werden. Deshalb steht ein ! vor dem Ausdruck: !content.startsWith("---").
• Wenn !content.startsWith("---") den Wert false liefert, wird der if-Block übersprungen und das Skript fährt mit der Logik zur Ergänzung eines vorhandenen Frontmatters fort.

#Neues Frontmatter erstellen

const frontmatter = Object.entries(props)
  .map(([k, v]) => `${k}: ${v}`).join("\n");

Diese Zeile ist etwas komplizierter:

• Das Objekt (props), das im Skript definiert ist und die zusätzlichen Eigenschaften (properties) enthält, wird in ein Array von Paaren konvertiert. Die Map‑Funktion formatiert dann jedes Paar zu einem String ${k}: ${v}, und .join("\n") hängt zwischen die so erzeugten Strings jeweils \n und gibt schließlich einen einzigen String zurück.
• Das Ergebnis ist ein String, der in der Konstante frontmatter gespeichert wird.
• Diese Konvertierung von JavaScript‑Objekt → Array → String wäre an dieser Stelle nicht notwendig, wenn props bereits als String definiert wäre. Aber die Definition als Objekt ist im weiteren Verlauf von Vorteil.

Der resultierende String sieht dann so aus:

  qualität: 0
  wichtigkeit: 0
  bearbeitet: false

Anschließend wird daraus das neue Frontmatter aufgebaut und zusammen mit dem bisherigen Inhaltsbereich der Notiz in der Variable newContent gespeichert.

const newContent = `---\n${frontmatter}\n---\n${content}`;

#Vorhandenes Frontmatter ergänzen

Bei einem existierenden Frontmatter sollen nur eventuell fehlende Eigenschaften in das Frontmatter hinzugefügt werden.

const parts = content.split("---");
const yaml = parts[1].trim().split("\n");
const keys = yaml.map(line => line.split(":")[0].trim());

• Dazu wird der Inhalt der Notiz (content) mit content.split("---") in Teile zerlegt. Das Ergebnis ist ein Array:
  • parts[0] enthält alles vor dem ersten ---.
  • parts[1] enthält alles zwischen den beiden ---, also den gesamten Inhalt des Frontmatters.
  • parts[2] (und ggf. weitere Elemente) enthält den restlichen Notiz‑Inhalt.
  • Die Trennzeichen --- sind in den Array‑Elementen nicht mehr enthalten.
• Anschließend wird parts[1] (also das Frontmatter) mit .trim().split("\n") in ein Array von Zeilen (yaml) konvertiert. Jede Zeile entspricht einem Eigenschafts-/Wert‑Paar.
• Schließlich extrahiert yaml.map(line => line.split(":")[0].trim()) aus jeder Zeile den Eigenschaftsnamen: Die Zeile wird am ersten Doppelpunkt geteilt, und das erste Element ([0]) wird getrimmt. Das Ergebnis ist das Array keys mit allen vorhandenen Eigenschafts‑Namen.

Hinweis: Diese Methode ist einfach, aber nicht narrensicher — sie geht davon aus, dass jede neue Eigenschaft in einer eigenen Zeile als key: value vorliegt.

Zur Veranschaulichung habe ich folgenden Test in der Browser‑Konsole ausgeführt. Die Variable content entspricht hier einer kompletten Notiz mit Frontmatter:

---
erstellt: 2025-08-18
ort: Heidelberg
--- 
Und hier ist der Content der Notiz
Und eine zweite Zeile

Und das zugehörige JavaScript:

const content = '---\nerstellt: 2025-08-18\nort: Heidelberg\n---\nUnd hier ist der Content der Notiz\nUnd eine zweite Zeile' 
const parts = content.split("---");
const yaml = parts[1].trim().split("\n");
const keys = yaml.map(line => line.split(":")[0].trim());// Try edit me


// Log to console
console.log(parts)
console.log(yaml)
console.log(keys)

Das Skript kannst du z. B. in die Konsole der Entwickler‑Tools im Chrome‑Browser eingeben oder du vertraust den folgenden Ausgaben.

Hier das Ergebnis von console.log(parts) (erste Zeile zeigt das Array in seiner Gänze; die folgenden Zeilen die indizierten Elemente):

['', '\nerstellt: 2025-08-18\nort: Heidelberg\n', ' Und hier ist der Content der Notiz\nUnd eine zweite Zeile']

0: ""
1: "\nerstellt: 2025-08-18\nort: Heidelberg\n"
2: " Und hier ist der Content der Notiz\nUnd eine zweite Zeile"

In der Konstante yaml sind dann die Schlüssel‑Wert‑Paare als Array abgelegt:

['erstellt: 2025-08-18', 'ort: Heidelberg']

0: "erstellt: 2025-08-18"
1: "ort: Heidelberg"

Und in keys enthält das Array nur noch die Eigenschaftsnamen:

['erstellt', 'ort']

0: "erstellt"
1: "ort"

Doch weiter im eigentlichen JavaScript

Nun wird für jeden Eintrag im props‑Objekt geprüft, ob der entsprechende key noch nicht in keys vorhanden ist (!keys.includes(key)). Ist das der Fall, wird das entsprechende Eigenschafts‑/Wert‑Paar an yaml angehängt und das Flag updated, das vor dem if‑Statement auf false gesetzt wurde, auf true gesetzt. Damit wird sichergestellt, dass die abschließende Routine nur ausgeführt wird, wenn tatsächlich Änderungen vorgenommen wurden.

for (const [key, value] of Object.entries(props)) {
  if (!keys.includes(key)) {
    yaml.push(`${key}: ${value}`);
    updated = true;
  }
}

#Datei speichern und Benachrichtigung anzeigen

Wenn das Flag updated auf true gesetzt wurde, wird eine neue Konstante newContent erstellt. Dabei werden zunächst die Trenn‑--- geschrieben, gefolgt von der neuen Frontmatter‑Definition, die aus dem yaml‑Array mit yaml.join("\n") in einen String konvertiert wird. Anschließend wird der restliche Notiz‑Inhalt angehängt (aus parts.slice(2)), und das vollständige Dokument wird zurück in die Datei geschrieben. Zum Schreiben wird await app.vault.modify(file, newContent); verwendet — das await sorgt dafür, dass das Skript erst nach Abschluss des Schreibvorgangs weiterläuft. Abschließend wird eine Erfolgs‑Meldung ausgegeben

if (updated) {
  const newContent = `---\n${yaml.join("\n")}\n---${parts.slice(2).join("---")}`;
  await app.vault.modify(file, newContent);
  new Notice("✅ Fehlende Eigenschaften hinzugefügt.");
} else {
  new Notice("✅ Alle Eigenschaften waren schon vorhanden.");
}

Ist updated false, zeigt das Skript die Meldung an, dass keine Eigenschaften ergänzt werden mussten.

#Script als Templater‑Vorlage ausführen

Wie schon erwähnt nutzen wir an dieser Stelle die erste Möglichkeit und speichern das Skript in einer Vorlage. Kopiere das Script und füge den Inhalt in eine neue Vorlage mit dem Namen eigenschaften hinzufügen ein. Lege die Vorlage im Ordner Vorlagen ab und erstelle sie ohne eigenen Frontmatter‑Bereich.

Damit du die Vorlage über die Befehlspalette aufrufen kannst, muss sie in den Einstellungen der Templater‑Erweiterung unter den Optionen für Template Hotkeys eingetragen werden. Du musst keinen Hotkey vergeben — dieser Eintrag stellt lediglich sicher, dass du den Befehl Templater: Insert eigenschaften_hinzufügen über die Befehlspalette ausführen kannst. Ohne diesen Eintrag wäre die Vorlage nur über das Templater‑Icon in der Seitenleiste aufrufbar.

Nun öffne eine Notiz und führe über die Befehls‑Palette den Befehl Templater: Insert eigenschaften_hinzufügen aus. Das Frontmatter der aktiven Notiz wird daraufhin direkt um die neuen Eigenschaften ergänzt.

#Zusammenfassung und Ausblick

In diesem Kapitel hast du die Erweiterung „Tägliche Notizen“ kennengelernt. Wie du spezielle Vorlagen erstellst und diese mit Daten aus deinem Vault, aber auch mit externen erweitern kannst. Zuletzt hast du einen ersten Eindruck gewinnen können, wie du mit etwas JavaScript Arbeitsschritte vereinfachen kannst.

Das nächste Kapitel ist ein kurzer Einschub und gibt eine Einführung in die Obsidian‑Erweiterung „Bases“. Die Obsidian‑Version 1.9.10, mit der „Bases“ eingeführt wurde, wurde gerade veröffentlicht, als dieses Kapitel entstand.

Also: stay tuned and no panic — just markdown!