JavaScript, თუ ორი პირობა დაკმაყოფილებულია, აჩვენეთ შეტყობინება. პირობითი განცხადებები

პროგრამირება ყოველთვის წრფივი რომ ყოფილიყო, მაშინ ის ალბათ არ იარსებებდა. ყოველივე ამის შემდეგ, თითქმის ნებისმიერ პროგრამაში არის სხვადასხვა შედეგები, რომლებიც დამოკიდებულია გარკვეულ გარე ან შიდა ფაქტორებზე. ეს არის ფილიალები, რომლებიც იქმნება გამოყენებით პირობითი განცხადებები, რომლის შესახებაც ამ სტატიაში მოგიყვებით.

ზოგადი ფორმა პირობითი განცხადება JavaScript-შიასეთი:

თუ (პირობა) (
//ოპერატორის ბლოკი
}
სხვა (
//ოპერატორის ბლოკი
}

საკვანძო სიტყვა პირველ რიგში მოდის თუ, რომელიც ეუბნება ბრაუზერს, რომ შემდეგი იქნება პირობითი განცხადება. ფრჩხილების შიგნით არის მდგომარეობა, რომელიც, შესაბამისად, ბრუნდება მართალიაან ყალბი. თუ გამოთქმა ფრჩხილებში იყო მართალია (მართალია), მაშინ განცხადებების პირველი ბლოკი შესრულებულია თუ პირობა ყალბი (ყალბი), შემდეგ განცხადებების ბლოკი სრულდება სხვა. ასევე დაბლოკვა სხვაარ არის სავალდებულო და ქვემოთ მოვიყვან მაგალითს.

ახლა მოდით ვივარჯიშოთ პრაქტიკაში. მოდით გადავჭრათ ეს პრობლემა: მომხმარებელი შეაქვს ნომერი და ჩვენ ვაჩვენებთ შეტყობინებას - ეს არის მეტ-ნაკლებად 5 .


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

მოდით შევხედოთ ამ მაგალითს. პირველ ხაზზე ჩვენ ვუწოდებთ ფუნქციას სწრაფი, რომელიც აჩვენებს ფანჯარას, რომელიც მოგთხოვთ შეიყვანოთ ნომერი. შემდეგი, მომხმარებელი შეაქვს რიცხვს, რომელიც ჩაწერილია ცვლადში x. შემდეგ მოდის მდგომარეობა, რომელსაც მე ასე ვთარგმნი: თუ x არის 5-ზე ნაკლები, მაშინ აჩვენეთ შეტყობინება: "შეყვანილი რიცხვი არის ხუთზე ნაკლები", წინააღმდეგ შემთხვევაში აჩვენეთ შეტყობინება "შეყვანილი რიცხვი მეტია ხუთზე". გამოხატულება x< 5 ბრუნდება ან მართალია ( < 5 ) ან ყალბი (x >= 5). ასევე გაითვალისწინეთ, რომ ჩვენ არ ვიყენებთ ხვეულ ბრეკეტებს. რატომ? რადგან ჩვენ ვიყენებთ მხოლოდ ერთ ოპერატორს (ფუნქცია გაფრთხილება ()). პრინციპში, ჩვენ შეგვიძლია მათი დაყენება და არაფერი შეიცვლება, თუმცა აქ ისინი ზედმეტი იქნება.

თუმცა, ჩვენი ამოცანა შეიცავს მნიშვნელოვან შეცდომას. თუ მომხმარებელი შედის " 5 ", შემდეგ ჩვენ ვაჩვენებთ შეტყობინებას" შეყვანილი რიცხვი ხუთზე მეტიათუმცა, ეს არ არის მთლად სწორი. ასე რომ, მოდით გადავიტანოთ მდგომარეობა შემდეგნაირად:

თუ (x< 5) alert ("Введённое число меньше пяти");
სხვა
თუ (x == 5) გაფრთხილება ("თქვენ შეიტანეთ ხუთი");
else alert ("შეყვანილი რიცხვი მეტია ხუთზე");

