Hier sind verschiedene nützliche Snippets zu numerischen Operationen in JavaScript gesammelt.

Die Snippets stellen Beispiele dar. Passe diese gerne für deine Zwecke an. Manche Snippets sind für Anfänger, manche können auch für erfahrene Entwickler interessant sein.

01 · Abschnitt

Zwei Zahlen addieren.

JavaScript 
let numOne = 12;
let numTwo = 4;

if (!isNaN(numOne) && !isNaN(numTwo)) {
    let sum = numOne + numTwo;
    console.log(`Sum: ${sum}`);
} else {
    console.log("Numbers invalid");
}
Output 
Sum: 16
02 · Abschnitt

Das kleinste gemeinsame Vielfache finden.

JavaScript 
let numOne = 45;
let numTwo = 25;

// Check if numbers are valid and positive
if (
    !isNaN(numOne) &&
    !isNaN(numTwo) &&
    Number.isInteger(numOne) &&
    Number.isInteger(numTwo) &&
    numOne > 0 &&
    numTwo > 0
) {

    let largerNum = Math.max(numOne, numTwo);
    let lcm = largerNum;

    while (true) {
        if (lcm % numOne === 0 && lcm % numTwo === 0) {
            console.log(`LCM of ${numOne} & ${numTwo} = ${lcm}`);
            break;
        }
        lcm += largerNum;
    }

} else {
    console.log(`One or more numbers invalid.`);
}
Output 
LCM of 45 & 25 = 225
03 · Abschnitt

Den größten gemeinsamen Teiler finden.

JavaScript 
let numOne = 28;
let numTwo = 96;

// Check numbers are valid and positive
if (
    !isNaN(numOne) &&
    !isNaN(numTwo) &&
    Number.isInteger(numOne) &&
    Number.isInteger(numTwo) &&
    numOne > 0 &&
    numTwo > 0
) {
    let smallerNum = Math.min(numOne, numTwo);
    let gcd = 1;

    for (let i = 1; i <= smallerNum; i++) {
        if (numOne % i === 0 && numTwo % i === 0) {
            gcd = i;
        }
    }

    console.log(`GCD of ${numOne} and ${numTwo} = ${gcd}`);
} else {
    console.log("One or more numbers invalid.");
}
Output 
GCD of 28 and 96 = 4
04 · Abschnitt

Zufällige Zahl generieren.

Das untenstehende Beispiel generiert eine zufällige Zahl zwischen zwei angegbenen Zahlen.

JavaScript 
let numOne = 28;
let numTwo = 96;

// Check numbers are valid and positive
if (
    !isNaN(numOne) &&
    !isNaN(numTwo) &&
    Number.isInteger(numOne) &&
    Number.isInteger(numTwo) &&
    numOne > 0 &&
    numTwo > 0
) {
    let smallerNum = Math.min(numOne, numTwo);
    let gcd = 1;

    for (let i = 1; i <= smallerNum; i++) {
        if (numOne % i === 0 && numTwo % i === 0) {
            gcd = i;
        }
    }

    console.log(`GCD of ${numOne} and ${numTwo} = ${gcd}`);
} else {
    console.log("One or more numbers invalid.");
}
Output 
GCD of 28 and 96 = 4
05 · Abschnitt

Fläche des Kreises berechnen.

JavaScript 
function circleArea(radius) {
    if (isNaN(radius) || radius <= 0) {
        return "Invalid radius";
    }
    
    const area = Math.PI * Math.pow(radius, 2);
    return area;
}

const radius = 5;
const area = circleArea(radius);

console.log(`Area of circle with radius ${radius} = ${area}`);
Output 
Area of circle with radius 5 = 78.53981633974483
06 · Abschnitt

Fläche eines Dreiecks berechnen.

JavaScript 
let base = 10;
let height = 8;

if (!isNaN(base) && !isNaN(height) && base > 0 && height > 0) {
    let area = 0.5 * base * height;
    console.log(`Area: ${area}`);
} else {
    console.log("Number has to be valid");
    console.log("Base has to be positive");
    console.log("Height has to be positive");
}
Output 
Area: 40
07 · Abschnitt

Typ prüfen - Integer, Float oder NaN.

NaN = Not a number

