JavaScript კონვერტაციის რიცხვი სიმებიანი. JavaScript: მონაცემთა ტიპი კონვერტაცია

JavaScript არის inepiest ენა (უფრო ზუსტად, სუსტად აკრეფილი ან დინამიურად აკრეფილი). ეს იმას ნიშნავს, რომ ჩვენ არ უნდა მიუთითოთ ცვლადის ტიპი, როდესაც გამოაცხადა იგი. Ineeposis აძლევს JavaScript მოქნილობა და სიმარტივის, ამჯობინეს სკრიფტინგის ენა (თუმცა ეს თვისებები მიიღებს ფასის ნაკლებობა rigor, მნიშვნელოვანია ხანგრძლივი და უფრო რთული პროგრამები, რომლებიც ხშირად დაწერილი უფრო მკაცრი ენები, როგორიცაა C ან Java). JavaScript- ის მონაცემთა ტიპების მოქნილი მუშაობის მნიშვნელოვანი ფუნქცია არის თარჯიმნის მიერ შესრულებული ავტომატური მონაცემების ტრანსფორმაციები. მაგალითად, თუ document.write () მეთოდი გადაცემულია, JavaScript ავტომატურად აკონვერტებს მას ეკვივალენტური სიმებიანი წარმომადგენლობას. ანალოგიურად, სიმებიანი ღირებულების შემოწმება, თუ ინსტრუქციის პირობებში, JavaScript ავტომატურად აკონვერტებს ამ სიმრავლე ლოგიკურ მნიშვნელობას - ყალბი, თუ სიმებიანი ცარიელია და ჭეშმარიტად სხვაგვარად.

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

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

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

