Truthiness!

Although this is a case where idiomatic python is different from idiomatic js.

In js:

  // same:
  !! ""   // false
  !! 0    // false
  !! 1    // true
  !! null // false  

  // different:
  !! {}  // true
  !! []  // true

while in python:

  # same:
  not not ""    # False
  not not 0     # False
  not not 1     # True
  not not None  # False
  
  # different:
  not not {}       # False
  not not []       # False
  not not tuple()  # False

Nice list.

Perhabs just personal preference but I'd use

    for(let element of someList){
    	console.log(element);
    }

instead of

    someList.forEach(element => {
      console.log(element)
    })

for...of is easier to read and recognize as a loop construct at first glance, and as far as I recall it's also faster nowadays since the body of the loop is inline, whereas forEach requires the runtime to deal with a function object.

Personally I find the method-style syntax significantly more readable.

You can also ‘return’ the outer function from within a ‘for...of’ which is pretty useful imo.

And you can use await in the context of an outer async function, which is a huge advantage in reducing code complexity.

Makes me wonder if maybe the syntax for mapping, folding and other collection operations should have a similar syntax to for instead of the current method-style syntax popular in most modern languages.

C# has a syntax called Linq Query Syntax that provides keywords in the language to do things like map, filter, and reduce.

Example:

  var queryLondonCustomers = from cust in customers
                             where cust.City == "London"
                             select cust;

I'm not a big fan of it honestly, the function style seems more consistent and easier to read to me.

https://www.pyret.org/ does it like this:

  for each(str from [list: "Ahoy", "world!"]):
    print(str)
  end

  for map(n from [list: 1,2,3]): n * n end
  # ==> [list: 1, 4, 9]

  for filter(n from [list: 1, 2, 3]):
    n >= 2
  end
  # ==> [list: 2, 3]

  for fold(sum from 0, n from [list: 4, 5, 6]):
    sum + n
  end
  # ==> 15

That sounds a lot like Python list comprehensions

I genuinely love the design of the page. It has personality without compromising readability. This is something a lot of people struggle to get right.

Instead of...

    Object.entries(newDict).forEach(element => {
      console.log(`${element[0]} ${element[1]}`)
    })

... you could write ...

    for (const key in newDict) {
      console.log(`${key} ${newDict[key]}`)
    }

... or ...

    for (const [key, value] of Object.entries(newDict)) {
      console.log(`${key} ${value}`)
    }

It would be nice to have a sectioin with things that work differently in both languages. For example in python `if []:` evaluates to False while in javascript `if ([]) {` evaluates to True.

First: congratulations, this is very well done.

Second: I don't like seeing JavaScript code without semicolons. Maybe I am old, but it makes me nervous.

Thanks for the site! Do you have thoughts on removing all the print/console.logs calls on every line? It feels like there's a lot of visual noise there, that can still be met with the comments showing state/output.

I might suggest replacing javascript's parseInt() with Number()

Consider renaming to "How to write $X in both Python 3 and JavaScript" to avoid the confusion with X11 that others have pointed out? Nice article!

I really like the page. I really enjoyed going through the list. One suggestion would be to add python/javascript generator functions to the list.

Very cool reference.

Add Python 2 and or another language that has a static type system like C.

I think anyone who hasn't learned to do X in Python already really should be better off learning it in Python 3 rather than a version of the language which is in the process of deprecation.

Either you forgot to mention that this is a personal todo, or you're trolling the author?