HTTP-യിലെ POST-ഉം PUT-ഉം തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കുന്നു

Arthur Petit
2024, ജൂൺ 2, ഞായറാഴ്‌ച 7:43:46 PM
Node.js

HTTP രീതികളിലേക്കുള്ള ആമുഖം

RESTful വെബ് സേവനങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ, HTTP രീതികൾ, പ്രത്യേകിച്ച് POST, PUT എന്നിവ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ മനസ്സിലാക്കേണ്ടത് വളരെ പ്രധാനമാണ്. ഈ രീതികൾ പലപ്പോഴും ഉറവിടങ്ങൾ സൃഷ്ടിക്കുന്നതിനും അപ്ഡേറ്റ് ചെയ്യുന്നതിനും ഉപയോഗിക്കുന്നു, എന്നാൽ അവ വ്യത്യസ്ത രീതികളിൽ പ്രവർത്തിക്കുന്നു. അവരുടെ തനതായ ഉദ്ദേശ്യങ്ങളും ശരിയായ ആപ്ലിക്കേഷനുകളും മനസ്സിലാക്കുന്നത് നിങ്ങളുടെ API ഡിസൈൻ കാര്യക്ഷമവും അവബോധജന്യവുമാണെന്ന് ഉറപ്പാക്കാൻ സഹായിക്കും.

POST സാധാരണയായി പുതിയ ഉറവിടങ്ങൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു, അതേസമയം PUT ഒരു പ്രത്യേക URI-യിൽ ഒരു ഉറവിടം സൃഷ്ടിക്കുന്നതിനോ മാറ്റിസ്ഥാപിക്കുന്നതിനോ ഉപയോഗിക്കുന്നു. ഈ വേർതിരിവ്, സൂക്ഷ്മമായതാണെങ്കിലും, ഒരു വെബ് സേവന പരിതസ്ഥിതിയിൽ വിഭവങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യപ്പെടുകയും സംവദിക്കുകയും ചെയ്യുന്നു എന്നതിന് സുപ്രധാനമായ പ്രത്യാഘാതങ്ങളുണ്ട്.

കമാൻഡ് വിവരണം
express() എക്സ്പ്രസ് ആപ്ലിക്കേഷൻ ആരംഭിക്കുന്നു.
app.use(express.json()) ഇൻകമിംഗ് JSON അഭ്യർത്ഥനകൾ പാഴ്‌സ് ചെയ്യാൻ മിഡിൽവെയർ.
app.post() ഉറവിടങ്ങൾ സൃഷ്ടിക്കുന്നത് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു POST റൂട്ട് നിർവചിക്കുന്നു.
app.put() ഉറവിടങ്ങൾ അപ്‌ഡേറ്റുചെയ്യുന്നതിനോ മാറ്റിസ്ഥാപിക്കുന്നതിനോ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു PUT റൂട്ട് നിർവചിക്കുന്നു.
req.body അഭ്യർത്ഥന ബോഡിയിൽ അയച്ച JSON ഡാറ്റ ആക്സസ് ചെയ്യുന്നു.
res.status().send() HTTP സ്റ്റാറ്റസ് കോഡ് സജ്ജീകരിക്കുകയും ക്ലയൻ്റിന് ഒരു പ്രതികരണം അയയ്ക്കുകയും ചെയ്യുന്നു.
fetch() മുൻവശത്ത് നിന്ന് HTTP അഭ്യർത്ഥനകൾ നടത്തുന്നു.
method: 'POST' ലഭ്യമാക്കുന്നതിനുള്ള അഭ്യർത്ഥനയിൽ ഉപയോഗിക്കേണ്ട HTTP രീതി വ്യക്തമാക്കുന്നു.
headers: { 'Content-Type': 'application/json' } JSON ഉള്ളടക്കം സൂചിപ്പിക്കാൻ അഭ്യർത്ഥന തലക്കെട്ടുകൾ സജ്ജമാക്കുന്നു.
body: JSON.stringify(data) അഭ്യർത്ഥന ബോഡിക്കായി JavaScript ഒബ്‌ജക്റ്റ് ഡാറ്റയെ JSON സ്‌ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

