Due domandine

Ciao a tutti,
avrei due domande forse banali:

  1. sto utilizzando timeout() per ottenere un effettivo timeout
    in una connessione di rete. Se specifico direttamente i secondi
    in questa maniera timeout(5) funziona, mentre con timeout("#{timeout}")
    non funziona… mmh… dove sbaglio?

  2. ho letto alcuni esempi di utilizzo di getopts, e visto la mia poca
    esperienza, non riesco a capire cosa voglia dire ad esempio il “.to_i”
    in $OPT_y.to_i

grazie per la pezienza :slight_smile:
giaco

  1. Se timeout è una variabile con il numero di secondi, allora basta
    timeout(timeout)

(forse è il caso di cambiargli nome però)

Come l’hai scritto tu converti l’intero in stringa prima di passarla a
timeout()

  1. il metodo to_i converte in intero. Se la variabile $OPT_y è un float,
    allora $OPT_y.to_i lo converte in intero
  1. il fatto che prima utilizzo timeout = $OPT_T || ‘5’ e vorrei che
    l’utente
    tramite getopts possa specificare il valore di timeout
  1. Se timeout è una variabile con il numero di secondi, allora basta
    timeout(timeout)

(forse è il caso di cambiargli nome però)

Come l’hai scritto tu converti l’intero in stringa prima di passarla a
timeout()

  1. il metodo to_i converte in intero. Se la variabile $OPT_y è un float,
    allora $OPT_y.to_i lo converte in intero

On Sep 26, 2006, at 2:19 PM, Jack C. wrote:

  1. il fatto che prima utilizzo timeout = $OPT_T || ‘5’ e vorrei che
    l’utente
    tramite getopts possa specificare il valore di timeout

timeout = ($OPT_T || 5).to_i

On 9/26/06, Cristiano M. [email protected] wrote:

Su perl esiste una cosa del genere:
$i = 0;
while ($i < 18) {
print "$i ";
$i++;
}

Ma su ruby esiste il $i++; (cioè come si aumenta di 1 unità) ??

Ciao Cristiano,

puoi usare i += 1 (occhio che =+ non è la stessa cosa).
In termini di stile, si preferisce l’uso di iteratori piuttosto che
cicli
con un contatore che si autoincrementa di uno. (ad esempio 18.times{|i|
puts
i} oppure 0.upto(17){|i| puts i})

Antonio

PS: ti consiglio di fare amicizia con irb, che ti permette di
sperimentare e
chiarire dubbi. :slight_smile:

Su perl esiste una cosa del genere:
$i = 0;
while ($i < 18) {
print "$i ";
$i++;
}

Ma su ruby esiste il $i++; (cioè come si aumenta di 1 unità) ??

Grazie.

O è più efficiente

timeout = ($OPT_T.to_i || 5)

?

Cioè, come l’hai scritto tu, è sempre una sola chiamata a to_i() che
viene eseguita?

L’espressione tra parentesi vale 5 solo e soltanto se $OPT_T è false,
dico bene? Quindi se l’utente ha inserito “pippo”, a timeout verrà
assegnato “pippo”.to_i , e cioè 0 (zero l’integer, cioè NON false). Il
programma dovrebbe quindi comunque controllare che $OPT_T è un numero.

O no?

(Sto spaccando il capello in 4, lo so, ma…)

Stefano C. wrote:


Ml mailing list
[email protected]
http://lists.ruby-it.org/mailman/listinfo/ml


“Remember, always be yourself. Unless you suck.” - Joss Whedon

Ma su ruby esiste il $i++; (cioè come si aumenta di 1 unità) ??

PS: ti consiglio di fare amicizia con irb, che ti permette di sperimentare e
chiarire dubbi. :slight_smile:

Sakrosanto, ed ho scoperto una cosa che ho trovato abbastanza curiosa:
guardate un po’:

irb(main):001:0> i = 1
=> 1
irb(main):002:0> i++
irb(main):003:0* i
=> 2

Insomma, sembrerebbe funzionare (anche se non ritorna niente,
incrementa la variabile), ma continuando:

irb(main):004:0> i++
irb(main):005:0* i
=> 2

Confuso, faccio qualche altra prova, e con altri valori iniziali di i
‘scopro’ che var++ moltiplica per due, ma una volta sola!

Chiamo a raccolta tutto (quasi) l’ufficio, e dopo un po’ ‘scopriamo’
quest’altra cosa:

irb(main):025:0> i=9
=> 9
irb(main):026:0> i++
irb(main):027:0* i++
irb(main):028:0* i++
irb(main):029:0* i
=> 36

