Ostatnia aktualizacja: 1.11.2015

Często istnieje potrzeba konwersji jednych danych na drugie. Na przykład:

varnumber1 = "46"; varnumber2 = "4"; varresult = liczba1 + liczba2; dziennik konsoli (wynik); //464

Obie zmienne reprezentują ciągi, a dokładniej ciągowe reprezentacje liczb. I w rezultacie otrzymamy nie liczbę 50, ale ciąg 464. Ale byłoby miło, gdyby można je też było dodawać, odejmować, w ogóle działałyby jak ze zwykłymi liczbami.

W takim przypadku możemy użyć operacji transformacji. Funkcja służy do konwersji ciągu na liczbę. parseInt():

varnumber1 = "46"; varnumber2 = "4"; var wynik = parseInt(liczba1) + parseInt(liczba2); dziennik konsoli (wynik); // pięćdziesiąt

Aby przekonwertować ciągi na liczby ułamkowe zastosowana funkcja parseFloat():

varnumber1 = "46.07"; varnumber2 = "4.98"; var wynik = parseFloat(liczba1) + parseFloat(liczba2); dziennik konsoli (wynik); //51.05

W tym przypadku ciąg może mieć mieszaną zawartość, na przykład „123hello”, czyli w tym przypadku są liczby, ale są też zwykłe znaki. Ale metoda parseInt() nadal będzie próbowała wykonać konwersję:

Varnum1 = "123cześć"; varnum2 = parseInt(num1); dziennik konsoli (num2); // 123

Jeśli metoda nie powiedzie się, zwraca NaN (Not a Number), co oznacza, że ​​ciąg nie reprezentuje liczby i nie można go przekonwertować.

Ze specjalną funkcją isNaN() możesz sprawdzić, czy ciąg reprezentuje liczbę. Jeśli ciąg nie jest liczbą, to funkcja zwraca prawdę, jeśli jest liczbą, to fałsz:

Var num1 = "javascript"; varnum2 = "22"; varresult = isNaN(num1); dziennik konsoli (wynik); // prawda - num1 nie jest liczbą wynik = isNaN(num2); dziennik konsoli (wynik); // fałsz - num2 to liczba

Powyżej rozważaliśmy tłumaczenie ciągów na liczby w system dziesiętny. Możemy jednak przetłumaczyć liczby na dowolny system. Domyślnie sam interpreter JavaScript odgaduje, na który system liczbowy chcemy przekonwertować ciąg (zwykle wybrany jest system dziesiętny). Ale możemy użyć drugiego parametru, aby wyraźnie wskazać, że chcemy przekonwertować ciąg na liczbę w określonym systemie. Na przykład konwersja na liczbę w system binarny:

Varnum1 = "110"; varnum2 = parseInt(num1, 2); dziennik konsoli (num2); // 6

Wynik będzie 6, ponieważ 110 w systemie binarnym to liczba 6 w systemie dziesiętnym.

Teraz napiszmy mały program, w której wykorzystujemy operacje na zmiennych:

Za pomocą funkcji prompt() w przeglądarce wyświetlane jest okno dialogowe z prośbą o wprowadzenie jakiejś wartości. Drugi argument tej funkcji określa domyślną wartość.

Jednak funkcja prompt() zwraca ciąg. Dlatego musimy przekonwertować ten ciąg na liczbę, aby wykonać na nim operacje.

Po otwarciu strony w przeglądarce zobaczymy zaproszenie do wpisania kwoty wpłaty:

Następnie podobny komunikat zostanie wyświetlony przy wprowadzaniu wartości procentowej. Na koniec program otrzyma dane, przekonwertuje je na liczby i wykona obliczenia.

JavaScript to język z dynamicznym wpisywaniem danych. Oznacza to, że możesz zapisywać wartości do tej samej zmiennej różne rodzaje, natomiast zmieni się typ samej zmiennej. Takie zachowanie często pozwala zapomnieć o różnym zachowaniu zmiennych z inny rodzaj, ale nadal trzeba pamiętać o tej funkcji. Pokażmy to w poniższym przykładzie.

console.log(suma(1, 2)); // 3 (tu wszystko jest w porządku) console.log(sum(1, "2")); // 12 (i nie tak dużo tutaj)

