Swift中如何通过字符串访问变量？plist配置表单上传的实现疑问

Got it, let's tackle this problem—you're totally on the right track with the property_name: backend_name dictionary approach, and Swift's static typing doesn't block this at all. Here's how to make it work step by step:

1. Define Your Field Mapping #

First, create a dictionary that maps your local form property names to the exact keys the backend expects. You can either hardcode this (great for small sets) or load it from a plist file (perfect if you want to tweak mappings without changing code):

Option A: Hardcoded Mapping #

// Local property name → Backend field name
let fieldMapping: [String: String] = [
    "userFullName": "backend_full_name",
    "userEmail": "backend_email_address",
    "userPhone": "backend_contact_number"
]

Option B: Load from Plist #

Add a plist file (e.g., FieldMapping.plist) to your project with key-value pairs matching the structure above, then load it like this:

var fieldMapping: [String: String] = [:]

if let plistPath = Bundle.main.path(forResource: "FieldMapping", ofType: "plist"),
   let loadedMapping = NSDictionary(contentsOfFile: plistPath) as? [String: String] {
    fieldMapping = loadedMapping
}

2. Transform Local Form Data to Backend Format #

Assume you have a dictionary (or a model you can convert to a dictionary) holding the user's form input. We'll use the mapping to swap out the keys for the backend's required names:

// Example: Local form data from user input
let localFormData: [String: Any] = [
    "userFullName": "Jane Smith",
    "userEmail": "jane@example.com",
    "userPhone": "555-1234"
]

// Convert to backend-compatible data
var backendFormData = [String: Any]()
for (localKey, backendKey) in fieldMapping {
    // Only add the field if it exists in the local data
    if let value = localFormData[localKey] {
        backendFormData[backendKey] = value
    }
}

3. Upload the Transformed Data #

Now you can send backendFormData to your server using either URLSession (native) or a library like Alamofire. Here's the native approach for URL-encoded form data:

guard let uploadURL = URL(string: "https://your-backend-endpoint.com/submit-form") else {
    print("Invalid backend URL")
    return
}

var request = URLRequest(url: uploadURL)
request.httpMethod = "POST"
request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")

// Convert the backend data dictionary to a URL-encoded string
let encodedFormString = backendFormData.compactMap { key, value in
    guard let encodedValue = "\(value)".addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
        return nil
    }
    return "\(key)=\(encodedValue)"
}.joined(separator: "&")

request.httpBody = encodedFormString.data(using: .utf8)

// Execute the request
let uploadTask = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Upload error: \(error.localizedDescription)")
        return
    }
    
    // Handle successful response
    if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
        print("Form uploaded successfully!")
        // Parse response data if needed
        if let data = data {
            // Process data here
        }
    }
}
uploadTask.resume()

Why This Works With Swift's Static Typing #

You don't need dynamic variables here—we're just using dictionaries to map and transform data at runtime. Swift's static typing ensures type safety for your core code, but dictionaries let you handle dynamic key-value pairs exactly for scenarios like this form mapping.

内容的提问来源于stack exchange，提问作者James Woodrow