Joliment formatant la sortie sur la console, en spécifiant le nombre d’onglets

Question

Je suis de la génération d'un script qui est de la sortie de l'information de la console. L'information est une sorte de statistique avec une valeur. Donc un peu comme une table de hachage.

Si une seule valeur est le nom peut être composé de 8 caractères et une autre est de 3. quand je suis en boucle au travers de la sortie de l'information avec deux \t certaines colonnes ne sont pas alignées correctement.

Ainsi, par exemple, la sortie peut être en tant que tel:

long value name          14
short              12
little             13
tiny               123421
long name again          912421

Je veux toutes les valeurs correctement alignés. Je fais ceci:

puts "#{value_name} - \t\t #{value}"

Comment pourrais-je dire pour les noms longs, d'utiliser un seul onglet? Ou est-il une autre solution?

Answer 1

Pourvu que la longueur maximale ne dépasse pas 20 caractères:

 printf "%-20s %s\n", value_name, value
 

Si vous voulez le rendre plus dynamique, quelque chose comme ceci devrait fonctionner correctement:

 longest_key = data_hash.keys.max { |a, b| a.length <=> b.length }
data_hash.each do |key, value|
  printf "%-#{longest_key.length}s %s\n", key, value
end
 

Answer 2

Il est généralement un %10s genre d' printf régime de formats bien.
Cependant, je n'ai pas utilisé ruby, alors vous devez vérifier que.

---

Oui, il y a printf avec la mise en forme.
L'exemple ci-dessus devrait aligner à droite dans un espace de 10 caractères.
Vous pouvez à partir de votre plus large champ dans la colonne.

printf ([port ]format, arg...)

Imprime arguments formaté selon le format comme sprintf. Si le premier argument est l'instance de l'OI ou de ses sous-classe, l'impression redirigé vers cet objet. la valeur par défaut est la valeur de $stdout.

Answer 3

Il y avait peu de bugs auparavant, mais vous pouvez maintenant utiliser la plupart de la syntaxe printf avec% operator:

 1.9.3-p194 :025 > " %-20s %05d" % ['hello', 12]
 => " hello                00012" 
 

Bien sûr, vous pouvez aussi utiliser la largeur précalculée:

 1.9.3-p194 :030 > "%-#{width}s %05x" % ['hello', 12]
  => "hello          0000c" 
 

Answer 4

J'ai écrit une chose

• Détecte automatiquement les largeurs de colonne
• Les espaces par des espaces
• Tableau de tableaux en [[],[],...] ou un tableau de hachages [{},{},...]

• Ne pas détecter les colonnes trop larges pour la fenêtre de la console

  listes = [ [ 123, "SDLKFJSLDKFJSLDKFJLSDKJF" ], [ 123456, "ffff" ], ]

array_maxes

def array_maxes(lists)
  lists.reduce([]) do |maxes, list|
    list.each_with_index do |value, index|
      maxes[index] = [(maxes[index] || 0), value.to_s.length].max
    end
    maxes
  end
end

array_maxes(lists)
# => [6, 24]

puts_arrays_columns

def puts_arrays_columns(lists)
  maxes = array_maxes(hashes)
  lists.each do |list|
    list.each_with_index do |value, index|
      print " #{value.to_s.rjust(maxes[index])},"
    end
    puts
  end
end

puts_arrays_columns(lists)

# Output:
#     123, SDLKFJSLDKFJSLDKFJLSDKJF,
#  123456,                     ffff,

et une autre chose

hashes = [
  { "id" => 123,    "name" => "SDLKFJSLDKFJSLDKFJLSDKJF" },
  { "id" => 123456, "name" => "ffff" },
]

hash_maxes

def hash_maxes(hashes)
  hashes.reduce({}) do |maxes, hash|
    hash.keys.each do |key|
      maxes[key] = [(maxes[key] || 0), key.to_s.length].max
      maxes[key] = [(maxes[key] || 0), hash[key].to_s.length].max
    end
    maxes
  end
end

hash_maxes(hashes)
# => {"id"=>6, "name"=>24}

puts_hashes_columns

def puts_hashes_columns(hashes)
  maxes = hash_maxes(hashes)

  return if hashes.empty?

  # Headers
  hashes.first.each do |key, value|
    print " #{key.to_s.rjust(maxes[key])},"
  end
  puts

  hashes.each do |hash|
    hash.each do |key, value|
      print " #{value.to_s.rjust(maxes[key])},"
    end
    puts
  end

end

puts_hashes_columns(hashes)

# Output:
#      id,                     name,
#     123, SDLKFJSLDKFJSLDKFJLSDKJF,
#  123456,                     ffff,

Edit: Corrections clés de hachage considéré dans la longueur.

hashes = [
  { id: 123,    name: "DLKFJSDLKFJSLDKFJSDF", asdfasdf: :a  },
  { id: 123456, name: "ffff",                 asdfasdf: :ab },
]

hash_maxes(hashes)
# => {:id=>6, :name=>20, :asdfasdf=>8}

Voulez blanche colonnes?

hashes.map{ |h| h.slice(:id, :name) }
# => [
#  { id: 123,    name: "DLKFJSDLKFJSLDKFJSDF" },
#  { id: 123456, name: "ffff"                 },
#]

Answer 5

Généralement, vous ne voulez pas utiliser d'onglets, vous voulez utiliser des espaces et configurer essentiellement vos "colonnes" vous-même, sinon vous rencontrez ce type de problèmes.