Jak widać na przykładzie, funkcja suma zachowuje się niepoprawnie, jeśli przynajmniej jeden z jego argumentów nie jest liczbą. Faktem jest, że podczas „dodawania” liczby do łańcucha, liczba jest konwertowana na łańcuch i łączona (sklejana) z drugim argumentem.

Aby uniknąć takich komplikacji, możesz podczas wykonywania skryptu poznać typ zmiennej i poprawić jej zachowanie lub uważnie monitorować typy zmiennych.

typ operatora

Ten jednoargumentowy operator przyjmuje absolutnie dowolną wartość jako operand i zwraca jej typ w zmiennej łańcuchowej.

JavaScript ma następujące typy danych:

// 1.) obiekt console.log(typeof()); // obiekt var p = (x: 1, y: 3); console.log(typeofp); // obiekt // 2.) funkcja funkcja sayHello() ( console.log("Hello!"); ) console.log(typeof sayHello); // funkcja // 3.) string console.log(typeof "JavaScript"); // string // 4.) liczba console.log(typeof 3.1415); // liczba // 5.) boolean console.log(typeof true); // boolean // 6.) undefined var notExistsOne; console.log(typeof notExistsOne); // niezdefiniowana console.log(typeof notExistsTwo); // nieokreślony

zauważ, że nieokreślony jest to również typ danych składający się z pojedynczej wartości.

Rzucać

Rzutowanie typu w programowaniu to konwersja wartości zmiennej jednego typu na wartość innego typu.
Często ta transformacja zachodzi bez kontroli programisty. Widać to na przykładzie z funkcją suma. Zmiana typu następuje, gdy wynik wykonania operacji na zmiennej oryginalnego typu nie jest jasny. Na przykład nie można dokładnie powiedzieć, co wyniknie z dodania ciągu z liczbą, ale operacja dodawania dwóch liczb jest oczywista i w tym przypadku logiczne jest sprowadzenie liczby do ciągu.

Konwertuj ciąg na liczbę

Czasami sam programista może zmienić typ zmiennej, wykonując na niej pewne operacje. Na przykład operacje inkrementacji lub dekrementacji na łańcuchu przekonwertują go na liczbę.

var c = "nie-liczba"; ++c; console.log(typ c); // NaN

Warto zauważyć, że nie musisz uciekać się do tej metody konwersji ciągu na liczbę ze względu na jego słabą czytelność i nieoczywistość. W js są wbudowane funkcje do tego zadania. parseInt oraz parseFloat. Jako pierwszy argument przyjmują ciąg, który ma zostać przekonwertowany na liczbę, a jako opcjonalny drugi argument przyjmują podstawę systemu liczbowego, który zawiera liczbę w ciągu przekazanym jako pierwszy argument. Jeśli drugi argument nie zostanie określony, zostanie uznane, że łańcuch zawiera liczbę w systemie liczb dziesiętnych.

Funkcjonować parseInt służy do konwersji łańcucha na liczbę całkowitą, a funkcja parseFloat przekonwertować na ułamkowe.

var a = parseInt("10"); console.log(["a = ", a, "; typ a:", typ a].join(" ")); // a = 10 ; typeof a: liczba var pi = parseInt("3.1415"); console.log("pi = " + pi); // pi = 3 pi = parseFloat("3.1415"); console.log("pi = " + pi); // pi = 3,1415

Zauważ, że ciąg może zawierać dowolną literalną wartość liczbową, w tym szesnastkową, ósemkową lub wykładniczą.

a = parseInt("010"); console.log("a = " + a); // a = 8 a = parseInt("0xAA"); console.log("a = " + a); // a = 170 a = parseFloat("1e-10"); console.log("a = " + a); // a = 1e-10 (1e-10 = 1 * 10^-10 = 0,00000000001)

Jako drugi parametr funkcji parseInt oraz parseFloat możesz określić podstawę systemu liczbowego.

a = parseInt("10", 8); console.log("a = " + a); // a = 8 a = parseInt("010", 10); console.log("a = " + a); // a = 10 a = parseInt("ff", 16); console.log("a = " + a); // a = 255

Jeśli wartość jest w ciągu, który funkcje parseInt oraz parseFloat przyjąć jako pierwszy parametr, nie jest literałem numerycznym, to wynikiem wykonania tych funkcji będzie wartość NaN.

a = parseInt("nie liczba"); console.log("a = " + a); // a = NaN a = parseFloat("nie liczba"); console.log("a = " + a); // a = NaN

Konwersja ciągów

W Znaczenie JavaScript dowolny typ można rzutować na ciąg. Jak już zostało powiedziane powyżej, gdy łańcuch jest łączony z liczbą, liczba jest redukowana do łańcucha i dopiero wtedy następuje łączenie. Stanie się tak z dowolnym typem wartości.

var str = "Obiekt: " + (); dziennik konsoli(str); // Obiekt: str = "Tablica: " + ; dziennik konsoli(str); // Tablica: 1,2,3 funkcja sum(a, b) ( return a + b; ) str = "Funkcja: " + suma; dziennik konsoli(str); /* Funkcja: suma funkcji(a, b) ( zwraca a + b; ) */

W rzeczywistości, podczas rzutowania obiektu na łańcuch, metoda jest niejawnie wywoływana toString, który można również nazwać jawnie.

zm p = (x: 2, y: 4), str; str = p.doString(); console.log(typeofstr); // string console.log(str); // str = .toString(); console.log(typeofstr); // string console.log(str); // 1,2,3

Konwersja numeryczna

Konwersja na liczbę następuje podczas wykonywania operacje matematyczne oraz podczas wykonywania operacji porównania z rzutowaniem typu (==, !=), podczas gdy wartość fałszywy a pusta tablica jest konwertowana na wartość typu 0 numer.

var a = prawda + prawda + prawda; // 1 + 1 + 1 console.log(a); // 3

Niepusta tablica, obiekt i funkcja są rzutowane na ciąg znaków, gdy są używane w wyrażeniach arytmetycznych.

var arr = ; console.log(arr + 4); // 1,2,34 funkcja sum(a, b)(zwróć a + b;) console.log(sum + 5); // suma funkcji(a, b)(zwróć a + b;)5

Jak widać, niejawna konwersja typu w js nie zawsze jest oczywista, więc powinieneś jej unikać, używając funkcji do jawnej konwersji typu, takich jak parseInt, parseFloat oraz toString.

To wszystko. Jak zawsze powodzenia!

Istnieją dwa główne sposoby konwersji ciągu na liczbę w javascript. Jednym ze sposobów jest przeanalizowanie go, a innym sposobem jest zmiana jego typu na liczbę. Wszystkie sztuczki w innych odpowiedziach (np. jednoargumentowy plus) implikują niejawne wymuszenie typu łańcucha na liczbę. Możesz również zrobić to samo z funkcją Numer.

Syntaktyczny

Zmienna przeanalizowana = parseInt("97", 10);

ParseInt i parseFloat to dwie funkcje używane do przetwarzania ciągów na liczby. Parsowanie zatrzyma się po cichu, jeśli trafi w znak, którego nie rozpoznaje, co może być przydatne do analizowania ciągów takich jak „92px”, ale jest również nieco niebezpieczne, ponieważ nie da żadnego błędu przy złym wejściu, zamiast tego „zwrócisz NaN, jeśli ciąg nie zaczyna się od liczby.Spacja na początku ciągu jest ignorowana.Oto przykład czegoś, co robi coś innego, czego chcesz, i nie daje żadnej wskazówki, że coś poszło nie tak:

Var widgetsSold = parseInt("97,800", 10); // widżetySprzedane to teraz 97

Dobrą praktyką jest zawsze określanie dziesiętnego jako drugiego argumentu. W starszych przeglądarkach ciąg rozpoczynający się od 0 byłby interpretowany jako ósemkowy, chyba że podano wartość podstawy, co zaskoczyło wielu ludzi. Zachowanie dla początku szesnastkowego jest wyzwalane, jeśli łańcuch zaczyna się od 0x, chyba że określono wartość podstawy. 0xff. Standard faktycznie zmienił się z ecmascript 5, więc nowoczesne przeglądarki nie są już uruchamiane ósemkami, gdy jest wiodące 0, jeśli nie określono przyczyny. parseInt rozumie rodniki do podstawy 36, w którym to przypadku zarówno wielkie, jak i małe litery są traktowane jako równoważne.

Zmień typ ciągu na numer

Wszystkie inne sztuczki wymienione powyżej, które nie używają ParseInt, obejmują niejawne przekształcanie ciągu w liczbę. Wolę robić to wprost

Var cast = Liczba("97");

