Category:

Code

10 JavaScript conversion programs covering various scenarios

written by utmoker71

Here are 10 JavaScript conversion programs covering various scenarios like unit conversions, data type conversions, and currency conversions.

Each program includes an explanation of how it works.

1. String to Number Conversion

Converts a string input into a number using parseInt() and parseFloat().

let strNumber1 = "42";
let strNumber2 = "3.14";

let intNumber = parseInt(strNumber1);
let floatNumber = parseFloat(strNumber2);

console.log(intNumber); // Output: 42
console.log(floatNumber); // Output: 3.14

Explanation:

parseInt() converts the string “42” to an integer (42).
parseFloat() converts the string “3.14” to a floating-point number (3.14).

2. Number to String Conversion

Converts a number into a string using toString() or string templates.

let num = 123;
let numToString1 = num.toString();
let numToString2 = `${num}`; // Using template literals

console.log(numToString1); // Output: "123"
console.log(numToString2); // Output: "123"

Explanation:

toString() converts the number 123 into the string “123”.
Using template literals (`${num}`) also converts the number to a string.

3. Temperature Conversion (Celsius to Fahrenheit)

Converts a temperature from Celsius to Fahrenheit.

function celsiusToFahrenheit(celsius) {
  return (celsius * 9/5) + 32;
}

let celsius = 30;
let fahrenheit = celsiusToFahrenheit(celsius);

console.log(`${celsius}°C is ${fahrenheit}°F`); // Output: "30°C is 86°F"

Explanation:

The formula for converting Celsius to Fahrenheit is F = (C * 9/5) + 32.

4. Temperature Conversion (Fahrenheit to Celsius)

Converts a temperature from Fahrenheit to Celsius.

function fahrenheitToCelsius(fahrenheit) {
  return (fahrenheit - 32) * 5/9;
}

let fahrenheit = 86;
let celsius = fahrenheitToCelsius(fahrenheit);

console.log(`${fahrenheit}°F is ${celsius.toFixed(2)}°C`); // Output: "86°F is 30.00°C"

Explanation:

The formula for converting Fahrenheit to Celsius is C = (F – 32) * 5/9.
toFixed(2) rounds the output to 2 decimal places.

5. Meters to Kilometers Conversion

Converts a length in meters to kilometers.

function metersToKilometers(meters) {
  return meters / 1000;
}

let meters = 5000;
let kilometers = metersToKilometers(meters);

console.log(`${meters} meters is ${kilometers} kilometers`); // Output: "5000 meters is 5 kilometers"

Explanation:

1 kilometer is equal to 1000 meters, so divide the meter value by 1000.

6. Kilometers to Miles Conversion

Converts a distance from kilometers to miles.

function kilometersToMiles(kilometers) {
  return kilometers * 0.621371;
}

let kilometers = 10;
let miles = kilometersToMiles(kilometers);

console.log(`${kilometers} kilometers is ${miles.toFixed(2)} miles`); // Output: "10 kilometers is 6.21 miles"

Explanation:

1 kilometer is approximately 0.621371 miles, so multiply the kilometers by this factor.

7. Pounds to Kilograms Conversion

Converts weight from pounds to kilograms.

function poundsToKilograms(pounds) {
  return pounds * 0.453592;
}

let pounds = 150;
let kilograms = poundsToKilograms(pounds);

console.log(`${pounds} pounds is ${kilograms.toFixed(2)} kilograms`); // Output: "150 pounds is 68.04 kilograms"

Explanation:

1 pound is equal to approximately 0.453592 kilograms.

8. Currency Conversion (USD to EUR)

Converts currency from USD to EUR based on a given exchange rate.

function usdToEur(usd, exchangeRate) {
  return usd * exchangeRate;
}

let usd = 100;
let exchangeRate = 0.85; // Example exchange rate
let eur = usdToEur(usd, exchangeRate);

console.log(`${usd} USD is ${eur.toFixed(2)} EUR`); // Output: "100 USD is 85.00 EUR"

Explanation:

Multiply the USD amount by the exchange rate to convert it to EUR.

9. Binary to Decimal Conversion

Converts a binary number (as a string) into a decimal number.

function binaryToDecimal(binary) {
  return parseInt(binary, 2);
}

let binary = "1010";
let decimal = binaryToDecimal(binary);

console.log(`Binary ${binary} is ${decimal} in decimal`); // Output: "Binary 1010 is 10 in decimal"

Explanation:

parseInt(binary, 2) converts the binary string to a decimal number. The 2 indicates that the input is in base 2.

10. Hexadecimal to Decimal Conversion

Converts a hexadecimal number (as a string) into a decimal number.

