Tracks
/
Factor
Factor
/
Übungen
/
Log-Level
Log-Level

Log-Level

Lernübung

Einführung

Ein String in Factor ist eine Folge von Zeichen. Die meisten Wörter aus dem Vokabular sequences funktionieren auch mit Strings, zusätzlich zu den speziellen Wörtern zur String-Verarbeitung in splitting, ascii und Verwandten.

String-Literale

Strings werden in doppelte Anführungszeichen gesetzt. Die üblichen Escape-Sequenzen werden unterstützt: \n, \t, \r, \\, \":

"hello, world" .                 ! => "hello, world"
"first\nsecond" print            ! prints two lines

Länge und Indexierung

Da ein String eine Sequenz ist, funktionieren die Wörter length und nth aus sequences direkt damit.

length gibt die Anzahl der Zeichen zurück:

"hello" length .    ! => 5

nth nimmt einen nullbasierten Index und die Sequenz und gibt das Element an dieser Position zurück. Bei einem String ist das Element ein Zeichen: ein Codepunkt (eine Ganzzahl), kein Teilstring aus einem Zeichen:

0 "hello" nth .     ! => 104   (CHAR: h)
4 "hello" nth .     ! => 111   (CHAR: o)

Von einem Zeichen zurück zu einem String

Um einen einzelnen Codepunkt in einen String aus einem Zeichen umzuwandeln, verwende 1string ( char -- str ) aus dem Vokabular strings. CHAR: ist die Form eines literalen Codepunkts zur Parse-Zeit:

CHAR: A 1string .                ! => "A"
0 "hello" nth 1string .          ! => "h"

Aufteilen

Das Vokabular splitting zerlegt einen String in Teile.

split1 zerlegt beim ersten Vorkommen eines Trennzeichens und gibt beide Hälften zurück:

split1 ( seq subseq -- before after )
"foo: bar" ": " split1 .s
! => "foo"
! => "bar"

split zerlegt bei jedem der Zeichen in einer Trennzeichenmenge und kann dabei leere Teile erzeugen:

"[ERROR]: Stack overflow" "[]" split .
! => { "" "ERROR" ": Stack overflow" }

harvest (in sequences) verwirft die leeren Teile:

"[ERROR]: Stack overflow" "[]" split harvest .
! => { "ERROR" ": Stack overflow" }

Einen Teil herausgreifen

Sobald ein String in ein Array von Teilen zerlegt ist, geben first, second, third und fourth (in sequences) den Teil an dieser Position zurück:

"apple,bee,carrot,duck" "," split first .    ! => "apple"
"apple,bee,carrot,duck" "," split second .   ! => "bee"
"apple,bee,carrot,duck" "," split third .    ! => "carrot"
"apple,bee,carrot,duck" "," split fourth .   ! => "duck"

Wenn du alle führenden Teile auf einmal auf dem Stack haben möchtest, packen first2 und first3 zwei oder drei davon in einem Schritt aus:

"apple,bee,carrot,duck" "," split first2 .s
! => "apple"
! => "bee"

"apple,bee,carrot,duck" "," split first3 .s
! => "apple"
! => "bee"
! => "carrot"

Auf einem String selbst gibt first das erste Zeichen zurück, einen Codepunkt, und keinen Teilstring:

"hello" first .                         ! => 104   (CHAR: h)

Trimmen

[ blank? ] trim (aus sequences, mit blank? aus dem Vokabular ascii) entfernt führenden und abschließenden Leerraum:

"  Disk full \r\n" [ blank? ] trim .
! => "Disk full"

Groß- und Kleinschreibung ändern

>lower und >upper (aus ascii) geben einen neuen String mit geänderter Groß- und Kleinschreibung zurück:

"WARNING" >lower .    ! => "warning"
"hello" >upper .      ! => "HELLO"

Verbinden

Zwei Wörter aus sequences setzen Strings zusammen:

surround umschließt einen String mit einem Präfix und einem Suffix:

surround ( seq pre post -- new-seq )
"warning" "(" ")" surround .    ! => "(warning)"

glue verbindet zwei Strings mit einem Trennzeichen dazwischen:

glue ( s1 s2 sep -- s )
"Disk full" "(error)" " " glue .    ! => "Disk full (error)"

Anleitung

In dieser Übung verarbeitest du Logzeilen.

Jede Logzeile ist ein String im Format "[<LEVEL>]: <MESSAGE>".

Es gibt drei Log-Level: INFO, WARNING und ERROR.

Du hast drei Aufgaben. Jede nimmt eine einzelne Logzeile vom Stapel.

1. Die Nachricht aus einer Logzeile ermitteln

Definiere message, um die Nachricht der Logzeile zurückzugeben. Führende und nachfolgende Leerzeichen sollen entfernt werden.

"[ERROR]: Invalid operation" message .
! => "Invalid operation"

"[WARNING]:  Disk almost full\r\n" message .
! => "Disk almost full"

2. Das Log-Level aus einer Logzeile ermitteln

Definiere log-level, um das Log-Level der Logzeile in Kleinbuchstaben zurückzugeben.

"[ERROR]: Invalid operation" log-level .
! => "error"

3. Eine Logzeile umformatieren

Definiere reformat, um die Nachricht an den Anfang zu stellen und das Log-Level in Kleinbuchstaben in Klammern dahinter zu setzen.

"[INFO]: Operation completed" reformat .
! => "Operation completed (info)"

Hinweis: Alle Strings in dieser Übung sind ASCII. Spätere Übungen beschäftigen sich mit der Verarbeitung von Strings, die Unicode berücksichtigen.

Über GitHub bearbeiten Der Link öffnet sich in einem neuen Fenster oder Tab
Factor Exercism

Bereit, mit Log-Level zu starten?

Melde dich bei Exercism an, um Factor mit 47 Konzepte163 Übungen und echtem menschlichen Mentoring zu lernen und zu meistern, alles kostenlos.