Տողի մեջ թվի JavaScript- ի փոխարկում: JavaScript. Տվյալների տեսակը փոխարկում

JavaScript- ը աննկատ լեզու է (ավելի ճշգրիտ, թույլ տպված կամ դինամիկ մուտքագրված): Սա նշանակում է, որ մենք չպետք է նշենք այն փոփոխականի տեսակը, երբ այն հայտարարեց: INEPosis- ը JavaScript- ի ճկունություն եւ պարզություն է հաղորդում, գերադասելի է գրությունների լեզվով (չնայած այս հատկանիշները ստանում են խստության պակասի գինը, որը կարեւոր է ավելի խիստ լեզուների համար, ինչպիսիք են C կամ Java): JavaScript- ում տվյալների տեսակների հետ ճկուն աշխատանքի կարեւոր առանձնահատկությունն է թարգմանչի կողմից կատարված տվյալների ավտոմատ վերափոխումները: Օրինակ, եթե փաստաթղթի () մեթոդը փոխանցվում է, JavaScript- ը ինքնաբերաբար վերափոխում է այն համարժեք լարային ներկայացուցչությանը: Նմանապես, ստուգելով լարային արժեքը, եթե հրահանգի վիճակում, JavaScript- ը ինքնաբերաբար փոխարկում է այս տողը տրամաբանական արժեքի, կեղծ, եթե լարվածը այլ կերպ է:

Հիմնական կանոնն այն է, որ երբ մեկ տեսակի արժեքը տեղի է ունենում այն \u200b\u200bհամատեքստում, որտեղ անհրաժեշտ է որոշակի տեսակի արժեքը, JavaScript- ը ինքնաբերաբար փորձում է վերափոխել արժեքը ցանկալի ձեւով: Հետեւաբար, օրինակ, համատեքստում, որը ենթադրում է տրամաբանական փոփոխական, թիվը վերածվում է տրամաբանական արժեքի:

Լարային համատեքստում գտնվող առարկան վերածվում է տողի: JavaScript- ի թվային համատեքստում տեղադրելը փորձում է վերափոխվել համարի:

Փոխարկում «Տարրական տիպի օբյեկտ»
Օրինակ, տրամաբանական համատեքստում ներքեւում գտնվող բոլոր առարկաները վերածվում են ճշմարիտ.

