Данас ћемо видети структуре за управљање протоком, које се називају и једноставно управљачке структуре или посебно итеративне структуре. Ова упутства су веома занимљива и користе се док развијају концепт од програма до интелигентног програма.
Зашто?
Ако не користимо структуре за контролу протока, програм је једноставан. То је програм који у почетку користи само променљиве и операторе у ономе што можемо назвати низом инструкција у линеарном времену, то јест једно за другим.
Увођењем структура које ћемо видети у наставку, наш програм престаје да буде само линеарни низ неефикасних инструкција да би постао програм који је способан да доноси одлуке у зависности од вредности променљивих којима се бави, па се зато називају „интелигентним“ .
Тхе итеративне структуре тако се зову јер се инструкције морају спровести може се поновити један или више пута. Постоји велики број типова итеративних структура са њиховим посебностима, међутим сви имају нешто заједничко, имају једну тачку уласка, односно активирају се при уносу података.
Сада ћемо видети различите врсте итеративних структура у ЈаваСцрипт -уИако у стварности у свим или скоро свим програмским језицима постоје у основи исте структуре и служе истим сврхама, разлика је у начину на који су написане, односно у синтакси.
Почећемо са итеративном структуром, која је можда најједноставнија и такође највише коришћена. Мислимо на структуру ако.
ИФ структураКажем да је то најједноставније од увођења информација и након што смо их проверили оно што наш програм ради је да ако се испуни унапред утврђени услов, извршавамо реченицу или реченице које сте унапред дефинисали у коду. С друге стране, ако овај услов није испуњен, напушта структуру и не извршава код који је прати.
Пример са Јавасцрипт кодом је следећи:
Иф (к) {алерт ("Вредност је тачна"); } Тако једноставна. Једино што говоримо је да ако је променљива коју уносимо (к) тачна, напишите "Вредност је истинита", а ако није тачна, немојте ништа писати. Такође се може изразити са Иф (к == труе) веома је важно да не збуните оператор == који упоређује обе вредности са = Оно што ради је додељивање вредности са леве стране вредности са десне стране.
Ова се структура сама по себи користи за провјеру било које врсте уноса информација на врло понављајући начин, међутим, обично је праћена другом структуром тзв. елсе.
Иначе се користи као допуна ако, ако ако услов утврђен иф није испуњен и настави са елсе, исказ или изрази повезани са наведеном структуром управљања се аутоматски извршавају, као што се може видети у следећем примеру:
Иф (к) {алерт ("Вредност је тачна"); } елсе {алерт ("Вредност је лажна"); } Као и у претходном примеру, ако су унети подаци, к, тачни, напишите „Вредност је тачна“. Разлика у односу на претходни пример у којем, ако к није тачно, није учинила ништа у томе што сада, као што иде на друго, директно пише "Вредност је лажна".Ово је врло корисно ако информације могу бити само истините или лажне, црне или бијеле, да или не, или било која друга бинарна комбинација, или једна или друга. Међутим, обично постоји случај у којем желимо знати да ли подаци које уносимо одговарају неком од неколико искључиви условиНа пример, ако желимо да знамо да ли је наш играч дефанзивац, везни, голман или нападач. Увек ће то бити само једна од четири ствари и овде нам ако ако и друго не одговара.
У овом случају можемо користити иначе ако је структура шта значи ако не. Све остало можемо користити ако то увек желимо после наше прве иф структуре и пре последње, што ће бити друго, као што можемо видети у следећем коду:
Ако (играч == голман) {алерт ("Играч је голман"); } елсе иф (плаиер == дефенце) {алерт ("Играч је одбрана"); } елсе иф (плаиер == везни) {алерт ("Играч је везни"); } елсе {алерт ("Играч је напред"); } На овај начин програм прво проверава да ли је голман. Ако јесте, он то пише, ако не иде на прво друго ако жели да провери да ли је одбрана. Ако јесте, запишите. Ако није, одлази у следећи блок да провери да ли је везни. Ако јесте, запишите. Ако то није ниједна од три опције, она улази у последњи блок. Оно што ради је да напише да се прослеђује одбацивањем.
Структуре које смо управо видели нису ефикасне ако се провере понављају, у том случају друге контролне структуре, као што су док или уради док за:
ВХИЛЕ петљаОва структура је оно што је познато као вхиле (што је дословни превод са енглеског) у алгоритмима. И како његово властито значење каже, то је петља која извршава упутства док услов или услови остају тачни, све док наставља да враћа „тачно“ као вредност.
Стога структура поменуте петље је врло једноставно:
док (услов)
{
упутства;
}
А. једноставан пример у ЈаваСцрипт -у то може бити следеће:
вар цоунтер = 1; вхиле (број <5) {алерт ("број"); број + = 1; } Ово је једноставно као додавање једног по једног у наш променљиви број док не достигне 5.Шта се дешава ако услов није испуњен пре уласка у петљу?
Да се петља никада неће покренути. И ту долазимо до посебне врсте вхиле петље која се зове учини док. Ова структура се користи ако желимо да програм бар једном уђе у петљу. Дословни превод је до… све док то уради барем једном, уђите у петљу.
Зашто увек бар једном уђе у нашу петљу?
Јер, као што ћемо видети у наставку, услов за извршавање петље се испуњава након што се то уради. Можда звучи компликовано, али видећемо да је врло једноставно:
вар чињеница = 1; вар број = 10; учинити {чињеница = број * чињеница; број--; } вхиле (број> 0); упозорење (број); Био би то пример.
Шта се дешава у овом примеру?
То прво улази у петљу и даје два упутства, множећи резултат са бројем, а затим смањујући број. Овај процес се понавља све док наш број не буде 1. По изласку из петље, напишите број који је у почетку био 10, а сада је 1.
Ова петља би се тада могла написати потпуно исто са вхиле. С друге стране, ако је у иницијализацији вар нум = 0; улази у петљу, да ли инструкције и нум остају са вредношћу -1, што се не би десило са вхиле пошто не би ушло у петљу, а на овај начин је то једном урадило.
Очигледно је ово врло једноставан пример са мало употребе, али при програмирању је веома занимљиво ако желимо да се мени прикаже бар једном.
Након што смо видели вхиле и до вхиле петљу, видећемо оно што мислим да се највише користи у програмирању. Говоримо о чувеној петљи за.
ЗА структуруТо је петља која се највише користи због своје ефикасности, иако је сложенија од претходних итеративних структура.
Има следећи облик:
за (ред иницијализација; стање; Редослед ажурирање)
{
Упутства за извршавање
}
И његов операција је врло једноставна:
У првом делу петље једна или више променљивих се иницијализују, односно добијају вредност. Након прве тачке и зареза, дефинисан је услов који мора бити испуњен за извршавање инструкција. И последњи део заграда, ажурирање, је вредност која ће бити додељена променљивим које су иницијализоване.
Врло једноставно, све док је наведени услов испуњен, инструкције унутар фор петље се извршавају. Након извршавања ажурирамо вредност променљивих коришћених у услову.
Сада ћемо видети пример написан на Јавасцрипт:
фор (и = 0; и <10; и ++) {алерт ("Још увек је мање од 10"); } Креирали смо и иницијализовали променљиву и са вредношћу 0. Важно је имати на уму да се овај део петље извршава само први пут, а остатак времена то не узима у обзир јер се иницијализује само једном . Наша зона стања је дугачка све док је и мање од 10, па ће се стога наша петља понављати све док и не буде мање од 10.Сада наступа зона за надоградњу. Да се вредност и није променила, како смо је иницијализовали на 0, постала би бесконачна петља.
У нашој зони ажурирања мењамо вредност наше променљиве. У случају примера, сваки пут када се петља изврши, вредност и се повећава за 1, али се могу поставити и друга упутства као што су множење, одузимање итд.
Тхе фор лооп је веома користан у свету програмирања, и иако је ређи, постоји посебан случај који се захтева у. Иако се ово обично користи у програмирању објеката који су већ прилично напредни, употреба у низовима је занимљива.
Лооп за у оно што ради је да пролази кроз низ који ефикасно пролази кроз све његове елементе. Дефинисан низ, код је следећи:
вар арраи = ["Први", "Други", "Трећи", "Четврти"]; фор (и у низовима) {алерт ("Курс: низ (и)"); } Он пише све доступне курсеве од првог до четвртог.
На крају ћемо говорити о још једној од најчешће коришћених структура за контролу протока, а то је прекидачка петља, што значи бирати на енглеском.
СВИТЦХ петљаОву структуру користимо скоро кад год желимо да направимо мени са различитим опцијама. То је нека врста оптимизације понављања петљи елсе иф које смо раније видели и која ради много боље и без да је сувишна. Користимо га за она времена када желимо да извршимо више провера исте променљиве, односно да изаберемо карактеристику над променљивом која је искључује из друге.
Тхе облик прекидача је следећи:
прекидач (слово) {случај а: упутства; пауза; случај б: упутства; пауза; случај ц: упутства; пауза; случај д: упутства; пауза; подразумевано: упутства; пауза; } Претходној петљи се прослеђује променљива, у овом случају слово. Проверава ову променљиву и у зависности од тога коју уноси и изводи једно или друго упутство, а затим излази из петље. За унос сваке од доступних опција наше променљиве слова користи се резервисано слово за реч. Из петље се излази помоћу кључне речи бреак, а то је а инструкција скока, која прекида или мења ток програма, у овом случају форсирање превременог изласка из петље. Међутим, унос ове речи није обавезан.
На овај начин не бисмо прекинули ток програма и проверили остале опције (за које знамо да неће бити истина) па ће то бити мање оптимално. Веома је важно напоменути да провере се врше по редуСтога, ако знамо која ће се опција или опције највише користити, боље је да их ставимо на прво место.
Тхе задана вриједност који видимо у коду је онај који се користи ако се унета вредност не подудара ни са једним великим словом. У том случају аутоматски прелази на подразумеване вредности. Међутим, није обавезно укључити подразумевано у наш код.
