JavaScript Syntax Flashcards For Beginners

Switch statements are used to execute different blocks of code based on different cases. They are declared using the switch keyword followed by the variable to evaluate and the cases to test against. Here is an example code for using a switch statement:

/* Switch statement */
let fruit = "banana";

switch (fruit) {
  case "apple":
    console.log("This is an apple.");
    break;
  case "banana":
    console.log("This is a banana.");
    break;
  default:
    console.log("Unknown fruit.");
}

JavaScript has several operators including arithmetic, comparison, logical, and assignment operators. Here is an example code for using operators:

/* Operators */
let a = 5;
let b = 10;
console.log(a + b); // output: 15
console.log(a == b); // output: false
console.log(a < b && a > 0); // output: true
a += 2;
console.log(a); // output: 7

Arrow functions are a shorthand way to declare functions in JavaScript. They are declared using the arrow notation => and can have implicit return statements. Here is an example code for using arrow functions:

/* Arrow functions */
let add = (a, b) => a + b;

let result = add(2, 3);
console.log(result); // output: 5

JavaScript has several data types including numbers, strings, booleans, objects, arrays, and null/undefined. Here is an example code for declaring data types:

/* Data types */
let age = 30;
let name = "John";
let isStudent = true;
let person = { name: "John", age: 30 };
let numbers = [1, 2, 3, 4];
let noValue = null;
let undefinedValue;

Arrays are used to store multiple values in a single variable. They are declared using square brackets and can hold any data type. Here is an example code for using an array:

/* Arrays */

let numbers = [1, 2, 3, 4];

Template literals are a way to concatenate strings and variables in a more readable and concise way. They are declared using backticks and placeholders for variables. Here is an example code for using template literals:

/* Template literals */
let name = "John";
let age = 30;
console.log(`My name is ${name} and I am ${age} years old.`); 
// output: "My name is John and I am 30 years old."

If statements are used to execute code based on a condition. They are declared using the if keyword followed by the condition and the code to execute if the condition is true. Here is an example code for using an if statement:

/* If statement */
let age = 30;

if (age >= 18) {
  console.log("You are an adult.");
}

Variables are used to store values in JavaScript. They are declared using the var, let, or const keyword followed by the variable name and an optional initial value. Here is an example code for declaring a variable:

/* Variables */
var message = "Hello, world!";
let count = 0;
const PI = 3.14;

While loops are used to iterate over a block of code while a condition is true. They are declared using the while keyword followed by the condition. Here is an example code for using a while loop:

/* While loop */
let i = 0;

while (i < 5) {
  console.log(i);
  i++;
}

Objects are used to store multiple values in a key-value format. They are declared using curly braces and can hold any data type. Here is an example code for using an object:

/* Objects */
let person = { name: "John", age: 30 };
console.log(person.name); // output: "John"

Else statements are used in conjunction with if statements to execute code if the condition is false. Here is an example code for using an else statement:

/* Else statement */
let age = 16;

if (age >= 18) {
  console.log("You are an adult.");
} else {
  console.log("You are a minor.");
}

Callback functions are used to pass a function as an argument to another function to be executed later. They are commonly used in asynchronous programming. Here is an example code for using a callback function:

/* Callback functions */
function greet(name, callback) {
  console.log(`Hello, ${name}!`);
  callback();
}

function bye() {
  console.log("Goodbye!");
}

greet("John", bye); 
// output: "Hello, John!" and "Goodbye!"

Functions are used to encapsulate a block of code that can be called multiple times with different arguments. They are declared using the function keyword followed by the function name, parameters, and function body. Here is an example code for declaring a function:

/* Functions */
function greet(name) {
  console.log("Hello, " + name + "!");
}

greet("John"); // output: "Hello, John!"

For loops are used to iterate over a block of code a specific number of times. They are declared using the for keyword followed by the initialization, condition, and increment/decrement expressions. Here is an example code for using a for loop:

/* For loop */
for (let i = 0; i < 5; i++) {
  console.log(i);
}

Classes are a way to define blueprints for creating objects in JavaScript. They are declared using the class keyword and can have properties and methods. Here is an example code for using classes:

/* Classes */
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  sayHello() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

let person = new Person("John", 30);
person.sayHello(); 
// output: "Hello, my name is John and I am 30 years old."

In JavaScript, functions can be assigned to variables and passed as arguments to other functions. Here is an example code for using functions as values:

/* Functions as values */
let add = function(a, b) {
  return a + b;
}

let result = add(2, 3);
console.log(result); // output: 5