Share
Ruby è una delle lingue più popolari utilizzate sul web. Abbiamo avviato una nuova serie di screencast qui su Nettuts + che ti introdurrà a Ruby, oltre ai grandi framework e strumenti che accompagnano lo sviluppo di Ruby. In questa lezione, daremo un'occhiata più approfondita agli operatori di Ruby e perché sono diversi da qualsiasi cosa tu abbia mai visto prima.
Hai familiarità con gli operatori.
1 + 2 # 3 persona [: nome] = "Joe"
Gli operatori sono cose come il segno più (uno degli operatori aritmetici) o il segno di uguale (l'operatore di assegnazione). Queste cose non sembrano molto diverse da quelle che usi in JavaScript, in PHP o in qualsiasi altra lingua. Ma, come la maggior parte di Ruby, qui c'è molto più di quanto non sembri.
Ecco il segreto: gli operatori di Ruby sono chiamate di metodo. Prova questo:
1. + (2) # 3
Qui, stiamo chiamando il + operatore sull'oggetto 1, passando nell'oggetto 2 come parametro Ritorniamo l'oggetto 3. Possiamo farlo anche con le stringhe:
Accentsconagua
name = "Joe" nome. + ("Smith") # "Joe Smith", ma "nome" è ancora "Joe" nome + = "Smith" # nome è ora "Joe Smith" Come puoi vedere, possiamo fare concatenazione di stringhe con il + metodo. Come bonus qui, ruby definisce l'operatore + = basato sull'operatore + (nota: non puoi usare + = come metodo).
Come puoi immaginare, questo ci dà un potere incredibile. Possiamo personalizzare il significato di aggiungere, sottrarre e assegnare oggetti nelle nostre classi personalizzate. Abbiamo visto come funziona con le proprietà sugli oggetti nella nostra lezione sulle classi (abbiamo definito a proprietà e property = metodo nella classe e ottenuto lo zucchero di sintassi previsto per il loro utilizzo). Quello che stiamo guardando qui sta facendo un ulteriore passo avanti.
Proviamo a creare uno di questi metodi noi stessi. Per questo esempio, creiamo un oggetto frigorifero, con cui possiamo aggiungere cose tramite + operatore e prendere le cose fuori dal - operatore.
Ecco l'inizio della nostra lezione:
classe Fridge def inizializzare (bevande = [], alimenti = []) @ bevande = bevande @ alimenti = alimenti fine def + (articolo) fine def - (articolo) fine fine
Nostro inizializzare la funzione è piuttosto semplice: prendiamo due parametri (che ricadono sugli array vuoti se non viene dato nulla) e li assegniamo alle variabili di istanza. Ora, creiamo queste due funzioni:
def + (item) se item.is_a? Beverage @ drinks.push item else @ foods.push end fine articolo
Questo è piuttosto semplice. Ogni oggetto ha un è un? metodo che accetta un singolo parametro: una classe. Se l'oggetto è un'istanza di quella classe, restituirà true; altrimenti, restituirà false. Quindi, questo dice che se l'oggetto che stiamo aggiungendo al frigo è un bevanda, lo aggiungeremo al @bevande array. Altrimenti, lo aggiungeremo al @cibo schieramento.
Quello è buono; ora, che ne dici di togliere le cose dal frigo? (Nota: questo metodo è diverso da quello mostrato nel video, questo dimostra che questo metodo di operatore ci dà una grande flessibilità, sono solo metodi normali con cui puoi fare qualsiasi cosa. Inoltre, penso che questo sia un versione migliore del metodo, tuttavia è più complessa).
def - (item) ret = @ drinks.find do | beverage | beverage.name.downcase == item.downcase end return @ drinks.delete ret se ret.nil? ret = @ foods.find do | food | food.name.downcase == item.downcase end @ foods.delete ret end
Ecco cosa sta succedendo quando usiamo l'operatore meno. Il parametro che ci vuole è una stringa, con il nome dell'elemento che stiamo cercando (A proposito, creeremo il file bevanda e Cibo classi presto). Iniziamo usando il trova metodo che hanno gli array. Ci sono alcuni modi per utilizzare questo metodo; stiamo passando un blocco; questo blocco dice che stiamo cercando di trovare l'elemento nell'array che ha a nome proprietà uguale alla stringa passata; nota che stiamo convertendo entrambe le stringhe in lettere minuscole, per essere sicuri.
Se c'è un elemento che corrisponde nell'array, verrà archiviato macerare; altrimenti, macerare sarà zero. Successivamente, restituiremo il risultato di @ beverage.delete ret, che rimuove l'elemento dall'array e lo restituisce. Si noti che stiamo usando un modificatore di dichiarazione alla fine di quella linea: lo facciamo salvo che macerare è zero.
Potresti chiederti perché stiamo usando la parola chiave ritorno qui, poiché non è richiesto in Ruby. Se non lo avessimo usato qui, la funzione non tornerebbe ancora, dal momento che c'è più codice per la funzione. utilizzando ritorno qui ci consente di restituire un valore da un luogo che la funzione normalmente non restituirebbe.
Se non torniamo, significa che l'oggetto non è stato trovato in @bevande. Pertanto, supponiamo che sia dentro @Alimenti. Faremo la stessa cosa per trovare l'oggetto @Alimenti e poi restituirlo.
Prima di testare questo, avremo bisogno del nostro Cibo e Bevande classi:
classe Beverage attr_accessor: nome def inizializza nome @name = nome @time = Time.now end end classe Cibo attr_accessor: nome def inizializza nome @name = nome @time = Time.now end end
Si noti che nel video, non l'ho fatto @nome accessibile dall'esterno dell'oggetto. Ecco, lo sto facendo con attr_accessor: nome, in modo che possiamo controllare il nome di questi oggetti quando sono all'interno di un frigorifero.
Quindi proviamolo in irb; inizieremo richiedendo il file che contiene il codice; quindi, provate le classi; nota che ho aggiunto interruzioni di riga all'output per facilitare la lettura.
