Sending array of dictionaries with alamofire

A couple of thoughts:

1. It would be easiest if you sent the response as a dictionary with one key, and it will correctly encode the array within the dictionary:

   let materials = [ "materials": [ [ "material_id": 1, "qty": 10 ], [ "material_id": 2, "qty": 5 ] ] ] 

   You could then just supply that as the parameters of request(), and Alamofire will properly encode that for you.

2. If you wanted to send an array of dictionaries, an alternative would be to change the web service to accept JSON. You could then encode the JSON yourself (using JSONSerialization or JSONEncoder), set the body of the request, and then send that request.

3. If you want to send application/x-www-form-urlencoded request with the array of dictionaries, you'd have to encode that yourself. In Swift 3 and later, that might look like:

   func encodeParameters(_ object: Any, prefix: String? = nil) -> String { if let dictionary = object as? [String: Any] { return dictionary.map { key, value -> String in self.encodeParameters(value, prefix: prefix != nil ? "\(prefix!)[\(key)]" : key) }.joined(separator: "&") } else if let array = object as? [Any] { return array.enumerated().map { (index, value) -> String in return self.encodeParameters(value, prefix: prefix != nil ? "\(prefix!)[\(index)]" : "\(index)") }.joined(separator: "&") } else { let escapedValue = "\(object)".addingPercentEncoding(withAllowedCharacters: .urlQueryValueAllowed)! return prefix != nil ? "\(prefix!)=\(escapedValue)" : "\(escapedValue)" } } 

   Where

   extension CharacterSet { /// Returns the character set for characters allowed in the individual parameters within a query URL component. /// /// The query component of a URL is the component immediately following a question mark (?). /// For example, in the URL `http://www.example.com/index.php?key1=value1#jumpLink`, the query /// component is `key1=value1`. The individual parameters of that query would be the key `key1` /// and its associated value `value1`. /// /// According to RFC 3986, the set of unreserved characters includes /// /// `ALPHA / DIGIT / "-" / "." / "_" / "~"` /// /// In section 3.4 of the RFC, it further recommends adding `/` and `?` to the list of unescaped characters /// for the sake of compatibility with some erroneous implementations, so this routine also allows those /// to pass unescaped. static var urlQueryValueAllowed: CharacterSet = { let generalDelimitersToEncode = ":#[]@" // does not include "?" or "/" due to RFC 3986 - Section 3.4 let subDelimitersToEncode = "!$&'()*+,;=" var allowed = CharacterSet.urlQueryAllowed allowed.remove(charactersIn: generalDelimitersToEncode + subDelimitersToEncode) return allowed }() } 

   Obviously, use whatever response method is appropriate for the nature of your server's response (e.g. response vs. responseJSON vs. ...).

   Anyway, the above generates a request body that looks like:

   materials[0][material_id]=1&materials[0][qty]=10&materials[1][material_id]=2&materials[1][qty]=5 

   And this appears to be parsed by servers as you requested in your question.

It's worth noting that this final point illustrates the preparation of an application/x-www-form-urlencoded request with nested dictionary/array structure, as contemplated here. This works on my server run by a major ISP, but I must confess that I haven't seen this convention documented in formal RFCs, so I'd be wary of doing it. I'd personally be inclined to implement this as JSON interface.

For prior versions of Swift, see previous revision of this answer.

You can make your array as JSON string and post in to server, then parse JSON in server end and from that you can get your desired data, lke this:

NSError *error; NSData *jsonData = [NSJSONSerialization dataWithJSONObject: yourArry options:NSJSONWritingPrettyPrinted error:&error]; NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding]; 

Hope this helps.. :)