Values, variables and types

Before you start, set up a new project folder named day02 exactly as you set up day01 in 1.2: open the folder in VS Code, run npm init -y and npm install --save-dev typescript in its terminal, and type the same tsconfig.json. Every program today goes in that folder.

On Day 1, every number you used was typed straight into an expression, like 30 - 12. That works once. But imagine a program that uses a ticket price in five places: if the price changes, you must find and edit all five, and missing one gives a wrong answer. Programs need a way to work a value out once, remember it, and refer to it by name.

A variable is a name that holds a value. You create one with a variable declaration. The simplest kind starts with the word let:

let name = expression;

The program runs a declaration in two steps. First it works out the expression on the right. Then it stores that value under the name on the left. From then on, wherever you write the name, the program uses the value stored there. Storing a value in a variable is called assigning it. The = sign does not mean “is equal to” as it does in math; read let price = 4; as “let price be 4” or “price gets 4”.

Think of a variable as a labeled box: the name is the label, and the box holds one value at a time.

let ticketPrice = 12;
let ticketsSold = 35;
let total = ticketPrice * ticketsSold;
console.log("Tickets sold:", ticketsSold);
console.log("Total:", total);

Tickets sold: 35
Total: 420

Now vary one thing: assign a new value to a variable that already exists. You write the name, =, and the new value, without let, because the variable is already made. The old value is thrown away and the new one takes its place. This lets you update a variable, even using its own old value on the right side.

let score = 10;
console.log("Start:", score);
score = score + 5;
console.log("After bonus:", score);
score = 0;
console.log("After reset:", score);

Start: 10
After bonus: 15
After reset: 0

Line 3, score = score + 5;, would be nonsense as a math equation, but as an assignment it makes sense: the right side is worked out first, using the current value 10, and only then is the result, 15, stored back in score. The let appears only once, on line 1, where the variable is made.

console.log("Total:", total);
let total = 5 * 3;

use-before-declare.ts:1:23 - error TS2448: Block-scoped variable 'total' used before its declaration.
use-before-declare.ts:1:23 - error TS2454: Variable 'total' is used before being assigned.

let apples = 6;
apples = apples + 4;
let pears = apples - 3;
apples = 2;
console.log(apples, pears);

2 7

let price = 4;
console.log("Old price:", price);
let price = 5;
console.log("New price:", price);

price-change.ts:1:5 - error TS2451: Cannot redeclare block-scoped variable 'price'.
price-change.ts:3:5 - error TS2451: Cannot redeclare block-scoped variable 'price'.

let price = 4;
console.log("Old price:", price);
price = 5;
console.log("New price:", price);

Old price: 4
New price: 5

Look back at ticket-total.ts in 2.1. None of its three variables ever changed after it was made. Most values in a program are like that: a price, a name, a total worked out once. If such a value changed by accident, the program would quietly give wrong answers.

TypeScript has a second kind of declaration for values that must stay the same. It starts with const (short for “constant”) instead of let:

const name = expression;

A variable declared with const is a constant: it gets its value once, when it is made, and can never be assigned a new one. A variable declared with let can be assigned again as often as you like. You met const once already, in Day 1’s preview const muffinsLeft: number = 12; (1.8).

const ticketPrice = 12;
const ticketsSold = 35;
const total = ticketPrice * ticketsSold;
let seatsLeft = 40;
seatsLeft = seatsLeft - ticketsSold;
console.log("Total:", total);
console.log("Seats left:", seatsLeft);

Total: 420
Seats left: 5

Now vary it: try to assign a new value to a constant.

const busSeats = 40;
console.log("Seats:", busSeats);
busSeats = 45;

const-reassign.ts:3:1 - error TS2588: Cannot assign to 'busSeats' because it is a constant.

The checker points at line 3, column 1, where the assignment starts, and the message says exactly why: busSeats was made with const. Line 2 is fine; reading a constant is always allowed. Only assigning to it is not. If the number of seats really does change, declare it with let; if it should not change, delete line 3. Fix or delete the file before you go on.

