# Value
In programming, a value is a piece of data, such as a number, text string, or object. It is the fundamental information that is stored in variables, passed to functions, and manipulated by expressions. Every value has a data type that defines its nature and the operations that can be performed on it.
**Pronunciation:** /ˈvæl.juː/
**Difficulty:** Beginner
**Synonyms:** Data, Datum, Information, Content, Literal
**Categories:** Programming Fundamentals, Data Structures, Computer Science
**Tags:** Data, Variable, Programming, Data Type, Primitive, Object
Canonical: https://scaleengineer.com/glossaries/value
---
## Definitions

- **Value in Programming:** In programming, a **value** is a fundamental piece of information or data. It is the actual content that a variable holds or an expression evaluates to. **Values** can be of various types, which determine how they can be used and manipulated.

**Key Concepts:**

*   **Literals:** A literal is a notation for representing a fixed **value** in source code. For example, `42` is an integer literal, `"hello"` is a string literal, and `true` is a boolean literal.
*   **Variables:** A variable is a named container that stores a **value**. The **value** of a variable can change during program execution. For example, in `let age = 30;`, `age` is the variable and `30` is its **value**.
*   **Expressions:** An expression is a combination of **values**, variables, and operators that computes to a new **value**. For instance, `5 + 10` is an expression that evaluates to the **value** `15`.

**Types of Values:**

*   **Primitive Values:** These are the most basic data types, often immutable. Examples include numbers (`10`, `3.14`), strings (`"world"`), booleans (`true`, `false`), `null`, and `undefined`.
*   **Composite/Object Values:** These are more complex data structures that can hold collections of other **values**. Examples include arrays (`[1, 2, 3]`), objects (`{ key: "value" }`), and functions.

**Example (JavaScript):**
```javascript
// 'score' is a variable holding the primitive value 100
let score = 100;

// 'message' holds the primitive string value "Game Over"
let message = "Game Over";

// 'player' holds a composite/object value
let player = { name: "Alex", score: score };

// The expression 'score > 90' evaluates to the boolean value 'true'
let isWinner = score > 90;
```
- **Value vs. Reference:** In many programming languages, it's crucial to understand the distinction between passing a **value** by value and passing it by reference. This distinction primarily applies to how **values** are assigned to variables and passed to functions.

**Pass by Value:**
When a primitive type (like a number or string) is assigned or passed, a copy of the actual **value** is created. Changes to the copy do not affect the original.
```javascript
let a = 10;
let b = a; // b gets a copy of the value of a
b = 20;    // changing b does not affect a
console.log(a); // Output: 10
console.log(b); // Output: 20
```

**Pass by Reference:**
When a composite type (like an object or array) is assigned or passed, a reference (or a pointer to the memory location) is copied, not the object itself. Both variables point to the same underlying object. Modifying the object through one variable will be visible through the other.
```javascript
let obj1 = { name: "Alice" };
let obj2 = obj1; // obj2 gets a copy of the reference to the object
obj2.name = "Bob"; // changing the object via obj2
console.log(obj1.name); // Output: "Bob"
```

## Etymology

The term 'value' originates from the Old French 'value', the past participle of 'valoir' meaning 'to be worth', which in turn comes from the Latin 'valere' meaning 'be strong, be well, be of value'. Its application in computing is a direct extension of its mathematical and general meaning of a quantity or quality.

## First used

1940s

## Historical context

The concept of a **value** is as old as computing itself, evolving alongside programming languages.

In the earliest days of computing (1940s-1950s), with languages like Fortran, a **value** was directly tied to a physical memory location. A variable was a name for that location, and the **value** was the sequence of bits stored there.

The 1960s and 1970s saw the rise of strongly-typed languages like ALGOL and Pascal. This introduced the idea that a **value** has an inherent type (e.g., integer, character). This was a major step forward, as the type defined what operations were permissible, preventing many common programming errors.

With the advent of Object-Oriented Programming (OOP) in the 1980s with languages like Smalltalk and C++, the concept of a **value** expanded significantly. A **value** could now be a complex object, bundling both data (attributes) and behavior (methods) together.

In modern languages like Python and JavaScript, the distinction between value types and reference types is a key concept. For primitive types (like numbers), a variable holds the actual **value**. For objects, the variable holds a reference (an address) to the memory location where the object's **data** is stored. This fundamental difference affects how data is assigned, copied, and passed to functions.

## Q&A

- **What is the difference between a value and a variable?:** A variable is like a labeled box that can hold something. A **value** is the 'something' that you put inside the box. For example, in `let name = "Alice";`, `name` is the variable (the box), and `"Alice"` is the string **value** (the content inside the box). The variable is a named reference to a memory location, while the **value** is the actual data stored in that location.
- **Explain the concept of 'pass by value' versus 'pass by reference'.:** 'Pass by value' means that when you pass data to a function, a copy of that data is made. Any changes inside the function happen to the copy, not the original. This typically applies to primitive types like numbers and booleans. 'Pass by reference' means that instead of a copy, a pointer (or reference) to the original data's memory location is passed. Any changes made inside the function affect the original data. This usually applies to complex types like objects and arrays.
- **What is a literal value?:** A literal **value** (or simply a 'literal') is a **value** that is written directly in the source code. It represents a fixed **datum**. For example, `123` is a number literal, `"hello world"` is a string literal, and `false` is a boolean literal. They are not stored in a variable first; they are the raw **data** itself.

## Usage examples

- In the statement `x = 5;`, the variable `x` is assigned the integer **value** of 5.
- The function returns a boolean **value** indicating whether the operation was successful.
- When you pass an object to a function in JavaScript, you are passing its reference, not a copy of its actual **value**.
- The database field can store a null **value** to represent missing **information**.

## Related terms

- Variable
- Data Type
- Reference
- Pointer
- Literal
- Expression

## Popular related terms

- Variable
- Data Type
- Object
- Primitive
- Function