Różni się to od metod analizowania (chociaż nadal ignoruje spacje). Jest bardziej rygorystyczny: jeśli nie rozumie całego łańcucha, to zwraca NaN , więc nie możesz go użyć do łańcuchów takich jak 97px . Ponieważ chcesz mieć pierwotną liczbę, a nie obiekt opakowujący liczby, upewnij się, że funkcja Number nie jest poprzedzona new .

Oczywiście konwersja na liczbę daje wartość, która może być liczbą zmiennoprzecinkową, a nie całkowitą, więc jeśli chcesz liczbę całkowitą, musisz ją zmienić. Można to zrobić na kilka sposobów:

Varrounded = Math.floor(Number("97,654")); // inne opcje to Math.ceil, Math.round var fixed = Number("97.654").toFixed(0); // zaokrąglona, ​​a nie skrócona var bitwed = Number("97,654")|0; // nie używaj dla dużych liczb

Każdy operator bitowy (tutaj zrobiłem bitową lub, ale możesz również wykonać podwójną negację, jak w poprzedniej odpowiedzi lub Bitshift) przekonwertuje wartość na 32-bitową liczbę całkowitą, a większość przekonwertuje ją na liczbę całkowitą ze znakiem. Należy pamiętać, że to nie chcę, żebyś szukał dużych liczb całkowitych. Jeśli liczba całkowita nie może być reprezentowana w 32 bitach, zostanie uzupełniona.

~~"3000000000.654" === -1294967296 // To to samo co Number("3000000000.654")|0 "3000000000.654" >>> 0 === 3000000000 // przesunięcie w prawo bez znaku daje dodatkowy bit "300000000000.654" > >> 0 === 3647256576 // ale nadal nie działa z większymi liczbami

Aby poprawnie pracować z dużymi liczbami, musisz użyć metod zaokrąglania

Math.floor("3000000000.654") === 3000000000 // To to samo co Math.floor(Number("3000000000.654"))

Pamiętaj, że wszystkie te metody rozumieją zapis wykładniczy, więc 2e2 to 200 , a nie NaN. Ponadto Number rozumie „Nieskończoność”, podczas gdy metody analizowania nie.

Zwyczaj

Jest mało prawdopodobne, że którakolwiek z tych metod robi dokładnie to, czego chcesz. Na przykład, zwykle chcę błędu nieudanej analizy i nie potrzebuję obsługi Infinity, wykładników ani spacji wiodących. W zależności od zastosowania, czasami warto napisać niestandardową funkcję konwersji.

Zawsze sprawdzaj, czy wynik liczbowy lub jedna z metod analizowania jest rodzajem oczekiwanej liczby. Prawie na pewno będziesz chciał użyć isNaN, aby upewnić się, że numer nie jest NaN (zazwyczaj jedyny sposób, aby dowiedzieć się, czy parsowanie nie powiodło się).

Nie ma znaczenia, jaki typ zmiennej jest używany w wyrażeniu. Jeśli wyrażenie jest matematyczne, wszystkie jego zmienne zostaną automatycznie zinterpretowane jako liczbowe. Jeśli przetwarzane są ciągi, wszyscy „uczestnicy” wyrażenia są traktowani jako ciągi. Jednak zadanie konwersji „ciągu na liczbę” JavaScript istnieje w znacznie szerszym kontekście.

Metody JavaScript do konwersji ciągów na liczby

Arsenał metod konwersji ciągów na liczby nie jest wielki, ale w sumie wystarczający proste przypadki. Tutaj JavaScript (szczególnie dla początkujących) jest drogą od prostego do złożonego z praktycznymi przykładami.

Będziesz zainteresowany:

Przykład opisuje cztery różne ciągi. W pierwszym bloku wyjściowym typ każdego zmienna funkcja typeof jest zdefiniowany jako ciąg. Każdy ciąg jest następnie w bardzo prosty sposób konwertowany na liczbę. W drugim bloku wyjściowym widać zmiany w zmiennych po konwersji, ich typ stał się liczbą. Przykład konwersji JavaScript parseFloat jest szczególnie odkrywczy: było „12e+3”, teraz jest „12000”.

Zmiany podczas konwersji ciągu na liczbę mogą być znaczące! Ale tylko pierwsze znaki mają znaczenie: muszą być numeryczne. Jeśli nie ma znaków numerycznych, wynikiem będzie NaN.

Odwrotna konwersja ciągu, który „staje się” liczbą, nie zawsze jest tym samym ciągiem. Moment ten można wykorzystać do sprawdzenia poprawności wprowadzenia informacji liczbowych.