Why is const the default choice? Because it is a promise the type checker enforces. A reader who sees const knows the value is the same on every line after it, without searching the program for changes. And if you assign to it by mistake, you find out from npx tsc before the program ever runs. Good practice is to write const first and change it to let only when the value really needs to change. (Older JavaScript code uses a third keyword, var, which you may see online. This course never uses it.)

const lunchPrice = 6;
let lunchesSold = 0;
lunchesSold = lunchesSold + 3;
const total = lunchPrice * lunchesSold;
lunchPrice = 7;

You choose every variable name, so two questions follow: which names does TypeScript accept, and which names make a program easy to read?

A name you choose is called an identifier. The rules are short:

1. An identifier may contain letters, digits, the underscore _, and the dollar sign $, and nothing else: no spaces, hyphens, or other symbols.
2. It cannot start with a digit.
3. Capital and small letters count as different (names are case-sensitive, as Day 1 showed), so score and Score are two different names.
4. It cannot be a reserved word, one of the keywords the language keeps for its own grammar, such as let, const, class, true, false, and null.

Why these rules? The type checker has to tell names apart from everything else on a line. A name starting with a digit would look like a number, a space would make one name look like two, and a hyphen looks like a minus sign.

On top of the rules there is a convention, a habit every TypeScript programmer follows even though the checker does not enforce it. Variable names use camelCase: the first word all lowercase, and every later word starting with a capital letter, with no spaces or underscores, like ticketPrice or maxSpeedKmh. The capitals in the middle stick up like the humps of a camel. Choose names that say what the value means: ticketsSold tells a reader far more than t or x.

const playerName = "Ana";
const player2Score = 18;
const maxSpeedKmh = 120;
console.log(playerName, player2Score, maxSpeedKmh);

Ana 18 120

Now vary the names so they break the rules. Each of these is a syntax error, so npx tsc reports it before anything runs:

let total cost = 5;

name-with-space.ts:1:11 - error TS1005: ',' expected.

let 2ndPlace = "Lee";

name-starts-with-digit.ts:1:1 - error TS1440: Variable declaration not allowed at this location.
name-starts-with-digit.ts:1:7 - error TS1005: ';' expected.
name-starts-with-digit.ts:1:7 - error TS1351: An identifier or keyword cannot immediately follow a numeric literal.

const class = "7B";

name-is-keyword.ts:1:7 - error TS1389: 'class' is not allowed as a variable declaration name.
name-is-keyword.ts:1:13 - error TS1005: '{' expected.

In the first, the checker reads total as the whole name and then finds a second word, cost, where it expected the declaration to go on (column 11 is where cost starts). In the second, it reads 2 as the start of a number and then finds letters glued to it; a numeric literal is a number typed directly into the code, and no number can contain letters. In the third, class is a reserved word, and the first message says so plainly. As on Day 1, read the first message of each group; the others follow from it. The fixes are totalCost, secondPlace, and a name like className. If you typed these files, delete them now.

let score = 10;
Score = score + 5;
console.log(score);

wrong-capitals.ts:2:1 - error TS2552: Cannot find name 'Score'. Did you mean 'score'?

On Day 1 you learned that every value has a type, the kind of value it is, and you met two: number and string (1.7). The type decides what you can do with a value: you can multiply numbers, but multiplying two pieces of text makes no sense. Today you meet three everyday types, and in 2.7 two more.

• number is the type of every number: whole numbers like 42, 0, and -7, and decimals like 3.5 and 0.45. Many languages have separate types for whole numbers and decimals; JavaScript has just one. That is why Day 1’s 8 / 2 showed 4 and 7 / 2 showed 3.5: both are simply numbers.
• string is the type of text in quotes, like "Hatchet".
• boolean is the type of a value that is either true or false, and nothing else. Those two words are written in small letters and without quotes. A boolean answers a yes-or-no question: is the shop open? Is the book a hardcover? On Day 4 you will make booleans by comparing values; today you store and show them.

