Låt oss gå tillbaka till våra harar

Låt oss komma ihåg uppgiften om harar och Mazai från förra kapitlet.
Utan användning av villkor och åtgärder utförda (eller inte utförda)
beroende på förhållandena, räkna antalet harar i den sista
båten kommer inte att bli lätt.

Låt oss lägga till en gren till lastBoatRabbits-funktionen:

var lastBoatRabbits = funktion (totalKaniner)(if (totalRabbits === 0) (// return 0;) else (var restRabbits = totalRabbits% 6; if (restRabbits === 0) (// return 6;) else (return restRabbits;)));

Så om det inte finns några harar på floden, kommer den sista båten inte att ta med någon (i själva verket kommer den tillbaka nästan omedelbart, eftersom farfar kommer att veta säkert att det inte finns några harar på floden).

Och om antalet harar på floden är en multipel av 6, kommer den sista båten att vara fullastad med harar.

Vad mer kan förbättras i det här programmet? Jag skulle använda en separat variabel,
lagra antalet harar som får plats i båten, ifall de tacksamma
harar kommer att ge Mazay en större båt. Man vet aldrig vad plötsligt.

funktion (totalKaniner)(if (totalKaniner === 0) (retur 0;) else (var restRabbits = totalRabbits% boatCapacity; if (restRabbits === 0) (return boatCapacity;) else (return restRabbits;)));

Förgreningssyntax

Förgrening kan ha en del som exekveras om villkoret inte är sant,
eller kanske inte har det:

// Alternativ med två grenar: if (regnFaller) (stayHome (); // Om rainIsFalling == sant, exekveras denna del) annat (walkInAPark (); // Annars exekveras denna del } // Alternativ med en gren: if (musicIsPlaying) (dans ();) // Om musicIsPlaying == false, fortsätter programkörningen bara

Betingelser

Villkoret i if kan vara ett uttryck för att jämföra två tal eller strängar,
använder operationer ==,>,< , >= , <= , != и === , любая переменная, которой
tilldelades ett booleskt värde och precis vilket värde som helst som ett resultat av arbetet
om kommer att gjutas till booleskt.

Jämförelseexempel:

10> 5 // => sant 11< 6 // =>falskt 5> = 5 // => sant 3! = 3 // => falskt "abc" == "abc" // => sant "abc" === "abc" // => sant

Variabler som villkor:

var condition = 10> 5; if (villkor) (konsol .log ("10> 5"); // Kommer att köras }

Logiska operationer på villkor

Flera uttryck som returnerar booleska (eller booleska) värden
kan kombineras med booleska operationer. Dessa operationer kallas:
logiskt OCH &&, logiskt ELLER || och logisk negation! ...

sant sant; // => sant falskt || falsk; // => false! false; // => sant

Boolean AND returnerar bara sant om sant på båda sidor av det,
logiskt ELLER returnerar endast falskt om båda sidor av det är falskt.
Negation returnerar falskt för sant och omvänt sant för falskt.

Enligt Javascript-reglerna casts värdena 0, null och undefined till false.
Men när vi får resultatet && får vi det första oreducerade värdet, vilket
reduceras till falskt och får resultatet || - det första oreducerade värdet,
som konverterar till sant:

0 && sant; // => 0 6 || 7 || falsk; // => 6! 0; // => sant

Således kan funktionen som returnerar antalet harar i den sista båten skrivas om så här:

var boatCapacity = 6; var lastBoatRabbits = funktion (totalKaniner)(retur totalRabbits && (totalRabbits% boatCapacity || boatCapacity);

Uppgifter

1. Skriv en fizzbuzz-funktion som tar en nummerparameter och:
   • För multiplar av tre, returnerar "Fizz"
   • För multiplar av fem, returnerar "Buzz"
   • För multiplar av femton (tre och fem samtidigt), returnerar "FizzBuzz"
   • Annars returneras det ursprungliga numret
2. Skriv en iGoToNorth-funktion som tar en sifferparameter och avgör om det godkända numret är lämpligt för oss. Numret är lämpligt om det är fler än 10, mindre än 30 och en multipel av 7.

JavaScript har en villkorlig konstruktion som påverkar exekveringsflödet för ett program. Om (på engelska if) något är, något är sant, gör då en sak, annars (på engelska annars) - gör en annan.

Om uttalande

Låt oss ta en titt på hur if-satsen fungerar direkt, det är enkelt och kräver inte mycket förklaring.

If (villkor) (kod som ska köras om villkoret är sant)

Det är enkelt: om villkoret är sant, så exekveras koden i (...)-blocket.

Var-siffra = 4; if (siffra == 4) (document.write ("siffran är 4.");)

Du kan göra en lite konstig kod:

Var-siffra = 4; if (true) (document.write ("Tillståndet är sant.");)

Annat uttalande

En else-sats kan användas tillsammans med en if-sats. Det översätts till "annat" och tillhandahåller en alternativ kod.

Var-siffra = 4; om (siffra

Notera de olika stavningarna av de lockiga klammerparenteserna i det här exemplet för if och else-satserna. Det är inte obligatoriskt att skriva på detta sätt, båda syntaxerna är korrekta.

Den else-satsen kan följas av en ny if-sats. Detta kommer att testa flera förhållanden.

Var-siffra = 4; om (siffra

JavaScript har inte en elseif-sats (i ett ord) som det finns i PHP.

Om du bara behöver exekvera en sats, är blockklammerna (...) onödiga. I vårt exempel behöver du inte skriva dem:

Var-siffra = 4; om (siffra

Ligger i JavaScript

If (villkor)-satsen utvärderar och konverterar villkoret i parentes (uttryck) till boolianskt (sant eller falskt).

Låt oss upprepa att det finns en lögn i JavaScript.

• Nummer 0 (noll).
• Tom rad "".
• Boolean falskt :)
• Värdet är null.
• Värdet är odefinierat.
• NaN-värdet (Not a Number).

Allt annat är sant.

Ett par möjliga fel:

If ("false") document.write ("Detta är sant.
"); if (false) document.write ("Detta är sant.

");

Här måste du skilja strängen "false" (inom citattecken) från värdet på den booleska typen false.

If ("") document.write ("Detta är sant.
"); else document.write ("Detta är falskt.
");

Här måste du skilja strängen "" (inuti ett mellanslag), från den tomma strängen "". Ett mellanslag inuti en sträng gör att den inte är tom, utan ett innehållande tecken. För tolken spelar det ingen roll en bokstav eller ett mellanslag – en symbol är en symbol.

Andra villkor i JavaScript

• JavaScript-switchkonstruktion.
• Operatörens frågetecken

JavaScript - Lektion 7. Programgrenar - If Statement

Mycket ofta uppstår en situation när vi behöver utföra en handling beroende på ett tillstånd. Vi har till exempel en klädbutik på nätet. Vi frågar användaren vem han är (man eller kvinna) och beroende på svaret visar vi en lista över motsvarande produkter (man eller kvinna). När man skriver sådana program används det villkorligt om uttalande... Dess syntax är följande:

Om B (S1)
annat (S2)

Var Bär ett uttryck av en logisk typ, och S1 och S2- operatörer.

Det fungerar så här: värdet på uttrycket beräknas B, om det är sant, exekveras operatören S1, om det är falskt, exekveras operatören S2... Sträng annat (S2) kan utelämnas.

Jag tror att ett exempel kommer att göra det tydligare. Låt oss säga att vi har ett formulär där användaren anger 3 värden. Låt oss skriva ett skript som kommer att bestämma det maximala antalet inmatade siffror.

Låt oss först skriva formulärkoden på html-sidan:

Javascript om

Skriv nu funktionskoden på sidan script.js:

funktion maxZnach (obj) (var a = 1 * obj.zn1.value; var b = 1 * obj.zn2.value; var c = 1 * obj.zn3.value; var m = a; if (b> m) m = b; om (c> m) m = c; obj.res.value = m;)

Så vår funktion tar tre värden från formuläret, för det maximala ( m) tar vi värdet a... Sedan jämför vi: om värdet b större än det maximala (dvs. a), då blir det maximala b, annars kvarstår maxvärdet a(eftersom uttrycket inom parentes inte är sant). Jämför sedan på samma sätt följande värde c med maximalt. Vi matar ut svaret i resultatfältet ( res).

I allmänhet skulle ett sådant scenario kunna skrivas med metoden max objekt Matematik diskuterades i förra lektionen, och koden skulle vara kortare:

funktion maxZnach (obj) (var a = 1 * obj.zn1.value; var b = 1 * obj.zn2.value; var c = 1 * obj.zn3.value; obj.res.value = Math.max (Math .max (a, b), c);)

Detta menar jag att programmering fortfarande är en kreativ process, och ett problem kan lösas på olika sätt. Programmerarens uppgift är att hitta det mest optimala alternativet. Men det här är så, en lyrisk utvikning. Låt oss gå tillbaka till if-påståendet och titta på ett mer intressant exempel. Låt oss skriva ett skript, under driften av vilket, när du håller muspekaren över bilden, kommer det att öka och skapa en zoomeffekt.

Som du kommer ihåg i HTML kan du ställa in storleken på den infogade bilden. Om de angivna måtten är större eller mindre än originalet, kommer webbläsaren automatiskt att anpassa originalet till dessa dimensioner. Detta är vad vi kommer att använda. Låt oss ta en bild så här:

Originalet är 302 pixlar brett. Vi vill att bilden på sidan ska vara 102 pixlar bred och vid hovring växa till 302 pixlar. Allt är klart med html-sidan:

Javascript om

Och i vår funktion kommer vi, förutom den villkorliga operatorn, även att använda standard javascript-funktionen setTimeout som anropar en användardefinierad funktion med en viss tid:

Funktion bigPict () (var w = document.tigr.width; if (w) Funktionen kontrollerar alltså bildens bredd ( bredd) och, om den är mindre än 302 pixlar, ökar denna bredd med 10 pixlar. Fungera setTimeout kallar vår funktion bigPict varje halv sekund, på grund av vilket storleken på bilden kommer att öka lika länge som tillståndet w kommer inte att bli falsk.

För att visuellt göra approximationen smidigare, försök att minska steget och funktionsanropstiden. Lek med dessa siffror och hitta de bästa.

Det var allt för idag, som din läxa, lägg till vårt skript så att bilden, när muspekaren avslutas, kommer att återgå till sina ursprungliga värden (dvs. 102 pixlar). Om det inte fungerar, ladda ner

Villkorade operatörer

Villkorliga satser låter dig hoppa över eller köra andra satser baserat på värdet av det angivna uttrycket. Dessa operatörer är beslutspunkterna i programmet, och kallas ibland också filialoperatörer.

Om vi ​​föreställer oss att programmet är en väg, och JavaScript-tolken är en resenär som går längs den, så kan villkorliga uttalanden ses som korsningar, där programkoden förgrenar sig till två eller flera vägar, och vid sådana korsningar måste tolken välja vilken väg att gå vidare....

Om / annat uttalande

If-satsen är en grundläggande kontrollsats som låter JavaScript-tolkaren fatta beslut, eller mer exakt, exekvera satser baserat på villkor. If-satsen har två former. Först:

if (uttryck) uttalande

I denna form utvärderas uttrycket först. Om resultatet är sant, exekveras uttalandet. Om uttrycket returnerar falskt exekveras inte satsen. Till exempel:

If (användarnamn == null) // Om användarnamn är null eller odefinierat användarnamn = "Alex"; // definiera det

Observera att parentesen runt det villkorliga uttrycket är en obligatorisk del av if-satssyntaxen.

Den andra formen av if-satsen introducerar else-satsen, som exekveras när uttrycket returnerar false. Dess syntax är:

if (uttryck) påstående1 annat påstående2

Detta formulär exekverar sats1 om uttrycket returnerar sant och sats2 om uttrycket returnerar falskt. Till exempel:

If (n == 1) console.log ("Mottog 1 nytt meddelande."); else console.log ("Mottagna" + n + "nya meddelanden.");

Annars om uttalande

Operatorn if / else utvärderar uttryckets värde och exekverar en eller annan del av programkoden, beroende på resultatet. Men vad händer om du vill utföra en av många bitar? Ett möjligt sätt att göra detta är att använda en else if-sats. Det är inte formellt en fristående JavaScript-operatör; detta är bara en vanlig programmeringsstil som använder en repeterande if / else-sats:

If (n == 1) (// Execute block 1) else if (n == 2) (// Execute block 2) else if (n == 3) (// Execute block 3) else (// Om ingendera en av de föregående else-satserna kördes inte, exekvera block 4)

Det är inget speciellt med det här utdraget. Det är helt enkelt en sekvens av if-satser, där varje if-sats är en del av else-satsen i föregående sats.

Byt uttalande

If-satsen skapar förgrening i programflödet, och multipositionsförgrening kan implementeras med flera andra if-satser. Detta är dock inte alltid den bästa lösningen, särskilt om alla grenar är beroende av värdet av samma uttryck. I det här fallet är det slösaktigt att omvärdera värdet av samma uttryck i flera if-satser.

Switch-satsen är utformad för just sådana situationer. Nyckelordet switch följs av ett uttryck inom parentes och ett kodblock inom klammerparenteser:

switch (uttryck) (påståenden)

Den fullständiga syntaxen för en switch-sats är dock mer komplex än vad som visas här. Olika platser i blocket är markerade med ett nyckelord fall följt av ett uttryck och ett kolonkaraktär.

När en switch-sats exekveras, utvärderar den uttryckets värde och letar sedan efter en falletikett som matchar det värdet (matchning bestäms med hjälp av identitetsoperatorn ===). Om en etikett hittas, exekveras kodblocket med början vid den första satsen efter caseetiketten. Om ingen case-etikett med matchande värde hittas, startar exekveringen från den första satsen efter specialetiketten standard:... Om det inte finns någon standardetikett, hoppas hela switchblocket över.

Det är svårt att förklara funktionen av switch-satsen i ord, förklaringen ser mycket tydligare ut med ett exempel. Följande switch-sats är ekvivalent med de upprepade if / else-satserna som visas i föregående exempel:

Switch (n) (fall 1: // Exekvera om n === 1 // Exekvera block 1 break; // Stop here case 2: // Execute if n === 2 // Execute block 2 break; // Stoppa här fall 3: // Exekvera om n === 3 // Exekvera block 3 break; // Stop here default: // Om allt annat misslyckas ... // Execute block 4 break; // Stop here )

Var uppmärksam på nyckelordet ha sönder i slutet av varje fallblock. Break-satsen överför kontrollen till slutet av switch-satsen och fortsätter exekveringen av de satser som följer. Fallsatserna i en switch-sats anger bara startpunkten för koden som exekveras, men anger inga slutpunkter.

Om det inte finns några break-satser, kommer switch-satsen att börja exekvera kodblocket med case-etiketten som motsvarar uttryckets värde och fortsätta exekvera satserna tills den når slutet av blocket. I sällsynta fall är detta användbart för att skriva kod som hoppar från en falletikett till nästa, men 99 % av gångerna bör du noggrant avsluta varje fallblock med en break-sats. (När du använder switch i en funktion kan du använda en return-sats istället för break. Båda dessa satser avslutar switch-satsen och förhindrar att du hoppar till nästa falletikett.)

Nedan är ett mer praktiskt exempel på att använda switch-satsen, den konverterar ett värde till en sträng på ett sätt som beror på typen av värde:

Funktion konvertera (x) (switch (typ av x) (// Konvertera ett tal till ett hexadecimalt heltal "number": returnera x.toString (16); // Returnera en citattäng skiftläge "sträng": returnera "" "+ x + "" "; // Alla andra typer konverteras på vanligt sätt standard: return x.toString ();)) console.log (convert (1067)); // Resultat "42b"

Observera att i de två föregående exemplen följdes nyckelord för skiftlägen av siffror eller bokstavliga strängar. Så här används switch-satsen oftast i praktiken, men ECMAScript-standarden låter dig specificera godtyckliga uttryck efter fallet.

Switch-satsen utvärderar först uttrycket efter nyckelordet switch och sedan skiftlägesuttrycken i den ordning de visas, tills ett matchande värde hittas. Faktumet av en matchning bestäms med identitetsoperatorn ===, inte med likhetsoperatorn ==, så uttrycken måste matcha utan någon typkonvertering.

Eftersom inte alla case-uttryck utvärderas varje gång en switch-sats körs, bör du undvika att använda case-uttryck som har bieffekter som funktionsanrop och tilldelningar. Det är säkrast att begränsa dina kasusuttryck till konstanta uttryck.

Som förklarats tidigare, om inget av kasusuttrycken matchar switch-uttrycket, börjar switch-satsen exekvera satsen märkt default :. Om det inte finns någon förinställd:-etikett, hoppas brödtexten i switch-satsen över helt. Observera att i de föregående exemplen visas standardetiketten: i slutet av brödtexten i switchsatsen, efter alla falletiketter. Detta är en logisk och vanlig plats för det, men i själva verket kan den placeras var som helst inom en switch-sats.

Om programmering alltid var linjär skulle den förmodligen inte existera. Faktum är att i nästan alla program finns det olika konsekvenser som beror på vissa externa eller interna faktorer. Dessa grenar skapas med hjälp av villkorade operatörer, som jag kommer att berätta om i den här artikeln.

Allmän form villkorlig operator i JavaScript sådan:

Om (skick) (
// Uttalande block
}
annat (
// Uttalande block
}

Nyckelordet kommer först om som talar om för webbläsaren att det villkorliga uttalandet kommer härnäst. Ett tillstånd indikeras innanför parenteserna, som följaktligen återkommer Sann eller falsk... Om uttrycket inom parentes var Sann (i sanning), så exekveras det första blocket med satser om villkoret falsk (falskt), sedan blocket av uttalanden i annan... Blockera också annanär valfritt, och jag ska ge dig ett exempel nedan.

Låt oss nu öva i praktiken. Låt oss lösa följande problem: användaren anger ett nummer och vi visar ett meddelande - oavsett om det är mer eller mindre 5 .

om (x< 5) alert ("Введённое число меньше пяти");

Låt oss titta på detta exempel. Med den första raden anropar vi funktionen prompt vilket tar upp ett fönster som ber dig att ange ett nummer. Därefter anger användaren ett tal som skrivs till en variabel x... Och så kommer tillståndet, som jag översätter som följer: Om x är mindre än 5, visa då meddelandet: "Det angivna numret är mindre än fem", annars visas meddelandet "Det angivna numret är större än fem"... Uttryck x< 5 återkommer heller Sann ( < 5 ) eller falsk (x> = 5). Observera också att vi inte använder lockiga hängslen. Varför? Eftersom vi bara använder en operatör (funktion varna ()). I princip kan vi sätta dem, och ingenting kommer att förändras, men här kommer de att vara överflödiga.

Vår uppgift innehåller dock ett betydande fel. Om användaren anger " 5 ", sedan meddelandet" Det angivna numret är större än fem"Detta är dock inte helt korrekt. Så låt oss omvandla tillståndet så här:

Om (x< 5) alert ("Введённое число меньше пяти");
annan
if (x == 5) alert ("Du skrev in fem");
else alert ("Det angivna numret är större än fem");

Som du kan se, blocket annan i det första tillståndet omvandlades. I blocket annan kontrolleras för att x och 5 är lika. Och i så fall visas ett motsvarande meddelande, annars visas det att antalet är större än fem. Det vill säga ett tillstånd inom ett tillstånd är helt normalt. Observera också att jag fortfarande inte har satt lockiga hängslen som om annat detta är en operatör. Och när det bara finns en operatör är närvaron av parentes valfri.

Låt oss ta ett annat exempel. Låt oss skapa en variabel som blir det Sann om det angivna numret är positivt, och falsk om siffran är negativ.

Var x = prompt ("Ange ett nummer");
var positiv = sant;
om (x< 0) positive = false;
alert (positiv);

Det här exemplet använder ett klassiskt exempel, när vi tar någon variabel och tilldelar den ett standardvärde. Och om det krävs så byter vi. I det här fallet ändrar vi standardvärdet om siffran är negativ. Men det här exemplet kunde ha skrivits ännu vackrare:

Var x = prompt ("Ange ett nummer");
var positiv = x< 0;

Vi är med andra ord variabla positiv tilldela omedelbart resultatet av jämförelsen x och repa.

Låt oss nu prata om den så kallade svåra förhållanden... I exemplen ovan har vi bara ansett enkla villkor, men det finns även andra villkor som består av flera villkor. Och det finns två operationer som används här: && - logiskt OCH och || - logiskt ELLER... Låt oss skriva ett villkor så här:

Om ((x<= 5) && (x >= 0)) (// block av operatorer)

Detta tillstånd (komplext tillstånd) kommer att ge Sann, om och endast om x<= 5 И x >= 0 ... Annars kommer det tillbaka falsk.

Överväg ett komplext tillstånd med logiskt ELLER.

Om ((x<= 5) || (x == 6)) {//блок операторов}

Du kan översätta det så här: if x<= 5 ИЛИ x == 6 återvänd sedan Sann, annars falsk.

Det sista jag vill säga är att det finns förutsättningar som består av flera logiska OCH och ELLER, och ibland måste du anstränga ditt huvud mycket allvarligt för att förstå ett sådant tillstånd.

Det var allt jag ville säga om villkorliga uttalanden i JavaScript... Och då behöver du bara träna. Tyvärr, utan övning kommer du aldrig att lära dig att använda den här operatören, utan vetskapen om vilken det helt enkelt är meningslöst att gå vidare. Så kom på något enkelt problem (som det vi löste ovan) och lös det.