hatpep

JSON in FileMaker

Datenstrukturen effizient verarbeiten

Ein praktischer Leitfaden zur Verwendung von JSON in FileMaker, von grundlegenden Funktionen bis zu fortgeschrittenen Anwendungsfällen.

2. Mai 2025
„Daten sind das neue Öl. Aber wie Öl müssen sie erst raffiniert werden, um wertvoll zu sein."
— Clive Humby

Seit FileMaker 16 hat Claris die JSON-Unterstützung kontinuierlich erweitert, und mit FileMaker 2024 wurden weitere Verbesserungen eingeführt. JSON ist heute ein unverzichtbares Werkzeug für die Integration mit Web-APIs, die Speicherung komplexer Datenstrukturen und die effiziente Datenverarbeitung in FileMaker. In diesem Artikel werfen wir einen tiefen Blick auf die JSON-Funktionalität in FileMaker und zeigen praktische Anwendungsfälle.

Grundlegende JSON-Funktionen in FileMaker ​

FileMaker bietet eine umfangreiche Palette von JSON-Funktionen, die es ermöglichen, JSON-Daten zu erstellen, zu parsen, zu manipulieren und zu extrahieren. Hier sind die wichtigsten Funktionen:

JSON erstellen ​

filemaker
# Einfaches JSON-Objekt erstellen
JSONSetElement ( "" ; "name" ; "Max Mustermann" ; "age" ; 30 )

# Ergebnis: {"name":"Max Mustermann","age":30}

# JSON-Array erstellen
JSONSetElement ( "" ; "users[0].name" ; "Max Mustermann" ; "users[0].age" ; 30 ; "users[1].name" ; "Anna Schmidt" ; "users[1].age" ; 25 )

# Ergebnis: {"users":[{"name":"Max Mustermann","age":30},{"name":"Anna Schmidt","age":25}]}

Mit FileMaker 2024 wurde die neue Funktion JSONMakeArray eingeführt, die das Erstellen von Arrays vereinfacht:

filemaker
# Array aus einer Liste erstellen
JSONMakeArray ( "1;2;3" ; ";" ; JSONNumber )

# Ergebnis: [1,2,3]

JSON parsen und extrahieren ​

filemaker
# Wert aus JSON extrahieren
JSONGetElement ( $json ; "users[0].name" )

# Typ eines JSON-Elements prüfen
JSONGetType ( $json ; "users[0].age" )  # Gibt "number" zurück

# Anzahl der Elemente in einem Array ermitteln
JSONListKeys ( $json ; "users" )  # Gibt "0¶1" zurück (wenn 2 Elemente vorhanden sind)

JSON manipulieren ​

filemaker
# Element hinzufügen oder aktualisieren
JSONSetElement ( $json ; "users[2].name" ; "Lisa Meyer" ; "users[2].age" ; 28 )

# Element entfernen
JSONDeleteElement ( $json ; "users[1]" )

# JSON formatieren (mit Einrückungen)
JSONFormatElements ( $json )

Fortgeschrittene JSON-Techniken ​

Rekursive JSON-Verarbeitung ​

Für komplexe JSON-Strukturen ist eine rekursive Verarbeitung oft notwendig. Hier ein Beispiel für eine benutzerdefinierte Funktion, die alle Werte in einem JSON-Objekt durchsucht:

filemaker
# Funktion: FindInJSON
# Parameter: $json (Text), $searchValue (Text)
# Rückgabe: Pfad zum gefundenen Element oder leer, wenn nicht gefunden

If ( IsEmpty ( $json ) or IsEmpty ( $searchValue ) )
    Exit Script [ Text Result: "" ]
End If

# Prüfen, ob es sich um ein Objekt oder Array handelt
Set Variable [ $type ; Value: JSONGetType ( $json ; "" ) ]

If ( $type = "object" )
    # Alle Schlüssel des Objekts durchgehen
    Set Variable [ $keys ; Value: JSONListKeys ( $json ; "" ) ]
    
    Loop
        Exit Loop If [ IsEmpty ( $keys ) ]
        
        Set Variable [ $key ; Value: GetValue ( $keys ; 1 ) ]
        Set Variable [ $keys ; Value: RightValues ( $keys ; ValueCount ( $keys ) - 1 ) ]
        
        # Wert des aktuellen Schlüssels prüfen
        Set Variable [ $value ; Value: JSONGetElement ( $json ; $key ) ]
        
        If ( $value = $searchValue )
            Exit Script [ Text Result: $key ]
        End If
        
        # Rekursiv in verschachtelten Objekten suchen
        Set Variable [ $nestedType ; Value: JSONGetType ( $json ; $key ) ]
        
        If ( $nestedType = "object" or $nestedType = "array" )
            Set Variable [ $nestedPath ; Value: FindInJSON ( JSONGetElement ( $json ; $key ) ; $searchValue ) ]
            
            If ( not IsEmpty ( $nestedPath ) )
                Exit Script [ Text Result: $key & "." & $nestedPath ]
            End If
        End If
    End Loop
