Just Learn Code

Mastering Expressions and Statements: The Building Blocks of Programming

Expressions and Statements in Programming: Understanding the Building Blocks

If you are a budding programmer, have you ever found yourself puzzled when reading a code? You see a lot of signs, symbols, and characters, but they don’t seem to make any sense.

Is it a puzzle that only the smartest individuals can solve? Fear not, as this article will guide you in understanding one of the most fundamental concepts in programming: expressions and statements.

These are key building blocks of every code, so once you understand them, you’ll be able to create, read and modify code efficiently.

Definition of Expressions and Statements

Programming languages use expressions and statements to communicate with a computer the actions that should be taken. The most basic definition of an expression is a combination of values, variables, operators, and functions, which can be evaluated or simplified to a new value.

For example, the expression 3 + 4 produces a new value, which is 7. On the other hand, a statement is a complete line of code that can perform a specific action or task.

A statement ends with a semicolon (;) to signify its completion. For example, console.log(“Hello, World!”); is a statement.

It instructs the computer to output “Hello, World!” in the console.

Identifying Expressions in Code

Expressions are used to manipulate data and perform calculations in code. They are composed of operands and operators (like +, =, and -).

Operands can either be constants like a number or a string, or variables like x and y. When you see an operator sign, this signifies that it is an expression that needs to be evaluated.

The result of that operation will be the new value. For example, a = 2 + 3 evaluates to a new value of 5.

Another example is b = a * 6 + 10, which evaluates to 40 given the previous example of a = 5.

Identifying Statements in Code

Statements in code are the complete lines that perform an action or task. Statements often involve expressions to provide the necessary input to complete a particular task.

Every statement in code must end with a semicolon, indicating that it is a complete instruction. For example:

if(x > y){

console.log(“X is Greater than Y”);



console.log(“Y is Greater than X”);


The entire block (including the if statement, the console.log()’s, and else statement are all statements).

Relationship between Declarations, Expressions and Statements

Declarations, expressions, and statements are essential to building complete code. Variables must first be declared before expressions can be used.

Expressions are repeatedly used throughout statements to produce new values and perform necessary tasks. For example, let’s take a look at a basic example in JavaScript:

let x = 5; //declaration

let y = 2; //declaration

let z = x + y; //expression

console.log(z); //statement

Here, we have first declared two variables, x and y.

Here, we have first declared two variables, x and y. Then, we use an expression to add them together and assign the new value to the variable z.

Finally, we use the console.log() statement to print the value of z to the console.

Examples of Code Analysis

Now that you have an understanding of expressions and statements’ basic definitions, let’s explore some examples of how they work in code.

Declaration Examples in Code

Variable Declaration: Declaring a variable sets aside space in memory to store a value. let name = “John”;

Function Declaration: Defining a function creates a reusable block of code.

function add(x, y){

return x + y;


Parameters: Parameters are variables used to pass values into a function. function add(x, y){

return x + y;


Expression Examples in Code

String Expression: A string expression is a combination of characters. let greeting = “Hello, World!”;

Arithmetic Expression: An arithmetic expression is used to perform arithmetic operations like addition, subtraction, multiplication, or division.

let sum = 5 + 6;

Function Definition Expression: A function definition expression defines an entire function as an expression. let timesTwo = function(a){

return a * 2;


Logical Expression: Logical expressions determine if a particular statement is true or false.

let greaterThan = 3 > 7;

Function Call: A function call executes or “calls” a particular function. add(2, 5);

Statement Examples in Code

console.log: The console.log is used to output data to the console. console.log(“Hello, World!”);

If-Else Block: An if-else block is an example of a conditional statement, meaning the code executes only if a certain condition is met.

if (x > y) {

console.log(“X is greater than Y”);

} else {

console.log(“Y is greater than X”);


Final Thoughts

Expressions and statements are essential to the foundation of programming. Statements are created by the combination of declarations and expressions.

Together, they make up logical instructions that tell a computer what to do. By understanding the basics of expressions and statements, you are ready to move on to more advanced programming concepts and become a more proficient programmer.

Expression Cheat Sheet: Understanding the Basics of Expressions

Expressions are an essential part of any programming language. They are the building blocks that allow software developers to create instructions for the computer to follow.

An expression is a combination of values, operators, and functions that can be evaluated to produce a new value. In this article, we will discuss the various types of expressions that can be used in programming, from arithmetic expressions to logical expressions and function definition expressions.

Arithmetic Expressions

Arithmetic expressions are the most basic type of expression. They involve mathematical operations and operators such as addition (+), subtraction (-), multiplication (*), and division (/).

Here are some examples:

1. Addition

let a = 4;

let b = 5;

let c = a + b;



let a = 4;

let b = 5;

let c = a – b;

3. Multiplication

let a = 4;

let b = 5;

let c = a * b;



let a = 4;

let b = 5;

let c = a / b;

String Expressions

String expressions use string values, which are a sequence of characters, to concatenate and manipulate strings. The addition operator (+) is used to concatenate strings together.

Here are some examples:

1. String Concatenation

let firstName = “John”;

let lastName = “Doe”;

let fullName = firstName + ” ” + lastName;


String Manipulation

let message = “Hello, World!”;

let count = message.length;

let upperCase = message.toUpperCase();

let lowerCase = message.toLowerCase();

Primary Expressions

Primary expressions involve the most fundamental expressions in programming. They include literal values and variable references.

A literal value is a direct definition of a value, such as a number or a string. A variable reference, on the other hand, refers to a previously declared variable.

Here are some examples:

1. Literal Value

let a = 4;

let b = “John”;

let c = true;


Variable Reference

let firstName = “John”;

let lastName = “Doe”;

let fullName = firstName + ” ” + lastName;

Array and Object Expressions

Arrays and objects are data types used to store collections of values. Array expressions use square brackets [] to surround a list of values, while object expressions use curly braces {} to define a set of key-value pairs.

Here are some examples:

1. Array Expression

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

let colors = [“red”, “green”, “blue”];


Object Expression

let person = {firstName: “John”, lastName: “Doe”, age: 30};

let car = {make: “Toyota”, model: “Camry”, year: “2010”};

Logical Expressions

Logical expressions deal with boolean values (true or false) and logical operators such as AND (&&), OR (||), and NOT (!). Here are some examples:


Boolean Value

let a = true;

let b = false;

2. Logical Operators

let age = 20;

let hasLicense = true;

let isInsured = true;

if (age >= 18 && hasLicense && isInsured) {

console.log(“You can legally drive!”);


Object Creation Expressions

Object creation expressions involve creating objects with a constructor function. Constructor functions are defined using the keyword “class” in ES6 and “function” in earlier versions of JavaScript.

Here are some examples:

1. Object Creation

class Person {

constructor(firstName, lastName, age) {

this.firstName = firstName;

this.lastName = lastName;

this.age = age;



let person = new Person(“John”, “Doe”, 30);


Return Object

function createPerson(firstName, lastName, age) {

let person = {

firstName: firstName,

lastName: lastName,

age: age


return person;


let person = createPerson(“John”, “Doe”, 30);

Object Property Expressions

Object property expressions involve accessing object properties using dot notation, as well as nested properties using dot notation. Here are some examples:


Object Property

let person = {firstName: “John”, lastName: “Doe”, age: 30};

let fullName = person.firstName + ” ” + person.lastName;

2. Nested Property

let car = {make: “Toyota”, model: “Camry”, year: 2010, owner: {firstName: “John”, lastName: “Doe”}};

let ownerFirstName = car.owner.firstName;

let ownerLastName = car.owner.lastName;

Function Definition Expressions

Function definition expressions are used to define a function as a variable. The function is created when the variable is declared, but the code inside the function is not executed until the function is called.

Here are some examples:

1. Function Definition

let add = function(x, y) {

return x + y;



Return Function

function createAdder(num) {

return function(x) {

return num + x;



let addFive = createAdder(5);

let result = addFive(10);


In conclusion, expressions are the basic building blocks of programming languages that allow software developers to create powerful and complex programs for computers to execute. This cheat sheet provides an overview of the various types of expressions in programming, including arithmetic, string, primary, array, object, logical, object creation, object property, and function definition expressions.

Understanding the basics of expressions is essential for any aspiring programmer to write efficient, maintainable, and scalable code. In conclusion, expressions are the fundamental building blocks of programming languages that enable developers to craft sophisticated programs for computers to execute.

This article provided an in-depth analysis of the different types of expressions, including arithmetic, string, primary, array, object, logical, object-creation, object property, and function definition expressions. It is crucial to understand the basics of expressions for writing efficient, scalable, and maintainable code.

Whether you are a novice or experienced programmer, a strong grasp on expressions is an essential skill to have. Remember that these expressions work together like puzzle pieces to build functional and successful code.

Popular Posts