POST, PUT സ്ക്രിപ്റ്റുകളുടെ പ്രവർത്തനക്ഷമത മനസ്സിലാക്കുന്നു

Node.js, Express എന്നിവ ഉപയോഗിക്കുന്ന ബാക്കെൻഡ് സ്‌ക്രിപ്റ്റ് HTTP രീതികൾ എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് കാണിക്കുന്നു ഒപ്പം റിസോഴ്സ് മാനേജ്മെൻ്റിനായി. ദി ഫംഗ്ഷൻ എക്സ്പ്രസ് ആപ്ലിക്കേഷൻ ആരംഭിക്കുന്നു, അതേസമയം app.use(express.json()) ഇൻകമിംഗ് JSON അഭ്യർത്ഥനകൾ പാഴ്‌സ് ചെയ്യാൻ മിഡിൽവെയർ ഉപയോഗിക്കുന്നു. ദി റിസോഴ്സ് ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്ന ഒരു റിസോഴ്‌സ് സൃഷ്‌ടിക്കാനുള്ള ഒരു റൂട്ട് രീതി നിർവചിക്കുന്നു ഒരു സെർവർ സൈഡ് ഒബ്‌ജക്റ്റിൽ സംഭരിക്കുകയും ചെയ്യുന്നു. റിസോഴ്സ് വിജയകരമായി സൃഷ്ടിച്ചുവെന്ന് സൂചിപ്പിക്കുന്ന 201 സ്റ്റാറ്റസ് കോഡ് ഉപയോഗിച്ച് പ്രതികരണം ക്ലയൻ്റിലേക്ക് തിരികെ അയയ്ക്കുന്നു.

ദി നിലവിലുള്ള ഒരു വിഭവം അപ്ഡേറ്റ് ചെയ്യുന്നതിനോ മാറ്റിസ്ഥാപിക്കുന്നതിനോ ഉള്ള ഒരു റൂട്ട് രീതി നിർവചിക്കുന്നു. ഈ രീതി റിസോഴ്സ് ഐഡി ഉപയോഗിക്കുന്നു എന്നിവയിൽ നിന്നുള്ള ഡാറ്റയും സെർവർ സൈഡ് ഒബ്ജക്റ്റ് അപ്ഡേറ്റ് ചെയ്യാൻ. റിസോഴ്‌സ് വിജയകരമായി അപ്‌ഡേറ്റ് ചെയ്‌തതായി സൂചിപ്പിക്കുന്ന 200 സ്റ്റാറ്റസ് കോഡ് ഉപയോഗിച്ച് പ്രതികരണം തിരികെ അയച്ചു. ഈ HTTP അഭ്യർത്ഥനകൾ നടപ്പിലാക്കാൻ ഫ്രണ്ട്എൻഡ് സ്ക്രിപ്റ്റ് Fetch API ഉപയോഗിക്കുന്നു. ദി fetch() ഉചിതമായ രീതികൾ ഉപയോഗിച്ച് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു ( ഒപ്പം ) കൂടാതെ ബാക്കെൻഡുമായി സംവദിക്കാനുള്ള തലക്കെട്ടുകൾ, ഉറവിടങ്ങൾ ശരിയായി സൃഷ്ടിക്കുകയും ക്ലയൻ്റ് ഭാഗത്ത് നിന്ന് അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു.

Node.js, Express എന്നിവ ഉപയോഗിച്ച് ബാക്കെൻഡ് സ്ക്രിപ്റ്റ്

ഒരു Node.js, Express ബാക്കെൻഡിൽ POST, PUT രീതികൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ സ്ക്രിപ്റ്റ് കാണിക്കുന്നു.

const express = require('express');
const app = express();
app.use(express.json());

let resources = {};

app.post('/resource', (req, res) => {
  const id = generateId();
  resources[id] = req.body;
  res.status(201).send({ id, ...req.body });
});

app.put('/resource/:id', (req, res) => {
  const id = req.params.id;
  resources[id] = req.body;
  res.status(200).send({ id, ...req.body });
});

function generateId() {
  return Math.random().toString(36).substr(2, 9);
}

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