To find out a value’s type while the program runs, put the keyword typeof in front of it. typeof gives back the type’s name as a string: typeof 42 is "number". This is JavaScript speaking: typeof runs inside node and reports what the value is at that moment.

const pages = 320;
const weightKg = 0.45;
const title = "Hatchet";
const isHardcover = false;
console.log(pages, typeof pages);
console.log(weightKg, typeof weightKg);
console.log(title, typeof title);
console.log(isHardcover, typeof isHardcover);

320 number
0.45 number
Hatchet string
false boolean

Now vary the quotes. console.log shows a string without its quotes, so a number and a string of digits look the same in the terminal. typeof tells them apart:

console.log(42, typeof 42);
console.log("42", typeof "42");
console.log(true, typeof true);
console.log("true", typeof "true");
console.log(typeof (6 * 7));

42 number
42 string
true boolean
true string
number

Lines 1 and 2 both show 42, and lines 3 and 4 both show true, but the types differ: the quotes make "42" and "true" strings, pieces of text that happen to contain digits or a word. The last line shows that typeof works on an expression too: 6 * 7 is worked out to 42, a number. The parentheses matter there: without them, typeof would apply only to the 6.

const isMember = True;
console.log("Member:", isMember);

true-capital.ts:1:18 - error TS2304: Cannot find name 'True'.

typeof tells you a type while the program runs. But the type checker works before anything runs, so it needs to know each variable’s type from the code alone. There are two ways it finds out.

The first is that you tell it. A type annotation is a colon and a type name written after a variable’s name: let visitors: number = 0; reads “visitors is a variable of type number, starting at 0.” You saw one on Day 1 in const muffinsLeft: number = 12;.

let name: type = expression;

The type names in annotations are the ones typeof reports: number, string, boolean. An annotation is TypeScript only; when Node runs the file, it strips the annotation away, as Day 1 explained.

let visitors: number = 0;
const city: string = "Lima";
const isOpen: boolean = true;
visitors = visitors + 25;
console.log(city, isOpen, visitors);

Lima true 25

Now vary it: take every annotation away.

let visitors = 0;
const city = "Lima";
const isOpen = true;
visitors = visitors + 25;
console.log(city, isOpen, visitors);

Lima true 25

The output is the same, and npx tsc still reports no errors for it. The checker did not need the annotations, because it can see the starting values: 0 is a number, so visitors must be a number. Working out a type from the code without being told is called type inference. In VS Code, hold the mouse pointer over visitors and a small box shows let visitors: number: the type the checker inferred. (Over a const, the box shows the value itself, such as const city: "Lima", because a constant can never hold anything else; Day 9 explains that kind of type.)

So when should you write an annotation? When the checker cannot see a starting value to infer from (2.7 shows that case), or when you want to state your intention so the checker can hold you to it. When a variable gets an obvious starting value, most programmers let inference do the work, and this course does the same from here on.

const isOpen: boolean = "true";
console.log("Open:", isOpen);

annotation-mismatch.ts:1:7 - error TS2322: Type 'string' is not assignable to type 'boolean'.

let lives = 3;
const nickname = "Ace";
let isPaused = false;
let speed: number = 2.5;
console.log(lives, nickname, isPaused, speed);

In 2.1 you assigned a new number to score. Could you assign a string to it instead? In plain JavaScript, yes: a JavaScript variable holds whatever you put in it, and a number can be replaced by text without complaint. That freedom causes bugs, because later lines still expect the number. TypeScript closes that door.

In TypeScript, a variable’s type is fixed when it is declared, by its annotation or by inference, and it never changes. Every later assignment must give a value of that type. This is called static typing: “static” means fixed, settled before the program runs. The type checker reads every assignment and rejects any that does not fit.

let count: number = 0;
count = "five";
console.log(count);

count-five.ts:2:1 - error TS2322: Type 'string' is not assignable to type 'number'.

