JavaScript-ൽ printIn, console.log എന്നിവ തമ്മിലുള്ള വ്യത്യാസം എന്താണ്? (ഉത്തരം) - എല്ലാ വ്യത്യാസങ്ങളും
ഉള്ളടക്ക പട്ടിക
വെബ് ബ്രൗസറുകളിൽ മാത്രം ലഭ്യമാകുന്ന ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയാണ് JavaScript. JavaScript കൺസോൾ നിങ്ങളുടെ ബ്രൗസറിലെ ഒരു കമാൻഡ്-ലൈൻ ഇന്റർഫേസാണ്, അത് കോഡ് സ്‌നിപ്പെറ്റുകൾ പ്രവർത്തിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. നിങ്ങൾ നിലവിൽ കാണുന്ന വെബ്‌പേജുമായി സംവദിക്കാൻ ആ കോഡ് സ്‌നിപ്പറ്റ് രൂപകൽപ്പന ചെയ്‌തിരിക്കുമ്പോൾ, അപ്രതീക്ഷിത ഫലങ്ങൾ ഉണ്ടായേക്കാം.
“PrintIn” ടെക്സ്റ്റ് കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്യപ്പെടുന്നു, അതേസമയം നിങ്ങൾ "console.log" അത് ലോഗിൻ ചെയ്യാനും ഒരു ബഗ് റിപ്പോർട്ടായി ഇമെയിൽ അയയ്‌ക്കുന്നത് പോലെയുള്ള വിവിധ ആവശ്യങ്ങൾക്കായി ഉപയോഗിക്കാനും ഉപയോഗിക്കാം.
നിങ്ങൾ ഒരു പ്രോഗ്രാമറാണെങ്കിൽ, ഉപയോഗിക്കേണ്ടതും മനസ്സിലാക്കേണ്ടതും എത്ര പ്രധാനമാണെന്ന് നിങ്ങൾക്കറിയാം. ജാവാസ്ക്രിപ്റ്റ് പോലെയുള്ള സ്ക്രിപ്റ്റിംഗ് ഭാഷകൾ. എന്നിരുന്നാലും, അതിന്റെ പ്രവർത്തനങ്ങളെക്കുറിച്ച് നിങ്ങൾ ആശയക്കുഴപ്പത്തിലായേക്കാം.
printIn, console.log ഫംഗ്ഷൻ പോലെ. ഈ രണ്ട് ഫംഗ്‌ഷനുകളുടെയും വ്യത്യാസവും പ്രയോഗവും മനസ്സിലാക്കാൻ നിങ്ങളെ സഹായിക്കുന്നതിന്, അവ എന്താണ് അർത്ഥമാക്കുന്നതെന്നും അവ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും ഞാൻ വിശദീകരിക്കും.
നമുക്ക് ആരംഭിക്കാം!
എന്താണ് JavaScript?
എന്താണ് JavaScript?
പതിവായി അപ്‌ഡേറ്റ് ചെയ്ത മെറ്റീരിയൽ സൃഷ്‌ടിക്കുന്നതിനും മൾട്ടിമീഡിയ നിയന്ത്രിക്കുന്നതിനും ഗ്രാഫിക്‌സ് ആനിമേറ്റ് ചെയ്യുന്നതിനുമുള്ള സ്ക്രിപ്റ്റിംഗ് ഭാഷയാണ് JavaScript.
ജാവാസ്ക്രിപ്റ്റ് പ്രോഗ്രാമിംഗ് ഭാഷയ്ക്ക് ചില സ്റ്റാൻഡേർഡ് പ്രോഗ്രാമിംഗ് കഴിവുകൾ ഉണ്ട്, അത് ഇനിപ്പറയുന്നതുപോലുള്ള കാര്യങ്ങൾ ചെയ്യാൻ നിങ്ങളെ പ്രാപ്തമാക്കുന്നു:
- ചില ഇവന്റുകൾ ഒരു വെബ് പേജിൽ സംഭവിക്കുമ്പോൾ, നിങ്ങൾക്ക് റൺ ചെയ്യുന്ന കോഡിനോട് പ്രതികരിക്കാം.
- ഉപയോഗപ്രദമായ ഡാറ്റ സംഭരിക്കുന്നതിന് നിങ്ങൾക്ക് വേരിയബിളുകൾ ഉപയോഗിക്കാം.
- ഒരു ടെക്സ്റ്റ് എഡിറ്റിംഗ് പ്രവർത്തനമായ "സ്ട്രിംഗുകൾ" നിങ്ങൾക്ക് ഉപയോഗിക്കാംപ്രോഗ്രാമിംഗിൽ
ഉപയോക്താവിന്റെ JavaScript ഭാഷയുടെ മുകളിൽ ചേർത്ത പ്രവർത്തനം, മറുവശത്ത്, കൂടുതൽ രസകരമാണ്. ആപ്ലിക്കേഷൻ പ്രോഗ്രാമിംഗ് ഇന്റർഫേസുകൾ (API-കൾ) നിങ്ങളുടെ JavaScript കോഡിന് അധിക ഫംഗ്‌ഷനുകൾ നൽകുന്നു.
ചുരുക്കത്തിൽ, നിങ്ങൾ എന്താണ് കോഡ് ചെയ്യുന്നതെന്ന് നിയന്ത്രിക്കാൻ JavaScript-ന് ധാരാളം ഫംഗ്‌ഷനുകൾ ഉണ്ട്. ഈ പ്രവർത്തനങ്ങളിൽ printIn, console.log എന്നിവ ഉൾപ്പെടുന്നു.
എന്താണ് PrintIn?
coding
PrintIn എന്നത് കൺസോളിൽ ടെക്സ്റ്റ് പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഒരു ജാവ രീതിയാണ്. ഈ രീതി ഈ ടെക്സ്റ്റ് ഒരു സ്‌ട്രിംഗിന്റെ രൂപത്തിൽ ഒരു പാരാമീറ്ററായി സ്വീകരിക്കുന്നു. ഇനിപ്പറയുന്ന വരിയുടെ തുടക്കത്തിൽ കഴ്‌സർ സൂക്ഷിക്കുമ്പോൾ ഈ സമീപനം കൺസോളിലേക്ക് ടെക്സ്റ്റ് പ്രിന്റുചെയ്യുന്നു.
അടുത്ത പ്രിന്റിംഗ് അടുത്ത വരിയിൽ ആരംഭിക്കുന്നു . ഇതുപോലുള്ള നിരവധി പ്രിന്റ്ഇൻ രീതികളുണ്ട്:
| void printIn() | നിലവിലെ ലൈൻ അവസാനിപ്പിക്കാൻ ലൈൻ സെപ്പറേറ്റർ സ്ട്രിംഗ് എഴുതുന്നു. | |
| അസാധുവായ പ്രിന്റ്ഇൻ(ബൂളിയൻ x) | ഒരു ബൂളിയൻ പ്രിന്റ് ചെയ്‌തതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കുന്നു. | |
| void printIn(char x) | ഒരു പ്രതീകം പ്രിന്റ് ചെയ്‌തതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കുന്നു. | |
| noid print(char [ ] x) | അക്ഷരങ്ങളുടെ ഒരു നിര പ്രിന്റ് ചെയ്‌തതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കുന്നു. | |
| void printIn(double x) | ഒരു ഇരട്ട ലൈൻ പ്രിന്റ് ചെയ്‌തതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കുന്നു. | |
| void printIn(float x) | ആഫ്‌ലോട്ട് പ്രിന്റ് ചെയ്‌തതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കുന്നു. | |
| അസാധുവാണ്printIn(int x) | ഒരു പൂർണ്ണസംഖ്യ അച്ചടിച്ചതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കുന്നു | ഒപ്പം പ്രിന്റ് ചെയ്‌തതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കുന്നു. |
| void printIn(Object x) | ഒരു ഒബ്‌ജക്റ്റ് പ്രിന്റ് ചെയ്‌തതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കും. | |
| അസാധുവായ printIn(String x) | ഒരു സ്ട്രിംഗ് പ്രിന്റ് ചെയ്‌തതിന് ശേഷം ലൈൻ അവസാനിപ്പിക്കുന്നു. |
printIn-ലെ വ്യത്യസ്ത രീതികളുടെ ഉപയോഗം
നിങ്ങളുടെ വർക്ക് കോഡിംഗിൽ നിങ്ങൾ ഉപയോഗിച്ചേക്കാവുന്ന നിരവധി രീതികൾ ഇതിലുണ്ടെങ്കിലും, കൺസോളിൽ ടെക്സ്റ്റ് പ്രദർശിപ്പിക്കുന്നതിന് നിങ്ങൾക്ക് മറ്റൊരു രീതി നേരിടേണ്ടി വന്നേക്കാം. കൺസോളിൽ, നിങ്ങളുടെ ജോലി പ്രിന്റ് ചെയ്യാൻ കഴിയുന്ന രണ്ട് രീതികളുണ്ട്, ആദ്യത്തേത് പ്രിന്റ് ഇൻ ആണ്, മറ്റൊന്ന് പ്രിന്റ് ആണ്.
ഈ രണ്ട് പ്രിന്റിംഗ് രീതികൾക്കിടയിൽ നിങ്ങൾക്ക് ആശയക്കുഴപ്പത്തിലാകാതിരിക്കാൻ, നമുക്ക് നോക്കാം പ്രിന്റിംഗിലെ രണ്ടാമത്തെ രീതിയായ പ്രിന്റ് തമ്മിലുള്ള വ്യത്യാസം നിർവ്വചിക്കുക.
കൺസോളിൽ വാചകം പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഒരു ജാവ രീതിയാണ് പ്രിന്റ്. ഈ രീതി ഈ ടെക്സ്റ്റ് ഒരു പാരാമീറ്ററായി സ്വീകരിക്കുന്നു. സ്ട്രിംഗ്. ഇനിപ്പറയുന്ന വരിയുടെ അവസാനം കഴ്‌സർ സൂക്ഷിക്കുമ്പോൾ ഈ സമീപനം കൺസോളിലേക്ക് ടെക്സ്റ്റ് പ്രിന്റുചെയ്യുന്നു.
അടുത്ത പ്രിന്റിംഗ് ഇവിടെ നിന്ന് ആരംഭിക്കും . ഇതുപോലുള്ള നിരവധി പ്രിന്റ് ഇൻ രീതികളുണ്ട്:
| void print(boolean b) | ഒരു boolean മൂല്യം പ്രിന്റ് ചെയ്‌തിരിക്കുന്നു. | 18>|
| അസാധുവായ പ്രിന്റ്(ചാർ സി) | ഒരു പ്രതീകം അച്ചടിച്ചു []ങ്ങൾ) | ഒരു കൂട്ടം പ്രതീകങ്ങൾ പ്രിന്റ് ചെയ്‌തു ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ പ്രിന്റ് ചെയ്‌തു. |
| അസാധുവായ പ്രിന്റ്(ഫ്ലോട്ട് എഫ്) | ഒരു ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ പ്രിന്റ് ചെയ്‌തു. | |
| അസാധുവായ പ്രിന്റ്(int i) | ഒരു പൂർണ്ണസംഖ്യ അച്ചടിച്ചു. | |
| അസാധുവായ പ്രിന്റ്(നീണ്ട l ) | ഒരു നീണ്ട പൂർണ്ണസംഖ്യ അച്ചടിച്ചു . | |
| അസാധുവായ പ്രിന്റ്(സ്ട്രിംഗ് സ്) | ഒരു സ്ട്രിംഗ് പ്രിന്റ് ചെയ്‌തു. |
പ്രിന്റിലെ വ്യത്യസ്ത രീതികളുടെ ഉപയോഗം
ചുരുക്കത്തിൽ, ഇവ രണ്ടും തമ്മിലുള്ള പ്രധാന വ്യത്യാസം കൺസോളിൽ പ്രിന്റ് ചെയ്ത ടെക്സ്റ്റിന്റെ സ്ഥാനമാണ്. PrintIn ഇനിപ്പറയുന്ന വരിയുടെ തുടക്കത്തിലാണ്, പ്രിന്റ് ഇനിപ്പറയുന്ന വരിയുടെ അവസാനം ആണ്.
നിങ്ങൾക്ക് windows 10-pro, pro-n എന്നിവയെക്കുറിച്ച് അറിയാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, പരിശോധിക്കുക എന്റെ മറ്റൊരു ലേഖനം പുറത്ത്.
എന്താണ് Console.log?
Console.log
ഇതും കാണുക: PyCharm കമ്മ്യൂണിറ്റിയും പ്രൊഫഷണലും തമ്മിലുള്ള വ്യത്യാസം എന്താണ്? (ഉത്തരം) - എല്ലാ വ്യത്യാസങ്ങളുംബ്രൗസറിന്റെ ഡീബഗ്ഗിംഗ് കൺസോളിലേക്ക് നിങ്ങൾക്ക് ആക്‌സസ് നൽകുന്ന ഒരു JavaScript ഒബ്‌ജക്റ്റാണ് കൺസോൾ.
console.log ഒരു JavaScript ആണ്. അതിൽ മുമ്പ് നിർവചിച്ചിട്ടുള്ള ഏതെങ്കിലും വേരിയബിളുകൾ പ്രിന്റ് ചെയ്യുന്ന ഫംഗ്ഷൻ, കൂടാതെ ഉപയോക്താവിന് കാണിക്കേണ്ട എല്ലാ വിവരങ്ങളും.
ഔട്ട്‌പുട്ട് കൂടുതലും ടെർമിനലിലേക്ക് ലോഗ് ചെയ്‌തിരിക്കുന്നു (പ്രിന്റ് ചെയ്‌തിരിക്കുന്നു). സ്ട്രിംഗുകൾ, അറേകൾ, ഒബ്ജക്റ്റുകൾ, ബൂളിയൻസ് എന്നിവയുൾപ്പെടെ ഏത് തരത്തിലുമുള്ള ലോഗ്() ലേക്ക് കൈമാറാൻ കഴിയും.
The console.log() രീതിബ്രൗസറിന്റെ ഡെവലപ്പർ ടൂൾ വഴി ആക്‌സസ് ചെയ്യാവുന്ന JavaScript കൺസോളിൽ ഔട്ട്‌പുട്ട് ദൃശ്യമാണ്. console.log() ഉപയോഗിച്ച് നിങ്ങൾ ഔട്ട്‌പുട്ട് ചെയ്യുന്നതെന്തും, എല്ലാ അന്തിമ ഉപയോക്താക്കൾക്കും അവരുടെ ഗ്രൂപ്പോ റോളോ പരിഗണിക്കാതെ ആക്‌സസ് ചെയ്യാൻ കഴിയും.
നിങ്ങൾക്ക് അത് എങ്ങനെ ഉപയോഗിക്കാമെന്നും ഈ ഫംഗ്ഷൻ ഉപയോഗിച്ചതിന് ശേഷമുള്ള ഔട്ട്‌പുട്ടും നോക്കാം.
| JavaScript | ഔട്ട്‌പുട്ട് |
// console. log() രീതി | abc 1 true null defined Aray(4) [ 1, 2, 3, 4 ] Object { a : 1, b : 2 , c : 3 }
|
console.log ഉപയോഗിച്ചുള്ള ഇൻപുട്ടും ഔട്ട്‌പുട്ടും
എന്താണ് Javascript-ൽ Console.log രീതി ഉപയോഗിച്ച് കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്യണോ?
ഇത് JavaScript-ന്റെ ഏറ്റവും ജനപ്രിയവും വ്യാപകമായി ഉപയോഗിക്കുന്നതുമായ കൺസോൾ രീതിയാണ്. കൺസോളിലേക്ക് വിവിധ സന്ദേശങ്ങളോ കണക്കുകൂട്ടൽ ഫലങ്ങളോ പ്രിന്റ് ചെയ്യുന്നതിനോ കോഡ് ഡീബഗ്ഗുചെയ്യുന്ന സമയത്തോ പോലും ഈ രീതി പതിവായി ഉപയോഗിക്കുന്നു.
രണ്ട് അക്കങ്ങൾ ചേർക്കുന്ന ചില കോഡ് നിങ്ങൾ എഴുതിയിട്ടുണ്ട്, ഫലം കാണാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു കൺസോളിലെ ആ പ്രവർത്തനത്തിന്റെ; ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് console.log() രീതി ഉപയോഗിക്കാം.
3400
Console.log സിൻക്രണസ് ആണോ അസിൻക്രണസ് ആണോ?
console.log സിൻക്രണസ് ആണോ അസിൻക്രണസ് ആണോ എന്ന് നിങ്ങളുമായി ചർച്ച ചെയ്യുന്നതിനുമുമ്പ്, സിൻക്രണസ്, അസിൻക്രണസ് എന്നിവ എന്താണെന്ന് ഞാൻ ആദ്യം നിർവചിക്കും.
സിൻക്രണസ് എന്നാൽ അത് ഒരേ സമയം സംഭവിക്കുന്നു, എന്നാൽ അസിൻക്രണസ് എന്നാൽ അത് ഒരേ സമയം സംഭവിക്കുന്നില്ല. അങ്ങനെസിൻക്രണസിലെ പങ്കാളികൾക്ക്/ഉപയോക്താക്കൾക്ക് ഉടനടി ഫീഡ്‌ബാക്ക് ലഭിക്കും. നിങ്ങളുടെ സമയത്തുതന്നെ പഠിക്കാൻ അസിൻക്രണസ് നിങ്ങളെ അനുവദിക്കുന്നു.
ഉത്തരം നൽകാൻ, concole.log അസമന്വിതമാണ്. അത് എന്തുകൊണ്ടാണെന്ന് ഞാൻ നിങ്ങൾക്ക് കാണിച്ചുതരാം, ഉദാഹരണങ്ങൾ കാണിച്ചുകൊണ്ട്, പ്രത്യേകിച്ച് ഒബ്ജക്റ്റുകളുടെ ഒരു നിര കൂടുതൽ കാര്യക്ഷമമായി അടുക്കുക. നമുക്ക് ആരംഭിക്കാം.
നിങ്ങളുടെ അറേയിൽ ഇനിപ്പറയുന്ന ഒബ്ജക്റ്റുകൾ ഉണ്ടെന്ന് പറയാം:
| ഉപയോക്താക്കളെ അനുവദിക്കുക = [ {name: “Nicole” , പ്രായം: 20, കുടുംബപ്പേര്: "ലൂണ" } , {പേര്: "കാര" , വയസ്സ്: 21, കുടുംബപ്പേര്: "ലിം" } , {പേര്: "ലാറ" , വയസ്സ്: 20, കുടുംബപ്പേര്: "തുഅസോൺ"}; ] |
അറേ ഒബ്ജക്റ്റുകൾ
നിങ്ങൾ ഈ അറേയെ ഫീൽഡ് നാമമനുസരിച്ച് അടുക്കണം, അത് സാധാരണയായി ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യുന്നു.
ഇതും കാണുക: വയർലെസ് റിപ്പീറ്റർ വേഴ്സസ് വയർലെസ് ബ്രിഡ്ജ് (രണ്ട് നെറ്റ്‌വർക്കിംഗ് ഇനങ്ങളുടെ താരതമ്യം) - എല്ലാ വ്യത്യാസങ്ങളും| / / പേര് (കാര, ലാറ, നിക്കോൾ ) ഉപയോക്താക്കൾ.സോർട്ട് ( ( a, b ) => a.name > b.name ? 1 : -1); / / പ്രായമനുസരിച്ച് ( ലാറ, നിക്കോൾ, കാര ) ഉപയോക്താക്കൾ.സോർട്ട് ( ( a, b ) => a.age > b.name ? 1 : -1); 0> |
അറേ ഒബ്ജക്റ്റുകൾ അടുക്കുന്നു
കൂടുതൽ കാര്യക്ഷമമായ രീതിയിൽ ക്രമീകരിക്കുന്നതിന്, നിങ്ങൾക്ക് ഇതുപോലെയുണ്ടാകും:
| users.sort(byField('name' )); users.sort(byField('age' )); |
അറേ ഒബ്ജക്റ്റുകൾ അടുക്കുക (ലളിതമായ വഴി)
അങ്ങനെ ചെയ്യുന്നതിന്, നിങ്ങളുടെ അറേയിലെ ഒബ്ജക്റ്റുകളുടെ Array.prototype.sort-ലേക്ക് കടത്തിവിടാൻ നിങ്ങൾ “ബൈഫീൽഡ്” ഫംഗ്ഷൻ എഴുതണം. ശരി, ഈ ലേഖനത്തിന്റെ പ്രാഥമിക ഫോക്കസ് ഇതല്ല, എന്നാൽ മുകളിലെ ഉദാഹരണം ലളിതമായി പൂർത്തിയാക്കാൻ ദയവായി ചുവടെയുള്ള ഉദാഹരണം നോക്കുക.
| > ഉപയോക്താക്കളെ അനുവദിക്കുക =[ {പേര്: “നിക്കോൾ” , വയസ്സ്: 20, കുടുംബപ്പേര്: “ലൂണ” } , {പേര്: “കാര” , വയസ്സ്: 21, കുടുംബപ്പേര്: “ലിം” } , {പേര്: “ലാറ” , വയസ്സ്: 20, കുടുംബപ്പേര്: "ടൂസോൺ"}; ] ഫംഗ്ഷൻ ബൈ ഫീൽഡ് (ഫീൽഡ് നെയിം ){ റിട്ടേൺ (എ, ബി ) => a[fieldName] ? 1 : -1 ; } users.sort(byField( 'name' ) ); concole.log(users); users.sort(byField( 'age' ) ); concole.log(users); (3) [ { … }, {…}, {…} ] > 0: {പേര്: ” ലാറ”, പ്രായം: ” 20 ” , കുടുംബപ്പേര്: ” തുഅസോൺ ” } > 1: {പേര്: ” നിക്കോൾ”, പ്രായം: ” 20 ” , കുടുംബപ്പേര്: ” ലൂണ ” } > 1: { പേര്: ” കാര “, വയസ്സ്: ” 21 ” , കുടുംബപ്പേര്: ” ലിം ” } നീളം: 3 > _proto_: അറേ (0) (3) [ { … }, {…}, {…} ] > 0: {പേര്: ” ലാറ”, പ്രായം: ” 20 ” , കുടുംബപ്പേര്: ” തുഅസോൺ ” } > 1: {പേര്: ” നിക്കോൾ”, പ്രായം: ” 20 ” , കുടുംബപ്പേര്: ” ലൂണ ” } > 1: { പേര്: ” കാര “, വയസ്സ്: ” 21 ” , കുടുംബപ്പേര്: ” ലിം ” } നീളം: 3 > _proto_: അറേ (0)
|
ക്രമീകരിച്ച അറേ ഒബ്ജക്റ്റുകൾ
മുകളിലുള്ള പട്ടികയിൽ നിന്ന് ഞാൻ അടുക്കുന്നത് നിങ്ങൾക്ക് കാണാം അറേ ഒബ്ജക്റ്റുകൾ രണ്ടുതവണ, ഞാൻ ആദ്യം പേര് പ്രകാരം അടുക്കുന്നു, അടുത്തത് പ്രായമനുസരിച്ച് അടുക്കുന്നു, ഓരോ സോർട്ട് ഓപ്പറേഷനു ശേഷവും ഞാൻ console.log () റൺ ചെയ്യുന്നു. കൂടാതെ, console.log() എല്ലാത്തരം ഫലങ്ങൾക്കും ഒരേ ഔട്ട്‌പുട്ട് പുനഃസ്ഥാപിക്കുന്നത് നിങ്ങൾ നിരീക്ഷിച്ചിരിക്കാം, എന്നാൽ ഇത് അങ്ങനെയല്ല; എന്തുകൊണ്ടെന്ന് ഞാൻ വിശദീകരിക്കാം.
ഞാൻ ഒറ്റയടിക്ക് മുകളിലുള്ള കോഡ് പ്രവർത്തിപ്പിച്ചു, തുടർന്ന് console.log ()-ൽ നിന്നുള്ള എല്ലാ പ്രതികരണങ്ങളും വികസിപ്പിക്കാൻ തീരുമാനിച്ചു. console.log() ആയതിനാൽ ഇത് പ്രധാനമാണ്അസിൻക്രണസ്.
ഇവന്റ് ലൂപ്പിന്റെ കാര്യത്തിൽ, എല്ലാ അസിൻക്രണസ് സവിശേഷതകളും ഇവന്റ് ടേബിളിൽ എത്തുന്നു. ഈ സാഹചര്യത്തിൽ, console.log() കൊണ്ടുവന്നതിന് ശേഷം, അത് ഇവന്റ് ടേബിളിലേക്ക് പോകുകയും ഒരു നിർദ്ദിഷ്ട ഇവന്റ് സംഭവിക്കുന്നതിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു.
ഒരു ഇവന്റ് സംഭവിക്കുമ്പോൾ, console.log() ഇവന്റ് ക്യൂവിലേക്ക് അയയ്‌ക്കും, അവിടെ നിങ്ങളുടെ console.log സ്ഥാപിക്കുമ്പോൾ ഈ ഇവന്റ് ക്യൂവിലെ എല്ലാ പ്രക്രിയകളും കോളിലേക്ക് അയയ്‌ക്കുന്നതുവരെ അത് കാത്തിരിക്കുന്നു. സ്റ്റാക്ക് ചെയ്യുക, തുടർന്ന് നിങ്ങളുടെ console.log() ഈ കോൾ സ്റ്റാക്കിലേക്കും അയയ്ക്കുന്നു.
Javascript Console.log എങ്ങനെ തുറക്കാം?
വെബ് ബ്രൗസറുകളിൽ, നിരവധി ഡെവലപ്പർ ടൂളുകളിൽ ഒന്നാണ് കൺസോൾ. നിങ്ങളുടെ JavaScript കോഡ് ട്രബിൾഷൂട്ട് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് കൺസോൾ ഉപയോഗിക്കാം. ബ്രൗസറിനെ ആശ്രയിച്ച് കൺസോൾ പല സ്ഥലങ്ങളിലും കാണാം.
നിങ്ങളുടെ ഗൂഗിൾ ക്രോം ബ്രൗസറിൽ കൺസോൾ എവിടെ കണ്ടെത്തണമെന്ന് ഈ ട്യൂട്ടോറിയലിൽ ഞാൻ നിങ്ങളെ പഠിപ്പിക്കും.
Chrome-ൽ കൺസോൾ ലോഗ് എങ്ങനെ തുറക്കാം എന്നതിനെക്കുറിച്ചുള്ള ഘട്ടങ്ങൾ
Chrome കൺസോൾ ലോഗ് തുറക്കുന്നത് എങ്ങനെയെന്ന് നോക്കാം.
- Chrome ബ്രൗസർ തുറന്നിരിക്കുമ്പോൾ പോപ്പ്-അപ്പ് മെനുവിൽ നിന്ന് പരിശോധിക്കുക തിരഞ്ഞെടുക്കുക.
- ഡെവലപ്പർ ടൂളുകളുടെ “ഘടകങ്ങൾ "നിങ്ങൾ പരിശോധന നടത്തുമ്പോൾ സ്ഥിരസ്ഥിതിയായി ടാബ് തുറക്കും. "ഘടകങ്ങളുടെ" വലതുവശത്ത്, "കൺസോൾ" ക്ലിക്ക് ചെയ്യുക.
- ഇപ്പോൾ നിങ്ങൾക്ക് കൺസോളും കൺസോൾ ലോഗിൽ റെക്കോർഡ് ചെയ്‌തിരിക്കുന്ന ഔട്ട്‌പുട്ടും കാണാവുന്നതാണ്.
നിങ്ങൾക്ക് ഇത് തുറക്കാവുന്നതാണ്. നിരവധി കുറുക്കുവഴി കീകൾ ഉപയോഗിക്കുന്ന Chrome ഡെവലപ്പർ ടൂളുകൾ. നിങ്ങളുടെ Chrome-ന്റെ പതിപ്പ് അനുസരിച്ച്, നിങ്ങൾഇനിപ്പറയുന്ന കുറുക്കുവഴികൾ ഉപയോഗിക്കാം:
Windows, Linux എന്നിവയ്‌ക്കായി,
| Ctrl + Shift + I | Developer Tools വിൻഡോ ദൃശ്യമാകുന്നു. |
| Ctrl + Shift + J | ഡെവലപ്പർ ടൂളിലെ കൺസോൾ ടാബ് തിരഞ്ഞെടുക്കുന്നു. |
| Ctrl + Shift + C<17 | എലമെന്റ് മോഡ് ടോഗിളുകൾ പരിശോധിക്കുക |
കുറുക്കുവഴി കീകൾ
അന്തിമ ചിന്തകൾ
പ്രധാന വ്യത്യാസം printIn തമ്മിലുള്ള console.log എന്നത് അവയുടെ പ്രവർത്തനവും കോഡിന്റെ ഫലവും ആണ്. പ്രിന്റ്ഇൻ കൺസോളിലേക്ക് ടെക്സ്റ്റ് പ്രിന്റുചെയ്യുമ്പോൾ console.log മുമ്പ് കോഡ് ചെയ്ത സ്ട്രിംഗുകളുള്ള ഏതെങ്കിലും വേരിയബിളുകൾ പ്രിന്റ് ചെയ്യുന്നു.
അടിസ്ഥാനപരമായി, Javascript-ന്റെ ഈ ഫംഗ്‌ഷനുകൾ കൺസോളിലേക്ക് വേരിയബിളുകളും ടെക്‌സ്‌റ്റും പ്രിന്റ് ചെയ്യാനും പ്രദർശിപ്പിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു. JavaScript-ൽ, നിങ്ങൾക്ക് വിവിധ രീതികൾ ഉപയോഗിച്ച് പ്രിന്റ് ചെയ്യാൻ കഴിയും.
ഡീബഗ്ഗിംഗ് ചെയ്യുമ്പോൾ ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ഓപ്ഷൻ JavaScript കൺസോൾ ലോഗ് രീതിയാണ്. നിങ്ങളുടെ കോഡ് കൂടുതൽ ഫലപ്രദമായി ഡീബഗ് ചെയ്യുന്നതിന്, നിങ്ങൾ അവയെല്ലാം പരിശീലിക്കുകയും അവ എങ്ങനെ ശരിയായി ഉപയോഗിക്കണമെന്ന് പഠിക്കുകയും വേണം.
പ്രോഗ്രാമർമാരും ഡവലപ്പർമാരും ഇതിൽ മുൻകൂട്ടി നിർവചിച്ചിട്ടുള്ള ഏതെങ്കിലും വേരിയബിളുകളും ആവശ്യമായ വിവരങ്ങളും പ്രിന്റ് ചെയ്യാൻ പലപ്പോഴും ഇവ ഉപയോഗിച്ചു. ഉപയോക്താവിന് അവതരിപ്പിക്കാൻ.