როგორც ხედავთ, ბლოკი სხვაპირველ მდგომარეობაში გარდაიქმნა. ბლოკში სხვაშემოწმებულია ტოლობისთვის x-სა და 5-ს შორის. და თუ ეს ასეა, მაშინ გამოჩნდება შესაბამისი შეტყობინება, წინააღმდეგ შემთხვევაში, ნაჩვენებია, რომ რიცხვი მეტია ხუთზე. ანუ მდგომარეობა მდგომარეობაში სრულიად ნორმალურია. ასევე გაითვალისწინეთ, რომ მე ჯერ კიდევ არ დავაყენე ხვეული ბრეკეტები, რადგან თუ კიდევეს არის ერთი ოპერატორი. და როდესაც მხოლოდ ერთი ოპერატორია, ფრჩხილების არსებობა საჭირო არ არის.

მოდით შევხედოთ სხვა მაგალითს. მოდით შევქმნათ ცვლადი, რომელიც იქნება მართალიათუ შეყვანილი რიცხვი დადებითია და ყალბითუ რიცხვი უარყოფითია.

Var x = მოთხოვნა ("შეიყვანეთ ნომერი");
var დადებითი = მართალია;
თუ (x< 0) positive = false;
გაფრთხილება (დადებითი);

ეს მაგალითი იყენებს კლასიკურ მაგალითს, სადაც ჩვენ ვიღებთ ზოგიერთ ცვლადს და ვანიჭებთ მას ნაგულისხმევ მნიშვნელობას. და თუ ეს საჭიროა, მაშინ ჩვენ მას ვცვლით. ამ შემთხვევაში, ჩვენ ვცვლით ნაგულისხმევ მნიშვნელობას, თუ ნომერი უარყოფითია. თუმცა, ეს მაგალითი შეიძლება კიდევ უფრო ლამაზად დაიწეროს:

Var x = მოთხოვნა ("შეიყვანეთ ნომერი");
var დადებითი = x< 0;

სხვა სიტყვებით რომ ვთქვათ, ჩვენ ვართ ცვალებადი დადებითიდაუყოვნებლივ მიანიჭეთ შედარების შედეგი xდა ნული.

ახლა მოდით ვისაუბროთ ე.წ რთული პირობები. ზემოთ მოყვანილ მაგალითებში განვიხილეთ მხოლოდ მარტივი პირობები, თუმცა არის სხვა პირობებიც, რომლებიც შედგება რამდენიმე პირობისგან. და აქ გამოიყენება ორი ოპერაცია: && - ლოგიკური დადა || - ლოგიკური ან. დავწეროთ ეს პირობა:

თუ ((x<= 5) && (x >= 0)) (//ოპერატორების ბლოკი)

ეს პირობა (კომპლექსური მდგომარეობა) მისცემს მართალია, თუ და მხოლოდ თუ x<= 5 И x >= 0 . წინააღმდეგ შემთხვევაში, ის დაბრუნდება ყალბი.

განვიხილოთ რთული მდგომარეობა ლოგიკური ან.

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

ეს შეიძლება ითარგმნოს შემდეგნაირად: თუ x<= 5 ИЛИ x == 6 , შემდეგ დაბრუნდი მართალია, წინააღმდეგ შემთხვევაში ყალბი.

ბოლო, რაც მინდა ვთქვა, არის ის, რომ არის პირობები, რომლებიც შედგება რამდენიმე ლოგიკური AND და ORდა ზოგჯერ თქვენ ნამდვილად უნდა დაიძაბოთ თქვენი თავი ამ მდგომარეობის გასაგებად.

სულ ეს იყო რისი თქმაც მინდოდა პირობითი განცხადებები JavaScript-ში. და მაშინ უბრალოდ პრაქტიკა გჭირდებათ. სამწუხაროდ, პრაქტიკის გარეშე, თქვენ ვერასდროს ისწავლით ამ ოპერატორის გამოყენებას, რომლის ცოდნის გარეშე უბრალოდ უაზროა გადასვლა. ასე რომ, შექმენით მარტივი პრობლემა (როგორც ის, რაც ზემოთ მოვაგვარეთ) და მოაგვარეთ იგი.

დავუბრუნდეთ ჩვენს კურდღლებს

გავიხსენოთ დავალება კურდღლებისა და მაზაის შესახებ ბოლო თავიდან.
შესრულებული (ან შესრულებული) პირობებისა და მოქმედებების გამოყენების გარეშე
პირობებიდან გამომდინარე, დაითვალეთ კურდღლების რაოდენობა ბოლოში
გემისთვის ადვილი არ იქნება.

მოდით დავამატოთ განშტოება lastBoatRabbits ფუნქციას:

var lastBoatRabbits = ფუნქცია (სულ კურდღლები)( if (totalRabbits === 0 ) ( // return 0 ; ) else ( var restRabbits = totalRabbits % 6 ; if (restRabbits === 0 ) ( // return 6 ; ) else ( return restRabbits; ) ) );

ასე რომ, თუ მდინარეზე კურდღელი არ არის, ბოლო ნავი არავის მოუტანს (ფაქტობრივად, ის თითქმის მაშინვე დაბრუნდება, რადგან ბაბუა დანამდვილებით ეცოდინება, რომ მდინარეზე კურდღელი არ არის).

და თუ კურდღლების რაოდენობა მდინარეზე არის 6-ის ჯერადი, მაშინ ბოლო ნავი სრულად იქნება დატვირთული კურდღლებით.

კიდევ რა შეიძლება გაუმჯობესდეს ამ პროგრამაში? მე გამოვიყენებდი ცალკე ცვლადს,
ნავში მორგებული კურდღლების რაოდენობის შენახვა, მადლიერების შემთხვევაში
კურდღლები მაზაის უფრო დიდ ნავს მისცემს. არასოდეს იცი რა მოულოდნელად.

ფუნქცია (სულ კურდღლები)( if (totalRabbits === 0 ) ( return 0 ; ) else ( var restRabbits = totalRabbits % boatCapacity; if (restRabbits === 0 ) ( return boatCapacity; ) else ( return restRabbits; ) ) );

განშტოების სინტაქსი

ფილიალს შეიძლება ჰქონდეს ნაწილი, რომელიც შესრულებულია, თუ პირობა მცდარია,
ან შეიძლება არ ჰქონდეს:

// ვარიანტი ორი ფილიალით: if (rainIsFalling) ( stayHome(); // თუ rainIsFalling == true, ეს ნაწილი შესრულებულია) else ( walkInAPark(); // წინააღმდეგ შემთხვევაში ეს ნაწილი შესრულდება } // ვარიანტი ერთი ფილიალით: if (musicIsPlaying) (ცეკვა();) // თუ musicIsPlaying == false, პროგრამის შესრულება უბრალოდ გრძელდება

პირობები

პირობა if შეიძლება იყოს გამონათქვამი, რომელიც ადარებს ორ რიცხვს ან სტრიქონს,
ოპერაციების გამოყენებით == , > ,< , >= , <= , != и === , любая переменная, которой
მინიჭებული იყო ლოგიკური მნიშვნელობა და უბრალოდ ნებისმიერი მნიშვნელობა, რომელიც ოპერაციის შედეგად
თუ გადაიცემა ლოგიკურ მნიშვნელობაზე.

შედარების მაგალითები:

10 > 5 // => მართალია 11< 6 // =>მცდარი 5 >= 5 // => მართალია 3 != 3 // => მცდარი "abc" == "abc" // => მართალია "abc" === "abc" // => მართალია

ცვლადები, როგორც პირობა:

var მდგომარეობა = 10 > 5 ; if (condition) ( console .log("10 > 5" ); // შესრულდება }

ლოგიკური მოქმედებები პირობებზე

მრავალი გამონათქვამი, რომელიც აბრუნებს ლოგიკურ (ან ლოგიკურზე იძულებით) მნიშვნელობას
შეიძლება გაერთიანდეს ლოგიკური ოპერაციების გამოყენებით. ასეთ ოპერაციებს უწოდებენ:
ლოგიკური AND &&, ლოგიკური OR || და ლოგიკური უარყოფა! .

მართალია && ჭეშმარიტი; // => true false || ყალბი ; // => false !false ; // => მართალია

ლოგიკური AND აბრუნებს ჭეშმარიტს მხოლოდ იმ შემთხვევაში, თუ მისი ორივე მხარე მართალია.
ლოგიკური OR აბრუნებს false-ს მხოლოდ იმ შემთხვევაში, თუ მისი ორივე მხარე ყალბია.
უარყოფა აბრუნებს false-ს სიმართლეს და, პირიქით, true-ს ცრუს.

Javascript წესების მიხედვით, მნიშვნელობები 0, null და undefined გადადის false-ზე.
თუმცა, შედეგის მიღებით ვიღებთ პირველ შეუმცირებელ მნიშვნელობას, რომელიც
გადაცემულია false-ზე და შედეგად მიღებული შედეგი არის || - პირველი შეუმცირებელი მნიშვნელობა,
რომელიც აფასებს ჭეშმარიტად:

0 && true; // => 0 6 || 7 || ყალბი ; // => 6 !0 ; // => მართალია

ამრიგად, ფუნქცია, რომელიც აბრუნებს კურდღლების რაოდენობას ბოლო ნავში, შეიძლება გადაიწეროს შემდეგნაირად:

var boat მოცულობა = 6 ; var lastBoatRabbits = ფუნქცია (სულ კურდღლები)(დააბრუნე სულ კურდღლები && (მთლიანი კურდღლები % boatCapacity || boatCapacity); );

Დავალებები

  1. დაწერეთ ფუნქცია fizzbuzz, რომელიც იღებს რიცხვის პარამეტრს და:
    • სამის ჯერადი რიცხვებისთვის აბრუნებს "Fizz"
    • ხუთის მრავლობითი რიცხვებისთვის აბრუნებს "Buzz"
    • თხუთმეტის ჯერადი რიცხვებისთვის (ორივე სამი და ხუთი), აბრუნებს "FizzBuzz"
    • წინააღმდეგ შემთხვევაში, აბრუნებს თავდაპირველ ნომერს
  2. დაწერეთ ფუნქცია iGoToNorth, რომელიც იღებს რიცხვის პარამეტრს და განსაზღვრავს არის თუ არა ჩვენთვის გადაცემული რიცხვი შესაბამისი. რიცხვი შესაფერისია, თუ ის 10-ზე მეტია, 30-ზე ნაკლები და 7-ის ჯერადი.

გაკვეთილი #5
განშტოება if განცხადებები JavaScript-ში

ფილიალის ოპერატორებიშექმნილია ისე, რომ პროგრამამ შეძლოს კოდის ამა თუ იმ ბლოკის გაშვება, იმისდა მიხედვით, პირობა მართალია თუ მცდარი.

ფილიალის ოპერატორების ხუთი ტიპი არსებობს, ამ გაკვეთილზე ჩვენ განვიხილავთ ორ მათგანს:
— ფილიალის ოპერატორი თუ
— ფილიალის ოპერატორი სხვა შემთხვევაში

აწარმოებს კოდს, თუ პირობა დაბრუნდება true.

ფილიალების ოპერატორებში პირობები ჩვეულებრივ არის შედარების ოპერაციები ან ლოგიკური ოპერაციები.

if ფილიალის განცხადების დიაგრამა ასე გამოიყურება:

თუ (პირობა) (კოდი იმუშავებს, თუ პირობა დაბრუნდება true)

მოდით მივცეთ მაგალითი ფილიალის ოპერატორთან, თუ:

// ორი ცვლადის შექმნა var numOne; var numTwo; // მნიშვნელობების მინიჭება ცვლადებს numOne = 5; numTwo = 3; if (numOne > numTwo) ( alert ("პირობა დაბრუნდა ჭეშმარიტი"); )

სკრიპტში ჩვენ შევქმენით ორი ცვლადი numOne და numTwo და მივენიჭეთ მათ რიცხვითი მნიშვნელობები 5 და 3.

შემდეგი, ჩვენ შევქმენით if branching ოპერატორი, რომელიც ადარებს ორი ცვლადის მნიშვნელობებს. თუ შედარების ოპერაცია დააბრუნებს true, მაშინ კოდი, რომელიც მდებარეობს ხვეულ ბრეკეტებს შორის, იმუშავებს. ჩვენს შემთხვევაში, გამოჩნდება ფანჯარა, რომელშიც შეტყობინება Condition დაბრუნდა true. თუ შედარების ოპერაცია დააბრუნებს false-ს, მაშინ არაფერი მოხდება.

ორმაგი დახრილი სიმბოლოები // არის კომენტარები. ორმაგი ხაზის შემდეგ შეგიძლიათ დაწეროთ ნებისმიერი ტექსტი, JavaScript-ის ინტერპრეტატორი მას აღიქვამს როგორც კომენტარს და არ დაამუშავებს. როგორც გვახსოვს, ენებზე და კომენტარების შექმნაც შეგიძლიათ.

ფილიალის განცხადება თუ სხვაა, შექმნილია კოდის კონკრეტული ბლოკის გასაშვებად, რაც დამოკიდებულია იმ მნიშვნელობაზე, რომელსაც დააბრუნებს მდგომარეობა: true ან false

if else ფილიალის განცხადების დიაგრამა ასე გამოიყურება:

თუ (პირობა) (კოდი იმუშავებს, თუ პირობა დააბრუნებს true) სხვა (კოდი იმუშავებს, თუ პირობა დააბრუნებს false)

მოდით მივცეთ მაგალითი ფილიალის ოპერატორთან, თუ სხვა შემთხვევაში:

VarnumOne; var numTwo; numOne = 5; numTwo = 3; if (numOne > numTwo) ( alert ("პირობა დაბრუნდა true"); ) else (alert ("პირობა დაბრუნდა false"); )

მიანიჭეთ ცვლადი numTwo, რიცხვი 5-ზე მეტი, მაგალითად 7, შემდეგ პირობა დაბრუნდება false და გამოჩნდება ფანჯარა შეტყობინება Condition returned false.

JavaScript - გაკვეთილი 7. განშტოება პროგრამაში - if განაცხადი

ძალიან ხშირად ჩნდება ვითარება, როცა რაიმე მდგომარეობიდან გამომდინარე, გვჭირდება რაიმე მოქმედების შესრულება. მაგალითად, გვაქვს ტანსაცმლის ონლაინ მაღაზია. ჩვენ ვეკითხებით მომხმარებელს, ვინ არის ის (მამაკაცი თუ მდედრობითი სქესის) და პასუხის მიხედვით ვაჩვენოთ შესაბამისი პროდუქტების სია (მამაკაცი თუ ქალი). ასეთი პროგრამების დაწერისას გამოიყენება პირობითი თუ განცხადება. მისი სინტაქსი ასეთია:

თუ B(S1)
სხვა (S2)

სად ბ- ლოგიკური ტიპის გამოხატულება და S1და S2- ოპერატორები.

ის ასე მუშაობს: გამოთვლების მნიშვნელობა გამოითვლება ბ, თუ ეს მართალია, მაშინ განცხადება შესრულებულია S1, თუ ის მცდარია, მაშინ განცხადება შესრულებულია S2. სიმებიანი სხვა (S2)შეიძლება გამოტოვდეს.

მგონი მაგალითით უფრო ნათელი გახდება. ვთქვათ, გვაქვს ფორმა, რომელშიც მომხმარებელი შეაქვს 3 მნიშვნელობას. დავწეროთ სკრიპტი, რომელიც განსაზღვრავს შეყვანილი რიცხვების მაქსიმუმს.

პირველ რიგში, მოდით დავწეროთ ფორმის კოდი html გვერდზე:

Javascript თუ

ახლა მოდით დავწეროთ ფუნქციის კოდი script.js გვერდზე:

ფუნქცია 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, თუ (c>m) m=c;

ასე რომ, ჩვენი ფუნქცია იღებს სამ მნიშვნელობას ფორმიდან, მაქსიმუმზე ( მ) ჩვენ ვიღებთ მნიშვნელობას ა. შემდეგ ვადარებთ: თუ მნიშვნელობა ბმაქსიმუმზე მეტი (ე.ი. ა), შემდეგ ხდება მაქსიმუმი ბთორემ მაქსიმუმი რჩება ა(რადგან გამოთქმა ფრჩხილებში არ შეესაბამება სიმართლეს). შემდეგი, ანალოგიურად შეადარეთ შემდეგი მნიშვნელობა გმაქსიმუმთან ერთად. პასუხი ნაჩვენებია შედეგის ველში ( რეზ).

ზოგადად, ასეთი სკრიპტის დაწერა შეიძლება მეთოდის გამოყენებით მაქსობიექტი Მათემატიკაგანხილული იყო ბოლო გაკვეთილზე და კოდი უფრო მოკლე იქნებოდა:

ფუნქცია maxZnach(obj)( var a=1*obj.zn1.value; var b=1*obj.zn2.value; var c=1*obj.zn3.value; obj.res.value=მათ.max(მათ. .max(a,b),c);

ვგულისხმობ იმას, რომ პროგრამირება ჯერ კიდევ შემოქმედებითი პროცესია და ერთი პრობლემის გადაჭრა სხვადასხვა გზით შეიძლება. პროგრამისტის ამოცანაა იპოვოთ ყველაზე ოპტიმალური ვარიანტი. მაგრამ ეს ასეა, ლირიკული გადახრა. დავუბრუნდეთ if განცხადებას და გადავხედოთ უფრო საინტერესო მაგალითს. მოდით დავწეროთ სკრიპტი, რომლის დროსაც მაუსის კურსორს სურათზე გადასვლისას ის გაიზრდება და შექმნის მასშტაბის ეფექტს.

როგორც გახსოვთ, HTML-ში შეგიძლიათ დააყენოთ ჩასმული სურათის ზომა. თუ მითითებული ზომები ორიგინალზე დიდი ან პატარაა, ბრაუზერი ავტომატურად დაარეგულირებს ორიგინალს ამ ზომებზე. ეს არის ის, რასაც ჩვენ გამოვიყენებთ. მოდით ეს სურათი გვქონდეს:

ორიგინალური სიგანე 302 პიქსელია. გვსურს გვერდზე გამოსახულებას ჰქონდეს 102 პიქსელის სიგანე, ხოლო კურსორის ატარებისას ის იზრდება 302 პიქსელამდე. ყველაფერი ნათელია html გვერდით:

Javascript თუ

და ჩვენს ფუნქციაში, პირობითი ოპერატორის გარდა, გამოვიყენებთ სტანდარტულ Javascript ფუნქციასაც setTimeout, რომელიც იძახებს მომხმარებლის მიერ განსაზღვრულ ფუნქციას მოცემულ დროის ინტერვალში:

ფუნქცია bigPict())( var w=document.tigr.width; if (w ამრიგად, ფუნქცია ამოწმებს სურათის სიგანეს ( სიგანე) და თუ ის 302 პიქსელზე ნაკლებია, მაშინ ამ სიგანეს 10 პიქსელით ზრდის. ფუნქცია setTimeoutუწოდებს ჩვენს ფუნქციას bigPictყოველ ნახევარ წამში, რის გამოც სურათის ზომა გაიზრდება მდგომარეობამდე ჩვენ არ გავხდებით ყალბი.

მიახლოების ვიზუალურად გასამარტივებლად, შეეცადეთ შეამციროთ სიგანის გაზრდის საფეხური და ფუნქციის გამოძახებისთვის საჭირო დრო. ითამაშე ამ ნომრებით და იპოვე ის, ვინც საუკეთესოდ მუშაობს.

დღეისთვის სულ ეს არის, როგორც საშინაო დავალება, დაასრულეთ ჩვენი სკრიპტი ისე, რომ მაუსის კურსორის გასვლისას სურათმა მიიღოს ორიგინალური მნიშვნელობები (ანუ 102 პიქსელი). თუ ეს არ მუშაობს, მაშინ გადმოწერეთ



 

შეიძლება სასარგებლო იყოს წაკითხვა: