GeckoGeek.fr

Paradigme d'un lézard

Mercredi 19 Juillet 2017

Les Tableaux Ruby : Array en détails

Par Lya le 08/10/2009 dans Programmation | 4 commentaires

Continuons sur la lancée programmation. Après avoir fait un petit tour par QT, nous allons nous pencher sur Ruby. Avant de voir des choses plus compliquées, voici un petit récapitulatif sur la manipulation de tableaux en Ruby. Vous y trouverez des informations sur la manière d’utiliser les méthodes associées à la classe Array mais aussi quelles sont celles qui sont les plus judicieuses à utiliser selon vos besoins (en terme de rapidité & d’efficacité, cf les commentaires dans les blocs de code). Pour les méthodes non abordées, n’hésitez pas à vous reporter à la documentation de la classe Array.

RubyCraft

Déclaration & Initialisation

Déclaration

Allons-y ! Commençons par le commencement : la création de tableau. Pour créer un tableau en Ruby, il suffit d’énumérer entre crochets les objets que l’on veut y mettre. Ces tableaux peuvent contenir des objets de types divers et variés. Voici différentes façon de créer un tableau selon le besoin :

myTab = [] # Create an empty tab
myTab = Array.[] # Create an empty tab (same that the previous line)
myTab = Array.new # Create an empty tab (another way, slower)
myTab = ["dragon"] # Create a tab with one element
myTab = ["dragon", 4, "wolf"] # Create a tab with more than one element and various objects

NB : en Ruby il existe un grand nombre de méthodes. Par soucis d’optimisation, prenez soin d’utiliser celles qui correspondent le mieux à vos besoins. En effet, si vous souhaitez seulement créer un tableau vide, la méthode Array.[] sera plus efficace et plus rapide que Array.new car cette seconde méthode est plus appropriée si l’on veut préciser une taille de tableau. Elle permet plusieurs paramètres possibles en entrée de son prototype ce qui implique une série de tests dans le constructeur, alors que la première est directe, et donc plus rapide. N’hésitez pas à aller regarder les codes sources de ces méthodes dans la documentation (en cliquant sur les prototypes).

Parler de plusieurs dimensions pour un tableau Ruby dans le sens ‘2D’, ‘3D’, etc, est plutôt une question de formalisme. En réalité en Ruby, dans un tableau on range des objets, et chacun de ces objets ont leur propre dimension (qui peut être différente de celle des autres). Pour ne pas être trop perdu par rapport à d’autres langages voici la création d’un tableau de ‘dimension 2′ :

myTab = [[],[]] # Create an empty tab (2 lin * 1 col)
myTab = Array.new(2) {|i| Array.new(1) {|j| 0} } # Create an empty tab (2 lin * 1 col) initialize with 0 (another way)
myTab = [["dragon"], ["wolf"]] # Create a tab 2*1 : myTab[0][0] = "dragon" myTab[1][0] = "wolf"
myTab = [["dragon", "wolf"], [4, 22]] # Create a tab 2*2 : myTab[0][0] = "dragon" myTab[0][1] = "wolf" myTab[1][0] = 4 myTab[1][1] = 22 

Voilà, nous avons donc notre tableau. En passant voici une petite astuce intéressante : si vous souhaitez avoir une liste des méthodes utilisables sur un objet, notre tableau par exemple ici, il vous suffit d’écrire :

puts myTab.methods

NB : on peut aussi obtenir le tableau en convertissant un intervalle :

myTab = (1..10).to_a
myTab = (1..10).entries # (alias)

Initialisation

Soit nous avons initialisé notre tableau lors de sa déclaration, soit nous ajoutons des objets par la suite à notre tableau vide :

myTab<<22 # Add an object at the end
myTab.push(22) # Add an object at the end (another way, slower for only one object, faster otherwise)
myTab<<22<<"ice" # Add more than one object at the end
myTab.push(22, "ice") # Add more than one object at the end (another way, faster)
myTab<<[22,4] # Add a two dimension object at the end
myTab.push([22,4]) # Add a two dimension object at the end (another way, slower for only one object, faster otherwise)