A questo punto il mondo si e’ gia’ diviso in 10 (in base 2) categorie
di persone. Io appartengo alla seconda, quella di chi ancora non ci
era arrivato, mentre altri fra voi si staranno facendo grasse risate.
Ad ogni modo, ho appreso una serie di cose utili:

  1. La sintassi di Ruby e’ veramente molto, molto liberale, ma Matz ha
    preferito non guastarla con zucchero inutile.
  2. Non e’ Ruby che e’ pazzo, ma io che so’ stupido (sia perche’ le *
    dovevano insospettirmi, sia perche’ lo sapevo che qualsiasi
    espressione DEVE ritornare qualcosa)
  3. Che in genere e’ meglio non usare l’operatore ++, dato che
    effettivamente non esiste, ma in alcuni contesti fa finta di si
  4. Che irb e’ veramente utile, si scoprono sempre cose interessanti!

Ciao!

Ciao,
una cosa del genere puo’ andare?

timeout = ($OPT_T || 5).to_i
usage if $OPT_T !~ /\d/

grazie

david wrote:

O è °i?iciente

timeout = ($OPT_T.to_i || 5)

?

Cioè¬ come l’hai scritto tu, è ³empre una sola chiamata a to_i() che
viene eseguita?

L’espressione tra parentesi vale 5 solo e soltanto se $OPT_T è ¦alse,
dico bene? Quindi se l’utente ha inserito “pippo”, a timeout verrà ?assegnato “pippo”.to_i , e cioè ° (zero l’integer, cioè ?ON false). Il
programma dovrebbe quindi comunque controllare che $OPT_T è µn numero.

O no?

(Sto spaccando il capello in 4, lo so, ma…)

Stefano C. wrote:


Ml mailing list
[email protected]
http://lists.ruby-it.org/mailman/listinfo/ml


“Remember, always be yourself. Unless you suck.” - Joss Whedon

cerco che ruby e’ veramente pignolo… :slight_smile:

timeout = ($OPT_T || 5).to_i
usage unless timeout =~ /\d/

oppure una cosa:

timeout = ($OPT_T || 5).to_i
usage unless timeout =~ /\d/

if timeout
usage unless timeout =~ /\d/
end

possibile che non funziona? Mi torna sempre usage…

Jack C. wrote:

Ciao,
una cosa del genere puo’ andare?

timeout = ($OPT_T || 5).to_i
usage if $OPT_T !~ /\d/

grazie

david wrote:

O è °i?iciente

timeout = ($OPT_T.to_i || 5)

?

Cioè¬ come l’hai scritto tu, è ³empre una sola chiamata a to_i() che
viene eseguita?

L’espressione tra parentesi vale 5 solo e soltanto se $OPT_T è ¦alse,
dico bene? Quindi se l’utente ha inserito “pippo”, a timeout verrà ?assegnato “pippo”.to_i , e cioè ° (zero l’integer, cioè ?ON false). Il
programma dovrebbe quindi comunque controllare che $OPT_T è µn numero.

O no?

(Sto spaccando il capello in 4, lo so, ma…)

Stefano C. wrote:


Ml mailing list
[email protected]
http://lists.ruby-it.org/mailman/listinfo/ml


“Remember, always be yourself. Unless you suck.” - Joss Whedon

  1. il metodo String#to_i restituisce un valore di tipo intero sempre
    (vedi ri).

  2. il metodo Object#=~ lo chiami su un intero (non esiste Fixnum#=~
    quindi stai usando Object#=~) che da sempre false, quindi usage
    viene sempre lanciata

quindi fai pure una cosa tipo:

Input: Prendi timeout dalle opzioni di command line. Qui timeout ha

come valore una stringa!

timeout = get_timeout_from_opts_using_what_you_want

Validazione: Chiami usage se non è un numero. il =~ lo fai su una

stringa

usage unless /\d/ =~ timeout

Parsing: lo trasformi in un numero.

timeout = timeout.to_i

se invece sei un tipo che vuole fare tutto one-line senza fare troppi
#to_i:

timeout = (usage if ($OPT_T and not $OPT_T =~ /\d/)) || ($OPT_T.to_i if
$OPT_T) || 5

Jack C. [email protected] writes:

cerco che ruby e’ veramente pignolo… :slight_smile:

Ruby non fa type casting

On Sep 27, 2006, at 5:08 PM, Jack C. wrote:

if timeout
usage unless timeout =~ /\d/
end

possibile che non funziona? Mi torna sempre usage…

“timeout” e’ un Fixnum, per cui l’operatore =~ tornera’ sempre false

if $OPT_T =~ /^\d+$/
timeout = ($OPT_T || 5).to_i
else
usage
end

fossi figo, farei:

def usage
puts “Istruzioni per scrivere correttamente un numero intero:”
puts " - digitare una o piu’ cifre decimali"
exit(0)
end

timeout = Integer($OPT_T) rescue usage

Ciao Luca,

