Percursos
/
Factor
Factor
/
Exercícios
/
Níveis de log
Níveis de log

Níveis de log

Exercício de aprendizagem

Introdução

Uma string em Factor é uma sequência de carateres. A maioria das palavras do vocabulário sequences funciona com strings, além das palavras dedicadas ao tratamento de strings em splitting, ascii e afins.

Literais de string

As strings escrevem-se entre aspas duplas. As sequências de escape habituais são suportadas: \n, \t, \r, \\, \":

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

Comprimento e indexação

Como uma string é uma sequência, as palavras length e nth de sequences funcionam diretamente com ela.

length devolve o número de carateres:

"hello" length .    ! => 5

nth recebe um índice com base em 0 e a sequência, e devolve o elemento nessa posição. No caso de uma string, o elemento é um caráter, ou seja, um ponto de código (um número inteiro), e não uma substring de um único caráter:

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

De um caráter de volta a uma string

Para transformar um único ponto de código numa string de um só caráter, usa 1string ( char -- str ) do vocabulário strings. CHAR: é a forma usada pelo analisador sintático para um ponto de código literal:

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

Divisão

O vocabulário splitting corta uma string em partes.

split1 corta na primeira ocorrência de um separador e devolve as duas metades:

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

split corta em qualquer um dos carateres de um conjunto de separadores, podendo produzir partes vazias:

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

harvest (em sequences) descarta as partes vazias:

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

Escolher uma parte

Depois de dividires uma string num array de partes, first, second, third e fourth (em sequences) devolvem a parte nessa posição:

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

Quando queres todas as primeiras partes na pilha de uma só vez, first2 e first3 desempacotam duas ou três delas num único passo:

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

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

No caso de uma string, first devolve o primeiro caráter (um ponto de código) e não uma substring:

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

Aparar

[ blank? ] trim (de sequences, com blank? do vocabulário ascii) remove os espaços em branco no início e no fim:

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

Conversão entre maiúsculas e minúsculas

>lower e >upper (de ascii) devolvem uma nova string com as maiúsculas e minúsculas convertidas:

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

Junção

Duas palavras de sequences montam strings:

surround envolve uma string com um prefixo e um sufixo:

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

glue junta duas strings com um separador entre elas:

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

Instruções

Neste exercício vais processar linhas de registo.

Cada linha de registo é uma string formatada como "[<LEVEL>]: <MESSAGE>".

Há três níveis de registo: INFO, WARNING e ERROR.

Tens três tarefas. Cada uma retira uma única linha de registo da pilha.

1. Obter a mensagem de uma linha de registo

Define message para devolver a mensagem da linha de registo. Qualquer espaço em branco no início ou no fim deve ser removido.

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

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

2. Obter o nível de registo de uma linha de registo

Define log-level para devolver o nível da linha de registo, em minúsculas.

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

3. Reformatar uma linha de registo

Define reformat para colocar a mensagem primeiro e o nível de registo em minúsculas entre parênteses, a seguir.

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

Nota: Todas as strings deste exercício são ASCII. Os exercícios seguintes irão abordar o tratamento de strings que tem em conta o Unicode.

Editar via GitHub A ligação abre numa nova janela ou separador
Factor Exercism

Estás pronto para começar Níveis de log?

Inscreve-te no Exercism para aprenderes e dominares Factor com 47 conceitos163 exercícios, e mentoria humana real, tudo grátis.