Manipulation

Maintenant voyons comment manipuler les objets du tableau que nous avons créé.

Accéder aux objets

Le besoin que nous rencontrons le plus souvent est l’accès aux objets. On peut vouloir accéder à un objet en particulier ou à un groupe d’objets, récupérer leur index. Cela va nous amener au parcours du tableau, très utile pour afficher les objets ou les modifier.

Accéder à un objet

On peut accéder à un objet par son index positif (de gauche à droite) ou négatif (de droite à gauche) :

myTab[1] # Get the second object of the tab
myTab.slice(1) # Get the second object of the tab (same that the previous line, alias)
myTab.fetch(0) # Get the second object of the tab (another way, a little faster)
myTab.at(1) # Get the second object of the tab (another way, faster)

myTab[-2] # Get the next to last object of the tab 
myTab.slice(-2) # Get the next to last object of the tab (same that the previous line, alias)
myTab.fetch(-2) # Get the next to last object of the tab (another way, a little faster)
myTab.at(-2) # Get the next to last object of the tab (another way, faster)

myTab.fetch(5, 0) # Prevent an error if the index is out of range by returning the default object (here: 0)
myTab.fetch(12) { |i| i } # Return the value of the block if index is out of range

myTab[0][0] # Get the first object of a two dimensional tab

On peut également utiliser first et last, surtout conseillés quand on veut les n premiers/derniers objets d’un tableau :

myTab.first # Get the first object of the tab (slower than myTab.at(1))
myTab.first(2) # Get the two first objects of the tab
myTab.last # Get the last object of the tab (slower than myTab.at(-1))
myTab.last(2) # Get the two last objects of the tab

Les méthodes de minimums et maximums renverront une liste par ordre alphabétique si les objets sont des strings. Il est également possible de les utiliser avec un bloc :

myTab.min # Get the minimum of the tab
myTab.max # Get the maximum of the tab
myTab.min {|a, b| a.length <=> b.length} # Get the object with the smaller lenght 
myTab.min_by {|obj| obj.length} # Get the minimum of the given block
myTab.max_by {|obj| obj.length} # Get the maximum of the given block

Pour afficher un objet, il suffit d’ajouter d’utiliser la méthode puts (ou d’appeler la méthode d’affichage propre à l’objet que vous avez créé) :

puts myTab[2] # Print the third object of the tab
puts myTab[0][0] # Print the first object of the two dimensional tab

On peut également vérifier qu’un objet est bien dans le tableau :

myTab.include?(22) # True if 22 is in the tab, false if not
myTab.member?(22) # True if 22 is in the tab, false if not (another way, slower)

Ou qu’un objet vérifie bien une condition :

myTab.any? {|object| object == 22} # True if there is an object equals to 22, false if not

Accéder à un groupe d’objets

Il est possible d’accéder à un groupe d’objets à partir d’une position que l’on précise, ou de donner une série d’indexes (ordonnée ou non) :

myTab[1, 3] # Get three consecutive objects starting by the second object 
myTab[1..3] # Get the objects between the second and the fourth, including those two ones
myTab[1...3] # Get the objects between the second and the fourth, excluding the fourth
myTab.slice(1, 3) # Get three consecutive objects starting by the second object (another way (alias))
myTab.slice(1..3) # Get the objects between the second and the fourth, including those two ones
myTab.slice(1...3) # Get the objects between the second and the fourth, excluding the fourth
myTab.values_at(1, 3, 0) # Get the objects given by the list of indexes, here the second, the fourth and the first object
#(NB: the indexes & indices methods are deprecated)

On peut demander le minimum et le maximum d’un tableau :

myTab.minmax # Get the min and the max of the tab
myTab.minmax_by {|obj| obj + 4 } # Get the min and the max of the given block

Ou ne récupérer seulement que la fin ou le début d’un tableau :

