Tracks
/
Factor
Factor
/
Ejercicios
/
Niveles de registro
Niveles de registro

Niveles de registro

Ejercicio de aprendizaje

Introducción

Un string en Factor es una secuencia de caracteres. La mayoría de las palabras del vocabulario sequences funcionan con strings, además de las palabras dedicadas al manejo de strings en splitting, ascii y similares.

Literales de string

Los strings se escriben entre comillas dobles. Se admiten los escapes habituales: \n, \t, \r, \\, \":

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

Longitud e indexación

Como un string es una secuencia, las palabras length y nth de sequences funcionan directamente sobre él.

length devuelve la cantidad de caracteres:

"hello" length .    ! => 5

nth toma un índice con base 0 y la secuencia, y devuelve el elemento en esa posición. En el caso de un string, el elemento es un carácter, un punto de código (un entero), no un substring de un solo carácter:

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

De un carácter de vuelta a un string

Para convertir un solo punto de código en un string de un carácter, usa 1string ( char -- str ) del vocabulario strings. CHAR: es la forma que toma un punto de código literal en tiempo de análisis sintáctico:

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

División

El vocabulario splitting corta un string en pedazos.

split1 corta en la primera aparición de un separador y devuelve ambas mitades:

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

split corta por cualquiera de los caracteres de un conjunto de separadores, y puede producir pedazos vacíos:

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

harvest (en sequences) descarta los pedazos vacíos:

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

Seleccionar un pedazo

Una vez que un string se divide en un array de pedazos, first, second, third y fourth (en sequences) devuelven el pedazo en esa posición:

"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"

Cuando quieres todos los primeros pedazos en la pila a la vez, first2 y first3 desempaquetan dos o tres de ellos en un solo paso:

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

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

Sobre un string mismo, first devuelve el primer carácter (un punto de código) en lugar de un substring:

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

Recorte

[ blank? ] trim (de sequences, con blank? del vocabulario ascii) elimina los espacios en blanco al principio y al final:

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

Conversión de mayúsculas y minúsculas

>lower y >upper (de ascii) devuelven un string nuevo con las mayúsculas y minúsculas cambiadas:

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

Unión

Dos palabras de sequences ensamblan strings:

surround envuelve un string con un prefijo y un sufijo:

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

glue une dos strings con un separador entre ellos:

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

Instrucciones

En este ejercicio vas a procesar líneas de log.

Cada línea de log es un string con el formato "[<LEVEL>]: <MESSAGE>".

Hay tres niveles de log: INFO, WARNING y ERROR.

Tienes tres tareas. Cada una toma una sola línea de log de la pila.

1. Obtén el mensaje de una línea de log

Define message para que devuelva el mensaje de la línea de log. Hay que eliminar los espacios en blanco al principio o al final.

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

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

2. Obtén el nivel de log de una línea de log

Define log-level para que devuelva el nivel de la línea de log, en minúsculas.

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

3. Reformatea una línea de log

Define reformat para que ponga el mensaje primero y, después, el nivel de log en minúsculas entre paréntesis.

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

Nota: Todos los strings de este ejercicio son ASCII. Los ejercicios posteriores abordarán el manejo de strings que tenga en cuenta Unicode.

Editar en GitHub El enlace se abre en una ventana o una pestaña nuevas
Factor Exercism

¿Todo listo para empezar Niveles de registro?

Regístrate en Exercism para aprender y dominar Factor con 47 conceptos163 ejercicios y mentoría humana real, todo gratis.