ruby - sprintf - tipos de pestañas postizas nombres

Muy bien formatear la salida a la consola, especificando el número de pestañas

Question

Estoy generando un script que está generando información en la consola. La información es algún tipo de estadística con un valor. Tanto como un hash.

Entonces, el nombre de un valor puede tener 8 caracteres de largo y otro es 3. cuando estoy realizando un bucle al dar salida a la información con dos / t algunas de las columnas no están alineadas correctamente.

Entonces, por ejemplo, la salida puede ser como tal:

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

Quiero que todos los valores estén alineados correctamente. En este momento estoy haciendo esto:

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

¿Cómo podría decir para los nombres largos, usar solo una pestaña? ¿O hay otra solución?

Answer 1

Escribí una cosa

• Detecta automáticamente anchos de columna
• Espacios con espacios
• Matriz de matrices [[],[],...] o matriz de hash [{},{},...]

• No detecta columnas demasiado anchas para la ventana de la consola

  lists = [[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,

y otra cosa

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,

Editar: corrige las claves hash consideradas en la longitud.

hashes = [
{ id: 123, name: "DLKFJSDLKFJSLDKFJSDF", asdfasdf: :a },
{ id: 123456, name: "ffff", asdfasdf: :ab },
]
hash_maxes(hashes)
# => {:id=>6, :name=>20, :asdfasdf=>8}

¿Quieres incluir columnas columnas?

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

Answer 2

Hubo algunos errores antes, pero ahora puede usar la mayoría de la sintaxis de printf con% operator:

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

Por supuesto, también puedes usar el ancho precalculado:

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

Answer 3

Para futuras referencias y personas que lo miren o lo encuentren ... Use una gema. Sugiero https://github.com/wbailey/command_line_reporter

Answer 4

Por lo general, no desea utilizar pestañas, desea utilizar espacios y esencialmente configurar sus "columnas" usted mismo o de lo contrario se encuentra con este tipo de problemas.

Answer 5

Siempre que sepa que la longitud máxima no debe ser más de 20 caracteres:

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

Si quieres hacerlo más dinámico, algo así debería funcionar bien:

longest_key = data_hash.keys.max_by(&:length)
data_hash.each do |key, value|
printf "%-#{longest_key.length}s %s/n", key, value
end

Answer 6

String tiene una ljust para exactamente esto:

x = {"foo"=>37, "something long"=>42, "between"=>99}
x.each { |k, v| puts "#{k.ljust(20)} #{v}" }
# Outputs:
# foo 37
# something long 42
# between 99

O bien, si desea pestañas, puede hacer un poco de matemática (suponiendo que la pestaña muestre un ancho de 8) y escribir una breve función de visualización:

def tab_pad(label, tab_stop = 4)
label_tabs = label.length / 8
label.ljust(label.length + tab_stop - label_tabs, "/t")
end
x.each { |k, v| puts "#{tab_pad(k)}#{v}" }
# Outputs:
# foo 37
# something long 42
# between 99

Answer 7

Usualmente hay un tipo de esquema printf %10s que formatea muy bien.
Sin embargo, no he usado rubí en absoluto, así que debes verificarlo.

Sí, hay printf con formato.
El ejemplo anterior debe alinearse a la derecha en un espacio de 10 caracteres.
Puede formatear según su campo más amplio en la columna.

printf ([puerto,] formato, arg ...)

Imprime argumentos formateados según el formato como sprintf. Si el primer argumento es la instancia del IO o su subclase, imprima redirigido a ese objeto. el valor predeterminado es el valor de $ stdout.