Now vary it: leave out the annotation, and add a line that stores a different number.

let count = 0;
count = 5;
count = "five";
console.log(count);

count-five-inferred.ts:3:1 - error TS2322: Type 'string' is not assignable to type 'number'.

The same message, now for line 3. The checker inferred number from the starting value 0, and an inferred type is just as fixed as an annotated one. Line 2 is accepted: 5 is a different value, but the same type. Only line 3 breaks the rule.

If you typed these two files, fix or delete them now. The fix depends on what you meant: if the count is a number, store 5; if you need the word, make a separate const countText = "five";.

let temperature = 21;
temperature = 22.5;
temperature = temperature - 4;
temperature = "cold";
console.log(temperature);

thermostat.ts:4:1 - error TS2322: Type 'string' is not assignable to type 'number'.

Some values are not known yet. A player with no middle name has none to store; a game that has not been scheduled has no date. JavaScript has two values that mean “nothing here,” and TypeScript gives each one a type.

• null means “deliberately empty”: the program knows there is no value. It is written in small letters, without quotes.
• undefined means “no value has been given yet.” JavaScript gives a variable this value when nothing has been assigned to it.

Each is the only value of its own type: the value null has the type null, and the value undefined has the type undefined.

const middleName = null;
const nextGame = undefined;
console.log(middleName, nextGame);
console.log(typeof middleName, typeof nextGame);

null undefined
object undefined

Now vary it: declare a variable with an annotation but no starting value. That is allowed with let, and it is the case 2.5 promised, where an annotation is needed because there is no value to infer from. Until you assign something, the variable holds undefined, and strict mode will not let you read it:

let finalScore: number;
console.log("Final score:", finalScore);

unassigned.ts:2:29 - error TS2454: Variable 'finalScore' is used before being assigned.

The checker points at line 2, column 29, where finalScore is read. Nothing has been stored in it, so showing it would only show undefined, which is almost certainly a bug. Assign a value first and the checker is satisfied:

let finalScore: number;
finalScore = 88;
console.log("Final score:", finalScore);

Final score: 88

Strict mode, the "strict": true setting from Day 1, also keeps null and undefined out of other types. A number variable must hold a number, and “nothing” is not a number:

let booksOut: number = null;
console.log("Books out:", booksOut);

null-count.ts:1:5 - error TS2322: Type 'null' is not assignable to type 'number'.

This rule protects you: whenever a variable’s type is number, you can be sure it holds an actual number, so arithmetic on it will not go wrong. A variable that is sometimes a number and sometimes null needs a type that says so; that is a preview of Day 9, which teaches how to write one. Fix or delete unassigned.ts and null-count.ts before you go on.

A movie is 135 minutes long. How many hours and minutes is that? 135 / 60 gives 2.25, which is true but not what you want. You want “2 hours and 15 minutes”: a whole number of hours, and the minutes left over. Day 1 gave you +, -, *, and /. Today adds two more operators and two rounding tools.

• The remainder operator % gives what is left over after dividing as many whole times as possible. 135 % 60 is 15, because two 60s make 120, and 135 - 120 is 15. The % sign here has nothing to do with percentages.
• The exponent operator ** raises a number to a power. 2 ** 10 means 2 multiplied by itself 10 times, which is 1024.
• Math.floor(x) rounds x down to a whole number. Math.floor(2.25) is 2. (“Floor” means the whole number at or below, like the floor below you.)
• Math.round(x) rounds x to the nearest whole number. Math.round(2.25) is 2, and Math.round(2.75) is 3.

Math is built in, like console, and holds many math tools. Read Math.floor as Day 1 taught you to read console.log: “Math’s floor function.” You call it with the number in parentheses, and it gives back the rounded number, which you can store, show, or use in another expression.

const totalMinutes = 135;
const hours = Math.floor(totalMinutes / 60);
const minutes = totalMinutes % 60;
console.log(totalMinutes, "minutes is", hours, "hours and", minutes, "minutes");

