Az interneten egyszerűen használhatunk számokat a megjelenítéshez olvasatlan üzenetek, megjegyzések, tetszésnyilvánítások, tweetek és így tovább, ha a számok formázásáról van szó egy bankban vagy pénzintézetben, a számok megjelenítése további munkát igényelhet.

Ha a számokat pénznem formátumban kell megjeleníteni, vagy vesszővel kell elválasztani, akkor biztosan tetszeni fog ez a javascript könyvtár a számok pénznemben történő formázásához.

Ma arról szeretnénk beszélni, hogyan lehet könnyen és egyszerűen megvalósítani egy ilyen funkciót, és egy példát mutatunk be. Tehát kezdjük.

Elkezdeni

Az Accounting.js egy JavaScript-könyvtár, függőségek nélkül. A könyvtár használatához nem kell integrálnia a jQuery-t. Töltse le a forráskódot a webhelyről, helyezze el a megfelelő könyvtárba, majd hivatkozzon a HTML-dokumentumban lévő fájlra.

Alapvető formázás

Az Accounting.js számos módszert kínál a számok formázására. És az első a formatMoney(). Ez a módszer az alapfunkció a közönséges számok pénznemre váltásához. Használatához minden metódust inicializálunk a könyveléssel, majd a metódus nevét használjuk. Például:

Számvitel.formátumMoney(2000000);
Alapértelmezett beállításokkal a fenti Accounting.js USD-jellel, három számjegyenként vesszővel, valamint a dollár és a cent elválasztásával jelenik meg.

$2,000,000.00
Egyes országok minden három számjegyhez (ezer) más elválasztót használnak. Az Accounting.js teljes mértékben lokalizálható. Ha nem tetszik az alapértelmezett pénznemmegjelenítés, a Beállítások segítségével módosíthatja.

Az alábbiakban hadd mondjak egy példát Németországból, amely nem használ elválasztót ezreknél:

Accounting.formatMoney(2000000, (
szimbólum: "€",
ezer: ".",
tizedes: ",",
});
Adott kód ennek eredményeként a következőket kapjuk:

€2.000.000,00
Ha a számokat pénznemszimbólum megadása nélkül szeretné formázni, használhatja a formatNumber() metódust:

Számok kerekítése

A számoknak lehetnek törtosztásai is, de megszoktuk, hogy a legközelebbi egész számra kerekítsük őket. Az Accounting.js-ben erre használhatjuk a .toFixed()-et. Ez a példa bemutatja, hogyan zárhatunk ki törtszámokat, valamint hogyan kerekíthetünk egész számokat a legközelebbi értékre:

könyvelés.Fixed(102.58, 0);
Ennek eredményeként a következőket kapjuk:

103
Egyszerű valutaváltó készítése

Ebben a részben a fenti függvényeket használjuk egy egyszerű valutaváltó kifejlesztésére. Semmi divatos, csak három pár, hogy megmutassa, hogyan működik az Accounting.js.

BAN BEN ezt a példát az USD-t 2 pénznemre váltjuk át: KRW (koreai von) és JPY (japán jen).

Használjuk a következő dokumentumszerkezetet:

Tól től

Amerikai dollár

$

Nak nek

Koreai Won
japán jen

₩ 0


Ahogy fentebb látható, itt van 2 sor div elemekkel. Az első sor az opciók legördülő listáját tartalmazza, amely USD értékre van állítva, és le van tiltva, mert a felhasználók nem választhatnak pénznemet ebben a mezőben. Ebben a sorban található egy szám típusú beviteli mező is, ahol meg kell adni az átváltandó USD összeget.

A második sorban van egy legördülő menü is, amely 2 valutát tartalmaz: a koreai vont és a japán jent. Mindegyik opciónak van egy érték attribútuma és egy adatszimbólum, amely a pénznem szimbólumát fogja tartalmazni. A konvertált eredmény megjelenítéséhez span elemet használunk.

Idézetek

A cikk írásakor 1 USD 1077,80 KRW-nak és 102,24 JPY-nek felelt meg. Ezeket a valós idejű árajánlat értékeket a használatával kaphatjuk meg. Azonban tovább Ebben a pillanatban egyszerűen beírjuk az értéket a változóba a .toFixed() metódussal, hogy kerekítsük az értéket:

Varjpy = accounting.toFixed(102.24; 0),
krw = accounting.toFixed(1077,80, 0),
Választási lehetőséget biztosítunk

getCurrency = function(elem) (
var $curAbbr = elem.find(":selected").val(),
$curSign = elem.find(":selected").data("szimbólum");
Visszatérés (
"symbol": $curSign,
"érték" : $curAbbr,
};
};
Konvertálási függvény

Az átalakításnak valós időben kell megtörténnie. Ez azt jelenti, hogy ez akkor történik meg, amikor a felhasználó számokat ír be a beviteli mezőbe, vagy vált a pénznemek között.

Ennek elérése érdekében az #output-currency, valamint az #input-number paramétereket alkalmazzuk 3 javascript eseménnyel, amelyeket változásnak nevezünk, és:

$("#output-currency, #input-number").on("keyup keydown", function() (
// dolog
}
Ezután a fent létrehozott getCurrency függvény segítségével kérjük le az értéket a legördülő menüből, #output-currency . Az értékek két változóban, a $symbol és a $val vannak elválasztva az alábbiak szerint.

Var $currency = getCurrency($("#output-currency")),
$symbol = $currency["szimbólum"],
$érték = $valuta["érték"];
A beviteli mezőből ki kell kapnunk a számot is, valamint az aktuális idézőjelek értékét, amit a jpy és a krw változókban beállítottunk. Egy feltételes függvény segítségével eldönthetjük, hogy melyik idézetet (krw vagy jpy) használjuk.

// számot kap
var mulitplyNum = ($val == "jpy") ? jpy: crw;
var $getInput = $("#bemeneti szám").val();
A fenti számok felhasználásával kiszámítjuk az eredményt.

Var $getTotal = ($getInput * mulitplyNum);
Mielőtt azonban kinyomtatnánk a számot, csomagoljuk megfelelő formátumba a .formatMoney() metódussal:

Varnumber = accounting.formatMoney($getTotal, (
szimbólum: $szimbólum,
pontosság: 0
ezer: ","
});
És végül kiadjuk a végső számformátumot:

$("#kimenet-szám").szöveg(szám);
Kész! A bemutatót alább tekintheti meg.

Ebben a cikkben közelebbről megvizsgáljuk a számokat, a matematikai operátorokat, a számok karakterláncsá alakításának módjait és fordítva, valamint sok más fontos pontot.

véges függvény

Az isFinite függvény lehetővé teszi annak ellenőrzését, hogy egy argumentum véges szám-e.

Válaszként adott funkciót false értéket ad vissza, ha az argumentum Infinity , -Infinity , NaN , vagy ha ezen speciális numerikus értékek valamelyikére lesz öntve. Ellenkező esetben ez a függvény true -ot ad vissza.

IsFinite(73); // igaz isVéges(-1/0); // false isFinite(Infinite); // false isFinite(NaN); // false isFinite("Szöveg"); // hamis

Az isFinite globális függvényen kívül a JavaScript rendelkezik a Number.isFinite metódussal is. Az isFinite-tel ellentétben nem kényszeríti az argumentum számmá alakítását.

IsFinite("73"); // igaz Number.isFinite("73"); // hamis

isNaN függvény

Az isNaN függvény annak meghatározására szolgál, hogy egy argumentum szám-e, vagy számmá alakítható-e. Ha igen, akkor az isNaN függvény false értéket ad vissza. Ellenkező esetben igazat ad vissza.

IsNaN(NaN); //igaz isNaN("25px"); //igaz, mert 20px nem szám isNaN(25,5); //hamis isNaN("25,5"); //hamis isNaN(" "); //hamis, mert egy szóközt vagy több szóközt 0-ra alakítunk át isNaN(null); //hamis, mert null értéket 0-ra konvertálunk isNaN(igaz); //hamis, mert igaz 1-re konvertálódik isNaN(hamis); //hamis, mert hamis értéket 0-ra konvertálunk

Ha ezt a műveletet típusátadás nélkül kell végrehajtani, használja a Number.isNaN metódust. Ezt a módszert az ECMAScript 6 óta vezették be a nyelvbe.

Hogyan lehet egy karakterláncot kifejezetten számmá alakítani?

Egy karakterláncot kifejezetten átadhat egy számra a következő módszerekkel:

1. Használja az unáris + operátort, amelyet az érték elé kell helyezni.

+"7,35"; // 7,35 +"szöveg"; // NaN

Ez a módszer figyelmen kívül hagyja a szóközöket a sor elején és végén, valamint a \n-t (soremelés).

+"7,35"; //7,35 +"7,35\n"; //7.35

Használata Ily módon vegye figyelembe, hogy egy üres karakterláncot vagy egy szóközökből és \n-ből álló karakterláncot a rendszer 0 számmá alakítja. Ezenkívül a null adattípust és a logikai értékeket is számmá alakítja.

Nulla; //0 +igaz; //1 +hamis; //0 +" "; //0

2. ParseInt függvény. Ez a függvény arra szolgál, hogy egy argumentumot egész számmá alakítson. Az unary + operátortól eltérően ez a módszer lehetővé teszi egy karakterlánc olyan számmá alakítását, amelyben nem minden karakter numerikus. Elkezdi konvertálni a karakterláncot, az első karaktertől kezdve. És amint olyan karakterrel találkozik, amely nem numerikus karakter, ez a függvény leállítja a munkáját, és visszaadja a kapott számot.

ParseInt("18px"); //18 parseInt("33,3%"); //33

Ez a funkció használható különböző rendszerek számozás (bináris, oktális, decimális, hexadecimális). A számrendszer alapjának jelzése 2 argumentum segítségével történik.

ParseInt("18px", 10); //18 parseInt("33,3%, 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

A parseInt függvényen kívül a JavaScript rendelkezik a Number.parseInt metódussal. Ez a módszer nem különbözik a parseInt függvénytől, és az ECMASCRIPT 2015(6) specifikációval vezették be a JavaScriptbe.

3. ParseFloat függvény. A parseFloat függvény hasonló a parseInt függvényhez, kivéve, hogy lehetővé teszi az argumentum törtszámmá alakítását.

ParseFloat("33,3%"); //33.3

Ezenkívül a parseFloat függvény a parseInt-től eltérően nem rendelkezik 2 argumentummal, ezért mindig megpróbálja a karakterláncot decimális jelölésű számként kezelni.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

A parseFloat függvényen kívül a JavaScript rendelkezik a Number.parseFloat metódussal. Ez a módszer nem különbözik a parseFloat függvénytől, és az ECMASCRIPT 2015(6) specifikációval vezették be a JavaScriptbe.

Szám konvertálása karakterláncra

Egy számból karakterláncot alakíthat a toString metódussal.

(12.8).toString(); //"12,8"

A toString metódus lehetővé teszi a számrendszer alapjának megadását is, ennek figyelembevételével a számot kifejezetten a karakterláncba kell önteni:

(255).toString(16); //"ff"

Hogyan ellenőrizhető, hogy egy változó szám-e

A következő módszerek egyikével határozhatja meg, hogy egy változó értéke szám-e:

1. Az isNaN és az isFinite függvények használata:

// myVar egy változó if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //sajátVar egy szám vagy átadható rá );

Funkcióként:

// függvény függvény isNumeric(value) ( ​​Return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // usage var myVar = "12px"; console.log(isNumeric(myVar)); //igaz

Ez a módszer lehetővé teszi annak meghatározását, hogy a megadott érték szám-e, vagy átalakítható-e arra. Ez a változat nem számol számként egy üres karakterláncot, egy szóköz karakterláncot, null , Infinity , -Infinity , igaz és hamis.

2. Használata operátor típusaés függvényei isFinite, isNaN:

// függvény, amely ellenőrzi, hogy az érték szám-e függvény isNumber(value) (érték típusa === "szám" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Ez a függvény határozza meg, hogy a megadott érték Number típusú-e, és azt is, hogy az egyikhez tartozik-e különleges értékek Infinity, -Infinity és NaN. Ha igen, akkor ez a függvény igazat ad vissza.

3. Az ECMAScript 6 Number.isInteger(value) metódusának használata. Ez a módszer lehetővé teszi annak meghatározását, hogy a megadott érték egész szám-e.

Number.isInteger("20"); //hamis, mert ez a metódus nem fordítja le a karakterláncot számmá Number.isInteger(20); //igaz, mert adott értéket egy szám

Páros és páratlan számok

Ezzel ellenőrizheti, hogy egy szám páros vagy páratlan-e következő funkciókat:

// Függvény annak ellenőrzésére, hogy egy szám páros-e függvény isEven(n) ( return n % 2 == 0; ) // Függvény annak ellenőrzésére, hogy egy szám páratlan-e függvény isOdd(n) ( return Math.abs(n % 2) == 1;)

Az ilyen ellenőrzés elvégzése előtt azonban kívánatos megbizonyosodni arról, hogy a megadott érték egy szám:

érték=20; if (Szám.isegész(érték)) ( if (isEven(érték)) ( console.log("Szám " + value.toString() + " - páros"); ) )

Prímszámok a Javascriptben

Tekintsünk egy példát, amelyben a felhasználást vezetjük le Javascript egyszerű számok 2-től 100-ig.

// Egy függvény, amely ellenőrzi, hogy egy szám prímfüggvény-e isPrime(érték) (if (isNaN(érték) || !isVéges(érték) || érték%1 || érték< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i (больше), < (меньше), >= (nagyobb vagy egyenlő), 3); //false console.log(5>=3); //igaz

A számok összehasonlításakor törtrész figyelembe kell venni a számítások során előforduló hibákat.

Például a JavaScriptben a számok összege (0,2 + 0,4) nem egyenlő 0,6-tal:

Console.log((0,2+0,4)==0,6); //hamis

Hibák azért fordulnak elő, mert minden számítás számítógépes vagy egyéb elektronikai eszköz 2 számrendszerben termel. Azok. Mielőtt bármilyen műveletet végrehajtana, a számítógépnek először át kell alakítania a kifejezésben szereplő számokat 2-es számrendszerré. De a 2. számrendszerben egyetlen tört decimális szám sem ábrázolható pontosan.

Például a 0,25 10 számot pontosan binárissá alakítjuk.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Például a 0,2 10 szám csak bizonyos pontossággal konvertálható 2-es rendszerré:

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 10 = 0,001100110011... 2

Ennek eredményeként ezek a hibák befolyásolják két szám összegének kiszámítását és az összehasonlítási eredményeket. Azok. kiderül, hogy a JavaScript a következőképpen fogja látni ezt a bejegyzést:

0.6000000000000001==0.6

Törtrészes számok kiszámításakor vagy megjelenítésekor mindig meg kell adni, hogy ezt milyen pontossággal kell elvégezni.

Hasonlítsa össze például a számokat 2 tizedesjegyig a toFixed() és toPrecision() metódusokkal:

//method toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //toPrecision() metódus console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //igaz

Alapvető matematikai műveletek

A JavaScript a következő matematikai operátorokkal rendelkezik: + (összeadás), - (kivonás), * (szorzás), / (osztás), % (osztás maradéka), ++ (érték növelése 1-gyel), -- (érték csökkentése 1-gyel) ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, azaz 6:3=2 => 6-3*2 => rest(0) 5%2 //1, azaz. 5:2=2(.5) => 5-2*2 => pihenés(1) 7,3%2 //1,3, azaz. 7,3:2=3(,65) => 7,3-2*3 => rest(1,3) //a művelet eredményének % előjele megegyezik az első érték előjelével -9%2,5 //-1,5, azaz. 9:2,5=3(,6) => 9-2,5*3 => pihenés(1,5) -9%-2,5 //-1,5, azaz. 9:2,5=3(,6) => 9-2,5*3 => pihenés(1,5) -2%5 //-2, azaz. 2:5=0(.4) => 2-5*0 => pihenés(2) x = 3; konzolnapló(x++); //3-at jelenít meg, majd y-t 4-re állítja console.log(x); //4 x = 3; konzolnapló(++x); //4-et állít be, és x = 5-öt ad ki; konzolnapló(x--); //5-öt ad ki, y ezután 4-et állít be console.log(x); //4 x = 5; konzolnapló(--x); //4-re állítja be, és a kimenetek Ezen kívül vannak kombinált operátorok a JavaScriptben: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). x=3; y=6; x+=y; konzolnapló(x); //9 x = 3; y=6; x-=y; konzolnapló(x); //-3 x = 3; y=6; x*=y; konzolnapló(x); //18 x = 3; y=6; x/=y; konzolnapló(x); //0,5 x = 3; y=6; x%=y; konzolnapló(x); //3