वहाँ कंसोल के लिए सुंदर स्विफ्ट शब्दकोशों प्रिंट करने के लिए एक रास्ता है?


92
NSDictionary *dictionary = @{@"A" : @"alfa",
                             @"B" : @"bravo",
                             @"C" : @"charlie",
                             @"D" : @"delta",
                             @"E" : @"echo",
                             @"F" : @"foxtrot"};
NSLog(@"%@", dictionary.description);

कंसोल पर निम्न प्रिंट करता है:

{
    A = alfa;
    B = bravo;
    C = charlie;
    D = delta;
    E = echo;
    F = foxtrot;
}

let dictionary: [String : String] = ["A" : "alfa",
                                     "B" : "bravo",
                                     "C" : "charlie",
                                     "D" : "delta",
                                     "E" : "echo",
                                     "F" : "foxtrot"];
print(dictionary)

कंसोल पर निम्न प्रिंट करता है:

["B": "bravo", "A": "alfa", "F": "foxtrot", "C": "charlie", "D": "delta", "E": "echo"]

क्या स्विफ्ट में एक ऐसा तरीका है जो इसे सुंदर प्रिंट शब्दकोशों में ले सकता है जहां प्रत्येक कुंजी-मूल्य जोड़ी एक नई रेखा पर रहती है?


7
dumpउदाहरण के लिए, यदि लक्ष्य शब्दकोश का निरीक्षण करना है, तो आप इसका उपयोग कर सकते हैं । stackoverflow.com/documentation/swift/3966/log-in-swift/…
एरिक आया

13
print(dictionary as! NSDictionary) घटिया चाल?
बेसजेन

मैं वास्तव में डंप () सुझाव देता हूं क्योंकि इसमें किसी भी कोड को लिखने या उसे डालने की आवश्यकता नहीं है। @ EricAya, यदि आप उस टिप्पणी के साथ उत्तर पोस्ट करते हैं, तो मैं इसे उत्तर के रूप में चिह्नित करूंगा।
टॉलैंड हॉन

1
@ टोलैंडहोन ने किया। मैंने आउटपुट के उदाहरण के साथ एक उत्तर दिया है।
एरिक आया

जवाबों:


99

आप डंप का उपयोग कर सकते हैं , उदाहरण के लिए, यदि लक्ष्य शब्दकोश का निरीक्षण करना है। dumpस्विफ्ट के मानक पुस्तकालय का हिस्सा है।

उपयोग:

let dictionary: [String : String] = ["A" : "alfa",
                                     "B" : "bravo",
                                     "C" : "charlie",
                                     "D" : "delta",
                                     "E" : "echo",
                                     "F" : "foxtrot"]

dump(dictionary)

आउटपुट:

यहाँ छवि विवरण दर्ज करें


dump प्रतिबिंब (मिररिंग) के माध्यम से किसी वस्तु की सामग्री को प्रिंट करता है।

एक सरणी का विस्तृत दृश्य:

let names = ["Joe", "Jane", "Jim", "Joyce"]
dump(names)

प्रिंटों:

1 4 तत्व
- [0]: जो
- [1]: जेन
- [2]: जिम
- [3]: जायसी

एक शब्दकोष के लिए:

let attributes = ["foo": 10, "bar": 33, "baz": 42]
dump(attributes)

प्रिंटों:

▿ 3 कुंजी / मूल्य जोड़े
▿ [0]: (2 तत्व)
- .0: बार
- .1: 33:
[1]: (2 तत्व)
- .0: baz
- .1: 42
value [2]: (। 2 तत्व)
- .0: foo
- .1: 10

dumpके रूप में घोषित किया गया है dump(_:name:indent:maxDepth:maxItems:)

पहले पैरामीटर में कोई लेबल नहीं है।

अन्य पैरामीटर उपलब्ध हैं, जैसे nameकि निरीक्षण किए जा रहे ऑब्जेक्ट के लिए एक लेबल सेट करना:

dump(attributes, name: "mirroring")

प्रिंटों:

▿ मिररिंग: 3 कुंजी / मूल्य जोड़े
▿ [0]: (2 तत्व)
- .0: बार
- .1: 33:
[1]: (2 तत्व)
- .0: baz
- .1: 42
3 [2]। : (2 तत्व)
- .0: foo
- .1: 10

आप केवल एक निश्चित संख्या में वस्तुओं को प्रिंट maxItems:करने के लिए, एक निश्चित गहराई तक वस्तु को पार्स करने maxDepth:और मुद्रित वस्तुओं के इंडेंटेशन को बदलने के लिए भी चुन सकते हैं indent:


5
यह बहुत अच्छा JSON मुद्रित नहीं है, यह कंसोल में केवल एक चर को डंप कर रहा है - मान्य JSON नहीं। हालांकि यह ओपी की जरूरतों के अनुरूप है, मेरा मानना ​​है कि इस मैच के लिए प्रश्न को फिर से दर्ज करने की आवश्यकता है।
जेम्स वोल्फ

4
@JamesWolfe This is not pretty printed JSONकिसी ने भी यह नहीं कहा। ओपी ने सुंदर मुद्रण स्विफ्ट शब्दकोशों के बारे में पूछा - जेसन के बारे में कोई बात नहीं कर रहा है, कुछ ऑफ-टॉपिक उत्तरदाताओं को छोड़कर। ओपी का क्वेसटन जेन्सन के बारे में बिल्कुल नहीं है।
एरिक आया

@JamesWolfe कृपया भी सवाल न बदलें। यह बर्बरता होगी। प्रश्न स्पष्ट है जैसा कि यह है, और यह JSON के बारे में नहीं है। एक प्रश्न को सिर्फ इसलिए मत बदलिए क्योंकि कुछ उत्तर कुछ और के बारे में बात करते हैं। धन्यवाद।
एरिक आया

112

'AnyObject' के लिए एक शब्दकोष बनाना मेरे लिए सबसे सरल उपाय था:

let dictionary = ["a":"b",
                  "c":"d",
                  "e":"f"]
print("This is the console output: \(dictionary as AnyObject)")

यह कंसोल आउटपुट है

डंप विकल्प की तुलना में मेरे लिए पढ़ना आसान है, लेकिन ध्यान दें कि यह आपको कुंजी-मानों की कुल संख्या नहीं देगा।


11
यह एक शानदार तरीका है और डंप से बेहतर है
अब्देलहैडी

109

पो समाधान

आप में से जो बाहर भागने अनुक्रम के साथ JSON के रूप में शब्दकोश देखने के लिए कंसोल , यहाँ ऐसा करने के लिए एक आसान तरीका है

(Lldb)p print(String(data: try! JSONSerialization.data(withJSONObject: object, options: .prettyPrinted), encoding: .utf8 )!)


1
चूंकि एक अभिव्यक्ति है और एक वस्तु नहीं है, इसलिए यह 'पी' होना चाहिए और 'पीओ' नहीं। लेकिन इस समाधान के लिए बहुत बहुत धन्यवाद! मेरे लिए ठीक काम करता है
एलेसेंड्रो फ्रेंकॉइ जुले

@AlessandroFrancucci से क्या फर्क पड़ता है? कमांड भी उसी तरह से काम करती है।
निक्वेलिन

