Chapter 2 - Values

Values are one of the fundamental concepts in programming. A value is any data that can be stored, manipulated, or passed around in a program. This article explores what values are, the types of values available in programming, and how they can be handled in various programming languages. We'll provide examples in Python, PHP, C++, Go, and Zig to help understand this concept across different languages.

What Is a Value?

In programming, a value is a piece of data that can be assigned to variables, used in expressions, or passed as arguments to functions. Values can represent numbers, text, boolean states, or even more complex structures like arrays and objects.

For example:

Integers: 42
Strings: "Hello, World!"
Booleans: True (or true depending on the language)
Floating-point numbers: 3.14

Types of Values

Programming languages typically categorize values into different types. Common types include:

Primitive Types

These are basic, indivisible values:

Integer: Whole numbers like 1, 100, or -42
Float/Double: Decimal numbers like 3.14 or -0.001
Boolean: True or False (often represented as 1 or 0 internally)
Character: Single characters like 'a' or '$'
String: Sequences of characters like "Hello"

Complex Types

These include data structures and user-defined types:

Arrays/Lists: Ordered collections of values.
Objects: Instances of classes containing both data and methods.
Tuples: Immutable sequences of values.
Dictionaries/Maps: Key-value pairs.

Special Values

Null/Nil: Represents the absence of a value.
Undefined: Indicates a variable has been declared but not initialized (in some languages).

Handling Values

Values are handled in programming through variables, constants, expressions, and operations. Let’s break down how this works:

Assigning Values to Variables

Variables store values so they can be used later.

Python:

x = 42
name = "Alice"
is_valid = True

PHP:

$x = 42;
$name = "Alice";
$is_valid = true;

C++:

int x = 42;
std::string name = "Alice";
bool isValid = true;

Go:

package main

import "fmt"

func main() {
    x := 42
    name := "Alice"
    isValid := true
    fmt.Println(x, name, isValid)
}

Zig:

const x: i32 = 42;
const name: []const u8 = "Alice";
const isValid: bool = true;

Performing Operations on Values

You can manipulate values using operators and functions.

Python:

sum = 10 + 20
message = "Hello, " + "World!"
is_greater = 5 > 3

PHP:

$sum = 10 + 20;
$message = "Hello, " . "World!";
$is_greater = 5 > 3;

C++:

int sum = 10 + 20;
std::string message = "Hello, " + "World!";
bool isGreater = 5 > 3;

Go:

package main

import "fmt"

func main() {
    sum := 10 + 20
    message := "Hello, " + "World!"
    isGreater := 5 > 3
    fmt.Println(sum, message, isGreater)
}

Zig:

const sum: i32 = 10 + 20;
const message: []const u8 = "Hello, " ++ "World!";
const isGreater: bool = 5 > 3;

Passing Values to Functions

Functions often take values as inputs and return values as outputs.

Python:

def add(a, b):
    return a + b

result = add(3, 4)  # 7

PHP:

function add($a, $b) {
    return $a + $b;
}

$result = add(3, 4);  // 7

C++:

int add(int a, int b) {
    return a + b;
}

int result = add(3, 4);  // 7

Go:

package main

import "fmt"

func add(a int, b int) int {
    return a + b
}

func main() {
    result := add(3, 4)
    fmt.Println(result)  // 7
}

Zig:

fn add(a: i32, b: i32) i32 {
    return a + b;
}

const result = add(3, 4); // 7

Comparing and Checking Values

Values can be compared using comparison operators.

Python:

x = 10
y = 20
print(x == y)  # False
print(x < y)   # True

PHP:

$x = 10;
$y = 20;
echo $x == $y;  // False
echo $x < $y;   // True

C++:

int x = 10;
int y = 20;
std::cout << (x == y) << std::endl;  // False
std::cout << (x < y) << std::endl;   // True

Go:

package main

import "fmt"

func main() {
    x := 10
    y := 20
    fmt.Println(x == y)  // False
    fmt.Println(x < y)   // True
}

Zig:

const x: i32 = 10;
const y: i32 = 20;
std.debug.print("{any}\n", .{x == y}); // False
std.debug.print("{any}\n", .{x < y});  // True

Handling Null or Undefined Values

Python:

value = None
if value is None:
    print("No value assigned")

PHP:

$value = null;
if (is_null($value)) {
    echo "No value assigned";
}

C++:

int* value = nullptr;
if (value == nullptr) {
    std::cout << "No value assigned" << std::endl;
}

Go:

package main

import "fmt"

func main() {
    var value *int = nil
    if value == nil {
        fmt.Println("No value assigned")
    }
}

Zig:

const value: ?i32 = null;
if (value == null) {
    std.debug.print("No value assigned\n", .{});
}

Immutable vs. Mutable Values

Some values are immutable, meaning they cannot be changed after being created, while others are mutable.

Immutable: Strings in Python, integers in most languages.
Mutable: Lists or dictionaries in Python, arrays in PHP.

Best Practices for Handling Values

Use Clear Variable Names: Make the purpose of the value obvious.
Validate Input Values: Ensure values are within acceptable ranges.
Use Constants Where Appropriate: Prevent accidental modification.
Handle Null or Undefined Values Gracefully: Avoid runtime errors.
Be Aware of Type Conversions: Implicit type conversions can lead to bugs.

Conclusion

Values are the core building blocks of any program. Understanding how to use, manipulate, and manage them effectively is key to becoming a proficient programmer. By exploring values in Python, PHP, C++, Go, and Zig, you can appreciate both the similarities and differences across languages, equipping you to work effectively in a variety of programming environments.

Last modified: 26 January 2025