135 minutes is 2 hours and 15 minutes

Now vary the numbers, to see what the rules really depend on:

console.log(8 % 2, 7 % 2);
console.log(-7 % 2);
console.log(2 ** 10, 9 ** 0.5);
console.log(Math.floor(3.99), Math.floor(-3.5));
console.log(Math.round(2.4), Math.round(2.5), Math.round(-2.5));

0 1
-1
1024 3
3 -4
2 3 -2

• % 2 gives 0 for every even number and 1 for every odd one, so the remainder tells you whether a number is even.
• -7 % 2 is -1: the remainder takes the sign of the number on the left.
• 9 ** 0.5 raises 9 to the power one half, which is the square root of 9: 3.
• Math.floor(3.99) is 3, not 4: it always rounds down, however close the next number is. And Math.floor(-3.5) is -4, because “down” means toward the lower number, and for negatives that is -4, not -3.
• Math.round(2.4) is 2, and a number exactly halfway rounds up to the larger number: Math.round(2.5) is 3, and Math.round(-2.5) is -2 (because -2 is larger than -3).

const pizzaSlices = 12;
const people = 0;
console.log("Each person gets", pizzaSlices / people);
console.log("Left over:", pizzaSlices % people);

Each person gets Infinity
Left over: NaN

console.log(17 % 5);
console.log(Math.floor(17 / 5));
console.log(17 / 5);
console.log(2 ** 5);
console.log(Math.round(17 / 5));

2
3
3.4
32
3

With six arithmetic operators, an expression like 10 + 3 ** 2 * 2 - 8 % 3 needs a clear rule for what happens first. Day 1 gave part of it: multiplication and division before addition and subtraction, parentheses first. Here is the full rule for today’s operators.

Operator precedence is the order in which the program applies operators. From first to last:

Operators on the same row are applied left to right, in the order they appear, with one exception: a chain of ** is worked out from the right. A function call like Math.floor(...) works out everything inside its parentheses first, just like a pair of parentheses.

console.log(10 + 3 ** 2 * 2 - 8 % 3);
console.log(100 / 10 / 2);
console.log(2 ** 3 ** 2);
console.log((2 ** 3) ** 2);

26
5
512
64

Now vary one thing in a real calculation: the parentheses. To average two test scores, you add them and divide by 2.

const scoreA = 88;
const scoreB = 94;
console.log(scoreA + scoreB / 2);
console.log((scoreA + scoreB) / 2);

135
91

Without parentheses, / happens before +, so line 3 divides only 94 by 2 (47) and adds 88, giving 135, which is not an average. With parentheses, the addition happens first, and the average is 182 / 2 = 91. Neither the checker nor Node can spot the mistake on line 3: both lines are correct code that works out a number. Only knowing what the answer should be reveals it.

console.log(-3 ** 2);

negative-power.ts:1:13 - error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.

console.log((-3) ** 2);
console.log(-(3 ** 2));

9
-9

console.log(7 + 8 % 3 * 2);
console.log((7 + 8) % 4 * 2);
console.log(2 * 3 ** 2);

11
6
18

Numbers do not always arrive as numbers. On Day 20 your programs will read what people type into a web form, and whatever they type arrives as text: the string "15", not the number 15. Files hold text too. The digits look the same, but the type is different, and the type decides what you can do:

const ageText = "15";
console.log(ageText * 2);

text-times-number.ts:2:13 - error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

An operand is a value an operator works on, and the left-hand side is the operand to the left of the operator, here ageText. The message lists the types that * accepts there; of those, the only one you know is number (the others are for later or for other situations). So it says: * needs a number on its left, and ageText is a string. The type checker is protecting you: arithmetic on text is almost always a mistake. If you typed this file, fix it with Number() (shown next) or delete it before your next check.

The fix is type conversion: making a new value of a different type from an existing one. Two built-in functions do it:

• Number(value) makes a number. Given a string of digits, such as "42" or "1.75", it gives that number.
• String(value) makes a string: the text you would see if you showed the value.

const fromText = Number("42");
const fromDecimal = Number("1.75");
const asText = String(42);
console.log(fromText, typeof fromText);
console.log(fromDecimal, typeof fromDecimal);
console.log(asText, typeof asText);
console.log(String(true), typeof String(true));

42 number
1.75 number
42 string
true string

Line 3’s asText shows as 42, the same as line 1’s number, because console.log shows strings without quotes. Only typeof reveals that it is text. Converting makes a new value; it does not change the original. After Number(priceText), priceText is still a string.

const priceText = "12";
const quantityText = "3";
const price = Number(priceText);
const quantity = Number(quantityText);
console.log("Total:", price * quantity);
console.log(typeof priceText, typeof price);

Total: 36
string number

Now vary the text: give Number something that is not a number.

const seats = Number("forty");
console.log(seats, typeof seats);
console.log("Seats for two buses:", seats * 2);

NaN number
Seats for two buses: NaN

Number("forty") cannot read a word as a number, so it gives back NaN, short for “Not a Number.” NaN is a special value that means “the result of a calculation that failed.” Its name is confusing, because its type is number, as line 2 shows. And any arithmetic involving NaN gives NaN again, so one bad conversion spreads through every result that uses it.

Notice who reported a problem: nobody. The type checker accepted the program, because Number(...) always gives a number, and seats * 2 is a number times a number. Node ran it without a runtime error, because producing NaN is not an error in JavaScript. The only sign is NaN in the output. (Day 4 shows how a program can check for it.)

Number has a few more rules worth knowing:

console.log(Number(" 12 "));
console.log(Number(""));
console.log(Number("12px"));
console.log(Number("3,5"));

12
0
NaN
NaN

Spaces at either end are ignored (" 12 " is 12), and empty text gives 0, not NaN. But anything extra inside makes the whole conversion fail: "12px" is NaN, and so is "3,5", because a number uses a dot, not a comma, for its decimal point.

console.log(Number("8") * 2);
console.log(String(5 + 5), typeof String(5 + 5));
console.log(Number("8 apples"));
console.log(Number(" 2.5 "));

16
10 string
NaN
2.5

const ageText = "15";
const yearsLeft = 18 - ageText;
console.log("Years until 18:", yearsLeft);

years-left.ts:2:24 - error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

const ageText = "15";
const yearsLeft = 18 - Number(ageText);
console.log("Years until 18:", yearsLeft);

Years until 18: 3

Run this program, and expect a surprise:

console.log(0.1 + 0.2);
console.log(1.1 * 3);
console.log(10 / 3);
console.log(1 + 2);

0.30000000000000004
3.3000000000000003
3.3333333333333335
3

0.1 + 0.2 is not exactly 0.3. Nothing is broken; every programming language that uses standard floating-point numbers (explained below) gets the same result. The reason is how a computer stores numbers.

A computer stores numbers in binary, using only the digits 0 and 1. Whole numbers of everyday size convert to binary exactly, so 1 + 2 is exactly 3. Many fractions do not. Think of 1/3 in ordinary decimal: 0.3333…, with threes forever. You can write 0.33 or 0.3333333, but never exactly one third. In binary, 0.1 is like that: it repeats forever, so the computer stores the closest value it can fit. That stored value is a tiny bit off, the tiny errors add up, and sometimes they show in the last digit. A number stored this way is called a floating-point number (or float), and the tiny error is called floating-point imprecision. Every JavaScript number is stored as a float.

The error is tiny (about 0.00000000000000004 here), so it almost never matters for a calculation. It matters when you show the result: nobody wants to read a price of 3.3000000000000003. The fix is to round when you show a value. Math.round rounds to a whole number, so to keep two decimal places, multiply by 100, round, and divide by 100 again: Math.round(x * 100) / 100. For one decimal place, use 10 instead of 100.