ti spiego cosa accade, per te o per i viaggiatori nel cronotopo di google
:slight_smile:

Ti ringrazio, piu’ che altro a nome degli altri. Non ero stato
esplicito ma credevo si fosse capito che alla fine perfino io ci ero
arrivato!

:wink:

On 9/27/06, Luca de Marinis [email protected] wrote:

  1. Che in genere e’ meglio non usare l’operatore ++, dato che
    effettivamente non esiste, ma in alcuni contesti fa finta di si

Ciao Luca,

ti spiego cosa accade, per te o per i viaggiatori nel cronotopo di
google
:slight_smile:
Le parentesi opzionali in Ruby possono portare a comportamenti
inaspettati,
se non si fa attenzione.

irb(main):001:0> i = 1

=> 1
irb(main):002:0> i++
irb(main):003:0* i
=> 2

In Ruby non esiste l’operatore ++. Quello che stai facendo è equivalente
a:

irb(main):001:0> i = 1
=> 1
irb(main):002:0> i+(+
irb(main):003:1* i)
=> 2
irb(main):004:0> i
=> 1

In pratica il secondo + diventa parte dell’argomento per il primo
operatore
+. Quando premi invio, irb aspetta ancora un valore da affiancare a quel
secondo + per completare l’argomento che deve essere di tipo numerico.
Nel
momento in cui scrivi i e premi invio, quello che ottieni è il seguente:
i+(+i) = 1+(+1) = 2. Per cui stai semplicemente calcolando 1+1, ma non
fai
alcun assegnamento alla variabile i che rimane 1, come puoi notare dalla
mia
sessione irb.

Applicando lo stesso ragionamento alla tua sessione:

irb(main):025:0> i=9

=> 9
irb(main):026:0> i++
irb(main):027:0* i++
irb(main):028:0* i++
irb(main):029:0* i
=> 36

Verifichi facilmente che equivale a dire, i+(+i+(+i+(+i))) =
9+(+9+(+9+(+9))) = 36. Si tratta di una semplice somma, quindi il valore
di
i, rimane inalterato (9).

“1”.to_i *2: qual’è il suo valore? Provalo in irb e vedrai che vale 1. :wink:

Ciao,
Antonio

On 9/29/06, Alessio C. [email protected] wrote:

“1”.to_i *2: qual’è il suo valore? Provalo in irb e vedrai che vale 1.
:wink:

Questa non l’ho capita.
Togliendo lo spazio restituisce 2, con lo spazio 1, come mai?

Ciao Alessio,

se aggiungi uno spazio tra * e 2, o rimuovi lo spazio tra to_i e *, stai
semplicemente calcolando “1”.to_i * 2 = 1 * 2 = 2. E fin qui nulla di
strano.
Quando calcoli “1”.to_i *2, si ottiene 1. La spiegazione è abbastanza
semplice:

“1”.to_i *2 equivale a “1”.to_i(*2).

Il metodo String#to_i accetta una valore intero che ne specifica la base
numerica (per cui “110”.to_i(2) restituisce 6).
L’asterisco usato come ‘operatore’ unario, è un ‘array expansion argument
specifier’ come lo ha definito matz. In altre parole espande un array
quando
lo si passa come argomento:

my_method([“uno”,“due”,“tre”]) # passa 1 parametro (l’array)
my_method(*[“uno”,“due”,“tre”]) # passa 3 parametri (le tre stringhe)

2 non è un array, si tratta perciò di un caso degenere nel quale
l’espansione di (*2) equivale semplicemente a passare l’argomento 2.

Per cui l’espressione diventa:

“1”.to_i *2 = “1”.to_i(*2) = “1”.to_i(2) = 1

(perché ovviamente 1 in base 2, equivale a 1 in base 10)

Ciao,
Antonio

Il giorno 30/set/06, alle ore 07:51, Antonio C. ha scritto:

[…]
Per cui l’espressione diventa:

“1”.to_i *2 = “1”.to_i(*2) = “1”.to_i(2) = 1

(perché ovviamente 1 in base 2, equivale a 1 in base 10)

Ciao,
Antonio

Credo che d’ora in poi starò più attento quando non uso le parentesi
(in realtà quasi mai).

Grazie mille,
Alessio


Alessio
“il sapere umano appartiene al mondo”
–skullbox, synapse
JID:[email protected]
SIP:[email protected]

2006/9/28, Antonio C. [email protected]:

[…]

“1”.to_i *2: qual’è il suo valore? Provalo in irb e vedrai che vale 1. :wink:

Questa non l’ho capita.
Togliendo lo spazio restituisce 2, con lo spazio 1, come mai?

Ciao

Alessio
Jabber(GTalk): [email protected]

“Il sapere umano appartiene al mondo”
–Skullbox, Synapse

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs