Values and types

Everything a program works with is a value, and every value has a type that decides what you can do with it. You can add two numbers but not two photographs, and you can capitalise a word but not a temperature. Types are how a language remembers which is which.

Values

A value is a piece of data: 42, 3.14, "hello", true. Written directly in code, it is a literal. A type is the kind of value, which determines how it is stored and which operations apply.

The basic types

The string "42" and the integer 42 look alike on screen and behave nothing alike. One is two characters, the other is a quantity. Keeping them apart is the single most useful habit in this lesson.

Null deserves a note. It marks “no value”: a lookup that found nothing, an optional field left blank. It is not zero, and it is not an empty string. Its inventor, Tony Hoare, later called it a billion-dollar mistake because programs forget to check for it, so treat any value that might be null with suspicion.

Languages also differ in how many types they offer. JavaScript has a single number type for both whole and fractional values. Python, Java and C separate integers from floats. C goes further and has no string type at all: text is a run of single characters ending in a zero byte.

Seeing a value’s type

Every language lets you find out a value’s type, but each one goes about it differently, because the type lives in a different place. In Python and JavaScript it travels with the value, so you ask the value. In Java and C it is fixed by the declaration, so the program already knows it.

print(42, type(42).__name__)
print(3.14, type(3.14).__name__)
print("42", type("42").__name__)
print(True, type(True).__name__)
print(None, type(None).__name__)
print(2**100, type(2**100).__name__)

42 int
3.14 float
42 str
True bool
None NoneType
1267650600228229401496703205376 int

console.log(42, typeof 42);
console.log(3.14, typeof 3.14);
console.log("42", typeof "42");
console.log(true, typeof true);
console.log(null, typeof null);
console.log(2 ** 100, typeof (2 ** 100));

42 number
3.14 number
42 string
true boolean
null object
1.2676506002282294e+30 number

import java.math.BigInteger;

public class TypesDemo {
    static void show(Object value) {
        System.out.println(value + " " + value.getClass().getSimpleName());
    }

    public static void main(String[] args) {
        show(42);
        show(3.14);
        show("42");
        show(true);
        show('x');
        show(BigInteger.TWO.pow(100));
    }
}

42 Integer
3.14 Double
42 String
true Boolean
x Character
1267650600228229401496703205376 BigInteger

#include <stdbool.h>
#include <stdio.h>

int main(void) {
    int count = 42;
    double ratio = 3.14;
    char letter = '4';
    bool done = true;

    printf("%d int, %zu bytes\n", count, sizeof count);
    printf("%.2f double, %zu bytes\n", ratio, sizeof ratio);
    printf("%d char, %zu byte\n", letter, sizeof letter);
    printf("%d bool, %zu byte\n", done, sizeof done);
    printf("\"42\" is %zu bytes\n", sizeof "42");
    return 0;
}

42 int, 4 bytes
3.14 double, 8 bytes
52 char, 1 byte
1 bool, 1 byte
"42" is 3 bytes

Mixing types

What happens when you combine different types depends on the language. Here is the same idea, the text "5" combined with the number 3.

print("5" + 3)

console.log("5" + 3);
console.log("5" * 3);

53
15

public class Mix {
    public static void main(String[] args) {
        System.out.println("5" + 3);
        // int n = "5";   // compile error: String cannot be converted to int
    }
}

53

#include <stdio.h>

int main(void) {
    printf("%d\n", '5' + 3);
    return 0;
}

56

Static and dynamic typing

The question “when is the type checked?” splits languages in two.

static:   int count = "three";     -> rejected before anything runs
dynamic:  count = "three"          -> fine; later, count + 1 fails at that moment

Neither is better in general. Static typing catches whole classes of mistakes early and helps tools; dynamic typing is quicker to write and more flexible. Several dynamic languages now support optional type annotations that external tools check, a middle path you will see in the language courses.

Strong and weak typing

This is a separate question: how readily does the language convert between types behind your back?

• Strong typing: few implicit conversions. Python rejects "5" + 3.
• Weak typing: many implicit conversions. JavaScript turns "5" + 3 into "53" and "5" * 3 into 15.

The two axes are independent. Python is dynamic and strong. JavaScript is dynamic and weak. Java is static and strong. C is static, but weaker than Java because it converts freely between many numeric types and pointers.

Converting on purpose

When you want a conversion, ask for it explicitly. That is called casting or conversion. Reading a number from a user always gives you a string first, so you will convert constantly. Each program converts the text "42" to a number and the number 42 to text, then proves it by adding 1 to the number and appending ! to the text.

age = int("42")
text = str(42)
print(age + 1, text + "!")

const age = Number("42");
const text = String(42);
console.log(age + 1, text + "!");

public class Convert {
    public static void main(String[] args) {
        int age = Integer.parseInt("42");
        String text = String.valueOf(42);
        System.out.println((age + 1) + " " + text + "!");
    }
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int age = atoi("42");
    char text[12];
    snprintf(text, sizeof text, "%d", 42);
    printf("%d %s!\n", age + 1, text);
    return 0;
}

All four print:

43 42!

A conversion can fail: "forty" has no sensible numeric answer. What happens next is one of the clearest differences between languages.

The first and third stop the program unless you handle the error, which the lesson on errors covers. The last two hand you a bad value that looks like a normal result, which is harder to notice.

Common pitfalls

• Numbers that are really strings. Input from a keyboard, file or web form arrives as text. Sorting "10" and "9" as text puts "10" first.
• Assuming silent conversion is harmless. "5" + 3 giving "53" is not a bug in JavaScript; it is a bug in your expectation.
• Using null as a number or string. Calling a method on a null value is among the most common runtime failures in every language.
• Confusing strong with static. Python has no declared types and is still strongly typed.

first = "7"
second = "8"
print(int(first) + int(second))
print(first + second)

const first = "7";
const second = "8";
console.log(Number(first) + Number(second));
console.log(first + second);

public class AddTyped {
    public static void main(String[] args) {
        String first = "7";
        String second = "8";
        System.out.println(Integer.parseInt(first) + Integer.parseInt(second));
        System.out.println(first + second);
    }
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    const char *first = "7";
    const char *second = "8";
    printf("%d\n", atoi(first) + atoi(second));
    printf("%s%s\n", first, second);
    return 0;
}

15
78

Summary

• Every value has a type, and "42" (text) differs from 42 (number).
• Static typing checks before running and dynamic typing checks while running; strong typing refuses implicit conversions and weak typing performs them.
• Convert explicitly, and expect conversions to fail sometimes, in a different way in each language.

Next: Variables and assignment.