Python VS JavaScript

$ python --version
Python 2.7.10
$ python2 --version
-bash: python2: command not found
$ python3 --version
Python 3.6.5

node program.js arg1 arg2 etc

<script src="program.js"></script>

python program.py arg1 arg2 etc

// Anything after two forward slashes is a comment
print(2);  // prints 2

/* Anything between slash-star and
star-slash is a comment */

# Anything after a # is a comment
print(2)  # prints 2

"""
At this point we wish
to print out some numbers
and see where that gets us
"""
print(1)
print(2)

console.log("Hello, world!");

let x = 10; console.log(x);

print(1); print(2)   # prints 1, then 2

if (x == 2) {
  console.log("x must be 2")
} else {
  if (x == 3) {
    console.log("x must be 3")
  } else {
    console.log("x must be something else")
  }
}

if x == 2:
  print("x must be 2")
else:
  if x == 3:
    print("x must be 3")
  else:
    print("x must be something else")

function foobar(x, y, z) {
  console.log(x, y, z);
  return 12;
}

let hello = () => {
  console.log("hello");
  console.log("world");
}

hello(); // prints hello, then world

// Arrow functions with single parameters don't
// need parens around the parameter:
let printNum = x => {
  console.log(x);
}

// If you don't explicitly return a value, the value
// of the last expression in the function is used.
// Also, single-expression functions don't need
// braces around them.
let add = (x, y) => x + y;

console.log(add(4, 5)); // prints 9

def foobar(x, y, z):
  print(x, y, z)
  return 12

add = lambda x, y: x + y

print(add(4, 5)) # prints 9

let x = 10;
const y = 30;

x = 10

let a = 12;        // number
let b = 1.2;       // number
let c = 'hello';   // string
let d = "world";   // string 
let e = true;      // boolean
let f = null;      // null value
let g = undefined; // undefined value

let s = `this is a
multi-line string`;

let x = 12;
console.log(`x is ${x}`); // prints "x is 12"

"2" + 4;           // string "24"
parseInt("2") + 4; // number 6
Number("2") + 4;   // number 6

a = 12       # int (integer)
b = 1.2      # float (floating point)
c = 'hello'  # str (string)
d = "world"  # str
e = False    # bool (boolean)
f = None     # null value

s = """this is a
multi-line string"""

x = 12
print(f'x is {x}')   # prints "x is 12"

"2" + 4        # ERROR: can't mix types
int("2") + 4   # integer 6
"2" + str(4)   # string 24

let a1 = new Array();   // Empty array
let a2 = new Array(10); // Array of 10 elements
let a3 = [];            // Empty array
let a4 = [10, 20, 30];  // Array of 3 elements
let a5 = [1, 2, "b"];   // No problem

console.log(a4[1]);  // prints 20

a4[0] = 5;   // change from 10 to 5
a4[20] = 99; // OK, makes a new element at index 20

a4.length; // 3

a1 = list()          # Empty list
a2 = list((88, 99))  # List of two elements
a3 = []              # Empty list
a4 = [10, 20, 30]    # List of 3 elements
a5 = [1, 2, "b"]     # No problem

print(a4[1])  # prints 20

a4[0] = 5;    # change from 10 to 5
a4[20] = 99;  # ERROR: assignment out of range

len(a4)   # 3

a[start:end] # items start through end-1
a[start:]    # items start through the rest of the array
a[:end]      # items from the beginning through end-1
a[:]         # a copy of the whole array

a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

x = (1, 2, 3)
print(x[1])  # prints 2

y = (10,)    # A tuple of one element, comma required

a = [1, 2, 3, 4, 5]

# Make a list b that is the same as list a:
b = [i for i in a]  # Pretty boring

# Make a list c that contains only the
# even elements of a:
c = [i for i in a if i % 2 == 0]

let o1 = {};           // empty object
let o2 = {"x": 12};    // one property
let o3 = {y: "hello"}; // property quotes optional

let o4 = {  // common multiline format
  "a": 20,
  "b": 1.2,
  "foo": "hello"
};

console.log(o2.x);      // prints 12
console.log(o4["foo"]); // prints hello

o1 = {}           # empty dict
o2 = {"x": 12}    # one key
o3 = {y: "hello"} # ERROR: key quotes required,
                  # unless y is a variable
                  # that holds a value you wish
                  # to use as a key

o4 = {  # multiline format
  "a": 20,
  "b": 1.2,
  "foo": "hello"
}

print(o4["a"])  # Prints 20

let x = 237;
let x_binary = x.toString(2); // string '11101101'
let x_hex = x.toString(16);   // string 'ed'

let x = 3.1415926535;
let y = x.toFixed(2);  // string '3.14'

let s = "Hello!";
let t = s.padStart(10, ' '); // string '    Hello!' 
let u = s.padEnd(10, ' ');   // string 'Hello!    '

let v = s.padStart(10, '*'); // string '****Hello!' 

// Pad with leading zeroes
(12).toString(2).padStart(8, '0'); // string '00001100'

let x = 3.1415926;
let y = "Hello";
let z = 67;

// 'x is 3.14, y is "Hello", z is 01000011'
let s = `x is ${x.toFixed(2)}, y is "${y}", z is ${z.toString(2).padStart(8, '0')}`

x = true;
y = false;

0 == "0";  // true
0 === "0"; // false

0 == [];   // true
0 === [];  // false

0 == 0;    // true
0 === 0;   // true

!0;    // true
!!0;   // false
!1;    // false
!null; // true
!"0";  // false, perhaps unexpectedly
!"x";  // false

if (a == 2 && b !== "") {
  // Something complicated
}

x = True
y = False

not 0      # true
not not 0  # false
not 1      # false
not None;  # true
not "0"    # false, perhaps unexpectedly
not "x"    # false

if a == 2 and b != "":
  # Something complicated

for (let i = 0; i < 10; i++) {
  console.log(i);
}

a = [10, 20, 30];

for (let i in a) {
  console.log(i);    # 0  1  2
  console.log(a[i]); # 10 20 30
}

b = {'x': 77, 'y': 88, 'z': 99};

for (let i in b) {
  console.log(i);    # x  y  z
  console.log(b[i]); # 77 88 99
}

a = [10, 20, 30];

for (let i of a) {
  console.log(i);  # 10 20 30
}

# Use the range() function to count:
for i in range(10):
  print(i)   # Prints 0-9

for i in range(20, 30):
  print(i)   # Prints 20-29

for i in range(-10, 20, 3):
  print(i)   # Print every 3rd number from -10 to 19

# A list
a = [10, 20, 30]

# Print 10 20 30
for i in a:
  print(i)

# A dict
b = {'x':5, 'y':15, 'z':0}

# Print x y z (the keys of the dict)
for i in b:
  print(i)

// Print 10 down to 0:

let x = 10;
while (x >= 0) {
  console.log(x);
  x--;
}

// Print 0 up to 9:
let x = 0;
do {
  console.log(x);
  x++;
while (x < 10);

# Print from 10 down through 0
x = 10
while x >= 0:
  print(x)
  x -= 1

switch(x) {
  case "foo":
    console.log("x is foo, all right");
    break;
  case 23:
    console.log("but here x is 23");
    break;
  default:
    console.log("x is something else entirely");
}

def func1():
  print("case 1 is hit")

def func2():
  print("case 2 is hit")

def func3():
  print("case 3 is hit")

funcs = {
  "alpha": func1,
  "bravo": func2,
  "charlie": func3
};

x = "bravo"
funcs[x]()  # calls func2

if (x == 10) {
  console.log("x is 10");
} else if (x == 20) {
  console.log("x is 20");
} else {
  console.log("x is something else");
}

if x == 10:
  print("x is 10")
elif x == 20:
  print("x is 20")
else:
  print("x is something else")

function Goat(color) {
  this.legs = 4;
  this.color = color;
}

g = new Goat("brown");

function Creature(type) {
  this.type = type;
}

// Make Goats inherit from Creature:
Goat.prototype = new Creature("mammal");

// Add a method:
Goat.prototype.jump = function () {
  console.log("I'm jumping! Yay!");
};

g = new Goat("red");
g.type;   // "mammal", since Goat inherits from Creature
g.jump(); // "I'm jumping! Yay!"

class Creature {
  constructor(type) {
    this.type = type;
  }
}

class Goat extends Creature {
  constructor(color) {
    super("mammal");
    this.legs = 4;
    this.color = color;
  }

  jump() {
    console.log("I'm jumping! Yay!");
  }
}

g = new Goat("orange");
g.type;   // "mammal"
g.jump(); // "I'm jumping! Yay!"

class Creature:
  def __init__(self, type): # constructor
    self.type = type

class Goat(Creature):
  def __init__(self, color):
    # call super constructor
    Creature.__init__(self, "mammal")
    self.color = color

  def jump(self):
    print("I'm jumping! Yay!")

g = Goat("green")
g.type    # mammal
g.jump()  # I'm jumping! Yay!

class Creature:
  def __init__(self, type): # constructor
    self.type = type

class Goat(Creature):
  def __init__(self, color):
    # call super constructor
    super().__init__("mammal")  # <-- Nicer!
    self.color = color

  def jump(self):
    print("I'm jumping! Yay!")

g = Goat("green")
g.type    # mammal
g.jump()  # I'm jumping! Yay!