String to dictionary (Get values from QRCode String) [closed] - ios

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 6 years ago.
Improve this question
I am trying to generate QRCode and then read it in. My problem is that I do not know how to get values from the QRCode string.
String inside my QRCode is following: ["firstName": "John", "lastName": "Bush"]
I achieved it like this:
let dict = ["firstName":firstName, "lastName": lastName]
dict.description
Now I want to get the values out of it, how should I do this? I tried to convert the string back to dictionary but couldn't do it.

Answer 1

If you're really interested in parsing this result, there is of course ways to do it. It's never going to be consistently successful unless there is a consistent format coming from your source. In the event that it is consistent, you could of course do something like this:
//get the string representation of our dictionary
let code = "[\"firstName\": \"firstName\", \"lastName\": \"lastName\"]"
//remove the brackets
let bracketless = String(code.characters.dropFirst().dropLast())
//get rid of our quotes
let quoteless = bracketless.replacingOccurrences(of: "\"", with: "")
//split our dictionary by key/value pairs
let pairs = quoteless.components(separatedBy: ", ")
//now split our key/value pairs into each key and value component respectively
let values: [[String]] = pairs.map { $0.components(separatedBy: ": ") }
//create ourself a dictionary to populate with our parsed data
var dict: [String:Any] = [:]
values.forEach { dict[$0[0]] = $0[1] } //populate the dictionary
print(dict) // ["lastName": "lastName", "firstName": "firstName"]
It's always better to use a standardized format (e.g. JSON). Perhaps in your situation this just isn't an option. I would still wonder why then you're in said situation..

Answer 2

This is rather tricky, the result from description is not really meant to be used as an exchange format. The best thing to do would be to use a different format to generate your QR Codes. But let's assume that it's too late for this.
To get the data back you need to write a parser, since the system doesn't provide one for the description format. Sounds hard, but it really is not. You might consider using the String method components(separatedBy:), but this will turn out very inefficient. The Foundation Scanner class is a much better tool for this.
The simplest parser to write is a "recursive descent" parser. This means for each part you want to recognise you write a function that calls such functions for sub-parts. So lets see what we have here:
The outer layer is the dictionary. This starts with the string "[", then we have key/value pairs separated by "," and finally another "]". (There also might be the case of an empty dictionary which is just "[]"
Then we have a pair. This is a string inside quotes, followed by a ":" and another quoted string.
The last part is the quoted string. There we have the quote ", and any other characters up to the next quote.
So in pseudo-code this will look something like this:
func dictionary() {
expect("[")
if !read("]") {
repeat {
pair()
} while read(",")
}
expect("]")
}
func pair() {
quotedString()
expect(":")
quotedString()
}
func quotedString() {
expect("\"")
readUpTo("\"")
expect("\"")
}
Here expect, read and readUpTo are placeholders for the methods provided by the Scanner class. If we provide those this basically is the complete parser. But like this it is not very useful as it just ignores the data. So we need to extend our parser so it actually returns the found data.
The final result then could look something like this:
let scanner = Scanner(string: string)
func dictionary() -> [String: String]? {
guard scanner.scanString("[", into: nil) else { return nil }
var result: [String: String] = [:]
if !scanner.scanString("]", into: nil) {
repeat {
guard let (key, value) = pair() else { return nil }
result[key] = value
} while scanner.scanString(",", into: nil)
}
guard scanner.scanString("]", into: nil) else { return nil }
return result
}
func pair() -> (String, String)? {
guard let key = quotedString(),
scanner.scanString(":", into: nil),
let value = quotedString()
else {
return nil
}
return (key, value)
}
func quotedString() -> String? {
guard scanner.scanString("\"", into: nil) else { return nil }
var result: NSString? = nil
guard scanner.scanUpTo("\"", into: &result), let string = result as? String else { return nil }
guard scanner.scanString("\"", into: nil) else { return nil }
return string
}
A little bit more code that the hacky solution using string splitting, but not really complicated either and much more flexible. Here we won't have any problems if the strings themselves contain "," or ":". The performance will be better too, since here we look at every character only once. The other solution will have to look at each character three times.
It still has one problem though: If any of your strings contain the double quote character this parser will fail. The description property of the dictionary will output this in a backslash-quoted form as \" - this will have to be handled in quotedString.