Else If ( $type = "array" )
    # Array-Elemente durchgehen
    Set Variable [ $count ; Value: ValueCount ( JSONListKeys ( $json ; "" ) ) ]
    
    Loop
        Exit Loop If [ $count ≤ 0 ]
        
        Set Variable [ $index ; Value: $count - 1 ]
        Set Variable [ $value ; Value: JSONGetElement ( $json ; "[" & $index & "]" ) ]
        
        If ( $value = $searchValue )
            Exit Script [ Text Result: "[" & $index & "]" ]
        End If
        
        # Rekursiv in verschachtelten Objekten suchen
        Set Variable [ $nestedType ; Value: JSONGetType ( $json ; "[" & $index & "]" ) ]
        
        If ( $nestedType = "object" or $nestedType = "array" )
            Set Variable [ $nestedPath ; Value: FindInJSON ( JSONGetElement ( $json ; "[" & $index & "]" ) ; $searchValue ) ]
            
            If ( not IsEmpty ( $nestedPath ) )
                Exit Script [ Text Result: "[" & $index & "]" & $nestedPath ]
            End If
        End If
        
        Set Variable [ $count ; Value: $count - 1 ]
    End Loop
End If

Exit Script [ Text Result: "" ]

JSON und Datenbankintegration ​

JSON kann als Zwischenformat für die Integration mit externen Datenbanken oder APIs verwendet werden. Hier ein Beispiel für die Konvertierung von FileMaker-Daten in JSON für eine API-Anfrage:

filemaker
# Funktion: RecordsToJSON
# Parameter: $tableName (Text), $fieldList (Text), $query (Text)
# Rückgabe: JSON-String mit den Ergebnissen

Set Variable [ $json ; Value: "{" ]
Set Variable [ $json ; Value: $json & "\"records\":[" ]

# Abfrage ausführen
Perform Find [ Restore ]
Set Variable [ $recordCount ; Value: Get ( FoundCount ) ]

If ( $recordCount > 0 )
    Go to Record/Request/Page [ First ]
    
    Loop
        Exit Loop If [ Get ( RecordNumber ) > $recordCount ]
        
        # Komma zwischen Einträgen einfügen (außer beim ersten)
        If ( Get ( RecordNumber ) > 1 )
            Set Variable [ $json ; Value: $json & "," ]
        End If
        
        # JSON-Objekt für aktuellen Datensatz erstellen
        Set Variable [ $json ; Value: $json & "{" ]
        
        # Felder durchgehen
        Set Variable [ $fields ; Value: $fieldList ]
        
        Loop
            Exit Loop If [ IsEmpty ( $fields ) ]
            
            Set Variable [ $fieldName ; Value: GetValue ( $fields ; 1 ) ]
            Set Variable [ $fields ; Value: RightValues ( $fields ; ValueCount ( $fields ) - 1 ) ]
            
            # Komma zwischen Feldern einfügen (außer beim ersten)
            If ( $json ≠ "{" and Right ( $json ; 1 ) ≠ "{" )
                Set Variable [ $json ; Value: $json & "," ]
            End If
            
            # Feldwert hinzufügen
            Set Variable [ $fieldValue ; Value: GetField ( $tableName & "::" & $fieldName ) ]
            
            # Typ des Feldwerts prüfen und entsprechend formatieren
            If ( IsNumeric ( $fieldValue ) )
                Set Variable [ $json ; Value: $json & "\"" & $fieldName & "\":" & $fieldValue ]
            Else
                Set Variable [ $json ; Value: $json & "\"" & $fieldName & "\":\"" & $fieldValue & "\"" ]
            End If
        End Loop
        
        Set Variable [ $json ; Value: $json & "}" ]
        
        Go to Record/Request/Page [ Next ; Exit after last ]
    End Loop
End If

Set Variable [ $json ; Value: $json & "]" ]
Set Variable [ $json ; Value: $json & "}" ]

Exit Script [ Text Result: $json ]

Praktische Anwendungsfälle ​

API-Integration ​

JSON ist das Standardformat für die meisten Web-APIs. Hier ein Beispiel für eine Funktion, die Daten von einer REST-API abruft und verarbeitet:

filemaker
# Funktion: GetWeatherData
# Parameter: $city (Text), $apiKey (Text)
# Rückgabe: Wetterdaten als JSON

# API-URL erstellen
Set Variable [ $url ; Value: "https://api.weatherapi.com/v1/current.json?key=" & $apiKey & "&q=" & $city ]