अब इसे करने के दोनों तरीके काम कर रहे हैं। लेकिन एक "पो प्रिंट" करने से पहले मेरे लिए काम नहीं किया। (पो का अर्थ है प्रिंट ऑब्जेक्ट .... जो थोड़ा
कंफ्यूज करने

बहुत बढ़िया! बस क्या मैं एक अच्छा तरीका userInfo में मुद्रित करने की जरूरत है PushNotification से
carmen_munich

चेक इस टिप्पणी एक lldb उर्फ में यह लाभ उठाने के लिए ताकि आप इसे हर टाइप करने के लिए नहीं है!
22

36

कार्यात्मक प्रोग्रामिंग का उपयोग करते हुए बस एक और तरीका

dictionary.forEach { print("\($0): \($1)") }

उत्पादन

B: bravo
A: alfa
F: foxtrot
C: charlie
D: delta
E: echo

1
यह शीर्ष उत्तर होना चाहिए। अच्छी तरह से काम!
यूरी डाउबॉव

या "और भी अधिक कार्यात्मक" होने के लिए ... Dictionary.map {"($ 0): ($ 1)"} .forEach (प्रिंट) (जीभ-इन-गाल टिप्पणी)
जॉन विलिस

3
यह ओपी [String: String]शब्दकोश के लिए काम करता है , लेकिन यह [AnyHashable: Any]शब्दकोशों के लिए बहुत अच्छा नहीं है , जहां यदि कोई मान है, तो आप स्विफ्ट के गैर-सुंदर मुद्रण पर वापस आ सकते हैं।
क्रिस्टोफर पिक्सले

मैंने इस उत्तर को चिह्नित किया है, क्योंकि मैं अभी भी इस वाक्यविन्यास को याद नहीं कर सकता हूं
नितिन अलबूर

29

डिबग उद्देश्य के लिए केवल मैं ऐरे या डिक्शनरी को एक सुंदर प्रिंट किए गए जोंसन में बदलूंगा:

public extension Collection {

    /// Convert self to JSON String.
    /// Returns: the pretty printed JSON string or an empty string if any error occur.
    func json() -> String {
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: self, options: [.prettyPrinted])
            return String(data: jsonData, encoding: .utf8) ?? "{}"
        } catch {
            print("json serialization error: \(error)")
            return "{}"
        }
    }
}

फिर:

print("\nHTTP request: \(URL)\nParams: \(params.json())\n")

कंसोल पर परिणाम:

HTTP request: https://example.com/get-data
Params: {
  "lon" : 10.8663676,
  "radius" : 111131.8046875,
  "lat" : 23.8063882,
  "index_start" : 0,
  "uid" : 1
}

यहाँ क्या है?
नितेश

@ नितेश bLog बैकट्रेस के साथ एक साधारण कस्टम लकड़हारा है जिसे मैंने लिखा, प्रिंट के साथ संपादित किया ()।
मार्को एम

सबसे सुंदर समाधान।
डेनिस कुटलुबा

यदि आप अपने प्रत्येक प्रोजेक्ट में कोड के उस स्निपेट को जोड़ने से बचना चाहते हैं, तो आप डीबग टर्मिनल में जौन की गणना आसानी से करने के लिए उस कोड का लाभ उठा सकते हैं (विवरण यहाँ )।
agirault

14

मैं यहाँ दिए गए बहुत सारे जवाबों पर विचार नहीं करूँगा, जो बहुत ही सुंदर मुद्रित JSON के रूप में दिए गए हैं, जब आप परिणाम को JSON सत्यापनकर्ता में पास करते हैं तो परिणाम अमान्य होता है (अक्सर कोड के कारण '=' के बजाय ':' सहित)।

ऐसा करने का सबसे आसान तरीका यह है कि सिर्फ JSON ऑब्जेक्ट को सुंदर मुद्रित लेखन विकल्प का उपयोग करके डेटा में परिवर्तित किया जाए, फिर परिणामस्वरूप डेटा का उपयोग करके स्ट्रिंग को प्रिंट किया जाए।

यहाँ एक उदाहरण है:

let jsonData = try! JSONSerialization.data(withJSONObject: parameters, options: .prettyPrinted)

if let jsonString = String(data: jsonData, encoding: .utf8) {
    print(jsonString)
}

परिणाम:

{
    "jsonData": [
        "Some String"
    ],
    "moreJSONData": "Another String",
    "evenMoreJSONData": {
        "A final String": "awd"
    }
}

संपादित करें : यह इंगित किया गया है कि ओपी ने JSON के लिए नहीं पूछा, हालांकि मुझे लगता है कि उत्तर जो केवल कंसोल में डेटा को प्रिंट करने या डंप करने की सलाह देते हैं, बहुत कम स्वरूपण (यदि कोई हो) प्रदान करते हैं और इसलिए सुंदर मुद्रण नहीं हैं।

