JavaScript for Python developers

If you write Python, most of JavaScript will feel familiar: functions are values, closures work the same way, exceptions are thrown and caught, async and await look the same, and f-strings have a close cousin in template literals. The differences are in the details, and they are the kind that let code run without an error and still give a wrong answer. JavaScript has one number type for whole and fractional numbers, so integers stop being exact after 2⁵³. Empty lists are truthy, and sort() compares numbers as text. Objects reorder number-like keys, and in checks keys, not values. A method taken off its object forgets the object, and an async function starts running the moment you call it. This lesson runs the same programs in Python 3.14.8 and Node.js 24.21.0, so you can see each difference in recorded output rather than take it on trust.

The same jobs in both languages

Here are three jobs you do every day in Python: counting words, sorting records by two keys, and reading a dictionary that may lack a key, written in both languages:

# Three everyday jobs in Python: count words, sort records by two keys, read a dict safely.
from collections import Counter

text = "the cat sat on the mat by the door"
counts = Counter(text.split())
print("top three:", counts.most_common(3))

people = [{"name": "Ravi", "age": 31}, {"name": "Asha", "age": 31}, {"name": "Meera", "age": 27}]
oldest_first = sorted(people, key=lambda p: (-p["age"], p["name"]))
print("oldest first:", [p["name"] for p in oldest_first])

prices = {"tea": 20, "coffee": 35}
print("samosa, with a default:", prices.get("samosa", 0))
try:
    prices["samosa"]
except KeyError as error:
    print("samosa, without one: KeyError", error)

top three: [('the', 3), ('cat', 1), ('sat', 1)]
oldest first: ['Asha', 'Ravi', 'Meera']
samosa, with a default: 0
samosa, without one: KeyError 'samosa'

// The same three jobs in JavaScript: count words, sort records by two keys, read a map safely.
const text = 'the cat sat on the mat by the door';
const counts = new Map();
for (const word of text.split(' ')) counts.set(word, (counts.get(word) ?? 0) + 1);
const topThree = [...counts].sort((a, b) => b[1] - a[1]).slice(0, 3);
console.log('top three:', topThree);

