დინამიური ტიპის იდენტიფიკაცია

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

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

არის ოპერატორი

ობიექტის კონკრეტული ტიპი შეიძლება განისაზღვროს is ოპერატორის გამოყენებით. ქვემოთ მოცემულია მისი ზოგადი ფორმა:

გამოხატულება არის ტიპი

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

ქვემოთ მოცემულია is ოპერატორის გამოყენების მაგალითი:

სისტემის გამოყენება; namespace ConsoleApplication1 ( class Add ( ) class Sum: Add ( ) class Program ( static void Main() ( Add a = new Add(); Sum s = new Sum(); if (a არის Add) Console.WriteLine("ცვლადი a არის Add"); if (s არის Sum) Console.WriteLine("ცვლადის ტიპი s მემკვიდრეობით მიიღება Add კლასიდან"); Console.ReadLine(); ) ) )

ოპერატორი როგორც

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

გამოხატვა, როგორც ტიპი

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

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

სისტემის გამოყენება; namespace ConsoleApplication1 ( class Add ( ) class Sum: Add ( ) class Program ( static void Main() ( Add a = new Add(); Sum s = new Sum(); // Type casting a = s როგორც Add; თუ (a != null) Console.WriteLine("Conversion was წარმატებული");

ამ პროგრამის შესრულების შედეგი იქნება წარმატებული კონვერტაცია.

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

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

ცვლადის ტიპის შემოწმება

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

მე დავწერე ეს მაგალითი, რათა ნათლად მეჩვენებინა, თუ რატომ არ არის ტიპი ყოველთვის სწორი არჩევანი.

Var _comparison = ( string: "string", int: 99, float: 13.555, object: (hello: "hello"), array: new Array(1, 2, 3) ); // აბრუნებს მასივს ობიექტის კლავიშებით var _objKeys = Object.keys(_comparison); for(var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

კოდის შესრულების შედეგი:

სტრიქონი ნომერი ნომერი ობიექტი ობიექტი

მართალია? - რა თქმა უნდა, არა. ორი პრობლემაა. თითოეული მათგანი დეტალურად იქნება აღწერილი და შემოთავაზებული გამოსავალი.

პირველი პრობლემა: მოძრავი ნომერი, გამომავალი რიცხვი

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

Var_floatNumber = 9.22; var _notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); ფუნქცია არისFloat(n)( დააბრუნებს ნომერი(n) === n && n % 1 !== 0; )

isFloat() ფუნქცია ამოწმებს, რომ ყველა მნიშვნელობა არის მცურავი წერტილი. პირველ რიგში, მოწმდება ტოლია თუ არა ცვლადი ნრიცხვი (ნომერ(ნ) === ნ) და თუ კი, მაშინ კეთდება სხვა შემოწმება ნაშთით გაყოფისთვის და თუ ნაშთია, მაშინ ლოგიკური ( მართალიაან ყალბი) შედეგი (n % 1 !== 0).

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

მეორე პრობლემა: მასივი განისაზღვრა როგორც ობიექტი

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

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

პირველი ვარიანტი (კარგი ვარიანტი). ჩვენ ვამოწმებთ, ეკუთვნის თუ არა მონაცემები მასივს instanceof() გამოყენებით.

Var data = new Array("hello", "world"); var isArr = მასივის მონაცემთა მაგალითი;

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

Var data = new Array("hello", "world"); var isArr = Array.isArray(data);

მესამე ვარიანტი (საუკეთესო, მაგრამ გრძელი). მოხერხებულობისთვის, შეგიძლიათ ეს მეთოდი ფუნქციად აქციოთ. ჩვენ ვაკეთებთ ობიექტის გამოყენებას. თუ Object.prototype.toString.call(data)-ის შედეგი არ არის ტოლი, მაშინ ცვლადი არ არის მასივი ().

Var data = new Array("hello", "world"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);

ბოლო შედეგი მოხერხებულობის ფუნქციის სახით:

ფუნქცია isArray(data) (დაბრუნება Object.prototype.toString.call(data) == "" )

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

შემდგომი სიტყვა

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

თუ ჯერ კიდევ გაქვთ რაიმე შეკითხვები, დაწერეთ ისინი ქვემოთ ამ ჩანაწერში. სიამოვნებით დაგეხმარები.

ოპერატორი ტიპისაბრუნებს სტრიქონს, რომელიც მიუთითებს ოპერანდის ტიპზე.

სინტაქსი

ოპერანდი მიჰყვება ოპერატორის ტიპს:

ტიპი ოპერანდი

ოფციები

ოპერანდიარის გამონათქვამი, რომელიც წარმოადგენს ობიექტს ან პრიმიტივს, რომლის ტიპი უნდა დაბრუნდეს.

აღწერა

შემდეგი ცხრილი ჩამოთვლის typeof-ის შესაძლო დაბრუნების მნიშვნელობებს. დამატებითი ინფორმაცია ტიპებისა და პრიმიტივების შესახებ შეგიძლიათ იხილოთ გვერდზე.

მაგალითები

// Numbers typeof 37 === "number"; ტიპი 3.14 === "ნომერი"; typeof(42) === "რიცხვი"; მათემატიკის ტიპი.LN2 === "რიცხვი"; უსასრულობის ტიპი === "რიცხვი"; NaN ტიპის === "რიცხვი"; // მიუხედავად იმისა, რომ ეს არის "Not-A-Number" ტიპის ნომერი (1) === "number"; // არასოდეს გამოიყენოთ ეს ჩანაწერი! // სტრიქონების ტიპი "" === "სტრიქონი"; ტიპი "bla" === "სტრიქონი"; ტიპი "1" === "სტრიქონი"; // გაითვალისწინეთ, რომ სტრიქონის შიგნით რიცხვი კვლავ არის სტრიქონის ტიპის ტიპის (ტიპი 1) === "სტრიქონი"; // typeof ყოველთვის დააბრუნებს სტრიქონს ამ შემთხვევაში typeof String("abc") === "string"; // არასოდეს გამოიყენოთ ეს ჩანაწერი! // Booleans typeof true === "ლოგიკური"; typeof false === "ლოგიკური"; ტიპი ლოგიკური (true) === "ლოგიკური"; // არასოდეს გამოიყენოთ ეს ჩანაწერი! // Symbols typeof Symbol() === "symbol" typeof Symbol("foo") === "symbol" type of Symbol.iterator === "symbol" // Undefined typeof undefined === "გაუზუსტებელი"; typeof deklaratedButUndefinedVariable === "დაუზუსტებელი"; typeof undeclaredVariable === "undefined"; // ობიექტების ტიპი (a: 1) === "ობიექტი"; // გამოიყენეთ Array.isArray ან Object.prototype.toString.call // განასხვავოთ ჩვეულებრივი ობიექტები და მასივები typeof === "ობიექტი"; typeof new Date() === "ობიექტი"; // რასაც მოჰყვება იწვევს შეცდომებს და პრობლემებს. არ გამოიყენოთ იგი! ახალი ლოგიკური ტიპი (true) === "ობიექტი"; ახალი ნომრის ტიპი (1) === "ობიექტი"; ახალი სტრიქონის ტიპი ("abc") === "ობიექტი"; // ფუნქციები typeof function() () === "function"; კლასის ტიპი C() === "ფუნქცია"; ტიპი Math.sin === "ფუნქცია";

null

// ეს განსაზღვრულია JavaScript-ის დაბადებიდან null === "ობიექტი";

JavaScript-ის პირველ განხორციელებაში მნიშვნელობები წარმოდგენილი იყო ტეგის ტიპისა და მნიშვნელობის წყვილით. ობიექტების ტეგის ტიპი იყო 0. null წარმოდგენილი იყო როგორც null მაჩვენებელი (0x00 უმეტეს პლატფორმებზე). მაშასადამე, null-ის ტეგის ტიპი null იყო, ამიტომ typeof-ის დაბრუნების მნიშვნელობა არის მოჩვენებითი. ()

შესწორება შემოთავაზებული იყო ECMAScript-ში (გამორთვის საშუალებით), მაგრამ უარყოფილია. ეს გამოიწვევს ტიპის null === "null" .

ახალი ოპერატორის გამოყენება

// ყველა კონსტრუქტორის ფუნქცია შექმნილი "new"-ით იქნება "object" ტიპის var str = new String("String"); var num = new Number(100); ტიპის ქ; // აბრუნებს "ობიექტს" ტიპის num; // აბრუნებს "ობიექტს" // მაგრამ არის გამონაკლისი Function კონსტრუქტორის var func = new Function(); ფუნქციის ტიპი; // "ფუნქციის" დაბრუნება

რეგულარული გამონათქვამები

გამოძახებადი რეგულარული გამონათქვამები იყო არასტანდარტული დამატება ზოგიერთ ბრაუზერში.

Typeof /s/ === "ფუნქცია"; // Chrome 1-12 არ შეესაბამება ECMAScript 5.1 ტიპის /s/ === "ობიექტს"; // Firefox 5+ შეესაბამება ECMAScript 5.1-ს

შეცდომები, რომლებიც დაკავშირებულია დროებით მკვდარ ზონებთან

ECMAScript 2015-მდე ოპერატორის ტიპს გარანტირებული ჰქონდა სტრიქონის დაბრუნება ნებისმიერი ოპერანდისთვის, რომლითაც გამოიძახებოდა. ეს შეიცვალა ბლოკის ფარგლების არაამწევი აწევისა და კონსტის დეკლარაციების დამატებით. ახლა, თუ ცვლადები გამოცხადებულია let-ით და const-ით და typeof გამოიძახება მათზე ცვლადის დეკლარაციის ბლოკში, მაგრამ დეკლარაციამდე, მაშინ იგზავნება ReferenceError. ქცევა განსხვავდება არადეკლარირებული ცვლადებისგან, რისთვისაც typeof დაბრუნდება "გაუზუსტებელი". ბლოკის მასშტაბის ცვლადებს აქვთ „დროებითი მკვდარი ზონა“, რომელიც გრძელდება ბლოკის დაწყებიდან ცვლადის გამოცხადებამდე. ამ ზონაში ცვლადებზე წვდომის მცდელობა გამონაკლისს ქმნის.

Typeof undeclaredVariable === "დაუზუსტებელი"; newLetVariable-ის ტიპი; მოდით newLetVariable; // ReferenceError type of newConstVariable; const newConstVariable = "გამარჯობა"; // ReferenceError

გამონაკლისები

ყველა მიმდინარე ბრაუზერში არის არასტანდარტული ჰოსტის ობიექტი document.all, რომელიც არის Undefined ტიპის.

Typeof document.all === "დაუზუსტებელი";

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

სპეციფიკაციები

სპეციფიკაცია	სტატუსი	კომენტარები
ECMAScript-ის უახლესი მონახაზი (ECMA-262)	პროექტი
ECMAScript 2015 (მე-6 გამოცემა, ECMA-262) "ოპერატორის ტიპის" განმარტება მოცემულია ამ სპეციფიკაციაში.	სტანდარტული
ECMAScript 5.1 (ECMA-262) "ოპერატორის ტიპის" განმარტება მოცემულია ამ სპეციფიკაციაში.	სტანდარტული
ECMAScript მე-3 გამოცემა (ECMA-262) "ოპერატორის ტიპის" განმარტება მოცემულია ამ სპეციფიკაციაში.	სტანდარტული
ECMAScript 1st Edition (ECMA-262) "ოპერატორის ტიპის" განმარტება მოცემულია ამ სპეციფიკაციაში.	სტანდარტული	საწყისი განმარტება. დანერგილია JavaScript 1.1-ში

ბრაუზერის თავსებადობა

განაახლეთ თავსებადობის მონაცემები GitHub-ზე

	კომპიუტერები						მობილური						სერვერი
	Chrome	ზღვარი	Firefox	Internet Explorer	ოპერა	Safari	ანდროიდის ვებ-ხედვა	Chrome Android-ისთვის	Firefox ანდროიდისთვის	ოპერა ანდროიდისთვის	Safari iOS-ზე	სამსუნგის ინტერნეტი	Node.js
ტიპის	Chrome სრული მხარდაჭერა 1	ზღვარი სრული მხარდაჭერა 12	Firefox სრული მხარდაჭერა 1	ი.ე. სრული მხარდაჭერა 3	ოპერა სრული მხარდაჭერადიახ	Safari სრული მხარდაჭერადიახ	WebView Android სრული მხარდაჭერა 1	Chrome Android სრული მხარდაჭერა 18	Firefox Android სრული მხარდაჭერა 4	ოპერა ანდროიდი სრული მხარდაჭერადიახ	Safari iOS სრული მხარდაჭერადიახ	Samsung ინტერნეტ Android სრული მხარდაჭერა 1.0	nodejs სრული მხარდაჭერადიახ

ლეგენდა

სრული მხარდაჭერასრული მხარდაჭერა

IE-ს სპეციფიკური შენიშვნები

IE 6, 7 და 8-ში ბევრი ჰოსტის ობიექტი არის ობიექტი, მაგრამ არა ფუნქციები. მაგალითად.

a = (b > 0) && (c + 1 != d); დროშა = !(სტატუსები = 0);

ცხრილი 14.5. ლოგიკური ოპერატორები

ოპერატორის აღწერა

! NOT (ლოგიკური ინვერსია)

&& და (ლოგიკური გამრავლება)

|| ან (ლოგიკური დამატება)

ცხრილი 14.6. AND და OR ოპერატორების შესრულების შედეგები

ოპერანდი 1	ოპერანდი 2

ცხრილი 14.7. NOT ოპერატორის შესრულების შედეგები

მისაღებად ოპერატორის ტიპი

აკრიფეთ get operator typeof აბრუნებს სტრიქონს, რომელიც აღწერს ოპერანდის მონაცემთა ტიპს. ოპერანდი, რომლის ტიპიც გსურთ იცოდეთ, მოთავსებულია ამ ოპერატორის შემდეგ და ჩასმულია ფრჩხილებში:

s = typeof("str");

ამ გამოთქმის შესრულების შედეგად, ცვლადი s შეიცავს სტრიქონს "სტრიქონს", რომელიც მიუთითებს სტრიქონის ტიპზე.

ყველა მნიშვნელობა, რომელსაც შეუძლია დააბრუნოს ოპერატორის ტიპი, ჩამოთვლილია ცხრილში. 14.8.

	ცხრილი 14.8. ოპერატორის ტიპის მიერ დაბრუნებული მნიშვნელობები
მონაცემთა ტიპი		დაბრუნების სტრიქონი
სიმებიანი
რიცხვითი

			ცხრილი 14.8 (ბოლო)
	მონაცემთა ტიპი	დაბრუნების სტრიქონი
	ლოგიკური

მონაცემთა ტიპის თავსებადობა და კონვერტაცია

დროა განვიხილოთ კიდევ ორი ​​მნიშვნელოვანი საკითხი: მონაცემთა ტიპის თავსებადობა და ერთი ტიპის მეორეზე გადაყვანა.

რას მიიღებთ, როცა ორ რიცხვს დაამატებთ? მართალია - კიდევ ერთი რიცხვითი მნიშვნელობა. რა მოხდება, თუ დაამატებთ რიცხვს და სტრიქონს? ძნელი სათქმელია... აქ JavaScript-ს აწყდება მონაცემთა შეუთავსებელი ტიპების პრობლემა და ცდილობს ამ ტიპების თავსებადი გახადოს ერთი მათგანის მეორეზე გადაყვანის გზით. ის ჯერ ცდილობს სტრიქონის რიცხვად გარდაქმნას და წარმატების შემთხვევაში ასრულებს დამატებას. წარუმატებლობის შემთხვევაში, რიცხვი გარდაიქმნება სტრიქონად და შედეგად მიღებული ორი სტრიქონი შეერთდება. მაგალითად, ვებ სკრიპტი სიაში 14.6 გარდაქმნის b-ის მნიშვნელობას რიცხვით მნიშვნელობად, როდესაც დაემატება a-ს; ამრიგად, c ცვლადი შეიცავს 23 მნიშვნელობას.

ჩამონათვალი 14.6

var a, b, c, d, e, f; a = 11;

b = "12"; c = a + b;

d = "JavaScript"; e = 2;

მაგრამ რადგან d ცვლადის მნიშვნელობა ვერ გადაიქცევა რიცხვად, e-ს მნიშვნელობა გადაიქცევა სტრიქონად, ხოლო შედეგი - f-ის მნიშვნელობა - გახდება ტოლი

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

ჩვენ გვაქვს მნიშვნელობები null და განუსაზღვრელი.

	ნაწილი III. ვებ გვერდის ქცევა. ვებ სკრიპტები

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

ოპერატორის უპირატესობა

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

იყოს შემდეგი გამოთქმა:

ამ შემთხვევაში, ჯერ c-ის მნიშვნელობა დაემატება b ცვლადის მნიშვნელობას, შემდეგ კი 10 გამოკლდება ჯამს ამ გამოსახულების ოპერატორებს აქვთ იგივე პრიორიტეტი და ამიტომ შესრულებულია მკაცრად მარცხნიდან მარჯვნივ.

ახლა განიხილეთ ეს გამოთქმა:

აქ მნიშვნელობა c ჯერ გამრავლდება 10-ზე და მხოლოდ ამის შემდეგ დაემატება მნიშვნელობა b მიღებულ პროდუქტს. გამრავლების ოპერატორს უფრო მეტი უპირატესობა აქვს, ვიდრე შეკრების ოპერატორს, ამიტომ "მკაცრად მარცხნიდან მარჯვნივ" წესრიგი დაირღვევა.

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

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

IN მაგიდა 14.9 ჩამოთვლილია ყველა ოპერატორი, რომელიც ჩვენ შევისწავლეთ მათი პრიორიტეტების კლებადობით.

		ცხრილი 14.9. ოპერატორის უპირატესობა (კლებადობით)
	ოპერატორები	აღწერა
	++ -- - ~ ! ტიპის	ზრდა, შემცირება, ნიშნის შეცვლა, ლოგიკური NOT, ტიპის განსაზღვრა
		გამრავლება, გაყოფა, ნაშთი
		სიმების შეკრება და შეერთება, გამოკლება
		შედარება ოპერატორები
		ლოგიკური და

	თავი 14. შესავალი ვებ პროგრამირებაში. JavaScript ენა
			ცხრილი 14.9 (ბოლო)
	ოპერატორები	აღწერა
		ლოგიკური ან
		პირობითი ოპერატორი(იხ. ქვემოთ)
	= <оператор>=	დავალება მარტივი და რთული

ყურადღება!

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

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

a = (b + c) * 10;

აქ ჯერ დაემატება b და c ცვლადების მნიშვნელობები, შემდეგ კი მიღებული ჯამი გამრავლდება 10-ზე.

ფრჩხილებში ჩასმული ოპერატორები ასევე ექვემდებარება უპირატესობას. ამიტომ ხშირად გამოიყენება მრავალი ჩასმული ფრჩხილები:

a = ((ბ + გ) * 10 - დ) / 2 + 9;

აქ ოპერატორები შესრულდება შემდეგი თანმიმდევრობით:

1. ბ და გ-ის დამატება.

2. მიღებული თანხა გაამრავლეთ 10-ზე.

3. ნამრავლს d გამოკლება.

4. გაყავით სხვაობა 2-ზე.

5. კოეფიციენტზე 9-ის დამატება.

თუ ამოიღებთ ფრჩხილებს:

a = b + c * 10 - d / 2 + 9;

მაშინ ოპერატორების შესრულების თანმიმდევრობა იქნება შემდეგი:

1. c და 10-ის გამრავლება.

2. გაყავით d 2-ზე.

3. b-ისა და c-ისა და 10-ის ნამრავლის დამატება.

4. მიღებული ჯამიდან გაყოფის კოეფიციენტის გამოკლებად 2-ით.

5. მიღებულ განსხვავებას დაამატეთ 9.

სულ სხვა შედეგი გამოდის, არა?

• განუსაზღვრელი: "დაუზუსტებელი"
• Null: "ობიექტი"
• ლოგიკური: "ბულიანი"
• ნომერი: "ნომერი"
• სტრიქონი: "სტრიქონი"
• ფუნქცია: "ფუნქცია"
• ყველაფერი დანარჩენი: "ობიექტი"

ამ ცხრილს უნდა დაემატოს შემდეგი შენიშვნები:

1. null ტიპის === "ობიექტი" .

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

პრაქტიკაში, ეს არასასიამოვნოა JavaScript-ში. ასე რომ, ES 5.1 დეველოპერები აპირებენ რაღაც უფრო ინტუიციურად გააკეთონ: typeof null === "null" .

მაგრამ რადგან ჩვენ ჯერ კიდევ გვაქვს ES3 გარშემო, არ შეცდეთ, მაგალითად, ამით:

/* ფუნქცია ეძებს ზოგიერთ ობიექტს და აბრუნებს ან ნულს, თუ არაფერი არ არის ნაპოვნი */ function search() () var obj = search(); if (ტიპი obj === "ობიექტი") ( // ნამდვილად ვიპოვეთ ობიექტი (FAIL) obj.method(); )

2. არ დაივიწყოთ შეფუთვის ობიექტები (ახალი ნომრის ტიპი (5) === „ობიექტი“).

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

არ გაგიკვირდეთ, რომ Safari ჯიუტად მიიჩნევს HTMLCollection-ს ფუნქციის ტიპად, ხოლო IE 9 ვერსიაზე ადრე ინახავს ჩვენს საყვარელ alert() ფუნქციას, როგორც ობიექტს. ასევე, Chrome ადრე RegExp-ს ფუნქციად თვლიდა, ახლა კი თითქოს გონს მოეგო და მას ობიექტით პასუხობს.

toString ()

მისი toString() მეთოდის შედეგიდან მნიშვნელობის ტიპის გარკვევის მცდელობა უაზროა. ყველა "კლასში" ეს მეთოდი თავისთავად არღვევს.

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

Object.prototype.toString()

მიუხედავად იმისა, რომ toString გადატვირთულია კონკრეტულ "კლასებში", ჩვენ მაინც გვაქვს მისი ორიგინალური განხორციელება Object-იდან. შევეცადოთ გამოვიყენოთ:

console.log(Object.prototype.toString.call(მნიშვნელობა));

console.log(Object.prototype.toString.call(მნიშვნელობა));

კლინტონი ამშვიდებს ამ დაღლილობას

უცნაურად საკმარისია, რომ ეს მეთოდი საოცრად კარგად მუშაობს.

სკალარული ტიპებისთვის აბრუნებს , , , .

სასაცილო ის არის, რომ ახალი ნომერიც კი (5), რომლის ტიპიც აქ წარუმატებელი იყო, ბრუნდება.

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

საგნები საინტერესო ხდება, როდესაც მივდივართ ობიექტებთან (ისინი typeof === "ობიექტი").

ჩაშენებული ობიექტები პრაქტიკულად მუშაობს აფეთქებით:

• {} —
• —
• თარიღი -
• შეცდომა -
• RegExp -

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

IE-ში, DOM ობიექტებმა დაიწყეს „ნორმალური“ ობიექტების გადაქცევა მხოლოდ მე-8 ვერსიიდან და მაშინაც კი, არა მთლიანად. ამიტომ, IE 6-8-ში, ყველა ეს ობიექტი (HTMLCOllection, DOMElement, TextNode, ისევე როგორც დოკუმენტი და ფანჯარა) უბრალოდ მცირდება.

ყველა სხვა ბრაუზერში (მათ შორის IE9) უკვე შეგიძლიათ გააკეთოთ რაღაც toString-ის შედეგით. მიუხედავად იმისა, რომ ყველაფერი ასევე არ არის მარტივი: HTMLCollection არსებობს, მაშინ . ფანჯარა - მერე, მერე, მერე. მაგრამ თქვენ უკვე შეგიძლიათ სცადოთ ამისგან რაიმეს მიღება.

ეს უფრო რთულია DOMElement-თან: ის ნაჩვენებია ფორმით, - განსხვავებული ფორმატი თითოეული ტეგისთვის. მაგრამ რეგულარული სეზონი აქაც დაგვეხმარება.

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

Object.prototype.toString() გამოყენების ნაკლოვანებები:

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

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

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

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

კონსტრუქტორები

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

null-ს და undefined-ს არ აქვს არც wrapper ობიექტები და არც კონსტრუქტორები.

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

(5).კონსტრუქტორი === ნომერი;

(რიცხვი .NaN ) .კონსტრუქტორი === ნომერი ;

(true).კონსტრუქტორი === ლოგიკური;

ნომრის 5 მაგალითი;

// მცდარი ნომერი .NaN ნომრის მაგალითი ;

// ლოგიკური ცრუ ჭეშმარიტი მაგალითი;

// false "string" instanceof String ;

// ყალბი

ნომრის 5 მაგალითი; // false Number.NaN ინსტანცია Number; // false true ინსტანცია ლოგიკური; // false "string" instance of String; // ყალბი

(მაგალითი იმუშავებს სულგრძელ ახალ ნომერზე (5))

ფუნქციებით (რომლებიც ასევე ობიექტებია) მაგალითები იმუშავებს:

console.log ( (function () ()) instanceof Function);

// true console.log ( (ფუნქცია () ( ) ).კონსტრუქტორი === ფუნქცია ) ;

// მართალია

console.log((function () ()) instanceof Function); // true console.log((ფუნქცია () ()).კონსტრუქტორი === ფუნქცია); // მართალია

ჩაშენებული კლასების ყველა ობიექტი ასევე ადვილად იდენტიფიცირებულია მათი კონსტრუქტორების მიერ: Array, Date, RegExp, Error.

აქ ერთი პრობლემა ჩნდება არგუმენტებთან დაკავშირებით, რომელთა კონსტრუქტორი არის Object.

და მეორე არის თავად Object-თან, უფრო სწორად, როგორ მივაკუთვნოთ მას საბაჟო კონსტრუქტორის მეშვეობით შექმნილი ობიექტი.

ამ გზით თქვენ შეგიძლიათ განსაზღვროთ მხოლოდ საბაზისო ობიექტი: ობიექტის ინსტანცია;განსაზღვრების ერთ-ერთი ვარიანტია ყველა სხვა შესაძლო ტიპის (Array, Error...) გავლა და თუ არცერთი მათგანი არ ჯდება - „ობიექტი“.

კონსტრუქტორები და მასპინძელი ობიექტები

საქმე უარესდება მასპინძელ ობიექტებთან.

დავიწყოთ იმით, რომ IE 7 ვერსიის ჩათვლით საერთოდ არ განიხილავს მათ ნორმალურ ობიექტებად. მათ უბრალოდ არ ჰყავთ დიზაინერები და პროტოტიპები (ყოველ შემთხვევაში, პროგრამისტი მათ ვერ მიაღწევს).

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

სხვადასხვა ბრაუზერები

განსხვავებულად. მაგალითად, HTMLCollection-ისთვის კონსტრუქტორი იქნება HTMLCollection ან NodeList, ან თუნდაც NodeListConstructor.
თქვენ ასევე უნდა განსაზღვროთ ბაზის კონსტრუქტორი DOMElement-ისთვის. FF-ში ეს არის, მაგალითად, HTMLElement, საიდანაც HTMLDivElement და სხვები უკვე მემკვიდრეობენ.
ხრიკი არის დაშვებული FireFox-ში მე-10 ვერსიის ქვემოთ და Opera-ს ქვემოთ 11. კოლექციის კონსტრუქტორი იქ არის Object.
კონსტრუქტორი.სახელი

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

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

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