జావాస్క్రిప్ట్ ఉచ్చులు: అయితే, అలా-కాసేపు,

ఆధునిక ప్రోగ్రామింగ్ భాష సింటెక్స్ వంటి ఏర్పాటు చరిత్ర విశ్వ విజ్ఞాన ప్రక్రియ పోలి ఉంటుంది. మరియు అది ప్రారంభంలో అని ... కానీ ఇప్పుడు ప్రతిదీ సాధారణ మరియు సరసమైన ఉంది.

చివరికి అల్గోరిథం - ఆదేశాల ఎల్లప్పుడూ ఒక డైసీ గొలుసు. ప్రోగ్రామింగ్ లో సమాంతరత - కలిపి సన్నివేశాలు ఒకేసారి సెట్. రౌండ్ రాబిన్ సీరియల్ లేదా సమాంతరంగా ఆదేశం గొలుసుకి ఆచరణాత్మక కాదు. Labels, పరివర్తనాలు, మరియు పరిస్థితులు - ఏ పరిష్కారం కోసం కేవలం తగినంత. ఫంక్షనల్ భాషలు ఈ ఆలోచనలు యొక్క ప్రాముఖ్యతను కోల్పోయింది, కానీ కోడ్ విభాగాలు పునరావృతం అవసరం ఉండిపోయింది.

బ్రౌజర్: DOM, తన నాలుక + సర్వర్

ఫంక్షనల్ ఆలోచనలు ప్రత్యేక అర్థాన్ని సంతరించుకుంది అయితే జావాస్క్రిప్ట్ చక్రాలను, ఉంటాయి. బహుశా ఏదో "లిస్ప్" మరియు "నాంది" వదిలేస్తే, కానీ అన్నిటికన్నా, జావాస్క్రిప్ట్ జీవించింది ప్రాంతం, ఉంది వాస్తవం దారితీసింది, కానీ అది ఈ తాజా నిర్ణయం సందేహాస్పదంగా ఉంది.

జావాస్క్రిప్ట్, పేజీ గెట్స్ ఒక DOM గా కావలసిన విధంగా విభజిస్తుంది మరియు మొదటి స్క్రిప్ట్ బాబు ఆ ఒక బ్రౌజర్ నడుస్తుంది. అన్ని ఇతర పేజీల, ఈ డౌన్లోడ్ సహా - ఇది సర్వర్లో కోడ్ మరియు చేసుకోగా AJAX మెకానిజం ఉపయోగించి ఫలితాలు ఆవాహన చెయ్యవచ్చు ద్వారా భాషను అభిసంధానించడం చేతులు డెవలపర్.

బ్రౌజర్ సర్వర్కు డేటాను బదిలీ చేసే ఒక సహా బ్రౌజర్ యొక్క వస్తువులు ఉపయోగించడానికి మరియు ఇది ఒక HTML మార్కప్ మరియు శైలులు మరియు వాస్తవ కోడ్ వ్యవహరించడానికి చేయవచ్చు ఒక స్పందన, అందుకోవచ్చు ఆ జావాస్క్రిప్ట్ కోడ్ కనుగొనేందుకు అమలు చేస్తుంది. స్పందన ప్రాతినిధ్యం శ్రేణుల మరియు వస్తువులు ఉండవచ్చు. ఒక JavaScript కోల్పోయింది చక్రాల ఉపయోగించడానికి సెన్స్, అవకాశాలు వాటిని లేకుండా చేయాలని పుష్కలంగా, మరియు ఆదేశాల అనంత శ్రేణిని ఉత్తమ పరిష్కారం కాదు హేంగ్ బ్రౌజర్ భరించి.

అసలైన ఉచ్చులు లో జావాస్క్రిప్ట్ సింటెక్స్ చాలా, డెవలపర్లు ప్రామాణిక నమూనా వారి స్వంత విధులు పూర్తి చేయవచ్చు ఉన్నాయి.

స్పేస్ లో జావాస్క్రిప్ట్ కోడ్ స్థానం

ఆధునిక ప్రోగ్రామర్ కూడా అతను ఉపయోగించిన ఆలోచించలేని (ఒక చక్రం , అయితే అయితే, ...) - చివరికి చక్రాల వరుస (చక్రాల) ప్రాసెసర్, ద్వియాంశ క్రియలతో ఒక సాధారణ క్రమంలో, అంతరాయం చెక్అవుట్ కౌంటర్లు, అంటే పరిస్థితులు.