const people = [{ name: 'Ravi', age: 31 }, { name: 'Asha', age: 31 }, { name: 'Meera', age: 27 }];
const byName = (a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
const oldestFirst = people.toSorted((a, b) => b.age - a.age || byName(a, b));
console.log('oldest first:', oldestFirst.map((p) => p.name));

const prices = new Map([['tea', 20], ['coffee', 35]]);
console.log('samosa, with a default:', prices.get('samosa') ?? 0);
console.log('samosa, without one:', prices.get('samosa'));

top three: [ [ 'the', 3 ], [ 'cat', 1 ], [ 'sat', 1 ] ]
oldest first: [ 'Asha', 'Ravi', 'Meera' ]
samosa, with a default: 0
samosa, without one: undefined

The two outputs say the same thing in two notations, and the code shows how the idioms map:

• Counter becomes a Map. JavaScript has no Counter; the pattern counts.set(word, (counts.get(word) ?? 0) + 1) does its job, and ?? supplies 0 for a word not seen yet. Python’s most_common keeps words with equal counts in the order it first met them, and so did the JavaScript version: a Map remembers insertion order, and sort is stable, so equal elements keep their order.
• A key tuple becomes a comparator. Python sorts by a key, (-age, name). JavaScript’s sort takes a comparator instead: a function given two items, whose result below zero, zero or above zero says which comes first. b.age - a.age || byName(a, b) sorts by age, oldest first, and by name when the ages are equal. toSorted returns a sorted copy, like sorted; sort sorts in place, like list.sort.
• A missing key is not an error. prices.get('samosa') is undefined, where Python’s prices["samosa"] raises KeyError. prices.get('samosa') ?? 0 matches dict.get with a default. The quiet undefined is convenient and dangerous at once: a typo in a key gives you undefined instead of an exception, and the problem shows up later.

Nine questions, two different sets of answers

The next two programs ask both languages the same nine questions. Each line prints a question and its answer:

# Nine expressions whose answers a Python developer knows. gotchas.mjs asks JavaScript the same questions.
def add(item, items=[]):
    items.append(item)
    return items

add(1)
rows = [
    ("2 ** 53 + 1 equals 2 ** 53", 2 ** 53 + 1 == 2 ** 53),
    ("-7 % 3", -7 % 3),
    ("7 divided by 2, rounded down", 7 // 2),
    ("an empty list is truthy", bool([])),
    ("[10, 9, 1] sorted by default", sorted([10, 9, 1])),
    ("'a' is in ['a']", "a" in ["a"]),
    ("[1, 2] equals [1, 2]", [1, 2] == [1, 2]),
    ("add(2) after add(1)", add(2)),
    ("keys of {b: 1, 10: 1, 2: 1}", list({"b": 1, 10: 1, 2: 1})),
]
for label, value in rows:
    print(f"{label:31} {value!r}")

2 ** 53 + 1 equals 2 ** 53      False
-7 % 3                          2
7 divided by 2, rounded down    3
an empty list is truthy         False
[10, 9, 1] sorted by default    [1, 9, 10]
'a' is in ['a']                 True
[1, 2] equals [1, 2]            True
add(2) after add(1)             [1, 2]
keys of {b: 1, 10: 1, 2: 1}     ['b', 10, 2]

// The questions of gotchas.py, asked of JavaScript. Several answers differ.
function add(item, items = []) {
  items.push(item);
  return items;
}

add(1);
const rows = [
  ['2 ** 53 + 1 equals 2 ** 53', 2 ** 53 + 1 === 2 ** 53],
  ['-7 % 3', -7 % 3],
  ['7 divided by 2, rounded down', Math.floor(7 / 2)],
  ['an empty list is truthy', Boolean([])],
  ['[10, 9, 1] sorted by default', [10, 9, 1].sort()],
  ["'a' is in ['a']", 'a' in ['a']],
  ['[1, 2] equals [1, 2]', [1, 2] === [1, 2]],
  ['add(2) after add(1)', add(2)],
  ['keys of {b: 1, 10: 1, 2: 1}', Object.keys({ b: 1, 10: 1, 2: 1 })],
];
for (const [label, value] of rows) console.log(label.padEnd(31), value);

2 ** 53 + 1 equals 2 ** 53      true
-7 % 3                          -1
7 divided by 2, rounded down    3
an empty list is truthy         true
[10, 9, 1] sorted by default    [ 1, 10, 9 ]
'a' is in ['a']                 false
[1, 2] equals [1, 2]            false
add(2) after add(1)             [ 2 ]
keys of {b: 1, 10: 1, 2: 1}     [ '2', '10', 'b' ]

Side by side, from the two outputs:

Eight of the nine answers differ. Here is why, row by row.

Numbers. Python’s int has unlimited precision. JavaScript has one number type for everything, the 64-bit floating-point double that Python uses for float, so whole numbers are exact only up to Number.MAX_SAFE_INTEGER, 2⁵³ − 1, which is 9,007,199,254,740,991. Past it, 2 ** 53 + 1 rounds to 2 ** 53. For larger exact integers JavaScript has a second type, BigInt, written with an n suffix: 2n ** 53n + 1n is exact. Money is safest as a whole number of the smallest unit, cents or paise, which stays exact to over 90 trillion rupees or dollars.

Remainder and division. % takes the sign of the dividend in JavaScript, so -7 % 3 is -1; Python’s takes the sign of the divisor and gives 2. Python’s // has no operator in JavaScript, where // starts a comment, so 7 // 2 silently means 7. Write Math.floor(7 / 2), which matches Python for negative numbers too, or Math.trunc, which rounds towards zero.

Truthiness. Python treats empty collections as false. In JavaScript only eight values are falsy: false, 0, -0, 0n, "", null, undefined and NaN. An empty array or an empty object is truthy, so if (items) is true for []; write if (items.length > 0).

Sorting. Without a comparator, sort turns the elements into strings and compares those, so 10 comes before 9 because "1" comes before "9". Sorting numbers always needs (a, b) => a - b.

in and equality. JavaScript’s in asks whether an object has a property with that key. For an array the keys are indices, so 0 in ['a'] is true and 'a' in ['a'] is false. Use includes for membership: ['a'].includes('a'). Equality has its own twist. JavaScript’s === compares objects by identity, like Python’s is, so two equal-looking arrays are not ===; compare their contents yourself. And == converts types before it compares ('1' == 1 is true), which is why JavaScript code uses ===.

Default arguments. Python evaluates a default once, when the function is defined, so the same list is shared by every call. JavaScript evaluates a default at every call that needs it, so add(2) gets a fresh [], and the famous mutable-default bug does not exist.

Key order. A Python dict keeps insertion order for every key. A JavaScript object lists keys that look like array indices first, in numeric order, and then the other keys in insertion order, which ECMA-262 specifies. Object keys are also always strings or symbols: obj[1] and obj['1'] are the same entry. A Map keeps insertion order and the type of every key, so a Map is the true counterpart of a dict whose keys are not plain words.

Python idioms, translated

Two Python tools have no direct counterpart in Node.js 24: zip (an Iterator.zip is planned for ECMAScript 2027) and math.fsum, whose counterpart Math.sumPrecise is part of ECMAScript 2026 but not yet in Node.js 24. A short loop does the job of either.

Methods and this

In Python a method taken off its object stays bound to it. In JavaScript it does not: the object a method works on, this, is decided by how the function is called, not where it was defined.

# A method taken off its object still knows the object in Python: it is a bound method.
class Counter:
    def __init__(self):
        self.n = 0

    def tick(self):
        self.n += 1
        return self.n


counter = Counter()
tick = counter.tick
print("tick() twice:", tick(), tick())

tick() twice: 1 2

// The same move in JavaScript: a method taken off its object forgets the object.
class Counter {
  n = 0;

  tick() {
    this.n += 1;
    return this.n;
  }
}

const counter = new Counter();
const tick = counter.tick;
try {
  tick();
} catch (error) {
  console.log('tick() on its own:', error.name, '(this is undefined)');
}
const bound = counter.tick.bind(counter);
console.log('bound tick() twice:', bound(), bound());

tick() on its own: TypeError (this is undefined)
bound tick() twice: 1 2

Called as tick(), the function has no object in front of it, so this is undefined (modules are strict) and reading this.n throws. Passing counter.tick to setTimeout or map loses the object in the same way, and an event listener calls it with the element as this instead. counter.tick.bind(counter) makes a copy with this fixed, and an arrow function, () => counter.tick(), keeps the call in the form counter.tick(). The Java lesson of this module looks at this from another side.

async and await: the same words, another start

Both languages write async def or async function and await, but they start the work at different times:

# When does an async function start? In Python, only once it is awaited or scheduled.
import asyncio


async def fetch_data():
    print("fetch_data starts")
    await asyncio.sleep(0)
    print("fetch_data resumes")
    return 42


async def main():
    print("before the call")
    pending = fetch_data()
    print("after the call, before await")
    print("result:", await pending)


asyncio.run(main())

before the call
after the call, before await
fetch_data starts
fetch_data resumes
result: 42

// When does an async function start? In JavaScript, at once: it runs until its first await.
async function fetchData() {
  console.log('fetchData starts');
  await null;
  console.log('fetchData resumes');
  return 42;
}

console.log('before the call');
const pending = fetchData();
console.log('after the call, before await');
console.log('result:', await pending);

before the call
fetchData starts
after the call, before await
fetchData resumes
result: 42

In Python, calling fetch_data() only creates a coroutine object, and the asyncio documentation stresses that calling a coroutine does not schedule it; its body starts when it is awaited. In JavaScript, calling fetchData() runs its body at once, up to the first await, and returns a promise for the rest. Three consequences matter when you port code:

• There is no asyncio.run. Browsers and Node.js run an event loop all the time, so you call an async function and await its promise, at the top level of a module if you like.
• Work starts when you call, not when you await. const a = load(1); const b = load(2); starts both loads at once, and await Promise.all([a, b]) collects them, much like asyncio.gather.
• A promise that fails while nobody waits for it is not silent. Since Node.js 15 an unhandled rejection ends the process with an error by default, so every promise you start must eventually be awaited or handled.

Exercise: port an expense report

This is a small Python function that totals a trip’s expenses per category, in paise so that no rounding creeps in. It runs on Python 3.14.8:

# The function to port: total a trip's expenses per category, in paise (whole numbers, so no rounding errors).
def totals_by_category(expenses):
    """Returns (category, total) pairs, largest total first, then by category name."""
    totals = {}
    for expense in expenses:
        amount = expense["amount_paise"]
        if not isinstance(amount, int) or isinstance(amount, bool):
            raise TypeError(f"amount must be a whole number of paise, got {amount!r}")
        category = expense.get("category") or "other"
        totals[category] = totals.get(category, 0) + amount
    return sorted(totals.items(), key=lambda pair: (-pair[1], pair[0]))


trip = [
    {"category": "food", "amount_paise": 45000},
    {"category": "travel", "amount_paise": 120000},
    {"category": "food", "amount_paise": 18050},
    {"category": "", "amount_paise": 9900},
    {"category": "travel", "amount_paise": -20000},
]
print(totals_by_category(trip))
print(totals_by_category([]))
try:
    totals_by_category([{"category": "food", "amount_paise": 12.5}])
except TypeError as error:
    print("TypeError:", error)

[('travel', 100000), ('food', 63050), ('other', 9900)]
[]
TypeError: amount must be a whole number of paise, got 12.5

Port it to JavaScript. The sample tests check the cases where a word-for-word port goes wrong: the comparator, the empty category, refunds and an amount that is not a whole number.

/**
 * A trip's expenses totalled per category, in paise.
 * @param {{ category?: string, amountPaise: number }[]} expenses
 * @returns {[string, number][]} pairs, largest total first, then by category name
 */
export function totalsByCategory(expenses) {
  return [];
}

import { test, assert } from 'mysmartcopilot:test';
import { totalsByCategory } from './totals.mjs';

test('totals each category and puts the largest first', () => {
  const trip = [
    { category: 'food', amountPaise: 45000 },
    { category: 'travel', amountPaise: 120000 },
    { category: 'food', amountPaise: 18050 },
  ];
  assert.deepEqual(totalsByCategory(trip), [['travel', 120000], ['food', 63050]]);
});

test('sorts by the number, not by its digits', () => {
  const trip = [{ category: 'a', amountPaise: 900 }, { category: 'b', amountPaise: 10000 }];
  assert.deepEqual(totalsByCategory(trip), [['b', 10000], ['a', 900]]);
});

test('three categories come out by total, not in the order they were added', () => {
  const trip = [
    { category: 'stay', amountPaise: 500 },
    { category: 'food', amountPaise: 900 },
    { category: 'travel', amountPaise: 100 },
  ];
  assert.deepEqual(totalsByCategory(trip), [['food', 900], ['stay', 500], ['travel', 100]]);
});

test('equal totals are in alphabetical order of the category', () => {
  const two = [{ category: 'stay', amountPaise: 500 }, { category: 'food', amountPaise: 500 }];
  assert.deepEqual(totalsByCategory(two), [['food', 500], ['stay', 500]]);
  const three = [
    { category: 'stay', amountPaise: 500 },
    { category: 'food', amountPaise: 500 },
    { category: 'misc', amountPaise: 500 },
  ];
  assert.deepEqual(totalsByCategory(three), [['food', 500], ['misc', 500], ['stay', 500]]);
});

test('refunds subtract, and a missing or empty category is "other"', () => {
  const trip = [
    { category: 'travel', amountPaise: 120000 },
    { category: 'travel', amountPaise: -20000 },
    { amountPaise: 700 },
    { category: '', amountPaise: 300 },
  ];
  assert.deepEqual(totalsByCategory(trip), [['travel', 100000], ['other', 1000]]);
});

test('no expenses give an empty array', () => {
  assert.deepEqual(totalsByCategory([]), []);
});

test('an amount with paise fractions is rejected with a TypeError', () => {
  assert.throws(() => totalsByCategory([{ category: 'food', amountPaise: 12.5 }]), TypeError);
});

Interview questions

Fresher · Why does [10, 9, 1].sort() return [1, 10, 9] in JavaScript?

Because without a comparator sort turns each element into a string and orders those strings by their UTF-16 code units, the way a dictionary orders words. "1" comes first, then "10", because a shorter prefix sorts before a longer string, and "9" last: the numbers are never compared as numbers. Give it a comparator whose result says which item goes first, below zero, zero or above zero: [10, 9, 1].sort((a, b) => a - b) gives [1, 9, 10], and (a, b) => b - a sorts from largest to smallest. Two details complete the answer. sort reorders the array itself, while toSorted returns a sorted copy. And since ECMAScript 2019 the specification requires a stable sort, so items that compare as equal stay in their original order. A Python developer expects numeric order because Python compares the values themselves.

Key takeaways

• Numbers are doubles: integers are exact only up to 2⁵³ − 1. Use BigInt for larger exact integers and whole paise or cents for money.
• % keeps the sign of the dividend, // is a comment, and empty arrays and objects are truthy.
• sort() compares as strings unless you pass a comparator; in checks keys and indices; === compares objects by identity.
• Defaults are evaluated at each call, objects put number-like keys first, and a Map is the counterpart of a dict.
• A detached method loses this, an async function starts when called, and an unhandled rejection ends a Node.js process.