ახალი ლოგიკური (ცრუ) // შიდა ღირებულება უტოლდება ყალბი, მაგრამ ობიექტი
// მოაქცია ჭეშმარიტი
ახალი ნომერი (0)
ახალი სიმებიანი (")
ახალი მასივი ()

რაოდენობის ობიექტების ტრანსფორმაცია იწყება ამ ობიექტის ღირებულების () მეთოდის ზარით. ყველაზე ობიექტები მემკვიდრეობით სტანდარტული მეთოდი Valueof () კლასი ობიექტი, რომელიც უბრალოდ დააბრუნებს ობიექტს თავად. მას შემდეგ, რაც სტანდარტული ღირებულების () მეთოდი არ დაბრუნდება ელემენტარული ღირებულების, JavaScript შემდეგ ცდილობს გარდაქმნას ობიექტი ნომერი, რომელსაც მოუწოდებს მისი tostring () მეთოდი და კონვერტაცია შედეგად სიმებიანი. მასთვის, ეს იწვევს საინტერესო შედეგებს. შეგახსენებთ, რომ tostring () მეთოდი აკონვერტებს ელემენტების მასივის შევიდა სიმებიანი, შემდეგ კი დააბრუნებს შედეგების concatenation ამ რიგების მათ შორის. აქედან გამომდინარე, მასივი ელემენტების გარეშე მოაქცია ცარიელი სტრიქონი, რომელიც გარდაიქმნება 0! გარდა ამისა, თუ მასივი შედგება ერთი ელემენტისგან, ნომერი N, მასივი გარდაიქმნება ამ ნომრის სიმებიანი წარმომადგენლობით, რომელიც შემდეგ მოაქვს ნომერზე N.

თუ მასივი შეიცავს ერთზე მეტ ელემენტს, ან თუ მისი ელემენტი არ არის ნომერი, მასივი მოაქვს NAN- ს. JavaScript- ში, კონტექსტი ყოველთვის არ არის განსაზღვრული ცალსახად! ოპერატორი + და შედარება ოპერატორები (და\u003e \u003d), როგორც ნომრები და სიმები, ასე რომ, როდესაც ობიექტი ერთი ამ ოპერატორით გამოიყენება, გაურკვეველია, რა უნდა იყოს გარდაიქმნება ნომერზე ან სიმებიანი. უმეტეს შემთხვევაში, JavaScript პირველი ცდილობს ობიექტის გარდაქმნას მნიშვნელობა () მეთოდით. თუ ეს მეთოდი დააბრუნებს ელემენტარულ ღირებულებას (როგორც წესი, რიცხვი), ეს მნიშვნელობა გამოიყენება. თუმცა, ხშირად ღირებულება () უბრალოდ დააბრუნებს ობიექტს კონვერტაციის გარეშე; ამ შემთხვევაში, JavaScript შემდეგ ცდილობს გარდაქმნას ობიექტი სიმებიანი გამოყენებით tostring () მეთოდი ზარი. ამ კონვერტაციის წესით არის მხოლოდ ერთი გამონაკლისი: როდესაც ობიექტი გამოიყენება + ოპერატორთან, კონვერსია შესრულებულია tostring () მეთოდის გამოყენებით. ამ გამონაკლისის არსებობა არის იმის გამო, რომ თარიღს აქვს tostring () მეთოდი და ღირებულება () მეთოდი. ოპერატორის თარიღის გამოყენებისას + თითქმის ყოველთვის საჭიროა სიმებიანი კონცერტი. მაგრამ როდესაც თარიღი ჩართულია შედარებით ოპერაციებში, თითქმის ყოველთვის აუცილებელია რიცხვითი შედარების შესასრულებლად, რათა დადგინდეს, თუ რომელი დროის წინ უძღოდა სხვა.

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

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

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

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

გამოკვეთილი კონვერტაციის ტიპები
Java-Script არ განსაზღვრავს ტრანსფორმაციის ოპერატორს C, C ++ და Java ენებზე, მაგრამ მსგავსი საშუალებები. JavaScript 1.1 (და ECMA-262) ნომერი (), ლოგიკური (), სიმებიანი () და ობიექტი () შეიძლება არა მხოლოდ დიზაინერებს, არამედ ფუნქციებს. ამგვარად გამოწვეული, ეს ფუნქციები ცდილობს გარდაქმნას
არგუმენტები შესაბამის ტიპში. მაგალითად, თქვენ შეგიძლიათ კონვერტირება ნებისმიერი x ღირებულების სიმებიანი გამოყენებით სიმებიანი (x) და ნებისმიერი ღირებულების Y ობიექტის გამოყენებით ობიექტი (Y).

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

Var x_as_string \u003d x + "";

რიცხვის ღირებულების გარდაქმნას, ნულის ჩამოწერის მიზნით:

Var x_as_number \u003d x - 0;

ოპერატორის გამოყენებით ლოგიკური მნიშვნელობის შეცვლა შესაძლებელია, ორჯერ გამოიყენება:

Var x_as_boolean \u003d !! x;

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

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

Var string_value \u003d სიმებიანი (ნომერი); // გამოყენებით სიმებიანი დიზაინერი ()
/ / როგორც ფუნქცია
Var string_value \u003d ნომერი + ""; // Concatenation ერთად ცარიელი სიმებიანი

კიდევ ერთი შესაძლებლობა უზრუნველყოფს მეთოდის toostring ():

String_value \u003d number.tostring ();

TOSTRING () რიცხვის ობიექტის მეთოდი (ელემენტარული რიცხვითი მნიშვნელობები მოაქვს რიცხვის ობიექტებს, ასე რომ თქვენ შეგიძლიათ დარეკოთ ეს მეთოდი) მიიღებთ სურვილისამებრ არგუმენტს, რომელიც ადგენს ნომრის სისტემის ბაზას, რომელსაც კონვერსია შესრულდება. თუ არგუმენტი არ არის მითითებული, ტრანსფორმაცია ხორციელდება ბაზაზე 10. მაგრამ თქვენ შეგიძლიათ სხვა ბაზებთან რიცხვების კონვერტაცია (2-დან 36-მდე). Მაგალითად:

Var n \u003d 17;
binary_string \u003d n.tostring (2); // თანაბრად "10001"
Octal_string \u003d "0" + n.tostring (8); // თანაბრად "021"
hex_string \u003d "0x" + n.tostring (16); // თანაბრად "0x11"

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

Ecmascript v3 და JavaScript 1.5 გვერდის ავლით ეს დაბრკოლება სამი ახალი კონვერტაციის მეთოდის მიხედვით ნომრის კლასში. Tofixed () მეთოდი აკონვერტებს რიცხვს სიმებიანი და აჩვენებს რიგი ნომრები შემდეგ ათობითი წერტილი გამოყენების გარეშე exponential notation. ToexOponentient () მეთოდი აკონვერტებს რიცხვს სიმებიანი, ჩაწერა ეს exponential ნოტაცია ერთი ციფრი ადრე ათობითი წერტილი და განსაზღვრული რაოდენობის ნომრები მას შემდეგ. Toprecision () მეთოდი აჩვენებს რიცხვს განსაზღვრული რაოდენობის მნიშვნელოვან ციფრებზე. თუ ასეთი რაოდენობის მნიშვნელოვანი ციფრი არ არის საკმარისი იმისათვის, რომ მთელი რიცხვის მთელი ნაწილი გამოვიყენოთ, ეს არის შეფასებული ნოტაცია. გთხოვთ გაითვალისწინოთ, რომ სამივე მეთოდი სწორად მრგვალდება შედეგად ხაზის მოღვაწეები. შეხედეთ შემდეგ მაგალითებს:

Var n \u003d 123456.789;
n.tofixed (0); // "123457"
n.tofixed (2); // "123456.79"
N.Toexponentient (1); // "1.2e + 5"
N.Toexponentient (3); // "1.235E + 5"
N.toprecision (4); // "1.235E + 5"
N.toprecision (7); // "123456.8"

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

Var number \u003d ნომერი (string_value);
Var number \u003d string_value - 0;

ასეთი ტრანსფორმაცია არასასიამოვნოა მისი გადაჭარბებული რიგით. იგი მუშაობს მხოლოდ decimal ნომრებიდა მიუხედავად იმისა, რომ კონვერტაციის საშუალებას იძლევა წამყვანი და დახურვის ფართები, ის არ იძლევა არაკომერციულ სიმბოლოებს რიცხვის შემდეგ. უფრო მოქნილი ტრანსფორმაციისთვის შეგიძლიათ გამოიყენოთ Parseint () და parsefloat () ფუნქციები. ეს ფუნქციები გარდაიქმნება და დაბრუნდა ხაზის დასაწყისში რომელიმე რიცხვით, იგნორირება არა-რიცხვითი სიმბოლოების იგნორირებით. Parseint () ფუნქციური პროცესები მხოლოდ მთელი რიცხვი და parsefloat () არის ორივე რიცხვი და მცურავი წერტილი ნომრები. თუ სიმებიანი იწყება "0x" ან "0x", Parseint () ინტერპრეტაციას, როგორც ჰექსადეციალური რიცხვი. Მაგალითად:

PARSEINT ("3 ბრმა მაუსები"); / / ბრუნდება 3.
Parsefloat ("3.14 მეტრი"); / / ბრუნდება 3.14.
Parseint ("12.34"); / / ბრუნდება 12.
Parseint ("0xff"); / / ბრუნდება 255.

ParseInt () ფუნქცია შეიძლება ჰქონდეს მეორე არგუმენტი, რომელიც მიუთითებს დამუშავებული რიცხვის რაოდენობის ბაზაზე. სწორი ღირებულებები - 2-დან 36-მდე. მაგალითად:

Parseint ("11", 2); / / ბრუნდება 3 (1 * 2 + 1)
PARSEINT ("FF", 16); / / ბრუნდება 255 (15 * 16 + 15)
PARSEINT ("ZZ", 36); / / ბრუნდება 1295 (35 * 36 + 35)
Parseint ("077", 8); / / ბრუნდება 63 (7 * 8 + 7)
Parseint ("077", 10); / / ბრუნდება 77 (7 * 10 + 7)

თუ parseint () და parsefloat () ვერ გადაიყვანეთ მითითებული სიმებიანი რიცხვი, ისინი დაბრუნდებიან NAN.

Parseint ("თერთმეტი"); / / ბრუნდება nan.
Parsefloat ("$ 72.47"); / / ბრუნდება nan.

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

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

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

მაგალითი აღწერს ოთხ სხვადასხვა ხაზს. პირველი ბლოკში გამოყვანის ტიპის თითოეული ცვლადი ფუნქცია ტიპიფი განისაზღვრება სიმებიანი. შემდეგ თითოეული ხაზი ძალიან უბრალოდ გარდაიქმნება ნომერზე. მეორე გამომავალი ბლოკში, ცვლადების ცვლილებები, მას შემდეგ, რაც ტრანსფორმაციის შემდეგ, მათი ტიპი გახდა რიცხვი. JavaScript Parasefloat კონვერტაციის მაგალითი განსაკუთრებით მიუთითებს: ეს იყო "12E + 3", გახდა "12000".

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

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

ჩვეულებრივი ტრანსფორმაციის მეთოდები

არსებობს რიცხვები და არსებობს fractional, შესაბამისად, JavaScript row ნომრით აკონვერტებს:

parseint;
parsefloat.

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

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

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

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

აუცილებელია რიცხვითი სისტემების შესახებ იდეები, ჰექსადეციმალის ჩაწერის მეთოდების შესახებ (რიცხვი იწყება "0x") და ოქტალური ნომრებით (რიცხვი იწყება "0").

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

გარდაქმნა

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

ასეთი ამოცანის გადასაჭრელად შეგიძლიათ შეცვალოთ სიმებიანი სიმბოლოები მათი რიცხვითი კოდებით ან ციფრული კოდების ან ციფრი და ციფრი და ციფრი. Carcodeat () მეთოდი გამოიყენება სიმებიანი ანიჭებს რიცხვითი ღირებულება 98 IB ცვლადი, ანუ, ასო კოდი "B". იმის გათვალისწინებით, რომ "A" -ს კოდექსის ღირებულება 97-ს შეადგენს, შეგიძლიათ მიიღოთ ლათინური ანბანის ყველა ასოების რიცხვი, რომელიც აღნიშნულია ხაზის და ზედაპირზე. მსგავსი რუსული ანბანის ასოები.

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

სიმებიანი უნიკალური რაოდენობის ფორმირება

თუ ასო კოდი "A" არის 97, მაშინ განსხვავება წერილსა და 97-ს შორის, ანბანის წერილს უნიკალურ რაოდენობას მისცემს. თითოეული ხაზის სიმბოლოების უნიკალური ნომრების შეჯამება, ძნელია ამ სიმებიანი უნიკალური რიცხვი.

თუ სიმებიანი წერილების თითოეული პოზიცია ენიჭება წონა, მაგალითად, პოზიცია:

0 წონა 1;
1 წონა 10;
2 წონა 100;

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

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

"იზრდება" საიტის გვერდი სელექტორები

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

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

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

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

საგზაო ოპტიმიზაცია და ანალიტიკა

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

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

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

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

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

ტრანსფორმაციის ინსტრუმენტი

JavaScript და CSS გადამუშავების კონტექსტში რიცხვითი ინფორმაცია საშუალებას გაძლევთ მართოთ გვერდის ჩვენება სერვერის მონაწილეობის გარეშე. CSS წესები აგებულია როგორც სუბსტრირება, რეკურსიულად. როგორც წესი, პარამეტრი არის რამდენიმე ასო, რასაც მოჰყვება რამდენიმე წერილი (მაგალითად, "PX", "PT", "EM", ...). პარამეტრი არის წესის სათაური და წესი შემოდის სუბსტროლში კლასის ან იდენტიფიკატორის სტილში.

Recursion JavaScript.strete. სტრუქტურა ... მიდის სასურველ ნომერზე, გარდაიქმნება სიმებიანი რიცხვიდან, ცვლის მას და წერს უკან სასურველ ადგილას. წესი იცვლება "მანქანა". ეს არის მარტივი და მოსახერხებელი, სერვერის მონაწილეობა.

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

სინტაქსიკი

Var parsed \u003d parseint ("97", 10);

parseint და Parsefloat არის ორი ფუნქცია გამოიყენება parsing რიგების ნომრები. სინტაქსის ანალიზი მდუმარედ შეაჩერებს, თუ ის არ აღიარებს სიმბოლოს, რომ ის შეიძლება სასარგებლო იყოს სიმებიანი სინტაქსური ანალიზისთვის, მაგალითად "92px", მაგრამ ეს გარკვეულწილად საშიშია, რადგან ეს არ მოგცემთ შეცდომას შესვლის ნაცვლად, თქვენ "დაბრუნდი nan თუ სიმებიანი არ იწყება რიცხვი, იგნორირება დასაწყისში ხაზი იგნორირებულია. აქ არის მაგალითი იმისა, თუ რას აკეთებს რაღაც განსხვავებულად, რა გჭირდებათ და არ მიუთითებს, რომ რაღაც წავიდა არასწორი:

Var widgetssold \u003d parseint ("97,800", 10); // widgetssold არის 97

კარგი პრაქტიკა ყოველთვის მიუთითებს მეორე არგუმენტად. ძველ ბრაუზერებში, თუ სიმებიანი დაიწყო 0, ეს იქნებოდა ინტერპრეტირებული როგორც ოქტალი, თუ იგი არ იყო მითითებული Radix- ის ღირებულებით, რამაც ბევრი ადამიანი გაოცებულიყო. ქცევის ჰექსადეციალური გაშვებისთვის იწყება, თუ სიმებიანი იწყება 0x- ით, თუ რადიქსის ღირებულება არ არის მითითებული. 0xff. სტანდარტი რეალურად შეიცვალა Ecmascript 5, ასე რომ თანამედროვე ბრაუზერები აღარ აწარმოებს ოქტალს, როდესაც მასპინძელი აღნიშნავს, თუ რადიქსის ღირებულება არ არის მითითებული. Parseint ესმის რადიკებს 36-მდე, და ამ შემთხვევაში, ზედა და ქვედა ასოები, როგორც ეკვივალენტი.

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

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

Var cast \u003d ნომერი ("97");

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

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

Var მომრგვალებული \u003d მათემატიკა.ფლიო (ნომერი ("97.654")); / სხვა პარამეტრები არიან Math.Ceil, math.round var ფიქსირებული \u003d ნომერი ("97.654"). Tofixed (0); // მრგვალი, ვიდრე truncated var bitwised \u003d ნომერი ("97.654") | 0; / / არ გამოიყენოთ დიდი რაოდენობით

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

~ "3000000000.654" \u003d\u003d\u003d -1294967296 // ეს იგივეა, რაც რიცხვი ("3000000000.654") | 0 "3000000000.654" \u003e\u003e\u003e 0 \u003d\u003d\u003d 3000000000 // Unsigned მარჯვენა ცვლა გაძლევთ დამატებით ბიტს "300000000000.654"\u003e \u003e\u003e 0 \u003d\u003d\u003d 3647256576 // მაგრამ მაინც ვერ ახერხებს უფრო დიდი რაოდენობით

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

Math.floor ("3000000000.654") \u003d\u003d\u003d 3000000000 // ეს არის იგივე, რაც მათემატიკა.ფლიო (ნომერი ("3000000000.654"))

გაითვალისწინეთ, რომ ყველა ეს მეთოდი გვესმის exponential notation, ამიტომ 2E2 არის 200, და არა nan. გარდა ამისა, ნომერი ესმის "უსასრულობას", ხოლო ანალიზის მეთოდები არ არის.

ჩვეულება

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

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

JavaScript- ში არის 2 ჩაშენებული ფუნქციები რიცხვების რიგების გარდაქმნისთვის: Parsefloat () და Parseint ().

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

ასევე, ფუნქცია შეუძლია "NUM N Multiplied მიერ 10 ხარისხის X", რომელიც პროგრამირებაში არის ჩვეულებრივი ჩაწერას წერილი E, მაგალითად: 0.5e6 ან 0.5e + 6. ხარისხი შეიძლება იყოს უარყოფითი: 0.5E-6, რაც 0.5 * 10 ^ -6 ან 0.5 / 1000000.

Parsefloat ("3.78kg") // 3.78 Parsefloat ("" KG33 ") // Nan Parsefloat (" 0004.111 ") // 4.111 Parsefloat (" 0x66 "") // 0 Parsefloat ("" 5 " ") / 0.5 Parsefloat (" "-. 5" ") // -0.5 Parsefloat (" 0.5E6 ") // 500000 Parsefloat (" 0.03E + 2 ") // 3 Parsefloat (" "3e- 4 "") // 0.0003 parsefloat ("" - 3E-4 "") // -0.0003

ParseInt (სიმებიანი [, რადიქსი]) ფუნქცია იღებს სიმებიანი, როგორც პირველი არგუმენტი, აანალიზებს მას და დააბრუნებს რიცხვს (ტიპის რიცხვის). ფუნქცია ცდილობს გაანალიზოს ნომრის სისტემის ანალიზი, რომელშიც მითითებულია ნომერზე წყარო (მაგალითად, ათობითი, octal ან hexadecimal - მაგრამ არა მხოლოდ ეს). გარდა ამისა, ნომრის სისტემა შეიძლება განისაზღვროს მკაფიოდ, მეორე რადიქსის პარამეტრით. Radix პარამეტრს შეუძლია მიიღოს ნებისმიერი რიცხვი 2-დან 36-მდე (მე -10 ზემოთ, ინგლისურ ანბანის ასოები გამოიყენება Z).

ნომრები ტიპი 1.5e6 ფუნქცია არ არის გაუმკლავდეს როგორც parsefloat ().

გთხოვთ, წაიკითხოთ მაგალითები ქვემოთ, ისე, რომ არ დააყენოთ pitfalls, არის harnessed ოპერაცია parseint () ფუნქცია.

PARSEIINT ("25") // 25 parseint ("" - 25 "") // -25 parseint ("45.12") // 45 Parseint ("045" ", 10) // 45 ParseInt (" 70 ", 8) // 56 (70 ოქტალურ სისტემაში ეს არის 56 ათობითი) ParseInt (" 070 ") // 56 (მნიშვნელოვანია !!! ნულოვანი პირველი ძალა იქნება ფუნქციონირების ფუნქცია, როგორც octal ნომერი) Parseint ("88" ", 8) // nan (Octal System No Digit 8) parseint (" A1 ") // nan (მნიშვნელოვანი !!! default ფუნქცია არ აღიქვამს რიცხვს, როგორც 16 მდიდარი, თუ არ დასძინა დასაწყისში რიგები 0x) parseint ("A1", 16) // 161 (აქ ნათლად არის მითითებული ნომრის სისტემა) Parseint ("0xa1") // 161 (სწორი 16-Riche Number Format, თქვენ არ შეგიძლიათ განსაზღვროთ მეორე პარამეტრი) ParseInt ("099") // 0 (მნიშვნელოვანი !!! რიცხვი ცნობილია, როგორც ოქტალი, მაგრამ შეიცავს არასწორი სიმბოლოების) ParseInt ("0.5E6") // 0 (მნიშვნელოვანია! არ მუშაობს parsefloat) parseint ("zz" ", 36) // 1295 parseint (" "- FF") // nan parseint ("" - FF "", 16) // -255

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

ნომრები ტიპი 1.5e6 ფუნქცია არ არის გაუმკლავდეს როგორც parsefloat ().

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