JavaScript Reference

Variables

A name for a value, so the program can refer to it later instead of repeating it.

let score = 10;
score = 25;              // reassigned

const NAME = "Amara";    // cannot be reassigned

• Use const by default, let only when the value genuinely changes.
• Avoid var. It behaves differently in ways that surprise people.
• Python has no keyword at all: score = 10

Comments

Notes for humans that the machine ignores.

// a single line

/* several
   lines */

• Python uses a hash for single lines.

Strings

Text. Template literals with backticks let you drop values straight in.

const name = "Amara";
const greeting = `Hello, ${name}`;

name.length          // 5
name.toUpperCase()   // "AMARA"
name[0]              // "A"
"  hi  ".trim()      // "hi"
"a,b,c".split(",")   // ["a", "b", "c"]

• Python uses f-strings: f"Hello, {name}", and len(name) rather than .length.

Converting between types

Input arrives as text. Convert before doing arithmetic with it.

Number("42")      // 42
String(42)        // "42"
parseInt("42px")  // 42

"7" + 3           // "73"  string joined
Number("7") + 3   // 10    numbers added

• That third line is the most common beginner bug there is.
• Python uses int(), float() and str().

Objects

Named fields. Python calls the same idea a dictionary.

const member = { name: "Ama", hours: 40 };

member.name        // "Ama"
member["hours"]    // 40
member.city = "Atlanta";
Object.keys(member);

• Python writes {"name": "Ama"} and reads it as member["name"].

Array methods worth knowing

Filtering, transforming and reducing, without writing the loop yourself.

const n = [1, 2, 3, 4];

n.filter(x => x % 2 === 0)     // [2, 4]
n.map(x => x * 10)             // [10, 20, 30, 40]
n.reduce((a, b) => a + b, 0)   // 10
n.find(x => x > 2)             // 3
[...n].sort((a, b) => a - b)   // numeric sort

• Plain .sort() compares as text, so 10 lands before 9. Always pass a comparator for numbers.

Loops

Repeat until something is done. for...of walks a collection directly.

for (const n of numbers) {
  total += n;
}

for (let i = 0; i < 5; i++) { }

while (balance < goal) {
  balance += 75;
}

• A while loop needs something inside it to change, or it never ends.
• Python writes for n in numbers, and range(5) for the counted form.

Errors

Wrap risky work, handle the failure, and let finally clean up either way.

try {
  const data = JSON.parse(text);
} catch (err) {
  console.log("Could not parse");
} finally {
  console.log("Always runs");
}

throw new Error("empty list");

• Python uses try, except and raise.

Scope

A variable created inside a function does not exist outside it.

let count = 10;

function change() {
  let count = 99;   // a different variable
}
change();
// count is still 10

• let and const are block scoped, so they also stop existing at the closing brace.

Complexity

How the work grows as the input grows. Sequence adds, nesting multiplies.

O(1)       indexing
O(log n)   binary search
O(n)       one loop
O(n log n) a good sort
O(n^2)     nested loops

• Swapping a nested search for a Set lookup turns O(n squared) into O(n).
• Make it correct first, measure, then optimise.

Edge cases worth testing every time

The six that catch the overwhelming majority of real defects.

[]          // empty
[x]         // one item
[x, x, x]   // all identical
            // answer first
            // answer last
[-3, -9]    // negatives
0           // zero