मेरा मानना ​​है कि ओपी जेएसएन के लिए नहीं पूछ रहा है, यह एक व्यवहार्य जवाब है क्योंकि यह डेटा के लिए बहुत अधिक पठनीय प्रारूप है जो भयावह प्रारूप से अधिक है जो कंसोल में एक्सकोड / स्विफ्ट से बाहर है।


1
धन्यवाद, इसके साथ मैं डिबगिंग के माध्यम से सुंदर प्रिंट करने में सक्षम था e let jsonData = try! JSONSerialization.data(withJSONObject: response, options: .prettyPrinted);if let jsonString = String(data: jsonData, encoding: .utf8) { print(jsonString) }
बैंगऑपरेटर

1
यह भी खूब रही! आप डीबग टर्मिनल (विवरण यहाँ ) में आसानी से json की गणना करने के लिए एक एलडीबी उपनाम के साथ इस कोड का लाभ उठा सकते हैं ।
एग्रीकल्चर

5

आप केवल लूप के लिए उपयोग कर सकते हैं और प्रत्येक पुनरावृत्ति को प्रिंट कर सकते हैं

for (key,value) in dictionary { 
    print("\(key) = \(value)")
}

विस्तार में आवेदन:

extension Dictionary where Key: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {

    var prettyprint : String {
        for (key,value) in self {
            print("\(key) = \(value)")
        }

        return self.description
    }
}

वैकल्पिक आवेदन:

extension Dictionary where Key: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {

    func prettyPrint(){
        for (key,value) in self {
            print("\(key) = \(value)")
        }
    }
}

उपयोग:

dictionary.prettyprint //var prettyprint
dictionary.prettyPrint //func prettyPrint

आउटपुट (Xcode 8 बीटा 2 प्लेग्राउंड में परीक्षण किया गया):

A = alfa
B = bravo
C = charlie
D = delta
E = echo
F = foxtrot

1
क्या कोई कारण है कि आपने केवल एक फ़ंक्शन के बजाय एक संस्करण को पूर्व निर्धारित किया है?
बजे हेडन हॉलिगन

ईमानदारी से, मुझे नहीं लगता कि यह मामला है (मैं गलत हो सकता है)। लेकिन अगर आप इसका भरपूर उपयोग करते हैं तो इसमें टाइप करना कम है। लेकिन एक दिलचस्प सवाल उठाएं।
असद्रबल

3
चूंकि एक descriptionऔर debugDescriptionपहले से ही है, इसलिए var को कॉल करना prettyDescriptionऔर स्वरूपित स्ट्रिंग को वापस करना अधिक उपयुक्त हो सकता है ।
टॉलैंड हॉन

5

स्विफ्ट डिक्शनरी को जसन और बैक में बदलने की पद्धति सबसे साफ है। मैं फेसबुक की छेनी का उपयोग करता हूं जिसमें स्विफ्ट डिक्शनरी छापने के लिए एक पीजसन कमांड है। उदाहरण के लिए:

(lldb) pjson dict as NSDictionary

इस शब्दकोश को सुंदर प्रिंट करना चाहिए। यह एक साफ-सुथरा तरीका है जो पहले से ही सुझाया गया है। पुनश्च अभी के लिए, आपको NS सहार के रूप में तानाशाह को डालना होगा क्योंकि उद्देश्य-सी रनटाइम स्विफ्ट शब्दकोशों को नहीं समझता है। मैंने पहले ही उस प्रतिबंध से छुटकारा पाने के लिए छेनी पर एक पीआर उठाया है।

अद्यतन: मेरा पीआर स्वीकार कर लिया है। अब आप ऊपर बताए गए pjson के बजाय psjson कमांड का उपयोग कर सकते हैं ।


4

के लिए स्विफ्ट 3 (& द्वारा प्रतिभाशाली जवाब पर निर्माण @Jalakoo ), निम्नलिखित बनाने Dictionaryविस्तार:

extension Dictionary where Key: ExpressibleByStringLiteral, Value: Any {
    var prettyPrint: String {
        return String(describing: self as AnyObject)
    }
}

तब किसी भी पदानुक्रम के शब्दकोश को एक सुंदर तरीके से (इससे बेहतर dump()) प्रिंट करें:

print(dictionary!.prettyPrint)

4

विवरण

  • Xcode 10.2.1 (10E1001), स्विफ्ट 5

समाधान

extension Dictionary {
    func format(options: JSONSerialization.WritingOptions) -> Any? {
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: self, options: options)
            return try JSONSerialization.jsonObject(with: jsonData, options: [.allowFragments])
        } catch {
            print(error.localizedDescription)
            return nil
        }
    }
}

प्रयोग

let dictionary: [String : Any] = [
                                    "id": 0,
                                    "bool": true,
                                    "int_array": [1,3,5],
                                    "dict_array": [
                                        ["id": 1, "text": "text1"],
                                        ["id": 1, "text": "text2"]
                                    ]
                                 ]
print("Regualr print:\n\(dictionary)\n")
guard let formatedDictionary = dictionary.format(options: [.prettyPrinted, .sortedKeys]) else { return }
print("Pretty printed:\n\(formatedDictionary)\n")

परिणाम

यहाँ छवि विवरण दर्ज करें


2

मेरे अन्य उत्तर के आधार पर समायोजित यहाँ

LLDB उपनाम का उपयोग करके बहुत बढ़िया JSON समाधान

कोई कोड की जरूरत

  • एक अच्छा json स्वरूपण (इंडेंटेशन, न्यूलाइन्स, आदि) प्राप्त करने के लिए आप अपने lldb टर्मिनल ( स्रोत ) में इस कमांड को चलाकर एक lldb उपनाम को परिभाषित कर सकते हैं :
command regex pjson 's/(.+)/expr print(NSString(string: String(data: try! JSONSerialization.data(withJSONObject: %1, options: .prettyPrinted), encoding: .utf8)!))/'
  • आप शायद XCode को खोलने के लिए हर बार उर्फ ​​को फिर से परिभाषित नहीं करना चाहते हैं, इसलिए निम्नलिखित परिभाषा को निम्न परिभाषा में जोड़ें ~/.lldbinit:
echo "command regex pjson 's/(.+)/expr print(NSString(string: String(data: try! JSONSerialization.data(withJSONObject: %1, options: .prettyPrinted), encoding: .utf8)!))/'" >> ~/.lldbinit
  • यह pjsonउर्फ बना देगा जिसे आप XCode में अपने lldb टर्मिनल में उपयोग कर सकते हैं:
pjson object

निम्न स्विफ्ट ऑब्जेक्ट के लिए आउटपुट की तुलना करना:

// Using Any? to demo optional & arbitrary Type
let dictionary: Any? = [
    "embedded": [
        "JustForTheSakeOfTheDemo": 42
    ],
    "A" : "alfa",
    "B" : "bravo",
    "C" : "charlie",
    "D" : "delta",
    "E" : "echo",
    "F" : "foxtrot"
]

✅ का उत्पादन pjson dictionary

{
  "F" : "foxtrot",
  "D" : "delta",
  "embedded" : {
    "JustForTheSakeOfTheDemo" : 42
  },
  "E" : "echo",
  "A" : "alfa",
  "C" : "charlie",
  "B" : "bravo"
}

❌ का उत्पादन p dictionary

(Any?) $R0 = 7 key/value pairs {
  [0] = {
    key = "F"
    value = "foxtrot"
  }
  [1] = {
    key = "D"
    value = "delta"
  }
  [2] = {
    key = "embedded"
    value = 1 key/value pair {
      [0] = (key = "JustForTheSakeOfTheDemo", value = 42)
    }
  }
  [3] = {
    key = "E"
    value = "echo"
  }
  [4] = {
    key = "A"
    value = "alfa"
  }
  [5] = {
    key = "C"
    value = "charlie"
  }
  [6] = {
    key = "B"
    value = "bravo"
  }
}

