Track
/
Ruby
Ruby
/
Esercizi
/
Parser di righe di log
Parser di righe di log

Parser di righe di log

Esercizio di apprendimento

Introduzione

Come tutto in Ruby, una String è un oggetto. Le stringhe sono costituite da una sequenza arbitraria di byte (normalmente caratteri) e vengono inizializzate e manipolate come qualsiasi altro oggetto. Infatti, una delle cose più utili di Ruby è il gran numero di metodi che si possono chiamare sulle stringhe (e su altri oggetti) per risparmiare molto tempo nella scrittura del codice. In questo esercizio esploreremo e giocheremo con alcuni di questi metodi ausiliari.

Creare una stringa

Anche se puoi usare String.new(...) per creare una stringa, è molto più comune usare un letterale. Esistono molti letterali diversi che puoi usare: si dividono in due categorie, quelli che permettono l'interpolazione e quelli che non la permettono.

I letterali più comuni sono gli apici singoli e doppi ('...' e "..."). Gli apici singoli non permettono l'interpolazione, mentre quelli doppi sì. L'interpolazione consiste nell'includere una stringa dentro un'altra usando la sintassi #{}.

# Use single quotes when not interpolated
location = 'World'

# And double quotes when interpolated
puts "Hello, #{location}!"   #=> "Hello, World!"

Puoi anche usare altri letterali come %{... } per le stringhe interpolate e %q{...} per le stringhe non interpolate. Sono utili se le tue stringhe contengono i caratteri ' o ".

Nota: non esiste una regola assoluta che dica che devi usare stringhe non interpolate se la tua stringa non contiene interpolazione.

Interagire con le stringhe

È utile pensare alle stringhe in Ruby in modo simile a come pensi agli array. Hanno una dimensione e i loro caratteri sono indicizzati (con 0 come primo indice):

my_string = "Some string"

my_string.size   #=> 11

my_string[0]    #=> 'S'
my_string[1]    #=> 'o'
my_string[-1]   #=> 'g'

# Find the first index of a character
my_string.index('m')   #=> 2

Parti di una stringa possono essere estratte usando gli indici o slice:

my_string = "Some string"

# Find three characters starting with the second character (index 1)
my_string[1, 3]         #=> "ome"
my_string.slice(1, 3)   #=> "ome"

Anche i valori semantici delle stringhe possono essere manipolati. Vale la pena esplorare la documentazione di Ruby per conoscere tutti i metodi, ma ecco alcuni esempi di uso comune:

"hello".capitalize   #=> "Hello"
"HELLO".downcase     #=> "hello"
"hello".center(9)    #=> "  hello  "
"  hello  ".strip    #=> "hello"

"hello world".split(" ")   #=> ["hello", "world"]

Puoi anche usare metodi come gsub per sostituire i caratteri:

# Replace one character with another
"noob".gsub("o","0")   #=> "n00b"

# (Advanced) Replace a regular expression
"Ruby really rocks".gsub(/[aieou]/,'')   #=> "Rby rlly rcks"

In tutti gli esempi precedenti, viene restituita una nuova String. Tuttavia, molti metodi hanno equivalenti che terminano con ! e che modificano effettivamente la stringa stessa.

# Use normal methods to return new strings
my_string = "hello"
my_string.capitalize   #=> "Hello"
puts my_string         #=> "hello"

# And bang-methods (...!) to modify the object
my_string = "hello"
my_string.capitalize!  #=> "Hello"
puts my_string         #=> "Hello"

Istruzioni

In questo esercizio elaborerai righe di log.

Ogni riga di log è una stringa formattata così: "[<LEVEL>]: <MESSAGE>".

Ci sono tre diversi livelli di log:

  • INFO
  • WARNING
  • ERROR

Hai tre attività: ognuna prenderà una riga di log e ti chiederà di fare qualcosa con essa. Ci sono tanti modi per risolvere queste attività: scegli i metodi che preferisci tra gli esempi qui sopra e vedi cosa ti viene in mente.

1. Estrarre il messaggio da una riga di log

Implementa il metodo LogLineParser#message per restituire il messaggio di una riga di log:

LogLineParser.new('[ERROR]: Invalid operation').message
# => "Invalid operation"

Eventuali spazi bianchi iniziali o finali devono essere rimossi:

LogLineParser.new("[WARNING]:  Disk almost full\r\n").message
# => "Disk almost full"

2. Estrarre il livello di log da una riga di log

Implementa il metodo LogLineParser#log_level per restituire il livello di log di una riga di log, che deve essere restituito in minuscolo:

LogLineParser.new('[ERROR]: Invalid operation').log_level
# => "error"

3. Riformattare una riga di log

Implementa il metodo LogLineParser#reformat che riformatta la riga di log, mettendo prima il messaggio e poi il livello di log tra parentesi:

LogLineParser.new('[INFO]: Operation completed').reformat
# => "Operation completed (info)"
Modifica tramite GitHub Il link si apre in una nuova finestra o scheda
Ruby Exercism

Vuoi iniziare Parser di righe di log?

Iscriviti a Exercism per imparare e padroneggiare Ruby con 21 concetti121 esercizi e il mentoring di persone reali, tutto gratis.