JavaScriptలో printIn మరియు console.log మధ్య తేడా ఏమిటి? (సమాధానం) - అన్ని తేడాలు
విషయ సూచిక
JavaScript అనేది వెబ్ బ్రౌజర్‌లలో మాత్రమే అందుబాటులో ఉండే ప్రోగ్రామింగ్ భాష. JavaScript కన్సోల్ అనేది మీ బ్రౌజర్‌లోని కమాండ్-లైన్ ఇంటర్‌ఫేస్, ఇది కోడ్ స్నిప్పెట్‌లను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు ప్రస్తుతం వీక్షిస్తున్న వెబ్‌పేజీతో ఇంటరాక్ట్ అయ్యేలా ఆ కోడ్ స్నిప్పెట్ రూపొందించబడినప్పుడు, ఊహించని ఫలితాలు రావచ్చు.
“PrintIn” టెక్స్ట్‌ని కన్సోల్‌కి ప్రింట్ చేస్తుంది, అయితే మీరు "console.log"ని లాగ్ చేయడానికి మరియు దానిని బగ్ రిపోర్ట్‌గా ఇమెయిల్ చేయడం వంటి వివిధ ప్రయోజనాల కోసం ఉపయోగించవచ్చు.
మీరు ప్రోగ్రామర్ అయితే, ఎంత ముఖ్యమైనది ఉపయోగించాలో మరియు అర్థం చేసుకోవాలో మీకు తెలుసు జావాస్క్రిప్ట్ వంటి స్క్రిప్టింగ్ భాషలు. అయితే, మీరు దాని ఫంక్షన్‌ల గురించి గందరగోళానికి గురయ్యే సందర్భాలు ఉన్నాయి.
PrintIn మరియు console.log ఫంక్షన్ లాగానే. ఈ రెండు ఫంక్షన్‌ల యొక్క వ్యత్యాసాన్ని మరియు అనువర్తనాన్ని అర్థం చేసుకోవడంలో మీకు సహాయం చేయడానికి, వాటి అర్థం మరియు అవి ఎలా పని చేస్తాయో నేను వివరిస్తాను.
ప్రారంభిద్దాం!
JavaScript అంటే ఏమిటి?
జావాస్క్రిప్ట్ అంటే ఏమిటి?
జావాస్క్రిప్ట్ అనేది క్రమం తప్పకుండా నవీకరించబడిన మెటీరియల్‌ని సృష్టించడం, మల్టీమీడియాను నియంత్రించడం, గ్రాఫిక్‌లను యానిమేట్ చేయడం మరియు ఇంకా చాలా చక్కగా ఏదైనా చేయడానికి స్క్రిప్టింగ్ భాష.
జావాస్క్రిప్ట్ ప్రోగ్రామింగ్ లాంగ్వేజ్ నిర్దిష్ట ప్రామాణిక ప్రోగ్రామింగ్ సామర్థ్యాలను కలిగి ఉంది, ఇది మీరు ఇలాంటి పనులను చేయగలదు:
- వెబ్ పేజీలో కొన్ని ఈవెంట్‌లు సంభవించినప్పుడు, మీరు నడుస్తున్న కోడ్‌కి ప్రతిస్పందించవచ్చు.
- ఉపయోగకరమైన డేటాను నిల్వ చేయడానికి మీరు వేరియబుల్‌లను ఉపయోగించవచ్చు.
- మీరు “స్ట్రింగ్‌లను” ఉపయోగించవచ్చు, ఇది టెక్స్ట్ ఎడిటింగ్ ఆపరేషన్ప్రోగ్రామింగ్‌లో
వినియోగదారు JavaScript భాష పైన జోడించబడిన కార్యాచరణ, మరోవైపు, మరింత ఆసక్తికరంగా ఉంటుంది. అప్లికేషన్ ప్రోగ్రామింగ్ ఇంటర్‌ఫేస్‌లు (APIలు) మీ JavaScript కోడ్‌కు అదనపు ఫంక్షన్‌లను అందిస్తాయి.
సంక్షిప్తంగా, మీరు కోడింగ్ చేస్తున్న వాటిని నియంత్రించడానికి JavaScript చాలా ఫంక్షన్‌లను కలిగి ఉంది. ఈ ఫంక్షన్లలో printIn మరియు console.log ఉన్నాయి.
PrintIn అంటే ఏమిటి?
కోడింగ్
ఇది కూడ చూడు: 2666 మరియు 3200 MHz RAM-తేడా ఏమిటి? - అన్ని తేడాలుPrintIn అనేది కన్సోల్‌లో వచనాన్ని ప్రదర్శించడానికి ఒక జావా పద్ధతి. ఈ పద్ధతి ఈ టెక్స్ట్‌ను స్ట్రింగ్ రూపంలో పారామీటర్‌గా అంగీకరిస్తుంది. ఈ విధానం క్రింది పంక్తి ప్రారంభంలో కర్సర్‌ను ఉంచుతూ కన్సోల్‌కు వచనాన్ని ప్రింట్ చేస్తుంది.
తదుపరి ప్రింటింగ్ తదుపరి లైన్‌లో ప్రారంభమవుతుంది . ఇలాంటి అనేక printIn పద్ధతులు ఉన్నాయి:
| void printIn() | ప్రస్తుత పంక్తిని ముగించడానికి లైన్ సెపరేటర్ స్ట్రింగ్‌ను వ్రాస్తుంది. |
| శూన్యం ప్రింట్‌ఇన్(బూలియన్ x) | బూలియన్‌ను ప్రింట్ చేసిన తర్వాత లైన్ ముగించబడుతుంది. |
| void printIn(char x) | అక్షరాన్ని ముద్రించిన తర్వాత లైన్ ముగించబడుతుంది. |
| void print(char [ ] x) | అక్షరాల శ్రేణిని ప్రింట్ చేసిన తర్వాత లైన్ ముగించబడుతుంది. |
| void printIn(double x) | డబుల్ లైన్‌ను ప్రింట్ చేసిన తర్వాత లైన్ ముగించబడుతుంది. |
| void printIn(float x) | అఫ్లోట్‌లో ప్రింట్ చేసిన తర్వాత లైన్ ముగించబడుతుంది. |
| శూన్యంprintIn(int x) | పూర్ణాంకాన్ని ముద్రించిన తర్వాత లైన్ ముగించబడుతుంది. |
| void printIn(long x) | ప్రింట్ చేసిన తర్వాత లైన్ నిలిపివేయబడుతుంది. |
| void printIn(Object x) | ఆబ్జెక్ట్‌ను ప్రింట్ చేసిన తర్వాత లైన్ ముగించబడుతుంది. |
| శూన్యం ప్రింట్‌ఇన్(స్ట్రింగ్ x) | స్ట్రింగ్‌ను ప్రింట్ చేసిన తర్వాత లైన్ ముగించబడుతుంది. |
ప్రింట్‌ఇన్‌లో విభిన్న పద్ధతులను ఉపయోగించడం
మీరు మీ పనిని కోడింగ్ చేయడానికి ఉపయోగించే అనేక పద్ధతులను కలిగి ఉన్నప్పటికీ, కన్సోల్‌లో వచనాన్ని ప్రదర్శించడానికి మీరు మరొక పద్ధతిని ఎదుర్కోవచ్చు. కన్సోల్‌లో, మీరు మీ పనిని ముద్రించగల రెండు పద్ధతులు ఉన్నాయి, మొదటిది printIn అయితే మరొకటి ప్రింట్.
ఈ రెండు ప్రింటింగ్ పద్ధతుల మధ్య మీరు గందరగోళం చెందకుండా ఉండేందుకు, చూద్దాం. ప్రింటింగ్‌లో రెండవ పద్ధతి, ప్రింట్ మధ్య వ్యత్యాసాన్ని నిర్వచించండి.
ప్రింట్ అనేది కన్సోల్‌లో టెక్స్ట్‌ని ప్రదర్శించడానికి ఒక జావా పద్ధతి. ఈ పద్ధతి ఈ టెక్స్ట్‌ని ఒక పారామీటర్‌గా అంగీకరిస్తుంది. స్ట్రింగ్. ఈ విధానం క్రింది పంక్తి చివరిలో కర్సర్‌ను ఉంచేటప్పుడు వచనాన్ని కన్సోల్‌కు ముద్రిస్తుంది.
తదుపరి ప్రింటింగ్ ఇక్కడే ప్రారంభమవుతుంది . ఇలాంటి అనేక ప్రింట్‌ఇన్ పద్ధతులు ఉన్నాయి:
| శూన్యం ప్రింట్(బూలియన్ బి) | బూలియన్ విలువ ముద్రించబడింది. |
| శూన్యం ప్రింట్(చార్ సి) | ఒక అక్షరం ముద్రించబడింది. |
| శూన్యం ప్రింట్(చార్ []లు) | అక్షరాల శ్రేణి ముద్రించబడింది. |
| శూన్యం ప్రింట్(డబుల్ డి) | రెండు-ఖచ్చితత్వం ఫ్లోటింగ్ పాయింట్ నంబర్ ప్రింట్ చేయబడింది. |
| శూన్యం ప్రింట్(ఫ్లోట్ ఎఫ్) | ఫ్లోటింగ్ పాయింట్ నంబర్ ప్రింట్ చేయబడింది. |
| శూన్యం ప్రింట్(int i) | పూర్ణాంకం ముద్రించబడింది. |
| శూన్యం ముద్రణ(దీర్ఘం l ) | దీర్ఘ పూర్ణాంకం ముద్రించబడింది. |
| శూన్యం ప్రింట్(ఆబ్జెక్ట్ obj) | ఒక వస్తువు ముద్రించబడింది . |
| శూన్యం ప్రింట్(స్ట్రింగ్ లు) | ఒక స్ట్రింగ్ ప్రింట్ చేయబడింది. |
ప్రింట్‌లో విభిన్న పద్ధతులను ఉపయోగించడం
సంక్షిప్తంగా, రెండింటి మధ్య ప్రధాన వ్యత్యాసం కన్సోల్‌లో ముద్రించిన టెక్స్ట్ యొక్క ప్లేస్‌మెంట్. ప్రింట్‌ఇన్ కింది పంక్తి ప్రారంభంలో ఉంది, ప్రింట్ ఈ క్రింది పంక్తి చివరిలో ఉంది.
మీకు windows 10-pro మరియు pro-n గురించి తెలుసుకోవాలని ఆసక్తి ఉంటే, తనిఖీ చేయండి నా ఇతర కథనం.
Console.log అంటే ఏమిటి?
Console.log
కన్సోల్ అనేది మీకు బ్రౌజర్ డీబగ్గింగ్ కన్సోల్‌కి యాక్సెస్‌ని అందించే JavaScript ఆబ్జెక్ట్.
console.log అనేది JavaScript. దానిలో గతంలో నిర్వచించబడిన ఏవైనా వేరియబుల్స్‌ను ప్రింట్ చేసే ఫంక్షన్, అలాగే వినియోగదారుకు చూపించాల్సిన ఏదైనా సమాచారం.
అవుట్‌పుట్ ఎక్కువగా టెర్మినల్‌కు లాగ్ చేయబడింది (ప్రింట్ చేయబడింది). స్ట్రింగ్‌లు, శ్రేణులు, వస్తువులు మరియు బూలియన్‌లతో సహా ఏదైనా రకాన్ని లాగ్()కి పంపవచ్చు.
The console.log() పద్ధతిజావాస్క్రిప్ట్ కన్సోల్‌లో అవుట్‌పుట్ కనిపిస్తుంది, ఇది బ్రౌజర్ డెవలపర్ సాధనం ద్వారా యాక్సెస్ చేయబడుతుంది. మీరు console.log()తో ఏ అవుట్‌పుట్ చేసినా, వారి సమూహం లేదా పాత్రతో సంబంధం లేకుండా, తుది వినియోగదారులందరికీ అందుబాటులో ఉంటుంది.
మీరు దీన్ని ఎలా ఉపయోగించవచ్చో మరియు ఈ ఫంక్షన్‌ని ఉపయోగించిన తర్వాత అవుట్‌పుట్‌ని చూద్దాం.
| జావాస్క్రిప్ట్ | అవుట్‌పుట్ |
// 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() పద్ధతిని ఉపయోగించవచ్చు.
2077
Console.log సింక్రోనస్ లేదా అసమకాలికమా?
console.log సమకాలికమా లేదా అసమకాలికమా అని నేను మీతో చర్చించే ముందు, సమకాలిక మరియు అసమకాలిక అంటే ఏమిటో నేను ముందుగా నిర్వచిస్తాను.
సమకాలిక అంటే అదే సమయంలో సంభవిస్తుంది, అయితే అసమకాలిక అంటే అది అది ఒకే సమయంలో జరగదు. కాబట్టిసింక్రోనస్‌లో పాల్గొనేవారు/వినియోగదారులు వెంటనే అభిప్రాయాన్ని స్వీకరించగలరు. అసమకాలిక మీ స్వంత సమయంలో తెలుసుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది.
సమాధానం చెప్పడానికి, concole.log అసమకాలికమైనది. ఉదాహరణలను చూపడం ద్వారా, ముఖ్యంగా వస్తువుల శ్రేణిని మరింత సమర్థవంతమైన పద్ధతిలో క్రమబద్ధీకరించడం ద్వారా అది ఎందుకు అని నేను మీకు చూపిస్తాను. ప్రారంభిద్దాం.
మీ శ్రేణిలో ఈ క్రింది వస్తువులు ఉన్నాయని అనుకుందాం:
| వినియోగదారులను అనుమతించండి = [ {పేరు: “నికోల్” , వయస్సు: 20, ఇంటిపేరు: “లూనా” } , {పేరు: “కారా” , వయస్సు: 21, ఇంటిపేరు: “లిమ్” } , {పేరు: “లారా” , వయస్సు: 20, ఇంటిపేరు: “టుయాజోన్”}; ] |
శ్రేణి ఆబ్జెక్ట్‌లు
మీరు ఈ శ్రేణిని ఫీల్డ్ పేరు ద్వారా తప్పనిసరిగా క్రమబద్ధీకరించాలి, ఇది సాధారణంగా కింది విధంగా జరుగుతుంది.
| / / పేరు ద్వారా ( కారా, లారా, నికోల్ ) వినియోగదారులు.sort ( ( a, b ) => a.name > b.name ? 1 : -1); / / వయస్సు (లారా, నికోల్, కారా ) వినియోగదారులు.sort ( ( a, b ) => a.age > b.name ? 1 : -1);
|
శ్రేణి ఆబ్జెక్ట్‌లను క్రమబద్ధీకరించడం
దీనిని మరింత సమర్ధవంతంగా అమర్చడానికి, మీకు ఇలా ఉంటుంది:
| users.sort(byField( 'name' )); users.sort(byField( 'age' )); |
శ్రేణి ఆబ్జెక్ట్‌లను క్రమబద్ధీకరించడం (సరళమైన మార్గం)
అలా చేయడానికి, మీరు తప్పనిసరిగా “బైఫీల్డ్” ఫంక్షన్‌ను పాస్ చేసి, Array.prototype.sortకి మీ శ్రేణిలోని వస్తువులకు క్రమబద్ధీకరించాలి. సరే, ఇది ఈ కథనం యొక్క ప్రాథమిక దృష్టి కాదు కానీ పై ఉదాహరణను సరళమైన మార్గంలో పూర్తి చేయడానికి దయచేసి దిగువ ఉదాహరణను చూడండి.
| > వినియోగదారులను అనుమతించండి =[ {పేరు: “నికోల్” , వయస్సు: 20, ఇంటిపేరు: “లూనా” } , {పేరు: “కారా” , వయస్సు: 21, ఇంటిపేరు: “లిమ్” } , {పేరు: “లారా” , వయస్సు: 20, ఇంటిపేరు: “టుయాజోన్”}; ] ఫీల్డ్ ద్వారా ఫంక్షన్ ( fieldName ){ return (a, b ) => a[fieldName] ? 1 : -1 ; } users.sort(byField( 'name') ); concole.log(users); users.sort(byField( 'age' ) ); concole.log(users); (3) [ { … }, {…}, {…} ] > 0: {పేరు: ” లారా “, వయస్సు: ” 20 ” , ఇంటిపేరు: ” Tuazon ” } > 1: {పేరు: ” నికోల్ “, వయస్సు: ” 20 ” , ఇంటిపేరు: ” లూనా ” } > 1: {పేరు: ” కారా”, వయస్సు: ” 21 ” , ఇంటిపేరు: ” లిమ్ ” } పొడవు: 3 > _proto_: అర్రే (0) (3) [ { … }, {…}, {…} ] > 0: {పేరు: ” లారా “, వయస్సు: ” 20 ” , ఇంటిపేరు: ” Tuazon ” } > 1: {పేరు: ” నికోల్ “, వయస్సు: ” 20 ” , ఇంటిపేరు: ” లూనా ” } > 1: {పేరు: ” కారా”, వయస్సు: ” 21 ” , ఇంటిపేరు: ” లిమ్ ” } పొడవు: 3 > _proto_: Array (0)
|
క్రమబద్ధీకరించబడిన అర్రే ఆబ్జెక్ట్‌లు
నేను క్రమబద్ధీకరించినట్లు మీరు పై పట్టిక నుండి చూడవచ్చు శ్రేణి ఆబ్జెక్ట్‌లను రెండుసార్లు, నేను మొదట పేరు ద్వారా, తదుపరి వయస్సు ప్రకారం క్రమబద్ధీకరిస్తాను మరియు ప్రతి విధమైన ఆపరేషన్ తర్వాత, నేను console.log ()ని అమలు చేస్తాను. అలాగే, ప్రతి విధమైన ఫలితం కోసం console.log() ఒకే అవుట్‌పుట్‌ను పునరుద్ధరించడాన్ని మీరు గమనించి ఉండవచ్చు, కానీ ఇది అలా కాదు; ఎందుకో వివరిస్తాను.
నేను పైన ఉన్న కోడ్‌ని ఒకేసారి అమలు చేసాను, ఆపై console.log () నుండి ప్రతి ప్రతిచర్యను విస్తరించాలని నిర్ణయించుకున్నాను. ఇది ముఖ్యమైనది ఎందుకంటే console.log() ఉందిఅసమకాలిక.
ఈవెంట్ లూప్ పరంగా, అన్ని అసమకాలిక లక్షణాలు ఈవెంట్ టేబుల్ వద్దకు వస్తాయి. ఈ సందర్భంలో, console.log()ని తీసుకువచ్చిన తర్వాత, ఇది ఈవెంట్ టేబుల్‌కి వెళుతుంది మరియు నిర్దిష్ట ఈవెంట్ కోసం వేచి ఉంటుంది.
ఒక ఈవెంట్ సంభవించినప్పుడు, console.log() ఈవెంట్ క్రమవరుసకు పంపబడుతుంది, ఇక్కడ మీ console.logని ఉంచినప్పుడు మరియు కాల్‌కి పంపబడినప్పుడు ఇప్పటికే ఉన్న ఈ ఈవెంట్ క్రమవరుసలోని అన్ని ప్రాసెస్‌ల వరకు వేచి ఉంటుంది. స్టాక్, ఆపై మీ console.log() కూడా ఈ కాల్ స్టాక్‌కి పంపబడుతోంది.
Javascript Console.logని ఎలా తెరవాలి?
వెబ్ బ్రౌజర్‌లలో, కన్సోల్ అనేక డెవలపర్ సాధనాల్లో ఒకటి. మీ జావాస్క్రిప్ట్ కోడ్‌ని పరిష్కరించడానికి, మీరు కన్సోల్‌ని ఉపయోగించవచ్చు. బ్రౌజర్‌ని బట్టి కన్సోల్‌ని చాలా చోట్ల కనుగొనవచ్చు.
ఈ ట్యుటోరియల్‌లో మీ Google Chrome బ్రౌజర్‌లో కన్సోల్‌ను ఎక్కడ కనుగొనాలో నేను మీకు నేర్పిస్తాను.
Chromeలో కన్సోల్ లాగ్‌ను ఎలా తెరవాలనే దానిపై దశలు
Chrome కన్సోల్ లాగ్‌ను ఎలా తెరవాలో చూద్దాం.
- Chrome బ్రౌజర్ తెరిచి ఉన్నప్పుడు పాప్-అప్ మెను నుండి తనిఖీ చేయి ఎంచుకోండి.
- డెవలపర్ టూల్స్ '“మూలకాలు మీరు తనిఖీని అమలు చేసినప్పుడు ” ట్యాబ్ డిఫాల్ట్‌గా తెరవబడుతుంది. "ఎలిమెంట్స్"కు కుడి వైపున, "కన్సోల్" క్లిక్ చేయండి.
- మీరు ఇప్పుడు కన్సోల్‌ను అలాగే కన్సోల్ లాగ్‌లో రికార్డ్ చేసిన ఏదైనా అవుట్‌పుట్‌ను వీక్షించవచ్చు.
మీరు దీన్ని కూడా తెరవవచ్చు. Chrome డెవలపర్ సాధనాలు అనేక షార్ట్‌కట్ కీలను ఉపయోగిస్తాయి. మీ Chrome సంస్కరణ ప్రకారం, మీరుకింది షార్ట్‌కట్‌లను ఉపయోగించవచ్చు:
Windows మరియు Linux కోసం,
| Ctrl + Shift + I | డెవలపర్ టూల్స్ విండో కనిపిస్తుంది. |
| Ctrl + Shift + J | డెవలపర్ టూల్స్‌లో కన్సోల్ ట్యాబ్‌ని ఎంచుకుంటుంది. |
| Ctrl + Shift + C | ఎలిమెంట్ మోడ్ టోగుల్‌లను తనిఖీ చేయండి |
షార్ట్‌కట్ కీలు
అంతిమ ఆలోచనలు
ప్రధాన వ్యత్యాసం printIn మధ్య మరియు console.log అనేది వారి ఫంక్షన్ మరియు కోడ్ యొక్క ఫలితం . PrintIn కన్సోల్‌కు వచనాన్ని ప్రింట్ చేస్తుంది, అయితే console.log ఇంతకు ముందు కోడ్ చేసిన స్ట్రింగ్‌లతో ఏవైనా వేరియబుల్‌లను ప్రింట్ చేస్తుంది.
ప్రాథమికంగా, Javascript యొక్క ఈ విధులు కన్సోల్‌కు వేరియబుల్స్ మరియు టెక్స్ట్‌ను ప్రింట్ చేయడానికి మరియు ప్రదర్శించడానికి మిమ్మల్ని అనుమతిస్తాయి. JavaScriptలో, మీరు వివిధ పద్ధతులను ఉపయోగించి ముద్రించవచ్చు.
డీబగ్గింగ్ చేసేటప్పుడు JavaScript కన్సోల్ లాగ్ పద్ధతి అత్యంత సాధారణంగా ఉపయోగించే ఎంపిక. మీ కోడ్‌ను మరింత ప్రభావవంతంగా డీబగ్ చేయడానికి, మీరు వాటన్నింటినీ ప్రాక్టీస్ చేయాలి మరియు వాటిని సరిగ్గా ఎలా ఉపయోగించాలో నేర్చుకోవాలి.
ప్రోగ్రామర్లు మరియు డెవలపర్‌లు తరచుగా వీటిలో ముందే నిర్వచించబడిన ఏవైనా వేరియబుల్‌లను అలాగే అవసరమైన ఏదైనా సమాచారాన్ని ప్రింట్ చేయడానికి వీటిని ఉపయోగిస్తారు. వినియోగదారుకు అందించబడుతుంది.