const bill = 10;
const friends = 3;
const share = bill / friends;
console.log("Exact:", share);
console.log("Rounded:", Math.round(share * 100) / 100);

Exact: 3.3333333333333335
Rounded: 3.33

const share = Math.round((10 / 3) * 100) / 100;
console.log("Share:", share);
console.log("Three shares:", share * 3);

Share: 3.33
Three shares: 9.99

console.log(Math.round((7 / 3) * 100) / 100);
console.log(1.1 * 3);
console.log(Math.round(1.1 * 3 * 10) / 10);

2.33
3.3000000000000003
3.3

Jordan is planning a 523-kilometre road trip at an average 90 km/h. The car uses 6.8 litres of fuel per 100 km, and fuel costs 1.89 per litre. The distance arrives as text, as if typed into a form, so it has to be converted. The comment on line 1 is from Day 1; the blank lines just split the program into steps.

First check. Jordan’s first attempt annotates the distance as a number but forgets to convert the text:

// Trip details: the distance arrives as text, as if typed into a form
const distanceText = "523";
const speedKmh = 90;
const litresPer100Km = 6.8;
const pricePerLitre = 1.89;

const distanceKm: number = distanceText;
console.log("Distance:", distanceKm, "km");

road-trip-attempt.ts:7:7 - error TS2322: Type 'string' is not assignable to type 'number'.

The annotation : number on line 7 states Jordan’s intention, so the checker can hold the line to it: distanceText is a string. Nothing has run yet. The fix is to convert with Number (2.10).

Check and run. Jordan fixes line 7 with the conversion. If you typed along, fix road-trip-attempt.ts the same way, or delete it and type the fixed program as road-trip.ts, so that no broken file is left. Now npx tsc reports no errors for the trip program, and node road-trip.ts shows:

// Trip details: the distance arrives as text, as if typed into a form
const distanceText = "523";
const speedKmh = 90;
const litresPer100Km = 6.8;
const pricePerLitre = 1.89;

const distanceKm: number = Number(distanceText);

const totalMinutes = Math.floor((distanceKm * 60) / speedKmh);
const hours = Math.floor(totalMinutes / 60);
const minutes = totalMinutes % 60;

const fuelLitres = (distanceKm / 100) * litresPer100Km;
const fuelCost = fuelLitres * pricePerLitre;

console.log("Distance:", distanceKm, "km");
console.log("Driving time:", hours, "hours", minutes, "minutes");
console.log("Fuel needed:", Math.round(fuelLitres * 10) / 10, "litres");
console.log("Fuel cost:", Math.round(fuelCost * 100) / 100);

Distance: 523 km
Driving time: 5 hours 48 minutes
Fuel needed: 35.6 litres
Fuel cost: 67.22

Follow the values and types, in the order the lines run:

Every name is a const (2.2), because nothing changes after it is worked out. The last two lines round only when showing (2.11): 35.564 shows as 35.6 and 67.21596 as 67.22. Notice line 9: the parentheses make the program multiply before dividing, so the minutes are worked out from the full distance and then rounded down once. Writing Math.floor(distanceKm / speedKmh) * 60 instead would round down to 5 whole hours before converting to minutes and lose the 48 extra minutes.

Every message from today in one place, to look up when you meet one again. All of them come from npx tsc, before anything runs, except the last row.

• A variable holds a value under a name. const makes one that can never be assigned again, and let makes one that can; use const unless the value must change. Names follow the identifier rules and, by convention, are descriptive camelCase.
• Every value has a type: number (whole or decimal), string, boolean (true or false), null, or undefined. typeof reports it while the program runs (with the quirk that typeof null is "object").
• The checker knows each variable’s type from a type annotation or by inference. With static typing, that type never changes: count = "five" for a number is rejected before anything runs, and so are null in a number and reading a variable before it is assigned.
• % gives the remainder, ** raises to a power, Math.floor rounds down, and Math.round rounds to the nearest whole number. Precedence: parentheses, then **, then * / %, then + -, left to right within a row.
• Number() and String() make new values of another type. Text that is not a number becomes NaN, and dividing by zero gives Infinity; neither the checker nor Node reports them.
• Numbers are stored as floats, so 0.1 + 0.2 shows a tiny error. Calculate with full values and round only for display, with Math.round(x * 100) / 100.

