საკონტროლო ინსტრუქციებიარის ინსტრუქციები, რომლებიც საშუალებას გაძლევთ აკონტროლოთ პროგრამის კოდის შესრულება. როგორც წესი, შესრულებადი კოდი საკონტროლო ინსტრუქციაში მოიხსენიება, როგორც ამ ინსტრუქციის ტექსტი.
საკონტროლო ინსტრუქციები შეიძლება იყოს ჩასმული ან გამოყენებული სხვა საკონტროლო ინსტრუქციებში.
პირობითი განცხადებები
ნაგულისხმევად, JavaScript თარჯიმანი ახორციელებს ინსტრუქციებს ერთმანეთის მიყოლებით იმ თანმიმდევრობით, რომელშიც ისინი გამოჩნდება საწყისი კოდი... იმ შემთხვევებში, როდესაც ზოგიერთი ინსტრუქციის შესრულება ან შეუსრულებლობა უნდა იყოს დამოკიდებული გარკვეული პირობის შესრულებაზე ან შეუსრულებლობაზე, გამოიყენება პირობითი განცხადებები.
თუ განცხადება
if განცხადებას ორი ფორმა აქვს. პირველი ფორმის სინტაქსია:
ფრჩხილებში გამოსახულებას ე.წ შესრულების პირობათუ განცხადებები ან პირობითი მოკლედ. ჯერ ფასდება გამოხატვის მნიშვნელობა. მიღებული მნიშვნელობა, საჭიროების შემთხვევაში, ირიბად გარდაიქმნება ლოგიკურ ტიპად. თუ გამოთქმა ფასდება ჭეშმარიტად, მაშინ განცხადება შესრულებულია. თუ გამოთქმა დააბრუნებს false, მაშინ განცხადება არ შესრულდება:
თუ (ჭეშმარიტი) გაფრთხილება ("დასრულებულია!"); თუ (ცრუ) გაფრთხილება ("არ შესრულდება!");
if სინტაქსი საშუალებას გაძლევთ შეასრულოთ მხოლოდ ერთი განცხადება, მაგრამ თუ თქვენ გჭირდებათ ერთზე მეტი განცხადების შესრულება, თქვენ უნდა გამოიყენოთ რთული განცხადება:
თუ (true) (var str = "გამარჯობა!"; გაფრთხილება (str);)
მეორე ფორმის სინტაქსია:
თუ (გამოხატვა) განცხადება; else განცხადება;
სხვა საკვანძო სიტყვა საშუალებას გაძლევთ დაამატოთ განცხადება, რომელიც უნდა შესრულდეს, თუ პირობა მცდარია:
თუ (ცრუ) გაფრთხილება ("არ შესრულდება"); სხვა გაფრთხილება ("შეასრულე");
როგორც უკვე აღვნიშნეთ, საკონტროლო ინსტრუქციები შეიძლება იყოს ჩასმული, რაც საშუალებას გაძლევთ შექმნათ შემდეგი კონსტრუქციები:
Var num = 2; if (num == 1) (გაფრთხილება ("num მნიშვნელობა:" + num);) სხვა თუ (num == 2) (გაფრთხილება ("num მნიშვნელობა:" + num);) else (გაფრთხილება ("მე არ ვარ იცოდე ასეთი რიცხვი! ”))
ამ კოდში განსაკუთრებული არაფერია. ეს არის უბრალოდ განცხადებების თანმიმდევრობა, სადაც თითოეული if წინადადება არის წინა if განცხადების სხვა ნაწილის ნაწილი. ერთი შეხედვით, აღნიშვნის ეს ფორმა შეიძლება სრულიად მკაფიო არ ჩანდეს, ამიტომ განვიხილოთ სინტაქსურად ეკვივალენტური ფორმა, რომელიც აჩვენებს if განცხადებების ბუდობას:
Var num = 2; if (num == 1) (გაფრთხილება ("num მნიშვნელობა:" + num);) else (თუ (num == 2) (გაფრთხილება ("num მნიშვნელობა:" + num);) else (გაფრთხილება ("I don' არ ვიცი ეს რიცხვები! ”)))
Reg.ru: დომენები და ჰოსტინგი
ყველაზე დიდი რეგისტრატორი და ჰოსტინგის პროვაიდერი რუსეთში.
სერვისში 2 მილიონზე მეტი დომენის სახელია.
პოპულარიზაცია, ფოსტა დომენისთვის, ბიზნეს გადაწყვეტილებები.
700 ათასზე მეტმა მომხმარებელმა მთელი მსოფლიოს მასშტაბით უკვე გააკეთა არჩევანი.
ჩატვირთვის ჩარჩო: სწრაფი რეაგირებადი განლაგება
ნაბიჯ-ნაბიჯ ვიდეო გაკვეთილი Bootstrap ჩარჩოში საპასუხო განლაგების საფუძვლების შესახებ.
ისწავლეთ აკრეფა მარტივად, სწრაფად და ეფექტურად, ძლიერი და პრაქტიკული ხელსაწყოს გამოყენებით.
განლაგება შეუკვეთეთ და მიიღეთ გადახდა.
* გადაიტანეთ მაუსი გადახვევის შესაჩერებლად.
უკან წინ
JavaScript if-else ფუნქციები და პირობები
ხშირად JavaScript-ის გამოყენებისას საჭირო ხდება სხვადასხვა მოქმედებების შესრულება სხვადასხვა პირობების დაკმაყოფილებისას.
მაგალითად, თქვენ დაწერეთ სკრიპტი, რომელიც ამოწმებს, რომელ ბრაუზერს იყენებს ვიზიტორი თქვენს საიტზე სტუმრობისას. თუ ეს Internet Explorer, უნდა ჩაიტვირთოს სპეციალურად IE-სთვის შექმნილი გვერდი, თუ ეს არის ნებისმიერი სხვა ბრაუზერი - უნდა ჩაიტვირთოს ამ გვერდის სხვა ვერსია.
if-else კონსტრუქციის ზოგადი სინტაქსი ასეთია:
თუ (პირობა) (მოქმედება) სხვა (მოქმედება2);
მაგალითად, განიხილეთ შემდეგი კოდი:
If (ბრაუზერი == "MSIE") (გაფრთხილება ("თქვენ იყენებთ IE")) else (გაფრთხილება ("თქვენ არ იყენებთ IE"));
გაითვალისწინეთ, რომ გამოყენებულია ყველა მცირე ასო. თუ დაწერთ "IF", მოხდება შეცდომა.
ასევე გაითვალისწინეთ, რომ შედარება იყენებს ორმაგ ტოლობის ნიშანს (==).
თუ დავწერთ ბრაუზერი = "MSIE"მაშინ ჩვენ უბრალოდ ვაძლევთ მნიშვნელობას MSIEდასახელებული ცვლადი ბრაუზერი.
როცა ვწერთ ბრაუზერი == "MSIE", შემდეგ JavaScript-ს „ესმის“, რომ ჩვენ გვინდა შედარება და არა მნიშვნელობის მინიჭება.
უფრო რთული პირობები თუშეიძლება შეიქმნას უბრალოდ მათი დამატებით, მაგალითად, ნაწილზე სხვაუკვე არსებული მშენებლობა თუ კიდევ:
თუ (პირობა) (მოქმედება1) სხვა (თუ (სხვა პირობა) (მოქმედება2) სხვა (მოქმედება3);
Მაგალითად:
If (ბრაუზერი == "MSIE") (გაფრთხილება ("თქვენ იყენებთ IE")) else (if (ბრაუზერი == "Netscape") (გაფრთხილება ("თქვენ იყენებთ Firefox")) else (გაფრთხილება ("თქვენ იყენებთ ამოუცნობი ბრაუზერი: ) ")); );
ლოგიკური ოპერატორები AND, OR და NOT
სტრუქტურის კიდევ უფრო მოქნილი გამოყენებისთვის თუ კიდევშეიძლება გამოყენებულ იქნას ეგრეთ წოდებული ლოგიკური ოპერატორები.
დადაწერილი როგორც && და გამოიყენება იმ შემთხვევებში, როდესაც საჭიროა შეამოწმოთ ერთზე მეტი პირობის ჭეშმარიტება.
მაგალითად: თუ მაცივარში არის კვერცხი და მაცივარში ბეკონი, მაშინ ჩვენ შეგვიძლია ვჭამოთ კვერცხი და ბეკონი.
სინტაქსი ასეთია:
თუ (პირობა1 && პირობა2) (მოქმედება) if (საათი == 12 && წუთი == 0) (გაფრთხილება ("შუადღე!"));
ანდაწერილი როგორც || და გამოიყენება მაშინ, როდესაც გვინდა შევამოწმოთ ორი ან მეტი პირობიდან მინიმუმ ერთის ჭეშმარიტება. (შეგიძლიათ მიიღოთ || Shift ღილაკის და \ კლავიშის დაჭერით)
მაგალითად: თუ მაცივარში რძეა, ან თუ მაცივარში წყალია, მაშინ რაღაც გვაქვს დასალევი.
სინტაქსი ასეთია:
If (პირობა1 || მდგომარეობა2) (მოქმედება) if (საათი == 11 || საათი == 10) (გაფრთხილება ("შუადღე ჯერ არ მოსულა!"));
არადაწერილი როგორც ! და გამოიყენება უარყოფისთვის.
მაგალითად: თუ მაცივარში კვერცხი არ არის ან ბეკონი არ არის, მაშინ არ შეგვიძლია ვჭამოთ არც კვერცხი და არც ბეკონი.
სინტაქსი არის:
If (! (მდგომარეობა)) (მოქმედება) if (! (საათი == 11)) (გაფრთხილება ("ეს არ არის 11 საათი"));
ფუნქციები JavaScript-ში
იმის ნაცვლად, რომ უბრალოდ დაამატოთ Javascript გვერდზე ისე, რომ ბრაუზერმა შეასრულოს კოდი, როდესაც საქმე ეხება მას, შეგიძლიათ სკრიპტის შესრულება მხოლოდ მაშინ, როდესაც მოხდება მოვლენა.
მაგალითად, თქვენ შექმენით JavaScript, რომლის ამოცანაა შეცვლა ფონის ფერიგვერდი კონკრეტულ ღილაკზე დაჭერისას. ამ შემთხვევაში, თქვენ უნდა "უთხარით" ბრაუზერს, რომ ეს სკრიპტი არ უნდა შესრულდეს მხოლოდ იმიტომ, რომ მას მიაღწია რიგში.
იმისათვის, რომ ბრაუზერმა არ შეასრულოს სკრიპტი მისი ჩატვირთვისას, თქვენ უნდა დაწეროთ სკრიპტი ფუნქციად.
ამ შემთხვევაში, JavaScript კოდი არ შესრულდება მანამ, სანამ არ "მოვკითხავთ" მას სპეციალური გზით.
შეხედეთ ფუნქციის სახით დაწერილი სკრიპტის ამ მაგალითს:
დააჭირეთ ღილაკს, რომ ნახოთ რას აკეთებს სკრიპტი:
თუ ხაზი გაფრთხილება ("მოგესალმებით!");არ იყო ჩაწერილი ფუნქციის შიგნით, მაშინ ის შესრულდებოდა, როდესაც ბრაუზერი მიაღწევდა ამ ხაზს. მაგრამ მას შემდეგ, რაც ჩვენ დავწერეთ ის ფუნქციის შიგნით, ეს ხაზი არ სრულდება, სანამ არ დავაჭერთ ღილაკს.
ფუნქციის გამოძახება (ანუ მასზე წვდომა) ხდება ამ ხაზზე:
როგორც ხედავთ, ჩვენ დავაყენეთ ღილაკი ფორმაზე და დავამატეთ ღონისძიება onClick = "myfunction ()"ღილაკისთვის.
მომავალ გაკვეთილებში ჩვენ განვიხილავთ სხვა სახის მოვლენებს, რომლებიც ააქტიურებენ ფუნქციებს.
ფუნქციების ზოგადი სინტაქსი ასეთია:
ფუნქციის ფუნქციის სახელი (ცვლადი1, ცვლადი2, ..., ცვლადიN) (// ფუნქციის ძირითადი ნაწილი მიდის აქ, მოქმედებები, რომლებსაც ის ასრულებს)
ბრეკეტები: { და } მიუთითეთ ფუნქციის დასაწყისი და დასასრული.
ტიპიური შეცდომა ფუნქციების შექმნისას არის დაუდევრობა და საქმის მნიშვნელობის იგნორირება. სიტყვა ფუნქციაზუსტად უნდა იყოს ფუნქცია... ვარიანტი ფუნქციაან ფუნქციაშეცდომას დაუშვებს.
ასევე, გამოყენებით დიდი ასოებიროლს ასრულებს ცვლადის სახელების განსაზღვრაში. თუ თქვენ გაქვთ ფუნქცია დასახელებული ჩემი ფუნქცია (), შემდეგ მცდელობა მიმართოს მას როგორც ჩემი ფუნქცია (), MYFUNCTION ()ან ჩემი ფუნქცია ()შეცდომას დაუშვებს.
მოგეწონათ მასალა და გსურთ მადლობა გადაგიხადოთ?
უბრალოდ გაუზიარე მეგობრებს და კოლეგებს!
Იხილეთ ასევე:
var a = 10; var b = (a> 1)? 100: 200; გაფრთხილება (ბ);
თუ პირობა a> 1მართალია, მაშინ ცვლადი ბღირებულების მინიჭება 100 , წინააღმდეგ შემთხვევაში b ცვლადს ენიჭება მნიშვნელობა 200 .
Js ამოცანა 3_4.კომპლემენტის კოდი: გამოცხადებულია 3 ადგილობრივი ცვლადის გამოყენებით საკვანძო სიტყვავარ. აუცილებელია შემდეგი სამეული ოპერატორის მნიშვნელობა მივანიჭოთ max ცვლადს: თუ a მეტია b-ზე, მაშინ ვაბრუნებთ a-ს, წინააღმდეგ შემთხვევაში ვაბრუნებთ b-ს.
კოდის ნაწყვეტი:
თუ (a * b< 6) { result = "Мало"; } else { result = "Много"; }
კითხვები თვითკონტროლისთვის:
- რა არის სინტაქსი სამიანი ოპერატორისთვის?
- რამდენი არგუმენტი აქვს სამეულ ოპერატორს?
ოპერატორის შეცვლა JavaScript-ში - switch
javascript switch განაცხადი გამოიყენება ცვლადის შესამოწმებლად მრავალი მნიშვნელობისთვის:
Სინტაქსი:
გადართვა (ცვლადი ან გამოხატულება) (შემთხვევის ვარიანტი 1: //.. განცხადების ბლოკი .. შესვენება პარამეტრი 2: //.. განცხადების ბლოკი.. ნაგულისხმევი შესვენება: //.. განცხადების ბლოკი ..)
ცვლადის ან გამოხატვის მნიშვნელობა მოწმდება: თითოეულში საქმეშემოწმებულია ერთ-ერთი მნიშვნელობა, შესაფერისი მნიშვნელობის შემთხვევაში, ამის შესაბამისი განცხადებების ერთი ან სხვა ბლოკი. საქმე.
სერვისის ნაგულისხმევი სიტყვით დაწყებული ბლოკი შეიძლება გამოტოვდეს. ბლოკის განცხადებები შესრულდება, თუ საერთოდ არ არის ჩამოთვლილი მნიშვნელობები საქმეარ ერგება.
Მნიშვნელოვანი:შესვენების განცხადება საჭიროა ცვლადის ყოველი განხილული მნიშვნელობის შემდეგ (თითოეულის შემდეგ საქმე); თუ არ იყენებთ მას, მაშინ გამოჩნდება ქვემოთ განთავსებული ყველა ოპერატორი
შეადარეთ ოპერატორს თუ:
var a = 2; შეცვლა (ა) (შემთხვევა 0: // თუ (a === 0) შემთხვევა 1: // თუ (a === 0) გაფრთხილება ("ნული ან ერთი"); // შემდეგ გამომავალი ... შესვენება; შემთხვევა 2: // თუ (a === 2) გაფრთხილება ("ორი"); // შემდეგ ჩვენება ... შესვენება; ნაგულისხმევი: // სხვა გაფრთხილება ("ბევრი"); // სხვა შემთხვევაში ჩვენება ...)
როგორ დავაჯგუფო რამდენიმე ვარიანტი?
ერთი და იგივე ოპერატორის შესასრულებლად შესაძლებელია რამდენიმე დაჯგუფება საქმე... როგორც ზემოთ მოცემულ მაგალითში:
შემთხვევა 0: შემთხვევა 1: გაფრთხილება („ნული ან ერთი“); შესვენება; ...
a = 0 და a = 1-ისთვის შესრულებულია იგივე განცხადება: alert ("ნული ან ერთი");
მაგალითი 4:შესთავაზეთ მომხმარებელს შეიყვანოს ფერი. გამომავალი თარგმანი ინგლისურიშეყვანილი ფერი. ფერისთვის "ლურჯი"და "ლურჯი"დააბრუნეთ იგივე მნიშვნელობა.
✍ გამოსავალი:
- შექმენით ვებ გვერდი html ჩონჩხით და ტეგით სკრიპტი.
- ცვლადის ინიცირება ფერი
- შეამოწმეთ ცვლადის მნიშვნელობა კონსტრუქციის გამოყენებით შეცვლა, გამომავალი თითოეული მნიშვნელობისთვის - შესაბამისი თარგმანი:
- ყვავილებისთვის "ლურჯი"და "ლურჯი"გააკეთეთ დაჯგუფება:
- მოაწყეთ გამოსავალი იმ ფერებისთვის, რომლებიც არ არის გათვალისწინებული პროგრამის მიერ:
- შეამოწმეთ სკრიპტი ბრაუზერში.
| var ფერი = მოთხოვნა ("რა ფერი?"); |
var ფერი = მოთხოვნა ("რა ფერი?");
შეცვლა (ფერი) (შემთხვევა "წითელი": გაფრთხილება ("წითელი"); შესვენება; შემთხვევა "მწვანე": გაფრთხილება ("მწვანე"); შესვენება; // ...
თუ ცვლადი ფერიაქვს მნიშვნელობა "red", შემდეგ აჩვენეთ თარგმანი მოდალურ ფანჯარაში - "red" და გამოდით კონსტრუქციიდან (break;). თუ ცვლადი ფერიაქვს მნიშვნელობა "მწვანე", შემდეგ აჩვენეთ თარგმანი მოდალურ ფანჯარაში - "მწვანე" და გამოდით კონსტრუქციიდან (შესვენება;).
// ... შემთხვევა "ლურჯი": შემთხვევა "ლურჯი": გაფრთხილება ("ლურჯი"); შესვენება; //...
თუ ცვლადი ფერიარის ლურჯი ან ცვლადი ფერიაქვს მნიშვნელობა "ლურჯი", შემდეგ აჩვენეთ თარგმანი მოდალურ ფანჯარაში - "ლურჯი" და გამოდით კონსტრუქციიდან (შესვენება;).
| // ... ნაგულისხმევი: გაფრთხილება ( "ამ ფერზე ინფორმაცია არ გვაქვს")) // ბოლო გადამრთველი |
// ... ნაგულისხმევი: alert ("y ჩვენ არ გვაქვს ინფორმაცია ამ ფერის შესახებ")) // დასრულება შეცვლა
Js ამოცანა 3_6.იპოვეთ და შეასწორეთ შეცდომები შემდეგი კოდის ნაწყვეტში:
| 14 15 16 17 | var ნომერი = მოთხოვნა ( "შეიყვანეთ ნომერი 1 ან 2:"); შეცვლა (ნომერი) (საქმე "1" (დოკუმენტი. ჩაწერეთ ("ერთი");); შესვენება; შემთხვევა "2" (დოკუმენტი. ჩაწერეთ ("ორი");); შესვენება; ნაგულისხმევი (დოკუმენტი. ჩაწერეთ ( "თქვენ შეიყვანეთ მნიშვნელობა 1-ისა და 2-ის გარდა") ; } ; } |
var ნომერი = მოთხოვნა ("შეიყვანეთ ნომერი 1 ან 2:"); შეცვლა (ნომერი) (საქმე "1" (დოკუმენტი. ჩაწერეთ ("ერთი");); შესვენება; შემთხვევა "2" (დოკუმენტი. ჩაწერეთ ("ორი");); შესვენება; ნაგულისხმევი (დოკუმენტი. ჩაწერეთ ("თქვენ შეიყვანეთ მნიშვნელობა, გარდა 1 და 2 ");))
Js ამოცანა 3_7.რა გამოჩნდება ეკრანზე შემდეგი კოდის შესრულებისას?:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | var მნიშვნელობა = "2"; შეცვლა (მნიშვნელობა) (საქმე "1": შემთხვევა "2": შემთხვევა "3": დოკუმენტი. ჩაწერეთ ("გამარჯობა"); შესვენება; შემთხვევა "4": შემთხვევა "5": დოკუმენტი. ჩაწერეთ ("მსოფლიო"); ნაგულისხმევი: document.write ("შეცდომა");) |
var მნიშვნელობა = "2"; შეცვლა (მნიშვნელობა) (საქმე "1": შემთხვევა "2": შემთხვევა "3": დოკუმენტი. ჩაწერეთ ("გამარჯობა"); შესვენება; შემთხვევა "4": შემთხვევა "5": დოკუმენტი. ჩაწერეთ ("მსოფლიო"); ნაგულისხმევი: document.write ("შეცდომა");)
Js ამოცანა 3_8.მომხმარებელს მოეთხოვება რიცხვი - ყვავების რაოდენობა ტოტზე. შეყვანილი ნომრის მიხედვით (არაუმეტეს 10), აჩვენეთ შეტყობინება: - იჯდა ტოტზე 1 ყვა- ტოტზე ზის 4 ყვავა- ტოტზე ზის 10 ყვავა
- შეყვანილი რიცხვიდან გამომდინარე, იცვლება სიტყვის დასასრული "ყვავი".
- შესამოწმებლად გამოიყენეთ Switch javascript განცხადება.
- შეინახეთ ეს გვერდი შედეგების საქაღალდეში (ეს გამოდგება შემდგომი მუშაობისთვის).
კითხვები თვითკონტროლისთვის:
- რა შემთხვევაში მიზანშეწონილია როგორც პირობითი ოპერატორიგამოიყენეთ მშენებლობა შეცვლა?
- რისთვის არის ნაგულისხმევი ბლოკი განცხადებაში? შეცვლა?
- სავალდებულოა თუ არა კონსტრუქციაში break განაცხადის გამოყენება შეცვლა?
- როგორ ხდება დაჯგუფება ოპერატორში მრავალი მნიშვნელობის ვარიანტებისთვის შეცვლა?
javaScript ენის ციკლური ოპერატორები - For
Სინტაქსი:
for (მრიცხველის საწყისი მნიშვნელობა; მდგომარეობა; მრიცხველის ზრდა) (//..განცხადებების ბლოკი ..)
Მნიშვნელოვანი: javascript for-ის ციკლი გამოიყენება, როდესაც წინასწარ არის ცნობილი, რამდენჯერ უნდა განმეორდეს ციკლური მოქმედებები (რამდენი გამეორება აქვს ციკლს)
- როგორც საწყისი ღირებულებაგანმეორების მრიცხველი, გამოიყენება დავალების გამოხატულება: მაგალითად, i = 0 - მარყუჟის მრიცხველი იწყება ნულიდან:
- მრიცხველის ზრდა მიუთითებს საფეხურზე, რომლითაც მრიცხველი უნდა გაიზარდოს: მაგალითად, მიუთითებს, რომ ციკლის ყოველ გამეორებას თან ახლავს მისი ზრდა. 1 :
- მარყუჟის პირობა არის მრიცხველის საბოლოო მნიშვნელობა: მაგალითად, i10, აჩერებს ციკლს:
for (var i = 0; მდგომარეობა; მრიცხველის ზრდა) (//.. განცხადებების ბლოკი ..)
for (var i = 0; პირობა; i ++) (//.. განცხადებების ბლოკი ..)
for (var i = 0; i<10; i++) { //..блок операторов.. }
მოდით შევხედოთ javascript-ში for loop-ის გამოყენების მაგალითს:
მაგალითი 5:დაბეჭდეთ რიცხვების თანმიმდევრობა 0 1 2 3 ... 9 , ყოველი ციფრი ახალ ხაზზე. 0 1 2 ... 8 9
✍ გამოსავალი:
- რიცხვების თანმიმდევრობის საჩვენებლად, ჩვენ გამოვიყენებთ for ციკლის მრიცხველს, რომელმაც უნდა შეცვალოს მისი მნიშვნელობა 0 ადრე 9 თანმიმდევრობის მიხედვით.
- აქედან გამომდინარე, ამისთვის ციკლის მრიცხველის საწყისი მნიშვნელობადააყენეთ მნიშვნელობა 0 ; როგორც ციკლის პირობებიდააყენეთ საბოლოო მნიშვნელობა - ii = 9; კონტრ ნაბიჯი უნდა იყოს ტოლი 1 (i ++) რადგან სხვაობა მიმდევრობის წევრებს შორის არის ერთი:
- შეამოწმეთ სკრიპტი ბრაუზერში.
for (var i = 0; i<10; i++)
{
document.write(i+"
");
}
მაგალითში, მარყუჟის მრიცხველის მნიშვნელობები ნაჩვენებია ეკრანზე, რადგან ეკრანზე გამოჩნდება მრიცხველის i ++ ზრდა, შესაბამისად. 0 1 2 3 ... 9
, ყოველი ციფრი ახალ ხაზზე (ტეგ
).
Js ამოცანა 3_9. 1 ადრე 15 .
- გამოიყენეთ მარყუჟის მრიცხველი, როგორც რიცხვების თანმიმდევრობა ამისთვის.
- დამამატებელი ცვლადისთვის გამოიყენეთ ცვლადის იდენტიფიკატორი ჯამი.
კოდის ნაწყვეტი:
იყიდება (var i = ...; ...; ...) (ჯამი = ჯამი + ...;) ...
მარყუჟის გასვლის განცხადებები შესვენებადა გააგრძელე JavaScript-ში. ოპერატორი გასვლა
break განაცხადი წყვეტს მთელი მარყუჟის სხეულის შესრულებას, ე.ი. იშლება javaScript-ის ციკლიდან.
მიუხედავად იმისა, რომ გაგრძელება განცხადება წყვეტს ციკლის მიმდინარე გამეორების შესრულებას, მაგრამ, ამავე დროს, აგრძელებს ციკლის შესრულებას შემდეგი გამეორებიდან.
განვიხილოთ შესვენების მოქმედება და გავაგრძელოთ განცხადებები მაგალითის გამოყენებით:
მაგალითი:კოდის ფრაგმენტის ალგორითმის გაანალიზება. რა იქნება ნაჩვენები?
კოდის ნაწყვეტი:
| 1 2 3 4 5 6 | for (var i = 0; i<
10
;
i++
)
{
if
(i==
4
)
continue
;
document.write
(i+
" "); თუ (i == 8) შესვენება;) |
for (var i = 0; i<10;i++)
{
if (i==4) continue;
document.write(i+"
"); თუ (i == 8) შესვენება;)
✍ გამოსავალი:
- მაგალითის მესამე ხაზი შეიცავს მდგომარეობას, რომლის გამოც ციფრი 4 არ გამოჩნდება: ოპერატორი გააგრძელეგადავა მარყუჟის შემდეგ გამეორებაზე მიმდინარე მარყუჟის დასრულების გარეშე.
- მე-5 სტრიქონში გამოდის მარყუჟი, მაგრამ ამავე დროს ნომერი 8 ნაჩვენები იქნება, რადგან გამომავალი დებულება დგება პირობის წინ (მე-4 სტრიქონში). გაიცნო შესვენება, თარჯიმანი შეწყვეტს ციკლს.
- რომ. ეკრანი გამოჩნდება: 0 1 2 3 5 6 7 8 - ყოველი ციფრი ახალ ხაზზე.
Js ამოცანა 3_10.გამოიტანეთ ყველა მთელი რიცხვის ჯამი საიდან 1 ადრე 15 , მთლიანი რაოდენობის გამოკლებით 5 და 7 .
გასვლის განცხადება
javasctipt ენა უზრუნველყოფს პროგრამის კოდიდან გასასვლელ ოპერატორს - გასვლის ოპერატორს.
ყველაზე ხშირად, ოპერატორი გამოიყენება მომხმარებლის შეყვანის შეცდომის აღმოსაფხვრელად.
განვიხილოთ მაგალითი:
მაგალითი 6:სთხოვეთ მომხმარებელს შეიყვანოს ნომერი. თუ ნომერი არ არის შეყვანილი, აჩვენეთ შეტყობინება "თქვენ გჭირდებათ ნომერი!"და შეაჩერე პროგრამა.
✍ გამოსავალი:
- ცვლადის ინიცირება ნომერიმომხმარებლის მიერ მოდალში შეყვანილი მნიშვნელობა:
- სტრიქონის მთელ რიცხვად გადაქცევისთვის parseInt ფუნქციის გამოყენებით, შეამოწმეთ არის თუ არა შეყვანილი მნიშვნელობა რიცხვი:
- შეამოწმეთ ცვლადის მნიშვნელობა ნომერი isNaN ფუნქციის გამოყენებით:
- ავტორი "ტყუილის" წესიმოაწყეთ ცვლადის მნიშვნელობის შემოწმება x... თუ მნიშვნელობა არ არის რიცხვითი, დაბეჭდეთ შესაბამისი შენიშვნა და შეწყვიტეთ პროგრამა:
- პროგრამის გასაგრძელებლად (თუ შეყვანილი მნიშვნელობა იყო რიცხვი), აჩვენეთ შემდეგი ფანჯარა შეყვანის მოთხოვნით:
- შეამოწმეთ სკრიპტი ბრაუზერში.
var ნომერი = მოთხოვნა ("შეიყვანეთ ნომერი");
ნომერი = parseInt (რიცხვი); // დააბრუნებს NaN - არა რიცხვს
თუ რიცხვი არ არის შეყვანილი, ფუნქცია დააბრუნებს მნიშვნელობას NaN (ინგლისურიდან. არა რიცხვი- არა რიცხვი).
x = isNaN (რიცხვი); // დააბრუნებს true თუ მნიშვნელობა არ არის რიცხვითი
IsNaN ფუნქცია აბრუნებს მნიშვნელობას მართალიაიმ შემთხვევაში, თუ ცვლადი არ არის რიცხვი
თუ (x) (გაფრთხილება ("ნომრა საჭიროა!"); გასვლა; // პროგრამიდან გასვლა)
alert ("შეიყვანეთ მეორე ნომერი"); // თუ შეიყვანთ არა რიცხვს, განცხადება არ შესრულდება
კითხვები თვითკონტროლისთვის:
- ჩამოთვალეთ მარყუჟის სამი პარამეტრი ამისთვისდა აუხსენით მათი მიზანი.
- რა ოპერატორებია გათვლილი მარყუჟიდან გასასვლელად და მის შეწყვეტაზე? მიეცით მაგალითები მათი გამოყენების შესახებ.
- რისთვის არის ოპერატორი გასასვლელი?
შესაძლებელია თუ არა რამდენიმე მრიცხველის ქონა ერთ FOR-ში?
საინტერესო მუშაობა for loop-ით შესაძლებელია გამოყენებით ციკლში ერთდროულად ორი მრიცხველი.
განვიხილოთ მაგალითი:
მაგალითი 7:სკრიპტის გამოყენებით დაბეჭდეთ შემდეგი ცვლადის მნიშვნელობის წყვილი სამ სტრიქონში: i = 0 j = 2 i = 1 j = 3 i = 2 j = 4
✍ გამოსავალი:
- for მარყუჟში მოაწყეთ ორი მრიცხველი: მრიცხველი i მიმდევრობის გამოსატანად 0 1 2 , მრიცხველი j მიმდევრობის გამოსატანად 2 3 4 :
- თითოეულ სტრიქონზე გამოსასვლელად გამოიყენეთ ტეგი
:
| 1 2 3 | (i = 0, j = 2; i< 10 , j< 5 ; i++, j++ ) { } |
(i = 0, j = 2; i<10, j<5; i++, j++) { }
for loop-ის სამი პარამეტრიდან თითოეულს ახლა აქვს ორი მნიშვნელობა, რომლებიც ჩამოთვლილია მძიმით გამოყოფილი(მაგალითად, პირველი პარამეტრი ორი მნიშვნელობით: i = 0, j = 2). თავად პარამეტრები ჩამოთვლილია მძიმით გამოყოფილი(;).
| 1 2 3 4 | (i = 0, j = 2; i<
10
,
j<
5
;
i++,
j++
)
{
document.write
(" i = ", i," j = ", j);) |
(i = 0, j = 2; i<10, j<5; i++, j++)
{
document.write("
i = ", i," j = ", j);)
On-the-fly გვერდის თაობა: როგორ არის?
შემდეგი დავალების შესრულებამდე, განიხილეთ მაგალითი. HTML გვერდის დინამიურად აშენება Javascript-ის გამოყენებით.
მაგალითი 8:
- აუცილებელია ვებ-გვერდზე დინამიურად გენერირება ბურთულებიანი და დანომრილი სიები მომხმარებლის მიერ შეყვანილი მონაცემების მიხედვით: შესთავაზეთ მომხმარებელს შეყვანა ჩამონათვალი(დანომრილი (ნომერი 1) ან ეტიკეტირებული (ნომერი 2)) და შემდეგ სიის ელემენტების რაოდენობა.
- პასუხიდან გამომდინარე, აჩვენეთ ბურთულებიანი ან დანომრილი სიის ტეგები ნივთების საჭირო რაოდენობით.
- თუ არარსებული სიის ტიპი შეყვანილია, მაშინ აჩვენეთ შეტყობინება "გთხოვთ შეიყვანოთ სწორი ტიპი!"და გამოდით პროგრამიდან ().
გავიხსენოთ ტეგები:
დანომრილი სიის ტეგები:
| <ol> <li> <li> <li> </ ol> |
ბურთულებიანი სიის ტეგები:
var listType = მოთხოვნა ("Enter" 1 "ბუტებიანი სიისთვის", 2 "დანომრილი სიისთვის");
- , მონიშნულისთვის (ნომერი 2) - tag
- ... თუ შეყვანილია სხვა მნიშვნელობა, დაბეჭდეთ შენიშვნა და დაასრულეთ პროგრამა:
- ცვლადის ინიცირება კოლვომომხმარებლის მიერ მოდალში შეყვანილი მნიშვნელობა:
- სტრიქონის მნიშვნელობის ციფრულ მნიშვნელობად გადასაყვანად გამოიყენეთ parseInt ფუნქცია:
- ვინაიდან სიები დახურულია შესაბამისი ტეგებით, სიის ტიპის მიხედვით, დაბეჭდეთ დახურვის ტეგები:
- ") else (გაფრთხილება (" შეიყვანეთ სწორი ტიპი "); გასვლა;)
var kolvo = მოთხოვნა ("შეიყვანეთ ნივთების რაოდენობა");
for (var i = 1; i<=kolvo; i++) document.write("");
| if (listType == "1") document.write ("") else if (listType ==" 2 ") document.write ("" ) ; |
if (listType == "1") document.write ("
Js ამოცანა 3_11.
დაწერეთ სკრიპტი, რომელიც აჩვენებს ტეგებს შეყვანა(კონტროლი) სხვადასხვა ტიპის, შეყვანილი ციფრის მიხედვით:
1
- ტექსტის ველი,
2
- ღილაკი,
3
- რადიო(გადამრთველი).
ასევე უნდა მოითხოვოს ნაჩვენები ტეგების რაოდენობა.
გავიხსენოთ ტეგები:
1-ისთვის - ტექსტური ველი: 2-ისთვის - ღილაკი: 3 - რადიოსთვის:
გამომავალი მაგალითი:
Js ამოცანა 3_12.დახაზეთ 9x9 ჭადრაკის დაფა ჯავასკრიპტის გამოყენებით მარყუჟებისთვის. "დახაზეთ" დაფა უნდა იყოს html ტეგები ცხრილისთვის:
გავიხსენოთ ტეგები:
| <ცხრილის საზღვარი = "1" სიგანე = "30%"> <tr> <td>-</ td> | -</ td> </ tr> </ მაგიდა> |
| - | - |
- 9 ხაზის დასახაზად, თქვენ უნდა მოაწყოთ გარე for loop მრიცხველით i.
- თითოეულ სტრიქონში 9 უჯრედის დასახატად, თქვენ უნდა მოაწყოთ შიდა (ბუდე) მარყუჟი მრიცხველით j.
- გამოიყენეთ document.write მეთოდი უჯრედებისა და ხაზების ტეგების გამოსატანად.
შედეგი:
დამატებით:
- დაბეჭდეთ გამრავლების ცხრილი ცხრილის უჯრედებში ციკლის მრიცხველების გამოყენებით (i და j).
- აჩვენეთ პირველი მწკრივი და პირველი სვეტი წითელი ფონით (ცხრილის უჯრედის ატრიბუტი bgcolor):
<td bgcolor = "წითელი">-</ td> -
შედეგი:
კითხვები თვითკონტროლისთვის:
- ახსენით რას ნიშნავს გვერდის დინამიური შექმნა?
- რომელია ყველაზე ხშირად გამოყენებული ენის კონსტრუქცია გვერდის დინამიური შესაქმნელად?
javaScript ენის ციკლური განცხადებები - while
while განაცხადის სინტაქსია:
ხოლო (პირობა) (//..განცხადებების ბლოკი ..);
მაგალითი:ჩვენება ძალაუფლება ორი მდე 1000 (2, 4, 8 ... 512). გამოიყენეთ alert () მეთოდი
✍ გამოსავალი:
- სცენარის ჩამონათვალი:
- შეამოწმეთ შედეგი ბრაუზერში.
| 1 2 3 4 5 | var a = 1; ხოლო (ა< 1000 ) { a*= 2 ; alert(a) ; } |
var a = 1; ხოლო (ა< 1000){ a*=2; alert(a); }
a * = 2 → ნაერთის მინიჭების ოპერაცია გამოიყენება: დავალებასთან შერწყმული პროდუქტი, ე.ი. იგივეა, რაც a = a * 2
როგორ მუშაობს შესვენება და გაგრძელების განცხადებები გარკვეული პერიოდის განმავლობაში?
მაგალითი:
| var a = 1; ხოლო (ა< 1000 ) { a*= 2 ; if (a== 64 ) continue ; if (a== 256 ) break ; alert(a) ; } |
var a = 1; ხოლო (ა< 1000){ a*=2; if (a==64) continue; if (a==256) break; alert(a); }
სიმძლავრე ორი იქნება გამომავალი 128 ინკლუზიური და ღირებულება 64 გამოტოვებული იქნება. იმათ. დიალოგურ ფანჯრებში ვნახავთ: 2 4 8 16 32 128
Js ამოცანა 3_13.რა მნიშვნელობებს აჩვენებს შემდეგი კოდის ნაწყვეტი?
var მრიცხველი = 5; ხოლო (მრიცხველი< 10) { counter++; document.write("Counter " + counter); break; document.write("Эта строка не выполнится."); }
Js ამოცანა 3_14.დაწერეთ ერექციის კოდი NSხარისხით წდროის მარყუჟის გამოყენებით. მოითხოვეთ ცვლადის მნიშვნელობები და გამოიტანეთ შედეგი გაფრთხილების გამოყენებით ().
შეავსეთ კოდი:
| 1 2 3 4 5 6 7 8 9 | var x = ...; var y = ...; მრიცხველი = 1; ჩისლო = x; ხოლო (...) (ჩისლო = x * ...; მრიცხველი = ...;) გაფრთხილება (ჩისლო); |
var x = ...; var y = ...; მრიცხველი = 1; ჩისლო = x; ხოლო (...) (ჩისლო = x * ...; მრიცხველი = ...;) გაფრთხილება (ჩისლო);
A გამოასწორეთ შეცდომა პროგრამაში, რომელიც შექმნილია რიცხვის ფაქტორების მოსაძებნად:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | var counter = მოთხოვნა ("შეიყვანეთ ნომერი"); var factorial = 1; დოკუმენტი.დაწერე ( "რიცხვის ფაქტორიალი:"+ მრიცხველი + "! ="); do (თუ (მრიცხველი == 0) (ფაქტორული = 1; შესვენება;) ფაქტორული = ფაქტორული / მრიცხველი; მრიცხველი = მრიცხველი + 1;) ხოლო (მრიცხველი> 0); დოკუმენტი.ჩაწერა (ფაქტორული); |
var counter = მოთხოვნა ("შეიყვანეთ ნომერი"); var factorial = 1; document.write ("Number factorial:" + counter + "! ="); do (თუ (მრიცხველი == 0) (ფაქტორული = 1; შესვენება;) ფაქტორული = ფაქტორული / მრიცხველი; მრიცხველი = მრიცხველი + 1;) ხოლო (მრიცხველი> 0); დოკუმენტი.ჩაწერა (ფაქტორული);
Js ამოცანა 3_16.შეცვალეთ პროგრამა მომხმარებლის შეყვანისთვის:
მოითხოვეთ მომხმარებლის სახელი მანამ, სანამ მომხმარებელი რეალურად არ შეიყვანს სახელს (ანუ ველი რეალურად შეივსება და გაუქმების ღილაკი არ იქნება დაჭერილი). როდესაც სახელი შეიყვანება, მაშინ გამომავალი "გამარჯობა სახელი!"... დოკუმენტი.
როგორ მოვძებნოთ შეცდომები Javascript-ში?
ზოგიერთ შემთხვევაში, გვერდზე არსებული კოდი რატომღაც არ მუშაობს. სად უნდა ვეძებოთ შეცდომა? ასეთ შემთხვევებში შეგიძლიათ გამოიყენოთ try..catch განცხადება.
ბრძანება try..catch ცდილობს შეასრულოს კოდის ნაწილი და თუ კოდში არის შეცდომა, შესაძლებელია შეცდომის ჩვენება ეკრანზე.
შეცდომა ინახება e.message ობიექტში.
განვიხილოთ ოპერატორის მუშაობა მაგალითის გამოყენებით:
მაგალითი:დაწერეთ განცხადება პროგრამაში შეცდომით. შეამოწმეთ შეცდომა საეჭვო შეცდომის კოდში: თუ კოდში არის შეცდომა, აჩვენეთ შეტყობინება "შეცდომის დამუშავება: შეცდომის სახელი"... მცდარი ოპერატორის შემოწმების შემდეგ, მიუხედავად იმისა, არის თუ არა შეცდომა კოდში, გაუშვით შეტყობინება "დამთავრებული მოქმედებები"
✍ გამოსავალი:
- როგორც შეცდომის მქონე შეტყობინება, ჩვენ გამოვიყენებთ prompt () მეთოდს, რომელიც დაწერილია შეცდომით - promt ()... ჩასვით შეცდომის შეტყობინება ცდის ბლოკში:
- შეცდომის შეტყობინება უნდა განთავსდეს დაჭერის ბლოკში:
- განათავსეთ საბოლოო შეტყობინება, რომელიც უნდა იყოს ნაჩვენები, მიუხედავად იმისა, არის თუ არა შეცდომა კოდში, საბოლოო ბლოკში:
გაფრთხილება ("ადრე"); try (promt ("შეიყვანეთ ნომერი"); // ოპერატორი შეცდომით)
სცადე ინგლისურიდან. - "სცადე", ამგვარად, კოდის ფრაგმენტის წინ ვდებთ try ინსტრუქციას, რომელიც შეიძლება შეიცავდეს შეცდომას (ჩვენს შემთხვევაში, ნამდვილად არის შეცდომა).
| 6 7 8 9 | დაჭერა (ე) (გაფრთხილება ( "შეცდომის დამუშავება:"+ ე.მესიჯი); ) |
catch (e) (გაფრთხილება ("შეცდომის დამუშავება:" + e.გზავნილი);)
თუ ნამდვილად არის შეცდომა, მაშინ catch განცხადება ინახავს ამ შეცდომას e ობიექტში. მოგვიანებით ის შეიძლება გამოჩნდეს e.message დიალოგურ ფანჯარაში.
ბოლოს (გაფრთხილება ("დასრულებული მოქმედებები");) alert ("შემდეგ");
თუ შეცდომაა, მაშინ თარჯიმანი, ჩვენს მაგალითში გამოტანის შემდეგ, გააგრძელებს დაჭერის ბლოკის შესრულებას, შემდეგ კი ბოლოს (ინგლისურიდან "დასრულება", "საბოლოოდ"), რომელიც ყოველთვის შესრულდება, მიუხედავად იმისა, თუ არა. იყო შეცდომა თუ არა. მაშინაც კი, თუ დაჭერის ბლოკში იყო შეცდომა.
Მნიშვნელოვანი:საბოლოო ბლოკი არჩევითია მშენებლობაში.
ჯს დავალება 3_17.მიჰყევით ზემოთ მოცემულ მაგალითს შემდეგი ცვლილებებით:
Შემაჯამებელი:
გაკვეთილზე განიხილებოდა შემდეგი javascript ენის ოპერატორები და კონსტრუქციები:
Javascript პირობითი განცხადებები:
მარყუჟის ოპერატორები:
დასკვნითი დავალება Js 3_18.
შექმენით თამაში ორისთვის:
- პროგრამა სთხოვს პირველ მოთამაშეს შეიყვანოს ნომერი საიდან 1 ადრე 100 (მეორე მოთამაშე ვერ ხედავს შეყვანილ ნომერს). შემდეგ მეორე მოთამაშეს სთხოვენ გამოიცნოს შეყვანილი ნომერი. შეტყობინება გამოჩნდება პასუხად "რამდენიმე"ან "ბევრი"შეყვანილი პასუხის მიხედვით. თუ მოთამაშე სწორად გამოიცნობს, მილოცვა გამოჩნდება. თუ ის არასწორად გამოიცნობს, თამაში გრძელდება (სანამ რიცხვი რეალურად გამოიცნობს).
- გამოთვალეთ მცდელობების რაოდენობა და დააბრუნეთ შედეგი, როდესაც რიცხვი გამოიცნობთ.
კითხვები თვითკონტროლისთვის:
- როდის არის მიზანშეწონილი For In მარყუჟის გამოყენება? რა არის მისი გამოყენების მაგალითი.
- რა არის ცდის დაჭერის მიზანი?
- ახსენით თითოეული try..catch განცხადების ბლოკის მიზანი.
ყოველდღიურ ცხოვრებაში ხშირად საჭირო ხდება რაიმე სახის გადაწყვეტილების მიღება, რაღაც მდგომარეობიდან გამომდინარე. მაგალითად, თუ შაბათ-კვირას თბილი ამინდია, მაშინ ზღვაზე წავალთ, თორემ, თუ მოღრუბლულია, სახლში დავჯდებით.
ეს ასევე ძალიან გავრცელებულია პროგრამირებაში. ამისათვის არსებობს ორი პირობითი განცხადება, ეს არის if-else და switch-case... ამ სტატიაში გეტყვით if-else დებულებას, ხოლო შემდეგ სტატიაში გადართვის შემთხვევაში.
If-else პირობითი განცხადების სინტაქსიშემდეგი:
თუ პირობა არის true, მაშინ კოდი if ბლოკიდან შესრულებულია, წინააღმდეგ შემთხვევაში, თუ პირობა არის false, მაშინ სხვა ბლოკის კოდი შესრულებულია.
უკეთ გასაგებად ავიღოთ ასეთი მარტივი მაგალითი, გვაქვს გარკვეული თანხა და გვინდა ვიყიდოთ მანქანა და აქ მაშინვე ჩნდება ასეთი მდგომარეობა, თუ საკმარისი ფული გვაქვს, მაშინ შეგვიძლია ვიყიდოთ ეს მანქანა, თორემ ვერ.
ვარ ფული = 35000; // ვთქვათ გვაქვს 35000 ევრო // მანქანა რისი ყიდვა გვინდა 50000 ევრო ღირს. და ასეთი მდგომარეობა ჩნდება, თუ (ფული> 50000) (document.write ("ჩვენ შეგვიძლია ვიყიდოთ მანქანა");) სხვა (document.write ("არ არის საკმარისი ფული მანქანის საყიდლად");)
ჩვენ ვინახავთ დოკუმენტს, ვხსნით მას ბრაუზერში და ვხედავთ, რომ შემდეგი შეტყობინება გამოჩნდება გვერდზე "არ არის საკმარისი თანხა მანქანის შესაძენად". თუ გვქონდა 50000 ევროზე მეტი, მაშინ კოდი if ბლოკიდან შესრულდებოდა. ზუსტად 50 000 ევრო რომ გვქონდეს, მაშინ ასევე ვერ ვიყიდით მანქანას, რადგან 50 000 არ არის 50 000-ზე მეტი. იმისთვის, რომ პირობა იყოს ჭეშმარიტი ამ შემთხვევაში, თქვენ უნდა დაწეროთ მეტი ან ტოლი ნიშანი ( > =)...
კომენტარი! ლოგიკური ოპერაცია ტოლი იწერება ორი ტოლობის ნიშნით (==)... ასევე არსებობს ლოგიკური ოპერაცია ნაკლები ან ტოლი (
ხვეული ბრეკეტების გამოყენებით
თუ მხოლოდ ერთი ოპერატორია, მაშინ ხვეული ბრეკეტები არჩევითია, თუ ბლოკში ერთზე მეტი ოპერატორია, მაშინ საჭიროა ხვეული ბრეკეტები.
ზემოთ მოყვანილი მაგალითი კარგად იმუშავებს ხვეული ბრეკეტების გარეშე, რადგან ორივე ბლოკი შეიცავს მხოლოდ ერთ განცხადებას.
ნებისმიერი ლოგიკური ოპერაცია შეიძლება ჩაიწეროს if-ში.მარტივია თუ რთული. თქვენ ასევე შეგიძლიათ გამოიყენოთ AND (&&) და OR (||) ოპერატორები.
კომენტარი! სხვა ბლოკის არსებობა არჩევითია.
მაგალითად, თუ a უდრის b-ს, ხოლო c უდრის d-ს, მაშინ ჩვენ ვაჩვენებთ შესაბამის შეტყობინებას, წინააღმდეგ შემთხვევაში, თუ სხვა ბლოკი არ არის, უბრალოდ გადავდივართ შემდეგ სტრიქონზე.
Var a = 4, b = 4, c = 8, d = 8; if ((a == b) && (c == d)) document.write ("a უდრის b და c უდრის d"); document.write ("კოდის შემდეგი ხაზი");
განცხადება თუ - სხვა თუ - სხვა
if ბლოკის შემდეგ შეიძლება მოჰყვეს ერთი ან მეტი if ბლოკი და ბოლოს არის else ბლოკი. ეს სასარგებლოა, როდესაც გჭირდებათ ერთზე მეტი პირობის გამოყენება.
უკეთ გასაგებად ავიღოთ მაგალითი ყოველდღიური ცხოვრებიდან. მაგალითად, გვაქვს მაღაზიების გარკვეული რაოდენობა. თუ ოთახში გვაქვს მხოლოდ ერთი გამოსასვლელი, მაშინ შეგვიძლია შევაერთოთ მხოლოდ ერთი მოწყობილობა, თუ არის ორი სოკეტი, მაშინ შეგვიძლია დავაკავშიროთ ორი მოწყობილობა, ხოლო თუ მეტია, მაშინ ყველა მოწყობილობა შეგვიძლია დავუკავშიროთ სახლიდან ელექტრო ქსელში.
ახლა გადავიდეთ პროგრამირებაზე.
Var socket = 2; // სოკეტების რაოდენობა სახლში თუ (სოკეტი == 1) დოკუმენტი.ჩაწერეთ ("
ჩვენ შეგვიძლია მხოლოდ ერთი მოწყობილობის დაკავშირება
"); სხვა შემთხვევაში, თუ (სოკეტი == 2) (დოკუმენტი. ჩაწერეთ ("ჩვენ შეგვიძლია მხოლოდ ორი მოწყობილობის დაკავშირება
"); დოკუმენტი. ჩაწერეთ ("მაგალითად ტელევიზორი და ლეპტოპი
");) else (დოკუმენტი. ჩაწერეთ ("ჩვენ შეგვიძლია დავუკავშიროთ ყველა მოწყობილობა სახლიდან ელექტრო ქსელთან
"); }სოკეტის ცვლადის მნიშვნელობიდან გამომდინარე, ამოქმედდება კოდის ესა თუ ის ბლოკი. როგორც უკვე მიხვდით, თუ სოკეტი 1-ის ტოლია, მაშინ კოდის პირველი ბლოკი იმუშავებს. თუ სოკეტი არის 2, მაშინ კოდის მეორე ბლოკი გააქტიურდება, ხოლო თუ სოკეტს აქვს რაიმე სხვა მნიშვნელობა (თუნდაც უარყოფითი რიცხვი), მაშინ კოდის მესამე ბლოკი გააქტიურდება.
შემოკლებული აღნიშვნა სხვა შემთხვევაში
შემოკლებული აღნიშვნა შეიძლება გამოყენებულ იქნას იმ შემთხვევაში, როდესაც, გარკვეული მდგომარეობიდან გამომდინარე, ცვლადს შეუძლია მიიღოს ერთი ან სხვა მნიშვნელობა.
მაგალითად, თუ a ცვლადის მნიშვნელობა მეტია b ცვლადის მნიშვნელობაზე, მაშინ x ცვლადში ვწერთ შემდეგ შეტყობინებას, "ცვლადი a მეტია b ცვლადზე", წინააღმდეგ შემთხვევაში ვწერთ, რომ " ცვლადი a ნაკლებია b ცვლადზე".
Var a = 50, b = 100, x; x = (a> b)? "
ცვლადი ა მეტიცვლადი ბ
" : "ცვლადი ა უფრო პატარაცვლადი ბ
"; // ამობეჭდეთ მიღებული შედეგი დოკუმენტი.write (x);ეს არის ყველაფერი, რის შესახებაც მინდოდა მეთქვა ამ სტატიაში. if-else პირობითი განცხადება უფრო მეტად გამოიყენება, ვიდრე ყველა სკრიპტში, ამიტომ ძალიან მნიშვნელოვანია მისი ცოდნა და გაგება. შემდეგ სტატიაში მე მოგიყვებით კიდევ ერთ პირობითი გადართვის შემთხვევაში.
ამ მაგალითში, ჩვენ პირველად ვაცხადებთ ოთხ ცვლადს var საკვანძო სიტყვის გამოყენებით და დაუყოვნებლივ მივანიჭებთ მათ რიცხვით მნიშვნელობებს. შემდეგი, ზრდისა და შემცირების ოპერატორების გამოყენებით, ჩვენ ვცვლით რიცხვების მნიშვნელობებს. ინფორმაცია ნაჩვენებია ფუნქციის გამოყენებით ექო(იხილეთ სტატია ""). ობიექტის სახელი რომ კიდევ ერთხელ არ დამეწერა, კონსტრუქცია გამოვიყენე ერთად ().
ლოგიკური ოპერატორები
მდგომარეობის შემოწმებისას გამოიყენება ლოგიკური ოპერატორები, რომ არ განმეორდეს, გავაკეთებ შემოკლებას: მარცხენა ოპერანდი არის L.O., ხოლო მარჯვენა ოპერანდი არის P.O.
- && - ლოგიკური "AND"
- || - "ან"
- ! - "არა"
- > - ლ.ო. მეტი P.O.
- > = - ლ.ო. მეტია ან ტოლია P.O.
- < - Л.О. меньше П.О.
- <= - Л.О. меньше или равен П.О.
- == - ლ.ო. ტოლია P.O.
- ! = - ლ.ო. არ უტოლდება P.O.
- | = - ლ.ო. თავის ტოლი OR P.O.
- & = - ლ.ო. ტოლი ჩემი და P.O.
- ^ = - ექსკლუზივი ან
ახლა განიხილეთ შემდეგი სკრიპტი:
| //***************************************** // ლოგიკური ოპერაციები// logik_if_else.js //***************************************** var a = 10, b = 100, WshShell, სათაური, msg1, msg2, msg3, msg4, vbInformation = 64; // WScript.Shell კლასის ინსტანციის შექმნა WshShell = WScript.CreateObject ("WScript.Shell"); სათაური = "IF ELSE JS პირობით განცხადებასთან მუშაობა"; (WshShell)-ით (თუ (a> = 5 && a<= 100 ) //истина msg1 = "TRUE" ; else msg1 = "FALSE" ; Popup (msg1, 5 , title, vbInformation) ; if (a>= 5 || b == 100) // true msg2 = "TRUE"; else msg2 = "FALSE"; ამომხტარი ფანჯარა (msg2, 5, სათაური, vbInformation); // პირობითი განცხადება js if else if (! ა) // false msg3 = "TRUE"; else msg3 = "FALSE"; ამომხტარი ფანჯარა (msg3, 5, სათაური, vbInformation); if (a & = 100) // false msg4 = "TRUE"; else msg4 = "FALSE"; ამომხტარი ფანჯარა (msg4, 5, სათაური, vbInformation); ) |
როგორც წინა სკრიპტში, აქაც გამოვიყენე კონსტრუქცია თანპროგრამის კოდის შესამცირებლად. თუმცა, ინფორმაციის ჩვენებისთვის, ჩვენ გამოვიყენეთ ფუნქცია ამომხტარი ფანჯარა(იხილეთ სტატია ""). შედეგად, დიალოგური ფანჯრები ავტომატურად დაიხურება რამდენიმე წამის შემდეგ. გთხოვთ გაითვალისწინოთ, რომ ამ მაგალითში ჩვენ არ გამოგვიყენებია ხვეული ბრეკეტები. js if პირობით განცხადებაში, ისინი აქტუალურია მხოლოდ მაშინ, როდესაც გჭირდებათ კოდის ერთზე მეტი ხაზის შესრულება, მაგრამ რამდენიმე.
და ბოლოს, მოდით შევხედოთ პრაქტიკულ მაგალითს, როგორიცაა კვადრატული განტოლების ამოხსნა:
| // კვადრატული განტოლების ამოხსნა// uravnenije_if_else.js // *********************************************************** var a, b, c, d, x, x1, x2; // ცვლადების გამოცხადება a = - 2; b = 6; c = 20; // დისკრიმინანტის ძიება d = მათემატიკა .pow (b, 2) - 4 * a * c; თუ (d == 0) (x = b / (2 * a); msg = "განტოლებას აქვს ერთი ამონახსნი, x არის ზუსტად"+ x) სხვა (თუ (d> 0) (x1 = (- b + მათემატიკა .sqrt (d)) / (2 * a); x2 = (- b- მათემატიკა .sqrt (d)) / (2 * a );msg = "განტოლებას აქვს ორი ამონახსნი \ n x1 ზუსტად"+ x1 +" \ n x2 ზუსტად "+ x2; // პირობითი განცხადება if else js) else msg = "არ არის გამოსავალი"; ) WScript.Echo (msg); |