JavaScript 
function checkNumberType(number) {
    if (typeof number !== "number" || isNaN(number)) {
        console.log(number + " is not a valid number");
    } else if (Number.isInteger(number)) {
        console.log(number + " is an integer");
    } else {
        console.log(number + " is a float");
    }
}

checkNumberType(5);
checkNumberType(3.14);
checkNumberType(7.0);
checkNumberType(-2.5);
checkNumberType(NaN);
checkNumberType("abc");
Output 
5 is an integer
3.14 is a float
7 is an integer
-2.5 is a float
NaN is not a valid number
abc is not a valid number
08 · Abschnitt

Prüfen, ob eine Zahl positiv, negativ oder Null ist.

JavaScript 
let posNum = parseFloat("10");
let negNum = parseFloat("-3");
let zeroNum = 0;

// Check - Positive number
if (!isNaN(posNum)) {
    if (posNum > 0) {
        console.log(`${posNum} is positive.`);
    }
} else {
    console.log("Number for posNum is invalid.");
}

// Check - Negative number
if (!isNaN(negNum)) {
    if (negNum < 0) {
        console.log(`${negNum} is negative.`);
    }
} else {
    console.log("Number for negNum is invalid.");
}

// Check - Zero number
if (zeroNum === 0) {
    console.log(`${zeroNum} is zero.`);
}
Output 
10 is positive.
-3 is negative.
0 is zero.
09 · Abschnitt

Prüfen, ob eine Zahl gerade oder ungerade ist

JavaScript 
let num = 14;

// Check if number is valid
if (!isNaN(num) && Number.isInteger(num)) {
    if (num % 2 === 0) {
        console.log(`${num} is even.`);
    } else {
        console.log(`${num} is odd.`);
    }
} else {
    console.log("Num is invalid number.");
}
Output 
14 is even.

Oder eine verkürzte Version.

JavaScript 
let num = 10;
console.log(num % 2 === 0 ? 'Gerade' : 'Ungerade');
Output 
Gerade
10 · Abschnitt

Quadratwurzel einer Zahl finden.

JavaScript 
let num = parseFloat("16");

if (!isNaN(num) && num >= 0) {
    let squareRoot = Math.sqrt(num);
    console.log(`Square root: ${squareRoot}`);
} else {
    console.log("Number is invalid");
}
Output 
Square root: 4
11 · Abschnitt

Bereich von Zahlen generieren

JavaScript 
function generateNumberRange(start, end) {
    let result = [];
    for (let i = 0; i <= end; i++) {
        result.push(i);
    }
    return result;
}

let numberRange = generateNumberRange(1, 5);
console.log("Number range:", numberRange);
Output 
Number range: [ 0, 1, 2, 3, 4, 5 ]
12 · Abschnitt

Multiplikationstabelle für eine Zahl generieren

JavaScript 
let num = 8;

if (!isNaN(num) && Number.isInteger(num)) {
    const range = 10;
    console.log(`Table for ${num} (up to ${range})`);
    for (let i = 1; i <= range; i++) {
        let result = num * i;
        console.log(`${num} x ${i} = ${result}`);
    }
} else {
    console.log("Num is invalid.");
}
Output 
Table for 8 (up to 10)
8 x 1 = 8
8 x 2 = 16
8 x 3 = 24
8 x 4 = 32
8 x 5 = 40
8 x 6 = 48
8 x 7 = 56
8 x 8 = 64
8 x 9 = 72
8 x 10 = 80
13 · Abschnitt

Summe der natürlichen Zahlen berechnen

Die Formel für die Berechnung lautet: sum = n * (n + 1) / 2

JavaScript 
let n = 20;

// Check if n is valid, positiv integer
if (!isNaN(n) && Number.isInteger(n) && n > 0) {
    let sum = (n * (n + 1)) / 2;
    console.log(`Sum of natural numbers from 1 to ${n}: ${sum}`);
} else {
    console.log("n is invalid.");
}
Output 
Sum of natural numbers from 1 to 20: 210
14 · Abschnitt

Summe der natürlichen Zahlen berechnen mit Rekursion

