{"id":28723,"date":"2026-01-21T10:00:00","date_gmt":"2026-01-21T09:00:00","guid":{"rendered":"https:\/\/contabo.com\/blog\/der-linux-time-befehl-erklaert\/"},"modified":"2026-03-04T10:48:24","modified_gmt":"2026-03-04T09:48:24","slug":"der-linux-time-befehl-erklaert","status":"publish","type":"post","link":"https:\/\/contabo.com\/blog\/de\/der-linux-time-befehl-erklaert\/","title":{"rendered":"Der Linux time-Befehl erkl\u00e4rt"},"content":{"rendered":"\n
\"Linux<\/figure>\n\n\n\n
<\/div>\n\n\n\n

Ein Gef\u00fchl daf\u00fcr zu bekommen, wie dein System Ressourcen nutzt und wie lange Prozesse tats\u00e4chlich dauern, ist absolut essenziell, wenn du einen Server betreibst. Der Linux time-Befehl ist eines dieser Werkzeuge, die simpel aussehen, es aber in sich haben: er misst, wie lange Befehle oder Programme f\u00fcr die Ausf\u00fchrung ben\u00f6tigen. Setze einfach „time“ vor das, was du gerade ausf\u00fchrst, und du siehst genau, wie viel CPU-Zeit verbraucht wurde im Vergleich dazu, wie lange du tats\u00e4chlich auf den Abschluss warten musstest.<\/p>\n\n\n\n

Wenn du ein SysAdmin oder Entwickler bist oder einen Linux VPS betreibst, wird dir dieses Tool bei der Suche nach Performance-Problemen extrem n\u00fctzlich sein. Vielleicht zieht sich dein Backup-Skript in die L\u00e4nge oder du willst wissen, welches von zwei Skripten schneller l\u00e4uft \u2013 das Linux time-Utility liefert dir echte Zahlen statt blo\u00dfer Vermutungen. Es verwandelt vage Ahnungen in echte Daten, damit du genau erkennst, was das System ausbremst. In diesem Guide schauen wir uns alles an \u2013 von der grundlegenden Nutzung von time bis hin zu fortgeschrittenen Tricks f\u00fcr das Profiling von Aufgaben auf deinem System.<\/p>\n\n\n\n

Nutzungsszenarien f\u00fcr den Linux time-Befehl<\/h2>\n\n\n\n

Herauszufinden, wie lange etwas dauert, ist nicht nur reine Neugier \u2013 es ist ein wichtiger Teil davon, ein System reibungslos am Laufen zu halten. Das Linux-Utility time wird zu deinem wichtigsten Werkzeug, wenn Skripte langsamer laufen als sie sollten und du wissen musst, warum. Entwickler nutzen den Linux time-Befehl, um Performance-Probleme nach Code-\u00c4nderungen aufzusp\u00fcren. Wenn sich mehrere Prozesse Ressourcen teilen, hilft das Wissen \u00fcber die exakte CPU-Zeit dabei, zu verhindern, dass ein Task alles f\u00fcr sich beansprucht. <\/p>\n\n\n\n

In der Produktion k\u00f6nntest du time f\u00fcr einen Prozess nutzen, der Teil deiner t\u00e4glichen Cron-Jobs ist. Wenn dein Backup, das normalerweise zehn Minuten dauert, pl\u00f6tzlich drei\u00dfig ben\u00f6tigt, zeigt dir die Ausgabe, ob Ressourcenmangel oder I\/O-Probleme die Verz\u00f6gerung verursachen. CI-Pipelines verlassen sich auf time, um zu messen, wie lange ein Befehl braucht, damit automatisierte Tests nicht ewig dauern. Die Ausf\u00fchrungsdaten des Linux time-Befehls helfen dir, Performance-Probleme zu erkennen, bevor die Nutzer anfangen, sich zu beschweren. <\/p>\n\n\n\n

Voraussetzungen: Shells, Bash-time-Befehl und \/usr\/bin\/time <\/h2>\n\n\n\n

Hier ist etwas, das viele Leute verwirrt: Es gibt tats\u00e4chlich zwei verschiedene Versionen dieses Tools. Meistens nutzt du den Bash-time-Befehl, der direkt in deine Shell integriert ist. Er ist schnell und einfach, bietet dir aber kaum Kontrolle \u00fcber die Ausgabe. Die andere Version liegt unter \/usr\/bin\/time. Es ist ein eigenst\u00e4ndiges Programm, das viel mehr Details liefert: Speichernutzung, I\/O-Operationen und vieles mehr. <\/p>\n\n\n\n

Willst du wissen, welchen du verwendest? F\u00fchre einfach aus: <\/p>\n\n\n\n

type time<\/code><\/pre>\n\n\n\n
Normalerweise wird angezeigt, dass es sich um ein Shell-Keyword handelt. Wenn du die erweiterten Funktionen des UNIX-time-Befehls aus dem System-Binary nutzen willst, musst du entweder den vollst\u00e4ndigen Pfad angeben oder einen Backslash vor time setzen. Egal, ob du den Ubuntu-time-Befehl oder eine andere Distro nutzt: Du brauchst nur eine normale Shell wie Bash oder Zsh, um einen Befehl mit time zu messen. Den Unterschied zwischen dem Bash-time-Befehl und der Systemversion zu kennen, erspart dir das R\u00e4tseln, warum bestimmte Flags nicht funktionieren.<\/p>\n\n\n\n
Grundlegende Syntax des Linux-time-Befehls<\/h2>\n\n\n\n
Der time-Befehl unter Linux ist erfrischend unkompliziert: Du setzt einfach „time“ vor das, was du ohnehin ausf\u00fchren wolltest. Das Grundmuster lautet: time [Optionen] Befehl [Argumente]. Willst du sehen, wie lange das Auflisten eines Verzeichnisses dauert:<\/p>\n\n\n\n
time ls<\/code><\/pre>\n\n\n\n
Das funktioniert f\u00fcr einzelne Programme, Pipelines, ganze Skripte \u2013 eigentlich f\u00fcr alles. <\/p>\n\n\n\n
Der Linux-time-Befehl ist flexibel genug f\u00fcr die meisten Situationen. Du kannst sogar die Ausgabe umleiten, wobei du auf die Syntax achten musst, um sicherzustellen, dass du den eigentlichen Befehl misst und nicht nur die Umleitung. Du kannst sogar die Ausgabe umleiten, wobei du auf die Syntax achten musst, um sicherzustellen, dass du den eigentlichen Befehl misst und nicht nur die Umleitung. Sobald du dieses Grundmuster erst einmal verinnerlicht hast, wirst du es \u00fcberall einsetzen. <\/p>\n\n\n\n
Shell-Built-in vs. externe time-Syntax<\/h3>\n\n\n\n
Es gibt einige Eigenheiten zwischen dem Bash-time-Befehl und dem UNIX-time-Befehl unter \/usr\/bin\/time. Das Bash-Built-in verarbeitet Pipelines problemlos: <\/p>\n\n\n\n
time find . | grep \"test\"<\/code><\/pre>\n\n\n\n
Aber das Linux-time-Binary erfordert hingegen mehr Sorgfalt, wenn du versuchst, eine Pipeline mit der externen Version zu messen, wird oft nur der erste Teil erfasst \u2013 es sei denn, du packst alles in eine Subshell. Diese Unterschiede zu kennen, hilft dir dabei, pr\u00e4zise Messwerte zu erhalten. <\/p>\n\n\n\n
Wichtige Optionen f\u00fcr den Linux-time-Befehl<\/h3>\n\n\n\n
Die grundlegende Version ist n\u00fctzlich, aber der Linux time-Befehl wird mit den richtigen Flags noch m\u00e4chtiger. Die Option -p erzwingt die Ausgabe im POSIX-Format, was f\u00fcr Skripte einfacher zu parsen ist. Musst du die Ergebnisse speichern? Die Option -o schreibt die Ausgabe des Linux time-Befehls in eine Datei, und mit -a kannst du Ergebnisse anh\u00e4ngen, statt sie zu \u00fcberschreiben. F\u00fcr maximale Details zeigt –verbose in der externen Version alles \u00fcber den Ausf\u00fchrungskontext des Linux time-Befehls: Kontextwechsel, Seitenfehler (Page Faults) und vieles mehr. <\/p>\n\n\n\n
Verst\u00e4ndnis der Ausgabe des Linux time-Befehls<\/h2>\n\n\n\n
Wenn du etwas \u00fcber den Linux time-Befehl ausf\u00fchrst, erh\u00e4ltst du drei Werte: real, user und sys. Die „Real“-Zeit ist die tats\u00e4chliche Uhrzeit vom Start bis zum Ende. Die Ausgabe des Linux time-Befehls zeigt auch die Benutzerzeit (CPU-Zeit im User-Modus) und die sys-Zeit (CPU-Zeit im Kernel f\u00fcr Systemaufrufe). <\/p>\n\n\n\n
Diese Zahlen k\u00f6nnen anfangs verwirrend sein. In Multi-Threaded-Programmen k\u00f6nnen Benutzer- und sys-Zeit zusammen mehr als die real-Zeit ergeben, da die Arbeit auf mehreren Kernen gleichzeitig erfolgte. Wenn ein Prozess auf ein langsames Netzwerk wartet, kann die Ausf\u00fchrung des Linux time-Befehls eine hohe real-Zeit, aber sehr geringe Benutzer- und sys-Zeiten anzeigen. Diese Aufschl\u00fcsselung ist genau der Weg, um \u00fcber Linux time herauszufinden, wie lange ein Befehl im Vergleich zur tats\u00e4chlich geleisteten Arbeit ben\u00f6tigt.<\/p>\n\n\n\n
Interpretation von Ausf\u00fchrungsmetriken des Linux time-Befehls <\/h3>\n\n\n\n
Um die Zeit eines Befehls unter Linux effektiv zu messen, solltest du nach Mustern suchen. Hohe sys-Werte bedeuten normalerweise viele I\/O-Vorg\u00e4nge oder Systemaufrufe \u2013 vielleicht ein ineffizienter Festplattenzugriff. Wenn die Benutzerzeit dominiert, bist du CPU-bound und durch die Prozessorgeschwindigkeit limitiert. Diese Ausf\u00fchrungswerte des Linux time-Befehls korrekt zu lesen, verr\u00e4t dir, ob der Bottleneck in deinem Code oder in der Systemeinrichtung liegt. <\/p>\n\n\n\n
Praktische Beispiele: Linux time-Befehl f\u00fcr Skripte und Programme <\/h2>\n\n\n\n
Erst bei der Verwendung des Linux time-Befehls f\u00fcr tats\u00e4chliche Aufgaben erkennst du seinen wahren Wert. Das funktioniert bei allem \u2013 vom Verschieben von Dateien bis hin zum Kompilieren von Code. Den Linux time-Befehl in deinen regul\u00e4ren Arbeitsablauf einzubinden, hilft dir dabei, ein Gef\u00fchl daf\u00fcr zu entwickeln, wie lange Dinge dauern sollten. Dann kannst du die Zeit eines Befehls unter Linux messen und erkennen, wenn etwas nicht stimmt. <\/p>\n\n\n\n
Einfache Beispiele f\u00fcr Einzelbefehle<\/h3>\n\n\n\n
Starte einfach und miss einen Linux-Befehl mit vorhersehbarer Dauer: <\/p>\n\n\n\n
time sleep 3<\/code><\/pre>\n\n\n\n
Das sollte dir ungef\u00e4hr drei Sekunden real-Zeit liefern. Du kannst Linux time auch verwenden, um die Dateierstellung zu messen oder einen Linux-Befehl wie einen Download mit curl zeitlich zu erfassen. Diese grundlegenden Beispiele zeigen, wie der Linux time-Befehl den Prozessstart und Verz\u00f6gerungen durch externe Ressourcen erfasst. <\/p>\n\n\n\n
Timing von Shell-Skripten und Pipelines<\/h3>\n\n\n\n
Musst du einen Linux-Prozess mit mehreren Schritten messen? Messe ein Shell-Skript so: <\/p>\n\n\n\n
time .\/script.sh<\/code><\/pre>\n\n\n\n
 F\u00fcr komplexe Pipelines k\u00f6nntest du einen Linux-Befehl messen, der Daten filtert und sortiert. Setze ihn in Klammern: <\/p>\n\n\n\n
time (find . -name \"*.log\" | xargs grep \"error\") <\/code><\/pre>\n\n\n\n
Auf dieser Weise erfasst der Linux-Befehl die gesamte Ausf\u00fchrungszeit f\u00fcr die komplette Kette. <\/p>\n\n\n\n
Vergleich von verschiedenen Implementierungen und Optimierungen<\/h3>\n\n\n\n
Eine der besten Anwendungen von Linux time ist der Vergleich zweier Ans\u00e4tze f\u00fcr dasselbe Problem. Hast du zwei Versionen eines Skripts? Du kannst die Zeit f\u00fcr beide unter Linux messen und sehen, welche gewinnt. Dies liefert dir echte Daten, um einen Linux-Befehl zu messen und die schnellere Option basierend auf Fakten statt auf dein Bauchgef\u00fchl zu w\u00e4hlen. <\/p>\n\n\n\n
 Erweiterte Optionen: Linux time-Formate, Dateien und Verbose-Modi<\/h2>\n\n\n\n
\u00dcber die grundlegende Zeitmessung hinaus musst du vielleicht die Zeit und den Ressourcenverbrauch unter Linux detaillierter pr\u00fcfen. Die erweiterten Funktionen des Linux time-Befehls erm\u00f6glichen es dir, Berichte und Speicherung anzupassen. Extrem n\u00fctzlich f\u00fcr automatisierte Tests oder Langzeit-Monitoring, bei dem du die Zeit unter Linux \u00fcber hunderte von Durchl\u00e4ufen hinweg pr\u00fcfen musst, ohne st\u00e4ndig daneben zu sitzen. Die Muster des Linux time-Befehls lassen dich spezifische Metriken wie den maximalen Speicherverbrauch oder Dateisystem-Operationen abrufen. <\/p>\n\n\n\n
Die Funktionalit\u00e4t zum Abrufen der Zeit (get time) in der externen Linux-Version ist weitaus m\u00e4chtiger als das Shell-Built-in. Ein einfacher Zeit-Check unter Linux liefert dir die Basics, aber erweiterte Flags erm\u00f6glichen ein tiefes Profiling der Speicher- und CPU-Interaktion. Dadurch fungiert die Ausgabe des Linux time-Befehls wie ein leichtgewichtiger Profiler, der zwischen einer Stoppuhr und einer vollst\u00e4ndigen Debugging-Suite angesiedelt ist. <\/p>\n\n\n\n
Umleiten der Ausgabe des Linux time-Befehls in eine Datei<\/h3>\n\n\n\n
W\u00e4hrend der Ausf\u00fchrung des Linux time-Befehls geht die Ausgabe normalerweise an stderr. M\u00f6chtest du die Ergebnisse protokollieren? Der Linux time-Befehl verf\u00fcgt \u00fcber das -o (oder –output-) Flag. Das ist essenziell, wenn du die Ergebnisse des Linux time-Befehls von Hintergrundjobs erfassen m\u00f6chtest. Das -a Flag h\u00e4ngt mehrere Ergebnisse an eine Log-Datei an \u2013 perfekt, um Daten w\u00e4hrend Stresstests oder langen Batch-Prozessen zu sammeln. <\/p>\n\n\n\n
Benutzerdefinierte Formate und detaillierte Ressourcenmetriken<\/h3>\n\n\n\n
Die GNU-Version erm\u00f6glicht es dir, bei der Ausgabe des Linux time-Befehls mit dem -f Flag extrem spezifisch zu werden. Formatbezeichner wie %E f\u00fcr die verstrichene Zeit, %U f\u00fcr User-Sekunden oder %M f\u00fcr den maximalen Speicherverbrauch. Dies verwandelt den Linux time-Befehl von einem einfachen Timer in einen echten Ressourcen-Monitor. Die Ausf\u00fchrung des Linux time-Befehls in der Bash nutzt die TIMEFORMAT-Umgebungsvariable f\u00fcr \u00e4hnliche Ergebnisse, konzentriert sich aber mehr auf Zeitfelder als auf Hardware-Metriken. <\/p>\n\n\n\n
Nutzung von Linux time-Befehlsmustern f\u00fcr das Profiling<\/h3>\n\n\n\n
Ein bew\u00e4hrtes Muster, um einen Linux-Befehl zu messen, ist die Ausf\u00fchrung in einer Schleife, um Durchschnittswerte zu erhalten. Du kannst den Linux time-Befehl in ein For-Loop-Skript integrieren, um einen Prozess zehnmal unter Linux zu messen und alles zu protokollieren. Dies ber\u00fccksichtigt das „Systemrauschen“ (Noise) und liefert dir genauere Durchschnittswerte f\u00fcr die Ausf\u00fchrung des Linux time-Befehls. Diese Muster helfen dir zu profilieren, wie Skripte unter verschiedenen Lasten oder Eingangsgr\u00f6\u00dfen reagieren, was den Linux time-Befehl zu einem vielseitigen Performance-Tool macht.<\/p>\n\n\n\n
Best Practices und h\u00e4ufige Fallstricke<\/h2>\n\n\n\n
Um gute Ergebnisse zu erzielen, wenn du einen Befehl unter Linux mit time misst, achte auf Faktoren, die deine Messungen verf\u00e4lschen k\u00f6nnten. Ein h\u00e4ufiger Fehler beim Messen eines Linux-Befehls ist das Ignorieren des „Cold Cache“-Effekts: Der erste Durchlauf liest von der Festplatte, sp\u00e4tere nutzen den Speicher. Um die Zeit eines Befehls unter Linux genau zu messen, f\u00fchre ihn einmal als „Warm-up“ aus, bevor du die tats\u00e4chlichen Ergebnisse aufzeichnest. <\/p>\n\n\n\n
Eine weitere Falle ist die Verwendung der falschen Version. Brauchst du Speicherdaten, nutzt aber weiterhin das integrierte Linux-time-Built-in? Dann wirst du nicht die Infos bekommen, die du ben\u00f6tigst. Denk auch daran, dass beim Messen eines Linux-Prozesses der Shell-Overhead f\u00fcr das Starten des Prozesses in der Zeit enthalten ist. Bei wirklich kurzen Befehlen kann dieser Overhead einen gro\u00dfen Teil der Gesamtzeit ausmachen, was deine Schlussfolgerungen verf\u00e4lschen kann. <\/p>\n\n\n\n
Vermeidung ungenauer oder verf\u00e4lschter Messungen<\/h3>\n\n\n\n
Umgebungsfaktoren st\u00f6ren die Zeitmessung von Linux-Befehlen. Wenn dein Server im Hintergrund ein intensives Backup durchf\u00fchrt, wird die Ausf\u00fchrungszeit deines Linux time-Befehls k\u00fcnstlich aufgebl\u00e4ht. Versuche die Zeit, die ein Befehl unter Linux ben\u00f6tigt, auf einem ruhigen System zu messen, um eine Baseline zu erhalten. Achte auch auf die Netzwerklatenz: Wenn dein Befehl eine Remote-API aufruft, spiegelt die „real“-Zeit eher die Internetgeschwindigkeit als die Leistung deines Skripts wider. <\/p>\n\n\n\n
Die Wahl zwischen time und anderen Linux-Profiling-Tools<\/h3>\n\n\n\n
Obwohl der Linux time-Befehl gro\u00dfartig f\u00fcr schnelle \u00dcbersichten ist, ist er nicht immer die richtige Wahl. Brauchst du Echtzeit-Ressourcenspitzen? Nutze stattdessen top oder htop. Musst du wissen, welche Funktion genau langsam ist? Greif zu einem dedizierten Profiler-Tool oder strace. Nutze den Linux time-Befehl als ersten Check, um ein Problem zu best\u00e4tigen, und wechsle dann zu spezialisierten Tools, um es genau zu lokalisieren. <\/p>\n\n\n\n
Linux time-Befehl – FAQ<\/h2>\n\n\n\n
Wie messe ich die Zeit eines Befehls unter Linux<\/h3>\n\n\n\n
Tippe einfach „time“ vor den Befehl, den du ausf\u00fchren m\u00f6chtest: <\/p>\n\n\n\n
time .\/myscript.sh <\/code><\/pre>\n\n\n\n
Es wird das Skript ausf\u00fchren und dir die Timing-Informationen anzeigen, sobald es fertig ist. <\/p>\n\n\n\n
Linux time: Wie lange dauert ein Befehl? <\/h3>\n\n\n\n
Du erh\u00e4ltst drei Metriken: real, user und sys. Real ist die tats\u00e4chlich vergangene Zeit, w\u00e4hrend user und sys die CPU-Zeit anzeigen, die vom Programm und vom Kernel beansprucht wurde. <\/p>\n\n\n\n
Der aktuelle Linux time-Befehl <\/h3>\n\n\n\n
Wenn du die aktuelle Uhrzeit wissen willst, statt eine Dauer zu messen, verwende den date-Befehl. Der Time-Befehl dient zur Messung, wie lange Dinge dauern, date hingegen zeigt den aktuellen Zeitbefehl in Linux an. <\/p>\n\n\n\n
Linux: Wie erhalte ich die aktuelle Zeit? <\/h3>\n\n\n\n
Um \u00fcber den Linux-Befehl die aktuelle Zeit in verschiedenen Formaten zu erhalten, nutze date +“%T“ f\u00fcr die Zeit oder date +“%Y-%m-%d“ f\u00fcr das Datum. Das time-Utility dient ausschlie\u00dflich dazu, die Performance zu profilieren und die Ausf\u00fchrung zu messen. <\/p>\n\n\n\n
Fazit<\/h2>\n\n\n\n
Der Linux time-Befehl ist ein Tool, das du in deinem Werkzeugkasten haben m\u00f6chtest; er liefert die Daten, die du brauchst, damit alles reibungslos l\u00e4uft. Zu lernen, wie man die Kennzahlen real, user und sys interpretiert, hilft dir schnell herauszufinden, ob Performance-Probleme durch deinen Code, die Hardware oder externe Abh\u00e4ngigkeiten verursacht werden. Egal, ob du das einfache Shell-Built-in oder die funktionsreiche GNU-Version nutzt: Der time-Befehl macht Schluss mit dem R\u00e4tselraten bei der Optimierung. <\/p>\n\n\n\n
Mache den Linux time-Befehl zu einem festen Bestandteil deiner regelm\u00e4\u00dfigen Performance-Checks. Zu verstehen, wie Prozesse mit der CPU und dem Speicher interagieren, ist der erste Schritt zu schnelleren und zuverl\u00e4ssigeren Anwendungen. Wenn du eine stabile Umgebung zum Testen deiner Skripte suchst, bietet dir ein dedizierter Linux-VPS die n\u00f6tige Kontrolle und Konsistenz f\u00fcr pr\u00e4zise Ergebnisse. Fange jetzt an, deine Befehle mit time zu messen, um einen echten Einblick in die Funktionsweise deines Linux-Systems zu erhalten. <\/p>\n","protected":false},"excerpt":{"rendered":"
Meistere den Linux time-Befehl, um die Prozessdauer und die CPU-Auslastung zu messen. Vergleiche Bash-Built-ins vs. \/usr\/bin\/time System-Metriken.<\/p>\n","protected":false},"author":50,"featured_media":27558,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"_uag_custom_page_level_css":"","site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[1399],"tags":[],"ppma_author":[1491],"class_list":["post-28723","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-tutorials"],"uagb_featured_image_src":{"full":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/01\/blog-head_linux-time-command.webp",1200,630,false],"thumbnail":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/01\/blog-head_linux-time-command-150x150.webp",150,150,true],"medium":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/01\/blog-head_linux-time-command-600x315.webp",600,315,true],"medium_large":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/01\/blog-head_linux-time-command-768x403.webp",768,403,true],"large":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/01\/blog-head_linux-time-command.webp",1200,630,false],"1536x1536":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/01\/blog-head_linux-time-command.webp",1200,630,false],"2048x2048":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/01\/blog-head_linux-time-command.webp",1200,630,false]},"uagb_author_info":{"display_name":"Tobias Mildenberger","author_link":"https:\/\/contabo.com\/blog\/de\/author\/tobias\/"},"uagb_comment_info":0,"uagb_excerpt":"Meistere den Linux time-Befehl, um die Prozessdauer und die CPU-Auslastung zu messen. Vergleiche Bash-Built-ins vs. \/usr\/bin\/time System-Metriken.","authors":[{"term_id":1491,"user_id":50,"is_guest":0,"slug":"tobias","display_name":"Tobias Mildenberger","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/077178d5dce6c3d4c0c0396857a7e544bfdf8adf04145fff5160b33a22e28b1f?s=96&d=mm&r=g","0":null,"1":"","2":"","3":"","4":"","5":"","6":"","7":"","8":""}],"_links":{"self":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/28723","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/users\/50"}],"replies":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/comments?post=28723"}],"version-history":[{"count":3,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/28723\/revisions"}],"predecessor-version":[{"id":28731,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/28723\/revisions\/28731"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/media\/27558"}],"wp:attachment":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/media?parent=28723"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/categories?post=28723"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/tags?post=28723"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/ppma_author?post=28723"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}