function hexToDecimal(hex) {
  return parseInt(hex, 16);
}

let hex = "1A3";
let decimal = hexToDecimal(hex);

console.log(`Hexadecimal ${hex} is ${decimal} in decimal`); // Output: "Hexadecimal 1A3 is 419 in decimal"

Explanation:

parseInt(hex, 16) converts the hexadecimal string to a decimal number. The 16 indicates that the input is in base 16.

These examples cover various types of conversions, including data type conversions, unit conversions (length, temperature, weight), and currency conversions.

Feel free to customize these programs for your specific use cases!

October 5, 2024 0 comment

Code

JavaScript Program to Check for a Leap Year

written by utmoker71

A leap year is a year that is divisible by 4, but if it is also divisible by 100, it should be divisible by 400 to be a leap year.

In this tutorial, we will write JavaScript programs to check if a given year is a leap year using both simple logic and functions.

1. Basic Leap Year Check Using if…else Statements

Here’s a straightforward JavaScript program to check if a year is a leap year.

// Program to check if a year is a leap year
function isLeapYear(year) {
    if ((year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0)) {
        return true;
    } else {
        return false;
    }
}

// Test the function
const year = 2024;
if (isLeapYear(year)) {
    console.log(`${year} is a leap year.`);
} else {
    console.log(`${year} is not a leap year.`);
}

Output:

2024 is a leap year

Explanation of the Code

Define the isLeapYear Function:

function isLeapYear(year) {
    if ((year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0)) {
        return true;
    } else {
        return false;
    }
}

This function takes a year as an argument.
It uses an if…else statement to check if the year is a leap year using the following conditions:
year % 4 === 0: Checks if the year is divisible by 4.
year % 100 !== 0: Checks if the year is not divisible by 100, which covers the rule that every 100th year is not a leap year unless it is also divisible by 400.
year % 400 === 0: Checks if the year is divisible by 400, making it a leap year.

If either of the conditions is satisfied, the function returns true, indicating it is a leap year.
If none of the conditions are satisfied, it returns false.

Test the Function:

const year = 2024;
if (isLeapYear(year)) {
    console.log(`${year} is a leap year.`);
} else {
    console.log(`${year} is not a leap year.`);
}

Calls the isLeapYear function with the year (in this case, 2024).

Uses console.log() to display the result based on the function's return value.

2. Shortened Leap Year Check Using a Ternary Operator

You can also write a more concise version of the leap year check using the ternary operator.

function isLeapYear(year) {
    return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
}

// Test the function
const year = 1900;
console.log(`${year} is ${isLeapYear(year) ? 'a leap year' : 'not a leap year'}.`);

Output:

1900 is not a leap year.

Explanation of the Shortened Code

Simplified isLeapYear Function:

This version uses the same condition but directly returns the boolean result of the expression:

return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);

There’s no need for an if…else statement here, making the code shorter and cleaner.

Using the Ternary Operator:

console.log(`${year} is ${isLeapYear(year) ? 'a leap year' : 'not a leap year'}.`);

Uses the ternary operator (? 🙂 to decide the output based on the return value of isLeapYear(year).

3. Inline Leap Year Check Without a Function

If you don't need to reuse the leap year check and want to keep it inline, here's a quick way to perform the check:

const year = 2000;
const isLeap = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);

console.log(`${year} is ${isLeap ? 'a leap year' : 'not a leap year'}.`);

Output:

2000 is a leap year.

Explanation

Directly stores the result of the leap year check in the variable isLeap.
Uses the same condition as before to determine if year is a leap year.
The result is then logged using console.log().

Summary

The logic to check for a leap year in JavaScript follows these steps:

A year is a leap year if it is divisible by 4.
However, if the year is also divisible by 100, it must be divisible by 400 to be a leap year.

This tutorial shows you multiple ways to implement a leap year check in JavaScript:

Using an if…else statement within a function.
Using a concise version with a ternary operator.
Inline check without defining a separate function.

You can use any of these approaches depending on your use case and coding style preferences.

October 5, 2024 0 comment

Code

JavaScript Program to Generate a Random Number

written by utmoker71

In this tutorial, we'll create a JavaScript program that generates a random number within a specified range using JavaScript's built-in Math functions.

Here's a simple JavaScript program to generate a random number between a specified minimum and maximum value:

// Function to generate a random number between min and max (inclusive)
function getRandomNumber(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

// Define the range for random number generation
const min = 1;
const max = 100;

// Generate and display the random number
const randomNumber = getRandomNumber(min, max);
console.log(`Random number between ${min} and ${max}: ${randomNumber}`);

Explanation of the Code

Define the getRandomNumber Function:

function getRandomNumber(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

This function takes two parameters: min and max, which define the range within which the random number will be generated.

Math.random():

This method returns a floating-point number between 0 (inclusive) and 1 (exclusive). For example, it might return 0.54321, 0.12345, etc.

Math.random() * (max – min + 1):

This scales the random number to the desired range. For instance, if min is 1 and max is 100, this expression will return a random number between 0 (inclusive) and 100 (exclusive).

Math.floor(…):

This method rounds down the floating-point number to the nearest integer.

Since Math.random() generates a number less than 1, adding min ensures that the final result includes the minimum value and stays within the specified range.
+ min:
This shifts the number to start at the min value. For example, if the range is between 10 and 50, this ensures that the final random number starts at 10.

Define the Range for Random Number Generation:

const min = 1;
const max = 100;

These constants set the minimum and maximum values for the random number generation.

Generate and Display the Random Number:

const randomNumber = getRandomNumber(min, max);
console.log(`Random number between ${min} and ${max}: ${randomNumber}`);

Calls the getRandomNumber function with the specified range (min and max) and stores the result in the randomNumber variable.
Uses console.log() to display the generated random number in the console.

How It Works

When you call getRandomNumber(min, max), the function calculates a random number using the formula:

Math.floor(Math.random() * (max - min + 1)) + min
Math.random() generates a random decimal between 0 and 1.

This decimal is multiplied by (max – min + 1) to stretch it to the desired range.
Math.floor() then rounds it down to the nearest whole number, ensuring it's an integer.
Adding min shifts the range to include the minimum value, ensuring the random number falls between min and max, inclusive.

Example Run

If min is 1 and max is 100, the program might output something like:

Random number between 1 and 100: 42

Customizing the Range

You can easily change the min and max values to generate random numbers in a different range. For example, to generate a random number between 50 and 200:

const min = 50;
const max = 200;

Summary

Math.random() generates a random decimal between 0 and 1.
Math.floor() rounds the number down to the nearest integer.
The formula Math.floor(Math.random() * (max – min + 1)) + min generates a random integer between min and max (inclusive).
This JavaScript program provides a flexible way to generate random numbers within any specified range.

October 5, 2024 0 comment

Code

JavaScript Program to Make a Simple Calculator

written by utmoker71

In this tutorial, we'll create a simple calculator using JavaScript that can perform basic arithmetic operations: addition, subtraction, multiplication, and division.

We'll use the prompt() function for input and switch statement to handle different operations.

Here's the full code for the calculator:

Calculator code

// Function to perform calculations
function calculator() {
  // Prompt the user to select an operation
  const operator = prompt('Enter operator (+, -, *, /):');

  // Prompt the user to enter the numbers
  const num1 = parseFloat(prompt('Enter the first number:'));
  const num2 = parseFloat(prompt('Enter the second number:'));

  let result;

  // Use a switch statement to perform the selected operation
  switch (operator) {
    case '+':
      result = num1 + num2;
      break;
    case '-':
      result = num1 - num2;
      break;
    case '*':
      result = num1 * num2;
      break;
    case '/':
      if (num2 !== 0) {
        result = num1 / num2;
      } else {
        result = 'Error: Division by zero is not allowed!';
      }
      break;
    default:
      result = 'Invalid operator! Please refresh and try again.';
  }

  // Display the result
  console.log(`Result: ${result}`);
}

// Call the calculator function
calculator();

Explanation of the Code

Define the calculator Function:

The entire program is wrapped in a function called calculator. This is a good practice for modular and reusable code.

Prompt for Operation:

const operator = prompt(‘Enter operator (+, -, *, /):');
This line prompts the user to input the desired arithmetic operation (+, -, *, or /).
The input is stored in the variable operator.

Prompt for Numbers:

const num1 = parseFloat(prompt(‘Enter the first number:'));
const num2 = parseFloat(prompt(‘Enter the second number:'));
These lines prompt the user to input two numbers.
The parseFloat() function converts the string input from prompt() to a floating-point number, allowing for decimal operations.

Variable for the Result:

let result;
Declares a variable result to store the outcome of the selected operation.

Switch Statement for Operation Selection:

switch (operator) { … }

This block decides which arithmetic operation to perform based on the user's input.
Each case corresponds to a different operator:
+: Adds num1 and num2.
-: Subtracts num2 from num1.
*: Multiplies num1 by num2.
/: Divides num1 by num2 and includes a check to prevent division by zero.
break; statements ensure that once a case is executed, the program exits the switch block.
The default case handles invalid operator input by setting the result to an error message.

Display the Result:

console.log(\Result: ${result}`);`
Displays the result of the operation in the console using template literals.

Call the calculator Function:

calculator();

This line invokes the calculator function, starting the program.

Example Usage

When you run this program, it will:
Ask for an operator (e.g., +, -, *, /).
Ask for two numbers.
Perform the operation and log the result in the console.

Sample Run

Enter operator (+, -, *, /): +
Enter the first number: 10
Enter the second number: 5
Result: 15

Future Enhancements

Input Validation: Add checks to ensure that the inputs are valid numbers before performing operations.
User Interface: Create a more interactive user interface using HTML and buttons instead of prompt() for a better user experience.
Additional Operations: Add more mathematical operations, like modulus (%), exponentiation (**), square root, etc.

This code provides a simple yet effective way to perform basic arithmetic operations using JavaScript. The use of prompt() and switch statement makes it easy to understand and extend.

Feel free to modify and expand this code for more complex calculator functionalities!

October 5, 2024 0 comment

Code

JavaScript Program to Check Prime Numbers

written by utmoker71

Here are some JavaScript programs that check if a given number is a prime number.

A prime number is a number greater than 1 that has no positive divisors other than 1 and itself.

Example 1: Basic Prime Number Check

This simple program checks if a number is prime using a for loop.

function isPrime(num) {
  if (num <= 1) {
    return false; // Numbers less than 2 are not prime
  }

  for (let i = 2; i < num; i++) {
    if (num % i === 0) {
      return false; // If divisible by any number other than 1 and itself, not prime
    }
  }

  return true; // Number is prime
}

// Test the function
const number = 29;
if (isPrime(number)) {
  console.log(`${number} is a prime number.`);
} else {
  console.log(`${number} is not a prime number.`);
}

Output:

29 is a prime number.

Explanation

The function isPrime(num) checks if the given number num is prime.
If num is less than or equal to 1, it is not a prime number.
The for loop iterates from 2 to num – 1 to check for divisors. If any divisor is found, it returns false.
If no divisors are found, the function returns true.

Example 2: Optimized Prime Number Check

A more efficient way to check if a number is prime is to iterate only up to the square root of the number. This reduces the number of iterations and improves performance.

function isPrime(num) {
  if (num <= 1) {
    return false; // Numbers less than 2 are not prime
  }
  
  // Check from 2 to the square root of num
  for (let i = 2; i <= Math.sqrt(num); i++) {
    if (num % i === 0) {
      return false; // If divisible, not prime
    }
  }

  return true; // Number is prime
}

// Test the function
const number = 29;
if (isPrime(number)) {
  console.log(`${number} is a prime number.`);
} else {
  console.log(`${number} is not a prime number.`);
}

Output:

29 is a prime number.

Explanation

This optimized version checks divisors only up to the square root of num, significantly reducing the number of iterations.

Example 3: Check Prime Numbers in a Range

This program checks all numbers within a specified range and logs whether each number is prime.

function isPrime(num) {
  if (num <= 1) {
    return false;
  }

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

  return true;
}

function checkPrimesInRange(start, end) {
  for (let i = start; i <= end; i++) {
    if (isPrime(i)) {
      console.log(`${i} is a prime number.`);
    } else {
      console.log(`${i} is not a prime number.`);
    }
  }
}

// Test the function
checkPrimesInRange(10, 20);

Output:

10 is not a prime number.
11 is a prime number.
12 is not a prime number.
13 is a prime number.
14 is not a prime number.
15 is not a prime number.
16 is not a prime number.
17 is a prime number.
18 is not a prime number.
19 is a prime number.
20 is not a prime number.

Explanation

The isPrime(num) function is used to check if each number in the range is prime.
The checkPrimesInRange(start, end) function iterates through the specified range and uses isPrime to log whether each number is prime.

Example 4: One-Liner Prime Number Check Using Array.every()

Here’s a one-liner function using the Array.every() method to check if a number is prime.

const isPrime = (num) => num > 1 && [...Array(Math.floor(Math.sqrt(num)) - 1).keys()].map(i => i + 2).every(i => num % i !== 0);

// Test the function
const number = 29;
console.log(isPrime(number) ? `${number} is a prime number.` : `${number} is not a prime number.`);

Output:

29 is a prime number.

Explanation

This one-liner creates an array of numbers from 2 to the square root of num.
The every() method checks that num is not divisible by any of these numbers.
It returns true if num is prime and false otherwise.
These examples show different ways to check if a number is prime in JavaScript, ranging from simple loops to optimized methods. Feel free to use or adapt these examples depending on your use case!

October 5, 2024 0 comment