navigation Navigation

MB arrow_forward Projekte arrow_forward Leistungen arrow_forward Docs arrow_forward

Number Snippets

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.

Inhaltsverzeichnis

    Zwei Zahlen addieren.

    let numOne = 12;
let numTwo = 4;

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

    Das kleinste gemeinsame Vielfache finden.

    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.`);
}
    LCM of 45 & 25 = 225

    Den größten gemeinsamen Teiler finden.

    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.");
}
    GCD of 28 and 96 = 4

    Zufällige Zahl generieren.

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

    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.");
}
    GCD of 28 and 96 = 4

    Fläche des Kreises berechnen.

    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}`);
    Area of circle with radius 5 = 78.53981633974483

    Fläche eines Dreiecks berechnen.

    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");
}
    Area: 40

    Typ prüfen - Integer, Float oder NaN.

    NaN = Not a number

    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");
    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

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

    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.`);
}
    10 is positive.
-3 is negative.
0 is zero.

    Prüfen, ob eine Zahl gerade oder ungerade ist

    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.");
}
    14 is even.

    Oder eine verkürzte Version.

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

    Quadratwurzel einer Zahl finden.

    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");
}
    Square root: 4

    Bereich von Zahlen generieren

    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);
    Number range: [ 0, 1, 2, 3, 4, 5 ]

    Multiplikationstabelle für eine Zahl generieren

    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.");
}
    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

    Summe der natürlichen Zahlen berechnen

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

    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.");
}
    Sum of natural numbers from 1 to 20: 210

    Summe der natürlichen Zahlen berechnen mit Rekursion

    // 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.");
}
    Sum of natural numbers to 24 = 300

    Celsius nach Fahrenheit berechnen

    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.");
}
    26° = 78.8 Fahrenheit.

    Kilometer nach Meilen berechnen

    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");
}
    120 km = 74.56 miles.

    Durchschnitt von zwei Zahlen finden

    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}`);
    Average of 10 and 20 = 15

    Zahl als Währung in lokaler Formatierung

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

    Prüfen, ob Zahl einer Primzahl ist

    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.")
}
    43 is prime number.

    Prüfen, ob eine Zahle 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
    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.");
}
    153 is Armstrong number.

    Bereich von Zahlen auf Armstrong-Zahl prüfen

    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.");
}
    Armstrong numbers: [10 - 400]
153
370
371

    Faktoren einer gegebenen Zahl finden

    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.");
}
    Factors of 8:
1
2
4
8

    Fakultät einer Zahl finden

    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.");
}
    Factorial of 14 = 87178291200

    Fakultät einer Zahl finden - mit Rekursion

    // 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.");
}
    Factorial of 6 = 720

    Fibonacci Reihe für eine Zahl berechnen

    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.");
}
    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

    Fibonacci Reihe für eine Zahl berechnen - mit Rekursion

    // 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.");
}
    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