అందుకని, సైకిల్ మిషిన్ భాషా స్థాయికి కాదు: సాధారణ ఆదేశాలను, నియత కార్యకలాపాలు మరియు మార్పిడులు కలయిక. ఉన్నా బ్రౌజర్ మరియు జావాస్క్రిప్ట్ దుబాసీ అభివృద్ధికి వాడవచ్చు అర్ధం ఏమిటి స్థాయికి ఎదగండి, చక్రాల ఏకైక ఉంటుంది. మరియు "కోడ్ ముక్కలు" వివిధ సార్లు మరియు ప్రోగ్రామర్లు వివిధ తరాల లో అందచేయబడుతుంది. పైన అంతస్తు "నిర్మాణ జావాస్క్రిప్ట్» ఉంది. వాక్యనిర్మాణం ఇది ఆధునిక జావాస్క్రిప్ట్ చక్రాల అందిస్తుంది.

JS - అందమైన భాష: ఆచరణ ఆధునిక మరియు పూర్తిగా ఫీచర్. ఈ పరికరం యొక్క సింటాక్స్ సమయం పరీక్ష అనుమతించింది మరియు మార్పు చెందని ఏదైనా అల్గారిథమ్ పునాదిగా మారింది చేసిన అన్ని నిర్మాణాలను కలిగి. కానీ చక్రాల, అవసరమైతే నిజంగా ఎందుకంటే? ప్రోగ్రామింగ్ లో ప్రోగ్రెస్ తరచుగా నాకు ఒక ప్రాథమిక ప్రకృతి ప్రశ్నలు అడిగారు, కాని కొన్ని సందర్భాల్లో, పరిష్కారం కనుగొనేందుకు.

లక్ష్యం మైదానాల్లో

చక్రం పరిస్థితి లేదా కౌంటర్ మాత్రమే రెండు రకాలు, కాని, నిజానికి ఏ చక్రం (అత్యల్ప స్థాయిలో) - మాత్రమే పరికల్పన ద్వారా. కొన్ని భాషలు ఉమ్మడి చక్రంలో "ప్రతి." జావాస్క్రిప్ట్ లో చక్రాల foreach నిర్మాణం వస్తువులో ఆసరా ప్రాతినిధ్యం, కానీ అది ఒక వేరియంట్ array.forEach (...) ఉపయోగించడానికి అవకాశం ఉంది.

ఏ సందర్భంలో, రెండు ఎంపికలు: కూడా వివరించడంలో భాషలు లో రాస్తూ, అన్ని ప్రోగ్రామింగ్ అల్గోరిథంలు చివరికి అమలు చేసే యంత్రం కోడ్, ఏ ఇతర ఆదేశం చైన్ రిపీట్ ఎంపికలు ఉన్నాయి: అతను మళ్ళీ వరకు నిర్వహించడానికి ఏదైనా కలిగి ఉండవచ్చు:

• కౌంటర్ గణనలు;
• పరిస్థితి ఏర్పడితే వరకు.

జావాస్క్రిప్ట్ - ఒక సాధారణ వ్యాఖ్యాత. దీని ప్రత్యేక లక్షణం: బ్రౌజర్ దాని వస్తువులు ఉపయోగిస్తుంది మరియు మీరు బ్రౌజర్ లో పేజీ లోడ్ అయిన క్లైంట్ వైపు అల్గోరిథంలు జరుపుటకు అనుమతించును లోపల, మరియు దాని పని చేసేప్పుడు అది నిర్వహించే.

ప్రతి సాధారణ చక్రం

జావాస్క్రిప్ట్ foreach ఉచ్చులు శ్రేణి ఫంక్షన్లను ఉపయోగించడం ఇలా:

ఇటువంటి వలయాలకు ఇబ్బందులు కారణం లేదు. లాంఛనప్రాయంగా, సరైన చక్రం ఉంది. శ్రేణి యొక్క మూలకాలు ఒక స్థిరమైన చికిత్స ఫంక్షన్ ఉంది.

కౌంటర్లో సైకిల్

మరింత కోసం జావాస్క్రిప్ట్ చక్రాల చూడండి అభిమానం:

ఇక్కడ, కౌంటర్ దీని విలువ మారుతూ సూత్రం మరియు సైన్ ప్రకారం చక్రం పరిస్థితి ముగిసే వేరియబుల్ అమలు చేస్తుంది. తప్పనిసరిగా ఫార్ముల మరియు పరిస్థితి ఒక వేరియబుల్ చక్రం కలిగి. కానీ చక్రంలో ముగింపు పాయింట్ యొక్క నియంత్రణలో పూర్తిగా వారి కంటెంట్ ద్వారా నిర్ణయించబడుతుంది.

నియత ఉచ్చులు

జావాస్క్రిప్ట్ మీరు పరిస్థితి తనిఖీ చెయ్యాలి ఉన్నప్పుడు బట్టి అందిస్తుంది అయితే తో ఎంపిక. లూప్ యొక్క శరీరం కూడా ఒకసారి అమలు ఉండకపోవచ్చు ఉంటే - ఈ ఒక, శరీరం, కనీసం ప్రదర్శించారు చేయాలి, అది వేరే విషయం:

మొదటి సందర్భంలో, డిజైన్ అయితే వివరించడంలో, జావాస్క్రిప్ట్ మొదటి పరిస్థితి వెతుకుతుంది, మరియు అది నిజమైతే, లూప్ అమలు. రెండవ సందర్భంలో చక్రం మొదటి అమలు అవుతుంది. అందించిన నిర్మాణాల్లో పేర్కొన్న వేరియబుల్స్ యొక్క ఫలితం ఉన్నప్పుడు, అది ఒక తప్పుడు విలువ పడుతుంది, లూప్ ఆపుతుంది.

సాధారణ అల్గోరిథంలు యొక్క భారీ కాంబినేషన్

ఏ అల్గారిథమ్ యొక్క ప్రధాన విధి (అంతర్భాగం) - కనుగొనేందుకు, మరియు అప్పుడు మాత్రమే తదుపరి ఏమి గురించి ఒక నిర్ణయం తీసుకుంటారు. అత్యంత ప్రాచీనమైన శోధన ఎంపిక - ఒక వేరియబుల్ ఒక విజ్ఞప్తి, ఫలితంగా వెంటనే. వేరియబుల్స్ చాలా ఉన్నాయి, మరియు అది అనేక విలువలు (శ్రేణి) కలిగి ఉంటే, అప్పుడు నమూనా విలువలు స్క్రిప్ట్ భవిష్యత్తు ప్రవర్తన నిర్ణయిస్తుందనేది దొరకలేదు తప్పక.

ఈ సాధారణ సిద్ధాంతం అన్ని సమస్యలకు ఉపశమం యొక్క జావాస్క్రిప్ట్ లాంగ్వేజ్ రకమైన ఒక కౌంటర్ తో ఒక లూప్ తయారు. ఆధునిక కంప్యూటర్లు వేర్వేరు వేగం. బ్రౌజర్ తగినంత స్క్రిప్ట్స్ అమలు సమయం, ఏ ఆతురుతలో ఉంది. ఇది అలాంటిదే ఏదో ఇరు సులభం. ఫలితంగా, J avaScript ఉచ్చులు చాలా ప్రాచుర్యం పొందాయి.

ఏమీ ఈ రకమైన తప్పు. కానీ ఈ విధానం వెనుక సారాంశం ఒకటి లేదా మరొక అల్గోరిథం వ్రాసిన ఇది కోసం కోల్పోతారు సులభం. ఈ అర్ధం కాదు. అర్ధమే ఏ కార్యక్రమం వ్రాసిన ఇది అన్ని ఆ. కోసం J avaScript చక్రాల వద్ద అదేపనిగా తినడం, డెవలపర్ కుడి యొక్క సారాంశం చూడలేకున్నాను మరియు కావలిసినంత అల్గోరిథం సృష్టించడానికి కాదు.

పనితనం, రియాలిటీ మరొక ప్రాతినిధ్యం

однотипного кода можно представить функциями - алгоритм сразу преобразится, основное тело скрипта уменьшится в размере, все станет читаемым и понятным. జావాస్క్రిప్ట్ చక్రాలను ఉపయోగించి, కోడ్ ఉదాహరణలు ఒకే రకమైన విధులు సూచిస్తుంది - అల్గోరిథం ఒకసారి రూపాంతరం, స్క్రిప్ట్ పరిమాణం తగ్గించిన ప్రధానభాగం, అన్ని రీడబుల్ మరియు అర్థమయ్యేలా ఉంటుంది.

మౌలికంగా కొత్త పరిష్కారం కాదు, కానీ సారాన్ని ఇతర భాష నిర్మాణాలు యొక్క పరిధిని దాటి కాదు. ముఖ్యంగా, J- avaScript చక్రాల సంగీతం స్ప్లిట్ () ఫంక్షన్ లో చూడవచ్చు:

cResult = '9,8,7,6,5,4' ; var cResult = '9,8,7,6,5,4';
aResult = cResult . var aResult = cResult. ( ',' ); స్ప్లిట్ ( ',');

ఏ చక్రం ఉంది, కానీ లేకపోతే చిహ్నం '' కోసం చూస్తున్న మరియు మరొక నుండి ఒక సంఖ్య వేరు దాన్ని ఉపయోగించండి ద్వారా కాకపోయినా, ఈ ఫంక్షన్ ప్రదర్శించారు.

మరింత సౌకర్యవంతంగా - అది ఎలా స్ప్లిట్ () ఫంక్షన్ లోపల అమలు నుండి abstracting ఉపయోగ నిబంధనలు సైకిళ్లను ఉపయోగించి దాని జావాస్క్రిప్ట్ కార్యాచరణతో అనుబంధంగా చేయవచ్చు. ఇది ఒక పద్ధతి వరుసగా ప్రతి పని కోసం కార్యాచరణ యొక్క అభివృద్ధి దారితీస్తుంది, కానీ మొత్తం ఇప్పటికీ ఈ విధానాన్ని ఉండాలి అత్యవసరం.

ఈ ఫంక్షన్లు అలట్ (), padc (), padl () మరియు padr () - లేదు జావాస్క్రిప్ట్ లో ఉనికిలో ఏమి, కానీ అది కుడి లేదా రెండు వైపులా, ఎడమ స్ట్రింగ్ యొక్క పొడవు align ఒక స్ట్రింగ్ లేదా ఖాళీలు నుండి తొలగించడానికి కొన్నిసార్లు అవసరం. జావాస్క్రిప్ట్ చక్రాలను - ఈ విధులు యొక్క శరీరం. సులభమైన, ప్రాప్యత మరియు అది ఉపయోగించే అల్గారిథమ్ వ్రేలాడదీయు ఎప్పుడూ.

16-ఎరీ 10 వ లెక్కింపు మరియు తిరిగి వ్యవస్థ ఆకారాలను సంఖ్య మార్పిడి ఫంక్షన్లను, చక్రాల అయితే ఒక డో ద్వారా ఏర్పాటు మరొక ఫార్మాట్ నుండి డేటా, చెప్పడం సులభం. చాలా కాంపాక్ట్ మరియు సమర్థవంతమైన సింటాక్స్.

సరైన చక్రాల - రియాలిటీ ప్రాతినిధ్యం

జావాస్క్రిప్ట్ - ఇతర ప్రోగ్రామింగ్ భాషలు మరియు వెర్షన్లు వివిధ రకాల ఇష్టం లేదు, మరియు ముఖ్యంగా, వాక్యనిర్మాణంలో మార్చడానికి, మరియు అభివృద్ధి మరియు విస్తరిస్తాయి కాదు ఉంటుంది.

ప్రోగ్రామర్ JS ఉపయోగించి ఆలోచిస్తూ, అది PHP ప్రోగ్రామర్ ఆలోచన నుండి వ్యత్యాసంగా (ప్రత్యేకంగా, మరియు మొత్తం ఇతర భాషలు, బాగా, "నాంది" మరియు అతని అనుచరులు సాధారణ దిశలో చేర్చారు లేని మినహా), అల్గోరిథం వేరియబుల్స్, శ్రేణులను అప్పగించిన ఆపరేటర్లు, చక్రీయ నిర్మాణాలు పరిమితం కాదు ఉన్నప్పుడు .

మేము ఏ చక్రాల ఉన్నాయి ఊహించుకోండి, మరియు సమస్యను పరిష్కరించడానికి ఉంటే అది అవసరం, సులభమయిన ఎంపిక (అజాగ్రత్తగా) - కార్యక్రమం సమాచారం ప్రదేశంలో ఒక బిందువు లేదా పాయింట్లు వ్యవస్థ డేటా ప్రాసెసింగ్, అని సూచిస్తున్నాయి. ఏం పాయింట్ మరియు పాయింట్లు వ్యవస్థ - అది ఒక నిర్దిష్ట విషయం ఉంది. ప్రోగ్రామర్, ఈ థీసిస్ అర్ధం: ఒక సాధారణ, ఈ సాధారణ డేటా సమితి. పాయింట్ - సహజంగానే, ఈ సాధారణ ఒక వ్యవస్థ క్రింద ఒక స్థాయికి స్థాయి, కానీ అధిక స్థాయి అవుతుంది.

ఈ విధానం తో, సంరక్షణ పాయింట్ - వారి పద్ధతుల ద్వారా తమ గుర్తింపును చూపించడానికి. ఉన్నప్పుడు సూపర్ వ్యవస్థలో పాయింట్, వ్యవస్థ పనితీరులో - ఆమె పాయింట్లు చెందిన సంస్థల కలయికతో దాని సారాంశం చూపించడానికి.

ఈ విధానం ప్రోగ్రామింగ్ భాషలు ఆలోచన అంత ప్రాచీనమైనది, కానీ ఇప్పటికీ ప్రోగ్రామింగ్ లో దాని తగిన ప్రతిబింబం కనుగొనలేకపోయింది. పలువురు ప్రోగ్రామర్లు సరిగ్గా అనుకుంటున్నాను, కానీ వారి పని యొక్క ఫలితం ఉండవల్సిన చాలా వెళ్లిపోతాడు.

ఇది ప్రపంచాన్ని తన కళ్ళ ఒక కట్టు ధరించడం కొన్నిసార్లు ఉపయోగకరంగా ఉంటుంది!