Do these in your day02 folder. First make sure npx tsc prints nothing there: if any broken file from today is still in the folder (such as a question’s price-change.ts, lunch-sales.ts, thermostat.ts, or years-left.ts), fix it or delete it. Then type each program yourself, check it with npx tsc, run it with node, and only then open the answer. Change the starting values and run them again to test your program.

const fahrenheit = 72;
const celsius = ((fahrenheit - 32) * 5) / 9;
console.log(fahrenheit, "degrees Fahrenheit is", Math.round(celsius * 10) / 10, "degrees Celsius");

72 degrees Fahrenheit is 22.2 degrees Celsius

const totalSeconds = 7384;
const hours = Math.floor(totalSeconds / 3600);
const secondsLeft = totalSeconds % 3600;
const minutes = Math.floor(secondsLeft / 60);
const seconds = secondsLeft % 60;
console.log(totalSeconds, "seconds is", hours, "hours,", minutes, "minutes and", seconds, "seconds");

7384 seconds is 2 hours, 3 minutes and 4 seconds

const principal = 1000;
const rate = 0.05;
const years = 10;
const amount = principal * (1 + rate) ** years;
const interest = amount - principal;
console.log("Final amount:", Math.round(amount * 100) / 100);
console.log("Interest earned:", Math.round(interest * 100) / 100);

Final amount: 1628.89
Interest earned: 628.89

let cents = 87;
const quarters = Math.floor(cents / 25);
cents = cents % 25;
const dimes = Math.floor(cents / 10);
cents = cents % 10;
console.log(quarters, dimes, cents);

3 1 2

const scoreA = 80;
const scoreB = 90;
const average = scoreA + scoreB / 2;
average = Math.round(average);
console.log("Average:", average);

average-two-mistakes.ts:4:1 - error TS2588: Cannot assign to 'average' because it is a constant.

const scoreA = 80;
const scoreB = 90;
const average = Math.round((scoreA + scoreB) / 2);
console.log("Average:", average);

Average: 85

const half = 7 / 2;
const doubledText = String(half * 2);
const fromWord = Number("seven");
console.log(half, typeof half);
console.log(doubledText, typeof doubledText);
console.log(fromWord, typeof fromWord);
console.log(typeof null);

3.5 number
7 string
NaN number
object

const priceText = "4.50 dollars";
const price = Number(priceText);
console.log("Price for 3:", price * 3);

const priceText = "4.50";
const price = Number(priceText);
console.log("Price for 3:", price * 3);

Price for 3: 13.5

console.log(Math.round(3.5));
console.log(Math.floor(4.99));
console.log(14 % 5);
console.log(-Math.floor(-4.5));

The TypeScript Handbook covers today’s types and annotations in more detail, and MDN explains declarations and JavaScript’s values: TypeScript Handbook: Everyday Types (read the primitives and type annotations sections) and MDN: Grammar and types.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can create a variable with let and trace how its value changes. Reread
• I can choose between const and let, and explain why const is the default. Reread
• I can tell whether a name is legal and write it in camelCase. Reread
• I can name the type of a number, a string, or a boolean, and use typeof. Reread
• I can write a type annotation and say what type the checker infers without one. Reread
• I can say whether the type checker will accept an assignment. Reread
• I can explain null and undefined and what strict mode does with them. Reread
• I can use %, **, Math.floor, and Math.round, including with negative numbers. Reread
• I can evaluate an expression in precedence order. Reread
• I can convert values with Number() and String() and explain where NaN comes from. Reread
• I can explain why 0.1 + 0.2 is not exactly 0.3 and round a result for display. Reread