कंसोल पर आउटपुट रूप से स्वरूपण आउटपुट, टैब की संख्या निर्दिष्ट करना

Question

मैं एक स्क्रिप्ट उत्पन्न कर रहा हूं जो कंसोल को जानकारी आउटपुट कर रहा है। जानकारी किसी मूल्य के साथ कुछ प्रकार की सांख्यिकी है। एक हैश की तरह बहुत।

तो एक मान का नाम 8 वर्ण लंबा हो सकता है और दूसरा 3 है। जब मैं दो कॉलम के साथ जानकारी आउटपुट के माध्यम से लूपिंग कर रहा हूं तो कुछ कॉलम सही तरीके से संरेखित नहीं होते हैं।

इसलिए उदाहरण के लिए उत्पादन के रूप में इस तरह के हो सकता है:

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

मैं सभी मूल्यों को सही ढंग से खड़े चाहते हैं। अभी मैं यह कर रहा हूं:

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

मैं केवल एक टैब का उपयोग करने के लिए लंबे नामों के लिए कैसे कह सकता हूं? या कोई और समाधान है?

Answer 1

आमतौर पर %10s प्रकार printf योजना है जो अच्छी तरह से प्रारूपित करती है।
हालांकि, मैंने रूबी का बिल्कुल उपयोग नहीं किया है, इसलिए आपको इसे जांचना होगा।

---

हां, फ़ॉर्मेटिंग के साथ printf है।
उपरोक्त उदाहरण को 10 वर्णों की एक जगह में सही संरेखित करना चाहिए।
आप कॉलम में अपने विस्तृत क्षेत्र के आधार पर प्रारूपित कर सकते हैं।

printf ([बंदरगाह,] प्रारूप, आर्ग ...)

प्रिंटों तर्क sprintf तरह प्रारूप के अनुसार प्रारूपित। यदि पहला तर्क आईओ या उसके उप-वर्ग का उदाहरण है, तो उस ऑब्जेक्ट पर रीडायरेक्ट प्रिंट करें। डिफ़ॉल्ट $ stdout का मान है।

Answer 2

आप आमतौर पर टैब का उपयोग नहीं करना चाहते हैं, तो आप रिक्ति और अनिवार्य रूप से सेटअप अपने "कॉलम" अपने आप उपयोग करना चाहते हैं या फिर आप समस्याओं के इन प्रकार में चलाने।

Answer 3

बशर्ते आप अधिकतम लंबाई पता नहीं 20 से अधिक वर्ण नहीं होने के लिए: आप इसे और अधिक गतिशील बनाना चाहते हैं

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

, कुछ इस तरह अच्छी तरह से काम करना चाहिए:

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 4

वहाँ गया था उस में कुछ कीड़े से पहले, लेकिन अब आप printf वाक्य रचना के सबसे% ऑपरेटर के साथ उपयोग कर सकते हैं:

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

Cours के

ई आप भी precalculated चौड़ाई का उपयोग कर सकते हैं:

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

Answer 5

मैं एक बात लिखा

• स्वचालित रूप से स्तंभ चौड़ाई रिक्तियों के साथ
• रिक्त स्थान का पता लगाता है
सरणियों [[],[],...] या हैश की सरणी के
• सरणी [{},{},...]

• कंसोल विंडो

  के लिए स्तंभों का बहुत विस्तृत पता नहीं लगाता है

  सूचियों = [ [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, 

और एक अन्य चीज

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, 

संपादित करें: सुधार हैश कुंजी लंबाई में माना जाता है।

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

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

कॉलम कॉलम को श्वेतसूची में रखना चाहते हैं?

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

Answer 6

भविष्य के संदर्भ के लिए और जो लोग इसे देखते हैं या पाते हैं ... एक मणि का प्रयोग करें।मेरा सुझाव है https://github.com/wbailey/command_line_reporter

Answer 7

स्ट्रिंग है एक बिल्कुल इस के लिए निर्मित ljust:

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 

या, यदि आप टैब चाहते हैं, आप एक छोटे से गणित (8 के टैब प्रदर्शन चौड़ाई कल्पना करते हुए) कर सकते हैं और एक छोटी लिखने प्रदर्शन समारोह:

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