JavaScript, Fetch API എന്നിവ ഉപയോഗിച്ച് ഫ്രണ്ട്എൻഡ് സ്‌ക്രിപ്റ്റ്

JavaScript, Fetch API എന്നിവ ഉപയോഗിച്ച് ഒരു ഫ്രണ്ട്എൻഡ് ആപ്ലിക്കേഷനിൽ നിന്ന് എങ്ങനെ POST, PUT അഭ്യർത്ഥനകൾ നടത്താമെന്ന് ഈ സ്‌ക്രിപ്റ്റ് കാണിക്കുന്നു.

const createResource = async (data) => {
  const response = await fetch('http://localhost:3000/resource', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
  });
  return response.json();
};

const updateResource = async (id, data) => {
  const response = await fetch(`http://localhost:3000/resource/${id}`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
  });
  return response.json();
};

// Example usage
createResource({ name: 'New Resource' }).then(data => console.log(data));
updateResource('existing-id', { name: 'Updated Resource' }).then(data => console.log(data));

RESTful API-കളിൽ റിസോഴ്സ് ക്രിയേഷൻ പര്യവേക്ഷണം ചെയ്യുന്നു

RESTful API-കൾ രൂപകൽപ്പന ചെയ്യുമ്പോൾ, ഇവയ്ക്കിടയിൽ തിരഞ്ഞെടുക്കുന്നു ഒപ്പം വിഭവങ്ങൾ സൃഷ്ടിക്കുന്നതിനുള്ള രീതികൾ ഉപയോഗ സാഹചര്യത്തെയും ആവശ്യമുള്ള പെരുമാറ്റത്തെയും ആശ്രയിച്ചിരിക്കുന്നു. ദി ഒരു നിർദ്ദിഷ്ട ഉറവിടത്തിന് കീഴിൽ ഒരു പുതിയ സബോർഡിനേറ്റ് റിസോഴ്സ് സൃഷ്ടിക്കാൻ രീതി ഉപയോഗിക്കുന്നു. ഇത് നിഷ്ക്രിയമാണ്, അതായത് ഒന്നിലധികം POST അഭ്യർത്ഥനകൾ ഒന്നിലധികം ഉറവിടങ്ങൾ സൃഷ്ടിക്കുന്നതിന് കാരണമാകും. സെർവർ പുതിയ റിസോഴ്സിൻ്റെ URI നിർണ്ണയിക്കുമ്പോൾ ഈ രീതി അനുയോജ്യമാണ്.