JavaScript 
// Define recursive function
function sumOfNaturalNumbers(n) {
    if (n === 1) {
        return 1;
    } else {
        return n + sumOfNaturalNumbers(n - 1);
    }
}

let num = 24;

// Check num is valid positive integer
if (!isNaN(num) && Number.isInteger(num) && num > 0) {
    let sum = sumOfNaturalNumbers(num);
    console.log(`Sum of natural numbers to ${num} = ${sum}`);
} else {
    console.log("Num is invalid.");
}
Output 
Sum of natural numbers to 24 = 300
15 · Abschnitt

Celsius nach Fahrenheit berechnen

JavaScript 
let celsius = parseFloat("26");

// Check celsius for valid number
if (!isNaN(celsius)) {
    let fahrenheit = (celsius * 9) / 5 + 32;
    console.log(`${celsius}° = ${fahrenheit} Fahrenheit.`);
} else {
    console.log("Number for celsius is invalid.");
}
Output 
26° = 78.8 Fahrenheit.
16 · Abschnitt

Kilometer nach Meilen berechnen

JavaScript 
let kilometers = parseFloat("120");

// Conversion factor
const kilometersToMilesFactor = 0.6213671;

// Check if input is a valid number
if (!isNaN(kilometers)) {
    let miles = (kilometers * kilometersToMilesFactor).toFixed(2);
    console.log(`${kilometers} km = ${miles} miles.`);
} else {
    console.log("Number for kilometers is invalid");
}
Output 
120 km = 74.56 miles.
17 · Abschnitt

Durchschnitt von zwei Zahlen finden

JavaScript 
function findAverage(numOne, numTwo) {
    let sum = numOne + numTwo;
    let average = sum / 2;
    return average;
}

let numberOne = 10;
let numberTwo = 20;
let result = findAverage(numberOne, numberTwo);

console.log(`Average of ${numberOne} and ${numberTwo} = ${result}`);
Output 
Average of 10 and 20 = 15
18 · Abschnitt

Zahl als Währung in lokaler Formatierung

JavaScript 
let amount = 1234.89;
let formattedAmount = amount.toLocaleString("de-DE", {style: "currency", currency: "EUR"});
console.log(`Formatted amount: ${formattedAmount}`);
Output 
Formatted amount: 1.234,89 €
19 · Abschnitt

Prüfen, ob Zahl einer Primzahl ist

JavaScript 
let num = 43;

// Check if num is valid and greater than 1
if (!isNaN(num) && Number.isInteger(num) && num > 1) {

    let isPrime = true;
    
    for (let i = 2; i <= Math.sqrt(num); i++) {
        if (num % i === 0) {
            isPrime = false;
            break;
        }
    }

    if (isPrime) {
        console.log(`${num} is prime number.`);
    } else {
        console.log(`${num} is NOT prime number.`);
    }

} else {
    console.log("Num is invalid number.")
}
Output 
43 is prime number.
20 · Abschnitt

Prüfen, ob eine Zahl eine Armstrong-Zahl ist

Eine Armstrong-Zahl ist eine Zahl, die die Summe ihrer eigenen Ziffern ist, jeweils hoch der Anzahl ihrer Ziffern.

Beispiel: 153 ist eine Armstrong-Zahl.

Erklärung:

  1. Zerlegung der Zahl 153 in Ziffern.
    • Erste Ziffer: 1
    • Zweite Ziffer: 5
    • Dritte Ziffer: 3
  2. Anzahl der Ziffern bestimmen.
    • 153 hat 3 Ziffern, allso n = 3
  3. Jede Ziffer hoch 3 nehmen.
    • 1^3 = 1
    • 5^3 = 125
    • 3^3 = 27
  4. Ergebnisse summieren.
    • 1 + 125 + 27 = 153
JavaScript 
let num = 153;

// Check if num is valid, positive integer
if (!isNaN(num) && Number.isInteger(num) && num > 0) {
    let originalNum = num;
    let numOfDigits = originalNum.toString().length;
    let sum = 0;

    // Calculate the sum of digits each raised to the power of the number of digits
    while (originalNum > 0) {
        let digit = originalNum % 10;
        sum += Math.pow(digit, numOfDigits);
        originalNum = Math.floor(originalNum / 10);
    }

    if (sum === num) {
        console.log(`${num} is Armstrong number.`);
    } else {
        console.log(`${num} is not Armstrong number.`);
    }
} else {
    console.log("Num is invalid.");
}
Output 
153 is Armstrong number.
21 · Abschnitt

Bereich von Zahlen auf Armstrong-Zahl prüfen

JavaScript 
let startNum = 10;
let endNum = 400;

if (
    !isNaN(startNum) &&
    !isNaN(endNum) &&
    Number.isInteger(startNum) &&
    Number.isInteger(endNum) &&
    startNum > 0 &&
    startNum < endNum
) {
    console.log(`Armstrong numbers: [${startNum} - ${endNum}]`);
    
    for (let i = startNum; i <= endNum; i++) {
        let originalNum = i;
        let numberOfDigits = originalNum.toString().length;
        let sum = 0;

        while (originalNum > 0) {
            let digit = originalNum % 10;
            sum += Math.pow(digit, numberOfDigits);
            originalNum = Math.floor(originalNum / 10);
        }

        if (sum === i) {
            console.log(i);
        }
    }
} else {
    console.log("Start or end number is invalid.");
}
Output 
Armstrong numbers: [10 - 400]
153
370
371
22 · Abschnitt

Faktoren einer gegebenen Zahl finden

JavaScript 
let number = 8;

// Check if input is valid positive integer
if (!isNaN(number) && Number.isInteger(number) && number > 0) {
    console.log(`Factors of ${number}:`);

    // Find and output the factors
    for (let i = 1; i <= number; i++) {
        if (number % i == 0) {
            console.log(i)
        }
    }
} else {
    console.log("The number is invalid.");
}
Output 
Factors of 8:
1
2
4
8
23 · Abschnitt

Fakultät einer Zahl finden

JavaScript 
let num = 14;

// Check if num is valid and non-negative
if (!isNaN(num) && Number.isInteger(num) && num >= 0) {
    let factorial = 1;
    for (let i = 1; i <= num; i++) {
        factorial *= i;
    }
    console.log(`Factorial of ${num} = ${factorial}`);
} else {
    console.log("Num is invalid.");
}
Output 
Factorial of 14 = 87178291200
24 · Abschnitt

Fakultät einer Zahl finden - mit Rekursion

JavaScript 
// Function - Calculate factorial
function factorial(n) {
    if (n === 0 || n === 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

let num = 6;

// Check if num is valid positive integer
if (!isNaN(num) && Number.isInteger(num) && num > 0) {
    let result = factorial(num);
    console.log(`Factorial of ${num} = ${result}`);
} else {
    console.log("Num is invalid.");
}
Output 
Factorial of 6 = 720
25 · Abschnitt

Fibonacci Reihe für eine Zahl berechnen

JavaScript 
let num = 25;

if (!isNaN(num) && Number.isInteger(num) && num > 0) {
    console.log(`Fibonacci sequence of ${num}:`);
    let fibArray = [0, 1];
    for (let i = 2; i < num; i++) {
        fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
    }
    console.log(fibArray.join("|"));
} else {
    console.log("Num is invalid.");
}
Output 
Fibonacci sequence of 25:
0|1|1|2|3|5|8|13|21|34|55|89|144|233|377|610|987|1597|2584|4181|6765|10946|17711|28657|46368
26 · Abschnitt

Fibonacci Reihe für eine Zahl berechnen - mit Rekursion

JavaScript 
// Function - generate fibonacci sequence
function fibonacci(n) {
    if (n <= 1) {
        return n;
    } else {
        return fibonacci(n -1) + fibonacci(n - 2);
    }
}

let num = 40;

// Check num is valid, positive integer
if (!isNaN(num) && Number.isInteger(num) && num >= 0) {
    console.log(`Fibonacci sequence of ${num}:`);

    for (let i = 0; i < num; i++) {
        console.log(fibonacci(i));
    }
} else {
    console.log("Num is invalid.");
}
Output 
Fibonacci sequence of 40:
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
10946
17711
28657
46368
75025
121393
196418
317811
514229
832040
1346269
2178309
3524578
5702887
9227465
14930352
24157817
39088169
63245986
/ Weiter

Zurück zu Snippets

Zur Übersicht