Διαίρεση ακέραιου αριθμού js. Κατάργηση - Διαίρεση ακέραιου αριθμού με υπόλοιπο σε JavaScript; Κόψιμο του κλασματικού μέρους
Αυτό σας επιτρέπει να διορθώσετε την απάντηση του @MarkElliot έτσι ώστε να λειτουργεί και για αρνητικούς αριθμούς:
Var div = Math.trunc(y/x); var rem = y % x;
Σημειώστε ότι οι μέθοδοι Math έχουν το πλεονέκτημα έναντι των τελεστών bitwise ότι λειτουργούν με αριθμούς μεγαλύτερους από 2 31 .
Η JavaScript υπολογίζει στα δεξιά το γένος των αρνητικών αριθμών και το υπόλοιπο των μη ακεραίων, ακολουθώντας μαθηματικούς ορισμούςγια αυτούς.
Το FLOOR ορίζεται ως "ο μεγαλύτερος ακέραιος μικρότερος από την παράμετρο", επομένως:
- θετικοί αριθμοί: FLOOR(X) = ακέραιο μέρος του X;
- αρνητικοί αριθμοί: FLOOR(X) = ακέραιο μέρος του X μείον 1 (επειδή θα πρέπει να είναι ΜΙΚΡΟΤΕΡΟ από την παράμετρο, δηλαδή πιο αρνητικό!)
ΥΠΟΜΕΝΟΝ ορίζεται ως οι «υπόλοιπες» διαιρέσεις (Ευκλείδεια αριθμητική). Όταν το μέρισμα δεν είναι ακέραιος, ο παράγοντας συνήθως δεν είναι επίσης ακέραιος, δηλαδή δεν υπάρχει υπόλοιπο, αλλά αν ο παράγοντας αναγκαστεί να είναι ακέραιος (και αυτό συμβαίνει όταν κάποιος προσπαθεί να πάρει το υπόλοιπο ή το μέτρο ενός αριθμός κινητής υποδιαστολής ), προφανώς θα υπάρχει ένας ακέραιος αριθμός "αριστερά".
Η JavaScript υπολογίζει τα πάντα όπως αναμενόταν, επομένως ο προγραμματιστής πρέπει να είναι προσεκτικός για να κάνει τις σωστές ερωτήσεις (και οι άνθρωποι πρέπει να είναι προσεκτικοί για να απαντήσουν σε ό,τι τίθεται!) Η πρώτη ερώτηση του Yarin ΔΕΝ ήταν "τι είναι ακέραιος διαίρεση του X με το Y", αντί για αυτό: "Ο ακέραιος αριθμός των φορών που ένας δεδομένος ακέραιος ΠΑΕΙ ΣΕ άλλο." Για τους θετικούς αριθμούς, η απάντηση είναι ίδια και για τους δύο, αλλά όχι για τους αρνητικούς αριθμούς, επειδή η διαίρεση ακέραιων αριθμών (μέρισμα με διαιρέτη) θα είναι -1 μικρότερη από τον αριθμό (διαιρέτης) "roll over" (μέρισμα). Με άλλα λόγια, το FLOOR θα επιστρέψει τη σωστή απάντηση για ακέραια διαίρεση ενός αρνητικού αριθμού, αλλά ο Yarin δεν το ρώτησε!
Το gammax απάντησε σωστά, αυτός ο κωδικός λειτουργεί σύμφωνα με τις οδηγίες του Yarin. Από την άλλη, ο Samuel κάνει λάθος, δεν έκανε τα μαθηματικά υποθέτω, αλλιώς θα έβλεπε ότι αυτό λειτουργεί πραγματικά (επίσης δεν είπε ποιος ήταν ο διαιρέτης του παραδείγματός του, αλλά ελπίζω να ήταν 3) :
Υπόλοιπο = X% Y = -100% 3 = -1
GoesInto = (X - Υπόλοιπο) / Y = (-100 - -1) / 3 = -99 / 3 = -33
Παρεμπιπτόντως, δοκίμασα τον κώδικα στον Firefox 27.0.1, λειτούργησε όπως αναμενόταν με θετικούς και αρνητικούς αριθμούς, καθώς και μη ακέραιες τιμές, τόσο για μερίσματα όσο και για διαιρέτες. Παράδειγμα:
100.34 / 3.57: GoesInto = -28, Remainder = -0.38000000000000079
Ναι, παρατήρησα ότι υπάρχει πρόβλημα με την υψηλή ακρίβεια, αλλά δεν έχω προλάβει να το ελέγξω (δεν ξέρω αν είναι πρόβλημα με Firefox, Windows 7 ή με το FPU της CPU μου). Ωστόσο, για την ερώτηση του Yarin, η οποία περιλαμβάνει μόνο ακέραιους αριθμούς, ο κώδικας gammax λειτουργεί καλά.
Μπορείτε να χρησιμοποιήσετε τη συνάρτηση parseInt για να λάβετε το περικομμένο αποτέλεσμα.
ParseInt(a/b)
Για να λάβετε το υπόλοιπο, χρησιμοποιήστε τον τελεστή mod:
Το parseInt έχει κάποιες παγίδες με συμβολοσειρές για να αποφύγει τη χρήση της παραμέτρου radix με βάση το 10
ParseInt("09", 10)
Σε ορισμένες περιπτώσεις, η αναπαράσταση συμβολοσειράς ενός αριθμού μπορεί να είναι επιστημονική σημείωση, οπότε το parseInt θα παράγει ένα εσφαλμένο αποτέλεσμα.
ParseInt(100000000000000000000000000000000, 10) // 1e+32
Αυτή η κλήση θα παράγει το αποτέλεσμα 1.
Ο υπολογισμός του αριθμού των σελίδων μπορεί να γίνει σε ένα βήμα: Math.ceil(x/y)
Αν απλώς μοιράζεστε τις δυνάμεις των δύο, μπορείτε να χρησιμοποιήσετε τελεστές bitwise:
Συνάρτηση εξαγωγής divideBy2(αριθμός) (επιστροφή ; ) συνάρτηση εξαγωγής divideBy4(αριθμός) (επιστροφή ;) συνάρτηση εξαγωγής divideBy8(αριθμός) (επιστροφή ;)
(Το πρώτο είναι το συγκεκριμένο, το δεύτερο είναι τα υπόλοιπα)
Αυτό θα περικόπτεται πάντα στο μηδέν. Δεν είμαι σίγουρος αν είναι πολύ αργά, αλλά λέει εδώ:
Συνάρτηση intdiv(μέρισμα, διαιρέτης) ( διαιρέτης = διαιρέτης - διαιρέτης % 1; αν (διαιρέτης == 0) ρίχνει νέο Σφάλμα("διαίρεση με μηδέν"); μέρισμα = μέρισμα - μέρισμα % 1; var rem = μέρισμα % διαιρέτης, επιστροφή ( υπόλοιπο: rem, πηλίκο: (μέρισμα - εμπόδιο) / διαιρέτης )
Δεν είμαι ειδικός στους τελεστές bitwise, αλλά εδώ είναι ένας άλλος τρόπος για να πάρετε έναν ακέραιο:
Var num = ~~(a / b);
Αυτό θα λειτουργήσει καλά και για αρνητικούς αριθμούς, ενώ η Math.floor() θα περιστρέφεται προς τη λάθος κατεύθυνση.
Αυτό φαίνεται επίσης σωστό:
Var num = (a / b) >> 0;
Το Math.floor(operation) επιστρέφει τη στρογγυλεμένη τιμή της πράξης.
Παράδειγμα ερώτησης 1:
Var x = 5; var y = 10,4; var z = Math.floor(x + y); console.log(z);
Κονσόλα:
Παράδειγμα ερώτησης 2:
Var x = 14; var y = 5; var z = Math.floor(x%y); console.log(x);
Κονσόλα:
Για κάποιο αριθμό y και κάποιο διαιρέτη x, υπολογίστε το πηλίκο και το υπόλοιπο (υπόλοιπο) ως:
Var πηλίκο = Math.floor(y/x); var υπόλοιπο = y % x;
Συχνά οι υπολογισμοί παράγουν αποτελέσματα που βρίσκονται εκτός των επιθυμητών ορίων. Ως αποτέλεσμα, είναι απαραίτητο να εφαρμοστεί Στρογγυλοποίηση 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. Αλλά αν χρειάζεται να παρέχετε υποστήριξη σε παλαιότερα προγράμματα περιήγησης, τότε θα πρέπει να χρησιμοποιήσετε polyfills.
Περικοπή δεκαδικών αριθμών
Όλες οι μέθοδοι που παρουσιάστηκαν προηγουμένως λειτουργούν 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.
Πολύ συχνά, οι υπολογισμοί σε 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;
Γκαουσιανή στρογγυλοποίηση
Η γκαουσιανή στρογγυλοποίηση, γνωστή και ως στρογγυλοποίηση τραπεζίτη, περιλαμβάνει στρογγυλοποίηση στον πλησιέστερο ζυγό αριθμό. Αυτή η μέθοδος στρογγυλοποίησης λειτουργεί χωρίς στατιστικό σφάλμα. Η καλύτερη απόφασηπροτάθηκε από τον 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 (σε δεκαεξαδικό 0x61), ενώ ο χαρακτήρας "C" έχει τον κωδικό U+0043 (0x43), ο οποίος εμφανίζεται νωρίτερα στο Unicode πίνακας από τον χαρακτήρα "α".
Για να ταξινομήσουμε έναν πίνακα που μπορεί να περιέχει μικτά πρώτα γράμματα, πρέπει είτε να μετατρέψουμε όλα τα στοιχεία προσωρινά σε πεζά ή να ορίσουμε τη σειρά ταξινόμησης χρησιμοποιώντας τη μέθοδο localeCompare() με ορισμένα ορίσματα. Κατά κανόνα, για μια τέτοια περίπτωση, είναι καλύτερο να δημιουργήσετε αμέσως μια λειτουργία για επαναλαμβανόμενη χρήση:
Συνάρτηση alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["squash buttternut ", "βερίκοκο", "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.Math.abs, parseInt, parseFloat
Η εργασία με αριθμούς σε JavaScript μπορεί να είναι πολύ πιο περίπλοκη από ό,τι φαίνεται. Οι λαμβανόμενες τιμές δεν εμπίπτουν πάντα στα αναμενόμενα όρια, μερικές φορές το αποτέλεσμα μπορεί να μην είναι καθόλου αυτό που περιμέναμε.Math.abs()
Η μέθοδος Math.abs() επιστρέφει την απόλυτη τιμή ενός αριθμού, η οποία μας θυμίζει μια παρόμοια μαθηματική συνάρτηση για το μέτρο συντελεστή ενός αριθμού.Έστω newVal = -57,64; Math.abs(newVal); > 57,64
Το Math.abs(0) επιστρέφει πάντα το μηδέν, αλλά αν βάλουμε ένα σύμβολο μείον μπροστά από τη συνάρτηση -Math.abs(NUM) θα παίρνουμε πάντα μια αρνητική τιμή.
Math.abs(0); > -0
parseInt()
Γνωρίζουμε ότι η JavaScript κατανοεί ότι το "15" είναι μια συμβολοσειρά, όχι ένας αριθμός και, για παράδειγμα, όταν αναλύουμε ιδιότητες CSS χρησιμοποιώντας JavaScript ή λαμβάνουμε μια τιμή από έναν μη προετοιμασμένο πίνακα, τα αποτελέσματά μας μπορεί να είναι απρόβλεπτα. Θα μπορούσαμε να λάβουμε μια συμβολοσειρά που αναπαρίσταται ως "17px" ως είσοδο, και αυτό δεν είναι ασυνήθιστο για εμάς. Το ερώτημα είναι πώς να μετατρέψετε αυτή τη συμβολοσειρά σε πραγματική τιμή και να τη χρησιμοποιήσετε σε περαιτέρω υπολογισμούς.Σύνταξη: parseInt(string, radix);
Η συνάρτηση parseInt μετατρέπει το πρώτο όρισμα που του διαβιβάστηκε σε τύπο συμβολοσειράς, το ερμηνεύει και επιστρέφει έναν ακέραιο ή NaN τιμή. Το αποτέλεσμα (αν όχι NaN) είναι ακέραιος και είναι το πρώτο όρισμα (string), που αντιμετωπίζεται ως αριθμός στην καθορισμένη ρίζα. Για παράδειγμα, η βάση 10 δείχνει τη μετατροπή από το δεκαδικό, το 8 από το οκταδικό, το 16 από το δεκαεξαδικό και ούτω καθεξής. Εάν η βάση είναι μεγαλύτερη από 10, τότε χρησιμοποιούνται γράμματα για να αναπαραστήσουν αριθμούς μεγαλύτερους από 9. Για παράδειγμα, για δεκαεξαδικούς αριθμούς (βάση 16), χρησιμοποιούνται τα γράμματα A έως F.
Ας δούμε ένα παράδειγμα εργασίας με ιδιότητες CSS, όπου, σχετικά, μπορούμε να πάρουμε την ακόλουθη τιμή:
Έστω elem = έγγραφο.σώμα; ας centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087,19px"
Μπορούμε να χωρίσουμε τις τιμές κατά κενά:
Έστω centers = centerPoint.split(" "); > ["454px", "2087.19px"]
Ωστόσο, κάθε στοιχείο εξακολουθεί να είναι μια συμβολοσειρά, μπορούμε να απαλλαγούμε από αυτό χρησιμοποιώντας τη συνάρτησή μας:
Έστω centerX = parseInt(centers, 10); > 454 έστω centerY = parseInt(centers, 10); >2087
Όπως μπορείτε να δείτε, με το δεύτερο όρισμα υποδεικνύουμε το σύστημα αριθμών στο οποίο θα μετατραπεί ο αριθμός αυτή η παράμετρος είναι προαιρετική, αλλά συνιστάται να τη χρησιμοποιήσετε εάν δεν γνωρίζετε ποια συμβολοσειρά θα ληφθεί ως είσοδος.
parseFloat()
Από το παραπάνω παράδειγμα, πιθανώς παρατηρήσατε ότι το parseInt απορρίπτει το κλασματικό μέρος. Στην περίπτωσή μας, το parseFloat μπορεί να λειτουργήσει με αριθμούς κινητής υποδιαστολής. Και πάλι, αυτό μπορεί να είναι χρήσιμο κατά την ανάλυση CSS και άλλων εργασιών, ειδικά όταν εργάζεστε με ποσοστά κινητής υποδιαστολής.Σύνταξη: parseFloat(string)
Έστω FP = "33,33333%"; console.log(parseFloat(FP)); > 33.33333
Σημειώστε ότι δεν υπάρχει δεύτερο όρισμα στη σύνταξη parseFloat.
Ενώ κατανοούμε ότι οι parseInt() και parseFloat() είναι εξαιρετικά χρήσιμες συναρτήσεις, είναι σημαντικό να έχουμε κατά νου ότι δεν είναι χωρίς σφάλματα, επομένως είναι απαραίτητο να ελέγξουμε το εύρος των αναμενόμενων τιμών και να αναλύσουμε τελικά το αποτέλεσμα για να διασφαλίσουμε ότι οι τιμές που λαμβάνονται είναι σωστές.
Αποστολή ανώνυμα
Σε αυτό το μέρος των μαθημάτων μας θα εξοικειωθούμε με το αντικείμενο Αριθμόςόπως με ένα κοντέινερ αριθμητικών τύπων δεδομένων. Η πραγματική αντικειμενική του ουσία θα αγγιχτεί πολύ επιφανειακά σήμερα.
Το ίδιο με το αντικείμενο Σειράπεριέχει γραμμές κειμένου, αντικείμενο Αριθμόςπεριέχει αριθμούς. Ακριβώς όπως οι συμβολοσειρές, οι αριθμοί που δημιουργούμε γίνονται αυτόματα στιγμιότυπα ενός αντικειμένου.
Αριθμός τύπος δεδομένων
Οι αριθμοί στο JavaScript διατίθενται σε δύο τύπους: ακέραιος και κινητής υποδιαστολής (δεν υπάρχουν διαιρέσεις σε πολλούς τύπους, όπως σε άλλες γλώσσες ακέραιος, μακρύς, σύντομος, διπλός). Οι αριθμοί κινητής υποδιαστολής έχουν ακέραια και κλασματικά μέρη που χωρίζονται με μια τελεία (ανεξάρτητα από τις ρυθμίσεις τοπικής ρύθμισης).
Αυτοί οι δύο τύποι αριθμών δεν είναι ανεξάρτητοι τύποι και δεν απαιτούν ειδική μετατροπή μεταξύ τους. Αν, για παράδειγμα, 32.5 θα πολλαπλασιάσουμε επί 0.4 , τότε παίρνουμε αμέσως έναν ακέραιο 13 , όχι κλάσμα 13.0 , η οποία πρέπει να μετατραπεί σε ακέραια τιμή (όπως συμβαίνει συχνά σε άλλες γλώσσες).
Δημιουργία αντικειμένου Αριθμός
Όπως μια συμβολοσειρά, ένας αριθμός συνήθως παρουσιάζεται ως αντικείμενο Αριθμός, μια απλή ανάθεση (σε αντίθεση με μια συμβολοσειρά, δεν απαιτούνται εισαγωγικά).
var myNum = 21 ;Αλλά μπορείτε επίσης να δημιουργήσετε ένα νέο αντικείμενο χρησιμοποιώντας τον κατασκευαστή:
var myNum = νέος αριθμός; myNum = 21 ;Στη συντριπτική πλειοψηφία των περιπτώσεων, αυτό είναι περιττό και ακόμη και επιβλαβές. Σωστά παραδείγματα παρόμοια εργασίαθα δούμε αντικείμενα στο 4ο μέρος.
Αναπαράσταση αριθμού
Εκθετική μορφή
Οι αριθμοί μπορούν να αναπαρασταθούν είτε με συνηθισμένη είτε με εκθετική μορφή, για παράδειγμα:
2e6 // χωρίς κενά!Σημαίνει: 2 × 10 6
Αν εξάγουμε έναν τέτοιο αριθμό μέσω της μεθόδου εγγράφου γράφω(), τότε παίρνουμε έναν διευρυμένο αριθμό στη συνηθισμένη αναπαράσταση.
Εγγραφο. γράφω(14e12);
Αποτέλεσμα:
Βασικά συστήματα αριθμών
Οι αριθμοί μπορούν επίσης να αναπαρασταθούν σε δεκαδικά, δεκαεξαδικά και οκταδικά συστήματα.
Ολόκληροςαριθμοί σε δεκαδική μορφή δεν πρέπει να ξεκινά από το μηδέν, γιατί το μηδέν είναι πρόθεμα για μη δεκαδικά συστήματα. Μόλις 0 πρόθεμα για οκταδικές τιμές και 0xγια δεκαεξαδικό.
Για παράδειγμα, 075 είναι η οκταδική παράσταση ενός δεκαδικού αριθμού 61 , ΕΝΑ 0x75δεκαεξαδική αναπαράσταση δεκαδικού αριθμού 117 .
Για οκταδικές τιμές, οι αριθμοί από 0 πριν 7 , για δεκαεξαδικές αλφαριθμητικές σειρές 0123456789ABCDEF. Μπορούν να χρησιμοποιηθούν γράμματα σε οποιοδήποτε μητρώο.
Οι αριθμητικές εκφράσεις μπορούν να χρησιμοποιούν οποιαδήποτε μορφή αριθμών, αλλά το αποτέλεσμα θα αναπαρίσταται πάντα ως δεκαδικός αριθμός.
Αναπαράσταση αριθμών σε άλλα συστήματα
Μιλώντας για το αντικείμενο Σειρά, θίξαμε τη μέθοδο toString(), το οποίο μετατρέπει οποιοδήποτε αντικείμενο σε συμβολοσειρά. Κατά τη μετατροπή αριθμών σε συμβολοσειρές, συνιστάται να προσδιορίσετε το σύστημα αριθμών ως όρισμα.
Σημείωση
Ο αρχικός αριθμός πρέπει να περικλείεται σε αγκύλες
(αριθμός). toString(Σύστημα)
Σύστημαμπορεί να πάρει οποιαδήποτε τιμή από 2 έως 36.
(157 ).toString(2 ); // δυαδική αναπαράσταση 157, ίσον (53 ).toString(27 ); // εξωτική αναπαράσταση 27 ψηφίων 53, ίσον
Αλλά αυτές οι εκφράσεις που προκύπτουν είναι συμβολοσειρές. Για να τους κάνετε πραγματικούς αριθμούς στα καθορισμένα συστήματα αριθμών, χρειάζεστε το αποτέλεσμα της μεθόδου toString(σύστημα)μετατρέψτε ξανά σε αριθμό. Αυτό δεν γίνεται πλέον με μέθοδο, αλλά Συνάρτηση πυρήνα Αριθμός(αντικείμενο). Θα μιλήσουμε για τις λειτουργίες του πυρήνα σε ένα από τα επερχόμενα μαθήματα, αλλά προς το παρόν δώστε προσοχή στη σύνταξη, είναι παρόμοια με μια κλήση συνάρτησης:
var a = 1546; var b = a. toString(2); var c = Αριθμός(σι);Ή αμέσως, "δύο σε ένα":
var a = 1546; var b = Αριθμός(ένα. toString(2 ));Σημείωση
Εάν ο αρχικός αριθμός έχει εκχωρηθεί σε μια μεταβλητή, τότε δεν χρειάζεται να τοποθετηθεί σε παρένθεση κατά την κλήση της μεθόδου toString() .
Ιδιότητες του αντικειμένου Αριθμός
Θα αγγίξουμε τις γενικές ιδιότητες αντικειμένου του κατασκευαστή και του πρωτοτύπου στο μάθημα για το αντικείμενο Αντικείμενο, και τώρα ας στραφούμε στις συγκεκριμένες ιδιότητες του αντικειμένου Αριθμός.
Αυτές οι ιδιότητες μόνο για διάβασμα, δηλαδή δεν μπορούμε να τα αλλάξουμε.
MAX_VALUE
Ο μέγιστος αριθμός που μπορεί να υποβληθεί σε επεξεργασία σε JavaScript.
Ας δούμε τι είδους αριθμός είναι αυτός:
var e = Αριθμός . MAX_VALUEέγγραφο. γράφω(μι)Αποτέλεσμα:
1,7976931348623157e+308
Plus σε αυτή την περίπτωση δεν είναι πρόσθετο πρόσημο, αλλά θετικός βαθμός, δηλαδή 1.7976931348623157 × 10.308
Σημείωση
Συνήθως δείχνω αποτελέσματα χρησιμοποιώντας πραγματικά γραπτά σενάρια. Αλλά πάρα πολλοί υπολογισμοί κλασματικοί αριθμοίμπορεί να επιβραδύνει τη φόρτωση της σελίδας και τα περισσότερα από τα αποτελέσματα σε αυτό το μάθημα είναι γραμμένα, ας πούμε, "με το χέρι".
MIN_VALUE
Και αυτή είναι κατά συνέπεια η ελάχιστη τιμή. Ας το εξερευνήσουμε.
var f = Αριθμός . MIN_VALUEέγγραφο. γράφω(φά)Αποτέλεσμα:
Αυτό είναι 5 × 10 -324
Μια μη αριθμητική τιμή που έχουμε ήδη συναντήσει.
Αυτή η ιδιότητα επιστρέφεται από τη JavaScript όταν μια αριθμητική λειτουργία παράγει με κάποιο τρόπο ένα μη αριθμητικό αποτέλεσμα.
NEGATIVE_INFINITY, POSITIVE_INFINITY
Μια φορά κι έναν καιρό σκέφτονταν κάτι τέτοιο: «ένα ελάφι, δύο ελάφια, πολλά ελάφια».
Το JavaScript μετράει λίγο πιο "προχωρημένο": "ένα ελάφι, δύο ελάφια, τρία ελάφια, ... , 1,7976931348623157 × 10,308 ελάφια, πολλά ελάφια."
Αυτό το υπερβατικό «πολλά» εκφράζεται από την ιδιότητα ΘΕΤΙΚΟ_ΑΠΕΙΡΟ.
Όταν η διαδικασία αντιστραφεί, διαιρώντας μια μονάδα («ένα ελάφι») σε μικρά, μικρά κομμάτια, το μικρότερο κομμάτι που θα μετρηθεί θα είναι 5 × 10 -324 μέρη. Οτιδήποτε λιγότερο είναι ήδη ΑΡΝΗΤΙΚΟ_ΑΠΕΙΡΟ.
Μέθοδοι του αντικειμένου Αριθμός
Σημείωση: Ακριβώς όπως η μέθοδος toString(), όλες οι άλλες μέθοδοι απαιτούν να περικλείεται ο αρχικός αριθμός σε παρένθεση εάν αναπαρίσταται ρητά (και όχι ως μεταβλητή).
toExponential()
Επιστρέφει μια συμβολοσειρά που αντιπροσωπεύει έναν αριθμό σε επιστημονική σημείωση, με ένα ψηφίο πριν από την υποδιαστολή.
Σύνταξη:
αριθμός. σε Εκθετικό(αριθμός πινακίδων)
Διαφωνία αριθμός πινακίδωνκαθορίζει την ακρίβεια στρογγυλοποίησης μετά την υποδιαστολή. Εάν το όρισμα παραλειφθεί, ο αριθμός των ψηφίων μετά την υποδιαστολή είναι ίσος με τον αριθμό των ψηφίων που απαιτούνται για την αναπαράσταση της τιμής.
Παράδειγμα:
var myFullNumber = 4659872156831598853654127; έγγραφο. γράφω(myFullNumber.toExponential(4))Αποτέλεσμα:
toFixed()
Επιστρέφει μια συμβολοσειρά που αντιπροσωπεύει έναν αριθμό σταθερού σημείου, στρογγυλεμένο στον αριθμό των δεκαδικών ψηφίων που καθορίζονται στο όρισμα.
Σύνταξη:
αριθμός. σε Διορθώθηκε(αριθμός πινακίδων)
Παραδείγματα:
var myDecimal1 = 46.59872156831598853654127; var myDecimal2 = 46 ; έγγραφο. γράφω(myDecimal1.toFixed(1)) έγγραφο. γράφω("") έγγραφο. γράφω(myDecimal2.toFixed(3))
Αποτελέσματα:
Αυτή η μέθοδος μερικές φορές είναι πολύ χρήσιμη. Για παράδειγμα, η δυσκίνητη συνάρτηση από το τελευταίο μάθημα μπορεί τώρα να αναπαρασταθεί ως εξής:
συνάρτηση anyRootPlus(x, y) ( var srcnum = Math . exp(Μαθηματικά. κούτσουρο(x)/y); var αποτέλεσμα = (srcnum). σε Διορθώθηκε(3); αποτέλεσμα επιστροφής? )Τώρα ας το εισαγάγουμε στη φόρμα και ας το δοκιμάσουμε:
Είναι αλήθεια ότι τώρα οι ακέραιοι θα έχουν επίσης τρία μηδενικά μετά την τελεία. Αλλά, γνωρίζοντας τη συμπεριφορά των αριθμών και των συμβολοσειρών, γνωρίζοντας πώς να εργάζεστε με τελεστές υπό όρους και τη μετατροπή τύπων, δεν είναι τόσο δύσκολο να κάνετε τον απαραίτητο αριθμητικό "σχεδιασμό".
toLocaleString()
Μετατρέπει ένα αριθμητικό αντικείμενο σε τιμή συμβολοσειράς, λαμβάνοντας υπόψη τις τοπικές ρυθμίσεις για διαχωριστικά δεκαδικών και χιλιάδων διαχωριστικών. Ως βάση λαμβάνεται το εθνικό νόμισμα, επομένως στη ρωσική έκδοση όλοι οι αριθμοί, ακόμη και ακέραιοι, παρουσιάζονται με δύο δεκαδικά ψηφία (καπίκια):
var myDrob = 25.327; var myMnogo = 25635120; var myRoubl = 35 ; /* μεγαλώστε το για να δείτε καλύτερα τα κόμματα */έγγραφο. γράφω(""
+ myDrob. toLocaleString() + "" ) έγγραφο. γράφω(""
+ myMnogo. toLocaleString() + "" ) έγγραφο. γράφω(""
+ myRoubl. toLocaleString() + "" );Αποτελέσματα:
toPrecision()
Επιστρέφει μια συμβολοσειρά που αντιπροσωπεύει έναν αριθμό με τον καθορισμένο συνολικό αριθμό σημαντικών ψηφίων.
Σύνταξη:
αριθμός. στην Ακρίβεια(QuantityDigits)
Διαφωνία:
QuantityDigitsαριθμός ψηφίων στην εμφανιζόμενη γραμμή. Εάν η καθορισμένη ποσότητα είναι μεγαλύτερη από την ποσότητα στον αρχικό αριθμό, εμφανίζονται δεκαδικά μηδενικά.
Εγγραφο. γράφω((354 ).στην Ακρίβεια(8 ))
Αποτέλεσμα:
Μέθοδοι toPrecision()Και toLocaleString()μαζί δεν δουλεύει, για τη "ρωσική σχεδίαση" αριθμών οποιασδήποτε ακρίβειας, θα χρειαστεί να γράψετε τη δική σας συνάρτηση. Η γραπτή συνάρτηση μπορεί να γίνει μια πρόσθετη μέθοδος του αντικειμένου Αριθμός, έχουμε ήδη κάνει κάτι παρόμοιο με το αντικείμενο Ημερομηνία(). Περισσότερες λεπτομέρειες στο μάθημα για το αντικείμενο Αντικείμενο.
toString()
Λοιπόν, έχουμε ήδη συζητήσει λεπτομερώς αυτήν τη μέθοδο στην αρχή του μαθήματος.
Δημιουργήστε τη δική σας μέθοδο
Τώρα θα δημιουργήσουμε την ίδια μέθοδο που θα εμφανίζει έναν αριθμό με οποιονδήποτε αριθμό δεκαδικών ψηφίων με κενά μεταξύ των χιλιοστών θέσεων και με κόμμα ως δεκαδικό διαχωριστικό.
Για να γίνει αυτό, χρειαζόμαστε μια αρκετά δύσκολη συνάρτηση που θα μετατρέπει συμβολοσειρές και πίνακες που λαμβάνονται από μια παρουσία ενός αντικειμένου Αριθμός.
Ας δηλώσουμε τη μέθοδο:
Number.prototype.toRussianString = toRussianString
Πριν ξεκινήσουμε τη δημιουργία της συνάρτησης, ας διατυπώσουμε τις εργασίες.
Πρώτα πρέπει να αναπαραστήσουμε τον αριθμό ως συμβολοσειρά και να εξαγάγουμε το ακέραιο μέρος, το κλασματικό μέρος και το διαχωριστικό σημείο από αυτό.
Στη συνέχεια, τοποθετήστε τα απαραίτητα κενά στο ακέραιο μέρος, στρογγυλοποιήστε το κλασματικό μέρος στον αριθμό των χαρακτήρων που μπορούν να καθοριστούν ως όρισμα στη συνάρτηση (και τη μέθοδο) και αλλάξτε την τελεία σε κόμμα.
Ας ξεκινήσουμε τη συνάρτηση δηλώνοντας τις απαραίτητες μεταβλητές.
συνάρτηση toRussianString(prec) ( /* μεταβλητές για μετατροπή συμβολοσειρών */ var a = "" , β = "" , γ, δ, ε;Κοιτάζοντας μπροστά, θα πω ότι το δεκαδικό μέρος, ως αποτέλεσμα των διαταραχών της χορδής μας, χάνει την «κλασματική» του ουσία και πρέπει να δουλέψουμε μαζί του όπως με έναν άλλο ακέραιο. Για να δουλέψουμε μαζί του θα χρησιμοποιήσουμε τη μέθοδο toPrecision(), και το όρισμα της συνάρτησής μας (και ταυτόχρονα της μεθόδου μας) ορίζει την τιμή ειδικά για τη μέθοδο toPrecision(). Η ελάχιστη παράμετρος αυτής της μεθόδου είναι μία. Και η συνάρτησή μας μπορεί επίσης να χρειάζεται μηδέν (όταν στρογγυλοποιούμε σε έναν ακέραιο). Και ταυτόχρονα, η σωστή στρογγυλοποίηση θα πρέπει να λειτουργεί ακόμη και πριν αρχίσουμε να «διαμελίζουμε» το αντικείμενο. Επομένως, αμέσως όταν δηλώνουμε μεταβλητές, θα το παρακάμψουμε υποβρύχιος βράχος:
/* μεταβλητή που μετατρέπει τη δεδομένη παρουσία αντικειμένου σε συμβολοσειρά */αν (prec == 0 ) var str = αυτό . σε Διορθώθηκε(0 ).toStringtoString(10 );Συνεχίζουμε να δηλώνουμε μεταβλητές.
/* μεταβλητή για την τιμή επιστροφής */ var nr1; /* μεταβλητές για μέρη της "έκρηξης" */ var intpart, fractpaft, precpart, divider, dot = str. lastIndexOf("." ) /* μετρητής */ var i;Μεταβλητός τελείαβρίσκει τη θέση ενός σημείου σε μια συμβολοσειρά του καθορισμένου αριθμού. Σε αυτή τη θέση κόβουμε ολόκληρο το μέρος ( ενδιάμεσο). Εάν ο αριθμός είναι ακέραιος και δεν υπάρχει σημείο, η θέση του θα είναι μικρότερη από το μηδέν. Σε αυτή την περίπτωση, ο διαχωριστής ( διαιρών), και το κλασματικό μέρος ( κλάσμα) πρέπει να είναι κενές συμβολοσειρές. Διαφορετικά, εκχωρείται κόμμα στο διαχωριστικό και το κλασματικό τμήμα κόβεται για περαιτέρω εργασία:
αν (κουκκ< 0 ) { intpart = str; fractpart = "" ; διαιρέτης = "" ;) else (inpart = str. υποσυμβολοσειρά(0 , τελεία); fractpart = στρ. υποσυμβολοσειρά(dot + 1 , str. μήκος) διαιρέτης = "," ;}Δουλεύουμε με όλο το μέρος. Τα κενά χρειάζονται μόνο εάν υπάρχουν περισσότεροι από 3 χαρακτήρες:
αν (εν μέρει. μήκος > 3 ) {Τώρα ας παίξουμε το ακόλουθο παιχνίδι "πασιέντζα" (όλα αυτά συμβαίνουν μέσα σε μια δήλωση υπό όρους):
Ας δούμε τις τριάδες με αντίστροφη σειρά.
Αρχικά, ας τα συλλέξουμε σε μια μεταβλητή έναχωρίς καμία προσθήκη, απλώς για να υπολογίσετε το μήκος της υποσυμβολοσειράς που προκύπτει. Εξάλλου, αν ο συνολικός αριθμός των ψηφίων δεν διαιρούνταν με το 3, τότε μια ουρά 1 ή 2 ψηφίων παρέμενε στα αριστερά και τώρα μπορούμε να την εκφράσουμε ως υποσυμβολοσειρά αφαιρώντας το μήκος της υποσυμβολοσειράς με "τρία" από το μήκος ολόκληρης της συμβολοσειράς (μεταβλητή ντο). Και βάλτε ένα χώρο που δεν σπάει μπροστά (που θα αφαιρέσουμε αργότερα). Για τι? Εφόσον οι ομάδες των τριών ψηφίων διαβάστηκαν με αντίστροφη σειρά, αυτή η αρχική ουρά θα πρέπει να τοποθετηθεί στο τέλος της σειράς. Δηλαδή, αν είχαμε έναν αριθμό, ας πούμε, 36748521, θα πρέπει να βάλουμε στη σειρά 521.748 36, βάζοντας ένα μη σπάσιμο διάστημα μπροστά από κάθε ομάδα έτσι ώστε να υπάρχει ένα διαχωριστικό για τον πίνακα (εξάλλου, πρέπει να τα αναστρέψουμε πίσω, και αυτό μπορεί να γίνει χρησιμοποιώντας τη μέθοδο array ΑΝΤΙΣΤΡΟΦΗ()).
Στην τελευταία εντολή του βρόχου, θα τακτοποιήσουμε σε τρίδυμα και θα γράψουμε το αποτέλεσμα σε μια μεταβλητή σι.
για (i=inpart. μήκος-3 ; i>=0 ; i-=3) /* συλλογή τριδύμων */(a = a + ενδιάμεσο. υποστρ(i, 3); /* βρείτε την αριστερή "ουρά" */γ = " " + ενδιάμεσο. υποστρ(0, ενδιάμεσο. μήκος-ένα. μήκος); /* διαχωριστικά θέσης σε τρίδυμα */ b = b + " " + ενδιάμεσο. υποστρ(i, 3);)Κατά την προσθήκη χορδών β+γπαίρνουμε μια συμβολοσειρά που πρέπει να μετατραπεί σε πίνακα, και στη συνέχεια αυτός ο πίνακας αντιστρέφεται και μετατρέπεται ξανά σε συμβολοσειρά (όλα αυτά γράφονται σε μια μεταβλητή ρε).
D = (b+c). διαίρεση(" " ).ΑΝΤΙΣΤΡΟΦΗ().toString().αντικαθιστώ(/,/σολ, " " );
Ο πίνακας μετατρέπεται σε συμβολοσειρά μαζί με οριοθέτες κόμματος δεν τους χρειαζόμαστε. Επομένως, στις ίδιες οδηγίες τα αφαιρούμε χρησιμοποιώντας κανονική έκφραση /,/g, Οπου /,/ δημιουργώντας μια κανονική έκφραση για το κόμμα και σολ"σημαία", που υποδεικνύει ότι πρέπει να αντικαταστήσετε όλα τα μοτίβα έκφρασης (απλά βάλτε όλα τα κόμματα) που εμφανίζονται στη γραμμή. Τα αντικαθιστούμε με τους ίδιους μη σπασμένους χώρους.
(Λεπτομέρειες για κανονικές εκφράσειςθα συζητηθεί στο τελευταίο μέρος του εγχειριδίου.)
Και τώρα πρέπει να καθαρίσουμε κάτι άλλο (μέσα στην ίδια δήλωση υπό όρους if (inpart.length > 3)).
Το γεγονός είναι ότι είτε στην αρχή είτε στο τέλος της γραμμής μας θα υπάρχει ένας επιπλέον χώρος χωρίς διακοπή που θα αποτελείται από 6 χαρακτήρες: "&", "n", "b", "s", "p" και " ;”. Επομένως, ας καθαρίσουμε τα σκουπίδια και ας γράψουμε το αποτέλεσμα σε μια μεταβλητή μι:
αν (δ. υποσυμβολοσειρά(0 , 1 ) == "&" ) e = δ. υποσυμβολοσειρά(6, d. μήκος-6); άλλο ε = δ. υποσυμβολοσειρά(0 , δ. μήκος-6 );Τώρα μπορούμε, με ήσυχη τη συνείδησή μας, να κλείσουμε ολόκληρη τη δήλωση υπό όρους και να γράψουμε Εναλλακτική επιλογηγια έναν σύντομο αριθμό που δεν χρειάζεται να χωριστεί σε «τρία».
) else e = intpart;Η μεταβλητή λοιπόν μιαποθηκεύει το ακέραιο μέρος του αριθμού και θα ασχοληθούμε με το δεκαδικό μέρος.
Προσοχή! Όταν εργαζόμαστε με το κλασματικό μέρος (το οποίο τώρα πρέπει να αντιμετωπιστεί ως σύνολο), πρέπει να θυμόμαστε ότι όταν prec == 0η λειτουργία θα δυσκολευτεί, οπότε ας την συνδέσουμε αμέσως:
αν (prec != 0 ) (Τώρα μπορείτε να εργαστείτε με την ησυχία σας. Αλλά υπάρχουν μερικές ακόμη «πέτρες» που τώρα θα παρακάμψουμε.
Πρώτον, αν έχουμε κλασματικό μέρος, ας υποθέσουμε 41 , και ορίζουμε τη στρογγυλοποίηση σε 3 ψηφία και μετά τη μέθοδο στην Ακρίβεια, λαμβάνοντας το κλασματικό μας μέρος ως ακέραιο, θα βγει 41.0 , δηλαδή, πρέπει να αφαιρέσετε το σημείο.
Δεύτερον, εάν το κλασματικό μέρος του αρχικού αριθμού είναι περισσότερα από 3 ψηφία, τότε η μέθοδος στην Ακρίβειαθα αρχίσει να παράγει το αποτέλεσμα σε εκθετική μορφή. Θα πρέπει να το πολεμήσετε και αυτό.
Επομένως, θα «καθαρίσουμε» το αποτέλεσμα μέσω τριών μεταβλητών: precpart, precpart1Και precpart2.
Precpart = (Αριθμός (fractpart). στην Ακρίβεια(προ)). toString(10 )
Τώρα «καθαρίζουμε»:
/* αν υπάρχει κλασματικό μέρος */ if (fractpart != "") ( /* αναζητήστε και εξαλείψτε το σημείο */ precpart1 = precpart. αντικαθιστώ(".", "") /* ελέγξτε για να δείτε αν υπάρχει εκθέτης εκεί, */ var plus = precpart1.lastIndexOf("e"); /* και αν υπάρχει, */αν (συν > 0 ) /* τραβήξτε το από τις ρίζες, */ precpart2 = precpart1. υποσυμβολοσειρά(0 , συν); /* σε διαφορετική περίπτωση */αλλού /* μην αλλάξεις τίποτα */ precpart2 = precpart1) /* αν δεν υπάρχει κλασματικό μέρος, */αλλού /* μετά βγάζουμε μηδενικά και πάλι απαλλαγούμε από την τελεία */ precpart2 = "," +precpart. αντικαθιστώ("." , "" )Εφόσον υποδείξαμε στην αρχή ότι αν δεν υπάρχει κλασματικό μέρος στον αρχικό αριθμό, δεν υπάρχει κόμμα, τότε σε αυτήν την περίπτωση πρέπει να το βάλουμε ξανά.
) άλλο ( /* δηλαδή, αν το prec εξακολουθεί να είναι μηδέν, απλώς εκτυπώστε κενές γραμμές */ precpart2 = "" ; διαιρέτης = "" ; }Και η τελευταία συγχορδία:
Nr1 = e + διαιρέτης + precpart2; επιστροφή nr1; )
Ολόκληρη η λειτουργία:
συνάρτηση toRussianString(prec) ( var a = "" , β = "" , γ, δ, ε; αν (prec == 0 ) var str = αυτό . σε Διορθώθηκε(0 ).toString(10); else var str = αυτό . toString(10); var nr1; var intpart, fractpaft, precpart, divider, dot = str. lastIndexOf("." ) var i; αν (κουκκ< 0 ) { intpart = str; fractpart = "" ; διαιρέτης = "" ;) else (inpart = str. υποσυμβολοσειρά(0 , τελεία); fractpart = στρ. υποσυμβολοσειρά(dot + 1 , str. μήκος) διαιρέτης = "," ;) αν (inpart. μήκος> 3 ) (για (i=intpart. μήκος-3 ; i>=0 ; i-=3 ) ( a = a + intpart. υποστρ(i, 3); γ = " " + ενδιάμεσο. υποστρ(0, ενδιάμεσο. μήκος-ένα. μήκος) b = b + " " + ενδιάμεσο. υποστρ(i, 3);) d = (b+c). διαίρεση(" " ).ΑΝΤΙΣΤΡΟΦΗ().toString().αντικαθιστώ(/,/σολ, " " ) αν (δ. υποσυμβολοσειρά(0 , 1 ) == "&" ) e = δ. υποσυμβολοσειρά(6, d. μήκος-6); άλλο ε = δ. υποσυμβολοσειρά(0 , δ. μήκος-6); ) else e = intpart; if (prec != 0 ) ( precpart = (Αριθμός (fractpart). στην Ακρίβεια(προ)). toString(10) if (fractpart != "") ( precpart1 = precpart. αντικαθιστώ(".", "") var plus = precpart1.lastIndexOf("e"); αν (συν > 0 ) precpart2 = precpart1. υποσυμβολοσειρά(0 , συν); else precpart2 = precpart1 ) else precpart2 = "," +precpart. αντικαθιστώ("." , "" ) ) else ( precpart2 = "" ; διαιρέτης = "" ; ) nr1 = e + διαιρέτης + precpart2; επιστροφή nr1; )Αυτή η συνάρτηση μπορεί τώρα να κληθεί ως μέθοδος.
Var myNumber = 2569843359.6583521 έγγραφο. γράφω(ο αριθμός μου. toRussianString(3 ))
Αποτέλεσμα:
Μπορείτε να τοποθετήσετε τη μέθοδο κατασκευής και τη συνάρτηση σε μια βιβλιοθήκη, δηλαδή σε ένα αρχείο .js που μπορεί να κληθεί από κώδικα ιστοσελίδας. Καθώς γράφετε μεθόδους για διαφορετικά αντικείμενα, μπορείτε να ταξινομήσετε τις μεθόδους σε αρχεία βιβλιοθήκης για αυτά τα αντικείμενα και να χρησιμοποιήσετε πρόσθετες μεθόδους.