മറുവശത്ത്, ദി ഒരു നിർദ്ദിഷ്‌ട യുആർഐയിൽ ഒരു റിസോഴ്‌സ് സൃഷ്‌ടിക്കാനോ മാറ്റിസ്ഥാപിക്കാനോ രീതിക്ക് കഴിയും. ഇത് ഐഡമ്പറ്റൻ്റാണ്, അതായത് ഒന്നിലധികം സമാനമായ PUT അഭ്യർത്ഥനകൾ ഒരൊറ്റ അഭ്യർത്ഥനയുടെ അതേ ഫലം നൽകും. ക്ലയൻ്റ് സൃഷ്ടിക്കുന്നതോ അപ്‌ഡേറ്റ് ചെയ്യേണ്ടതോ ആയ ഉറവിടത്തിൻ്റെ URI വ്യക്തമാക്കുന്ന സാഹചര്യങ്ങൾക്ക് ഈ രീതി അനുയോജ്യമാണ്. ഈ വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുന്നത്, പ്രതീക്ഷിക്കുന്ന സ്വഭാവങ്ങളോടും ആവശ്യകതകളോടും പൊരുത്തപ്പെടുന്ന API-കൾ രൂപകൽപ്പന ചെയ്യാൻ സഹായിക്കുന്നു.

  1. POST രീതിയുടെ പ്രാഥമിക ഉപയോഗം എന്താണ്?
  2. ദി ഒരു നിർദ്ദിഷ്ട വിഭവത്തിൻ്റെ കീഴിലായി ഒരു പുതിയ ഉറവിടം സൃഷ്ടിക്കുന്നതിനാണ് ഈ രീതി പ്രാഥമികമായി ഉപയോഗിക്കുന്നത്.
  3. PUT രീതിയുടെ പ്രാഥമിക ഉപയോഗം എന്താണ്?
  4. ദി ഒരു നിർദ്ദിഷ്‌ട യുആർഐയിൽ ഒരു ഉറവിടം സൃഷ്‌ടിക്കുന്നതിനോ മാറ്റിസ്ഥാപിക്കുന്നതിനോ ആണ് രീതി ഉപയോഗിക്കുന്നത്.
  5. POST നിർജീവമാണോ?
  6. ഇല്ല, ദി രീതി ഐഡമ്പറ്റൻ്റല്ല, അതായത് ഒന്നിലധികം POST അഭ്യർത്ഥനകൾ ഒന്നിലധികം ഉറവിടങ്ങൾ സൃഷ്ടിക്കും.
  7. PUT ബുദ്ധിശൂന്യമാണോ?
  8. അതെ, ദി രീതി ഐഡമ്പറ്റൻ്റാണ്, അതായത് ഒന്നിലധികം സമാനമായ PUT അഭ്യർത്ഥനകൾ ഒരൊറ്റ അഭ്യർത്ഥനയുടെ അതേ ഫലം നൽകും.
  9. എപ്പോഴാണ് നിങ്ങൾ POST-ൽ PUT ഉപയോഗിക്കേണ്ടത്?
  10. ഉപയോഗിക്കുക സെർവർ പുതിയ ഉറവിടത്തിൻ്റെ URI നിർണ്ണയിക്കുമ്പോൾ, ക്ലയൻ്റ് അത് വ്യക്തമാക്കേണ്ടതില്ല.
  11. എപ്പോഴാണ് നിങ്ങൾ POST-ൽ PUT ഉപയോഗിക്കേണ്ടത്?
  12. ഉപയോഗിക്കുക സൃഷ്‌ടിക്കാനോ അപ്‌ഡേറ്റ് ചെയ്യാനോ ഉള്ള വിഭവത്തിൻ്റെ യുആർഐ ക്ലയൻ്റ് വ്യക്തമാക്കുമ്പോൾ.
  13. ഒരു റിസോഴ്സ് അപ്ഡേറ്റ് ചെയ്യാൻ PUT ഉപയോഗിക്കാമോ?
  14. അതെ, ദി നിർദ്ദിഷ്ട URI നിലവിലുള്ള ഒരു റിസോഴ്സിനെയാണ് സൂചിപ്പിക്കുന്നതെങ്കിൽ, രീതിക്ക് നിലവിലുള്ള ഒരു ഉറവിടം അപ്ഡേറ്റ് ചെയ്യാൻ കഴിയും.
  15. ഒരു റിസോഴ്സ് അപ്ഡേറ്റ് ചെയ്യാൻ POST ഉപയോഗിക്കാമോ?
  16. അതേസമയം ഒരു റിസോഴ്‌സ് സാങ്കേതികമായി അപ്‌ഡേറ്റ് ചെയ്യാൻ കഴിയും, ഇത് സാധാരണയായി പുതിയ ഉറവിടങ്ങൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു.
  17. ഒരു PUT അഭ്യർത്ഥനയിലെ URI നിലവിലില്ലെങ്കിൽ എന്ത് സംഭവിക്കും?
  18. URI നിലവിലില്ലെങ്കിൽ, രീതിക്ക് ആ URI-യിൽ ഒരു പുതിയ ഉറവിടം സൃഷ്ടിക്കാൻ കഴിയും.
  19. വിജയകരമായ POST അഭ്യർത്ഥനയ്ക്കുള്ള പ്രതികരണ സ്റ്റാറ്റസ് കോഡ് എന്താണ്?
  20. ഒരു വിജയിച്ചു അഭ്യർത്ഥന സാധാരണയായി 201 സൃഷ്ടിച്ച സ്റ്റാറ്റസ് കോഡ് നൽകുന്നു.

HTTP-യിൽ POST, PUT എന്നിവയ്‌ക്കുള്ള പ്രധാന ടേക്ക്അവേകൾ

