What is the main difference between PATCH and PUT request?

by

HTTP verbs are probably one of the most cryptic things about the HTTP protocol. They exist, and there are many of them, but why do they exist?

Rails seems to want to support many verbs and add some verbs that aren’t supported by web browsers natively.

Here’s an exhaustive list of http verbs: http://annevankesteren.nl/2007/10/http-methods

There the HTTP patch from the official RFC: https://datatracker.ietf.org/doc/rfc5789/?include_text=1

The PATCH method requests that a set of changes described in the
request entity be applied to the resource identified by the Request-
URI. The set of changes is represented in a format called a “patch
document” identified by a media type. If the Request-URI does not
point to an existing resource, the server MAY create a new resource,
depending on the patch document type (whether it can logically modify
a null resource) and permissions, etc.

The difference between the PUT and PATCH requests is reflected in the
way the server processes the enclosed entity to modify the resource
identified by the Request-URI. In a PUT request, the enclosed entity
is considered to be a modified version of the resource stored on the
origin server, and the client is requesting that the stored version be
replaced. With PATCH, however, the enclosed entity contains a set of
instructions describing how a resource currently residing on the
origin server should be modified to produce a new version. The PATCH
method affects the resource identified by the Request-URI, and it also
MAY have side effects on other resources; i.e., new resources may be
created, or existing ones modified, by the application of a PATCH.

As far as I know, the PATCH verb is not used as it is in rails applications… As I understand this, the RFC patch verb should be used to send patch instructions like when you do a diff between two files. Instead of sending the whole entity again, you send a patch that could be much smaller than resending the whole entity.

Imagine you want to edit a huge file. You edit 3 lines. Instead of sending the file back, you just have to send the diff. On the plus side, sending a patch request could be used to merge files asynchronously. A version control system could potentially use the PATCH verb to update code remotely.

One other possible use case is somewhat related to NoSQL databases, it is possible to store documents. Let say we use a JSON structure to send back and forth data from the server to the client. If we wanted to delete a field, we could use a syntax similar to the one in mongodb for $unset. Actually, the method used in mongodb to update documents could be probably used to handle json patches.

Taking this example:

db.products.update(
   { sku: "unknown" },
   { $unset: { quantity: "", instock: "" } }
)

We could have something like this:

PATCH /products?sku=unknown
{ "$unset": { "quantity": "", "instock": "" } }

Last, but not least, people can say whatever they want about HTTP verbs. There is only one truth, and the truth is in the RFCs.

More Related Contents:

  1. What is the difference between POST and PUT in HTTP?
  2. What’s the difference between a POST and a PUT HTTP REQUEST?
  3. How do I allow a PUT file request on Nginx server?
  4. How to idiomatically log auth information with middleware
  5. REST HTTP status codes for failed validation or invalid duplicate
  6. How to $http Synchronous call with AngularJS
  7. Correct way to pass multiple values for same parameter name in GET request
  8. Why is it said that “HTTP is a stateless protocol”?
  9. HTTP 1.0 vs 1.1
  10. How to set a timeout on a http.request() in Node?
  11. Angular2 http.get() ,map(), subscribe() and observable pattern – basic understanding
  12. What should a Multipart HTTP request with multiple files look like? [duplicate]
  13. Why shouldn’t data be modified on an HTTP GET request?
  14. Cookie handling in Google Apps Script – How to send cookies in header?
  15. Correct way of getting Client’s IP Addresses from http.Request
  16. HTTP status code for a partial successful request
  17. How to use angular2 http API for tracking upload/download progress
  18. Why can’t I set a cookie and redirect?
  19. How does “304 Not Modified” work exactly?
  20. Process Management for the Go Webserver
  21. Does HTTP use UDP?
  22. What is Cache-Control: private?
  23. Custom HTTP Authorization Header
  24. How to send line break with curl?
  25. PATCH Async requests with Windows.Web.Http.HttpClient class
  26. Multiple HTTP Authorization headers?
  27. Share a cookie between two websites
  28. What is HTTP “Host” header?
  29. nginx upload client_max_body_size issue
  30. “Cannot GET /” with Connect on Node.js

Leave a Comment