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

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

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

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

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

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

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

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

სისტემის გამოყენება; namespace ConsoleApplication1 (კლასის დამატება () კლასის თანხა: დამატება () კლასის პროგრამა (სტატიკური ბათილი ძირითადი () (დამატება = ახალი დამატება (); თანხა s = ახალი ჯამი (); თუ (a არის დამატება) Console.WriteLine ("ცვლადი a არის ტიპი Add "); თუ (s არის Sum) Console.WriteLine (" s- ის ტიპი მემკვიდრეობით მიიღება Add class "); Console.ReadLine ();))))

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

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

გამოთქმა, როგორც ტიპი

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

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

სისტემის გამოყენება; namespace ConsoleApplication1 (კლასის დამატება () კლასის ჯამი: დამატება () კლასის პროგრამა (სტატიკური სიცარიელე მთავარი () (დამატება = ახალი დამატება (); ჯამი s = ახალი ჯამი (); // შეასრულეთ ტიპი = ა) ს დამატების სახით; თუ ( a! = null) Console.WriteLine ("კონვერტაცია წარმატებული იყო"); სხვაგვარად Console.WriteLine ("კონვერსია ვერ მოხერხდა"); Console.ReadLine ();))))

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

JavaScriptან ჯ(შემოკლებით) არ არის ადვილი ენა და ახალბედა დეველოპერები დაუყოვნებლივ არ სწავლობენ ამის შესახებ. თავიდან ისინი სწავლობენ საფუძვლებს და ყველაფერი ფერადი და ლამაზი ჩანს. ცოტა უფრო ღრმად რომ ჩავდივართ, ჩნდება 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 (_ შედარება); for (var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

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

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

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

პირველი პრობლემა: float number, output as number

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

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

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

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

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

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

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

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

Var data = ახალი მასივი ("გამარჯობა", "მსოფლიო"); var isArr = მასივის მონაცემები;

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

Var მონაცემები = ახალი მასივი ("გამარჯობა", "მსოფლიო"); var isArr = Array.isArray (მონაცემები);

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

Var მონაცემები = ახალი მასივი ("გამარჯობა", "მსოფლიო"); var isArr = Object.prototype.toString.call (მონაცემები) == ""; console.log (isArr);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ცხრილი 14.7. NOT განცხადების შედეგები

მიიღეთ ოპერატორის ტიპი

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

s = typeof ("str");

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

ყველა მნიშვნელობა, რომლის დაბრუნებაც შეუძლია ოპერატორის ტიპს, ჩამოთვლილია ცხრილში. 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", ხოლო მცდარი იქნება 0 ან "0". პირიქით, რიცხვი 1 გარდაიქმნება ჭეშმარიტად, ხოლო 0 რიცხვი ცრუ. ასევე, ცრუ გარდაიქმნება

ღირებულებები არის ნული და განუსაზღვრელი.

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

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

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

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

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

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

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

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

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

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

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

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

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

ყურადღება!

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

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

a = (b + c) * 10;

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

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

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

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

1. დამატება b და c.

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

3. გამოვაკლოთ დ პროდუქტს.

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 -ის დამატება მიღებულ სხვაობას.

შედეგი სრულიად განსხვავებულია, არა?

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

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

1. typeof null === "ობიექტი".

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

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

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

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

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

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

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

toString ()

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

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

Object.prototype.toString ()

მიუხედავად იმისა, რომ toString ხელახლა არის განსაზღვრული კონკრეტულ „კლასებში“, ჩვენ მაინც გვაქვს მისი საწყისი განხორციელება Object– დან. შევეცადოთ გამოვიყენოთ იგი:

console.log (ობიექტი .პროტოტიპი .toString .call (მნიშვნელობა));

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

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

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

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

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

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

გართობა იწყება მაშინ, როდესაც ჩვენ მივაღწევთ ობიექტებს (ისეთებს, როგორიცაა typeof === "ობიექტი").

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

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

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

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

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

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

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

Object.prototype.toString () - ის გამოყენების უარყოფითი მხარეებიდან:

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

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

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

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

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

და ბოლოს, კონსტრუქტორები. ვინ უკეთ იტყვის JS– ში ობიექტის „კლასზე“ თუ არა მის კონსტრუქტორზე?

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

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

(5) .კონსტრუქტორი === ნომერი; (ნომერი .NaN) .კონსტრუქტორი === ნომერი; (ჭეშმარიტი) .კონსტრუქტორი === ლოგიკური; ("სიმებიანი") .კონსტრუქტორი === სიმებიანი;

(5) .კონსტრუქტორი === ნომერი; (ნომერი. NaN) .კონსტრუქტორი === ნომერი; (ჭეშმარიტი) .კონსტრუქტორი === ლოგიკური; ("სიმებიანი"). კონსტრუქტორი === სიმებიანი;

მაგრამ მაგალითი აქ არ იმუშავებს:

ნომრის 5 მაგალითი; // ყალბი ნომერი .NaN მაგალითი ნომრიდან; // ბულის ყალბი ჭეშმარიტი მაგალითი; // ყალბი "სიმებიანი" სტრიქონის მაგალითი; // ყალბი

ნომრის 5 მაგალითი; // ყალბი ნომერი. ნომრის მაგალითი; // ბულის ყალბი ჭეშმარიტი მაგალითი; // ყალბი "სიმებიანი" სტრიქონის მაგალითი; // ყალბი

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

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

console.log ((ფუნქცია () ()) ფუნქციის მაგალითი); // true console.log ((ფუნქცია () ()) .constructor === ფუნქცია); // მართალია

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

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

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

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

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

ობიექტის ობიექტი;

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

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

მასპინძელი საგნებით, ყველაფერი უარესდება.

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

სხვა ბრაუზერები უკეთესად მუშაობენ. არსებობს კონსტრუქტორები და მათი გამოყენება შეგიძლიათ ღირებულების კლასის დასადგენად. მხოლოდ ისინი განსხვავებულად იწოდება სხვადასხვა ბრაუზერში. მაგალითად, HTMLCollection– ისთვის კონსტრუქტორი იქნება HTMLCollection ან NodeList, ან თუნდაც NodeListConstructor.

თქვენ ასევე უნდა განსაზღვროთ DOMElement– ის ბაზის კონსტრუქტორი. FF– ში, ეს არის, მაგალითად, HTMLElement, საიდანაც HTMLDivElement და სხვები უკვე მემკვიდრეობით მიიღეს.

FireFox 10 ვერსიის ქვემოთ და Opera 11 ვერსიის ქვემოთ ხუმრობენ. იქ კოლექციის კონსტრუქტორი არის ობიექტი.

კონსტრუქტორი.სახელი

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

იგი შეიცავს კონსტრუქტორის ფუნქციის სახელს, მაგალითად (5) .constructor.name === "ნომერი".

მაგრამ:
1. IE– ში ეს საერთოდ არ არის, თუნდაც მე –9 – ში.
2. ბრაუზერები კვლავ ძერწავს ყველაფერს მასპინძელ ობიექტებად (და ხშირად მათ საერთოდ არ აქვთ ეს თვისება). ოპერაში DOMElement– ს აქვს კონსტრუქტორის სახელი ზოგადად Function.prototype.
3. არგუმენტები კვლავ "ობიექტია".

დასკვნები

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

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

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

Სინტაქსი

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

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

Პარამეტრები

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

აღწერა

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

მაგალითები

// რიცხვები typeof 37 === "ნომერი"; typeof 3.14 === "ნომერი"; typeof (42) === "ნომერი"; typeof Math.LN2 === "ნომერი"; typeof Infinity === "ნომერი"; ტიპი NaN === "ნომერი"; // მიუხედავად იმისა, რომ ეს არის "არა-ნომერი" ტიპის ნომერი (1) === "ნომერი"; // არასოდეს გამოიყენოთ ეს ჩანაწერი! // სტრიქონები typeof "" === "სიმებიანი"; typeof "bla" === "string"; typeof "1" === "სიმებიანი"; // გაითვალისწინეთ, რომ სტრიქონში არსებული რიცხვი კვლავ არის ტიპის stringof (typeof 1) === "string"; // typeof ყოველთვის დააბრუნებს სტრიქონს ამ შემთხვევაში stringof ("abc") === "string"; // არასოდეს გამოიყენოთ ეს ჩანაწერი! // ლოგიკური ტიპები true === "ლოგიკური"; typeof false === "ლოგიკური"; ტიპი ბული (ჭეშმარიტი) === "ლოგიკური"; // არასოდეს გამოიყენოთ ეს ჩანაწერი! // სიმბოლოები typeof სიმბოლო () === "სიმბოლო" სიმბოლო სიმბოლო ("foo") === "სიმბოლო" typeof Symbol.iterator === "სიმბოლო" // განუსაზღვრელი ტიპი დაუდგენელი === "განუსაზღვრელი"; typeof daxuyanButUndefinedVariable === "განუსაზღვრელი"; typeof undeclaredVariable === "undefined"; // ობიექტების ტიპი (a: 1) === "ობიექტი"; // გამოიყენეთ Array.isArray ან Object.prototype.toString.call // რეგულარული ობიექტებისა და მასივების ერთმანეთისგან გასასხვავებლად === "ობიექტი"; typeof new Date () === "ობიექტი"; // რაც ქვემოთ არის, იწვევს შეცდომებს და პრობლემებს. Არ გამოიყენოთ! ახალი ბულის ტიპი (ჭეშმარიტი) === "ობიექტი"; ახალი ნომრის ტიპი (1) === "ობიექტი"; ახალი სტრიქონის ტიპი ("abc") === "ობიექტი"; // ფუნქციის ტიპები () () === "ფუნქცია"; typeof კლასი C () === "ფუნქცია"; typeof Math.sin === "ფუნქცია";

ნულოვანი

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

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

შესწორება შესთავაზეს ECMAScript– ში (გამორთვის საშუალებით), მაგრამ უარყოფილ იქნა. ეს გამოიწვევს typeof null === "null".

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

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

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

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

Typeof / s / === "ფუნქცია"; // Chrome 1-12 Not ECMAScript 5.1 compliant typeof / s / === "object"; // Firefox 5+ ECMAScript 5.1 თავსებადი

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

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

ტიპი არადეკლარირებული ცვლადი === "განუსაზღვრელი"; typeof newLetVariable; ნება newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "გამარჯობა"; // ReferenceError

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

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

Typeof document.all === "განუსაზღვრელი";

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

სპეციფიკაციები (რედაქტირება)

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

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

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

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

ლეგენდა

Სრული დახმარებაᲡრული დახმარება

ანუ კონკრეტული ჩანაწერები

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