myTab.drop(2) # Get a tab with the two first objects removed
myTab.take(3) # Get a tab with only the three first objects

On peut aussi récupérer les objets qui vérifient une condition. Par exemple récupérer une seule occurrence de tous les objets :

myTab.uniq # Get the objects of the tab one time each (remove the duplicated objects)

Ou tous les objets non nil :

myTab.compact # Get all the non-nil objects

Ou bien préciser la condition dans un bloc :

myTab.detect {|obj| obj % 2 == 0 } # Get the first object for which the block evaluate a 'true' value   
myTab.find {|obj| obj % 2 == 0 } # Get the first object for which the block evaluate a 'true' value (another way, same that the previous line (alias))
myTab.find_all {|obj| obj % 2 == 0 } # Get all the objects for which the block evaluate a 'true' value  
myTab.select {|obj| obj % 2 == 0 }  # Get all the objects for which the block evaluate a 'true' value (another way, same that the previous line (alias))
myTab.reject {|obj| obj % 2 == 0 } # Get all the objects for which the block evaluate a 'false' value 
myTab.grep(/ol/) # Get all the string objects of the tab that contains the substring 'ol'
myTab.grep(1..12) # Get all the object of the tab that are between 1 and 12 included
myTab.grep(/ol/) {|obj| obj.length} # Transform the returning result of the grep methods before storing it (here it returns the length of the selected objects)
myTab.collect {|object| object + 2} # Get a tab with all the objects modified given the condition of the block 
myTab.map {|object| object + 2} # Get a tab with all the objects modified given the condition of the block (alias)
myTab.drop_while {|obj| obj < 7} # Get a tab with the first objects removed until the condition of the block isn’t verified
myTab.take_while {|obj| obj < 7} # Get a tab with the first objects until the condition of the block isn’t verified
myTab.partition {|objet| objet%2 == 0} # Get two tab, the first with the objects for which the block’s condition was true, and false for the second

On peut également récupérer les objets dans un ordre aléatoire :

myTab.shuffle # Randomize the order of the tab
myTab.sort_by { rand } # Randomize the order of the tab (another way, slower)

Si l’on souhaite parcourir tous les objets d’un tableau, on utilise les boucles :

# Reach each objet of the tab
for object in myTab
  # Do whatever you want to ‘object’ (your iterator)
end

# Reach each objet of the tab (another way, slower)
myTab.each  {
	|object|
	# Do whatever you want to ‘object’ (your iterator)
}

# Reach each objet of the tab (another way)
myTab.each do  |object|
   # Do whatever you want to ‘object’ (your iterator) 
end

# Reach each objet of the tab starting from the end
myTab.reverse_each {
  
  |object|
  # Do whatever you want to ‘object’ (your iterator)
  
}

Pour avoir un accès à plusieurs objets dans chaque itération :

# Reach many consecutive object (two, here) starting from the beginning 
myTab.each_cons(2) {

  |obj1, obj2|  
  # Do whatever you want with the two consecutive objects ‘n’ and ‘n+1’  
  # It’s also possible to get the two object into only one var (only put |objs| instead of |obj1, obj2|

}

# Reach many consecutive object (two, here) starting from the beginning
myTab.each_slice(2) {
  |objs|  
  # Do whatever you want with the two consecutive objects   
  # If the divisibility doesn't mach, the remining objects are put into the last slice
}

Pour disposer d’un accumulateur (alias : reduce):

myTab = [1, 2, 3, 4, 7, 8, 9, 10]

# Get the sum of the object (=> 44)
puts myTab.inject {
  
  |sum_acc, obj|
  sum_acc + obj
  
}

myTab = ["Dragon", "wolf", "Korrigan", "Dragonfly"]

# Get the longest word (=> "Dragonfly")
myTab.inject do |memo, obj|
  memo.length > obj.length ? memo : obj
end

# Get the longest lenght (memo's intial value = 0) (=> 9)
puts myTab.inject(0) {   

  |memo, obj|   
  memo >= obj.length ? memo : obj.length
  
}