# HTTP-Anfrage senden
Insert From URL [ Select ; With dialog: Off ; $url ; $result ; $headers ; $statusCode ]

# Antwort prüfen
If ( $statusCode = 200 )
    # JSON parsen und zurückgeben
    Exit Script [ Text Result: $result ]
Else
    # Fehlerbehandlung
    Exit Script [ Text Result: "{\"error\":\"API-Fehler: " & $statusCode & "\"}" ]
End If

Komplexe Datenstrukturen speichern ​

JSON eignet sich hervorragend für die Speicherung komplexer Datenstrukturen in einem einzelnen Feld. Hier ein Beispiel für eine Konfigurationsstruktur:

filemaker
# Konfigurations-JSON erstellen
Set Variable [ $config ; Value: "{" ]
Set Variable [ $config ; Value: $config & "\"theme\":{" ]
Set Variable [ $config ; Value: $config & "\"primaryColor\":\"#3498db\"," ]
Set Variable [ $config ; Value: $config & "\"secondaryColor\":\"#2ecc71\"," ]
Set Variable [ $config ; Value: $config & "\"fontFamily\":\"Arial\"" ]
Set Variable [ $config ; Value: $config & "}," ]
Set Variable [ $config ; Value: $config & "\"notifications\":{" ]
Set Variable [ $config ; Value: $config & "\"email\":true," ]
Set Variable [ $config ; Value: $config & "\"push\":false," ]
Set Variable [ $config ; Value: $config & "\"frequency\":\"daily\"" ]
Set Variable [ $config ; Value: $config & "}" ]
Set Variable [ $config ; Value: $config & "}" ]

# In Datenbankfeld speichern
Set Field [ Users::Config ; $config ]

Datenimport und -export ​

JSON kann als Zwischenformat für den Import und Export von Daten verwendet werden. Hier ein Beispiel für den Export von Daten in eine JSON-Datei:

filemaker
# Funktion: ExportToJSON
# Parameter: $tableName (Text), $fieldList (Text), $filePath (Text)
# Rückgabe: Erfolg oder Fehler

# JSON-Daten generieren
Set Variable [ $json ; Value: RecordsToJSON ( $tableName ; $fieldList ; "" ) ]

# Datei speichern
Set Variable [ $fileRef ; Value: Open Data File [ $filePath ; Create new file ] ]

If ( Get ( LastError ) = 0 )
    Write to Data File [ $fileRef ; $json ]
    Close Data File [ $fileRef ]
    Exit Script [ Text Result: "Erfolg" ]
Else
    Exit Script [ Text Result: "Fehler: " & Get ( LastError ) ]
End If

Best Practices und Tipps ​

Fehlerbehandlung ​

Stelle sicher, dass du JSON-Daten validierst, bevor du sie verarbeitest:

filemaker
# Funktion: IsValidJSON
# Parameter: $json (Text)
# Rückgabe: true oder false

# Versuche, das JSON zu parsen
Set Variable [ $test ; Value: JSONGetElement ( $json ; "" ) ]

# Wenn kein Fehler auftritt, ist es gültiges JSON
Exit Script [ Text Result: Get ( LastError ) = 0 ]

Performance-Optimierung ​

Bei großen JSON-Strukturen kann die Verarbeitung langsam sein. Hier einige Tipps:

  1. Caching: Speichere häufig verwendete JSON-Daten in Variablen, anstatt sie bei jedem Zugriff neu zu generieren.
  2. Selektive Verarbeitung: Verarbeite nur die benötigten Teile eines JSON-Objekts.
  3. Indexierung: Verwende JSONListKeys und JSONGetElement mit präzisen Pfaden, anstatt große Teile des JSON zu durchsuchen.

Sicherheit ​

Beim Umgang mit JSON-Daten von externen Quellen solltest du immer vorsichtig sein:

  1. Validierung: Überprüfe JSON-Daten auf Gültigkeit, bevor du sie verarbeitest.
  2. Sanitization: Bereinige JSON-Daten, bevor du sie in deine Datenbank einfügst oder an Benutzer zurückgibst.
  3. Berechtigungen: Stelle sicher, dass nur autorisierte Benutzer JSON-Daten importieren oder exportieren können.

Fazit ​

JSON ist ein leistungsfähiges Werkzeug in FileMaker, das die Integration mit externen Systemen, die Speicherung komplexer Datenstrukturen und die effiziente Datenverarbeitung ermöglicht. Mit den kontinuierlichen Verbesserungen in FileMaker, insbesondere der neuen JSONMakeArray-Funktion in FileMaker 2024, wird die Arbeit mit JSON noch einfacher und flexibler.

Back to Blog