Նոր Boolean (FALSE) // Ներքին արժեքը հավասար է կեղծ, բայց օբյեկտի
// փոխարկվել է ճշմարիտ
Նոր համար (0)
Նոր լար (")
Նոր զանգված ()

Համարում օբյեկտների վերափոխումը սկսվում է այս օբյեկտի արժեքի () մեթոդի կոչից: Օբեկտների մեծ մասը ժառանգում է Ստանդարտ մեթոդ Արժեքային () դասի օբյեկտը, որը պարզապես վերացնում է օբյեկտը: Քանի որ ստանդարտ արժեքի () մեթոդը չի վերադարձնում տարրական արժեքը, JavaScript- ը, այնուհետեւ փորձում է օբյեկտը վերափոխել մի շարք, զանգահարելով իր Tostring () մեթոդը: Զանգվածների համար սա հանգեցնում է հետաքրքիր արդյունքների: Հիշեցնենք, որ Tostring () մեթոդը զանգվածի տարրերը վերածում է լարայինի, այնուհետեւ վերադարձնում է դրանց միջեւ ստորակետերով այս տողերի համախմբման արդյունքը: Հետեւաբար, առանց տարրերի զանգվածը վերածվում է դատարկ տողի, որը վերածվում է 0-ի: Բացի այդ, եթե զանգվածը բաղկացած է մեկ տարրից, ապա համարը, զանգվածը վերածվում է այս համարի լարային ներկայացման, որն այնուհետեւ վերափոխվում է N.

Եթե \u200b\u200bզանգվածը պարունակում է մեկից ավելի տարր, կամ եթե դրա մի տարրը թիվ չէ, զանգվածը վերածվում է նան: JavaScript- ում համատեքստը միշտ չէ, որ որոշվում է միանշանակ: Օպերատոր + եւ համեմատության օպերատորները (եւ\u003e \u003d) Աշխատեք ինչպես թվերով, այնպես էլ տողերով, այնպես որ, երբ օբյեկտը օգտագործվում է այս օպերատորներից մեկի հետ, պարզ չէ, թե այն հնարավոր չէ վերափոխվել այն, ինչը պետք է վերածվի մի շարք կամ տողի: Շատ դեպքերում JavaScript- ը նախ փորձում է վերափոխել օբյեկտը `զանգահարելով արժեքի () մեթոդը: Եթե \u200b\u200bայս մեթոդը վերադարձնում է տարրական արժեքը (սովորաբար համարը), այս արժեքն օգտագործվում է: Այնուամենայնիվ, հաճախ արժեքը () պարզապես վերափոխում է օբյեկտը, առանց փոխակերպման. Այս դեպքում JavaScript- ը այնուհետեւ փորձում է օբյեկտը վերածել տողի, օգտագործելով Tostring () մեթոդի զանգը: Այս փոխակերպման կանոնից միայն մեկ բացառություն կա. Երբ ամսաթվի օբյեկտը օգտագործվում է + օպերատորի հետ, փոխարկումը կատարվում է օգտագործման () մեթոդի միջոցով: Այս բացառության առկայությունը պայմանավորված է նրանով, որ ամսաթիվը ունի ինչպես Tostring () մեթոդը եւ արժեքի () մեթոդը: Օպերատորի հետ ամսաթիվը օգտագործելիս + համարյա միշտ պահանջվում է լարային համախմբում: Բայց երբ ամսաթիվը ներգրավված է համեմատության գործողություններում, գրեթե միշտ անհրաժեշտ է թվային համեմատություն կատարել, որոշելու, թե երկու կետերից որ մեկ անգամ նախորդում է:

Օբեկտների մեծ մասը կամ չունեն արժեքի մեթոդ (), կամ այս մեթոդը չի վերադարձնում օգտակար արդյունքներ:

Երբ օպերատորը + օգտագործվում է օբյեկտի համար, լարային համապատասխանում է սովորաբար, եւ ոչ լրացում: Երբ համեմատության օպերատորը կիրառվում է օբյեկտի վրա, սովորաբար կատարվում է լարային համեմատություն, ոչ թե թվային:

Օբյեկտի սահմանում Հատուկ մեթոդ Արժեքը () կարող է այլ կերպ վարվել: ԹվԱԿ-ի վերադարձը սահմանելով () մեթոդը, ձեր օբյեկտի համար կարող եք թվաբանություն եւ այլ հայտարարություններ կիրառել, բայց ձեր օբյեկտի ավելացումը կկատարվի ոչ թե սպասվող. Երկարաժամկետ () մեթոդը այլեւս կոչված չէ Մեթոդով վերադարձված թիվը ներգրավված է Cononationation Valuef ():

Վերջապես, հիշեք, որ արժեքի () մեթոդը չի կոչվում TONUMBER (), խստորեն ասած, դրա խնդիրն է օբյեկտը վերածել նշանակալից տարրական արժեքի, այնպես որ որոշ օբյեկտներ կարող են ունենալ տողերի արժեքի () մեթոդներ:

Փոխակերպման բացահայտ տեսակներ
Java-Script- ը չի սահմանում վերափոխման օպերատորը, ինչպես C, C ++ եւ Java լեզուներով, բայց տրամադրում է նմանատիպ միջոցներ: JavaScript- ում 1.1 (եւ ECMA-262) համարը (), բուլյան (), լարային () եւ օբյեկտը () կարելի է անվանել ոչ միայն որպես դիզայներներ, այլեւ որպես գործառույթներ: Այս եղանակով պատճառվելով, այս գործառույթները փորձում են վերափոխել իրենց
Փաստարկներ համապատասխան տիպի մեջ: Օրինակ, ցանկացած X արժեքը կարող եք վերափոխել լարային լարային (x) եւ ցանկացած արժեքի օբյեկտի (Y) օգտագործման ցանկացած արժեքի:

Կան եւս մի քանի տեխնիկա, որոնք կարող են օգտակար լինել բացահայտ տիպի վերափոխումներ կատարելու համար: Որպեսզի արժեքը տողի համար վերափոխենք, այն դարձրեք միակողմանի դատարկ լարով.

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 համարը + ""; // Հասկացում դատարկ տողի հետ

Մեկ այլ հնարավորություն ապահովում է TOOSTRING- ի մեթոդը ().

String_value \u003d number.tostring ();

Համարի օբյեկտի (տարրական թվային արժեքները) tostring () մեթոդը (տարրական թվային արժեքները փոխարկվում են համարի օբյեկտների համար, այնպես որ կարող եք այս մեթոդը անվանել) ընդունում է կամընտիր փաստարկ, որը սահմանում է փոխարկումը: Եթե \u200b\u200bփաստարկը նշված չէ, վերափոխումը կատարվում է բազայի 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"

1.5 տարբերակի համար JavaScript տարբերակների պակասը բաղկացած է բացակայությունից Ստանդարտ նորաձեւությունՁեզ թույլ տալով նշել տասնորդական նշանների քանակը շարքում `թվի վերափոխումից, կամ պահանջել էքսպոնենցիալ նոտան: Դա կարող է բարդացնել ավանդական ձեւաչափ ունեցող թվերի ցուցադրումը, ինչպիսիք են դրամական արժեքները:

ECMAScript V3 եւ JavaScript 1.5 շրջանցում այս խոչընդոտը `ավելացնելով փոխակերպման երեք նոր մեթոդ` համարի դասի: Tofixed () մեթոդը թիվն է վերածում տողի եւ ցուցադրում թվերի նշված քանակը տասնորդական կետից հետո, առանց էքսպոնենցիալ նոտան օգտագործելու: Toexponential () մեթոդը վերափոխում է տողի համարը, ձայնագրելով այն էքսպոզիցիոն նոտացիայի մեջ `մեկ նիշից առաջ` նախքան դրա հետեւից նշված թվերի քանակը: TOPRECISION () մեթոդը ցուցադրում է մի շարք, օգտագործելով նշանակալի թվանշանների քանակը: Եթե \u200b\u200bայդպիսի մի շարք նշանակալի թվանշաններ բավարար չեն համարի մի ամբողջ մասը դուրս բերելու համար, այն ձայնագրվում է էքսպոնենցիալ նոտացիայի մեջ: Խնդրում ենք նկատի ունենալ, որ բոլոր երեք մեթոդները ճիշտ կլորացվում են արդյունքում ստացված գծի թվերը: Նայեք հետեւյալ օրինակներին.

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

Թողերի փոխարկում թվերով
Մենք տեսանք, որ գծի թվային համատեքստում թվեր ներկայացնող համարները ավտոմատ կերպով վերածվում են իրական թվերի: Ինչպես ցույց է տրված վերեւում, այս փոխարկումը կարող է հստակ լինել.

Var համար \u003d համարը (string_value);
Var համար \u003d string_value - 0;

Նման վերափոխումը անհարմար է իր ավելորդ խստության պատճառով: Այն աշխատում է միայն տասնորդական համարներԵվ չնայած փոխարկումը թույլ է տալիս առաջատար եւ փակել տարածքներ, դա թույլ չի տալիս որեւէ ոչ դրոշիչ կերպար տողի քանակից հետո: Ավելի ճկուն վերափոխումների համար կարող եք օգտագործել պարաշինաց () եւ պարսլա () գործառույթներ: Այս գործառույթները վերափոխվում եւ վերադարձվում են գծի սկզբում առկա ցանկացած թվով, անտեսելով ոչ-թվային ոչ թվային նիշ: Մաղարուխտ () գործառույթի գործընթացները միայն ամբողջ թիվն են, իսկ պարաշինությունը () եւ ամբողջ թվերը եւ լողացող կետերը: Եթե \u200b\u200bտողը սկսվում է «0x» կամ «0x» -ով, փորագրումը () այն մեկնաբանում է որպես վեցանկյուն: Օրինակ:

Parseint («3 կույր մկներ»); // Վերադարձնում է 3-ը:
Parsefloat («3.14 մետր»); // վերադառնում է 3.14:
Parseint ("12.34"); // Վերադառնում է 12-ին:
Parseint ("0xff"); // Վերադառնում է 255:

Մաղարուխտի () գործառույթը կարող է ունենալ երկրորդ փաստարկ, որը ցույց է տալիս վերամշակված համարի քանակի հիմքը: Վավեր արժեքներ - 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)

