{"id":38698,"date":"2024-12-10T04:38:43","date_gmt":"2024-12-10T04:38:43","guid":{"rendered":"https:\/\/www.railscarma.com\/?p=38698"},"modified":"2024-12-10T05:12:52","modified_gmt":"2024-12-10T05:12:52","slug":"come-utilizzare-il-metodo-delle-mappe-in-ruby-con-esempi","status":"publish","type":"post","link":"https:\/\/www.railscarma.com\/it\/blog\/come-utilizzare-il-metodo-delle-mappe-in-ruby-con-esempi\/","title":{"rendered":"Come utilizzare il metodo Ruby Map con esempi"},"content":{"rendered":"
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Ruby \u00e8 un potente linguaggio di programmazione e uno dei suoi metodi pi\u00f9 versatili e comunemente utilizzati \u00e8 il metodo map. Che si tratti di trasformare array o di semplificare operazioni complesse, il metodo map \u00e8 un metodo indispensabile per ogni sviluppatore Ruby. In questo articolo esploreremo cos'\u00e8 il metodo map, come funziona e forniremo esempi pratici per aiutarvi a integrarlo nel vostro flusso di lavoro di sviluppo Ruby.<\/p>\n

Che cos'\u00e8 il metodo Ruby Map?<\/strong><\/h2>\n

Il metodo map \u00e8 un metodo enumerabile di Ruby usato per creare un nuovo array trasformando ogni elemento di un array o di un insieme esistente. Applica un determinato blocco di codice a ogni elemento e restituisce l'array risultante.<\/p>\n

Questo metodo \u00e8 particolarmente utile quando si desidera modificare o trasformare elementi senza alterare la matrice originale.<\/p>\n

Sintassi del metodo Mappa<\/strong><\/h3>\n

rubino<\/p>\n

array.map { |elemento| blocco }\n# O\narray.map do |elemento|\n  blocco\nfine<\/pre>\n
Caratteristiche principali:<\/strong><\/h3>\n
    \n
  1. Non distruttivo<\/strong>: L'array originale rimane invariato, a meno che non venga utilizzato map! (con un punto esclamativo).<\/li>\n
  2. Compatibilit\u00e0 enumerabile<\/strong>: Funziona su qualsiasi enumerabile, come array e hash.<\/li>\n<\/ol>\n
    Esempio di base del metodo Ruby Map<\/strong><\/h2>\n
    Cominciamo con un semplice esempio:<\/p>\n
    rubino<\/p>\n
    numeri = [1, 2, 3, 4, 5]\nnumeri_quadrati = numeri.map { |num| num ** 2 }\nputs numeri_quadrati\n# Uscita: [1, 4, 9, 16, 25]<\/pre>\n
    Qui, il blocco { |num| num ** 2 }<\/code> prende ogni numero, lo eleva al quadrato e crea un nuovo array con i risultati.<\/p>\n
    Quando utilizzare il metodo Ruby Map<\/strong><\/h2>\n
    Utilizzare il mappa<\/code> quando \u00e8 necessario:<\/p>\n
      \n
    1. Applica la stessa operazione a ogni elemento di un insieme.<\/li>\n
    2. Trasformare i dati da una forma all'altra.<\/li>\n
    3. Genera un nuovo array da uno esistente senza modificare l'originale.<\/li>\n<\/ol>\n
      Usare Ruby Map con le stringhe<\/strong><\/h2>\n
      \u00c8 possibile utilizzare il pulsante mappa<\/code> per manipolare le stringhe in un array.<\/p>\n
      rubino<\/p>\n
      nomi = [\"Alice\", \"Bob\", \"Charlie\"]\nnomi_maiuscoli = nomi.map { |nome| nome.maiuscolo }\nputs nomi_maiuscoli\n# Output: [\"ALICE\", \"BOB\", \"CHARLIE\"]<\/pre>\n
      Usare Ruby Map con gli hash<\/strong><\/h2>\n
      mappa<\/code> funziona perfettamente anche con gli hash:<\/p>\n
      rubino<\/p>\n
      studenti = { \"Alice\" => 85, \"Bob\" => 90, \"Charlie\" => 78 }\nadjusted_scores = students.map { |nome, punteggio| [nome, punteggio + 5] }.to_h\nmette adjusted_scores\nUscita #: {\"Alice\"=>90, \"Bob\"=>95, \"Charlie\"=>83}<\/pre>\n
      Qui, mappa<\/code> trasforma ogni coppia chiave-valore in un array modificato e lo converte di nuovo in un hash usando to_h<\/code>.<\/p>\n
      Usare Ruby Map con gli intervalli<\/strong><\/h2>\n
      Il mappa<\/code> funziona anche con gli intervalli:<\/p>\n
      rubino<\/p>\n
      intervallo = (1..5)\nvalori_doppiati = range.map { |num| num * 2 }\nmette valori_doppiati\n# Uscita: [2, 4, 6, 8, 10]<\/pre>\n
      Concatenare Ruby Map con altri metodi<\/strong><\/h2>\n
      Il mappa<\/code> pu\u00f2 essere combinato con altri metodi enumerabili per operazioni pi\u00f9 complesse:<\/p>\n
      rubino<\/p>\n
      numeri = [1, 2, 3, 4, 5]\nrisultato = numbers.map { |num| num ** 2 }.select { |num| num > 10 }\nputs risultato\n# Risultato: [16, 25]<\/pre>\n
      In questo caso, i numeri vengono elevati al quadrato e poi vengono selezionati solo quelli superiori a 10.<\/p>\n
      Usare Ruby Map con blocchi o processi<\/strong><\/h2>\n
      Si possono passare blocchi o proc al metodo mappa<\/code> per una migliore riutilizzabilit\u00e0.<\/p>\n
      rubino<\/p>\n
      incremento = Proc.new { |num| num + 1 }\nnumeri = [1, 2, 3, 4, 5]\nnumeri_incrementati = numbers.map(&increment)\nputs numeri_incrementati\n# Uscita: [2, 3, 4, 5, 6]<\/pre>\n
      Differenza tra Mappa e Ciascuno<\/strong><\/h2>\n
      Mentre entrambi mappa<\/code> E ciascuno<\/code> possono iterare un array, ma hanno casi d'uso diversi:<\/p>\n\n\n\n\n\n
      Mappa<\/th>\nCiascuno<\/th>\n<\/tr>\n
      Trasforma gli elementi e restituisce un nuovo array.<\/td>\nEsegue un blocco per ogni elemento, ma non restituisce un nuovo array.<\/td>\n<\/tr>\n
      Si usa quando \u00e8 necessario modificare gli elementi.<\/td>\nUtilizzato per gli effetti collaterali, come la stampa o la registrazione.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      Esempio con ciascuno<\/code>:<\/p>\n
      rubino<\/p>\n
      numbers.each { |num| puts num ** 2 }\n# Uscita:\n# 1\n# 4\n# 9\n# 16\n# 25<\/pre>\n
      Il risultato viene stampato, ma l'array originale non viene modificato e non viene restituito un nuovo array.<\/p>\n
      Utilizzo di Map with Bang (!) per la trasformazione distruttiva<\/strong><\/h2>\n
      Se si vuole modificare l'array originale, usare mappa!<\/code>:<\/p>\n
      rubino<\/p>\n
      numeri = [1, 2, 3, 4, 5]\nnumeri.map! { |num| num ** 2 }\nputs numeri\n# Uscita: [1, 4, 9, 16, 25]<\/pre>\n
      Esempi avanzati<\/strong><\/h3>\n
      Mappa con array annidati<\/strong><\/h4>\n
      rubino<\/p>\n
      matrice = [[1, 2], [3, 4], [5, 6]]\nappiattito_e_squadrato = matrice.map { |arr| arr.map { |num| num ** 2 } }\nputs appiattito_e_squadrato\nUscita #: [[1, 4], [9, 16], [25, 36]]<\/pre>\n
      Mappa per semplificare gli oggetti<\/strong><\/h4>\n
      rubino<\/p>\n
      utenti = [\n  { nome: \"Alice\", et\u00e0: 25 },\n  { nome: \"Bob\", et\u00e0: 30 },\n  { nome: \"Charlie\", et\u00e0: 35 }\n]\nnomi_utenti = utenti.map { |utente| utente[:nome] }\nputs nomi_utente\n# Output: [\"Alice\", \"Bob\", \"Charlie\"].<\/pre>\n
      Punti di forza<\/strong><\/h3>\n