Как отправить файл изображения на сервер, используя функцию post с помощью быстрого 4 [дубликата]

В своем комментарии ниже вы сообщаете нам, что используете синтаксис $_FILES для извлечения файлов. Это означает, что вы хотите создать запрос multipart/form-data. Процесс в основном:

1. Укажите границу для вашего запроса multipart/form-data.
2. Укажите Content-Type запроса, который указывает, что он multipart/form-data и что граница.
3. Создает тело запроса, разделяя отдельные компоненты (каждый из опубликованных значений, а также между каждой загрузкой).

Подробнее см. RFC 2388 . В любом случае, в Swift 3 это может выглядеть так:

/// Create request
///
/// - parameter userid:   The userid to be passed to web service
/// - parameter password: The password to be passed to web service
/// - parameter email:    The email address to be passed to web service
///
/// - returns:            The `URLRequest` that was created

func createRequest(userid: String, password: String, email: String) throws -> URLRequest {
    let parameters = [
        "user_id"  : userid,
        "email"    : email,
        "password" : password]  // build your dictionary however appropriate

    let boundary = generateBoundaryString()

    let url = URL(string: "https://example.com/imageupload.php")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

    let path1 = Bundle.main.path(forResource: "image1", ofType: "png")!
    request.httpBody = try createBody(with: parameters, filePathKey: "file", paths: [path1], boundary: boundary)

    return request
}

/// Create body of the `multipart/form-data` request
///
/// - parameter parameters:   The optional dictionary containing keys and values to be passed to web service
/// - parameter filePathKey:  The optional field name to be used when uploading files. If you supply paths, you must supply filePathKey, too.
/// - parameter paths:        The optional array of file paths of the files to be uploaded
/// - parameter boundary:     The `multipart/form-data` boundary
///
/// - returns:                The `Data` of the body of the request

private func createBody(with parameters: [String: String]?, filePathKey: String, paths: [String], boundary: String) throws -> Data {
    var body = Data()

    if parameters != nil {
        for (key, value) in parameters! {
            body.append("--\(boundary)\r\n")
            body.append("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n")
            body.append("\(value)\r\n")
        }
    }

    for path in paths {
        let url = URL(fileURLWithPath: path)
        let filename = url.lastPathComponent
        let data = try Data(contentsOf: url)
        let mimetype = mimeType(for: path)

        body.append("--\(boundary)\r\n")
        body.append("Content-Disposition: form-data; name=\"\(filePathKey)\"; filename=\"\(filename)\"\r\n")
        body.append("Content-Type: \(mimetype)\r\n\r\n")
        body.append(data)
        body.append("\r\n")
    }

    body.append("--\(boundary)--\r\n")
    return body
}

/// Create boundary string for multipart/form-data request
///
/// - returns:            The boundary string that consists of "Boundary-" followed by a UUID string.

private func generateBoundaryString() -> String {
    return "Boundary-\(UUID().uuidString)"
}

/// Determine mime type on the basis of extension of a file.
///
/// This requires `import MobileCoreServices`.
///
/// - parameter path:         The path of the file for which we are going to determine the mime type.
///
/// - returns:                Returns the mime type if successful. Returns `application/octet-stream` if unable to determine mime type.

private func mimeType(for path: String) -> String {
    let url = URL(fileURLWithPath: path)
    let pathExtension = url.pathExtension

    if let uti = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, pathExtension as NSString, nil)?.takeRetainedValue() {
        if let mimetype = UTTypeCopyPreferredTagWithClass(uti, kUTTagClassMIMEType)?.takeRetainedValue() {
            return mimetype as String
        }
    }
    return "application/octet-stream"
}

С помощью:

extension Data {

    /// Append string to Data
    ///
    /// Rather than littering my code with calls to `data(using: .utf8)` to convert `String` values to `Data`, this wraps it in a nice convenient little extension to Data. This defaults to converting using UTF-8.
    ///
    /// - parameter string:       The string to be added to the `Data`.

    mutating func append(_ string: String, using encoding: String.Encoding = .utf8) {
        if let data = string.data(using: encoding) {
            append(data)
        }
    }
}

Или, в Swift 2:

/// Create request
///
/// - parameter userid:   The userid to be passed to web service
/// - parameter password: The password to be passed to web service
/// - parameter email:    The email address to be passed to web service
///
/// - returns:            The NSURLRequest that was created

func createRequest (userid userid: String, password: String, email: String) -> NSURLRequest {
    let param = [
        "user_id"  : userid,
        "email"    : email,
        "password" : password]  // build your dictionary however appropriate

    let boundary = generateBoundaryString()

    let url = NSURL(string: "https://example.com/imageupload.php")!
    let request = NSMutableURLRequest(URL: url)
    request.HTTPMethod = "POST"
    request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

    let path1 = NSBundle.mainBundle().pathForResource("image1", ofType: "png") as String!
    request.HTTPBody = createBodyWithParameters(param, filePathKey: "file", paths: [path1], boundary: boundary)

    return request
}

/// Create body of the multipart/form-data request
///
/// - parameter parameters:   The optional dictionary containing keys and values to be passed to web service
/// - parameter filePathKey:  The optional field name to be used when uploading files. If you supply paths, you must supply filePathKey, too.
/// - parameter paths:        The optional array of file paths of the files to be uploaded
/// - parameter boundary:     The multipart/form-data boundary
///
/// - returns:                The NSData of the body of the request

