Trilhas
/
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 caracteres. 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 são escritas entre aspas duplas. As sequências de escape usuais são aceitas: \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 do vocabulário sequences funcionam diretamente nela.

length retorna o número de caracteres:

"hello" length .    ! => 5

nth recebe um índice com base em zero e a sequência, e retorna o elemento naquela posição. No caso de uma string, o elemento é um caractere, um ponto de código (um número inteiro), e não uma substring de um caractere:

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

De um caractere de volta para uma string

Para transformar um único ponto de código em uma string de um caractere, use 1string ( char -- str ) do vocabulário strings. CHAR: é a forma que o parser aceita para um ponto de código literal:

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

Separação

O vocabulário splitting corta uma string em pedaços.

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

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

split corta em qualquer um dos caracteres de um conjunto de separadores, podendo produzir pedaços vazios:

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

harvest (em sequences) descarta os pedaços vazios:

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

Selecionando um pedaço

Depois que uma string é dividida em um array de pedaços, first, second, third e fourth (em sequences) retornam o pedaço naquela 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 você quer todos os primeiros pedaços na pilha de uma vez, first2 e first3 desempacotam dois ou três deles em um único passo:

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

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

Em uma string, first retorna o primeiro caractere, um ponto de código, e não uma substring:

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

Remoção de espaços em branco

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

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

Conversão de maiúsculas e minúsculas

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

"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 une duas strings com um separador entre elas:

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

Instruções

Neste exercício, você vai processar linhas de log.

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

Existem três níveis de log: INFO, WARNING e ERROR.

Você tem três tarefas. Cada uma recebe uma única linha de log da pilha.

1. Obtenha a mensagem de uma linha de log

Defina message para retornar a mensagem da linha de log. Espaços em branco no início ou no final devem ser removidos.

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

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

2. Obtenha o nível de log de uma linha de log

Defina log-level para retornar o nível da linha de log, em minúsculas.

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

3. Reformate uma linha de log

Defina reformat para colocar a mensagem primeiro e o nível de log em minúsculas entre parênteses depois dela.

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

Observação: Todas as strings deste exercício são ASCII. Exercícios posteriores vão abordar o tratamento de strings com suporte a Unicode.

Editar via GitHub O link abre em uma nova janela ou aba
Factor Exercism

Tudo pronto para começar Níveis de log?

Crie sua conta no Exercism para aprender e dominar Factor com 47 conceitos163 exercícios e mentoria humana de verdade, tudo de graça.