In diesem Artikel werden die fehlenden mathematischen Funktionen von JavaScript untersucht und benutzerdefinierte Implementierungen bereitgestellt. Während JavaScripts math Objekt nützliche Operationen anbietet, fehlen viele häufig verwendete Funktionen, die in anderen Sprachen zu finden sind. Wir werden abdecken: Summe, Produkt, ungerade/sogar Überprüfungen, Dreiecksnummern, Faktorien, Faktoren, Primzahlüberprüfungen, größter gemeinsamer Divisor (GCD) und niedrigstes gemeinsames Multiple (LCM).

Schlüsselpunkte:

1. erweitern die mathematischen Funktionen von JavaScript: Wir erstellen JavaScript -Funktionen für wesentliche mathematische Operationen, die nicht in der Standardbibliothek enthalten sind. Diese Funktionen sind in vielen Programmierkontexten von grundlegender Bedeutung.

2. effiziente Implementierungen: Wir werden effiziente Implementierungen mit iterativen (Schleifen) und rekursiven Ansätzen demonstrieren, die Techniken wie die record () Methode und der euklideische Algorithmus.

   zeigen.

3. Praktische Anwendungen und Codeoptimierung:

   Wir werden reale Szenarien hervorheben, in denen diese Funktionen vorteilhaft sind und die Klarheit und Effizienz von Code betonen.

fehlende mathematische Methoden:

1. Summe: Berechnung der Summe der Elemente eines Arrays. Die record ()

Methode liefert eine kurze Lösung:

function sum(array) {
  return array.reduce((sum, number) => sum   number, 0);
}

2. Produkt: Berechnung des Produkts der Elemente eines Arrays. Ähnlich wie Funktionsprodukt (Array) { return Array.Reduce ((insgesamt, num) => Gesamt * num, 1); }

function product(array) {
  return array.reduce((total, num) => total * num, 1);
}

festlegen, ob eine Nummer ungerade ist oder sogar den Modulo -Operator verwendet (

%): function iseven (number) { Rückgabezahl % 2 === 0; } Funktion isodd (number) { Rückgabezahl % 2! == 0; }

function isEven(number) {
  return number % 2 === 0;
}

function isOdd(number) {
  return number % 2 !== 0;
}

Berechnung der n -ten Dreiecksnummer unter Verwendung der Formel 0.5

n (n 1): Funktion trianglenumber (n) { Rückgabe 0,5 * n * (n 1); }

function triangleNumber(n) {
  return 0.5 * n * (n   1);
}

Berechnung des Faktororials einer Nummer unter Verwendung von Rekursion:

Funktion factorial (n) { if (n

function factorial(n) {
  if (n 

Finden Sie alle Faktoren einer Nummer:

Funktionsfaktoren (Nummer) { Sei Faktorenlisten = []; für (lass count = 1; count

function factors(number) {
    let factorsList = [];
    for (let count = 1; count 

prüft, ob eine Nummer Prim ist:

function issprime (number) { Rücklauffaktoren (Zahl) .Length === 2; }

function isPrime(number) {
  return factors(number).length === 2;
}

Verwenden des euklidischen Algorithmus für Effizienz:

Funktion gcd (a, b) { if (b === 0) { Rückkehr a; } anders { Return GCD (b, A % b); } }

function gcd(a, b) {
  if (b === 0) {
    return a;
  } else {
    return gcd(b, a % b);
  }
}

berechnet mit dem GCD:

Funktion LCM (a, b) { return (a * b) / gcd (a, b); }

function lcm(a, b) {
  return (a * b) / gcd(a, b);
}

(FAQS -Abschnitt bleibt weitgehend gleich, könnte aber leicht für einen besseren Fluss und die Selbstverständlichkeit umformuliert werden.)