func createBodyWithParameters(parameters: [String: String]?, filePathKey: String?, paths: [String]?, boundary: String) -> NSData {
    let body = NSMutableData()

    if parameters != nil {
        for (key, value) in parameters! {
            body.appendString("--\(boundary)\r\n")
            body.appendString("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n")
            body.appendString("\(value)\r\n")
        }
    }

    if paths != nil {
        for path in paths! {
            let url = NSURL(fileURLWithPath: path)
            let filename = url.lastPathComponent
            let data = NSData(contentsOfURL: url)!
            let mimetype = mimeTypeForPath(path)

            body.appendString("--\(boundary)\r\n")
            body.appendString("Content-Disposition: form-data; name=\"\(filePathKey!)\"; filename=\"\(filename!)\"\r\n")
            body.appendString("Content-Type: \(mimetype)\r\n\r\n")
            body.appendData(data)
            body.appendString("\r\n")
        }
    }

    body.appendString("--\(boundary)--\r\n")
    return body
}

/// Create boundary string for multipart/form-data request
///
/// - returns:            The boundary string that consists of "Boundary-" followed by a UUID string.

func generateBoundaryString() -> String {
    return "Boundary-\(NSUUID().UUIDString)"
}

/// Determine mime type on the basis of extension of a file.
///
/// This requires MobileCoreServices framework.
///
/// - parameter path:         The path of the file for which we are going to determine the mime type.
///
/// - returns:                Returns the mime type if successful. Returns application/octet-stream if unable to determine mime type.

func mimeTypeForPath(path: String) -> String {
    let url = NSURL(fileURLWithPath: path)
    let pathExtension = url.pathExtension

    if let uti = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, pathExtension! as NSString, nil)?.takeRetainedValue() {
        if let mimetype = UTTypeCopyPreferredTagWithClass(uti, kUTTagClassMIMEType)?.takeRetainedValue() {
            return mimetype as String
        }
    }
    return "application/octet-stream";
}

И :

extension NSMutableData {

    /// Append string to NSMutableData
    ///
    /// Rather than littering my code with calls to `dataUsingEncoding` to convert strings to NSData, and then add that data to the NSMutableData, this wraps it in a nice convenient little extension to NSMutableData. This converts using UTF-8.
    ///
    /// - parameter string:       The string to be added to the `NSMutableData`.

    func appendString(string: String) {
        let data = string.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: true)
        appendData(data!)
    }
}

Имея все это, вам необходимо отправить этот запрос. Я бы посоветовал не использовать синхронную технику в вашем вопросе. Вы должны сделать это асинхронно. Например, в URLSession в Swift 3 вы сделаете что-то вроде:

let request: URLRequest

do {
    request = try createRequest(userid: userid, password: password, email: email)
} catch {
    print(error)
    return
}

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard error == nil else {
        // handle error here
        print(error!)
        return
    }

    // if response was JSON, then parse it

    do {
        let responseDictionary = try JSONSerialization.jsonObject(with: data!)
        print("success == \(responseDictionary)")

        // note, if you want to update the UI, make sure to dispatch that to the main queue, e.g.:
        //
        // DispatchQueue.main.async {
        //     // update your UI and model objects here
        // }
    } catch {
        print(error)

        let responseString = String(data: data!, encoding: .utf8)
        print("responseString = \(responseString)")
    }
}
task.resume()

Или, для версии Swift 2:

let request = createRequest(userid: userid, password: password, email: email)

let task = NSURLSession.sharedSession().dataTaskWithRequest(request) { data, response, error in
    if error != nil {
        // handle error here
        print(error)
        return
    }

    // if response was JSON, then parse it

    do {
        if let responseDictionary = try NSJSONSerialization.JSONObjectWithData(data!, options: []) as? NSDictionary {
            print("success == \(responseDictionary)")

            // note, if you want to update the UI, make sure to dispatch that to the main queue, e.g.:
            //
            // dispatch_async(dispatch_get_main_queue()) {
            //     // update your UI and model objects here
            // }
        }
    } catch {
        print(error)

        let responseString = NSString(data: data!, encoding: NSUTF8StringEncoding)
        print("responseString = \(responseString)")
    }
}
task.resume()

Мой оригинал ниже для исторических целей:

Несколько наблюдений:

1. Вы устанавливаете HTTPBody как стандартный формат POST (как если бы он был запросом application/x-www-form-urlencoded, даже если вы этого не указали). Затем вы можете отказаться от этого и заменить его двоичными данными PNG-представления изображения. Вы, вероятно, хотели отправить оба.
2. Мы не можем дать вам разъяснения относительно того, что ожидает сервер, но часто это multipart/form-data, а не application/x-www-form-urlencoded (например, если это веб-служба PHP, он использует переменную $_FILES). Если вы пытаетесь сделать multipart/form-data, см. Это POST multipart / form-data с Objective-C , например, как это сделать. Ясно, что это Objective-C, но это иллюстрирует основную технику. Обратите внимание: существуют и другие форматы, используемые другими веб-службами, поэтому я смущаюсь просто предположить, что это ожидает запрос multipart/form-data. Вы должны точно подтвердить, что ожидает сервер.

Излишне говорить, что есть и другие проблемы (например, вы действительно должны указать Content-Type запроса, по крайней мере; вы действительно не должны выдавать синхронный запрос (если вы уже делаете это в фоновом потоке), я бы посоветовал NSURLSession и т. д.).

Но основная проблема заключается в том, как вы заселяете HTTPBody. Нам тяжело помочь вам в дальнейшем без большей ясности относительно того, что требует сервер.