Եթե \u200b\u200bParseint () եւ parsefloat () չի կարող սահմանված տողը վերափոխել համարին, նրանք վերադառնում են Նան:

Parseint ("տասնմեկ"); // վերադարձնում է նանին:
Parsefloat («72,47 դոլար»); // վերադարձնում է նանին:

Ոչ մի տարբերություն չկա, թե ինչ տեսակի փոփոխական է օգտագործվում արտահայտությամբ: Եթե \u200b\u200bարտահայտությունը մաթեմատիկական է, նրա բոլոր փոփոխականներն ինքնաբերաբար մեկնաբանվելու են որպես թվային: Եթե \u200b\u200bտողերը մշակվեն, ապա արտահայտությունների բոլոր «մասնակիցները» համարվում են տողեր: Այնուամենայնիվ, փոխակերպման առաջադրանքը javaScript- ի «տողի համար» գոյություն ունի շատ ավելի լայն համատեքստում:

Թվերի փոխակերպման javascript մեթոդներ թվերով

Թվերի մեջ տողերը վերափոխելու համար «Արսենալի» մեթոդները մեծ չեն, բայց բավարար են բոլոր պարզ դեպքերում: Այստեղ JavaScript- ը (հատկապես սկսնակների համար) Արդյոք գործնական օրինակներով պարզից բարդ է ուղին:

Օրինակը նկարագրում է չորս տարբեր տող: Արդյունքի տիպի առաջին բլոկում յուրաքանչյուրը Փոփոխական գործառույթ Մուտքագրումը սահմանվում է որպես լար: Այնուհետեւ յուրաքանչյուր տող շատ ուղղակի փոխարկվում է համարի: Երկրորդ ելքային բլոկում փոխակերպումից հետո փոփոխականների փոփոխությունները տեսանելի են, դրանց տեսակը դարձել է մի շարք: JavaScript Parasefloat- ի վերափոխման օրինակն առանձնահատուկ ցուցիչ է. Այն «12E + 3» էր, այն դարձավ «12000»:

Փոփոխությունները տողը մի թվով վերածելիս կարող է նշանակալի լինել: Բայց կարեւոր են միայն առաջին նիշերը. Դրանք պետք է թվային լինեն: Եթե \u200b\u200bչկա մեկ թվային խորհրդանիշ, արդյունքը կլինի նան:

Թվի միջոցով «դարձել է» լարային վերափոխումը միշտ չէ, որ նույն տողը չէ: Այս պահը կարող է օգտագործվել թվային տեղեկատվության մուտքագրման ճիշտությունը ստուգելու համար:

Պայմանական վերափոխման մեթոդներ

Կան ամբողջ թվեր, եւ կան կոտորակ, համապատասխանաբար, javaScript շարքը դեպի թիվը,

parseint;
parseflous.

Ընդհանուր գործը իրականացվում է տողի միջոցով `պարզ մաթեմատիկական արտահայտությամբ:

Բավական է «+» խորհրդանիշի առջեւ դնելը, եւ եթե դրա մեջ կա մի շարք, արտահայտության արդյունքը կլինի թիվը: Փոփոխականի արժեքը կարող է փոխվել, բայց տեսակը միշտ կփոխվի. Տեսակը ցույց կտա համարը, ոչ լարային: Կարեւոր է հասկանալ, որ տողային արտահայտության մեջ փոխակերպված փոփոխականի օգտագործումը կարող է ցույց տալ բոլորովին այլ արդյունք:

Այս համատեքստում սկսնակների համար JavaScript- ը չափազանց պարզ է: Ավելի դժվար է հասկանալ Pasrseint մեթոդով ամբողջական փոխարկման աշխատանքը, քանի որ այն աշխատում է մեքենայում տասնորդական համակարգ Համարը, բայց կարող է տողը մեկնաբանել որպես օկտալ կամ վեցանկյուն: Այս դեպքում այս հանգամանքը միշտ չէ, որ կախված է երկրորդ պարամետրից, որը ցույց է տալիս համարների համակարգը:

JavaScript տող համարին միշտ շրջվում է, բայց եթե գծի սկզբում թվային խորհրդանիշ չկա, ապա արդյունքը կլինի նան:

Անհրաժեշտ է գաղափարներ ունենալ թվերի համակարգերի վերաբերյալ, վեցանկյունների ձայնագրման մեթոդների մասին (համարը սկսվում է «0x») եւ օկտալային համարներով (թիվը սկսվում է «0»):

JavaScript մեթոդի նրբությունները հասկանալու համար, որը պարունակում է, որ գաղափար ունենա, թե ինչ մաթեմատիկական գրառումը իրական թիվ է:

Դարձ

JavaScript- ը զննարկչի լեզու է, քանի որ այն ավելի շատ լեզուներ են, որոնք քննադատում են լատինական այբուբենի եւ համարների հիմնական շարքից դուրս խորհրդանիշներին: Տեսակ - փրկված գործողություն: Բայց միշտ չէ, որ իմաստ ունի տվյալներ ցուցանակների տեսակավորելու համար սերվերին ուղարկելու համար, ավելի հեշտ եւ գործնական աշխատելու համար:

Նման առաջադրանքի լուծման համար կարող եք լարային խորհրդանիշները վերածել իրենց թվային կոդերի մեջ կամ նշանակել թվերի պատվերով հաջորդականություն իրենց թվային կոդերում կամ թվանշանային եւ թվանշանային: Լարով կիրառվող Charcodeat () մեթոդը նշանակում է IB փոփոխականի 98 թվային արժեք, այսինքն, «B» տառը: Հաշվի առնելով, որ «Ա» տառի կոդի արժեքը 97 է, կարող եք լատինական այբուբենի բոլոր տառերի քանակը ձեռք բերել աճող կարգով `գծի եւ մեծատառերի հավաքածուների վրա: Նման է ռուսական այբուբենի տառերին:

Սեփական տեսակավորման տարբերակներով թվերը թույլ են տալիս ձեւավորել նիշերի ցանկալի հավաքածուներ: Օրինակ, հնարավոր է «ընդհատել» կիրիլյան եւ լատիներենը եւ խառնել դրանք, որպեսզի թողնի միայն գրավոր նամակներ, ավելացրեք ներդիրների եւ տարածությունների հավաքածուներ:

Տողի եզակի քանակի ձեւավորում

Եթե \u200b\u200b«Ա» տառը 97 է, ապա նամակի եւ 97-րդ համարի միջեւ տարբերությունը յուրահատուկ թվով կտա այբուբենի մեջ: Ամփոփելով եզակի համարները յուրաքանչյուր տողի խորհրդանիշի համար, դժվար է ստանալ այս տողի եզակի քանակը:

Եթե \u200b\u200bտողի մեջ տառի յուրաքանչյուր դիրքը նշանակված է քաշ, օրինակ, դիրքը.

0 քաշ 1;
1 քաշ 10;
2 քաշ 100;

Այն բազմապատկում է տողի յուրաքանչյուր բնույթի եզակի քանակը այն դիրքի ծանրության վրա, որում այն \u200b\u200bհայտնաբերվում է, եւ ամփոփելով բոլոր համարները, կարող եք ստանալ եզակի համարը եւ օգտագործել այն որպես բնօրինակ գծի մեջ որպես միանշանակ նամակագրություն:

Նման շարքի փոխարկումը հետադարձելի է, այսինքն, այն թվով, որը միշտ կարող եք ստանալ աղբյուրի գիծը: Նման վերափոխումը ձեռնտու է, քանի որ մի շարք կարող եք ցանկացած գործողություն ապահով կերպով կատարել կայքի էջի կոդավորման, կիրիլյան եւ այլ տեղական առանձնահատկությունների համատեքստում, դիմումի դաշտ:

«Մեծանում» կայքի էջի ընտրողներ

Այն հաճախ տեղի է ունենում կայքի էջերում ընտրողների ստեղծման խնդիր, որի արժեքները նախապես հնարավոր չէ հստակեցնել, բայց ժամանակի ընթացքում դրանք լրացվում են: Առաջին հերթին դատարկ ընտրիչը հասանելի է առաջին այցելուին, տեղեկատվություն ստանալու համար:

Ընտրողի տեղեկատվական գծերի յուրաքանչյուր նոր մուտք (ցանկացած այցելուի կողմից) վերածվում է այն համարի, որը, բնօրինակով, ուղարկվում է պահեստային սերվերին: Երբ սկսվում է նոր աշխատանքային նստաշրջան կամ նոր այցելու է գալիս, ընտրիչը այլեւս դատարկ չէ: Ներբեռնման էջը զննարկիչ է գալիս ոչ դատարկ ընտրողով:

Յուրաքանչյուր նոր ընտրողի արժեքով, միայն այն պահից հետո այն գնում է պահեստային սերվեր եւ միայն այն ժամանակին նշանակվում է եզակի թվային կոդ:

Այս առաջադրանքը լուծելու համար JavaScript- ի մեթոդը չի կարող օգտագործվել անընդմեջ օգտագործելու համար: Սովորական մաղադանտ եւ պարսեֆլաթի մեթոդները նախատեսված են այլ օգտագործման համար, բայց դուք կարող եք գալ ալգորիթմ, թվով տողի միանշանակ փոխարկման համար եւ պարտադիր չէ: Բավական է, որ փոխակերպման ալգորիթմի ալգորիթմը չի կրկնվի գծի կերպարների տարբեր հավաքածուներով:

Traff անապարհային օպտիմիզացում եւ վերլուծություն

Էջ ձեւավորելիս ծրագրավորողը օգտագործում է զգալի քանակությամբ տեղեկատվություն: Տեղեկատվություն մուտքագրելու համար այցելու է. լավ միջոց Կայքի վարկանիշը իջեցնելու պատճառով իր թույլ գործունակության պատճառով եւ հիասթափեցրեք այցելուին:

Որոշ տեղեկատվական բլոկների այցելուի գործողություններին javaScript- ի գործառույթի ձեւով նշանակելով միջոցառման գործառույթ, կարող եք ձեւավորել զտիչ, որը թույլ կտա այցելուին ճշգրիտ դնել անհրաժեշտ տեղեկատվություն, ստացեք ցանկալի լուծում:

Փոքրատառ տեղեկատվության վերափոխումը այստեղ կարող է լինել կամայական հզորություն գծի մի մասում եւ թվով շատ փոքր: Այլ կերպ ասած, JavaScript տողի վերափոխումը մշակողների թվով ելույթ է ունենում ըստ իր ալգորիթմի: Այցելուն շահագործում է հասկանալի տեղեկատվությունը, եւ սերվերը ունի նվազագույն քանակությամբ տվյալների, մի շարք:

Բոլոր այցելուների վերաբերյալ բազմաթիվ այցելուների դինամիկան, ինչպես հայտնի տեղեկատվության համատեքստում, թույլ է տալիս JavaScript- ի մեկ այլ գործառույթ (ոչ թե բեռնաթափող), որը կոչվում է սերվերի պատասխան, AJAX մեխանիզմի միջոցով, միաժամանակ բոլոր այցելուներին անհրաժեշտ տեղեկատվություն տալու համար: Այսպիսով, համակարգն աշխատում է:

JavaScript Row- ի վերափոխման այս տարբերակը շատ պահանջարկ ունի առցանց խաղերի, ինտերակտիվ գիտաժողովների, փոխանցման զարգացման մեջ Ակնթարթային հաղորդագրություններ Եվ այլն

Փոխակերպումների գործիք

JavaScript- ը եւ CSS- ը վերամշակման համատեքստում Թվային տեղեկատվություն Թույլ տվեք կառավարել էջի ցուցադրումը առանց սերվերի մասնակցության: CSS կանոնները կառուցվում են որպես ենթաշերտ, ռեգշիվ: Սովորաբար պարամետրը այն համարն է, որին հաջորդում են մի քանի տառեր (օրինակ, «PX», «PT», «Էմ», ...): Պարամետրը ենթարկվում է կանոնակարգում, եւ կանոնը ենթադրում է սուբստրրոպ, դասի կամ նույնականացման ոճով:

Վերականգնում javascript.strete. Կառուցվածքը ... գնում է ցանկալի համարին, տողից վերածվում է համարի, փոխում է այն եւ գրում է ցանկալի վայր: Կանոն փոփոխվում է «մեքենան»: Այն շատ պարզ եւ հարմար է, սերվերի մասնակցություն չկա:

Լարը JavaScript- ին փոխարկելու երկու հիմնական եղանակ կա: Մի ճանապարհ է այն վերլուծել, եւ մեկ այլ եղանակ. Փոխեք դրա տեսակը համարին: Այլ պատասխանների բոլոր հնարքները (օրինակ, Unary Plus) ենթադրում են տողի պես ենթադրյալ հարկադրանքի համար: Կարող եք նաեւ նույնը անել համարի գործառույթով:

Սինթոլտային

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

parseint- ը եւ Parsefloat- ը երկու գործառույթ են, որոնք օգտագործվում են թվերի շարքերը վերլուծելու համար: Սինտաքսի վերլուծությունը լուռ կդադարի, եթե այն ընկնի խորհրդանիշի մեջ, որ այն չի ընդունում, որ այն կարող է օգտակար լինել տողերի սինթակտիկ վերլուծության համար, օրինակ, «92Px», քանի որ դա նույնպես ոչ մի սխալ չի թույլ տա Մուտքագրեք, փոխարենը դուք «վերադառնում եք nan, եթե լարը չի սկսվում թվից: Գծի սկզբում անտեսվում է: Ահա այն, ինչ նա ինչ-որ բան է անում Սխալ է.

Var widgetssold \u003d parseint ("97,800", 10); // widgetssold- ն այժմ 97 է

Լավ պրակտիկան միշտ նշում է որպես երկրորդ փաստարկ: Հին զննարկիչներում, եթե տողը սկսվեց 0-ով, այն մեկնաբանվելու էր որպես օվկիանոս, եթե այն չնշվի ռադիքսի արժեքով, ինչը զարմանալիորեն գրավեց ռադիքսի արժեքով: Hexadecimal գործարկման պահվածքը սկսվում է, եթե տողը սկսվում է 0x- ով, եթե ճառագայթների արժեքը նշված չէ: 0xff. Ստանդարտը, ըստ էության, փոխվել է EcmaScript- ի օգտագործմամբ Ժամանակակից զննարկիչներ Այլեւս Octal- ը չի վարվում, երբ հյուրընկալողը նշվում է, եթե ճառագայթների արժեքը նշված չէ: Փարլեինը ռադիկները հասկանում է 36-ի հիմքի վրա, եւ այս դեպքում թիվ եւ փոքրատառ տառերը վերամշակվում են համարժեք:

Լարային տեսակը Փոխվում է ըստ համարի

