> For the complete documentation index, see [llms.txt](https://docs.ninox.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.ninox.com/ninox-scripting/de/automate-your-workflows/work-with-functions/files-and-export.md).

# Dateien und Export

Dateien helfen dir, Daten in Ninox zu importieren und aus Ninox zu exportieren. Du kannst Anhänge importieren, Text- oder Tabellenexporte erstellen, Dateien bündeln, Links erzeugen und steuern, wer auf geteilte Dateien und Ansichten zugreifen kann. Dieses Kapitel zeigt dir die wichtigsten Dateifunktionen für typische Automatisierungs- und Berichtsaufgaben.

<table><thead><tr><th width="214.921875">Funktion (A-Z)</th><th>Aufgabe</th></tr></thead><tbody><tr><td><code>appendTempFile()</code></td><td>Fügt Inhalte zu einer temporären Datei hinzu</td></tr><tr><td><code>createTempFile()</code></td><td>Erstellt eine temporäre Datei, für 24 h über einen Link abrufbar</td></tr><tr><td><code>createTextFile()</code></td><td>Erstellt eine einfache Textdatei</td></tr><tr><td><code>createXLSX()</code></td><td>Exportiert Daten in eine XLSX-Datei</td></tr><tr><td><code>createZipFile()</code></td><td>Bündelt mehrere Dateien in ein ZIP-Archiv</td></tr><tr><td><code>file()</code></td><td>Gibt eine einzelne Dateireferenz zurück</td></tr><tr><td><code>fileMetadata()</code></td><td>Gibt die Metadaten einer Datei zurück</td></tr><tr><td><code>files()</code></td><td>Gibt mehrere Dateireferenzen zurück</td></tr><tr><td><code>fileUrl()</code></td><td>Gibt einen URL-Link zum Anhang eines Datensatzes zurück</td></tr><tr><td><code>importFile()</code></td><td>Importiert eine Datei in einen Ninox-Datensatz</td></tr><tr><td><code>loadFileAsBase64()</code></td><td>Gibt den Dateiinhalt als Base64-String zurück</td></tr><tr><td><code>loadFileAsBase64URL()</code></td><td>Gibt den Dateiinhalt als Base64-Daten-URL zurück</td></tr><tr><td><code>printAndSaveRecord()</code></td><td>Erstellt ein PDF aus einem Datensatz und gibt den Link zu dieser Datei zurück</td></tr><tr><td><code>removeFile()</code></td><td>Entfernt eine Datei</td></tr><tr><td><code>renameFile()</code></td><td>Benennt eine Datei um</td></tr><tr><td><code>urlOf()</code></td><td>Gibt die URL eines Datensatzes zurück</td></tr></tbody></table>

## Dateien importieren, erstellen und verarbeiten

Nutze diese Funktionen, wenn du eine Datei nach Ninox bringen, Ausgaben erzeugen oder mit einem oder mehreren Dateiobjekten in einem Skript arbeiten willst.

### Eine Datei mit `importFile()` importieren <a href="#import-a-file-with-importfile" id="import-a-file-with-importfile"></a>

Nutze `importFile()`, um eine Datei in Ninox zu importieren, wenn der Dateiimport unterstützt wird.

Nutze die Funktion, wenn du:

* externe Inhalte zu einem Workflow hinzufügen willst.
* eine Quelldatei vor der weiteren Verarbeitung nach Ninox verschieben willst.
* eine Datei über eine URL an einen Datensatz anhängen willst.
* erzeugte Dateiausgaben in einem Dateifeld speichern willst.

`importFile(nid, string)`\
`importFile(nid, link)`\
`importFile(nid, string, string)`\
`importFile(nid, link, string)`

* `nid` Zieldatensatz
* `string` oder `link` (zweites Argument des Datensatzformulars): Quell-URL oder der Dateilink
* `string` (optionales drittes Argument des Datensatzformulars): Dateiname zum Speichern

`importFile()` gibt ein Dateiobjekt zurück.

#### Schauen wir uns ein Beispiel an:

```ninox
importFile(
    this, 
    "https://ninox.com/beispiel.jpg", 
    "Bild-" + format(today(), "YYYY-MM-DD") + ".jpg")
```

Importiert die Datei von der URL und hängt sie als "Bild-2026-07-28.jpg" mit dem Datum des Imports an den aktuellen Datensatz an.

{% hint style="warning" %}
Nutze für Dateinamen nur zulässige Zeichen. Schrägstriche `/` sind nicht erlaubt.\
Zum Beispiel muss der Wert von `today()`, wenn dieser `08/23/2026` erzeugt, mit der Funktion `format()` wie im Beispiel oben geändert werden. Andernfalls schlägt die PDF-Erstellung fehl.
{% endhint %}

### Erstelle und speichere ein PDF aus einem Datensatz mit `printAndSaveRecord()` <a href="#create-and-save-a-pdf-from-a-record-with-printandsaverecord" id="create-and-save-a-pdf-from-a-record-with-printandsaverecord"></a>

Nutze `printAndSaveRecord()`, um mit einem Drucklayout aus einem Datensatz ein PDF zu erzeugen, es in Ninox zu speichern und einen Download-Link zurückzugeben.

Nutze die Funktion, wenn du:

* eine Dateiversion eines gedruckten Dokuments speichern möchtest.
* Drucken und Dateiausgabe in einem Schritt verbinden möchtest.
* den zurückgegebenen Link zur Datei nutzen möchtest, um die Datei als Anhang zu importieren.

`printAndSaveRecord(nid, string)`

* `nid` der Datensatz, den du drucken möchtest
* `string` der Name des Drucklayouts

`printAndSaveRecord()` gibt einen Download-Link zur gespeicherten PDF-Datei zurück.

{% hint style="info" %}
`printAndSaveRecord()` läuft nur auf dem Server. Führe die Funktion in einem `do as server ... end`-Block aus.
{% endhint %}

#### Schauen wir uns einige Beispiele an:

```ninox
do as server 
printAndSaveRecord(this, "Rechnung")
end
```

Erzeugt ein PDF für den aktuellen Datensatz aus dem Drucklayout "Rechnung" und gibt einen Link zur gespeicherten Datei zurück.

Kombiniere `printAndSaveRecord()` mit `importFile()`, um die Datei zu importieren, an den aktuellen Datensatz anzuhängen und im Feld "Rechnung PDF" anzuzeigen.

```
do as server
rechnung_pdf := importFile(
                this, 
                printAndSaveRecord(this, "Rechnungslayout"), 
                rechnungsnummer + ".pdf")
end
```

Druckt den aktuellen Datensatz mit dem Layout "Rechnungslayout". Das PDF wird im Dateifeld "Rechnung PDF" gespeichert. Der Dateiname kombiniert den Wert aus dem Feld "Rechnungsnummer" mit dem Text ".pdf".

Tipps:

* Nutze eindeutige Layoutnamen, damit Skripte lesbar bleiben.
* Kombiniere Drucklayouts mit `format()` für sauber formatierte Zahlen und Daten.
* Übergib `importFile()` einen Dateinamen, wenn die Quell-URL keinen passenden Namen liefert.
* Du kannst `importFile()` mit generierten Dateilinks verwenden, nicht nur mit externen URLs.

### Dateien mit `createTextFile()` erstellen <a href="#build-files-with-createtextfile" id="build-files-with-createtextfile"></a>

Nutze `createTextFile()`, wenn du den fertigen Inhalt bereits hast und sofort eine Datei erzeugen willst.

`createTextFile(nid, string, string)`\
`createTextFile(nid, string, string, any)`

* `nid` Zieldatensatz
* `string` (zweites Argument) Dateiinhalt
* `string` (drittes Argument) Dateiname
* `any` Optionen wie `{ encoding: "utf8" }`. Folgende Kodierungen sind verfügbar:
  * `utf8`
  * `utf16le`
  * `latin1`
  * `base64`
  * `base64url`
  * `hex`
  * `ascii`

#### Schauen wir uns einige Beispiele an:

```ninox
let myFile := createTextFile(this, "Hallo", "Notiz.txt");
myFile
```

Erstellt eine Textdatei mit dem Namen "Notiz.txt" und dem Inhalt "Hallo".

```ninox
let myFile := createTextFile(this, text(rich_text), "Meine-Beispieldatei.txt");
myFile
```

Erstellt eine Textdatei aus dem sichtbaren Textinhalt des Rich-Text-Felds.

```ninox
let myFile := createTextFile(this, raw(rich_text), "Mein-HTML-Beispiel.html");
myFile
```

Erstellt eine HTML-Datei aus dem Rohinhalt des Rich-Text-Felds.

<pre class="language-ninox"><code class="lang-ninox">do as server 
    createTextFile(this,raw(rich_text),"Mein-UTF8-Beispiel.html",{
        encoding: "utf8"
    })
<strong>end
</strong></code></pre>

Erstellt die Datei mit expliziter UTF-8-Kodierung.

Tipps:

* Du kannst jeden Dateinamen und jede Endung wählen, zum Beispiel `.txt`, `.csv` oder `.html`.
* Wenn du die zurückgegebene Datei nicht an anderer Stelle speicherst, zum Beispiel in einem Dateifeld, hängt Ninox sie an den Datensatz an.

{% hint style="info" %}
Die Option `encoding` ist nur im Server-Kontext verfügbar. Führe `createTextFile()` daher in `do as server ... end` aus, wenn du die Option `encoding` verwendest.
{% endhint %}

### Dateien mit `createTempFile()` erstellen und mit `appendTempFile()` Inhalte anhängen <a href="#create-files-and-append-content-with-createtempfile-and-appendtempfile" id="create-files-and-append-content-with-createtempfile-and-appendtempfile"></a>

`appendTempFile()` fügt einer temporären Datei auf dem Ninox-Server Inhalte hinzu. Verwende dafür den Link, den `createTempFile()` zurückgibt.

Nutze die Funktionen, wenn du:

* große Exporte in mehreren Schritten erstellen willst.
* Protokolle oder Berichtszeilen nacheinander schreiben willst.
* einen Textanhang zum Herunterladen oder Teilen erzeugen willst.

`createTempFile(string, string)`

* `string` (erstes Argument) Anfangsinhalt der temporären Datei
* `string` (zweites Argument) Dateiname der temporären Datei

`createTempFile()` gibt einen Link zur temporären Datei zurück.

{% hint style="warning" %}
Da die Datei temporär ist, wird sie nach 24 Stunden automatisch gelöscht.
{% endhint %}

`appendTempFile(link, string)`\
`appendTempFile(string, string)`

* `link` oder `string` (erstes Argument) Link zur temporären Datei, den `createTempFile()` zurückgibt
* `string` (zweites Argument) anzuhängender Inhaltsabschnitt

#### Schauen wir uns einige Beispiele an:

```ninox
do as server
	let myKopfzeile := "Name,E-Mail
	";
	url_feld := createTempFile(myKopfzeile, "Export.csv");
end
```

Erstellt eine temporäre CSV-Datei mit einer Kopfzeile. Speichert den Dateilink im „URL-Feld“ des aktuellen Datensatzes.

```ninox
do as server
	let myZeilenumbruch := "
";
	for myK in select kontakte do
		let myZeile := myK.name + "," + myK.email + myZeilenumbruch;
		appendTempFile(url_feld, myZeile)
	end
end
```

Fügt der temporären CSV-Datei für jeden Kontakt eine Zeile hinzu. Das „URL-Feld“ im aktuellen Datensatz verweist auf die Datei.

```ninox
do as server
	let myZeilenumbruch := "
";
	let myKopfzeile := "Name,email" + myZeilenumbruch;
	url_feld := createTempFile(myKopfzeile, "Export.csv");
	for myK in select kontakte do
		let myZeile := myK.name + "," + myK.email + myZeilenumbruch;
		appendTempFile(url_feld, myZeile)
	end
end
```

Erstellt eine temporäre CSV-Datei, schreibt die Kopfzeile und fügt in einem Skript für jeden Kontakt eine Zeile hinzu.

Tipps:

* Nutze eine temporäre Datei, wenn du Inhalte innerhalb kurzer Zeit (24 h) zusammenstellst. Die temporäre Datei wird nach 24 Stunden automatisch gelöscht.
* `createTempFile()` erstellt die Datei nur, wenn der Anfangsinhalt nicht leer ist.
* Die temporäre Datei muss noch vorhanden sein, wenn `appendTempFile()` ausgeführt wird.
* `appendTempFile()` eignet sich für große oder lang laufende Exporte.

{% hint style="info" %}
Beide Funktionen müssen auf dem Server ausgeführt werden. Führe sie in einem `do as server ... end`-Block aus.
{% endhint %}

### Daten mit `createXLSX()` exportieren <a href="#export-data-with-createxlsx" id="export-data-with-createxlsx"></a>

Nutze `createXLSX()`, um direkt aus deiner App dynamische und formatierte Excel-Dateien mit mehreren Arbeitsblättern zu erstellen.

Nutze die Funktion, wenn du:

* bestimmte Datensätze an einen Nutzer senden willst.
* formatierte Excel-Dateien mit eigenen Spalten und Zeilen erstellen willst.
* Exporte mit mehreren Arbeitsblättern für Berichts- oder Übergabe-Workflows erstellen willst.

Die erzeugte Datei wird direkt in Ninox gespeichert und bietet dir flexible Optionen für Datenaufbereitung und Formatierung.

\
`createXLSX(nid, any, string)`

* `nid` Zieldatensatz, in dem die Datei gespeichert werden soll
* `any` Definition der Arbeitsmappe oder des Arbeitsblatts
* `string` Dateiname für den XLSX-Export

`createXLSX()` gibt ein Dateiobjekt zurück.

#### Schauen wir uns einige Beispiele an:

Wegen der Komplexität dieser Funktion teilen wir die Beispiele in folgende Schritte auf:

1. Definiere die Spalten und Zeilen.
2. Definiere die Arbeitsblattstruktur.
3. Nutze die Funktion `createXLSX`.
4. Definiere optional Stile und Formatierungen.

#### **Spalten und Zeilen definieren** <a href="#define-columns-and-rows" id="define-columns-and-rows"></a>

Erstelle zuerst ein Objekt, das die Spalten definiert:

```json
let columns := [
    {
        header: "Name",
        key: "name",
        width: 10,
    },
    {
        header: "Age",
        key: "age",
        width: 10
    },
    {
        header: "URL",
        key: "url",
        width: 30
    },
    {
        header: "Description",
        key: "description",
        width: 20
    }
];
```

Definiere danach die Zeilen. Bei Bedarf kannst du unterstützte Spezialfelder verwenden. Mehr dazu findest du weiter unten:

```json
let rows := [
{
name: "Luis Gómez",
age: 30,
url: {
text: "www.google.com",
hyperlink: "http://www.google.com",
tooltip: "www.google.com"
}
},
{
name: "Maria Silva",
age: 25,
url: {
text: "www.google.com",
hyperlink: "http://www.google.com",
tooltip: "www.google.com"
}
},
{
name: "Ayesha Khan",
age: 35,
url: {
text: "www.google.com",
hyperlink: "http://www.google.com",
tooltip: "www.google.com"
}
},
{
name: "Li Wei",
age: 40,
url: {
text: "www.google.com",
hyperlink: "http://www.google.com",
tooltip: "www.google.com"
}
},
{
name: "Rajesh Kumar",
age: 21,
url: {
text: "www.google.com",
hyperlink: "http://www.google.com",
tooltip: "www.google.com"
}
},
{
name: "Sofia Müller",
age: 24,
url: {
text: "www.google.com",
hyperlink: "http://www.google.com",
tooltip: "www.google.com"
}
}
];
```

#### Arbeitsblattstruktur definieren <a href="#define-worksheet-structure" id="define-worksheet-structure"></a>

Definiere ein Arbeitsblatt mit Spalten und Zeilen:

```json
let worksheets := {
Sheet1: {
columns: columns,
rows: rows
}
};
```

#### `createXLSX` verwenden <a href="#use-createxlsx" id="use-createxlsx"></a>

Rufe die Funktion `createXLSX` mit den definierten Arbeitsblättern auf:

```json
my_file_field := createXLSX(this, worksheets, "Beispiel.xlsx")
```

Speichert die erstellte Datei im Tab <i class="fa-paperclip-vertical">:paperclip-vertical:</i> **Dateien** des aktuellen Datensatzes und schreibt sie in ein Dateifeld deiner Formularansicht.

```json
createXLSX(this, worksheets, "Beispiel.xlsx")
```

Speichert die Datei nur im Tab <i class="fa-paperclip-vertical">:paperclip-vertical:</i> **Dateien** des aktuellen Datensatzes.

#### Stile und Formatierungen optional definieren <a href="#define-styles-and-formatting-optional" id="define-styles-and-formatting-optional"></a>

Wende einen Stil auf eine Kopfzelle an:

```json
let columns := [{
    header: "Name",
    key: "name",
    width: 10,
    headerStyle: {
        font: {
            bold: true
        }
    }
}];
```

Wende einen Stil auf eine ganze Spalte außer der Kopfzeile an:

```json
let columns := [{
			header: "Name",
			key: "name",
			width: 10,
			style: {
				font: {
					name: "Comic Sans MS"
				}
			}
		}]
```

Wende einen Stil auf eine ganze Zeile an:

```json
let rows := [
{
name: "Luis Gómez",
age: 30,
url: {
text: "www.google.com",
hyperlink: "http://www.google.com",
tooltip: "www.google.com"
},
			styles: [{
					fill: {
						type: "pattern",
						pattern: "solid",
						fgColor: {
							argb: "F08080"
						}
					}
				}]]
}
];
```

Wende einen Stil auf bestimmte Zellen in einer Zeile an:

```json
let rows := [
{
name: "Luis Gómez",
age: 30,
url: {
text: "www.google.com",
hyperlink: "http://www.google.com",
tooltip: "www.google.com"
},
styles: [
{
targets: ["name", "age"],
fill: {
type: "pattern",
pattern: "solid",
fgColor: {
argb: "F08080"
}
}
}
]
}
];
```

Wenn du das Skript gespeichert hast, klicke auf die Schaltfläche, um eine Excel-Datei zu erstellen.

#### Unterstützte Stil- und Formatierungsoptionen <a href="#supported-styles-and-formatting-options" id="supported-styles-and-formatting-options"></a>

**Schriftart**

```json
{
  font: {
    name: "Arial Black",
    color: { argb: "FF00FF00" },
    family: 2,
    size: 14,
    italic: true,
    underline: true,
    bold: true
  }
}
```

**Optionen für Schriftarten**

<table data-search="false"><thead><tr><th width="134.85546875">Schriftart-Eigenschaft</th><th>Beschreibung</th><th>Beispielwert(e)</th></tr></thead><tbody><tr><td>name</td><td>Gibt den Namen der Schriftart an.</td><td>"Arial"<br>"Calibri"<br>usw.</td></tr><tr><td>family</td><td>Gibt die Schriftfamilie für Fallbacks als ganze Zahl an.</td><td>1 - Serif<br>2 - Sans Serif<br>3 - Mon<br>Weitere - unbekannt</td></tr><tr><td>scheme</td><td>Gibt das Schriftartschema an.</td><td>"minor"<br>"major"<br>"none"</td></tr><tr><td>charset</td><td>Gibt den Zeichensatz der Schriftart als ganze Zahl an.</td><td>1<br>2<br>usw.</td></tr><tr><td>size</td><td>Gibt die Schriftgröße als ganze Zahl an.</td><td>9<br>10<br>12<br>16<br>usw.</td></tr><tr><td>color</td><td>Gibt die Schriftfarbe als ARGB-Objekt an.</td><td>{ argb: "FFFF0000" }</td></tr><tr><td>bold</td><td>Gibt an, ob die Schrift fett ist.</td><td>true<br>false</td></tr><tr><td>italic</td><td>Gibt an, ob die Schrift kursiv ist.</td><td>true<br>false</td></tr><tr><td>underline</td><td>Gibt den Unterstreichungsstil der Schrift an.</td><td>true<br>false<br>"none"<br>"single"<br>"double"<br>"singleAccounting"<br>"doubleAccounting"</td></tr><tr><td>strike</td><td>Gibt an, ob die Schrift durchgestrichen ist.</td><td>true<br>false</td></tr><tr><td>outline</td><td>Gibt an, ob die Schrift eine Kontur hat.</td><td>true<br>false</td></tr><tr><td>vertAlign</td><td>Gibt die vertikale Ausrichtung der Schrift an.</td><td>"superscript"<br>"subscript"</td></tr></tbody></table>

**Ausrichtung**

```json
{ alignment: { vertical: "top", horizontal: "left" }
```

**Optionen für Ausrichtung**

<table data-search="false"><thead><tr><th width="162.87890625">horizontal</th><th width="106.08203125">vertical</th><th width="81.1484375">wrapText</th><th width="89.84375">shrinkToFit</th><th width="90.4609375">indent</th><th width="106.26171875">readingOrder</th><th width="105.7734375">Textdrehung</th></tr></thead><tbody><tr><td>left</td><td>top</td><td>true</td><td>true</td><td>integer</td><td>rtl</td><td>0 bis 90</td></tr><tr><td>center</td><td>middle</td><td>false</td><td>false</td><td></td><td>ltr</td><td>-1 bis -90</td></tr><tr><td>right</td><td>bottom</td><td></td><td></td><td></td><td></td><td>vertical</td></tr><tr><td>fill</td><td>distributed</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>justify</td><td>justify</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>centerContinuous</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>distributed</td><td></td><td></td><td></td><td></td><td></td><td></td></tr></tbody></table>

**Rahmen**

```json
// lege einen einfachen dünnen Rahmen fest
{
  border: {
    top: { style: "thin" },
    left: { style: "thin" },
    bottom: { style: "thin" },
    right: { style: "thin" }
  }
}

// lege einen doppelten, dünnen, grünen Rahmen fest
{
  border: {
    top: { style: "double", color: { argb: "FF00FF00" } },
    left: { style: "double", color: { argb: "FF00FF00" } },
    bottom: { style: "double", color: { argb: "FF00FF00" } },
    right: { style: "double", color: { argb: "FF00FF00" } }
  }
}

// setze ein diagonales Kreuz mit dicken roten Linien
{
  border: {
    diagonal: { up: true, down: true, style: "thick", color: { argb: "FFFF0000" } }
  }
}
```

**Gültige Rahmenstile**

{% columns %}
{% column width="25%" %}

* thin
* dotted
* dashDot
* hair
  {% endcolumn %}

{% column width="33.333333333333336%" %}

* dashDotDot
* slantDashDot
* mediumDashed
* mediumDashDotDot
  {% endcolumn %}

{% column width="41.666666666666664%" %}

* mediumDashDot
* medium
* double
* thick
  {% endcolumn %}
  {% endcolumns %}

**Musterfüllung**

```json
// mit senkrechten dunkelroten Streifen ausfüllen
{
  fill: {
    type: "pattern",
    pattern: "darkVertical",
    fgColor: { argb: "FFFF0000" }
  }
}

// mit einem dunkelgelben Gitter und Blau im Hintergrund ausfüllen
{
  fill: {
    type: "pattern",
    pattern: "darkTrellis",
    fgColor: { argb: "FFFFFF00" },
    bgColor: { argb: "FF0000FF" }
  }
}

// durchgehend in Korall ausfüllen
{
  fill: {
    type: "pattern",
    pattern: "solid",
    fgColor: { argb: "F08080" }
  }
}

// mit einem Blau-Weiß-Blau-Verlauf von links nach rechts füllen
{
  fill: {
    type: "gradient",
    gradient: "angle",
    degree: 0,
    stops: [
      { position: 0, color: { argb: "FF0000FF" } },
      { position: 0.5, color: { argb: "FFFFFFFF" } },
      { position: 1, color: { argb: "FF0000FF" } }
    ]
  }
}

// mit Rot-Grün-Verlauf von der Mitte aus füllen
{
  fill: {
    type: "gradient",
    gradient: "path",
    center: { left: 0.5, top: 0.5 },
    stops: [
      { position: 0, color: { argb: "FFFF0000" } },
      { position: 1, color: { argb: "FF00FF00" } }
    ]
  }
}
```

**Optionen für Musterfüllung**

<table><thead><tr><th width="130.734375">Eigenschaft</th><th width="134.16796875">Erforderlich</th><th>Beschreibung</th></tr></thead><tbody><tr><td>type</td><td>Ja</td><td>Gibt an, dass diese Füllung ein Muster verwendet.</td></tr><tr><td>pattern</td><td>Ja</td><td>Gibt den Mustertyp an.<br>Siehe <strong>Gültige Mustertypen</strong> nach dieser Tabelle.</td></tr><tr><td>fgColor</td><td>Nein</td><td>Gibt die Vordergrundfarbe des Musters an.<br>Die Standardfarbe ist Schwarz.</td></tr><tr><td>bgColor</td><td>Nein</td><td>Gibt die Hintergrundfarbe des Musters an.<br>Die Standardfarbe ist Weiß.</td></tr></tbody></table>

{% hint style="info" %}
Um eine Zelle mit dem Muster `solid` zu füllen, musst du `bgColor` nicht angeben.
{% endhint %}

**Gültige Mustertypen**

{% columns %}
{% column %}

* none
* solid
* darkGray
* mediumGray
* lightGray
* gray125
* gray0625
  {% endcolumn %}

{% column %}

* darkHorizontal
* darkVertical
* darkDown
* darkUp
* darkGrid
* darkTrellis
  {% endcolumn %}

{% column %}

* lightHorizontal
* lightVertical
* lightDown
* lightUp
* lightGrid
* lightTrellis
  {% endcolumn %}
  {% endcolumns %}

**Verlaufsfüllung**

<table><thead><tr><th width="137.0625">Eigenschaft</th><th width="144.5546875">Erforderlich</th><th>Beschreibung</th></tr></thead><tbody><tr><td>type</td><td>Ja</td><td>Gibt an, dass diese Füllung einen Verlauf verwendet.</td></tr><tr><td>gradient</td><td>Ja</td><td>Definiert den Verlaufstyp. Er kann entweder "angle" oder "path" sein.</td></tr><tr><td>degree</td><td>angle</td><td><ul><li>Gibt die Richtung des Verlaufs an.</li><li>Der Wert 0 verläuft von links nach rechts.</li><li>Werte von 1 bis 359 drehen die Richtung im Uhrzeigersinn.</li></ul></td></tr><tr><td>center</td><td>path</td><td><ul><li>Gibt die relativen Koordinaten für den Start des Verlaufspfads an.</li><li>Die Werte für "left" und "top" liegen zwischen 0 und 1.</li></ul></td></tr><tr><td>stops</td><td>Ja</td><td><ul><li>Gibt die Farbfolge des Verlaufs an.</li><li>Ein Array von Objekten definiert Position und Farbe, beginnend bei Position 0 und endend bei Position 1.</li><li>Zusätzliche Positionen können weitere Farben auf dem Pfad angeben.</li></ul></td></tr></tbody></table>

**Unterstützte Spezialfelder**

Die Funktion unterstützt Spezialfelder wie Hyperlinks, Rich-Text und Formeln:

* Hyperlinks liefern Links zu Webinhalten oder internen Verweisen.
* Rich-Text erlaubt gemischte Formatierungen wie Fett, Kursiv und andere Schriftstile.
* Formeln ermöglichen es Zellen, Werte dynamisch zu berechnen.
* Datumswerte können direkt aus Ninox verwendet werden.

**Hyperlink**

```json
// Link zum Internet
value := {
  text: "www.mylink.com",
  hyperlink: "http://www.mylink.com",
  tooltip: "www.mylink.com"
};
// interner Link
value := {
  text: "Sheet2",
  hyperlink: "#'Sheet2'!A1"
};
```

**Rich-Text** (in XLSX)

```json
value := {
  richText: [
    { text: "This is" },
    { font: {italic: true}, text: "italic" },
  ]
};
```

**Formel** (in XLSX)

```json
value := { formula: "A1+A2" };
value := { formula: "SUM(A1,A2)" };
```

**Datum** (in XLSX)

```json
let columns := [{
    header: "Birthdate",
    key: "birthdate",
    width: 10,
    date: true
}];
```

Tipps:

* Filtere die Auswahl vor dem Export, wenn die Datei nur relevante Datensätze enthalten soll.
* Nutze einen klaren Dateinamen, damit Empfänger wissen, was sie erhalten haben.
* Nutze den Export als XLSX-Datei, wenn du eigene Spalten, Stile oder mehrere Arbeitsblätter brauchst.
* Spezielle Zellwerte können Hyperlinks, Rich-Text, Formeln und Datumswerte enthalten.
* Speichere die zurückgegebene Datei in einem Dateifeld, damit sie in der Formularansicht in einem bestimmten Datenkontext sichtbar ist.

### Dateien mit `createZipFile()` bündeln <a href="#bundle-files-with-createzipfile" id="bundle-files-with-createzipfile"></a>

Nutze `createZipFile()`, um mehrere Dateien in einem ZIP-Archiv zusammenzufassen.

Nutze die Funktion, wenn du:

* mehrere Dateien in einem Download bereitstellen willst.
* Berichte und Anhänge zusammengefasst versenden willst.
* manuelle Schritte für den Empfänger reduzieren willst.

`createZipFile(nid, [file], string)`

* `nid` Zieldatensatz
* `[file]` einzuschließende Datei(en)
* `string` Dateiname der ZIP-Datei

`createZipFile()` gibt ein Dateiobjekt zurück und speichert es im Tab <i class="fa-paperclip-vertical">:paperclip-vertical:</i> **Dateien** des zugewiesenen `nid`.

#### Schauen wir uns einige Beispiele an:

```ninox
do as server
    let myProd := (select produkte).foto;
    createZipFile(this, produkte, "Produkte.zip")
end
```

Erstellt ein ZIP-Archiv mit allen Dateien aus dem Feld "Foto" in den ausgewählten `Produkte`-Datensätzen.

```ninox
do as server
    createZipFile(this, files(this), "Produkte.zip")
end
```

Erstellt ein ZIP-Archiv mit allen Dateien, die am aktuellen Datensatz angehängt sind.

```ninox
do as server
    createZipFile(this, [foto], "Produkte.zip")
end
```

Erstellt ein ZIP-Archiv aus einer Datei in einem Dateifeld, indem sie in ein Array gesetzt wird.

Tipps:

* `createZipFile()` funktioniert derzeit nur im Server-Kontext. Setze die Funktion daher immer in `do as server ... end`.
* Nutze `files(this)`, wenn du *alle* Dateien des aktuellen Datensatzes in eine ZIP-Datei packen willst.
* Setze eine einzelne Datei in ein Array, wenn du aus einem Anhang eine ZIP-Datei erstellen willst.

{% hint style="info" %}
Das Erstellen und Teilen von Dateien kann je nach Client-Fähigkeiten abweichen. Teste Export- und Freigabe-Skripte in den Umgebungen, die dein Team am häufigsten nutzt.
{% endhint %}

### Mit `file()` und `files()` ein oder mehrere Dateiobjekte zurückgeben <a href="#return-one-or-more-file-objects-with-file-and-files" id="return-one-or-more-file-objects-with-file-and-files"></a>

Nutze `file()`, wenn du eine Dateireferenz brauchst. Nutze `files()`, wenn du die vollständige Liste der am Datensatz gespeicherten Dateianhänge brauchst.

Nutze sie, wenn du:

* Dateiobjekte an andere Dateifunktionen übergeben willst.
* einen bestimmten Anhang über den Dateinamen aus einem Datensatz auswählen willst.

`file(any)`\
`file(nid, string)`\
`files(any)`\
`files(nid)`

* `any` das Dateifeld, der Datensatz oder die unterstützte Quelle, die du lesen willst
* `nid` Datensatz, der den Dateianhang enthält
* `string` exakter Dateiname des Anhangs, den du zurückgeben willst

`files()` gibt ein Array von Dateiobjekten zurück.

#### Schauen wir uns einige Beispiele an:

```ninox
files(this)
```

Gibt alle Anhänge des aktuellen Datensatzes als Array zurück.

```ninox
count(files(this))
```

Gibt die Anzahl der Anhänge des aktuellen Datensatzes zurück.

```ninox
file(this, "Mein-gesuchtes-Dokument.pdf")
```

Gibt den Dateianhang aus dem aktuellen Datensatz mit dem Namen "Mein-gesuchtes-Dokument.pdf" zurück.

Tipps:

* Nutze `files()`, wenn Nutzer mehrere Dateien anhängen können und du alle brauchst.
* Nutze `file()` mit Datensatz-ID und exaktem Dateinamen, wenn ein Datensatz mehrere Anhänge hat und du eine bestimmte Datei brauchst.
* Achte auf den exakten Dateinamen, wenn du die Form mit Datensatz und Namen nutzt.

### Dateidetails mit `fileMetadata()` prüfen <a href="#check-file-details-with-filemetadata" id="check-file-details-with-filemetadata"></a>

Nutze `fileMetadata()`, um eine Datei zu prüfen, bevor du sie teilst, exportierst oder verarbeitest.

Nutze die Funktion, wenn du:

* Dateigröße, Dateiname oder Änderungsdatum prüfen willst.
* Dateidetails aus einem Datensatz lesen willst, wenn du den Dateinamen kennst.

`fileMetadata(nid, string)`

* `nid` Datensatz, der den Dateianhang enthält
* `string` exakter Dateiname des Anhangs, den du prüfen willst

`fileMetadata()` gibt JSON mit Details wie `name`, `size` und `modifiedDate` zurück.

#### Schauen wir uns einige Beispiele an:

```ninox
fileMetadata(this, "Rechnung.pdf")
```

Gibt Dateimetadaten zurück wie:

```json
{ "name": "Rechnung.pdf", "size": 95935, "modifiedDate": 1661385600000 }
```

```ninox
let myName := item(split(item(split(text(rechnung), ":"), 3), """"), 1);
metadata_field := fileMetadata(this, myName)
```

Gibt die Metadaten der Datei zurück, deren Name mit Funktionen aus [Text und Zeichenfolgen](/ninox-scripting/de/automate-your-workflows/work-with-functions/text-and-strings.md) aus dem Dateifeld "Invoice" extrahiert wird.

Tipps:

* Prüfe Metadaten, bevor du große oder sensible Dateien sendest.
* Nutze Metadatenprüfungen in Freigabe- oder Export-Workflows.
* Nutze die Form mit Datensatz und Namen, wenn ein Datensatz mehrere Anhänge hat und du genau eine Datei brauchst.
* `modifiedDate` wird als Zeitstempel zurückgegeben.

## Dateien umbenennen oder entfernen

Nutze diese Funktionen, wenn du vorhandene Dateien nach dem Erstellen, Im- oder Export verwalten willst.

### Eine Datei mit `renameFile()` und `removeFile()` umbenennen oder entfernen <a href="#rename-or-remove-files" id="rename-or-remove-files"></a>

Nutze `renameFile()`, um den Dateinamen zu ändern. Nutze `removeFile()`, um eine Datei zu löschen.

Nutze die Funktionen, um:

* Dateinamen nach dem Import zu vereinheitlichen oder zu korrigieren.
* temporäre Ausgaben zu bereinigen.
* veraltete oder falsche Dateien zu entfernen.

`renameFile(file, string)`\
`renameFile(nid, string, string)`\
`removeFile(file)`\
`removeFile(nid, string)`

* `file` Dateiobjekt, das du umbenennen oder entfernen willst
* `string` neuer Dateiname für `renameFile`
* `nid` Datensatz, der die Datei enthält, die du umbenennen oder entfernen willst
* `string` (zweites Argument von `renameFile`) aktueller Dateiname
* `string` (drittes Argument von `renameFile`) neuer Dateiname
* `string` (zweites Argument von `removeFile`) exakter Dateiname der zu entfernenden Datei

#### Schauen wir uns einige Beispiele an:

```ninox
let myDat := createTextFile( "Hallo","Beispiel.txt");
renameFile(myDat, "Lies mich.txt")
```

Benennt die Datei in "Lies mich.txt" um.

```ninox
Image := renameFile(bild, "A1234_Vorderseite_0729.jpg")
```

Benennt die Datei im Feld "Bild" um und aktualisiert das Feld mit der umbenannten Datei.

```ninox
renameFile(this, "Angebot_0724.pdf", "Angebot_0724-1.pdf")
```

Benennt die angehängte Datei im aktuellen Datensatz um.

```ninox
removeFile(bild);
```

Entfernt die Datei, die im Feld "Bild" angezeigt wird.

```ninox
removeFile(this, "Angebot_0724.pdf")
```

Entfernt die Datei "Angebot\_0724.pdf" aus dem aktuellen Datensatz.

Tipps:

* Entferne Dateien nur, wenn du sicher bist, dass sie nicht mehr gebraucht werden.
* Führe `renameFile()` und `removeFile()` in nativen Apps im Server-Kontext aus.
* Nutze die Form `removeFile(nid, string)`, wenn ein Datensatz mehrere Anhänge hat und du genau eine Datei entfernen willst.

## URLs für Datensätze erstellen

Nutze `urlOf()`, um einen direkten Link zu einem Datensatz zu erstellen.

### Die URL eines Datensatzes mit `urlOf()` abrufen <a href="#use-record-urls-to-link-to-specific-data" id="use-record-urls-to-link-to-specific-data"></a>

Nutze `urlOf()`, wenn du:

* einen direkten Link zum aktuellen Datensatz teilen willst.
* eine Datensatz-URL in einer Nachricht oder einem Export speichern möchtest.
* einen Link an ein anderes System übergeben willst.

`urlOf(nid)`

* `nid` Datensatz, dessen URL du abrufen willst

`urlOf()` gibt einen Link zurück.

#### Schauen wir uns ein Beispiel an:

```ninox
urlOf(this)
```

Gibt einen Link zum aktuellen Datensatz zurück.

### Einen Link zum Anhang eines Datensatzes mit `fileUrl()` erstellen

Nutze `fileUrl()`, um eine URL für eine Datei zurückzugeben.

Nutze die Funktion, wenn du:

* einen Download-Link anzeigen oder senden möchtest.
* auf einen bestimmten Anhang eines Datensatzes verlinken möchtest.

`fileUrl(nid, string)`

* `nid` der Datensatz, der den Dateianhang enthält
* `string` der genaue Dateiname des Anhangs, auf den du verlinken möchtest

`fileUrl()` gibt einen Link zurück.

#### Schauen wir uns ein Beispiel an:

```ninox
let dateiName := item(split(raw(bild), """"), 11);
fileUrl(this, dateiName)
```

Extrahiert den Dateinamen aus den Metadaten des Felds "Bild" und gibt einen Link zu dieser Datei zurück.

Tipps:

* `fileUrl()` ist für die clientseitige Nutzung vorgesehen.
* Du kannst `fileUrl()` nicht in Triggern verwenden. Auch nicht in Blöcken mit `do as server`, `do as transaction` oder `do as deferred`.
* Der erzeugte Link nutzt Informationen des aktuell angemeldeten Nutzers. Deshalb ist er bei serverseitiger Ausführung nicht verfügbar.

## Dateien als Base64 für API und Übermittlungen laden

Nutze diese Funktionen, wenn du den eigentlichen Dateiinhalt benötigst, nicht nur das Dateiobjekt oder einen Link.

### Dateiinhalt mit `loadFileAsBase64()` und `loadFileAsBase64URL()` zurückgeben

Nutze `loadFileAsBase64()` für unformatierten Base64-Text. Nutze `loadFileAsBase64URL()`, wenn du eine fertige `data:`-URL benötigst.

Nutze sie, wenn du Folgendes möchtest:

* Dateiinhalt an eine API senden.
* Eine Datei in einer generierten Ausgabe einbetten.
* Binären Dateiinhalt als Text für eine Folgeanfrage speichern.

`loadFileAsBase64(file)`\
`loadFileAsBase64(nid, string)`\
`loadFileAsBase64URL(file)`\
`loadFileAsBase64URL(nid, string)`

* `file` das Dateiobjekt oder die unterstützte Dateiquelle, die du als Base64 kodieren möchtest
* `nid` der Datensatz, der den Dateianhang enthält
* `string` der genaue Dateiname des Anhangs, den du kodieren möchtest

`loadFileAsBase64()` gibt den Dateiinhalt als Base64-String zurück.

`loadFileAsBase64URL()` gibt den Dateiinhalt als Base64-Daten-URL zurück.

#### Schauen wir uns einige Beispiele an:

```ninox
loadFileAsBase64(this, "Mein_Foto.jpg")
```

Gibt die Datei "Mein\_Foto.jpg" aus den Anhängen des aktuellen Datensatzes als Base64-String zurück.

```ninox
loadFileAsBase64(foto)
```

Gibt die Datei im Feld "Foto" als Base64-String zurück.

```ninox
loadFileAsBase64URL(this, "Mein_Foto.jpg")
```

Gibt die Datei "Mein\_Foto.jpg" aus den Anhängen des aktuellen Datensatzes als Base64-Daten-URL zurück.

```ninox
let myFo := first((select kontakte where punktzahl = 100).eingereichtes_foto);
let myGewin := loadFileAsBase64URL(myFo);
Gewinner_foto := myGewin;
```

Ermittelt den Datensatz mit der „Punktzahl“ 100 in der Tabelle „Kontakte“. Ruft aus diesem die Datei des Feldes „Eingereichtes Foto“ ab.\
Die Datei wird in eine Base64-Daten-URL umgewandelt.\
Die URL wird im Feld „Gewinnerbild“ gespeichert.\
Nutze den Wert beispielsweise in einem REST-API-Aufruf.

Tipps:

* Base64 erhöht die Größe des Speicherverbrauchs.
* Nutze es nur, wenn deine Ninox-App unbedingt diese Inhalte benötigt.
* Nutze die Variante mit Datensatz und Dateiname, wenn ein Datensatz mehrere Anhänge enthält.
* Nutze `loadFileAsBase64URL()`, wenn das Ziel eine fertige `data:`-URL erwartet.

{% hint style="info" %}
Speichere keine großen Mengen an Base64-Strings. Wenn du sie speichern musst, nutze [createTextFile()](#build-files-with-createtextfile), um den String in eine Datei umzuwandeln. Nutze anschließend [importFile()](#import-a-file-with-importfile), um diese als Anhang zu speichern.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.ninox.com/ninox-scripting/de/automate-your-workflows/work-with-functions/files-and-export.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.