Python syntax here : 2.7 - online REPL
Javascript ES6 via Babel transpilation - online REPL
import math
print math.log(42)
from math import log
print log(42)
# not a good practice (pollutes local scope) :
from math import *
print log(42)
import math from 'math';
console.log(math.log(42));
import { log } from 'math';
console.log(log(42));
import * from 'math';
console.log(log(42));
print range(5)
# 0, 1, 2, 3, 4
console.log(Array.from(new Array(5), (x,i) => i));
// 0, 1, 2, 3, 4
def foo():
yield 1
yield 2
yield 3
function *foo() {
yield 1;
yield 2;
yield 3;
}
lambda a: a * 2
a => a * 2
status, data = getResult()
var [status, data] = getResult();
search_db(**parameters)
searchDb(...parameters);
def fibonacci():
pre, cur = 0, 1
while True:
pre, cur = cur, pre + cur
yield cur
for x in fibonacci():
if (x > 1000):
break
print x,
var fibonacci = {
[Symbol.iterator]: function*() {
var pre = 0, cur = 1;
for (;;) {
var temp = pre;
pre = cur;
cur += temp;
yield cur;
}
}
}
for (var n of fibonacci) {
if (n > 1000)
break;
console.log(n);
}
(Python has builtin support for multiple inheritance)
class SpiderMan(Human, SuperHero):
def __init__(self, age):
super(SpiderMan, self).__init__(age)
self.age = age
def attack(self):
print 'launch web'
class SpiderMan extends SuperHero {
constructor(age) {
super();
this.age = age;
}
attack() {
console.log('launch web')
}
}
names = [c.name for c in customers if c.admin]
(Experimental in Babel)
var names = [for (c of customers) if (c.admin) c.name];
map(lambda: x*2, [1,2,3,4])
[1,2,3,4].map(x => x*2)
len([])
[].length
help(anything)
: get docstring for any module/method/function- list comprehensions, class magic methods !
- very powerful OOP
- huge and coherent standard library, ex : string has 38 useful methods
- built-in strings and array slicing.
- Builtin JSON support
- NPM packaging is a killer-feature : simple and fast, light-years ahead pip+virtualenv.
- Works in the browser :)
What I like about JS is the functional part of it. With a lot of iteration methods being a part of a prototype chain, one can nicely chain any iterable processing and easily shuffle between complex types while doing it
Also anonymous functions with fat arrow syntax makes it so much nicer to write functional code with, higher order functions and function composition is a joy.
In JS you can do things like bind functions to different contexts, borrow methods from other objects and so on.
I really miss object destructuring in Python. On the other hand, things like comprehensions make up for it a ton :)
Fun fact, both Javascript and Python leverage prototypal inheritance model under the covers, but JS is the one to expose it as public API.