Վերոնշյալ բոլոր մյուս հնարքները, որոնք չեն օգտագործում մաղադանեխ, ենթադրում են տողի ենթադրյալ հարկադրանքը համարին: Ես նախընտրում եմ դա անել հստակ

Var Cast \u003d համարը ("97");

Սա տարբերվում է վերլուծության մեթոդներից (չնայած այն դեռ անտեսում է տարածությունները): Դա խիստ է. Եթե այն չի հասկանում ամբողջ գիծը, քան նանը վերադառնում է, այնպես որ դուք չեք կարող օգտագործել այն 97px տիպի տողերով: Քանի որ ձեզ հարկավոր է պրիմիտիվ թիվ, ոչ թե համարի փաթաթված օբյեկտը, համոզվեք, որ դուք նորը չեք դնում նախքան թվից գործառույթը:

Ակնհայտ է, որ համարի փոխարկումը ձեզ հնարավորություն է տալիս լինել մի արժեք, որը կարող է լինել լողալ, եւ ոչ մի ամբողջ թվով, այնպես որ, եթե ցանկանում եք ամբողջ թիվ, անհրաժեշտ է փոխել այն: Դա անելու մի քանի եղանակներ կան.

Var կլորացված \u003d մաթեմատիկա (համարը («97.654»)); // այլ Ընտրանքներն են Math.Ceil, Math.Round Var Fixed \u003d համարը ("97.654"): Tofixed (0); // կլորացված, այլ ոչ թե կրճատված var bitwised \u003d համարը ("97.654") | 0; // մեծ թվերի համար մի օգտագործեք

Ditter անկացած դառը օպերատոր (ահա ես օրհնություն եմ կամ, բայց կարող եք նաեւ կրկնակի ժխտվել, քանի որ ավելի վաղ պատասխանում կամ բիթ հերթափոխը) վերածում է 32-բիթանոց ամբողջ թվին: Նկատի ունեցեք, որ սա Մեծ թվերի կարիք չի լինի, Եթե \u200b\u200bամբողջ թիվը կարող է ներկայացվել 32 բիթում, այն կավարտվի:

~~ "3000000000.654" \u003d\u003d\u003d -1294967296 // Սա նույնն է, ինչ համարը ("3000000000.654") | 0 "3000000000.654") \u003e\u003e\u003e 0 \u003d\u003d\u003d 3000000000 // Չստորագրված ճիշտ հերթափոխը ձեզ լրացուցիչ բիթ է տալիս "300000000000.654" \u003e\u003e 0 \u003d\u003d\u003d 3647256576 // բայց դեռեւս ձախողվում է ավելի մեծ թվերով

Խոշոր թվով ճիշտ աշխատելուն, դուք պետք է օգտագործեք կլորացման մեթոդներ

Math.Floor ("3000000000.654") \u003d\u003d\u003d 3000000000 // Սա նույնն է, ինչ մաթեմատիկա (համարը ("3000000000.654"))

Հիշեք, որ այս բոլոր մեթոդները հասկանում են էքսպոնենցիալ նոտան, հետեւաբար 2E2- ը 200 է, եւ ոչ նան: Բացի այդ, համարը հասկանում է «անսահմանությունը», մինչդեռ վերլուծության մեթոդները չեն:

Մաքսատուրք

Սխալ է, որ այս մեթոդներից որեւէ մեկը կատարում է հենց այն, ինչ ցանկանում եք: Օրինակ, ինձ սովորաբար անհրաժեշտ է սխալ, որը տեղի է ունենում այն \u200b\u200bժամանակ, երբ շարահյուսական վերլուծության ձախողումը, եւ ինձ պետք չէ անսահմանության աջակցություն, ցուցահանդեսներ կամ առաջատար բացեր: Կախված ձեր օգտագործումից, երբեմն իմաստ ունի գրել օգտվողի փոխակերպման գործառույթ:

Միշտ ստուգեք, որ վերլուծության մեթոդներից մեկի արդյունքը կամ վերլուծության մեթոդներից մեկը եք ակնկալում: Դուք, անշուշտ, ցանկանում եք օգտագործել Isnan- ը `համոզվելու համար, որ համարը NAN- ը չէ (սովորաբար սա միակ միջոցն է, պարզելու, որ շարահյուսական վերլուծությունը ձախողվել է):

JavaScript- ում Թվերի մեջ շարքերը վերափոխելու համար կա 2 ներկառուցված գործառույթ, պարսե հատ () եւ փորձնական ():

parsefloat () Փաստարկը տանում է մի տող, որը պետք է բերվի թվային տիպի եւ վերադառնա տիպի բոցերի քանակը: Համարը պետք է պարունակվի գծի սկզբում: Եթե \u200b\u200bգծի մի շարքից հետո դեռ կան որոշ կերպարներ, ապա դրանք կտրում են: Համարի կոտորակային մասը պետք է գրանցվի կետի միջոցով (ստորակետը չի ընկալվում որպես բաժանարար): Եթե \u200b\u200bպարունակում է լարային () չի կարող տող վերածել, այն վերադառնում է նանին:

Բացի այդ, գործառույթը կարող է կարգավորել «Num n բազմապատկվելը 10-րդ աստիճանի x» - ով, որը ծրագրավորմամբ սովորական է գրառում E տառով, օրինակ `0.5e6 կամ 0.5e + 6: Աստիճան կարող է լինել նաեւ բացասական. 0.5E-6, որը 0,5 * 10 ^ -6 կամ 0.5/0000 է:

Parsefloat ("3.78 կգ) // 3.78 Parsefloat (" "KG33" ") // na 0004.111" ") // 4.111") // 0. ") // 0,5 պարսլա (" "-. 5" "») // -0.5 պարսլոտ ("" 0,5E6 "") // 500000 պարսա ("" "3E- 4 "" ») // 0.0003 Պարսափելի (" "- 3E-4" ») // -0.0003

Պարսինգը (լարային [Radix] առանձնահատկությունը տողը տանում է որպես առաջին փաստարկ, վերլուծում է այն եւ վերադարձնում է ամբողջ թիվ (տիպի ամբողջ թիվ): Գործառույթը փորձում է վերլուծել այն համակարգը, որում նշված է համարը ձայնագրվում է աղբյուրի գծում (օրինակ, տասնորդական, օկտալ կամ վեցանկյուն, բայց ոչ միայն դրանք): Բացի այդ, համարների համակարգը կարող է հստակ հստակեցվել `այն անցնելով Radix- ի երկրորդ պարամետրով: Radix պարամետրը կարող է ցանկացած թիվ վերցնել 2-ից 36 (10-րդից բարձր համակարգերում, օգտագործվում են անգլերեն այբուբենի տառերը, A- ից Z):

Համարների տեսակը 1.5e6 Գործառույթը չի վարվում որպես պարաշյուտային ():

Խնդրում ենք կարդալ հետեւյալ օրինակները, որպեսզի որոգայթները չդարձնեն, օգտագործվեն պարաշյուտարի () գործառույթի շահագործման մեջ:

Parseint ("" 25 "") // 25 Պարսինտ ("" - 25 "") // -25 Պարսինգ ("" 45.12 "") // 45 parseint ("045" 70 ", 8) //56 (70-ը` օկտալ համակարգում, տասնորդական) փորվածքի ("070") // 56 (Կարեւոր! Zero Կխնդրեն գործառույթը) Parseint ("" 88 "", 8) // NAN (Octal System No Digit 8) Parseint ("" A1 ") // NAN (կարեւոր է), Եթե \u200b\u200bչլինի սկզբնական շարքերում 0x) parseint ("" "A1" ", 16) // 161 (այստեղ հստակ նշվում է համարների համակարգով) Parseint (D 161). Դուք չեք կարող նշել երկրորդ պարամետրը) Parseint ("099" ") // 0 (Կարեւոր! Համարը ընկալվում է որպես օվկիանոս, բայց պարունակում է անվավեր նիշ) // 0 (Կարեւոր: !! ՉԻ ԱՇԽԱՏԱՆՔ, ՈՐՊԵՍ ՊԱՐՍԵՅԼՈՏՈՎ) Պարսինտ ("" ZZ "", 36) // 1295 Parseint ("- FF" ") // Նան Պարսինտ (" - FF "», 16) // -255

Եթե \u200b\u200bտվյալներ եք մշակում Տեքստի դաշտԴա մտնում է օգտագործողին, միշտ օգտագործեք փորվածքի () երկրորդ ռադիքս պարամետրերի հետ միասին, այն կպաշտպանի ձեր ծածկագիրը անսպասելի արդյունքներից:

JavaScript- ում Թվերի մեջ շարքերը վերափոխելու համար կա 2 ներկառուցված գործառույթ, պարսե հատ () եւ փորձնական ():

Համարների տեսակը 1.5e6 Գործառույթը չի վարվում որպես պարաշյուտային ():

Եթե \u200b\u200bդուք օգտագործում եք տվյալ տեքստի դաշտից տվյալներ, որոնք մուտք են գործում օգտագործող, միշտ օգտագործեք փորվածքը () Radix- ի երկրորդ պարամետրը, այն կպաշտպանի ձեր ծածկագիրը անսպասելի արդյունքներից: