Στρογγυλοποίηση αριθμών js προς τα πάνω. Απλοί κανόνες στρογγυλοποίησης σε javascript. Μελετάμε μεθόδους και τις κάνουμε πράξη
Συχνά οι υπολογισμοί παράγουν αποτελέσματα που βρίσκονται εκτός των επιθυμητών ορίων. Ως αποτέλεσμα, είναι απαραίτητο να εφαρμοστεί Στρογγυλοποίηση JavaScript μέχρι μια ορισμένη τιμή.
Γιατί στρογγυλοποιήστε τους αριθμούς;
Η JavaScript δεν αποθηκεύει ακέραιους αριθμούς επειδή οι τιμές τους αντιπροσωπεύονται ως αριθμοί κινητής υποδιαστολής. Πολλά κλάσματα δεν μπορούν να αναπαρασταθούν ως αριθμός με συγκεκριμένο πεπερασμένο αριθμό δεκαδικών ψηφίων, επομένως η JavaScript μπορεί να δημιουργήσει αποτελέσματα όπως τα εξής:
0.1 * 0.2; > 0.020000000000000004
Στην πράξη αυτό δεν θα κάνει καμία διαφορά από τότε μιλάμε γιαπερίπου ένα σφάλμα 2 εκατομμυρίων. Ωστόσο, αυτό μπορεί να επηρεάσει τα αποτελέσματα όταν εργάζεστε με αριθμούς που αντιπροσωπεύουν νομισματικές τιμές, ποσοστά ή μέγεθος αρχείου. Επομένως, πρέπει να κάνετε ή σε ένα συγκεκριμένο δεκαδικό ψηφίο.
Στρογγυλοποίηση δεκαδικών αριθμών
Να κόψω" δεκαδικός αριθμός, χρησιμοποιούνται οι μέθοδοι toFixed() ή toPrecision(). Και οι δύο λαμβάνουν ένα όρισμα, το οποίο καθορίζει τον αριθμό των σημαντικών και δεκαδικών ψηφίων που θα συμπεριληφθούν στο αποτέλεσμα:
- εάν η toFixed() δεν έχει καθορισμένο όρισμα, η προεπιλεγμένη τιμή είναι 0, δηλαδή δεν υπάρχουν δεκαδικά ψηφία. η μέγιστη τιμή ορίσματος είναι 20.
- Εάν δεν δοθεί όρισμα στην toPrecision(), ο αριθμός δεν αλλάζει.
var randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" var randNum = 87.335; randNum.toFixed(2); > "87.33" var randNum = 87.337; randNum.toPrecision(3); > "87.3"
Σημείωση
Τόσο η toFixed() όσο και η toPrecision επιστρέφουν μια στρογγυλεμένη παράσταση συμβολοσειράς του αποτελέσματος, αντί για έναν αριθμό. Αυτό σημαίνει ότι η προσθήκη στρογγυλεμένων στο randNum θα έχει ως αποτέλεσμα μια συνένωση συμβολοσειρών αντί για έναν μεμονωμένο αριθμό:
console.log(randNum + rounded); > "6.256"
Εάν θέλετε η JavaScript να στρογγυλοποιεί έναν αριθμό στα πλησιέστερα εκατοστά, χρησιμοποιήστε parseFloat():
var randNum = 6,25; var rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3
Η toFixed() και η toPrecision() είναι επίσης χρήσιμες μέθοδοι για την περικοπή μεγάλη ποσότηταδεκαδικά ψηφία. Αυτό είναι χρήσιμο όταν εργάζεστε με αριθμούς που αντιπροσωπεύουν νομισματικές μονάδες:
var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
Σημειώστε ότι εάν ένας αριθμός έχει περισσότερα ψηφία από την ακρίβεια που έχει καθοριστεί, το toPrecision θα παράγει το αποτέλεσμα σε επιστημονική μορφή:
var num = 123.435 num.toPrecision(2); > "1.2e+2"
Πώς να αποφύγετε λάθη κατά τη στρογγυλοποίηση δεκαδικών
Σε ορισμένες περιπτώσεις για να διορθωθεί και να εφαρμοστεί η ακρίβεια JavaScript στρογγυλοποίηση 5 προς τα κάτω, και όχι σε περισσότερα:
var numTest = 1,005; numTest.toFixed(2); > 1;
Το αποτέλεσμα του παραπάνω παραδείγματος θα πρέπει να είναι 1,01, όχι 1. Εάν θέλετε να αποφύγετε αυτό το σφάλμα, συνιστούμε να χρησιμοποιήσετε εκθετικούς αριθμούς:
συνάρτηση round(τιμή, δεκαδικά) ( return Number(Math.round(value+"e"+decials)+"e-"+decials); )
Εφαρμογή:
γύρος (1.005,2); > 1.01
Εάν χρειάζεστε μια ακόμη πιο στιβαρή λύση από τη στρογγυλοποίηση, είναι διαθέσιμη στη διεύθυνση MDN.
Στρογγυλοποίηση με έψιλον
Εναλλακτική μέθοδος JavaScript στρογγυλοποίηση στα δέκαταεισήχθη στο ES6 ( γνωστό και ως JavaScript 2015). « Μηχανή έψιλον" παρέχει ένα εύλογο περιθώριο σφάλματος κατά τη σύγκριση δύο αριθμών κινητής υποδιαστολής. Χωρίς στρογγυλοποίηση, οι συγκρίσεις μπορεί να παράγουν αποτελέσματα παρόμοια με τα ακόλουθα:
0,1 + 0,2 === 0,3 > ψευδές
Το Math.EPSILON μπορεί να χρησιμοποιηθεί σε μια συνάρτηση για να λάβετε μια έγκυρη σύγκριση:
συνάρτηση epsEqu(x, y) (επιστροφή Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Η συνάρτηση παίρνει δύο ορίσματα: το ένα περιέχει τους υπολογισμούς, το δεύτερο το αναμενόμενο (στρογγυλοποιημένο) αποτέλεσμα. Επιστρέφει μια σύγκριση αυτών των δύο παραμέτρων:
epsEqu(0.1 + 0.2, 0.3) > true
Όλα τα σύγχρονα προγράμματα περιήγησης υποστηρίζουν μαθηματικές συναρτήσεις ES6. Αλλά αν χρειάζεται να παρέχετε υποστήριξη σε παλαιότερα προγράμματα περιήγησης, τότε πρέπει να χρησιμοποιήσετε πολυσυμπληρώσεις.
Περικοπή δεκαδικών αριθμών
Όλες οι μέθοδοι που παρουσιάστηκαν προηγουμένως λειτουργούν JavaScript στρογγυλοποίηση στα δέκατα. Για να περικόψετε έναν θετικό αριθμό σε δύο δεκαδικά ψηφία, πολλαπλασιάστε τον με το 100, περικόψτε τον ξανά και μετά διαιρέστε το αποτέλεσμα με το 100:
συνάρτηση περικομμένος(αριθμός) ( επιστροφή Math.trunc(αριθμός * 100) / 100; ) περικομμένος(3.1416) > 3.14
Εάν χρειάζεστε κάτι πιο ευέλικτο, μπορείτε να χρησιμοποιήσετε τον τελεστή bitwise:
συνάρτηση περικομμένη (αριθμός, δεκαδικάΜέτρα) ( var numPowerConverter = Math.pow(10, δεκαδικάPlaces); επιστροφή ~~(αριθμός * numPowerConverter)/numPowerConverter; )
Χρήση:
var randInt = 35.874993; περικομμένο(randInt,3); > 35.874
Στρογγυλοποιήστε στον πλησιέστερο αριθμό
Να εφαρμόσει JavaScript στρογγυλοποίηση στον πλησιέστερο ακέραιο, Math.round() χρησιμοποιείται:
Math.round(4.3) > 4 Math.round(4.5) > 5
Σημειώστε ότι " μισές τιμές", όπως 0,5, στρογγυλοποιούνται προς τα πάνω.
Στρογγυλοποιήστε προς τα κάτω στον πλησιέστερο ακέραιο αριθμό
Εάν θέλετε να στρογγυλοποιήσετε προς τα κάτω, χρησιμοποιήστε τη μέθοδο Math.floor():
Math.floor(42.23); > 42 Math.floor(36,93); > 36
Η στρογγυλοποίηση προς τα κάτω έχει μία κατεύθυνση για όλους τους αριθμούς, συμπεριλαμβανομένων των αρνητικών. Αυτό μπορεί να φανταστεί ως έναν ουρανοξύστη με άπειρο αριθμό ορόφων, συμπεριλαμβανομένων κάτω από το επίπεδο θεμελίωσης ( που αντιπροσωπεύει αρνητικούς αριθμούς). Εάν βρίσκεστε στο ασανσέρ μεταξύ των ορόφων 2 και 3 του υπογείου ( που αντιστοιχεί σε τιμή -2,5), Το Math.floor θα σας μεταφέρει στον όροφο -3:
Math.floor(-2,5); > -3
Εάν χρειάζεται να το αποφύγετε, χρησιμοποιήστε JavaScript Math στρογγυλοποίηση χρησιμοποιώντας Math.trunc() , που υποστηρίζεται σε όλα σύγχρονα προγράμματα περιήγησης(εκτός IE/Edge):
Math.trunc(-41,43); > -41
Το MDN παρέχει επίσης polyfill τριών γραμμών για την παροχή υποστήριξης για το Math.trunc σε παλαιότερα προγράμματα περιήγησης και IE/Edge.
Στρογγυλοποιήστε στον πλησιέστερο ακέραιο αριθμό
Εάν θέλετε να στρογγυλοποιήσετε τους δεκαδικούς αριθμούς προς τα πάνω, χρησιμοποιήστε το Math.ceil . Αυτή η μέθοδος μπορεί επίσης να θεωρηθεί ως ένας άπειρος ανελκυστήρας: το Math.ceil πάντα σας ανεβάζει, ανεξάρτητα από το αν ο αριθμός είναι αρνητικός ή θετικός:
Math.ceil(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); -36
Στρογγυλοποιήστε στο πλησιέστερο πολλαπλάσιο
Εάν πρέπει να στρογγυλοποιήσετε μια τιμή στο πλησιέστερο πολλαπλάσιο του 5, δημιουργήστε μια συνάρτηση που διαιρεί τον αριθμό με το 5, τον στρογγυλοποιεί και, στη συνέχεια, πολλαπλασιάζει το αποτέλεσμα με την ίδια τιμή:
συνάρτηση roundTo5(αριθμός) (επιστροφή Math.round(num/5)*5;)
Χρήση:
roundTo5(11); > 10
Εάν χρειάζεστε JavaScript για στρογγυλοποίηση σε δύο δεκαδικά ψηφία, μπορείτε να περάσετε και το seed και το πολλαπλάσιο στη συνάρτηση:
συνάρτηση roundToMultiple(αριθμός, πολλαπλάσια) (επιστροφή Math.round(αριθμός/πολλαπλά)*πολλαπλά; )
Για να χρησιμοποιήσετε τη συνάρτηση, συμπεριλάβετε τον αριθμό που θα στρογγυλοποιηθεί και το πολλαπλάσιο στην κλήση της:
var αρχικός αριθμός = 11; var πολλαπλάσιο = 10; roundToMultiple(initialNumber, multiple); > 10;
Για να στρογγυλοποιήσετε μόνο τις τιμές προς τα πάνω ή προς τα κάτω, αντικαταστήστε το στρογγυλό με οροφή ή πάτωμα στη λειτουργία.
Δέσμευση εύρους
Μερικές φορές χρειάζεται να λάβετε την τιμή του x, η οποία πρέπει να είναι εντός ορισμένο εύρος. Για παράδειγμα, χρειαζόμαστε μια τιμή από το 1 έως το 100, αλλά παίρνουμε την τιμή 123. Για να το διορθώσετε, μπορείτε να χρησιμοποιήσετε min() ( επιστρέφει τον μικρότερο αριθμό) και μέγιστο ( επιστρέφει τον μέγιστο επιτρεπόμενο αριθμό).
Χρήση:
var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
Μπορείτε να δημιουργήσετε μια συνάρτηση ή επέκταση της κλάσης Number:
Number.prototype.clamp = συνάρτηση(min, max) ( return Math.min(Math.max(this, min), max); );
Χρήση:
(numInput).clamp(lowBound, highBound);
Γκαουσιανή στρογγυλοποίηση
Gaussian στρογγυλοποίηση ("τραπεζική", συγκλίνουσα ή ολλανδική) είναι μια μέθοδος στρογγυλοποίησης χωρίς στατιστικό σφάλμα. Πρότυπο Στρογγυλοποίηση JavaScriptμερικές φορές δίνει λάθη σε μεγαλύτερη κατεύθυνση. Η στρογγυλοποίηση Gauss αποφεύγει αυτό το σφάλμα στρογγυλοποιώντας στον πλησιέστερο ζυγό αριθμό. Η καλύτερη απόφαση, που ξέρω.
Γεια σας, λάτρεις της JavaScript. Έχετε ήδη παρατηρήσει ότι αυτή η γλώσσα είναι πολύ εξαιρετική και σε κάθε ενότητα ξεχωρίζει για τις ιδιαιτερότητές της και τις ασυνήθιστες τεχνικές λύσεις. Επομένως, η σημερινή δημοσίευση είναι αφιερωμένη στο θέμα: «Στρογγυλοποίηση JavaScript».
Αφού διαβάσετε το τρέχον άρθρο, θα μάθετε γιατί είναι απαραίτητο να στρογγυλοποιούνται οι αριθμοί, ποιες μέθοδοι και ιδιότητες στο js εκτελούν αυτή τη λειτουργία, καθώς και τι διακρίνει τη διαίρεση με το 0. Χωρίς να αλλάξω τις αρχές μου, θα επισυνάψω παραδείγματα στα βασικά σημεία του υλικό και περιγράψτε αναλυτικά κάθε ενέργεια. Τώρα ας αρχίσουμε να μαθαίνουμε!
Σημαντικές σημειώσεις για τους αριθμούς
Αρχικά, να θυμάστε ότι στο js όλοι οι τύποι αριθμών (κλασματικοί και ακέραιοι) ανήκουν στον τύπο Αριθμός. Επιπλέον, είναι όλα 64-bit, καθώς αποθηκεύονται στη μορφή «διπλής ακρίβειας», η οποία είναι γνωστή και ως πρότυπο IEEE-754.
Οι αριθμητικές μεταβλητές δημιουργούνται με τον συνήθη τρόπο:
var numb = 35; // φυσικός αριθμός
var drob = 0,93; //δεκαδική παράσταση
var numb16 = 0xFF; //Δεξαδικό σύστημα αριθμών
Υποστηρίζει άλλες αριθμητικές αναπαραστάσεις. Έτσι, μπορείτε επίσης να δημιουργήσετε αριθμούς κινητής υποδιαστολής (μερικές φορές ονομάζονται «επιστημονικοί αριθμοί»).
Υπάρχει τώρα υποστήριξη για μια πολύ ενδιαφέρουσα μέθοδο toLocaleString(), το οποίο μορφοποιεί όλες τις αριθμητικές παραμέτρους σύμφωνα με τις προδιαγραφές που προβλέπονται στο ECMA 402. Χάρη σε αυτό, μεγάλοι αριθμοί, τηλεφωνικοί αριθμοί, τα νομίσματα και ακόμη και τα ποσοστά εμφανίζονται όμορφα στο πλαίσιο διαλόγου.
var num = 714000,80;
alert(num.toLocaleString());
Για να εργαστείτε με στοιχεία του τύπου Αριθμός, παρέχεται ένα ολόκληρο καθολικό αντικείμενο με μια δέσμη από διάφορες μαθηματικές συναρτήσεις, το όνομα των οποίων Μαθηματικά.
Εκτός από αυτό, υπάρχουν και άλλες μέθοδοι που πραγματοποιούν στρογγυλοποίηση αριθμητικές τιμέςμέχρι ακέραιους αριθμούς, μέχρι δέκατα, εκατοστά κ.λπ. Ας τα δούμε όλα πιο αναλυτικά.
Τα μεγάλα και δυνατά μαθηματικά
Το καθολικό αντικείμενο Math περιλαμβάνει μεγάλο ποσόδιάφορα μαθηματικά και τριγωνομετρικές συναρτήσεις. Αυτό είναι ένα πολύ απαραίτητο αντικείμενο και συχνά βοηθά τους προγραμματιστές όταν εργάζονται με ψηφιακά δεδομένα.
Υπάρχουν ανάλογα των Μαθηματικών σε άλλες πλατφόρμες. Για παράδειγμα, σε τέτοια δημοφιλείς γλώσσες, όπως η Java και η C#, τα Μαθηματικά είναι μια κλάση που υποστηρίζει το ίδιο τυποποιημένα χαρακτηριστικά. Έτσι, όπως μπορείτε να δείτε, αυτό το όργανο είναι πραγματικά υπέροχο και ισχυρό.
Τώρα θέλω να περάσω από τις συγκεκριμένες μεθόδους που είναι υπεύθυνες για τη στρογγυλοποίηση και να μιλήσω για αυτές λεπτομερώς.
Math.floor()
Θα ξεκινήσω με Μαθηματικά.πάτωμα. Δώστε προσοχή στο όνομα της μεθόδου. Λογικά γίνεται σαφές ότι εφόσον μιλάμε για στρογγυλοποίηση, και η κυριολεκτική μετάφραση της λέξης "δάπεδο" σημαίνει "πάτωμα", τότε αυτό το εργαλείοθα στρογγυλοποιήσει τις επεξεργασμένες τιμές προς τα κάτω.
Είναι επίσης πιθανό ο αριθμός που επεξεργάζεται με αυτήν τη λειτουργία να παραμείνει ίδιος. Αυτό συμβαίνει επειδή η στρογγυλοποίηση πραγματοποιείται σύμφωνα με μια μη αυστηρή ανισότητα (<=). Таким образом, при отработке этой строчки кода:
alert(Math.floor(4.5));
η απάντηση θα είναι νούμερο 4.
Math.ceil()
Και πάλι, κοιτάξτε το όνομα (έτσι το υλικό απορροφάται πιο γρήγορα). Αν κάποιος δεν ξέρει, «ταβάνι» σημαίνει «ταβάνι». Αυτό σημαίνει ότι τα αριθμητικά δεδομένα θα στρογγυλοποιηθούν προς τα πάνω χρησιμοποιώντας μια μη αυστηρή ανισότητα (>=).
alert(Math.ceil(4.5));
Όπως ίσως έχετε μαντέψει, η απάντηση θα είναι ο αριθμός 5.
Math.round()
Αυτή η μέθοδος στρογγυλεύει ένας κλασματικός αριθμόςστον πλησιέστερο ακέραιο. Έτσι, εάν το κλασματικό μέρος είναι στην περιοχή από 0 έως 0,5 χωρίς να συμπεριλαμβάνεται, τότε γίνεται στρογγυλοποίηση σε μικρότερη τιμή. Και αν το κλασματικό μέρος βρίσκεται στην περιοχή από 0,5 συμπεριλαμβανομένου στον επόμενο ακέραιο αριθμό, τότε στρογγυλοποιείται σε μεγαλύτερο ακέραιο αριθμό.
alert(Math.round(4.5));
Ελπίζω ότι όλοι σκέφτηκαν ή είπαν ότι η σωστή απάντηση είναι 5.
Μερικές ακόμη μέθοδοι
Η JavaScript έχει επίσης 2 άλλες μεθόδους που ασχολούνται με τη στρογγυλοποίηση αριθμητικών αναπαραστάσεων. Ωστόσο, είναι κάπως διαφορετικά.
Θα μιλήσουμε για εργαλεία όπως π.χ toFixed()Και toPrecision(). Είναι υπεύθυνοι όχι μόνο για τη στρογγυλοποίηση, αλλά και για την ακρίβειά της σε συγκεκριμένους χαρακτήρες. Ας σκάψουμε πιο βαθιά.
toFixed()
Χρησιμοποιώντας αυτόν τον μηχανισμό, μπορείτε να καθορίσετε σε πόσα δεκαδικά ψηφία θα πρέπει να στρογγυλοποιηθεί η τιμή. Η μέθοδος επιστρέφει το αποτέλεσμα ως συμβολοσειρά. Παρακάτω έχω επισυνάψει μια επιλογή με τρεις διαφορετικές επιλογές. Αναλύστε τις απαντήσεις που λάβατε.
var num = 5656,9393;
document.writeln(num.toFixed()); // 5657
document.writeln(num.toFixed(2)); // 5656,94
document.writeln(num.toFixed(7)); // 5656.9393000
Όπως μπορείτε να δείτε, εάν δεν καθορίσετε ένα όρισμα, τότε το toFixed ()) θα στρογγυλοποιήσει την κλασματική τιμή στο σύνολοαριθμοί. Η τρίτη γραμμή είναι στρογγυλεμένη έως 2 χαρακτήρες,και στο τέταρτο, λόγω της παραμέτρου «7», προστέθηκαν άλλα τρία 0.
toPrecision()
Αυτή η μέθοδος λειτουργεί λίγο διαφορετικά. Στη θέση του ορίσματος, μπορείτε είτε να αφήσετε ένα κενό χώρο είτε να ορίσετε μια παράμετρο. Ωστόσο, το τελευταίο θα στρογγυλοποιήσει τους αριθμούς σε καθορισμένη ποσότητααριθμούς, ανεξάρτητα από το κόμμα. Ακολουθούν τα αποτελέσματα που παράγονται από το πρόγραμμα, ξαναγραμμένα από το προηγούμενο παράδειγμα:
var num = 5656,9393;
document.writeln(num.toPrecision()); // 5656.9393
document.writeln(num.toPrecision(2)); // 5,7e+3
document.writeln(num.toPrecision(7)); // 5656.939
Χαρακτηριστικό της διαίρεσης με το 0 σε js
Όπως γνωρίζετε από τα μαθήματα μαθηματικών, δεν μπορείτε να διαιρέσετε με το μηδέν. Αυτός ο κανόνας ελήφθη ως βάση από τους περισσότερους δημιουργούς γλωσσών προγραμματισμού. Επομένως, κατά τη διαίρεση με το μηδέν, όλα τα προγράμματα δημιουργούν ένα σφάλμα.
Ωστόσο, η JavaScript υπερέχει και εδώ. Άρα, κατά την εκτέλεση μιας τέτοιας λειτουργίας, δεν προκύπτουν μηνύματα σφάλματος... γιατί μια τέτοια λειτουργία επιστρέφει "Απειρο"!
Γιατί είναι έτσι; Όπως είναι γνωστό από τις ίδιες μαθηματικές επιστήμες, όσο μικρότερος είναι ο διαιρέτης, το αποτέλεσμα είναι μεγαλύτερο αριθμό. Αυτός είναι ο λόγος για τον οποίο οι δημιουργοί αυτής της γλώσσας προσανατολισμένης στα πρωτότυπα αποφάσισαν να εγκαταλείψουν τα πρότυπα και να ακολουθήσουν τον δικό τους δρόμο.
Για όσους συναντούν την τιμή Infinity για πρώτη φορά, έχω εξηγήσει τα χαρακτηριστικά του παρακάτω.
Άπειρο – σημαίνει άπειρο και αντιστοιχεί πλήρως μαθηματικό σημάδι ∞.
Μπορεί να είναι αρνητικό. Διατηρούνται επίσης όλοι οι τυπικοί κανόνες για την εργασία με αριθμητικούς τελεστές.
alert(12/ 0); // Άπειρο
alert(12.34/ 0); // Άπειρο
συναγερμός (-3/ 0); // -Άπειρο
Μάλλον θα τελειώσω εδώ. Αν σας άρεσε η δημοσίευση, φροντίστε να εγγραφείτε στο blog μου. Μην είστε άπληστοι με έναν σύνδεσμο προς ενδιαφέροντα άρθρακαι μοιραστείτε τα με τους φίλους σας. Αντίο!
Με εκτίμηση, Roman Chueshov
Ανάγνωση: 194 φορές
Σε αυτό το άρθρο θα δούμε αναλυτικά αριθμούς, μαθηματικούς τελεστές, τρόπους μετατροπής ενός αριθμού σε συμβολοσειρά και αντίστροφα, καθώς και πολλά άλλα σημαντικά σημεία.
είναι πεπερασμένη συνάρτηση
Η συνάρτηση isFinite σάς επιτρέπει να ελέγξετε εάν ένα όρισμα είναι πεπερασμένος αριθμός.
Ως απάντηση αυτή τη λειτουργίαεπιστρέφει false εάν το όρισμα είναι Infinity , -Infinity , NaN ή θα μεταφερθεί σε μία από αυτές τις ειδικές αριθμητικές τιμές. Διαφορετικά, αυτή η συνάρτηση θα επιστρέψει true.
IsFinite(73); // true is Finite(-1/0); // false isFinite(Infinity); // false is Finite(NaN); // false isFinite("Κείμενο"); // ψευδής
Εκτός παγκόσμια λειτουργίαΤο isFinite JavaScript έχει επίσης μια μέθοδο Number.isFinite. Σε αντίθεση με το isFinite, δεν αναγκάζει το όρισμα να μετατραπεί σε αριθμό.
IsFinite("73"); // true Number.isFinite("73"); // ψευδής
συνάρτηση isNaN
Η συνάρτηση isNaN έχει σχεδιαστεί για να προσδιορίζει εάν ένα όρισμα είναι αριθμός ή μπορεί να μετατραπεί σε ένα. Αν ναι, τότε η συνάρτηση isNaN επιστρέφει false. Διαφορετικά επιστρέφει αληθινό.
IsNaN(NaN); //true isNaN("25px"); //αληθές, γιατί Το 20px δεν είναι αριθμός isNaN(25.5). //false isNaN("25.5"); //false isNaN(" "); //ψευδής, επειδή ένα διάστημα ή πολλά κενά μετατρέπεται σε 0 isNaN(null). //ψευδής, επειδή μηδενική τιμήμετατρέπεται σε 0 isNaN(true); //ψευδής, επειδή true μετατρέπεται σε 1 isNaN(false); //ψευδής, επειδή false μετατρέπεται σε 0
Εάν αυτή η ενέργεια πρέπει να εκτελεστεί χωρίς cast τύπου, χρησιμοποιήστε τη μέθοδο Number.isNaN. Αυτή η μέθοδος εισήχθη στη γλώσσα ξεκινώντας με το ECMAScript 6.
Πώς να μετατρέψετε ρητά μια συμβολοσειρά σε αριθμό;
Μπορείτε να μετατρέψετε ρητά μια συμβολοσειρά σε αριθμό χρησιμοποιώντας τις ακόλουθες μεθόδους:
1. Χρήση ενιαίος τελεστής +, το οποίο πρέπει να τοποθετηθεί πριν από την τιμή.
+"7,35"; // 7.35 +"κείμενο"; // NaN
Αυτή η μέθοδος αγνοεί τα κενά στην αρχή και το τέλος της γραμμής, καθώς και \n (τροφοδοσία γραμμής).
+" 7,35 "; //7,35 +"7,35 \n "; //7,35
Χρησιμοποιώντας αυτή τη μέθοδοείναι απαραίτητο να προσέξουμε το γεγονός ότι κενή γραμμήή μια συμβολοσειρά που αποτελείται από κενά και \n μετατρέπεται στον αριθμό 0. Επιπλέον, μετατρέπει επίσης τον τύπο μηδενικά δεδομένακαι δυαδικές τιμές στον αριθμό.
Μηδενικό; //0 +true; //1 +false; //0 +" "; //0
2. Συνάρτηση ParseInt. Αυτή η λειτουργία έχει σχεδιαστεί για μετατροπή όρισμα σε ακέραιο. Σε αντίθεση με τη χρήση ενιαίος τελεστής +, αυτή τη μέθοδοσας επιτρέπει να μετατρέψετε μια συμβολοσειρά σε αριθμό, στον οποίο δεν είναι όλοι οι χαρακτήρες αριθμητικοί. Αρχίζει να μετατρέπει τη συμβολοσειρά, ξεκινώντας από τον πρώτο χαρακτήρα. Και μόλις συναντήσει έναν μη αριθμητικό χαρακτήρα, αυτή η συνάρτηση σταματά την εργασία της και επιστρέφει τον αριθμό που προκύπτει.
ParseInt("18px"); //18 parseInt("33,3%"); //33
Αυτή η λειτουργία μπορεί να λειτουργήσει με διαφορετικά συστήματαΑριθμοί (δυαδικοί, οκταδικοί, δεκαδικοί, δεκαεξαδικοί). Η βάση του συστήματος αριθμών καθορίζεται χρησιμοποιώντας 2 ορίσματα.
ParseInt("18px", 10); //18 parseInt("33,3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181
Εκτός από τη συνάρτηση parseInt, η JavaScript έχει τη μέθοδο Number.parseInt. Αυτή η μέθοδος δεν διαφέρει από τη συνάρτηση parseInt και εισήχθη στην JavaScript με την προδιαγραφή ECMASCRIPT 2015 (6).
3. Συνάρτηση ParseFloat. Η συνάρτηση parseFloat είναι παρόμοια με την parseInt, με τη διαφορά ότι σας επιτρέπει να μετατρέψετε το όρισμα σε κλασματικό αριθμό.
ParseFloat("33,3%"); //33.3
Επιπλέον, η συνάρτηση parseFloat, σε αντίθεση με το parseInt, δεν έχει 2 ορίσματα και επομένως προσπαθεί πάντα να αντιμετωπίζει τη συμβολοσειρά ως αριθμό στο μετρικό σύστημαΥπολογισμός.
ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");
Εκτός από τη συνάρτηση parseFloat, η JavaScript έχει τη μέθοδο Number.parseFloat. Αυτή η μέθοδος δεν διαφέρει από τη συνάρτηση parseFloat και εισήχθη στην JavaScript με την προδιαγραφή ECMASCRIPT 2015 (6).
Μετατροπή αριθμού σε συμβολοσειρά
Μπορείτε να μετατρέψετε έναν αριθμό σε συμβολοσειρά χρησιμοποιώντας τη μέθοδο toString.
(12.8).toString(); //"12,8"
Η μέθοδος toString σάς επιτρέπει επίσης να καθορίσετε τη βάση του συστήματος αριθμών, λαμβάνοντας υπόψη ποια πρέπει να μετατρέψετε ρητά τον αριθμό σε συμβολοσειρά:
(255).toString(16); //"ff"
Πώς να ελέγξετε αν μια μεταβλητή είναι αριθμός
Προσδιορίστε εάν η τιμή είναι μεταβλητός αριθμόςμπορείτε να χρησιμοποιήσετε μία από τις ακόλουθες μεθόδους:
1. Χρησιμοποιώντας τις συναρτήσεις isNaN και isFinite:
// myVar είναι μια μεταβλητή εάν (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar είναι ένας αριθμός ή μπορεί να μεταδοθεί σε αυτόν);
Ως συνάρτηση:
// συνάρτηση συνάρτησης είναι Αριθμητική(τιμή) ( επιστροφή !isNaN(parseFloat(τιμή)) && isFinite(parseFloat(τιμή)); ) // χρήση var myVar = "12px"; console.log(isNumeric(myVar)); //αληθής
Αυτή η μέθοδος σάς επιτρέπει να προσδιορίσετε εάν η καθορισμένη τιμή είναι αριθμός ή μπορεί να μετατραπεί σε ένα. Αυτή η επιλογήδεν μετράει την κενή συμβολοσειρά, συμβολοσειρά διαστημάτων, null, Infinity, -Infinity, true και false ως αριθμό.
2. Χρησιμοποιώντας τον τελεστή typeof και τις συναρτήσεις isFinite, isNaN:
// συνάρτηση που ελέγχει αν η τιμή είναι μια αριθμητική συνάρτηση isNumber(value) (‘return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}
Αυτή η συνάρτηση καθορίζει εάν η καθορισμένη τιμή είναι τύπου Number και εάν είναι μία από τις ειδικές τιμές Infinity, -Infinity και NaN. Αν ναι, τότε αυτή η συνάρτηση επιστρέφει true.
3. Χρησιμοποιώντας τη μέθοδο ECMAScript 6 Number.isInteger(value). Αυτή η μέθοδος σάς επιτρέπει να προσδιορίσετε εάν η καθορισμένη τιμή είναι ακέραιος.
Number.isInteger("20"); //ψευδής, επειδή Αυτή η μέθοδος δεν μετατρέπει μια συμβολοσειρά σε αριθμό Number.isInteger(20); //αληθές, γιατί δεδομένη αξίαείναι ένας αριθμός
Ζυγοί και περιττοί αριθμοί
Μπορείτε να ελέγξετε εάν ένας αριθμός είναι άρτιος ή μονός χρησιμοποιώντας παρακάτω λειτουργίες:
// Συνάρτηση για έλεγχο αριθμού για άρτια συνάρτηση ισοτιμίας isEven(n) ( return n % 2 == 0; ) // Συνάρτηση για έλεγχο αριθμού για συνάρτηση περιττής ισοτιμίας isOdd(n) ( return Math.abs(n % 2) == 1;
Αλλά πριν πραγματοποιήσετε έναν τέτοιο έλεγχο, συνιστάται να βεβαιωθείτε ότι η καθορισμένη τιμή είναι ένας αριθμός:
Τιμή = 20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Number" + value.toString() + " - even"); ) )
Πρώτοι αριθμοί σε Javascript
Ας δούμε ένα παράδειγμα από το οποίο αντλούμε χρησιμοποιώντας Javascript πρώτοι αριθμοίαπό 2 έως 100.
// Συνάρτηση που ελέγχει εάν ένας αριθμός είναι πρώτη συνάρτηση isPrime(value) (if (isNaN(value) || !isFinite(value) || value%1 || value< 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
Στρογγυλοποίηση αριθμού σε Javascript
Υπάρχουν διάφοροι τρόποι για να στρογγυλοποιήσετε ένα κλάσμα σε έναν ακέραιο αριθμό στο JavaScript.
1. Χρησιμοποιώντας τις μεθόδους Math.floor, Math.ceil και Math.round ειδικά σχεδιασμένες για αυτό. Η μέθοδος Math.floor στρογγυλοποιεί ένα κλάσμα στον πλησιέστερο ακέραιο αριθμό, δηλ. απλά απορρίπτει το κλασματικό μέρος. Το Math.ceil στρογγυλοποιεί ένα κλάσμα στον πλησιέστερο ακέραιο αριθμό. Το Math.round στρογγυλοποιεί έναν αριθμό προς τα πάνω ή προς τα κάτω ανάλογα με την τιμή του κλασματικού μέρους. Εάν το κλασματικό μέρος είναι μεγαλύτερο ή ίσο με 0,5, τότε επάνω, διαφορετικά η συστροφή είναι προς τα κάτω.
Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8
2. Χρησιμοποιώντας τη μέθοδο toFixed (precision). Αυτή η μέθοδος στρογγυλοποιεί το κλασματικό μέρος ενός αριθμού σε καθορισμένη ακρίβεια. Το αποτέλεσμα στρογγυλοποίησης επιστρέφεται ως συμβολοσειρά.
Console.log(7.987.toFixed(2)); //"7,99"
Εάν δεν υπάρχουν αρκετά δεκαδικά ψηφία για να σχηματιστεί η καθορισμένη ακρίβεια του αριθμού, τότε συμπληρώνεται με μηδενικά.
Console.log(7.987.toFixed(5)); //"7,98700"
3. Χρησιμοποιώντας τη μέθοδο toPrecision(accuracy). Αυτή η μέθοδος αντιπροσωπεύει έναν αριθμό με καθορισμένη ακρίβεια. Ταυτόχρονα, μπορεί να στρογγυλοποιήσει όχι μόνο το κλασματικό, αλλά και ολόκληρο το μέρος του αριθμού. Αυτή η μέθοδος μπορεί να παρουσιάσει τον αριθμό που προκύπτει ανάλογα με το αποτέλεσμα σε σταθερό σημείο ή σε εκθετική μορφή.
Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"
4.Χρησιμοποιώντας λογικούς τελεστέςΟΧΙ ή Ή.
//μέσω διπλής λογικής άρνησης console.log(~~7.9); //7 // χρησιμοποιώντας λογικό Ή με μηδέν: console.log(7.9^0); //7
Ακέραιο και κλασματικό μέρος ενός αριθμού
Μπορείτε να πάρετε το ακέραιο μέρος ενός αριθμού χρησιμοποιώντας τις μεθόδους Math.floor() και parseInt():
Console.log(Math.floor(7.21)); // 7 console.log(parseInt(7.21)); // 7
Μπορείτε να πάρετε το κλασματικό μέρος ενός αριθμού χρησιμοποιώντας τον τελεστή ποσοστό (%). Αυτός ο χειριστήςεπιστρέφει το υπόλοιπο που θα προκύψει από τη διαίρεση του πρώτου αριθμού με τον δεύτερο. Σε αυτήν την περίπτωση, πρέπει να χρησιμοποιήσετε το 1 ως τον 2ο αριθμό.
Console.log(7.21%1); // 0.20999999999999996 // με ακρίβεια 2 δεκαδικών ψηφίων console.log((7.21%1).toFixed(2)); // "0,21"
Επιπλέον, το κλασματικό μέρος μπορεί επίσης να ληφθεί χρησιμοποιώντας υπολογισμούς:
Var αριθμός = 7,21; var fractionNumber = αριθμός - Math.floor(Math.abs(number)); console.log(fractionNumber); // 0,20999999999999996
Ο αριθμός διαιρείται με ακέραιο;
Μπορείτε να προσδιορίσετε εάν ένας αριθμός διαιρείται με έναν ακέραιο χρησιμοποιώντας τον τελεστή ποσοστού:
Var αριθμός = 9; // αν το υπόλοιπο του αριθμού διαιρούμενο με το 3 είναι 0, τότε ναι, διαφορετικά όχι εάν (number%3==0) ( console.log ("Ο αριθμός " + αριθμός + " διαιρείται με το 3"); ) else ( κονσόλα ("Ο αριθμός " + αριθμός + " δεν διαιρείται με το 3");
Μορφοποίηση αριθμών
Στο JavaScript, μορφοποιήστε την έξοδο του αριθμού σύμφωνα με περιφερειακά πρότυπα (ΡΥΘΜΙΣΕΙΣ ΓΛΩΣΣΑΣ λειτουργικό σύστημα) επιτρέπει τη μέθοδο toLocaleString().
Για παράδειγμα, ας μορφοποιήσουμε έναν αριθμό σύμφωνα με τα τοπικά πρότυπα που είναι εγκατεστημένα στο σύστημα από προεπιλογή:
Αριθμός Var = 345,46; console.log(number.toLocaleString()); //"345,46"
Για παράδειγμα, ας μορφοποιήσουμε τον αριθμό σύμφωνα με τα περιφερειακά πρότυπα της Ρωσίας (ru):
Console.log((108.1).toLocaleString("ru-RU")); //"108.1"
Αυτή η μέθοδος μπορεί επίσης να χρησιμοποιηθεί για τη μορφοποίηση ενός αριθμού ως νομίσματος:
Console.log((2540.125).toLocaleString("ru-RU",(style:"currency", νόμισμα:"RUB"))); //"2,540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", νόμισμα:"USD"))); //"89.30 $" console.log((2301.99).toLocaleString("ru-RU",(style:"currency", νόμισμα:"EUR"))); //"2.301,99 €"
Αναπαριστά έναν αριθμό ως ποσοστό:
Console.log((0.45).toLocaleString("ru-RU",(style:"percent"))); //"45%"
Σπάστε έναν αριθμό σε ψηφία (ιδιότητα useGrouping):
Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125,452,32"
Εκτυπώστε έναν αριθμό με συγκεκριμένο αριθμό ψηφίων (2) μετά την υποδιαστολή:
Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1.240,46"
Σύγκριση αριθμών
Οι ακόλουθοι τελεστές χρησιμοποιούνται για τη σύγκριση αριθμών στο JavaScript: == (ίσο), != (όχι ίσο), > (μεγαλύτερο από),< (меньше), >= (μεγαλύτερο ή ίσο με),<= (меньше или равно).
Για παράδειγμα, ας συγκρίνουμε δύο αριθμούς:
Console.log(2>3); //false console.log(5>=3); //αληθής
Κατά τη σύγκριση αριθμών με ένα κλασματικό μέρος, είναι απαραίτητο να ληφθούν υπόψη τα σφάλματα που μπορεί να προκύψουν κατά τη διάρκεια αυτών των υπολογισμών.
Για παράδειγμα, στο JavaScript το άθροισμα των αριθμών (0,2 + 0,4) δεν ισούται με 0,6:
Console.log((0.2+0.4)==0.6); //ψευδής
Παρουσιάζονται σφάλματα επειδή όλοι οι υπολογισμοί γίνονται από υπολογιστή ή άλλο ηλεκτρονική συσκευήπαράγει σε σύστημα 2 αριθμών. Εκείνοι. Πριν εκτελέσετε οποιαδήποτε ενέργεια, ο υπολογιστής πρέπει πρώτα να μετατρέψει τους αριθμούς που παρουσιάζονται στην παράσταση στο 2ο σύστημα αριθμών. Αλλά δεν μπορεί να αναπαρασταθεί κάθε κλασματικός δεκαδικός αριθμός ακριβώς στο 2ο σύστημα αριθμών.
Για παράδειγμα, ο αριθμός 0,25 10 μετατρέπεται σε δυαδικό ακριβώς.
0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2
Για παράδειγμα, ο αριθμός 0,2 10 μπορεί να μετατραπεί στο σύστημα 2 μόνο με μια συγκεκριμένη ακρίβεια:
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
Ως αποτέλεσμα, αυτά τα σφάλματα θα επηρεάσουν τον υπολογισμό του αθροίσματος δύο αριθμών και τα αποτελέσματα σύγκρισης. Εκείνοι. Αποδεικνύεται ότι η JavaScript θα δει πραγματικά αυτήν την καταχώρηση ως εξής:
0.6000000000000001==0.6
Κατά τον υπολογισμό ή την εμφάνιση αριθμών με κλασματικά μέρη, πρέπει πάντα να υποδεικνύετε την ακρίβεια με την οποία θέλετε να το κάνετε.
Για παράδειγμα, συγκρίνετε αριθμούς έως και 2 δεκαδικά ψηφία χρησιμοποιώντας τις μεθόδους toFixed() και toPrecision():
//method toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //method toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //αληθής
Βασικές μαθηματικές πράξεις
Οι ακόλουθοι μαθηματικοί τελεστές υπάρχουν στη JavaScript: + (πρόσθεση), - (αφαίρεση), * (πολλαπλασιασμός), / (διαίρεση), % (modulo), ++ (αύξηση μιας τιμής κατά 1), -- (μείωση μιας τιμής κατά 1).
6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, δηλ. 6:3=2 => 6-3*2 => ανάπαυση(0) 5%2 //1, δηλ. 5:2=2(.5) => 5-2*2 => υπόλοιπο(1) 7.3%2 //1.3, δηλ. 7,3:2=3(,65) => 7,3-2*3 => υπόλοιπο(1,3) //το πρόσημο του αποτελέσματος της λειτουργίας % ισούται με το πρόσημο της πρώτης τιμής -9%2,5 //-1,5 , δηλ. 9:2,5=3(,6) => 9-2,5*3 => ξεκούραση(1,5) -9%-2,5 //-1,5, δηλ. 9:2.5=3(.6) => 9-2.5*3 => υπόλοιπο (1.5) -2%5 //-2, δηλ. 2:5=0(.4) => 2-5*0 => υπόλοιπο(2) x = 3; console.log(x++); //outputs 3, στη συνέχεια ορίζει 4 console.log(x); //4 x = 3; console.log(++x); //ορίζει σε 4 και βγάζει x = 5; console.log(x--); //outputs 5, στη συνέχεια ορίζει 4 console.log(x); //4 x = 5; console.log(--x); //σύνολα 4 και έξοδοι Επιπλέον, η JavaScript έχει τελεστές συνδυασμού: 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; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3
Συχνά το αποτέλεσμα των υπολογισμών είναι ένας αριθμός με μεγάλο ποσόδεκαδικά ψηφία. Εάν αυτός ο αριθμός χρησιμοποιείται για περαιτέρω υπολογισμούς, τότε μπορεί να παραμείνει ως έχει. Αλλά μερικές φορές ένας αριθμός πρέπει να στρογγυλεύεται, για παράδειγμα για εμφάνιση σε μια σελίδα. Η JavaScript στρογγυλοποιεί αριθμούς χρησιμοποιώντας διάφορες μεθόδους.
Η μέθοδος Math.round() στρογγυλοποιεί την τιμή σε έναν ακέραιο.
Math.round (αριθμός)
Οι αριθμοί στρογγυλοποιούνται σύμφωνα με μαθηματικούς κανόνες. Δηλαδή, εάν μετά την υποδιαστολή υπάρχει ένας αριθμός από το 0 έως το 4, τότε το κλασματικό μέρος απλώς απορρίπτεται. Και αν μετά την υποδιαστολή υπάρχει ένας αριθμός από το 5 έως το 9, τότε το κλασματικό μέρος απορρίπτεται και ένα προστίθεται σε ολόκληρο το μέρος. παράδειγμα:
JavaScript:
Υπάρχουν δύο ακόμη μέθοδοι που στρογγυλοποιούν έναν αριθμό σε έναν ακέραιο αριθμό. Η μέθοδος Math.floor() στρογγυλοποιεί προς τα κάτω. Απορρίπτει το κλασματικό μέρος του αριθμού. Και η μέθοδος Math.ceil() ολοκληρώνεται. Απορρίπτει το κλασματικό μέρος και προσθέτει ένα στο ολόκληρο μέρος. Παράδειγμα:
Φυσικά, το 5 - (-2) είναι 5+2. Μην ξεχνάτε ότι δεν θα πάρετε τον αριθμό 5 σε αυτόν τον τύπο. Το μέγιστο θα είναι 4,999999999. Οι προκύπτουσες τιμές μπορούν να στρογγυλοποιηθούν στην απαιτούμενη ακρίβεια.
Εάν χρειάζονται μόνο ακέραιοι αριθμοί, τότε οι τιμές που προκύπτουν μπορούν να στρογγυλοποιηθούν προς τα κάτω στον πλησιέστερο ακέραιο αριθμό. Ένα πρέπει να προστεθεί στο μέγιστο ώστε να είναι δυνατό και αυτό το μέγιστο. Ο τύπος μοιάζει με αυτό:
ακέραιος = Math.floor(min + Math.random() * (max + 1 - min)
Ας εκτυπώσουμε αριθμούς από το 10 έως το 15:
20 |
για (i=1; i<=10; i++) { rand = Math.floor(10 + Math.random() * (15 + 1 - 10)); console.log(rand); } |
Σύγκριση κλασματικών αριθμών
Οι μαθηματικοί υπολογισμοί έχουν μια ιδιαιτερότητα - τα αποτελέσματά τους δεν είναι πάντα απολύτως ακριβή. Αυτό είναι ένα πρόβλημα όχι μόνο με τη JavaScript, αλλά και με τις περισσότερες γλώσσες προγραμματισμού. Αυτό συμβαίνει επειδή οι αριθμοί και άλλα δεδομένα μετατρέπονται σε δυαδικό κώδικα και μόνο τότε γίνονται υπολογισμοί με αυτούς. Στις περισσότερες περιπτώσεις, αυτό δεν οδηγεί σε ιδιαίτερες δυσκολίες οι υπολογισμοί απλώς μερικές φορές καταλήγουν σε έναν αριθμό με μεγάλο αριθμό δεκαδικών ψηφίων. Αλλά υπάρχει μια κατάσταση όπου η ανακρίβεια υπολογισμού επηρεάζει τη λειτουργία του προγράμματος. Αυτή είναι μια σύγκριση αριθμών. Εάν συγκριθούν διαφορετικοί αριθμοί, τότε όλα θα πρέπει να είναι καλά.
5.1 < 5.2
Αν όμως ο υπολογισμός καταλήξει σε δύο πανομοιότυπους κλασματικούς αριθμούς, τότε το αποτέλεσμα της σύγκρισής τους δεν είναι προβλέψιμο. Μπορεί να είναι ίσα ή το ένα μπορεί να είναι μεγαλύτερο από το άλλο. Όταν ένα σενάριο χρησιμοποιεί μια τέτοια σύγκριση, πρέπει να ελέγξετε εάν το σενάριο λειτουργεί σωστά. Εάν υπάρχει κάποιο σφάλμα σε αυτό, τότε πρέπει να στρογγυλοποιήσετε τις τιμές που συγκρίνονται.
Άλλες μαθηματικές μέθοδοι
Υπάρχουν αρκετές μέθοδοι για διάφορους μαθηματικούς υπολογισμούς. Είναι απλά και δεν απαιτούν πρόσθετη εξήγηση. Οι μέθοδοι που χρησιμοποιούνται συχνά παρατίθενται στον παρακάτω πίνακα:
Δοκιμάστε να κάνετε μερικούς υπολογισμούς χρησιμοποιώντας αυτές τις μεθόδους.
Πολύ συχνά, οι υπολογισμοί σε JavaScript δεν δίνουν ακριβώς τα αποτελέσματα που θέλουμε. Φυσικά, μπορούμε να κάνουμε ό,τι θέλουμε με αριθμούς - στρογγυλοποιούμε προς τα πάνω ή προς τα κάτω, ορίζουμε εύρη, κόβουμε τους περιττούς αριθμούς σε έναν ορισμένο αριθμό δεκαδικών ψηφίων, όλα εξαρτώνται από το τι θέλετε να κάνετε με αυτόν τον αριθμό στο μέλλον.Γιατί είναι απαραίτητη η στρογγυλοποίηση;
Μία από τις ενδιαφέρουσες πτυχές της JavaScript είναι ότι στην πραγματικότητα δεν αποθηκεύει ακέραιους αριθμούς, εργαζόμαστε αμέσως με αριθμούς κινητής υποδιαστολής. Αυτό, σε συνδυασμό με το γεγονός ότι πολλές κλασματικές τιμές δεν μπορούν να εκφραστούν σε έναν πεπερασμένο αριθμό δεκαδικών ψηφίων, στο JavaScript μπορούμε να πάρουμε αποτελέσματα όπως αυτό:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
Για πρακτικούς λόγους, αυτή η ανακρίβεια δεν έχει σημασία, στην περίπτωσή μας μιλάμε για ένα σφάλμα σε πεμπτουσιά, ωστόσο, αυτό μπορεί να απογοητεύσει ορισμένους. Μπορούμε επίσης να έχουμε κάπως περίεργα αποτελέσματα όταν εργαζόμαστε με αριθμούς που αντιπροσωπεύουν νομίσματα, ποσοστά ή μεγέθη αρχείων. Για να διορθώσουμε αυτές τις ανακρίβειες, χρειάζεται απλώς να μπορούμε να στρογγυλοποιήσουμε τα αποτελέσματα και αρκεί να ορίσουμε τη δεκαδική ακρίβεια.
Στρογγυλοποίηση αριθμών έχει πρακτική χρήση, μπορεί να χειριζόμαστε έναν αριθμό εντός κάποιου εύρους, για παράδειγμα θέλουμε να στρογγυλοποιήσουμε την τιμή στον πλησιέστερο ακέραιο αριθμό αντί να δουλεύουμε μόνο με το δεκαδικό μέρος.
Στρογγυλοποίηση δεκαδικών αριθμών
Για να κόψετε έναν δεκαδικό αριθμό, χρησιμοποιήστε τη μέθοδο toFixed ή toPrecision. Και οι δύο λαμβάνουν ένα μόνο όρισμα που προσδιορίζει, αντίστοιχα, πόσα σημαντικά ψηφία (δηλαδή, ο συνολικός αριθμός των ψηφίων που χρησιμοποιούνται στον αριθμό) ή δεκαδικά ψηφία (ο αριθμός μετά την υποδιαστολή) το αποτέλεσμα πρέπει να περιλαμβάνει:- Εάν ένα όρισμα δεν έχει οριστεί για το toFixed() τότε θα είναι προεπιλεγμένο ίσο με μηδέν, που σημαίνει 0 δεκαδικά ψηφία, το όρισμα έχει μέγιστη τιμή 20.
- Εάν δεν δοθεί όρισμα στην Ακρίβεια, ο αριθμός παραμένει ανέγγιχτος
Και οι δύο μέθοδοι toFixed() και toPrecision() επιστρέφουν μια παράσταση συμβολοσειράς του αποτελέσματος, όχι έναν αριθμό. Αυτό σημαίνει ότι όταν αθροίζεται μια στρογγυλεμένη τιμή με το randNum, θα παράγει μια συνένωση συμβολοσειρών αντί για ένα άθροισμα αριθμών:
Έστω randNum = 6,25; ας στρογγυλεμένο = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6.256"
Αν θέλετε το αποτέλεσμα να είναι αριθμητικός τύποςδεδομένα, τότε θα χρειαστεί να εφαρμόσετε το parseFloat:
Έστω randNum = 6,25; let rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3
Σημειώστε ότι οι τιμές του 5 στρογγυλοποιούνται εκτός από σπάνιες περιπτώσεις.
Οι μέθοδοι toFixed() και toPrecision() είναι χρήσιμες επειδή μπορούν όχι μόνο να κόψουν το κλασματικό μέρος, αλλά και να προσθέσουν δεκαδικά ψηφία, κάτι που είναι βολικό όταν εργάζεστε με νόμισμα:
Έστω wholeNum = 1 έστω dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
Σημειώστε ότι το toPrecision θα παράγει το αποτέλεσμα σε επιστημονική σημείωση εάν ο αριθμός των ακεραίων είναι μεγαλύτερος από την ίδια την ακρίβεια:
Έστω num = 123.435 num.toPrecision(2); > "1.2e+2"
Πώς να αποφύγετε σφάλματα στρογγυλοποίησης με δεκαδικούς αριθμούς
Σε ορισμένες περιπτώσεις, το ToFixed και το toPrecision στρογγυλοποιεί την τιμή 5 προς τα κάτω και προς τα πάνω:Έστω numTest = 1,005; numTest.toFixed(2); > "1.00"
Το αποτέλεσμα του παραπάνω υπολογισμού θα έπρεπε να ήταν 1,01, όχι 1. Αν θέλετε να το αποφύγετε παρόμοιο σφάλμα, μπορούμε να χρησιμοποιήσουμε τη λύση που προτείνει ο Jack L Moore, η οποία χρησιμοποιεί εκθετικούς αριθμούς για να υπολογίσει:
Συνάρτηση round(τιμή, δεκαδικά) ( επιστροφή Αριθμός(Math.round(τιμή+"e"+δεκαδικοί)+"e-"+δεκαδικοί);
Τώρα:
Γύρος (1.005,2); > 1.01
Εάν θέλετε μια πιο στιβαρή λύση από αυτή που φαίνεται παραπάνω, μπορείτε να μεταβείτε στο MDN.
Στρογγυλοποίηση έψιλον μηχανής
Μια εναλλακτική μέθοδος για τη στρογγυλοποίηση δεκαδικών αριθμών εισήχθη στο ES6. Η στρογγυλοποίηση έψιλον μηχανής παρέχει ένα εύλογο περιθώριο σφάλματος κατά τη σύγκριση δύο αριθμών κινητής υποδιαστολής. Χωρίς στρογγυλοποίηση, οι συγκρίσεις μπορεί να παράγουν αποτελέσματα παρόμοια με τα ακόλουθα:0,1 + 0,2 === 0,3 > ψευδές
Χρησιμοποιούμε το Math.EPSILON στη συνάρτησή μας για να έχουμε μια έγκυρη σύγκριση:
Συνάρτηση epsEqu(x, y) ( επιστροφή Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
Η συνάρτηση παίρνει δύο ορίσματα: το πρώτο είναι ο τρέχων υπολογισμός, το δεύτερο είναι το αναμενόμενο αποτέλεσμα. Επιστρέφει μια σύγκριση των δύο:
EpsEqu(0,1 + 0,2, 0,3) > true
Όλα τα σύγχρονα προγράμματα περιήγησης υποστηρίζουν ήδη μαθηματικές συναρτήσεις ES6, αλλά αν θέλετε υποστήριξη σε προγράμματα περιήγησης όπως το IE 11, χρησιμοποιήστε polyfills.
Κόψιμο του κλασματικού μέρους
Όλες οι μέθοδοι που παρουσιάζονται παραπάνω μπορούν να στρογγυλοποιηθούν σε δεκαδικούς αριθμούς. Για να κόψετε απλώς έναν αριθμό σε δύο δεκαδικά ψηφία, πρέπει πρώτα να τον πολλαπλασιάσετε με το 100 και στη συνέχεια να διαιρέσετε το αποτέλεσμα που προκύπτει με το 100:Συνάρτηση περικομμένη(αριθμός) ( επιστροφή Math.trunc(αριθμός * 100) / 100; ) περικομμένη(3.1416) > 3.14
Εάν θέλετε να προσαρμόσετε τη μέθοδο σε οποιονδήποτε αριθμό δεκαδικών ψηφίων, μπορείτε να χρησιμοποιήσετε διπλή άρνηση bitwise:
Συνάρτηση περικομμένη (αριθμός, δεκαδικά μέρη) ( έστω numPowerConverter = Math.pow(10, δεκαδικά μέρη); επιστροφή ~~ (αριθμός * numPowerConverter)/numPowerConverter; )
Τώρα:
Έστω randInt = 35.874993; περικομμένο(randInt,3); > 35.874
Στρογγυλοποιήστε στον πλησιέστερο αριθμό
Για να στρογγυλοποιήσουμε έναν δεκαδικό αριθμό στον πλησιέστερο αριθμό προς τα πάνω ή προς τα κάτω, σε όποιον είμαστε πιο κοντά, χρησιμοποιήστε το Math.round():Math.round(4.3) > 4 Math.round(4.5) > 5
Σημειώστε ότι το "μισό της τιμής", το 0,5 στρογγυλοποιείται σύμφωνα με τους κανόνες των μαθηματικών.
Στρογγυλοποιήστε προς τα κάτω στον πλησιέστερο ακέραιο αριθμό
Εάν θέλετε να στρογγυλεύετε πάντα προς τα κάτω, χρησιμοποιήστε το Math.floor:Math.floor(42.23); > 42 Math.floor(36,93); > 36
Λάβετε υπόψη ότι η στρογγυλοποίηση προς τα κάτω λειτουργεί για όλους τους αριθμούς, συμπεριλαμβανομένων των αρνητικών αριθμών. Φανταστείτε έναν ουρανοξύστη με άπειρο αριθμό ορόφων, συμπεριλαμβανομένων των ορόφων στο κάτω επίπεδο (που αντιπροσωπεύει αρνητικούς αριθμούς). Εάν βρίσκεστε σε ανελκυστήρα στο χαμηλότερο επίπεδο μεταξύ 2 και 3 (που αντιπροσωπεύει μια τιμή -2,5), το Math.floor θα σας μεταφέρει στο -3:
Math.floor(-2,5); > -3
Αλλά αν θέλετε να αποφύγετε παρόμοια κατάσταση, χρησιμοποιήστε το Math.trunc, που υποστηρίζεται σε όλα τα σύγχρονα προγράμματα περιήγησης (εκτός από το IE/Edge):
Math.trunc(-41,43); > -41
Στο MDN θα βρείτε ένα polyfill που θα παρέχει υποστήριξη για το Math.trunc σε προγράμματα περιήγησης και IE/Edge.
Στρογγυλοποιήστε στον πλησιέστερο ακέραιο αριθμό
Από την άλλη πλευρά, εάν χρειάζεται πάντα να στρογγυλοποιείτε, χρησιμοποιήστε το Math.ceil. Και πάλι, θυμηθείτε τον άπειρο ανελκυστήρα: Το Math.ceil θα ανεβαίνει πάντα «ανεβαίνει», ανεξάρτητα από το αν ο αριθμός είναι αρνητικός ή όχι:Math.ceil(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); > -36
Στρογγυλοποίηση προς τα πάνω/κάτω στον απαιτούμενο αριθμό
Αν θέλουμε να στρογγυλοποιήσουμε στο πλησιέστερο πολλαπλάσιο του 5, ο ευκολότερος τρόπος είναι να δημιουργήσουμε μια συνάρτηση που διαιρεί τον αριθμό με το 5, τον στρογγυλοποιεί και μετά τον πολλαπλασιάζει με το ίδιο ποσό:Συνάρτηση roundTo5(αριθμός) (επιστροφή Math.round(num/5)*5; )
Τώρα:
RoundTo5(11); > 10
Εάν θέλετε να στρογγυλοποιήσετε σε πολλαπλάσια της αξίας σας, χρησιμοποιούμε περισσότερα γενική λειτουργία, περνώντας την αρχική τιμή και ένα πολλαπλάσιο σε αυτήν:
Συνάρτηση roundToMultiple(αριθμός, πολλαπλάσια) ( επιστροφή Math.round(αριθμός/πολλαπλά)*πολλαπλά; )
Τώρα:
Έστω αρχικός αριθμός = 11; έστω πολλαπλάσιο = 10; roundToMultiple(initialNumber, multiple); > 10;
Διορθώνοντας έναν αριθμό σε ένα εύρος
Υπάρχουν πολλές περιπτώσεις όπου θέλουμε να πάρουμε μια τιμή x που βρίσκεται μέσα σε ένα εύρος. Για παράδειγμα, μπορεί να χρειαζόμαστε μια τιμή μεταξύ 1 και 100, αλλά καταλήξαμε σε μια τιμή 123. Για να το διορθώσουμε, μπορούμε να χρησιμοποιήσουμε min (επιστρέφει τον μικρότερο από ένα σύνολο αριθμών) και max (επιστρέφει το μεγαλύτερο από οποιοδήποτε σύνολο των αριθμών). Στο παράδειγμά μας, το εύρος είναι από 1 έως 100:Έστω lowBound = 1; ας highBound = 100; έστω numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
Και πάλι, μπορούμε να επαναχρησιμοποιήσουμε τη λειτουργία και να τυλίξουμε το όλο θέμα σε μια συνάρτηση, χρησιμοποιώντας τη λύση που προτείνει ο Daniel X. Moore:
Number.prototype.clamp = συνάρτηση(min, max) ( return Math.min(Math.max(this, min), max); );
Τώρα:
NumInput.clamp(lowBound, highBound); > 100;
Γκαουσιανή στρογγυλοποίηση
Η στρογγυλοποίηση Gauss, γνωστή και ως στρογγυλοποίηση τραπεζίτη, περιλαμβάνει στρογγυλοποίηση στον πλησιέστερο ζυγό αριθμό. Αυτή η μέθοδος στρογγυλοποίησης λειτουργεί χωρίς στατιστικό σφάλμα. Μια καλύτερη λύση προτάθηκε από τον Tim Down:Συνάρτηση gaussRound(αριθμός, δεκαδικά μέρη) (έστω d = δεκαδικά θέσεις || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0,5 - e && f< 0.5 + e) ?
((i % 2 == 0) ? i: i + 1) : Math.round(n);
return d ? r / m: r;
}
Τώρα:
GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Δεκαδικός σε CSS:
Δεδομένου ότι η JavaScript χρησιμοποιείται συχνά για τη δημιουργία αντιστοιχίσεων θέσης για στοιχεία HTML, ίσως αναρωτιέστε τι θα συνέβαινε αν δημιουργούσαμε δεκαδικές τιμές για τα στοιχεία μας:
#box (πλάτος: 63.667731993 px; )
Τα καλά νέα είναι ότι τα σύγχρονα προγράμματα περιήγησης θα σέβονται τις δεκαδικές τιμές μοντέλο μπλοκ, συμπεριλαμβανομένων ποσοστών ή μονάδων pixel.
Ταξινόμηση
Πολύ συχνά πρέπει να ταξινομήσουμε ορισμένα στοιχεία, για παράδειγμα, έχουμε μια σειρά από αρχεία παιχνιδιών και πρέπει να είναι οργανωμένα με φθίνουσα σειρά κατάταξης παικτών. Δυστυχώς, τυπική μέθοδοςΤο sort() έχει ορισμένους εκπληκτικούς περιορισμούς: λειτουργεί καλά με τα συχνά χρησιμοποιούμενα με αγγλικές λέξεις, αλλά αναλύεται αμέσως όταν συναντάτε αριθμούς, μοναδικούς χαρακτήρες ή κεφαλαία λόγια.Ταξινόμηση αλφαβητικά
Φαίνεται ότι η ταξινόμηση ενός πίνακα αλφαβητικά θα πρέπει να είναι μια απλή εργασία:Let fruit = ["κολοκυθάκι βουτυρού", "βερίκοκο", "πεπόνι"]; fruit.sort(); > "βερίκοκο", "κολοκυθάκι βουτυρού", "πεπόνι"]
Ωστόσο, αντιμετωπίζουμε πρόβλημα μόλις ένα από τα στοιχεία είναι με κεφαλαία:
Αφήνω φρούτα = ["κολοκυθάκι βουτυρού", "βερίκοκο", "κανταλόπη"]; fruit.sort(); > «Πεππόνι», «βερίκοκο», «κολοκυθάκι βουτύρου»]
Αυτό συμβαίνει επειδή, από προεπιλογή, ο ταξινομητής συγκρίνει τον πρώτο χαρακτήρα που αντιπροσωπεύεται στο Unicode. Το Unicode είναι μοναδικός κωδικόςγια οποιοδήποτε σύμβολο, ανεξαρτήτως πλατφόρμας, ανεξαρτήτως προγράμματος, ανεξαρτήτως γλώσσας. Για παράδειγμα, αν κοιτάξετε τον πίνακα κωδικών, ο χαρακτήρας "a" έχει την τιμή U+0061 (in δεκαεξαδικό σύστημα 0x61), ενώ ο χαρακτήρας "C" έχει τον κωδικό U+0043 (0x43), ο οποίος εμφανίζεται νωρίτερα στον πίνακα Unicode από τον χαρακτήρα "a".
Για να ταξινομήσουμε έναν πίνακα που μπορεί να περιέχει μικτά πρώτα γράμματα, πρέπει είτε να μετατρέψουμε όλα τα στοιχεία προσωρινά σε πεζά ή να ορίσουμε τη σειρά ταξινόμησης χρησιμοποιώντας τη μέθοδο localeCompare() με ορισμένα ορίσματα. Κατά κανόνα, για μια τέτοια περίπτωση, είναι καλύτερο να δημιουργήσετε αμέσως μια λειτουργία για επαναλαμβανόμενη χρήση:
Συνάρτηση alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash ", "βερίκοκο", "Cantaloupe"]; alphaSort(φρούτο) >
Εάν θέλετε να πάρετε έναν πίνακα αντίστροφη ταξινόμηση αλφαβητική σειρά, απλώς αλλάξτε τις θέσεις των a και b στη συνάρτηση:
Συνάρτηση alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash ", "βερίκοκο", "Cantaloupe"]; alphaSort(φρούτο) > ["Πεπόνι", "κολοκυθάκια βουτυρού", "βερίκοκο"]
Εδώ αξίζει να σημειωθεί ότι το localeCompare χρησιμοποιείται με ορίσματα, πρέπει επίσης να θυμόμαστε ότι υποστηρίζεται από τον IE11+, για παλαιότερες εκδόσεις του IE, μπορούμε να το χρησιμοποιήσουμε χωρίς ορίσματα και με πεζά:
Συνάρτηση caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["butternut squash", "Apricot", "Πεπονάκι"]; caseSort(fruit) > ["βερίκοκο", "κολοκυθάκι βουτύρου", "πεπόνι"]
Αριθμητική ταξινόμηση
Όλα αυτά δεν ισχύουν για το παράδειγμα που μιλήσαμε παραπάνω σχετικά με τη σειρά των ρεκόρ παιχνιδιών. Με ορισμένους αριθμητικούς πίνακες, η ταξινόμηση λειτουργεί μια χαρά, αλλά κάποια στιγμή το αποτέλεσμα μπορεί να είναι απρόβλεπτο:Έστω HighScores = ; highScores.sort(); >
Το θέμα είναι ότι η μέθοδος sort() εκτελεί μια λεξικογραφική σύγκριση: που σημαίνει ότι οι αριθμοί θα μετατραπούν σε μια συμβολοσειρά και οι συγκρίσεις θα γίνουν ξανά αντιστοιχίζοντας τον πρώτο χαρακτήρα αυτής της συμβολοσειράς με τη σειρά των χαρακτήρων στον πίνακα Unicode . Επομένως, πρέπει και πάλι να ορίσουμε τη σειρά ταξινόμησης:
Έστω HighScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Και πάλι, για να ταξινομήσετε τους αριθμούς με αντίστροφη σειρά, αλλάξτε τις θέσεις των a και b στη συνάρτηση.
Ταξινόμηση μιας δομής τύπου JSON
Και τέλος, εάν έχουμε μια δομή δεδομένων τύπου JSON που αντιπροσωπεύεται ως μια σειρά από εγγραφές παιχνιδιού:Let scores = [ ( "όνομα": "Daniel", "score": 21768 ), ( "όνομα": "Michael", "score": 33579 ), ( "όνομα": "Alison", "score": 38395 ) ];
Στο ES6+, μπορείτε να χρησιμοποιήσετε τις λειτουργίες βέλους:
Scores.sort((a, b) => b.score - a.score));
Για παλαιότερα προγράμματα περιήγησης που δεν έχουν αυτήν την υποστήριξη:
Scores.sort(function(a, b) ( return a.score - b.score ));
Όπως μπορείτε να δείτε, η ταξινόμηση σε JavaScript είναι ένα μάλλον ασαφές πράγμα, ελπίζω ότι αυτά τα παραδείγματα θα κάνουν τη ζωή ευκολότερη κατά κάποιο τρόπο.
Εργασία με λειτουργίες ισχύος
Η εκτίμηση είναι μια πράξη που αρχικά ορίστηκε ως το αποτέλεσμα του επανειλημμένου πολλαπλασιασμού ενός φυσικού αριθμού με τον εαυτό του, η τετραγωνική ρίζα του a είναι ο αριθμός που δίνει a όταν τετραγωνίζεται. Θα μπορούσαμε να χρησιμοποιούμε αυτές τις λειτουργίες συνεχώς Καθημερινή ζωήσε μαθήματα μαθηματικών, συμπεριλαμβανομένου του υπολογισμού περιοχών, όγκων ή ακόμα και φυσικής μοντελοποίησης.Σε JavaScript λειτουργία ισχύοςπαρουσιάστηκε ως Math.pow(), εισήχθη στο νέο πρότυπο ES7 νέο χειριστήεκφορά - " * * ".
Εκθεσιμότητα
Για να αυξήσετε έναν αριθμό στην nη δύναμη, χρησιμοποιήστε τη συνάρτηση Math.pow(), όπου το πρώτο όρισμα είναι ο αριθμός που θα αυξηθεί στη δύναμη, το δεύτερο όρισμα είναι ο εκθέτης:Math.pow(3,2) > 9
Αυτή η μορφή σημειογραφίας σημαίνει 3 τετράγωνο ή 3 × 3, που οδηγεί στο αποτέλεσμα 9. Φυσικά, μπορεί να δοθεί ένα άλλο παράδειγμα:
Math.pow(5,3); > 125
Δηλαδή, 5 κυβικά, ή 5 × 5 × 5, είναι ίσο με 125.
Το ECMAScript 7 είναι επόμενη έκδοση JavaScript, καταρχήν, μπορούμε να χρησιμοποιήσουμε τον νέο προτεινόμενο τελεστή εκθέσεως - * *, αυτή η μορφή σημειογραφίας μπορεί να είναι πιο περιγραφική:
3 ** 2
> 9
Επί αυτή τη στιγμήΗ υποστήριξη αυτού του χειριστή είναι αρκετά περιορισμένη, επομένως η χρήση του δεν συνιστάται.
Η λειτουργία ισχύος μπορεί να είναι πολύ χρήσιμη διαφορετικές καταστάσεις. Ένα απλό παράδειγμα, υπολογισμός του αριθμού των δευτερολέπτων σε μια ώρα: Math.pow (60,2).
Τετράγωνες και κυβικές ρίζες
Το Math.sqrt() και το Math.cbrt() είναι το αντίθετο του Math.pow(). Όπως θυμόμαστε, η τετραγωνική ρίζα του a είναι ο αριθμός που δίνει a όταν τετραγωνιστεί.Math.sqrt(9) > 3
Ταυτόχρονα, η κυβική ρίζα του a είναι ένας αριθμός που δίνει a όταν ανυψωθεί σε κύβο.
Math.cbrt(125) > 5
Το Math.cbrt() εισήχθη μόλις πρόσφατα στην προδιαγραφή JavaScript και επομένως υποστηρίζεται μόνο σε σύγχρονα προγράμματα περιήγησης: Chrome 38+, Firefox και Opera 25+ και Safari 7.1+. Θα το παρατηρήσετε Internet Explorerδεν περιλαμβάνεται σε αυτήν τη λίστα, αλλά θα βρείτε ένα πολυγέμισμα στο MDN.
Παραδείγματα
Φυσικά, μπορούμε να χρησιμοποιήσουμε μη ακέραιες τιμές σε μία από αυτές τις συναρτήσεις:Math.pow(1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
Λάβετε υπόψη ότι αυτό λειτουργεί επίσης πολύ καλά όταν χρησιμοποιείτε αρνητικές τιμές ορίσματος:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Ωστόσο, αυτό δεν θα λειτουργήσει για την τετραγωνική ρίζα:
Math.sqrt(-9) > NaN
Από μαθηματική ανάλυσηΓνωρίζουμε ότι με τον όρο φανταστικό αριθμό εννοούμε τις τετραγωνικές ρίζες των αρνητικών αριθμών. Και αυτό μπορεί να μας οδηγήσει σε μια άλλη τεχνική εργασίας μιγαδικοί αριθμοί, Αλλά αυτό είναι μια άλλη ιστορία.
Μπορείτε να χρησιμοποιήσετε κλάσματα στο Math.pow() για να βρείτε τις τετραγωνικές και κυβικές ρίζες των αριθμών. Τετραγωνική ρίζαχρησιμοποιεί εκθέτη 0,5:
Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
Ωστόσο, λόγω των ιδιοτροπιών της κινητής υποδιαστολής, δεν μπορείτε να μαντέψετε ακριβώς το σωστό αποτέλεσμα:
Math.pow(2.23606797749979,2) > 5.0000000000000001
Σε τέτοιες περιπτώσεις, θα πρέπει να καταφύγετε σε αποκοπή πινακίδων από τον αριθμό ή στρογγυλοποίηση σε κάποια τιμή.
Μερικοί, από για άγνωστους λόγουςΗ JavaScript συγχέει τη συνάρτηση Math.pow() με τη Math.exp() , η οποία είναι μια εκθετική συνάρτηση για αριθμούς γενικά. Σημείωση: σε αγγλική γλώσσαΟ "εκθέτης" μεταφράζεται ως "εκθέτης", επομένως αυτό είναι πιο πιθανό να ισχύει για τους αγγλόφωνους, αν και υπάρχουν εναλλακτικές ονομασίες για τον εκθέτη, όπως δείκτης, ισχύς.
Μαθηματικές σταθερές
Η εργασία με τα μαθηματικά σε JavaScript γίνεται ευκολότερη από μια σειρά από ενσωματωμένες σταθερές. Αυτές οι σταθερές είναι ιδιότητες του αντικειμένου Math. Αξίζει να σημειωθεί ότι οι σταθερές γράφονται με κεφαλαία και όχι με σημειογραφία CamelCase.Μόνο εγγεγραμμένοι χρήστες μπορούν να συμμετάσχουν στην έρευνα. Μπείτε, παρακαλώ.
Ετικέτες:- javascript
- μαθηματικά