Avec un parcours, on peut par exemple afficher tous les objets d’un tableau :

# For each object in the tab
for object in myTab
  puts object # Print object
end

Vous remarquerez que ceci marche aussi pour afficher un tableau (sauf si vous voulez personnaliser votre affichage) :

puts myTab # Print all object of the tab
myTab.display # Print all object of the tab (another way, faster)

Ou d’une manière plus élaborée (affiche sous la forme [obj, obj, …]) :

puts myTab.inspect # Get a printable version of an array

Il peut être intéressant de parcourir un tableau de manière infinie jusqu’à ce qu’une condition soit vérifiée :

myTab.cycle do |obj|
     puts obj
     break if obj == 10
end

Ou bien piocher dans le tableau en boucle (liste circulaire) :

myTabObjs = myTab.cycle

Avec myTabObjs.next vous obtenez l’objet suivant dans le tableau. Arrivé à la fin, ça repart au début. Vous pouvez également revenir au début par myTabObjs.rewind

D’autres méthodes si on veut plusieurs objets pour chaque itération :

myTabObjs = myTab.each_cons(2) # Two consecutives objects for each .next
myTabObjs = myTab.enum_cons(2) # Two consecutives objects for each .next
myTabObjs = myTab.each_slice(2) # The objects of the tab are group by two, each group accessible by .next
myTabObjs = myTab.enum_slice(2) # The objects of the tab are group by two, each group accessible by .next

Accéder aux index

myTab.index(0) # Get the first index of the specified object starting from the begining of the tab
myTab.rindex(0) # Get the first index of the specified object starting from the end of the tab
myTab.index myTab.min # Get the index of the first object that corresponds to the condition
myTab.find_index {|index| index% == 0 } # Get the first index of the object that verify the block condition
myTab.index {|obj| obj == 2} # Get the first index of the object that verify the block condition

# Reach each index of the tab
myTab.each_index {
  
  |index|
  #do whatever you want with index
    
}

Il existe aussi une méthode qui permet d’obtenir les objets et les indexes :

# Reach both indexes and objects of the tab
myTab.each_with_index {
  
  |object, index|
  #do whatever you want with index and object
    
}

Taille du tableau

myTab.length # Get the lenght of the tab
myTab.size # Get the length of the tab (same that the previous line (alias))
myTab.count # Get the length of the tab
myTab.nitems # Get the number of non-nil object of the tab

Si l’on veut compter le nombre d’occurrences d’un objet :

myTab.count(1) # Get the number of occurrence of the object ‘1’

On peut également vérifier qu’un tableau est vide ou est «nil» :

myTab.empty? # True if the tab is empty, false if not
myTab.nil? # True if the tab is equal to nil, false if not

Modifier les objets

Insérer un objet

myTab.unshift(22) # Add the object at the first position of the tab
myTab.unshift(22, 23) # Add many objects on the front of the tab
myTab.push(22) # Add the object at the end of the tab
myTab.push(22, 23) # Add many objects at the end of the tab
myTab<<22 # Add the object at the end of the tab (faster only for one object)
myTab.insert(1 ,2) # Insert the object 2 at the second position of the tab

Effacer un/plusieurs objets

On peut effacer un objet au début ou à la fin du tableau :

myTab.shift # Delete the first object of the tab
myTab.pop # Delete the last object of the tab

En donnant un index ou une série d’indexes :

myTab.delete_at(1) # Delete the object at the given index, here the second object of the tab
myTab.slice!(1) # Delete the object at the given index, here the second object of the tab (another way (Bang method), slower)
myTab.slice!(1, 2) # Delete two objects starting from the second position, here the second and the third objects of the tab (Bang method)
myTab.slice!(1..2) # Delete two objects starting from the second position, here the second and the third objects of the tab (Bang method)

NB : la méthode slice! est appelée « bang method » à cause de son point d’exclamation. Vous rencontrerez souvent parmi les méthodes une méthode et sa bang method associée. La différence réside dans le fait que la bang method modifie l’objet, alors que la méthode normale renvoie un nouvel objet.

On peut également effacer un objet en l’indiquant :

myTab.delete(1) # Delete all the objects '1' of the tab
myTab.delete(22) {"Not in the tab"} # Delete all the objects '22' of the tab, if nothing is found, print the default block

Ou par des conditions spécifiques :

myTab.delete_if {|object| object < 4} # Delete all the objects that verify the block's condition (here all the ojects lower than 4)
myTab.uniq! # Delete all the duplicated objects (Bang method)
myTab.compact! # Delete all the nil objects (Bang method)
myTab.reject! {|obj| obj % 2 == 0 } # Delete all the even objects (Bang method)

Effacer un tableau

Pour effacer tous les éléments d’un tableau il suffit d’appeler une seule méthode :

myTab.clear # Delete all the objects in the tab

Modifier un objet

La modification d’une partie d’un tableau se fait comme dans beaucoup de langages, par un index :

myTab = [1, 2, 3, 4, 5, 6]
myTab[2] = 10 # Modify the third object of the tab (=> [1, 2, 10, 4, 5, 6])
myTab[0] = [1, 2] # Modifiy the first object of the tab (=> [[1,2], 12, 12, 4, 5, 6])

Modifier plusieurs objets

On peut modifier les objets de plusieurs manières. Généralement, les non-correspondance de dimensions ne génèrent pas d’erreur, mais étirent (ou tronquent) plutôt les objets.

myTab = [1, 2, 3, 4, 5, 6]
myTab[0..2] = [11, 11, 11] # Modify the three first object of the tab  (=> [11, 11, 11, 4, 5, 6])
myTab[0, 3] = [12, 12, 12] # Modify the three first objects of the tab  (=> [12, 12, 12, 4, 5, 6])
myTab[0..2] = 13 # Modifiy the three first objects of the tab (=> [13, 4, 5, 6])
myTab[0..1] = [14, 14, 14] # Modifiy the two first objects of the tab and add a new one given the dimension (=> [14, 14, 14, 5, 6])

myTab.fill(2) # Modify all the objects of the tab (=> [2, 2, 2, 2, 2])
myTab.fill(3, 1, 2) # Modify the second and the third object (=> [2, 3, 3, 2, 2])
myTab.fill(4, 0..2) # Modify the three first objects (=> [4, 4, 4, 2, 2])
myTab.fill {|index| index} # Modify all the objects with the value given by the block (=> [0, 1, 2, 3, 4])
myTab.fill(2) {|index| index*2} # Modify all the objects after the given index with the value given by the block (=> [0, 1, 4, 6, 8])

Une autre manière de modifier tous les objets :

myTab.collect! {|object| object + 2} # Modify all the object of the tab given the condition of the block (=> [6, 6, 6, 6]) (Bang method)
myTab.map! {|object| object + 2} # Modify all the object of the tab given the condition of the block (=> [6, 6, 6, 6]) (alias, Bang method)

On peut carrément le remplacer par un autre tableau :

myTab.replace([2, 2, 2, 2, 2]) # Replace the tab by the given tab (=> [0, 1, 4, 6, 8])
myTab.replace([3, 3, 3]) # Replace and truncate the tab by the given tab (=> [3, 3, 3])
myTab.replace([4, 4, 4, 4]) # Replace and expand the tab by the given tab (=> [4, 4, 4, 4])

Trier un tableau

myTab.sort # Get a sorted tab 
myTab.sort {|obj1, obj2| obj2 <=> obj1.to_s} # Get a sorted tab in descending order
myTab.sort {|obj1, obj2| obj1.to_s <=> obj2.to_s} # Get a heterogeneous sorted tab (with different sort of objects)

myTab.sort! # Sort the tab (Bang method)

On peu trier selon une condition :

# Sort the object by the condition of the block, here by length
 myTab.sort_by {

	|object| 
	object.length

}

On peut aussi vouloir le trier dans un ordre aléatoire :

myTab.shuffle!

Inverser un tableau

myTab.reverse # Get a reverse tab
myTab.reverse! # Reverse the tab (Bang method)

Opérations sur les tableaux

Concaténation

Si on veut concaténer deux tableaux :

myTab1 = [1, 2, 3]
myTab2 = [4, 5, 6]

myTab1 + myTab2 # Concatenate two tab (=> [1, 2, 3, 4, 5, 6])
myTab1 += myTab2 # Concatenate two tab (=> [1, 2, 3, 4, 5, 6]) and put the result into the irst one
myTab1.concat(myTab2) # Concatenate two tab (=> [1, 2, 3, 4, 5, 6, 4, 5, 6]) and put the result into the first one (another way, faster)

Ou répéter un tableau :

myTab1 = [1, 2, 3]
myTab1 * 3 # Concatenate the tab with itself the number of time specified (=> [1, 2, 3, 1, 2, 3, 1, 2, 3])

Opérations

Nous avons bien sûr les opération ET, OU, OR :

myTab1 & myTab2 # Get the common objects of the two tabs (without duplicated objects)
myTab1 - myTab2 # Get the objects of the first tab that don't appear in the second tab (without duplicated objects)
myTab1 | myTab2 # Get the objects that appear in the first tab or in the second tab (without duplicated objects)

myTab1 &= myTab2 # Create one tab deleting the non common objects of the two tabs(and duplicated objects)
myTab1 -= myTab2 # Create one tab deleting the objects that apear in both tab (and duplicated objects)
myTab1 |= myTab2 # Create one tab deleting the duplicated objects of the two tab

Remettre un tableau en une dimension :

myTab = [1, [2, 3], 4, 5 [6, [7, 8], 9], 10]

myTab.flatten # Get a one dimensional tab (=> [1, 2, 3, 4, 5, 6, 7 ,8, 9, 10])
myTab.flatten! # Transform the tab into a one dimensional tab (=> [1, 2, 3, 4, 5, 6, 7 ,8, 9, 10])

Transformation

Pour transposer (une matrice) :

myTab = [[1,2], [3,4], [5,6]]
myTab.transpose # Transpose the lines and columns (=> [[1, 3, 5], [2, 4, 6]])

Obtenir un hashcode pour le tableau (deux hashcodes identiques indique deux tableaux identiques) :

myTab.hash

Pour transformer en binaire :

myTab.pack (templateString) #Packs the contents of the tab into a binary sequence given the directives in templateString

Permutation & autres transformations :

myTab1 = [1, 2, 3]
myTab2 = [4, 5, 6]
myTab3 = [7, 8]

myTab1.zip(myTab1, myTab2) # Put the three tabs in lines (=> [[1, 1, 4], [2, 2, 5], [3, 3, 6]])
myTab3.zip(myTab1, myTab2) # Ignore the third line (=> [[7, 1, 4], [8, 2, 5]])
myTab2.zip(myTab3, myTab1) # (=> [[4, 7, 1], [5, 8, 2], [6, nil, 3]])

myTab1.product(myTab3) # (=> [[1, 7], [1, 8], [2, 7], [2, 8], [3, 7], [3, 8]])
myTab1.product() # (=> [[1], [2], [3]])

myTab1.permutation.to_a # Permutation (=> [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]])
myTab1.permutation(2).to_a # Permutation (=> [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]])

myTab1.combination(1).to_a # (=> [[1], [2], [3]])
myTab1.combination(2).to_a # (=> [[1, 2], [1, 3], [2, 3]])

Regrouper selon un critère :

myTab = [1, 2, 3, 4, 7, 8, 9, 10]

# Break the tab into groups given the condition in the block (=> {0=>[3, 9], 1=>[1, 4, 7, 10], 2=>[2, 8]})
myTab.group_by {  
  |obj|
  obj % 3
}

