JavaScript-ൽ വേരിയബിൾ തരങ്ങൾ മനസ്സിലാക്കുന്നു
JavaScript-ൽ ഒരു വേരിയബിളിൻ്റെ തരം നിർണ്ണയിക്കുന്നത് ഡെവലപ്പർമാർക്ക് ഒരു അടിസ്ഥാന വൈദഗ്ധ്യമാണ്. വിവിധ ഡാറ്റാ തരങ്ങളിൽ, ടെക്സ്റ്റും പ്രതീകങ്ങളും കൈകാര്യം ചെയ്യുന്നതിൽ സ്ട്രിംഗുകൾ നിർണായക പങ്ക് വഹിക്കുന്നു.
ഈ ലേഖനത്തിൽ, ഒരു വേരിയബിൾ JavaScript-ൽ ഒരു സ്ട്രിംഗ് ആണോ എന്ന് പരിശോധിക്കുന്നതിനുള്ള വ്യത്യസ്ത രീതികൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. നിങ്ങളുടെ വേരിയബിളുകൾ പ്രതീക്ഷിക്കുന്ന ഡാറ്റ തരങ്ങൾ കൈവശം വയ്ക്കുന്നുവെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് കൂടുതൽ കരുത്തുറ്റതും പിശകില്ലാത്തതുമായ കോഡ് എഴുതാൻ ഇത് നിങ്ങളെ സഹായിക്കും.
| കമാൻഡ് | വിവരണം |
|---|---|
| typeof | ഒരു വേരിയബിളിൻ്റെ ഡാറ്റ തരം നിർണ്ണയിക്കുന്നു. ഒരു വേരിയബിൾ ഒരു സ്ട്രിംഗ് ആണോ എന്ന് പരിശോധിക്കാൻ ഉപയോഗപ്രദമാണ്. |
| instanceof | ഒരു ഒബ്ജക്റ്റ് ഒരു നിർദ്ദിഷ്ട ക്ലാസിൻ്റെയോ കൺസ്‌ട്രക്‌റ്ററിൻ്റെയോ ഉദാഹരണമാണോ എന്ന് പരിശോധിക്കുന്നു. സ്ട്രിംഗ് ഒബ്ജക്റ്റുകൾ തിരിച്ചറിയാൻ സഹായിക്കുന്നു. |
| new String() | ഒരു പുതിയ സ്ട്രിംഗ് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു. പരിശോധനയുടെ ഉദാഹരണം കാണിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്. |
| http.createServer() | Node.js-ൽ ഒരു HTTP സെർവർ സൃഷ്ടിക്കുന്നു. HTTP അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യാനും പ്രതികരിക്കാനും ഉപയോഗിക്കുന്നു. |
| req.url | ഒരു ഇൻകമിംഗ് HTTP അഭ്യർത്ഥനയിൽ നിന്ന് URL വീണ്ടെടുക്കുന്നു. മൂല്യനിർണ്ണയത്തിനായി മൂല്യം വേർതിരിച്ചെടുക്കാൻ ഉപയോഗിക്കുന്നു. |
| res.writeHead() | HTTP പ്രതികരണ തലക്കെട്ടുകൾ എഴുതുന്നു. പ്രതികരണത്തിൻ്റെ സ്റ്റാറ്റസ് കോഡും ഉള്ളടക്ക തരവും സജ്ജമാക്കാൻ ഉപയോഗിക്കുന്നു. |
| res.end() | HTTP പ്രതികരണം അവസാനിപ്പിക്കുകയും ക്ലയൻ്റിലേക്ക് ഡാറ്റ തിരികെ അയയ്ക്കുകയും ചെയ്യുന്നു. മൂല്യനിർണ്ണയ ഫലങ്ങൾ നൽകുന്നതിന് ഉപയോഗിക്കുന്നു. |
| server.listen() | HTTP സെർവർ ആരംഭിക്കുകയും ഒരു നിർദ്ദിഷ്ട പോർട്ടിൽ ഇൻകമിംഗ് അഭ്യർത്ഥനകൾ ശ്രദ്ധിക്കുകയും ചെയ്യുന്നു. |
JavaScript-ൽ സ്ട്രിംഗ് തരം പരിശോധന പര്യവേക്ഷണം ചെയ്യുന്നു
ആദ്യ സ്ക്രിപ്റ്റ് ജാവാസ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ഫ്രണ്ട്എൻഡ് നടപ്പിലാക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. ഇത് രണ്ട് പ്രാഥമിക രീതികൾ ഉപയോഗിക്കുന്നു: ഒപ്പം . ദി ഒരു വേരിയബിളിൻ്റെ തരം നിർണ്ണയിക്കുന്നതിനുള്ള ഒരു നേരായ മാർഗമാണ് ഓപ്പറേറ്റർ. ഒരു വേരിയബിളിൽ പ്രയോഗിക്കുമ്പോൾ, അത് 'സ്ട്രിംഗ്', 'നമ്പർ' അല്ലെങ്കിൽ 'ബൂളിയൻ' പോലുള്ള തരം സൂചിപ്പിക്കുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു. പ്രാകൃത സ്ട്രിംഗ് മൂല്യങ്ങൾക്ക് ഈ രീതി ലളിതവും ഫലപ്രദവുമാണ്. മറുവശത്ത്, ദി instanceof ഒരു ഒബ്ജക്റ്റ് ഒരു പ്രത്യേക കൺസ്ട്രക്റ്ററുടെ ഉദാഹരണമാണോ എന്ന് ഓപ്പറേറ്റർ പരിശോധിക്കുന്നു. ഉപയോഗിച്ച് സൃഷ്ടിച്ച സ്ട്രിംഗ് ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ് കൺസ്ട്രക്റ്റർ. പ്രിമിറ്റീവ് സ്ട്രിംഗുകൾക്കും സ്ട്രിംഗ് ഒബ്‌ജക്റ്റുകൾക്കുമായി സമഗ്രമായ തരം പരിശോധന ഉറപ്പാക്കുന്നതിന് സ്ക്രിപ്റ്റ് രണ്ട് രീതികളും ഉദാഹരണങ്ങളോടെ കാണിക്കുന്നു.
രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് Node.js ഉപയോഗിച്ച് ബാക്കെൻഡ് മൂല്യനിർണ്ണയത്തെ അഭിസംബോധന ചെയ്യുന്നു. ഇറക്കുമതി ചെയ്തുകൊണ്ടാണ് ഇത് ആരംഭിക്കുന്നത് മൊഡ്യൂൾ ചെയ്ത് ഒരു HTTP സെർവർ സൃഷ്ടിക്കുന്നു പ്രവർത്തനം. ഉപയോഗിക്കുന്ന URL പാതയിൽ നിന്ന് സെർവർ ഒരു മൂല്യം വേർതിരിച്ചെടുക്കുന്നു അതൊരു സ്ട്രിംഗ് ആണോ എന്ന് പരിശോധിക്കുന്നു. ദി typeof മൂല്യത്തിൻ്റെ തരം നിർണ്ണയിക്കാൻ ഇവിടെ ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു. ഫലത്തെ അടിസ്ഥാനമാക്കി, സെർവർ ഉചിതമായ സന്ദേശങ്ങളുമായി പ്രതികരിക്കുന്നു. ദി സ്റ്റാറ്റസ് കോഡും ഉള്ളടക്ക തരവും ഉൾപ്പെടെ പ്രതികരണ തലക്കെട്ടുകൾ രീതി സജ്ജമാക്കുന്നു മെത്തേഡ് അന്തിമ പ്രതികരണം ക്ലയൻ്റിലേക്ക് തിരികെ അയയ്ക്കുന്നു. പോർട്ട് 3000-ൽ ഇൻകമിംഗ് അഭ്യർത്ഥനകൾ സെർവർ ശ്രദ്ധിക്കുന്നു, ഒരു ബാക്കെൻഡ് പരിതസ്ഥിതിയിൽ സ്ട്രിംഗ് തരം മൂല്യനിർണ്ണയത്തിൻ്റെ പ്രായോഗിക ഉദാഹരണം നൽകുന്നു.
ജാവാസ്ക്രിപ്റ്റിലെ സ്ട്രിംഗുകൾ തിരിച്ചറിയുന്നതിനുള്ള രീതികൾ
JavaScript ഫ്രണ്ട് ഇംപ്ലിമെൻ്റേഷൻ
// Method 1: Using typeoffunction isString(value) {return typeof value === 'string';}// Example usageconsole.log(isString("Hello")); // trueconsole.log(isString(123)); // false// Method 2: Using instanceoffunction isString(value) {return value instanceof String || typeof value === 'string';}// Example usageconsole.log(isString(new String("Hello"))); // trueconsole.log(isString("World")); // trueconsole.log(isString(123)); // false
ജാവാസ്ക്രിപ്റ്റിലെ സ്ട്രിംഗ് വേരിയബിളുകളുടെ ബാക്കെൻഡ് മൂല്യനിർണ്ണയം
Node.js ബാക്കെൻഡ് ഇംപ്ലിമെൻ്റേഷൻ
const http = require('http');// Create an HTTP serverconst server = http.createServer((req, res) => {let value = req.url.substring(1); // Get value from URL pathif (typeof value === 'string') {res.writeHead(200, {'Content-Type': 'text/plain'});res.end('The value is a string');} else {res.writeHead(400, {'Content-Type': 'text/plain'});res.end('The value is not a string');}});server.listen(3000, () => {console.log('Server is running at http://localhost:3000');});
ജാവാസ്ക്രിപ്റ്റിലെ സ്ട്രിംഗ് മൂല്യനിർണ്ണയത്തിനുള്ള വിപുലമായ രീതികൾ
അടിസ്ഥാനം കൂടാതെ ഒപ്പം രീതികൾ, സ്ട്രിംഗ് മൂല്യനിർണ്ണയത്തിനുള്ള മറ്റ് നൂതന സാങ്കേതിക വിദ്യകൾ JavaScript വാഗ്ദാനം ചെയ്യുന്നു. അത്തരത്തിലുള്ള ഒരു രീതിയാണ് ഉപയോഗിക്കുന്നത് പ്രവർത്തനം. ഈ സമീപനം ഉപയോഗപ്രദമാണ്, കാരണം ഇത് ഒരു വേരിയബിളിൻ്റെ കൃത്യമായ തരം നിർണ്ണയിക്കാൻ കൂടുതൽ വിശ്വസനീയമായ മാർഗം നൽകുന്നു. വിളിച്ച് കൊണ്ട് Object.prototype.toString.call(value), നിങ്ങൾക്ക് സ്ട്രിംഗ് മൂല്യങ്ങൾക്കായി "[object String]" പോലെയുള്ള ഒരു സ്ട്രിംഗ് ലഭിക്കും, അത് വേരിയബിൾ ഒരു സ്ട്രിംഗ് ആണെന്ന് ഉറപ്പാക്കാൻ താരതമ്യം ചെയ്യാം. ഒരു വേരിയബിളിൻ്റെ തരം പെട്ടെന്ന് വ്യക്തമാകാത്ത സങ്കീർണ്ണമായ കോഡ്ബേസുകളിൽ ഈ രീതി പ്രത്യേകിച്ചും പ്രയോജനകരമാണ്.
മറ്റൊരു നൂതന രീതി, സാധാരണ പദപ്രയോഗങ്ങളുടെ ഉപയോഗം ഉൾപ്പെടുന്നു. ഒരു വേരിയബിൾ ഒരു നിർദ്ദിഷ്ട പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ റെഗുലർ എക്സ്പ്രഷനുകൾ അല്ലെങ്കിൽ റീജക്സ് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഉപയോഗിക്കാം സ്ട്രിംഗുകളുമായി മാത്രം പൊരുത്തപ്പെടുന്ന ഒരു റീജക്സ് സൃഷ്ടിക്കാൻ ഒബ്ജക്റ്റ്. ഒരു ഇമെയിൽ വിലാസമോ ഫോൺ നമ്പറോ പോലെയുള്ള ഒരു പ്രത്യേക ഫോർമാറ്റിൽ ഒരു സ്ട്രിംഗ് അനുസരിച്ചിരിക്കുന്നുവെന്ന് സാധൂകരിക്കേണ്ടിവരുമ്പോൾ ഈ രീതി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. അടിസ്ഥാന രീതികളുമായി ഈ നൂതന സാങ്കേതിക വിദ്യകൾ സംയോജിപ്പിക്കുന്നത്, നിങ്ങളുടെ JavaScript കോഡ് വേരിയബിളുകൾ ശരിയായി കൈകാര്യം ചെയ്യുന്നുവെന്ന് ഉറപ്പുവരുത്തുകയും റൺടൈം പിശകുകളുടെ അപകടസാധ്യത കുറയ്ക്കുകയും ചെയ്യുന്നു.
- ടൈപ്പ് ഓഫ് ഉപയോഗിച്ച് വേരിയബിൾ ഒരു സ്ട്രിംഗ് ആണോ എന്ന് എനിക്ക് എങ്ങനെ പരിശോധിക്കാം?
- ഉപയോഗിക്കുക ഓപ്പറേറ്റർ:
- സ്ട്രിംഗ് ചെക്കിംഗിനായി instanceof ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനം എന്താണ്?
- മൂല്യത്തിൻ്റെ ഒരു ഉദാഹരണമാണോ എന്ന് ഇത് പരിശോധിക്കുന്നു കൺസ്ട്രക്റ്റർ:
- Object.prototype.toString.call() സ്ട്രിംഗ് മൂല്യനിർണ്ണയത്തിൽ എങ്ങനെ സഹായിക്കുന്നു?
- ഇത് ഒരു കൃത്യമായ തരം പരിശോധന നൽകുന്നു:
- ഒരു വേരിയബിൾ ഒരു സ്ട്രിംഗ് ആണോ എന്ന് പരിശോധിക്കാൻ റെഗുലർ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കാമോ?
- അതെ, ഉപയോഗിക്കുന്നതിലൂടെ സ്ട്രിംഗുകളുമായി പൊരുത്തപ്പെടുന്ന ഒരു പാറ്റേൺ നിർവ്വചിക്കാൻ ഒബ്ജക്റ്റ്.
- എന്തുകൊണ്ടാണ് നിങ്ങൾ JavaScript-ൽ പുതിയ സ്ട്രിംഗ്() ഉപയോഗിക്കുന്നത്?
- ഉപയോഗിച്ച് പരിശോധിക്കാവുന്ന ഒരു സ്ട്രിംഗ് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ
- Node.js-ൽ നിങ്ങൾ എങ്ങനെയാണ് ഒരു HTTP സെർവർ സൃഷ്ടിക്കുന്നത്?
- ഉപയോഗിച്ച് മുതൽ പ്രവർത്തനം മൊഡ്യൂൾ
- ഒരു HTTP അഭ്യർത്ഥനയിൽ നിന്ന് URL വീണ്ടെടുക്കാൻ ഏത് രീതിയാണ് ഉപയോഗിക്കുന്നത്?
- ദി സ്വത്ത്
- ഒരു HTTP സെർവറിൽ നിങ്ങൾക്ക് എങ്ങനെ ഒരു പ്രതികരണം അയയ്ക്കാനാകും?
- ഉപയോഗിച്ച് തലക്കെട്ടുകൾ സജ്ജീകരിക്കുന്നതിനും പ്രതികരണം അയയ്ക്കാൻ
- JavaScript-ൽ വേരിയബിൾ തരങ്ങൾ സാധൂകരിക്കുന്നത് പ്രധാനമായിരിക്കുന്നത് എന്തുകൊണ്ട്?
- വേരിയബിളുകൾ പ്രതീക്ഷിക്കുന്ന ഡാറ്റ തരങ്ങൾ ഹോൾഡ് ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കാൻ, റൺടൈം പിശകുകൾ കുറയ്ക്കുന്നു
ജാവാസ്ക്രിപ്റ്റിൽ വേരിയബിൾ ടൈപ്പ് ചെക്കിംഗ് പൊതിയുന്നു
വിശ്വസനീയവും കാര്യക്ഷമവുമായ കോഡ് എഴുതുന്നതിന് JavaScript-ൽ ഒരു വേരിയബിൾ ഒരു സ്ട്രിംഗ് ആണോ എന്ന് നിർണ്ണയിക്കുന്നത് വളരെ പ്രധാനമാണ്. പോലുള്ള രീതികൾ ഉപയോഗിക്കുന്നു , , തുടങ്ങിയ നൂതന സാങ്കേതിക വിദ്യകൾ കൂടാതെ റെഗുലർ എക്സ്പ്രഷനുകൾ സമഗ്രമായ സാധൂകരണം ഉറപ്പാക്കുന്നു. ഈ തന്ത്രങ്ങൾ പ്രയോഗിക്കുന്നതിലൂടെ, ഡവലപ്പർമാർക്ക് വേരിയബിൾ തരങ്ങൾ ആത്മവിശ്വാസത്തോടെ നിയന്ത്രിക്കാനും കോഡ് സ്ഥിരത വർദ്ധിപ്പിക്കാനും റൺടൈം പിശകുകൾ കുറയ്ക്കാനും കഴിയും.