കാര്യക്ഷമവും ഫലപ്രദവുമായ RESTful API-കൾ നിർമ്മിക്കുന്നതിന് റിസോഴ്‌സ് സൃഷ്‌ടിക്കുന്നതിന് ഉചിതമായ HTTP രീതി തിരഞ്ഞെടുക്കുന്നത് അത്യന്താപേക്ഷിതമാണ്. ദി സെർവർ റിസോഴ്സിൻ്റെ യുആർഐ നിർണ്ണയിക്കുന്ന പുതിയ ഉറവിടങ്ങൾ സൃഷ്ടിക്കുന്നതിന് ഏറ്റവും അനുയോജ്യമാണ് രീതി. ഇത് നിഷ്ക്രിയമാണ്, ഒന്നിലധികം അഭ്യർത്ഥനകൾ ഒന്നിലധികം വിഭവങ്ങൾ സൃഷ്ടിക്കുന്നതിലേക്ക് നയിച്ചേക്കാം. വിപരീതമായി, ദി റിസോഴ്സിനായി ക്ലയൻ്റ് യുആർഐ വ്യക്തമാക്കുമ്പോൾ ഈ രീതി അനുയോജ്യമാണ്, കൂടാതെ ഉറവിടങ്ങൾ സൃഷ്ടിക്കുന്നതിനോ അപ്ഡേറ്റ് ചെയ്യുന്നതിനോ ഇത് ഉപയോഗിക്കാം. ആവർത്തിച്ചുള്ള അഭ്യർത്ഥനകൾക്കിടയിലും സ്ഥിരമായ ഫലങ്ങൾ ഉറപ്പാക്കുന്ന, അത് നിഷ്‌ക്രിയമാണ്.

ഈ സൂക്ഷ്മതകൾ മനസ്സിലാക്കുന്നത് ഡെവലപ്പർമാരെ പ്രതീക്ഷിക്കുന്ന പെരുമാറ്റങ്ങൾക്കും ആവശ്യകതകൾക്കും അനുസൃതമായി API-കൾ രൂപകൽപ്പന ചെയ്യാൻ സഹായിക്കുന്നു. നൽകിയിരിക്കുന്ന ഉദാഹരണങ്ങൾ, Node.js, Express എന്നിവ ഉപയോഗിച്ച് ഒരു ബാക്കെൻഡ് സിസ്റ്റത്തിൽ ഈ രീതികൾ എങ്ങനെ നടപ്പിലാക്കാമെന്ന് കാണിക്കുന്നു, സെർവറിൽ നിന്നും ക്ലയൻ്റ് വശങ്ങളിൽ നിന്നും വിഭവങ്ങൾ ഫലപ്രദമായി കൈകാര്യം ചെയ്യപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

ഉപസംഹാരമായി, RESTful API-കൾക്കുള്ളിൽ റിസോഴ്സ് സൃഷ്ടിയിലും മാനേജ്മെൻ്റിലും POST, PUT രീതികൾക്ക് വ്യതിരിക്തമായ പങ്കുണ്ട്. ഒരു യുആർഐ വ്യക്തമാക്കാതെ തന്നെ പുതിയ ഉറവിടങ്ങൾ സൃഷ്‌ടിക്കുന്നതിന് POST അനുയോജ്യമാണ്, അതേസമയം ഒരു നിർദ്ദിഷ്‌ട യുആർഐയിൽ ഉറവിടങ്ങൾ സൃഷ്‌ടിക്കുന്നതിനോ അപ്‌ഡേറ്റുചെയ്യുന്നതിനോ PUT മികച്ചതാണ്. ഈ രീതികൾ മനസ്സിലാക്കുകയും ഉചിതമായി ഉപയോഗിക്കുകയും ചെയ്യുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് കരുത്തുറ്റതും വിശ്വസനീയവും RESTful ആർക്കിടെക്ചറിൻ്റെ തത്വങ്ങളുമായി പൊരുത്തപ്പെടുന്നതുമായ API-കൾ രൂപകൽപ്പന ചെയ്യാൻ കഴിയും.