Okna.  Wirusy.  Notatniki.  Internet.  biuro.  Narzędzia.  Kierowcy

Często wynikiem obliczeń jest liczba z dużą liczbą miejsc po przecinku. Jeśli ta liczba zostanie wykorzystana do dalszych obliczeń, można ją pozostawić w tej formie. Ale czasami trzeba zaokrąglić liczbę, na przykład, aby wyświetlić ją na stronie. Istnieje kilka metod zaokrąglania liczb w JavaScript.

Metoda Math.round() zaokrągla wartość do liczby całkowitej.

Runda matematyczna (liczba)

Liczba jest zaokrąglana zgodnie z zasadami matematycznymi. Oznacza to, że jeśli po przecinku znajduje się liczba od 0 do 4, część ułamkowa jest po prostu odrzucana. A jeśli po przecinku jest liczba od 5 do 9, to część ułamkowa jest odrzucana, a jedna jest dodawana do całej części. przykład:

JavaScript:

Istnieją jeszcze dwie metody, które zaokrąglają liczbę do wartości całkowitej. Metoda Math.floor() zaokrągla w dół. Odrzuca ułamkową część liczby. A metoda Math.ceil() zaokrągla w górę. Odrzuca część ułamkową i dodaje jeden do części całkowitej. Przykład:

Oczywiście 5 - (-2) to 5+2. Nie zapominaj, że w tym wzorze nie otrzymasz liczby 5. Maksimum wyniesie 4,999999999. Otrzymane wartości można zaokrąglić do pożądanej dokładności.

Jeśli potrzebne są tylko liczby całkowite, otrzymane wartości można zaokrąglić w dół do najbliższej liczby całkowitej. Do maksimum należy dodać jeden, aby to maksimum było również możliwe. Formuła wygląda następująco:

integer = Math.floor (min + Math.random() * (max + 1 - min)

Wypiszmy liczby od 10 do 15:

20
21
22
23
24

dla (i=1; i= (większe lub równe), 3); //false console.log(5>=3); //PRAWDA

Porównując liczby z częścią ułamkową, należy wziąć pod uwagę błędy, które mogą wystąpić podczas tych obliczeń.

Na przykład w JavaScript suma liczb (0,2 + 0,4) nie równa się 0,6:

Console.log((0.2+0.4)==0.6); //FAŁSZ

Błędy występują, ponieważ wszystkie obliczenia są komputerowe lub inne urządzenie elektroniczne produkuje w systemie 2-liczbowym. Te. przed wykonaniem jakichkolwiek czynności komputer musi najpierw przekonwertować liczby przedstawione w wyrażeniu na system liczbowy 2. Ale żadna ułamkowa liczba dziesiętna nie może być dokładnie reprezentowana w drugim systemie liczbowym.

Na przykład liczba 0,25 10 jest dokładnie konwertowana na binarną.

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

Na przykład liczbę 0,2 10 można przekonwertować na system 2 tylko z pewną dokładnością:

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

W rezultacie błędy te wpłyną na obliczenie sumy dwóch liczb i wyniki porównania. Te. okazuje się, że w rzeczywistości JavaScript zobaczy ten wpis w następujący sposób:

0.6000000000000001==0.6

Podczas obliczania lub wyświetlania liczb z częścią ułamkową należy zawsze określić precyzję, z jaką ma to być wykonane.

Na przykład porównaj liczby do 2 miejsc po przecinku za pomocą metod toFixed() i toPrecision():

//metoda toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //toPrecision() metoda console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //PRAWDA

Podstawowe działania matematyczne

JavaScript ma następujące operatory matematyczne: + (dodawanie), - (odejmowanie), * (mnożenie), / (dzielenie), % (reszta z dzielenia), ++ (zwiększenie wartości o 1), -- (zmniejszenie wartości o 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, tj. 6:3=2 => 6-3*2 => reszta(0) 5%2 //1, tj. 5:2=2(.5) => 5-2*2 => reszta(1) 7,3%2 //1,3, tj. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //znak wyniku operacji % jest równy znakowi pierwszej wartości -9%2.5 //-1.5, tj. 9:2,5=3(.6) => 9-2,5*3 => reszta(1,5) -9%-2,5 //-1,5, tj. 9:2,5=3(.6) => 9-2,5*3 => reszta(1,5) -2%5 //-2, tj. 2:5=0(.4) => 2-5*0 => reszta(2) x = 3; dziennik konsoli (x++); //wyświetla 3, następnie ustawia y na 4 console.log(x); //4 x = 3; dziennik konsoli(++x); //ustawia 4 i wyprowadza x = 5; dziennik konsoli (x--); //wyprowadza 5, y następnie ustawia 4 console.log(x); //4 x = 5; dziennik konsoli (--x); //ustawia na 4 i wyprowadza Dodatkowo w JavaScript występują operatory łączone: 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; dziennik konsoli (x); //9 x = 3; y=6; x-=y; dziennik konsoli (x); //-3 x = 3; y=6; x*=y; dziennik konsoli (x); //18 x = 3; y=6; x/=y; dziennik konsoli (x); //0,5 x = 3; y=6; x%=y; dziennik konsoli (x); //3

Rozważmy teraz metodę podłogową (w tłumaczeniu - płeć), która działa odwrotnie do metody sufitowej, tj. zaokrągla liczbę ułamkową W DÓŁ.

zmienny wiek = 35,97;

wiek = Matematyka.piętro(wiek) ; /* Zaokrąglij wartość zmiennej wieku w dół */

dokument.napisz(wiek);

Jak widać, metoda podłogi zaokrągliła liczbę 35,97 w dół do 35 . Mimo że 0,97 jest większe niż 0,5 (cm. ).

W tej lekcji omówiono metody obiektu Math, które umożliwiają zaokrąglanie ułamków dziesiętnych.

Teraz musisz odrobić pracę domową.

Twoim zadaniem jest napisanie funkcji, która przyjmuje dwa parametry.
1. Tablica składająca się z liczb z ułamkami.
2. Metoda zaokrąglania „okrągły”, „sufitowy” lub „podłogowy”.

Na wyjściu funkcja powinna wypisać tę samą tablicę, ale jednocześnie wszystkie elementy tablicy powinny zostać zaokrąglone metodą obiektu Math określoną w drugim parametrze.

Tablica źródłowa:

varnumberArray = ;

Na pierwszy rzut oka rozwiązanie tego zadania może wydawać się niemal identyczne z rozwiązaniami zadań domowych z pierwszych trzech lekcji. ten temat. Ale nie wszystko jest takie proste...

Decyzja nr 1 - Uwaga

W zależności od stanu problemu funkcja musi przyjąć dwa parametry - oryginalną tablicę i jedną z metod: "round" , "ceil" lub "floor" . Na tej podstawie próbowałem to zrobić ...

function decimal (anyArray ,method ) /* Utwórz funkcję z dwoma parametrami */
{

dla (i = 0; ja< anyArray .length ; i ++ )

{
dokument.write(dowolnatablica
" )

dowolnatablica = Metoda.matematyczna(dowolnatablica); /* Użyj jednej z metod obiektu Math, aby zaokrąglić bieżący element tablicy */

dokument.write(dowolnatablica + "

" )
}

decimal (numberArray, round ) /* Wywołaj funkcję i nadaj jej dwa parametry. Ale NIE określaj NAZWY metody jako parametru funkcji */

W tym rozwiązaniu tworzymy funkcję z dwoma parametrami, a gdy ją wywołujemy, staramy się podać oryginalną tablicę i NAZWĘ jednej metody jako parametry funkcji:
dziesiętny (numberArray, round ) - in ta sprawa okrągły.

Ale wyniku nie otrzymamy, ponieważ NIEMOŻLIWE jest podanie NAZWY metody jako parametru funkcji.

Uwaga: to nie przypadek, że nazwy metod "round" , "ceil" i "floor" są ujęte w cudzysłów w opisie problemu.

decimal (numberArray, "round" ) - ale taki zapis też nie będzie poprawny!!!

Rozwiązanie nr 2 — Korekta poprzedniego rozwiązania

Możesz rozwiązać problem, określając jeden parametr dla funkcji.

varnumberArray = ;

function decimal (anyArray ) /* Utwórz funkcję z jednym parametrem */
{

dla (i = 0; ja< anyArray .length ; i ++ ) /* Перебираем элементы массива */

{
dokument.write(dowolnatablica + "- pierwiastek oryginalny szyk
" ) /* Wyświetl bieżący element tablicy */

/* Użyj metody round obiektu Math, aby zaokrąglić bieżący element tablicy */

document.write (anyArray + " - Zaokrąglony element

" ) /* Wyświetl element ZAOKRĄGLONY tablicy */
}

decimal (numberArray ) /* Wywołaj funkcję i podaj jeden parametr - oryginalną tablicę */


35 - Zaokrąglony element


13 - Zaokrąglony element


17 - Element zaokrąglony


79 - Element zaokrąglony

Udało nam się tutaj osiągnąć zamierzony efekt: metoda round zaokrągliła wszystkie liczby o . Ale warunek nie jest spełniony, ponieważ funkcja przyjmuje tylko jeden parametr.

Rozwiązanie nr 3 - Funkcja z dwoma parametrami

Tutaj problem został rozwiązany poprawnie. W tym celu trzeba było pamiętać warunki przedmiotowe w javascript i zastosować wiele warunków jednocześnie.

varnumberArray = ;

funkcja dziesiętna (dowolna tablica , metoda )
{
dla (i = 0; ja< anyArray .length ; i ++ )
{
document.write (anyArray + " - oryginalny element tablicy
" );

jeśli (metoda
{
dowolnatablica = Math.round(dowolnatablica);
document.write (anyArray + " - standardowe zaokrąglenie

" )
}

Inaczej jeśli (metoda
{

document.write (anyArray + " - zaokrąglenie w górę

" )
}

inaczej jeśli (metoda
{

document.write (anyArray + " - zaokrąglenie w DÓŁ

" )
}

}
}
decimal (numberArray, "ceil" )/* Drugi parametr funkcji - w cudzysłowie podaj nazwę jednej z metod */

34,82 - oryginalny element tablicy
35 - zaokrąglić w górę

12.9 - oryginalny element tablicy
13 - zaokrąglamy w górę

17.01 - oryginalny element tablicy
18 - zaokrąglamy w górę

78,51 - oryginalny element tablicy
79 - zaokrąglamy w górę

To jest prawidłowe rozwiązanie zadania domowego. Tutaj określone są dwa parametry dla funkcji zgodnie z warunkiem.

Spróbuj w ostatnim wierszu tego rozwiązania:
decimal (numberArray, "ceil" ) jako drugi parametr funkcji, podaj nazwy pozostałych metod "round" i "floor" obiektu Math.

Rozwiązanie nr 4 - Funkcja z dwoma parametrami + szybka metoda

Postanowiłem nieco zoptymalizować poprzednie rozwiązanie i dodałem szybka metoda, który dzwoni okno modalne A, który zawiera pole do wprowadzania informacji.

Teraz dzięki temu będzie można wpisać w polu wprowadzania nazwę jednej z metod okrągłych, podłogowych lub ceilowych i uzyskać odpowiedni wynik.

varnumberArray = ;

funkcja dziesiętna (dowolna tablica , metoda )
{
dla (i = 0; ja< anyArray .length ; i ++ )
{
document.write (anyArray + " - oryginalny element tablicy
" );

if (metoda == "round" ) /* 1. warunek */
{
dowolnatablica = Math.round(dowolnatablica);
dokument.write(dowolnatablica + "

" )
}

Else if(method == "ceil" ) /* Drugi warunek */
{
dowolnatablica = Math.ceil(dowolnatablica);
dokument.write(dowolnatablica + "

" )
}

else if(method == "floor" ) /* 3. warunek */
{
dowolnatablica = Podłoga matematyczna (dowolnatablica);
dokument.write(dowolnatablica + "

" )
}

/* Dodaj metodę zachęty */

var method = prompt("Wpisz jedną z metod: round, ceil lub floor" );

if (metoda == "podłoga" ) /* 1. warunek */
{
document.write("Wprowadziłeś metodę " + method + ", która zaokrągla liczby W DÓŁ

" )
}

else if (metoda == "round" ) /* Drugi warunek */
{
document.write("Wprowadziłeś metodę " + method + " , która zaokrągla liczby według standardowych zasad

" )
}

else if (method == "ceil" ) /* 3. warunek */
{
document.write("Wprowadziłeś metodę " + method + " , która zaokrągla liczby w górę

" )
}

inaczej /* inaczej... */
{
document.write("Nie wprowadziłeś ani nie wprowadziłeś metody przez pomyłkę

" )
}

decimal (tablica liczb, metoda ) /* Wywołaj funkcję */

W ten sposób działają metody round , floor lub ceil obiektu Math, które zaokrąglają liczby ułamkowe.

Jeśli zauważysz błąd, zaznacz fragment tekstu i naciśnij Ctrl + Enter
UDZIAŁ: