Een van de belangrijkste hulpmiddelen bij het programmeren zijn loops. Ze zijn handig als u iets een bepaald aantal keren moet doen.
Als er zo'n taak is, bijvoorbeeld om de regel "hallo allemaal" 1000 keer weer te geven. Dan zal het, zonder een cyclus te gebruiken, ten eerste veel tijd kosten en ten tweede zal het er niet erg mooi uitzien. Daarom moet je cycli heel goed kennen, omdat ze heel vaak worden gebruikt.
Er zijn vier lussen bij het programmeren: while, do-while, for en foreach. Elk van hen heeft zijn eigen syntaxis en wordt in bepaalde gevallen gebruikt.
De meest gebruikte lussen zijn for en foreach, while en do-while-lus is zeer zeldzaam.
En we beginnen met een while-lus.
De syntaxis van de while-lus is als volgt:
Eerst declareren we de variabele i, die een teller is, en binnen de lus verhogen we deze teller. Tussen haakjes schrijven we de voorwaarde voor het betreden/verlaten van de lus.
Opmerking! Schrijf de exit-voorwaarde correct, anders krijg je mogelijk een eindeloze lus en loopt het script vast. Zo'n cyclus kan plaatsvinden als we bijvoorbeeld eenvoudigweg 'true' schrijven in de uitgangsvoorwaarde.
Laten we bijvoorbeeld de tekenreeks "Hallo iedereen!" afdrukken. 10 keer.
Vari = 0; terwijl(i "); ik++; )
De variabele i kan beginnen vanaf 0 of 1 of vanaf een ander getal.
De uitgangsvoorwaarde is tegelijkertijd de ingangsvoorwaarde. De lus werkt als volgt: eerst wordt gecontroleerd of de variabele i kleiner is dan 10, en als de voorwaarde waar is, gaan we de lus binnen, anders niet. IN in dit geval als variabele i bijvoorbeeld gelijk is aan 30, wordt de lus niet uitgevoerd omdat 30 niet kleiner is dan 10.
We zijn de cyclus binnengegaan, hebben de regel "Hallo iedereen" afgedrukt, hebben de teller verhoogd en gaan opnieuw naar de voorwaarde, waar we opnieuw controleren of de waarde van de variabele i kleiner is dan 10, dan gaan we de cyclus in, anders verlaten we deze. En dit gebeurt tot het moment waarop de ingangsvoorwaarde onwaar wordt, dat wil zeggen dat de waarde van de variabele i 10 zal zijn. 10 is niet minder dan 10, dus we komen niet langer in de lus, maar gaan verder.
Opmerking! Vergeet niet de teller te verhogen (i++), anders krijg je een oneindige lus.
We hebben de while-lus behandeld, laten we nu verder gaan met de do-while-lus.
De syntaxis van de do-while-lus is als volgt:
Het verschil tussen een while-lus en een do-while-lus is dat een do-while-lus minstens één keer kan worden uitgevoerd, ongeacht de voorwaarde, terwijl een while-lus helemaal niet wordt uitgevoerd als de voorwaarde onwaar is.
Opmerking! Vergeet niet, net als bij de while-lus, de i-teller te verhogen.
Laten we verder gaan met oefenen. Laten we bijvoorbeeld het product van de getallen 1 tot en met 10 berekenen.
Vari = 1; var-productie = 1; do( productie *= i; i++; )while(i
Het resultaat is het nummer 3628800. Bij de eerste stap zijn we, ondanks de toestand ervan, onmiddellijk in de lus terechtgekomen waar de bewerking productie *= i werd uitgevoerd (dit is hetzelfde als productie = productie * 1). Vervolgens verhogen we de teller. Na ophoging heeft het een waarde van 2. En aan het einde controleren we de voorwaarde: als de tellerwaarde kleiner is dan of gelijk is aan 10, dan gaan we naar de volgende iteratie van de lus, anders verlaten we de lus en gaan verder .
voor lusZoals ik hierboven schreef, komt de for-lus vrij vaak voor, dus je moet deze heel goed kennen.
Syntaxis voor lus volgende:
Laten we voor een beter begrip een eenvoudig probleem oplossen. Laten we zeggen dat we de som van de getallen van 1 tot 1000 moeten berekenen met behulp van een for-lus.
Var-summa = 0; for(var i = 1; ik
We slaan het document op, openen het in de browser en zien dat het resultaat 500500 is.
Opmerking! Als er maar één statement in een lus zit, dan beugel optioneel.
Laten we, om dit te demonstreren, vijf keer een tekenreeks op het scherm weergeven, bijvoorbeeld 'Hallo!'
For(var i = 1; ik
Opmerking! Nadat de lus is uitgevoerd, blijft de laatste waarde in variabele i staan.
Laten we het probleem nu iets ingewikkelder oplossen, we moeten bijvoorbeeld de string "Hallo" 100 keer afdrukken. En zodat het niet allemaal op één rij terechtkomt, gaan we na elke tiende iteratie naar nieuwe lijn. En aan het einde zullen we de waarde van de variabele i afdrukken.
For(var i = 1; i 10) pauze;"); }
document.write(array[i] + "
Deze lus doorloopt alle elementen van de array, maar de laatste vier elementen worden niet weergegeven in de browser, omdat de test if (array[i] > 10) de lus zal onderbreken met een break-instructie wanneer het itereren door de array bereikt onderdeel 12.
Als we alleen de iteratie willen overslaan, maar de lus niet willen verlaten, kunnen we de instructie continue gebruiken:< array.length; i++) { if (array[i] >Var-array = [ 1, 2, 3, 4, 5, 12, 17, 6, 7 ]; voor (var i = 0; i"); }
10) doorgaan;
document.write(array[i] + " Als het programma in dit geval een getal groter dan 10 in de array tegenkomt, wordt dit getal niet in de browser weergegeven. beschikbaar in JavaScript.
Je kunt de lus zien als een computerversie van een spel waarbij je iemand vertelt X stappen in de ene richting te zetten, en vervolgens Y stappen in de andere richting; Het idee van het spel "Walk 5 steps east" kan bijvoorbeeld worden uitgedrukt als een lus:
Var-stap; voor (stap = 0; stap< 5; step++) { // Запускается 5 раз, с шагом от 0 до 4. console.log("Идём 1 шаг на восток"); }
Er zijn er veel verschillende soorten loops, maar ze doen in wezen allemaal hetzelfde: ze herhalen een actie meerdere keren (vergeet de herhalingstijd van nul niet, het tellen in de array begint vanaf 0). Cycli van verschillende structuren bieden verschillende manieren om het begin en einde van een cyclus te bepalen. Voor diverse taken programmeren heeft zijn eigen lusoperatoren, met behulp waarvan ze veel gemakkelijker kunnen worden opgelost.
Operators die zijn ontworpen om lussen in JavaScript te organiseren:
voor lusDe for-lus herhaalt acties totdat een speciale lusbeëindigingsgebeurtenis plaatsvindt. De for-instructie in JavaScript is vergelijkbaar met de for-instructie in Java en C. Declaration voor exploitant ziet er zo uit:
Voor ([start]; [voorwaarde]; [stap]) expressies
Wanneer het wordt uitgevoerd, gebeurt het volgende:
IN volgende functie Er is een for-lus die het aantal geselecteerde genres in een schuiflijst telt (een element waarmee u meerdere items kunt selecteren). De for-lus declareert een variabele i en stelt de waarde ervan in op 0. Hij controleert ook of i kleiner is dan het aantal elementen in element , voert de if-instructie uit en verhoogt i met één na elke passage door de lus.
Selecteer enkele muziekgenres en klik vervolgens op de onderstaande knop: R&B Jazz Blues New Age Klassieke Opera
functie howMany(selectObject) ( var numberSelected = 0; for (var i = 0; i< selectObject.options.length; i++) { if (selectObject.options[i].selected) { numberSelected++; } } return numberSelected; } var btn = document.getElementById("btn"); btn.addEventListener("click", function(){ alert("Выбрано элементов: " + howMany(document.selectForm.musicTypes)) }); doe... while-lusDe do...while-lus herhaalt zich zolang de gegeven voorwaarde waar is. De do...while-instructie ziet er als volgt uit:
Doe expressies while(condition);
expressies worden uitgevoerd zolang de voorwaarde waar is. Als u meerdere expressies wilt gebruiken, gebruikt u een blokexpressie ( ... ) om ze te groeperen. Als de voorwaarde waar is, worden de expressies opnieuw uitgevoerd. Aan het einde van elke doorgang wordt de toestand gecontroleerd. Als de voorwaarde onwaar is, wordt de uitvoering opgeschort en wordt de controle overgedragen naar de expressie na do...while .
VoorbeeldIn het volgende voorbeeld wordt de do-lus minimaal één keer uitgevoerd en opnieuw uitgevoerd zolang i kleiner is dan 5.
Doen ( i += 1; console.log(i); ) terwijl (i< 5);
terwijl lusDe while-lus voert expressies uit zolang de voorwaarde waar is. Het ziet er zo uit:
While (voorwaarde)-expressies
Als de voorwaarde onwaar wordt, stoppen de expressies in de lus met uitvoeren en gaat de controle over naar de expressie na de lus.
Er wordt gecontroleerd of de voorwaarde waar is voordat de expressies in de lus worden uitgevoerd. Als de voorwaarde waar is, worden de expressies uitgevoerd en vervolgens wordt de voorwaarde opnieuw getest. Als de voorwaarde onwaar is, wordt de uitvoering opgeschort en wordt de besturing na enige tijd verplaatst naar de uitdrukking.
Als u meerdere expressies wilt gebruiken, gebruikt u een expressieblok ( ... ) om ze te groeperen.
Voorbeeld 1De volgende while-lus loopt zolang n kleiner is dan drie:
Varn = 0; varx = 0; terwijl (n< 3) { n++; x += n; }
Bij elke iteratie verhoogt de lus n en telt die waarde op bij x. Daarom krijgen x en n de volgende waarden:
- Na de eerste passage: n = 1 en x = 1
- Na de tweede: n = 2 en x = 3
- Na de derde passage: n = 3 en x = 6
Na de derde passage, voorwaarde n< 3 становится ложным, поэтому цикл прерывается.
Voorbeeld 2Voorkomen eindeloze lussen. Zorg ervoor dat de lusvoorwaarde uiteindelijk onwaar wordt; anders wordt de cyclus nooit onderbroken. De expressies in de volgende while-lus zullen voor altijd worden uitgevoerd omdat de voorwaarde zal nooit onwaar worden:
Terwijl (waar) ( console.log("Hallo wereld"); )
LabelEen label is een verklaring met een identificatie waarmee u naar een bepaalde plaats in uw programma kunt verwijzen. U kunt bijvoorbeeld een label gebruiken om een lus aan te geven en vervolgens break- of continue-instructies gebruiken om aan te geven of het programma de lus moet verbreken of moet doorgaan met het uitvoeren ervan.
De syntaxis van het label is als volgt:
Label: exploitant
Betekenis labels kan elke geldige JavaScript-ID zijn die dat niet is gereserveerd woord. Exploitant , degene die u opgeeft na het label kan elke expressie zijn.
VoorbeeldIn dit voorbeeld vertegenwoordigt de markLoop een while-lus.
MarkLoop: while (theMark == true) ( doSomething(); )
pauzeGebruik de break-instructie om een lus te verbreken, de controle te wijzigen of in combinatie met de label-instructie.
- Wanneer u break zonder label gebruikt, worden de while , do-while en for loops verbroken of wordt de besturing onmiddellijk overgeschakeld naar de volgende expressie.
- Wanneer u break met een markering gebruikt, wordt de speciaal gemarkeerde uitdrukking verbroken.
De syntaxis van de operator zou kunnen zijn:
De eerste vorm van syntaxis doorbreekt de lus helemaal of verandert van besturing; de tweede onderbreekt een speciaal aangewezen uitdrukking.
Voorbeeld 1In het volgende voorbeeld worden de elementen in een array doorlopen totdat een element wordt gevonden waarvan de waarde theValue is:
Voor (i = 0; ik< a.length; i++) { if (a[i] == theValue) { break; } }
Voorbeeld 2: Labelonderbreking var x = 0; var z = 0 labelCancelLoops: while (true) ( console.log("Buitenste lus: " + x); x += 1; z = 1; while (true) ( console.log("Binnenste lus: " + z) ; z += 1; if (z === 10 && x === 10) ( break labelCancelLoops; ) else if (z === 10) ( break; ) ) doorgaanDe continue instructie wordt gebruikt om één stap vooruit te gaan in while , do-while , for loops of om naar een label te springen.
- Wanneer u continue zonder label gebruikt, wordt de huidige iteratie van de while , do-while en for loops verbroken en wordt de lus voortgezet vanaf de volgende iteratie. In tegenstelling tot break onderbreekt continue de uitvoering van de lus niet volledig. In de while-lus springt het naar de voorwaarde. En ervoor zorgt dat de stap groter wordt.
- Wanneer u Doorgaan met een label gebruikt, wordt dit toegepast op de lus met dat label.
De continue syntaxis kan er als volgt uitzien:
Het volgende voorbeeld toont een while-lus met exploitant doorgaan, die vuurt als de waarde van i 3 is. Dus n krijgt de waarden 1, 3, 7 en 12.
Vari = 0; var n = 0; terwijl (ik< 5) { i++; if (i == 3) { continue; } n += i; }
Voorbeeld 2Uitdrukking gemarkeerd checkiandj bevat de gemarkeerde uitdrukking checkj. Wanneer u continue tegenkomt, breekt het programma de huidige iteratie af checkj en start de volgende iteratie. Elke keer dat je tegenkomt, ga verder, checkj gaat door naar de volgende iteratie zolang de voorwaarde false retourneert. Wanneer false wordt geretourneerd na het berekenen van de rest van een deling checkiandj, checkiandj gaat door naar de volgende iteratie zolang de voorwaarde false retourneert. Wanneer false wordt geretourneerd, gaat het programma verder met de uitvoering vanaf de expressie erna checkiandj.
Als doorgaan is gemarkeerd checkiandj, kan het programma vanaf het begin van de markering doorgaan checkiandj.
Checkiandj: terwijl (i< 4) { console.log(i); i += 1; checkj: while (j >4) ( console.log(j); j -= 1; if ((j % 2) != 0) ( ga door met checkj; ) console.log(j + "even."); ) console.log("i = " + ik);
console.log("j = " + j);) voor...in De instructie for...in doorloopt alle opsombare eigenschappen van een object. JavaScript voert voor elk de opgegeven expressies uit
Voor (variabele in object) (expressies)
VoorbeeldDe volgende functie neemt een object en zijn naam als argument. Vervolgens doorloopt het alle eigenschappen van het object en retourneert een tekenreeks die de namen van de eigenschappen en hun waarden bevat.
Functie dump_props(obj, obj_naam) ( var resultaat = ""; for (var i in obj) ( resultaat += obj_naam + "." + i + " = " + obj[i] + "
"; ) resultaat += ""; retourneert resultaat; )
Voor een autoobject met merk- en modeleigenschappen geldt: resultaat zullen :
Auto.merk = Ford auto.model = Mustang
Voorbeeld nr. 2U kunt de waarde ook per sleutel weergeven:
Laat obj = (model: "AUDI A8", jaar: "2019", kleur: "bruin") voor (sleutel in obj) ( console.log(`$(key) = $(obj)`); ) // model = AUDI A8 // jaar = 2019 // kleur = bruin
ArraysHoewel het verleidelijk is om for... te gebruiken als een manier om alle elementen van een array te doorlopen, retourneert deze operator naast de numerieke indices ook de naam van door de gebruiker gedefinieerde eigenschappen. Het is dus beter om de standaard for te gebruiken voor numerieke indices bij interactie met arrays, aangezien de instructie for...in doorgaat specifieke gebruiker eigenschappen naast de array-elementen als u de array wijzigt, bijvoorbeeld door eigenschappen en methoden toe te voegen.
Voor( variabel van voorwerp) { uitdrukkingen}
Het volgende voorbeeld laat het verschil zien tussen de for...of- en for...in-lussen. Terwijl for...in itereert over eigenschapsnamen, for...of itereert over eigenschapswaarden:
Laat arr = ; arr.foo = "hallo"; for (laat i in arr) ( console.log(i); // print "0", "1", "2", "foo" ) for (laat i van arr) ( console.log(i); / / uitgangen "3", "5", "7")
De geschiedenis van de vorming van de syntaxis van moderne programmeertalen lijkt op het begrijpen van de processen van vorming van het universum. Wat en hoe het in het begin was... Maar nu is alles eenvoudig en toegankelijk.
Uiteindelijk is het algoritme altijd een opeenvolgende reeks opdrachten. Parallellisme bij programmeren is een reeks op de een of andere manier gecombineerde reeksen. seriële of parallelle commandostructuur is nog nooit zo praktisch geweest. Labels, overgangen en voorwaarden - alles was genoeg voor elke oplossing. Functionele talen deze ideeën hadden geen betekenis meer, maar de noodzaak om delen van de code te herhalen bleef bestaan.
Browser: DOM, zijn taal + serverIn JavaScript blijven lussen bestaan, hoewel functionele ideeën een speciale betekenis hebben gekregen. Er kan iets overgebleven zijn van "Lisp" en "Prolog", maar hoogstwaarschijnlijk heeft het gebied waar JavaScript leeft geleid tot wat er is, maar het valt te betwijfelen of dit de laatste oplossing is.
JavaScript draait in de browser, die de pagina ontvangt, parseert in de DOM en het eerste script uitvoert. Alle andere pagina's, inclusief de pagina's die op deze zijn geladen, zijn het werk van de ontwikkelaar die de taal manipuleert, waarmee de code op de server kan worden aangeroepen en het resultaat kan worden verkregen met behulp van het AJAX-mechanisme.
De browser voert JavaScript-code uit, die browserobjecten kan gebruiken, waaronder degene die informatie naar de server verzendt en een reactie ontvangt, zoals HTML-opmaak, stijlen en de code zelf. Het antwoord kan worden weergegeven door arrays en objecten. Het nut van het gebruik van lussen in JavaScript gaat verloren, er zijn genoeg mogelijkheden om het zonder te doen, en het risico dat de browser blijft hangen met een eindeloze reeks opdrachten is niet de beste oplossing.
Loops zelf zijn aanwezig in de meeste JavaScript-syntactische constructies; de ontwikkelaar kan de standaardconstructies aanvullen met zijn eigen functies.
De positie van JavaScript in coderuimteEen moderne programmeur denkt niet eens dat de while, do while, ...) die hij gebruikt uiteindelijk een reeks processorcycli is, een eenvoudige reeks binaire bewerkingen, onderbroken door tegencontroles, dat wil zeggen voorwaarden.
Er bestaat op dit niveau geen cyclus als zodanig machinetaal: Er is een combinatie van reguliere opdrachten, voorwaardelijke instructies en vertakkingen. Eén niveau hoger, ongeacht welke tool wordt gebruikt om de browser en JavaScript-interpreter te ontwikkelen, zullen er zeker loops zijn. Bovendien zullen er “stukjes code” worden gepresenteerd op verschillende tijdstippen En verschillende generaties programmeurs. De verdieping erboven is het JavaScript-"gebouw". De syntaxis ervan biedt moderne JavaScript-loops.
JS is een prachtige taal: praktisch, modern en volledig uitgerust. De syntaxis van deze tool omvat alle constructies die de tand des tijds hebben doorstaan en de onwrikbare basis van elk algoritme zijn geworden. Maar zijn cycli echt nodig? De vooruitgang op het gebied van programmeren stelde zichzelf vaak vragen van fundamentele aard, maar vond slechts in enkele gevallen een oplossing.
Objectieve grondenEen cyclus kan slechts twee opties hebben: op voorwaarde of op basis van een teller, maar in wezen (op het laagste niveau) is elke cyclus alleen op voorwaarde. In sommige talen is er een cyclus "voor elk". In JavaScript foreach-lussen worden weergegeven door de prop in de objectconstructie, maar u kunt de optie array.forEach(...) gebruiken.
Er zijn in ieder geval twee opties: de programmeur die uiteindelijk alle algoritmen van de programmeur uitvoert, zelfs de algoritmen die in interpretatieve talen schrijven, heeft geen andere opties om de reeks commando's te herhalen: hij kan iets opnieuw uitvoeren totdat:
- de teller telt;
- zolang aan de voorwaarde wordt voldaan.
JavaScript is een typische tolk. Zijn eigenaardigheid: het werkt in de browser, gebruikt zijn objecten en stelt u in staat algoritmen aan de clientzijde uit te voeren, zowel wanneer de pagina in de browser wordt geladen als tijdens de werking ervan.
In JavaScript zien foreach-lussen eruit alsof ze een functie op een array toepassen:
Het gebruik van dergelijke cycli levert geen problemen op. Formeel bestaat er geen cyclus als zodanig. Er is een sequentiële functieaanroep naar de elementen van de array.
Lus op een tellerFor loops zien er bekender uit in JavaScript:
Hier is de teller een variabele waarvan de waarde verandert volgens een formule, en een voorwaarde is een teken van het einde van de cyclus. De formule en voorwaarde hoeven geen lusvariabele te bevatten. Maar de controle over het moment waarop de cyclus eindigt, wordt volledig bepaald door de inhoud ervan.
Voorwaardelijke lussenOptie met terwijl JavaScript aanbiedingen afhankelijk van wanneer de staat moet worden gecontroleerd. Als de body van de lus niet één keer mag worden uitgevoerd, is dit één ding; als de body minstens één keer moet worden uitgevoerd, is dit iets anders:
In het eerste geval controleert JavaScript bij het interpreteren van de while-constructie eerst de voorwaarde, en als deze waar is, voert het de lus uit. In het tweede geval wordt de lus als eerste uitgevoerd. Als, als gevolg van het wijzigen van de variabelen die zijn opgegeven in de voorwaarde van de do while-constructie, deze false wordt, stopt de lus met uitvoeren.
Enorme combinaties van eenvoudige algoritmenDe hoofdtaak (onderdeel) van elk algoritme is het vinden en pas daarna een beslissing nemen over wat er vervolgens moet gebeuren. De meest primitieve zoekoptie is toegang tot een variabele, het resultaat wordt direct verkregen. Als er veel variabelen zijn, of het heeft veel waarden (een array), dan is het voor het selecteren van een waarde noodzakelijk om iets te vinden dat het verdere gedrag van het script zal bepalen.
Deze eenvoudige doctrine heeft van de tegenlus in JavaScript een soort wondermiddel voor alle problemen gemaakt. Moderne computers verschillen in snelheid. Er is voldoende tijd om scripts in de browser uit te voeren, u hoeft zich niet te haasten. Het is gemakkelijker dan ooit om ergens doorheen te gaan omwille van iets. Als gevolg hiervan zijn for-loops erg populair geworden in JavaScript.
Hier lijkt niets slechts aan te zijn. Maar achter deze aanpak gaat de essentie waarvoor dit of dat algoritme is geschreven gemakkelijk verloren. Gegevens zijn niet betekenisloos. Alles waarvoor een programma is geschreven, heeft betekenis. Door te veel for-loops in JavaScript te gebruiken, kan het zijn dat een ontwikkelaar de vereiste entiteit niet herkent en er niet in slaagt een adequaat algoritme te creëren.
Met behulp van JavaScript-lussen kunnen voorbeelden van hetzelfde type code worden weergegeven als functies - het algoritme zal onmiddellijk transformeren, de hoofdtekst van het script zal kleiner worden, alles zal leesbaar en begrijpelijk worden.
Dit is geen radicaal nieuwe oplossing, maar gaat in wezen niet verder dan andere taalconstructies. In het bijzonder zijn JavaScript-loops te vinden in klassieke functie splitsen():
var cResultaat = "9,8,7,6,5,4" ;
var aResultaat = cResultaat .split ( "," );
Er is hier geen lus, maar hoe kan dit anders worden gedaan dan door te zoeken naar het ","-symbool en dit te gebruiken om het ene getal van het andere te scheiden.
Als u abstractie maakt van de manier waarop dit binnen de functie split() is geïmplementeerd, kunt u JavaScript aanvullen met uw eigen functionaliteit die gebruikmaakt van lussen, wat handiger is vanuit gebruiksoogpunt. Het is belangrijk dat deze aanpak leidt tot de ontwikkeling van functionaliteit voor elke taak, maar het algemene zal nog steeds bij deze aanpak blijven.
Deze functies allt(), padc(), padl() en padr() zijn iets dat JavaScript niet heeft, maar soms moet je spaties uit een string verwijderen of de lengte van een string links, rechts of links uitlijnen. beide kanten. De hoofdteksten van deze functies bevatten JavaScript-loops. Eenvoudig, toegankelijk en het algoritme dat hiervan gebruik maakt, zal nooit crashen.
Varianten van functies voor het converteren van getallen van het hexadecimale naar het 10e getalsysteem en omgekeerd, eenvoudiger gezegd, van het ene gegevensformaat naar het andere, worden hier uitgevoerd met behulp van do while-lussen. Zeer compacte en efficiënte taalsyntaxis.
JavaScript is geen partij voor andere programmeertalen en verschilt niet in de verscheidenheid aan versies, en het allerbelangrijkste: het streeft ernaar de syntaxis niet te veranderen, maar om deze te ontwikkelen en uit te breiden.
De mentaliteit van een programmeur die JS gebruikt, is anders vanuit het denken PHP-programmeur(in het bijzonder, en andere talen in het algemeen, behalve dat “Proloog” en zijn opvolgers niet zijn opgenomen in de algemene mainstream), wanneer het algoritme niet beperkt is tot variabelen, arrays, toewijzingsoperatoren en cyclische constructies.
Als we ons voorstellen dat er geen cycli zijn, maar dat het probleem moet worden opgelost, dan is de eenvoudigste optie (blinddoek) om aan te nemen dat het programma gegevens verwerkt die een punt of een systeem van punten in informatie ruimte. Wat een punt is en wat een puntensysteem is, is een kwestie van specifiek vakgebied. Voor een programmeur betekent deze stelling: er is een eenvoudig gegeven en er is een verzameling eenvoudige gegevens. Uiteraard zal een eenvoudig gegeven van één niveau een systeem zijn voor een niveau eronder, en een punt voor een niveau erboven.
Bij deze benadering gaat het erom de essentie van het punt via de methoden tot uiting te brengen. Wanneer een punt zich in een supersysteem bevindt, is het de functie van het systeem om zijn essentie te manifesteren als een verzameling essenties van de punten die erin zijn opgenomen.
Deze aanpak is zo oud als het idee van programmeertalen, maar is nog niet voldoende tot uiting gekomen in het programmeren. Veel programmeurs denken correct, maar het resultaat van hun creativiteit laat veel te wensen over.
Het helpt om soms een blinddoek te dragen om de wereld te zien!