❌ का उत्पादन p (dictionary as! NSDictionary)

(NSDictionary) $R18 = 0x0000000281e89710 {
  ObjectiveC.NSObject = {
    base__SwiftNativeNSDictionaryBase@0 = {
      baseNSDictionary@0 = {
        NSObject = {
          isa = Swift._SwiftDeferredNSDictionary<Swift.String, Any> with unmangled suffix "$"
        }
      }
    }
  }
}

❌ का उत्पादन po dictionary

Optional<Any>
  ▿ some : 7 elements
    ▿ 0 : 2 elements
      - key : "F"
      - value : "foxtrot"1 : 2 elements
      - key : "D"
      - value : "delta"2 : 2 elements
      - key : "embedded"
      ▿ value : 1 element
        ▿ 0 : 2 elements
          - key : "JustForTheSakeOfTheDemo"
          - value : 423 : 2 elements
      - key : "E"
      - value : "echo"4 : 2 elements
      - key : "A"
      - value : "alfa"5 : 2 elements
      - key : "C"
      - value : "charlie"6 : 2 elements
      - key : "B"
      - value : "bravo"

❌ का उत्पादन po print(dictionary)

Optional(["F": "foxtrot", "D": "delta", "embedded": ["JustForTheSakeOfTheDemo": 42], "E": "echo", "A": "alfa", "C": "charlie", "B": "bravo"])


1

डिबगिंग करते समय, कंसोल के लिए कोडेबल प्रोटोकॉल के अनुरूप संरचना का
उपयोग करें , जोसन प्रारूप का उपयोग करता है।

extension Encodable {
    var jsonData: Data? {
        let encoder = JSONEncoder()
        encoder.outputFormatting = .prettyPrinted
        return try? encoder.encode(self)
    }
}

extension Encodable where Self: CustomDebugStringConvertible {
    var debugDescription: String {
         if let data = self.jsonData,
             let string = String(data: data, encoding: .utf8) {
             return string
         }
         return "can not convert to json string"
     }
}

कर्टकट कस्टमडैबगस्ट्रिंगकॉनवर्टेबल के अनुरूप है

struct Test: Codable, CustomDebugStringConvertible {
    let a: String
    let b: Int
}

let t = Test(a: "test string", b: 30)

डिबग प्रिंट संरचना

(lldb) p print(t)
{
  "a" : "test string",
  "b" : 30
}

1

डेटा ऑब्जेक्ट से सुंदर प्रिंट:

let jsonObj = try JSONSerialization.jsonObject(with: data, options: [])
            let jsonData = try JSONSerialization.data(withJSONObject: jsonObj, options: [.prettyPrinted])
            print(String(data: jsonData, encoding: .utf8)!)

1
यह भी खूब रही! आप डीबग टर्मिनल (विवरण यहाँ ) में आसानी से json की गणना करने के लिए एक एलडीबी उपनाम के साथ इस कोड का लाभ उठा सकते हैं ।
एग्रीकल्चर

0

कैसा रहेगा:

import Foundation

extension Dictionary {
    var myDesc: String {
        get {
            var v = ""
            for (key, value) in self {
                v += ("\(key) = \(value)\n")
            }
            return v
        }
    }
}


// Then, later, for any dictionary:
print(dictionary.myDesc)

0
extension String {

    var conslePrintString: String {

        guard let data = "\""
            .appending(
                replacingOccurrences(of: "\\u", with: "\\U")
                    .replacingOccurrences(of: "\"", with: "\\\"")
            )
            .appending("\"")
            .data(using: .utf8) else {

            return self
        }

        guard let propertyList = try? PropertyListSerialization.propertyList(from: data,
                                                                             options: [],
                                                                             format: nil) else {
            return self
        }

        guard let string = propertyList as? String else {
            return self
        }

        return string.replacingOccurrences(of: "\\r\\n", with: "\n")
    }
}

let code in extension String and it works fine 

let string = "\(jsonDictionary)".conslePrintString
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.