Comparaison

Si l’on veut savoir si un tableau est égal à un autre :

myTab1 == myTab2 # True if the two tabs have the same number of objects and if each object is equal to the correspondig object in the other tab, false if not
myTab1.equal?(myTab2) # True if the two tabs have the same number of objects and if each object is equal to the correspondig object in the other tab, false if not
myTab1.eql?(myTab2) # True if the two tabs have the same number of objects and if each object has the same value that the correspondig object in the other tab, false if not (another way, faster)
1 == 1.0     # (=> true)
1.eql? 1.0   # (=> false)

Ou différent :

myTab1 != myTab2 # True if the two tabs have a different number of objects or if an object isn't equal to the correspondig object in the other tab, true if not

Ou avoir une comparaison nuancée :

myTab1 <=> myTab2 # -1 if the first tab is lesser than the second, 1 if it's greater, 0 if they are equal 
[1, 2, 3] <=> [1, 1, 2] # -1
[1, 2, 3, 4] <=> [1, 1, 2] # 1

Sorte de comparaison rapide :

myTab.all? {|objet| objet == 22} # True if all the objects verify the block condition (here, if they are equals to 22)
myTab.none? {|object| object < 2} # True if none of the objects verify the block’s condition, false if not
myTab.one? {|object| object < 1} # True if one of the objects verify the block’s condition, false if not

Un autre exemple ou l’on veut choisir un tableau parmi un set de tableau :

myTabs.assoc(1) # Return the first array which start with the given object
myTabs.rassoc(1) # Return the first array which second object is equal to the given object

Chaînes de caractères et tableaux

Il est possible de créer facilement un tableau grâce à une chaîne de caractères, et inversement.

Créer un tableau à partir d’une chaîne de caractères

myString = "Have always a dragon in your pocket"
myString.split(" ")

Créer une chaîne de caractères à partir d’un tableau

Sans séparateur :

myTab.to_s # Return the tab into a string without separator
myTab.join # Return the tab into a string without separator (another way, slower)

Avec séparateur :

myTab = ["Have","always","a","dragon", "in", "your", "pocket"]

myTab.join(" ") # Return the string: "Have always a dragon in your pocket"
myTab.join(", ") # Return the string: "Have, always, a, dragon, in, your, pocket"
myTab * ", " # Return the string: "Have, always, a, dragon, in, your, pocket" (another way, faster) 

myTab = ["dragons","wolfs", "korrigans"]
myTab[0..1] * ", " + " and " + myTab.at(-1) # Transform the tab into "dragons, wolfs and korrigans"

Aller plus loin

Voilà, on a à peu près vu les méthodes de bases utilisables sur les tableaux. Si une méthode dont vous avez besoin n’est pas implémentée dans la classe Array, vous pouvez la rajouter, c’est très simple :

class Array

	def myNewMethod()

		#What my method is doing

	end
end

Et vous pourrez ensuite l’utiliser :

myTab.myNewMethod()

Encore une fois n’hésitez pas à optimiser votre code et à fouiller dans les sources ;-] N’hésitez pas à laisser un commentaire ou partager ce billet si vous l’avez apprécié :-]
Bon Ruby !

Commentaires (4)
  1. TL le 2 Mar 2012 à 15:41

    Parfait : merci !

  2. Aszlahel le 22 Jun 2012 à 15:15

    Merci

  3. Toea le 17 Dec 2014 à 14:23

    La bible des tableaux Ruby! Dommage qu’il n’y ait pas le même type de document pour d’autres thèmes. On peut difficilement faire plus complet et concis!

  4. stage decorators in chennai|best wedding decorators in chennai|decorators for wedding in chennai|decorators in chennai for wedding|flower decorators for wedding in chennai|best wedding stage decorators in chennai|stage decorators in chennai for wedding|we le 16 Sep 2015 à 23:50

    Right away I am going to do my breakfast, when having my breakfast coming yet again to read additional news.|


Laisser un commentaire