PROGRAMMING LANGUAGE SYNTAX COMPARISON

A syntax summary, which also compares the differences between each programming language.

• List of languages
  • Python, Javascript (Typescript), Ruby, Kotlin, Java, C#, C/C++, Groovy

Table of Contents

• Interpreted Language
• Compiled Language
• Both Interpreted And Compiled Language
• Hello World
• Comments
• Data types
• Variable declaration int
• Variable declaration float
• Variable declaration None
• Strings
• Boolean
• Arithmetic Operators
• Comparison Operators
• Logical Operators
• Getting Input
• Bitwise Operators
• Increment
• Arrays and Lists
• Conditional Statement
• Loops
• Instantiation
• Functions
• Higher order functions
• Hash Tables
• Destructuring
• Spread Operator
• Rest parameters
• Class
• Importing Libraries
• Type Conversions
• Find Data Type
• String Concatenation
• JSON
• Program Entry Point
• Swapping values
• Error Handling
• Custom Error
• Asynchronous
• Math
• Date and Time
• Access modifier
• File System
• Iterators
• Generators
• Fetching Web Data
• Enum
• Language Specific

Interpreted Language

Dynamically-typed Language: resolution of types, members, properties, methods are done at run-time

lose compile-time checking, have to write more unit tests to ensure app behaves properly at run-time

• Python
• Javascript
  • Features
    • based on ECMAScript standard
    • not compiled, interpreted at runtime
    • no native function calls in browser
    • runtime differ between environments
    • restricted to browser sandbox
    • managed memory access
    • prototype-based inheritance
• Ruby

Compiled Language

Statically-typed Language: resolution of types, members, properties, methods are done at compile-time

trying to access a method that is not defined in an object when compiling the app will get an immediate error feedback

• Java: compiled to bytecode then interpreted by Java virtual machine into machine code
  • Features
    • not compatible with other languages
    • calls to native functions go through Java Native Interface (JNI)
    • write once, run anywhere
    • runs in a protected Java Virtual Machine (JVM)
    • managed memory access
    • limited to single inheritance
    • class-based inheritance
  • Types
    • Java Platform, Standard Edition (SE)
      • Core language and Java Runtime Environment (JRE)
    • Java Platform, Enterprise Edition (EE)
      • Recommendation for industrial-strength web applications
    • Java Platform, Micro Edition (ME)
      • Microcontrollers, sensors, mobile devices, telephone sim cards
      • A subset of Java SE
    • Java FX
      • Desktop appication framework (windows, mac, linux)
  • Automatic memory management
    • memory for objects are allocated automatically
    • local variables & function calls are stored in stack
    • objects & member variables are stored in heap
    • objects are retained in memory until dereferenced
    • object is eligible for collection when all references expire
      • when do references expire
        • variables local to methods or code blocks expire with scope

        void changeString() {
          String localVar = "Won't be around for long!";
          System.out.println("In function: " + localVar);
        }

        • explicitly dereference variables with null keyword

        void changeString() {
          String localVar = "Won't be around for long!";
          tempVar = null;
        }

    • when Java Virtual Machine runs out of memory for a newly requested object
      • the system throws OutOfMemoryError
      • Tips for managing memory
        • minimize the number of objects created
        • find out how much memory is available & is currently in used in the virtual machine
          • Runtime.maxMemory() & Runtime.totalMemory()
        • setting available memory
          • use command line options to manage amount of available heap memory
            • set inital heap size java -Xms256s HelloWord
            • set max heap size java -Xmx256m HelloWord
            • set heap size for new objects java -Xmn256n HelloWord
  • Java Garbage Collector
    • runs in its own thread
    • allocates & deallocates memory
    • can destroy dereferenced objects, but not required
    • garbage collection is managed by the Virtual Machine
    • cannot force garbage collection as it is an automatic process
      • Can run System methods to call garbage collection
        • Methods System.gc() & Runtime.gc() can request garbage collection
          • but there is no guarantee it will happen
  • Identifiers and Keywords
    • Keywords can't be used as class or other identifiers
    • class, method, field, and other names are identifiers
    • identifiers must start with alpha character or underscore
  • Identifier conventions
  • classes are always Pascal case class MyClass {}
  • methods and variables are Camel case void doSomething(String withThis) {}
  • constants are all uppercase public static final String FIRSTNAME="Myname";
    • final means once it has been set, it can't be changed
• C#: compiled to an Intermediate Language (IL), which is then translated by the Common Language Runtime (CLR) into machine code
  • from .NET 4, dynamic capability was added to improve interoperability with COM & Dynamic languages
• C++: compiled into native machine language
  • Features
    • compatible with C language
    • allows calls to native system libraries
    • requires porting to other platforms
    • exposes low-level system functions
    • explicit memory management
    • allows multiple inheritance

Both Interpreted And Compiled Language

• Groovy
  • it is a Java-syntax-compatible object-oriented programming language for the Java platform
  • is both a static and dynamic language with features similar to those of Python
  • can be used as both a programming language and a scripting language for the Java Platform, is compiled to Java virtual machine (JVM) bytecode
    • interoperates seamlessly with other Java code and libraries
  • allows optionally-typed dynamic capabilities
    • do not need to spell out the type of field
  • allows advance programming
    • metaprogramming, functional programming, closures
  • supports authoring of domain-sepcific languages
    • jenkins file: to create a built pipeline with jenkins
    • gradle build script
  • requires installation of Java Development Kit (JDK) to work
  • allows duck typing: provides the option to use the def keyword to determine the type at runtime
  • can also have a variable assign a concrete type
    • can tell groovy compiler to enforce static typing if needed
  • auto generates getter and setter methods at runtime for class members
  • contains Abstract Syntax Tree (AST) transformations: provides annotations for generating methods at runtime
    • such as defining contructors, equals, hashCode, toString methods
  • automatically imports commonly-used packages
    • like java.util.* and java.io.*
  • makes the default modifier as public, leading to less verbose code
  • semicolons are optional, only required if want to define more than 1 statement on a single line

Hello World

python 2

print "Hello World"

python 3

print("Hello World")  # "Hello World\n"
print("Hello", "World", sep="/")  # "Hello/World"
print("Hello World", end="")  # "Hello World"

javascript

console.log("Hello World"); // "Hello World"
console.log("Hello", "World"); // "Hello World"

ruby

print "Hello World"  # takes whatever you give it and prints it to the screen
puts "Hello World"  # adds a new (blank) line after the thing you want it to print
p "Hello World"  # same as puts

kotlin

// fun for function declaration
fun main() {  // main method, a must to have
    println("Hello, world")  // adds new line after printing
}

java

• java classes are typically organized into packages
  • package is a global unique string that usually starts with your domain name in reverse domain order
    • ensures globally unique identifiers (e.g.: Main)
      • if there are more than 1 class named Main in an app
        • can be distinguished by using the package
• each source code file will contain 1 public class
• public visible to all classes
• protected visible to class they belong and any subclasses
• private (most restricted): visible only to class they belong
• static can be accessed without creating a class instance
• final constant value, value cannot be changed
• void means that the method doesn't return any value

package com.example;  // package declaration

// class declaration
public class HelloWorld {
  // main method: always have the 3 keywords (public, static, void)
  // must also receive an array of strings as an argument
  public static void main(String[] args) {
    // executable code
    System.out.println("Hello World");  // adds new line after printing
    System.out.print("Hello World");  // no new line is added after
  }
}

c#

public class HelloWorld {
  public static void Main() {
    System.Console.WriteLine("Hello World");  // adds new line after printing
    System.Console.Write("Hello World");  // no new line is added after printing
  }
}

c++

#include <iostream>

int main()
{
    std::cout << "Hello, World!";
    return 0;
}

groovy

• using dynamic type method

println "Hello World"

• using static type method

class HelloWorld {
  static void main(String[] args) {
    println("Hello World");
  }
}

assembly

; x86 32 bit Mac OSX
; to run file, compile and run with the following command
; nasm -f macho hello_world32.asm && ld -macosx_version_min 10.7.0 -o hello_world32 hello_world32.o && ./hello_world32

global start

section .text
start:
    push    dword msg.len
    push    dword msg
    push    dword 1
    mov     eax, 4
    sub     esp, 4
    int     0x80
    add     esp, 16

    push    dword 0
    mov     eax, 1
    sub     esp, 12
    int     0x80

section .data

msg:    db      "Hello, world!", 10
.len:   equ     $ - msg

; x86_64 64 bit Mac OSX
; to run file, compile and run with the following command
; nasm -f macho64 hello_world64.asm && ld -macosx_version_min 10.7.0 -lSystem -o hello_world64 hello_world64.o && ./hello_world64

global start

section .text

start:
    mov     rax, 0x2000004 ; write
    mov     rdi, 1 ; stdout
    mov     rsi, msg
    mov     rdx, msg.len
    syscall

    mov     rax, 0x2000001 ; exit
    mov     rdi, 0
    syscall

section .data

msg:    db      "Hello, world!", 10
.len:   equ     $ - msg

back to top

Comments

python 2 & 3

# Single line comment

"""
multi-line comments
"""

javascript

// Single line comment

/*
multi-line comments
*/

ruby

# Single line comment

=begin
multi-line comments
=end

java

// Single line comment

/*
multi-line comments
*/

/**
 * javadoc <b>comments</b> for classes, javadocs can be used to auto generate documentation documents for code commented with javadocs
 */

 /**
 * javadoc <b>comments</b> for methods with parameters - example main method
 * @param args - an array of string values
 */

c#

// Single line comment

/*
multi-line comments
*/

c++

// Single line comment

/*
multi-line comments
*/

assembly

; Single line comment

back to top

Data types

python

8 main data types

• Text type
  • str, x = "Hello World" , x = str("Hello World")
• Numeric types
  • int, x = 20 , x = int(20)
  • float, x = 20.5, x = float(20.5)
  • complex, x = 1j, x = complex(1j)
• Sequence types
  • list, x = ["apple", "banana", "cherry"], x = list(("apple", "banana", "cherry"))
  • tuple, x = ("apple", "banana", "cherry"), x = tuple(("apple", "banana", "cherry"))
  • range, x = range(6), x = range(6)
• Mapping type
  • dict, x = {"name" : "John", "age" : 36}, x = dict(name="John", age=36)
• Set types
  • set, x = {"apple", "banana", "cherry"}, x = set(("apple", "banana", "cherry"))
  • frozenset, x = frozenset(cherry), x = frozenset(("apple", "banana", "cherry"))```
• Boolean type
  • bool, x = True, x = bool(5)
• Binary types
  • bytes, x = b"Hello", x = bytes(5)
  • bytearray, x = bytearray(5), x = bytearray(5)
  • memoryview, x = memoryview(bytes(5)), x = memoryview(bytes(5))
• None type
  • None, x = None

javascript

1 primitive structural root

• null
  • unknown values – a standalone type that has a single value null

2 Structual types

• object
  • for more complex data structures
  • new Object, new Array, new Map, new Set, new WeakMap, new Date, new ...

6 basic primitive data types

• number

  • for numbers of any kind: integer or floating-point, integers are limited by ±(2^53-1) === ±9007199254740991
  • contain
    • regular numbers

      let n = 123;

    • floats

      let n = 1.23;

    • special numeric values
      • Infinity

        let n = 1 / 0;
        let n2 = Infinity;

      • -Infinity
      • NaN

        let n = "not a number" / 2; // NaN

• bigint

  • no maximum limit to a BigInt

  let bigInt = 1234567890123456789012345678901234567890n; // ends with n

• string

  • may have zero or more characters, there’s no separate single-character type

• boolean

  • true / false.

• undefined

  • unassigned values – a standalone type that has a single value undefined

• symbol

  • for unique identifiers

  // id is a new symbol
  let id = Symbol();
  
  // can give symbol a description (also called a symbol name), mostly useful for debugging purposes
  let _id = Symbol("id2");
  
  // symbol in an object literal
  let obj = {
    [_id]: 123, // not "id": 123
  };
  
  // guaranteed to be unique
  let id1 = Symbol("id");
  let id2 = Symbol("id");
  console.log(id1 == id2); // false
  
  // convert symbol to string
  id1.toString(); // "Symbol(id)"
  
  // get symbol description
  id1.description; // "id"

  • Symbols allow us to create “hidden” properties of an object, that no other part of code can accidentally access or overwrite

  let user = {
    // belongs to another code
    name: "John",
  };
  
  let id = Symbol("id");
  user[id] = 1;
  console.log(user[id]); // 1
  console.log(user); // { name: 'John', [Symbol(id)]: 1 }

  • benefit of using symbol over string
    • objects belongs to another code, and that code also works with them, we shouldn’t just add any fields to it
    • symbol cannot be accessed accidentally, the third-party code probably won’t even see it
  • Symbols are skipped by for...in loop

  let id = Symbol("id");
  let user = {
    name: "John",
    age: 30,
    [id]: 123,
  };
  
  for (let key in user) console.log(key); // name age undefined

  • Symbol can be cloned with Object.assign

  let id = Symbol("id");
  let user = {
    [id]: 123,
  };
  
  let clone = Object.assign({}, user);
  console.log(clone); // { [Symbol(id)]: 123 }

  • global symbols
    • use if want same-named symbols to be same entities

  // get symbol by name
  let id1 = Symbol.for("id");
  let id2 = Symbol.for("id");
  
  console.log(id1 === id2); // true
  
  // get name by symbol, can only use for global symbol
  console.log(Symbol.keyFor(id1)); // "id"

java 8

2 major data types

1. Primitive data types

   • stored in fastest available memory
   • names are all camel case
   • Java class library includes helper classes for each primitive
     • helper classes support conversion and formatting tools
     • import java.lang.Byte; import not required from java.lang libraries
   • all primitive numeric variables default to 0

   public class Main {
     private static int myInt;  // must be declared as static of a class to have default value
   
     public static void main(String args[]) {
       System.out.println(myInt);  // 0
     }
   }

   • data types
     • numbers
       • byte
         • 8 bits
         • -128 to 127
         • default value 0
         • helper class Byte
       • short
         • 16 bits
         • -32,768 to 32,767
         • default value 0
         • helper class Short
       • int
         • 32 bits
         • -2,147,483,648 to 2,147,483,647
         • default value 0
         • helper class Integer
       • long
         • 64 bits
         • -9.22337E+18 to 9.22337E+18
         • default value 0L
         • helper class Long
       • float
         • 32 bits
         • default value 0.0f or 0.0F or .0f or .0F
         • helper class Float
       • double
         • 64 bits
         • default value 0.0d or 0.0D or .0d or .0D
         • helper class Double

         double doubleValue = 156.5d;
         Double doubleObj = new Double(doubleValue);  // declare instance of the double class
         int intValue = doubleObj.intValue();  // 156, use helper object to convert to desired numeric data type

     • characters
       • '\u0000' (or 0) to '\uffff' (or 65,535 inclusive)
       • default value '\u0000'
     • booleans
       • default value false

2. Objects

   • an object is an instance of a class
   • nonprimitive variables are references to objects
   • objects can have multiple references
   • Object data types
     • String
       • a complex object
       • is an instance of the string class
       • is an array of characters
       • string objects are immutable
       • reasigning the string value creates a new object
         • the old object can be cleared from memory thrown garbage collection process
       • helper class is java.lang.String, thus import not required

       String string1 = new String("Hello");

back to top

Variable declaration int

• integer ...-2, -1, 0, 1, 2...

python 2

# int: -2147483648 ~ 2147483647
integer_name = 123
# long: -9223372036854775808L ~ 9223372036854775807L
long_name = 123L  # int beyond int size will automatically be converted to long

python 3

# python 3: int and long are combined into int
integer_name = 123

javascript ES5

// method 1
var integer_name;
integer_name = 123; // accessible within the function

// method 2
var integer_name = 123;

javascript ES6

// method 1
let integer_name;
integer_name = 123; // accessible only within the block {}

// method 2
let integer_name = 123;

// method 3
const integer_name = 123; // variable value cannot be reassigned

typescript

let integer_name: number = 123; // method 1
let integer_name2 = 123; // method 2, not required to declare type if assigning to value
let integer_name3: number; // must declare the value type
integer_name3 = 123;

let decimal: number = 6;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;

ruby

integer_name = 123

java

// public/private/protected static final byte/short/int/long integerName = 123;
/*
public: visible to all classes
protected: visible to class they belong and any subclasses
private (most restricted): visible only to class they belong
static: can be accessed without creating a class instance
final: constant value, value cannot be changed
*/

// byte: -128 ~ 127, 8 bits
byte byteName = 123;

// short: -32768 ~ 32767, 16 bits
short shortName = 123;

// int: -2147483648 ~ 2147483647, -2_147_483_648 ~ 2_147_483_647, 32 bits
int integerName; integerName = 123;
int integerName2 = 123;  // default is visible within the same package

// long: -9223372036854775808L ~ 9223372036854775807L, can use _ same as int, 64 bits
long longName1 = 123l;  // 123
long longName2 = 123L;  // 123
long longName3 = 10_000;  // 10000, introduced in java 7, just makes it easier to read

c#

// var can be used to handle declarations when the data type is unknown
// once a variable is declared with var, the variable cannot be reassigned to a different data type
var variableName = 123;
variableName = "123";  // error CS0029: Cannot implicitly convert type `string' to `int'

// byte: -128 ~ 127, 8 bits
byte byteName = 123;  // type Byte
System.Byte byteName2 = 123;

// short: -32768 ~ 32767, 16 bits
short shortName = 123;  // type Int16
System.Int16 shortName2 = 123;

// int: -2,147,483,648 ~ 2,147,483,647
int integerName1 = 123;  // type Int32
int integerName2 = int.MaxValue;  // 2147483647
System.Int32 integerName3 = 123;

// Add const before variable declaration to make it a constant
const int integerName3 = 123;

// long: -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807
long longName1 = 123;  // type Int64
long longName2 = long.MaxValue;  // 9223372036854775807
System.Int64 longName3 = 123;

// decimal: max value 79,228,162,514,264,337,593,543,950,335
decimal decimalName1 = 123;  // type Decimal
decimal decimalName2 = 123m;
decimal decimalName3 = decimal.MaxValue;  // 79228162514264337593543950335
System.Decimal decimalName4 = 123;

// use System.Numerics.BigInteger for larger values (need add references to System.Numerics.dll)

c++

// const unsigned char/short/int/long/long long integer_name = 123;
/*
const: constant value, value cannot be changed
integer are signed by default: can assign both positive & negative values
unsigned integer (use when dealing with bit values): 0 ~ ...
  e.g. char: -128 ~ 127
  e.g. unsigned char: 0 ~ 255  // 128 + 127 = 255
*/

// char: 1 byte, -128 ~ 127, use C code to print "#include＜stdio.h＞ printf("%d", char_name);"
// 1 char has 8 bits
char char_name;
char_name = 123;

// similar to the rest of int variable declaration

// short/short int: 16 bits, 2 bytes, -32768 ~ 32767
short short_name;
short_name = 123;

short int short_name; short_name = 123;

// similar to the rest of int variable declaration

// int: 16 bits, 4 bytes, -2147483648 ~ 2147483647
int integer_name;
integer_name = 123;  // uninitialized

int integer_name = 123;  // C-like initialization

int integer_name (123);  // Constructor initialization

int age {123};  // C++11 list initialization syntax

// long/long int: 32 bits, 4 bytes, -2147483648 ~ 2147483647 bytes
long long_name;
long_name = 123;

long int long_name;
long_name = 123;

// similar to the rest of int variable declaration

// long long/long long int: 64 bits, 8 bytes, -9223372036854775808 ~ 9223372036854775807
long long long_name;
long_name = 123;

long long int long_name; long_name = 123;

// similar to the rest of int variable declaration

back to top

Variable declaration float

• float, double

python 2 & 3

float_name = 1.123
float_name = 0.1123e1  # equals to 1.123
float_name = 0.1123E1  # equals to 1.123
float_name = 1123e-3  # equals to 1.123
float_name = 1123E-3  # equals to 1.123

• float have inaccurate values

print(.1 + .2 + .3)  # 0.6000000000000001
# use the decimal library to make it accurate
from decimal import *

# do not do this
Decimal(.1) + Decimal(.2) + Decimal(.3)  # Decimal('0.6000000000000000055511151231')

# do this: convert float to a string first
x = Decimal(".1") + Decimal(".2") + Decimal(".3")  # Decimal('0.6')
f"{x}"  # "0.6
print(type(x))  # <class 'decimal.Decimal'>

javascript ES5

var float_name = 1.123;

javascript ES6

let float_name = 1.123;
const float_name = 1.123;

typescript

let float_name: number = 1.123;

ruby

java:

// float: 32 bits, 4 bytes
float float_name = 1.123f;  // 1.123, have 7 decimal digits
float float_name = (float) 1.123;

// double: 64 bits, 8 bytes
double double_name = 1.123d;  // 1.123, have 16 decimal digits
double double_name = 1.123;

// using BigDecimal math class
import java.math.BigDecimal;

public class Main {

  public static void main(String[] args) {
    double value = .012;
    double pSum = value + value + value;
    System.out.println(pSum);  // 0.036000000000000004

    String strValue = Double.toString(value);
    System.out.println(strValue);  // 0.012

    BigDecimal bigValue1 = new BigDecimal(value);
    BigDecimal bSum1 = bigValue1.add(bigValue1).add(bigValue1);
    System.out.println(bSum1.toString());  // 0.0360000000000000007494005416219806647859513759613037109375

    BigDecimal bigValue2 = new BigDecimal(strValue);
    BigDecimal bSum2 = bigValue2.add(bigValue2).add(bigValue2);
    System.out.println(bSum2.toString());  // 0.036
  }
}

c#

// float: 32 bit max value with 7 decimals of precision 3.402823E+38
float floatName1 = 1.123f;  // type Single
float floatName2 = float.MaxValue;  // 3.402823E+38
System.Single floatName3 = 1.123f;

// double: 64 bit max value with 15 decimals of precision 1.79769313486232E+308
double doubleName1 = 1.123d;  // type Double
double doubleName2 = 1.123;  // all floats are double by default
double doubleName3 = double.MaxValue;  // 1.79769313486232E+308
System.Double doubleName4 = 1.123;

c++

// float: 4 bytes
float float_name;
float_name = 1.123;  // have 7 decimal digits

// similar to the rest of int variable declaration

// double: 8 bytes
double double_name;
double_name = 1.123;  // have 15 decimal digits

// similar to the rest of int variable declaration

// long double: 12 bytes
long double double_name;
double_name = 1.123;  // have 19 decimal digits

// similar to the rest of int variable declaration

back to top

Variable declaration None

python 2 & 3

variable_name = None

# nan in python
import math
math.inf - math.inf  # nan

javascript

// undefined is reserved for variables whose values have not yet been set.
let variable_name; // undefined

//null is reserved for variables whose values are explicitly nothing — instead of just “not yet defined.”
let variable_name2 = null;

// NaN is a special numeric value meaning “Not a Number”
let variable_name3 = NaN;

typescript

let variable_name: void = undefined; // method 1
let variable_name2 = undefined; // method 2
let variable_name: undefined; // method 3

let variable_name2: void = null;
let variable_name3: number = NaN;

ruby

variable_name = nil  # nil is returned when no values are assigned, but nothing is displayed on screen

java

String stringName = null;

// NaN is produced if a floating point operation
float floatName = Float.NaN;  // NaN
double doubleName = Double.NaN;  // NaN

Double x = new Double(-2.0/0.0);  // -Infinity
Double y = new Double(0.0/0.0);  // NaN
x.isNaN();  // false
y.isNaN();  // true

System.out.println(2.0 / 0);  // Infinity

// set infinity value
double inf = Double.POSITIVE_INFINITY;  // Infinity
double inf = Double.NEGATIVE_INFINITY;  // -Infinty

c#

string stringName = null;
string stringName2 = String.Empty;

// method 1: use the nullable method
Nullable<int> integerName1 = null;

// method 2: value type requires ? during declaration
int? integerName2 = null;

c++

back to top

Strings

python 2 & 3

string_name = "string"
string_name = 'string'
# back slash not required, but will produce a new line if not given
string_name = """multi-line \
string\
"""

# raw strings (ignore escape characters)
string_name = r"\n raw string"  # "\n raw string"

len(string_name)  # 6

# Character unicode point
# only accepts 1 character
ord("b")  # 98

# reverse string
string_name = string_name[::-1]  # "gnirts"

string_name = "Gnirts"
string_name = string_name.swapcase()  # "gNIRTS"
string_name = string_name.upper()  # "GNIRTS"
string_name = string_name.lower()  # "gnirts"

# casefold: it is more aggressive than lower(), it removes all case distinctions even in unicode
string_name_casefold = "Hello World ß"
string_name_casefold.casefold()  # "hello world ss"

# capitalize string
string_name_caps = "test me"
string_name_caps.title()  # "Test Me"
string_name_caps.capitalize()  # "Test me"

# Replace string in string, string_name.replace(old, new, max)
string_name = string_name.replace("g", "xxx")  # "xxxnirts"
string_name = string_name.replace("x", "g", 1)  # "gxxnirts"

# Find character or string in string and return the index of the 1st character, return -1 if not found
string_name.find("x")  # 1
string_name.find("v")  # -1

# string slicing
# extract characters from a string, from start position to but not including end position
new_string_name = string_name[1:4]  # "xxn"

# Split strings, string_name.split(separator, max)
string_name = string_name.split()  # ["gxxnirts"]  only works for string without spaces
string_name = "test string"
string_name1 = string_name.split()  # ["test", "string"]
string_name2 = string_name.split("s")  # ["te", "t ", "tring"]
string_name3 = string_name.split("s", 1)  # ["te", "t string"]

# Split string into an array of letters
string_name4 = list(string_name)  # ['t', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g']

# Remove empty spaces
string_name = "    string    "
# remove all left spaces
string_name1 = string_name.lstrip()  # "string    "
# remove all right spaces
string_name2 = string_name.rstrip()  # "    string"
# remove all spaces
string_name3 = string_name.strip()  # "string"

# Check if string has alphabet and integer characters
string_name3.isalnum()  # False
string_name = "123"
string_name.isalnum()  # True
string_name = "s 123"
string_name.isalnum()  # False
string_name = "s123"
string_name.isalnum()  # True

# Check if string has all alphabet characters
string_name3.isalpha()  # True
string_name = "A e"
string_name.isalpha()  # False
string_name = "a2"
string_name.isalpha()  # False

# Check if string has all digit characters
string_name = "123"
string_name.isdigit()  # True
string_name = "12 3"
string_name.isdigit()  # False
string_name = "12d"
string_name.isdigit()  # False

# Join an array of string elements
arr = ["a", "b"]
"_".join(arr)  # "a_b"

javascript ES5

var stringName = "string";
var stringName = "string";
// back slash required
var stringName =
  "multi-line \
string";

stringName.length; // 6

// Character unicode point
string.charCodeAt(stringIndex);
"abc".charCodeAt(1); // 98

// reverse string
stringName.split("").reverse().join(""); // "gnirts"

stringName = stringName.toUpperCase(); // "GNIRTS"
stringName = stringName.toLowerCase(); // "gnirts"

// capitalize string
stringName = stringName.charAt(0).toUpperCase() + stringName.slice(1); // "Gnirts"

// replace 1 string occurance with string, stringName.replace(old, new)
stringName = stringName.replace("G", "xxx"); // "xxxnirts"

let stringName0 = "test_test_123";
// replace all string occurances with string, stringName.replaceAll(old, new)
stringName0 = stringName0.replaceAll("_", " "); // "test test 123"

// extract characters from a string, from start position to but not including end position
newStringName = stringName.substring(1, 4); // "xxn"

// Split string into arrays
stringName = "test string";
stringName1 = stringName.split(); // ["test string"]
stringName2 = stringName.split(""); // ['t', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g']
stringName3 = stringName.split("s"); // ["te", "t ", "tring"]

javascript ES6 // Almost all of ES5 are included in ES6

// back slash not required, but will produce a new line if not given
var stringName = `multi-line \
string`;
let stringName = "string";
const stringName = "string";

// raw strings (ignore escape characters)
String.raw`\n raw string`; // "\n raw string"

typescript

let stringName: string = "string";

// declare string and/or other types
let strOrNum: string | number;
strOrNum = "abc";
strOrNum = 123; // can be reassigned to a declared type

ruby

string_name = <<EOM
this is a
  multi line string
EOM
string_name = <<eom
this is a
  multi line string
eom
string_name = 'string'
string_name = "string"

string_name.length  # 6

string_name = string_name.reverse  # "gnirts"

string_name = string_name.upcase  # "GNIRTS"
string_name = string_name.swapcase  # "gnirts"
string_name = string_name.swapcase  # "GNIRTS"
string_name = string_name.downcase  # "gnirts"


string_name = string_name.capitalize  # "Gnirts"

# replace string in string, string_name.gsub!(/old/, new)
string_name = string_name.gsub!(/G/, "xxx")  # "xxxnirts"

# Split strings into an array
string_name = string_name.split("i")  # ["xxxn", "rts"]
string_name = "string"
string_name = string_name.split("")  # ["s", "t", "r", "i", "n", "g"]

# check if a string exists within a string
nameExist = "full name"
nameExist.include?("name")  # returns true

# search and count the total number of declared alphabets that exist in the string
nameExist.count("l")  # returns 2
nameExist.count("ln")  # (l + l + n) therefore returns 3

# search and count the total number of the opposite of the declared alphabets that exist in the string
nameExist.count("^l")  # returns everything except "l", therefore returns 7

# check if a string that starts with the declared string exists
nameExist.start_with?("ful")  # returns true
nameExist.start_with?("nam")  # returns false

# find the index of a searched string, returns the index of the first searched letter
nameExist.index("ll")  # returns 2

# remove empty spaces from string
removeStr = "   string   "
removeStr.lstrip  # "string   "
removeStr.rstrip  # "   string"
removeStr.strip  # "string"

# format string
moveString = "string"
moveString.rjust(10, ".")  # "....string"
moveString.ljust(10, ".")  # "string...."
moveString.center(10, ".")  # "..string.."

# Slice end of string
newStr = "string"
newStr.chop  # "strin"
# state the last letters to remove from string
newStr.chomp("ng")  # "stri"

# remove all listed letters from string
removeStr = "sstring"
removeStr.delete("si")  # "trng"

# SYMBOLS: strings that are immutable, must use letters or underscores (_)
# used mainly for memory conservation or speed string comparison
# use a symbol if need a string to be immutable and not need to access string methods
# commonly used in hashed for keys
variable_name = :symbolStringWithoutQuotes
puts variable_name  # symbolStringWithoutQuotes

java

// character: 16 bits, 2 bytes, only 1 letter or symbol, must use single quotes ''
char charName1 = 'a';
char charName2 = '\u0061';  // unicode character for the letter a

// modify character cases
Character.toUpperCase(charName1);  // 'A'
Character.toLowerCase(charName1);  // 'a'

// convert Char Array to a string
char[] chars = {'H', 'e', 'l', 'l', 'o'};
String s = new String(chars);  // "Hello"

// convert string to char array
char[] chars2 = s.toCharArray();
for (char c : chars2) {  // for each loop
  System.out.print(c);  // "Hello"
}

// convert primitive values to string
int intValue = 42;
String fromInt = Integer.toString(intValue);  // "42"

boolean boolValue = true;
String fromBool = Boolean.toString(boolValue);  // "true"


// strings: must use double quotes ""
String stringName = new String("Hello");  // method 1
String stringName1 = "string";  // method 2
String stringName2 = "multi-line " +
                     "string";


// get character of string with index
char indexChar = stringName1.charAt(0);  // 's'


// modify string cases
String stringName3 = stringName1.toUpperCase();  // "STRING"
String stringName4 = stringName3.toLowerCase();  // "string"


// get length of string
stringName4.length();  // 6

// get index of substring
int index = stringName4.indexOf("ng");  // 4

// get substring with index
String sub1 = stringName4.substring(4);  // "ng"
String sub2 = stringName4.substring(4, 6);  // "ng" from starting index to but exclude last index

// trim whitespaces from beginning and ending of string
String trimStr = "  test  ";
String newStr = trimStr.trim();  // "test"


// toString method: convert primitive numeric values to string
double doubleValue = .5d;
String stringName5 = Double.toString(doubleValue);  // "0.5"

// comparing strings
String str1 = "Hello";  // object 1
String str2 = "Hello";  // str2 points to str1, thus is still object 1
str1 == str2;  // true

String part1 = "Hello ";
String part2 = "World";
String str3 = part1 + part2;  // object 1
String str4 = "Hello World";  // object 2
str3 == str4;  // false
// need to use .equals()
str3.equals(str4);  // true

c#

• Strings (immutable)
  • each operation that appears to be modifying a string is actually creating a new string
  • modifying a string repeatedly can cause a significant performance penalty
  • when to use string
    • when number of changes that your app will make to a string is small
      • string builder might offer negligible or no performance improvement
    • when performing a fixed number of concatenation operations is required
      • compiler might combine the concatenation operations into a single operation
    • when performing extensive search operations while building a string is required
      • string builder lacks search methods (IndexOf, StartsWith)
      • thus will need to convert string builder to a string for these operations
      • this can negate the performance benefit from using string builder

// character: 16 bits
char charName1 = 'a';  // type Char
char charName2 = '\u0061';  // unicode character for the letter a
System.Char charName3 = 'a';

// strings
string stringName = "string";  // type String
System.String stringName2 = "string";

// multiline strings
// method 1
string multilineString1 = "multi-line\n"
+ "string";
// method 2
string multilineString2 = @"multi-line
string";
// method 3
string multilineString3 = System.String.Join(
  System.Environment.NewLine,
  "multi-line",
  "string"
);


// raw strings (ignore escape characters
string rawString = @"\n raw string";  // "\n raw string"


// check if string is empty
String.IsNullOrEmpty(stringName);  // False
String.IsNullOrEmpty("");  // True

// check for white space or empty
String.IsNullOrWhiteSpace(stringName); // False
String.IsNullOrWhiteSpace("  "); // True
String.IsNullOrWhiteSpace(""); // True
String.IsNullOrWhiteSpace(" test "); // False


// get length of a string
stringName.Length;  // 6


// get index of the 1st character or word in a string
stringName.IndexOf("s");  // 0
stringName.IndexOf("unknown");  // -1


// convert string to uppercase
stringName.ToUpper();  // "STRING"


// convert string to lowercase
stringName.ToLower();  // "string"


// split string to an array of characters
stringName.ToCharArray();  // ['s', 't', 'r', 'i', 'n', 'g']


// split string into an array of strings (must have separator)
stringName.Split('r');  // ["st", "ing"]


// get substring from a string (if length is not declared, the entire string from startIndex onwards will be returned)
int startIndex = 0;
int length = 2;
stringName.Substring(startIndex, length);  // "str"


// replace string with another string, stringName.Replace(old, new);
stringName.Replace("test", "newTest");  // "  newTest  "


// comparing strings
string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2));  // True True True
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s3), s1 == s3, s1.Equals(s3));  // False True True
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s4), s1 == s4, s1.Equals(s4));  // False False True


// check if a string starts with a character or words
string sampleString = "some random words";
sampleString.StartsWith("some");  // True

// check if a string ends with a character or words
sampleString.EndsWith("words");  // True


// remove white spaces from both left and right
string stringName3 = "  test  ";
stringName3.Trim();  // "test"
// remove white spaces from left
stringName3.TrimStart();  // "test  "
// remove white spaces from right
stringName3.TrimEnd();  // "  test"


// string slicing from start index
// count is the number of characters to delete from the start index
int startIndex = 3;
int count = 3;
stringName.Remove(startIndex, count);  // "str"
stringName.Remove(startIndex);  // "str"
stringName.Remove(startIndex, 2);  // "strg"

• String builder (muttable)
  • maintains a buffer to accommodate expansions to the string
  • new data is appended to the buffer if room is available
    • otherwise, a larger buffer is allocated
    • data from the original buffer is copied to the new buffer
    • then the new data is appended to the new buffer
  • when to use string builder
    • when expecting an unknown number of changes to a string at design time (when using a loop to concatenate a random number of strings that contain user input)
    • when expecting to make a significant number of changes to a string

// Declaration
// method 1
System.Text.StringBuilder builder = new System.Text.StringBuilder();  // ''
// method 2
using System.Text;  // import the prefix
var builder2 = new StringBuilder();  // ''
// method 3
var builder3 = new StringBuilder("starting string");  // "starting string"


// check if string builder is empty
// method 1
if (builder == 0) System.Console.WriteLine("true");  // "true"
// method 2
if (System.String.IsNullOrEmpty(builder.ToString()))
  System.Console.WriteLine("true");  // "true"


// append an array of similar characters
builder.Append('-', 3);  // "---"

// append a new line in string
builder.AppendLine();  // new line is counted as 1 character

// append a string
builder.Append("Header");
/*
"---
Header"
*/


// replace a character with a new character or a string with new string
builder.Replace('-', '+');
builder.Replace("er", "ing");
/*
"+++
Heading"
*/


// remove characters from startIndex for totalCharacters
int startIndex = 0;
int totalCharacters = 3;
builder.Remove(startIndex, totalCharacters);
/*
"
Heading"
*/


// insert an array of similar characters at index
builder.Insert(startIndex, new string('+', 4));
/*
"++++
Heading"
*/


// get character of string builder at index
builder[0];  // '+'

c++

// character: only have 1 character, must use single quotes ''
char charName;
charName = 'a';

char charName = 'a';
char charName ('a');
char charName {'a'};

// strings
// C-style strings: an ARRAY of characters, must use double quotes ""
// THIS IS NOT A TRUE STRING, IT IS AN ARRAY OF CHARACTERS!!!!!!!
char * stringName = "string";
const char * stringName = "string";  // const is normally used
char stringName[] = "string";  // creates array of 7 chars, last char is null "\0"
char stringName[7] = "string";  // need give 7 slots for chars and null char
char stringName[7] = {'s', 't', 'r', 'i', 'n', 'g', 0};  // no 0 = error
char stringName[7] = {'s', 't', 'r', 'i', 'n', 'g', '\0'};  // no '\0' = error

//C++ strings: must add at the top "#include＜string＞", must use double quotes ""
#include＜string＞
std::string stringName;
stringName = "string";

// back slash not required, but can use if want to
std::string stringName = "multi-line"
                          "string";
std::string stringName ("string");

back to top

Boolean

python 2 & 3

boolean_name = True
boolean_name = False
not True  # False
not False  # True

javascript ES5

var boolean_name;
boolean_name = true;
var boolean_name = false;
!true; // false
!false; // true

• truthy: "xxx", 1, -1, 2.5, true
• falsey: false, 0, "", null, undefined, NaN

javascript ES6

let boolean_name;
boolean_name = true;
let boolean_name = false;
const boolean_name = true;

typescript

let isDone: boolean = false;

ruby

boolean_name = true
boolean_name = false

• truthy: true, 0, 1, -1, "",
• falsey: false, nil
• Check if method exist
  • obj.respond_to?(:method)
    • example 1

      [1, 2, 3].respond_to?(:push) # true

    • example 2

      123.respond_to?(:next) # true

    • example 3: false because array can't be turned into a symbol

      [1, 2, 3].respond_to?(:to_sym) # false

java

boolean booleanName1 = true;
boolean booleanName2 = false;
boolean booleanName3 = !booleanName2;  // true

String sBoolean = "true";
boolean booleanName4 = Boolean.parseBoolean(sBoolean);  // true

c#

type Boolean
bool booleanName = true;  // displayed as True when printed
bool booleanName = false;  // displayed as False when printed
System.Boolean booleanName = false;

c++: 8 bits

bool boolean_name; boolean_name = true;  // produces a 1 output
bool boolean_name = false;  // produces a 0 output
bool boolean_name (true);
bool boolean_name {false};

back to top

Arithmetic Operators

python 2

• addition: +
• subtraction: -
• multiplication: *
• division: 3.0/2 # output 1.5, 3/2 output 1
• modulus: %
• exponent: **
• floor division: 3//2 # output 1

python 3

• division: 3/2 # output 1.5
• floor division: 3//2 # output 1

javascript

• addition: +
• subtraction: -
• multiplication: *
• division: 3/2 // output 1.5
• modulus: %
• exponent: **
• floor division: Math.floor(3/2) // output 1

ruby

• addition: +
• subtraction: -
• multiplication: *
• division: 3.0/2 # output 1.5, 3/2 output 1
• modulus: %
• exponent: **
• floor division: 3/2.floor

java

• addition: +
• subtraction: -
• multiplication: *
• division: double double_name = 3.0/2; // output 1.5, 3/2 output 1
• modulus: %
• exponent: Math.pow(3, 2); // output 9
• floor division: int integer_name = 3/2; // output 1

c#

• addition: +
• subtraction: -
• multiplication: *
• division: 3.0/2; // output 1.5, 3/2 output 1
• modulus: %
• exponent: Math.Pow(3, 2); // output 9
• floor division: 3/2; // output 1

c++

• addition: +
• subtraction: -
• multiplication: *
• division: double double_name = 3.0/2 // output 1.5, 3/2 output 1
• modulus: %
• exponent:
  • must add this to the top #include＜cmath＞
  • int integer_name = pow(3, 2); // output 9
• floor division: 3/2 // output 1

back to top

Comparison Operators

python 2 & 3

• == condition is True if both operand have equal contents

list1 = []
list2 = []
list1 == list2  # True

• is condition is True if both operand points to the same identical object

list1 = []
list2 = []
list1 is list2  # False

list1 = None
list2 = None
list1 is list2  # True

• != condition is True if both operand do not have equal contents
• is not condition is True if both operand do not points to the same identical object
• <> py2 only, condition is True if both operands do not equal contents
• > condition is True if right operand is less than left operand
• < condition is True if left operand is less than right operand
• >= condition is True if right operand is less than or equal to left operand
• <= condition is True is left operand is less than or equal to right operand

javascript

• == not type-safe, e.g.: string or int will be automatically converted before comparison, only checks the value

var x = 5;
x == 5; // is true
x == "5"; // is also true

• === string or int will NOT be converted before comparison, checks both the value and type
  • NaN and NaN comparison are not equal
  • +0 and -0 are equal

var x = 5;
x === 5; // is true
x === "5"; // is false

• Object.is(var1, var2); similar to ===
  • NaN and NaN comparison are equal
  • +0 and -0 are not equal
• !=
• !==
• >
• <
• >=
• <=
• ?? Nullish coalescing operator: returns right-hand side operand when left-hand side operand is null or undefined, and otherwise returns its left-hand side operand

const foo = null ?? "default string";
console.log(foo);
// expected output: "default string"

const baz = 0 ?? 42;
console.log(baz);
// expected output: 0

ruby

• ==
• !=
• >
• <
• >=
• <=
• <=> Combined Comparison Operator
• object1.equal?object2

string1 = "string"
string2 = "string"
string1 == string2  # returns true
string1.equal?string2  # returns false
string1.equal?string1  # returns true

num1 = 2
num2 = 5
puts num1 <=> num2  # -1
puts num2 <=> num1  # 1
num1 = 3
num2 = 3
puts num1 <=> num2 # 0

string1 = "b"  # looks at only the 1st letter, "bz" will not change the outcome, unless both strings start with the same 1st letter
string2 = "e"
puts string1 <=> string2  # -1
puts string2 <=> string1  # 1
string1 = "c"
string2 = "c"
puts string1 <=> string2  # 0

java

• ==
  • reference comparison

  String s1 = new String("string value");
  String s2 = new String("string value");
  System.out.println(s1 == s2);  // false

  • use equals method to compare string values

  String s1 = new String("string value");
  String s2 = new String("string value");
  System.out.println(s1.equals(s2));  // true

• !=
• >
• <
• >=
• <=
• instanceof class membership

String s = "Hello";
if (s instanceof java.lang.String) {
  System.out.println(true);
}

c#

• ==
• !=
• >
• <
• >=
• <=

c++

• ==
• !=
• >
• <
• >=
• <=

back to top

Logical Operators

python 2 & 3

• and
• or
• not

javascript

• && and
• || or
• ! not
• truthy and falsey examples
  • truthy1 && truthy2 truthy2
  • falsey && truthy falsey
  • truthy && falsey falsey
  • falsey1 && falsey2 falsey1
  • truthy1 || truthy2 truthy1
  • truthy || falsey truthy
  • falsey1 || falsey2 falsey2

ruby

• && and
• || or
• ! not

java

• && and
• || or
• ^ exclusive or
• ! not

c#

• && and
• || or
• ^ exclusive or
• ! not

c++

back to top

Getting Input

python 2

raw_input("What's your name?")

# input must be the same data type as xxx else return an error
input(xxx)

python 3

input("What's your name?")

javascript

// install readline-sync package locally via npm i readline-sync
var readlineSync = require("readline-sync"); // import package
var getInput = readlineSync.question("What's your name?");

ruby

# print question
print "What's your name?"
# get input
name = gets.chomp

java

• must import scanner library

import java.util.Scanner;

// print question
System.out.println("What's your name?");

// get raw input
Scanner scanner = new Scanner(System.in);
// convert raw value to string type
// can read the input only till the space
// It can't read two words separated by a space
// places the cursor in the same line after reading the input
String input = scanner.next();
// reads input including space between the words till the end of line \n
// Once the input is read, positions the cursor in the next line
String input1 = scanner.nextLine();
// convert raw value to int type
Int input2 = scanner.nextInt();

c#

// print question
System.Console.WriteLine("What's your name?");
// get input
string name = System.Console.ReadLine();

c++

back to top

Bitwise Operators

python 2 & 3

# Each digit is 1 bit, all bitwise operators converts to signed 32-bit integers, except for zero-fill right shift which results to unsigned 32 bit integer
a = 60  # 60 = ...0011 1100
b = 13  # 13 = ...0000 1101
c = 9  # 9 = ...0000 1001
# & is binary AND, return 1 if both a and b are 1
a & b  # 12 = ...0000 1100

# | is binary OR, return 1 if either a and or b HAVE a 1
a | b  # 61 = ...0011 1101

# ^ is binary XOR, return 1 if both a and b are not 1 or 0
a ^ b  # 49 = ...0011 0001

# ~ is binary ones complement, invert everything, 1 change to 0 and vice versa
~a  # -61 = ...1100 0011

# << is binary left shift, shift everything to the left by n digit(s)
a << 2  # 240 = ...1111 0000

# >> is binary right shift, shift everything to the right by n digit(s)
a >> 2  # 15 = ...0000 1111
c >> 2  # 3 = ...0000 0010, count the 1s
c = -9  # -9 = ...1111 0111
c >> 2  # -3 = ...1111 1101, count the 0s

# Zero fill right shift, shift everything to the right by n digits(s), leftmost will add n 0s
def zero_fill_right_shift(val, n):
    return (val >> n) if val >= 0 else ((val + 0x100000000) >> n)
zero_fill_right_shift(9, 2)  # 2 = ...0000 0010, count the 1s
c = -9  # -9 = ...1111 0111
zero_fill_right_shift(-9, 2)  # 1073741821 = 0011...1111 1101, count the 0s

javascript

// Each digit is 1 bit, all bitwise operators converts to signed 32-bit integers, except for zero-fill right shift which results to unsigned 32 bit integer
let a = 60; // 60 = ...0011 1100
let b = 13; // 13 = ...0000 1101
let c = 9; // 9 = ...0000 1001
// & is binary AND, return 1 if both a and b are 1, count the 1s
a & b; // 12 = ...0000 1100

// | is binary OR, return 1 if either a and or b HAVE a 1
a | b; // 61 = ...0011 1101

// ^ is binary XOR, return 1 if both a and b are not 1 or 0
a ^ b; // 49 = ...0011 0001

// ~ is binary ones complement, invert everything, 1 change to 0 and vice versa, count the 0s
~a; // -61 = ...1100 0011

// << is binary left shift, shift everything to the left by n digit(s)
a << 2; // 240 = ...1111 0000

// >> is Sign-propagating right shift, a binary right shift, shift everything to the right by n digit(s)
a >> 2; // 15 = ...0000 1111
c >> 2; // 3 = ...0000 0010, count the 1s
c = -9; // -9 = ...1111 0111
c >> 2; // -3 = ...1111 1101, count the 0s

// >>> is Zero fill right shift, shift everything to the right by n digits(s), leftmost will add n 0s
c >>> 2; // 2 = ...0000 0010, count the 1s
c = -9; // -9 = ...1111 0111
c >>> 2; // 1073741821 = 0011...1111 1101, count the 0s

ruby

java

// & is binary AND, return 1 if both a and b are 1, count the 1s
a & b  // 12 = ...0000 1100

// | is binary OR, return 1 if either a and or b HAVE a 1
a | b  // 61 = ...0011 1101

// ^ is binary XOR, return 1 if both a and b are not 1 or 0
a ^ b  // 49 = ...0011 0001

// ~ is binary ones complement, invert everything, 1 change to 0 and vice versa, count the 0s
~a  // -61 = ...1100 0011

// << is binary left shift, shift everything to the left by n digit(s)
a << 2  // 240 = ...1111 0000

// >> is Sign-propagating right shift, a binary right shift, shift everything to the right by n digit(s)
a >> 2  // 15 = ...0000 1111
c >> 2  // 3 = ...0000 0010, count the 1s
c = -9  // -9 = ...1111 0111
c >> 2  // -3 = ...1111 1101, count the 0s

// >>> is Zero fill right shift, shift everything to the right by n digits(s), leftmost will add n 0s
c >>> 2  // 2 = ...0000 0010, count the 1s
c = -9  // -9 = ...1111 0111
c >>> 2  // 1073741821 = 0011...1111 1101, count the 0s

c#

// & is binary AND, return 1 if both a and b are 1, count the 1s
a & b  // 12 = ...0000 1100

// | is binary OR, return 1 if either a and or b HAVE a 1
a | b  // 61 = ...0011 1101

c++

back to top

Increment

python 2 & 3

• x = x + 1 increment
• x += 1

javascript

• x = x + 1; add 1 now
• x += 1; add 1 now
• ++x; preincrement, add 1 now
• x++; postincrement, display without addition now then add 1 later when called again

ruby

• x = x + 1 increment
• x += 1

java

• x = x + 1;
• x += 1;
• ++x; preincrement, add 1 now
• x++; postincrement, display without addition now then add 1 later when called again

c#

• x = x + 1;
• x += 1;
• ++x; preincrement, add 1 now
• x++; postincrement, display without addition now then add 1 later when called again

c++

• x = x + 1;
• x += 1;
• ++x; preincrement, add 1 now
• x++; postincrement, display without addition now then add 1 later when called again

back to top

Arrays and Lists

python 2 & 3

# Empty list
list_name = []
# List with elements
list_name = [1, "one", True]
# Nested lists
list_name = [1, ["two", 3]]


# Find list size
len(list_name)


# Get index of element, return ValueError if element does not exist
list_name.index(element)


# Add element to list (left to right)
list_name.append(element)

# Add element to list at index
list_name.insert(index, element)

# Extends list by appending elements from the iterable
list_name = [1, 2]
list_name.extend([3, 4])  # [1, 2, 3, 4]


# Access an element
list_name[index]

# Modify an element
list_name[index] = element


# Remove element from list (right to left)
list_name.pop()

# Remove element from list at index
list_name.pop(index)

# Remove any element from list at element
list_name.remove(element)

# Method 1: remove all elements
del list_name[:]
# Method 2: remove all elements
list_name = []
# Method 3: remove all elements, only in python 3
list_name.clear()


Slice notation
# items start through stop-1
list_name[start:stop]

# items start through the rest of the array
list_name[start:]

# items from the beginning through stop-1
list_name[:stop]

# a copy of the whole array
list_name[:]

# start through not past stop, by step
list_name[start:stop:step]
list_name = [1, 2, 3, 4, 5]
list_name[::2]  # [1, 3, 5]

# last item in the array
list_name[-1]

# last two items in the array
list_name[-2:]

# everything except the last two items
list_name[:-2]

# all items in the array, reversed
list_name[::-1]

# the first two items, reversed
list_name[1::-1]

# the last two items, reversed
list_name[:-3:-1]

# everything except the last two items, reversed
list_name[-3::-1]


# Reverse an array
list_name.reverse()


# Merge 2 or more arrays together
new_list = list_name + list_name2


# Sort an array in ascending order
list_name = [2, 3, 1, 4]
# method 1
list_name2 = sorted(list_name)  # [1, 2, 3, 4]
# method 2
list_name.sort()  # [1, 2, 3, 4]

# sort an array of dictionaries in ascending order
dict_name = [{"key_name": value1}, {"key_name": value2}]
# sort by value
dict_name2 = sorted(dict_name, key=lambda k: k["key_name"])


# Sort an array in descending order
# method 1
list_name2 = sorted(list_name2, reverse=True)  # [4, 3, 2, 1]
# method 2
list_name.sort(reverse=True)  # [4, 3, 2, 1]

# sort an array of dictionaries in descending order
# sort by value
dict_name2 = sorted(dict_name, key=lambda k: k["key_name"], reverse=True)

# Join array into a string
list_name = ["a", "b", "c"]
x = ", ".join(list_name)
print(x)  # "a, b, c"

# Split string into an array
y = x.split(", ")
print(y)  # ['a', 'b', 'c']

javascript

// Method 1: empty list
var list_name = [];
// Method 2: empty list
var list_name = new Array();
// create list of empty elements
var list_name = new Array(3); // [undefined, undefined, undefined]
var list_name = Array.from({ length: 3});  // [undefined, undefined, undefined]
// List with elements
var list_name = [1, "one", true];
var list_name = new Array(3).fill("-") // ["-", "-", "-"]
// Nested lists
var list_name = [1, ["two", 3]];
var list_name = new Array(3).fill(new Array(2).fill("-")) // [["-", "-"], ["-", "-"], ["-", "-"]]


// Modify an element
list_name[index] = element;

// Access an element
list_name[index];


// Remove element from list (right to left)
list_name.pop();
// Remove element from list (left to right)
list_name.shift();
// Remove number of elements (left to right) from index and insert new elements (left to right)
list_name.splice(index, number_of_element);


// Add element to list (left to right)
list_name.push(element);
// Add element to list (right to left)
list_name.unshift(element);
// Add element to list at index (left to right)
list_name.splice(index, 0, new_element1, new_element2...);
// Add & Remove elements to & from list at index (left to right)
list_name.splice(index, number_of_element, new_element1, new_element2...);


// Return the selected elements in an array, as a new array object
list_name.slice();
// Return the elements starting at the given 1st argument,
// and ends at, but does not include, the given 2nd argument
list_name.slice(1, 3);
list_name.slice(1);  // if 1 argument is given, return all elements from array from the 1st argument index


// Find list size
list_name.length;
// Remove all elements
list_name = [];


// Merge 2 or more arrays together
list_name1 = [1, 2, 3];
list_name2 = [4, 5, 6];
new_list = list_name1.concat(list_name2);


// Get index of element, return -1 if not present
list_name = ["element1", "element2", "element1"]
list_name.indexOf("element1")  // returns index of 0
list_name.indexOf("element1", 1);  // returns index of 2
list_name.indexOf("element1", 2);  // also returns index of 2
list_name.indexOf("element1", 0);  // returns index of 0


// Sort array in ascending order
list_name = [2, 3, 1, 4];
list_name.sort();  // [1, 2, 3, 4]  work only only positive integers and strings

list_name = [2, -1, 4, 3];
list_name.sort((a, b) => a - b);  // [ -1, 2, 3, 4 ] work for negative and positive integers

// Sort array in descending order
list_name.sort((a, b) => (b - a));  // [4, 3, 2, 1] work for negative and positive integers
list_nameStr = ["b", "a", "c"];
// method 1: most optimal
list_nameStr.sort().reverse(); // ["c", "b", "a"]
// method 2
list_nameStr.sort((a, b) => (a > b ? -1 : 1));
// method 3
list_nameStr.sort((a, b) => b.localeCompare(a));


// Determine whether an array contains a specified element
list_name = ["a", "b", "c", "a"]
console.log(list_name.includes("b"))  // true

// Determine whether an array contains a specified element from starting index
console.log(list_name.includes("b", 2)  // false
console.log(list_name.includes("a", 2)  // true

// Flatten nested arrays
list_name = [1, 2, [3, 4]];
list_name.flat() // [1, 2, 3, 4]

// Check if all elements in array pass the conditional check
function helper(currentValue) {
 return currentValue < 3;
}
list_name = [1, 2, 3, 4];
list_name.every(helper); // false
list_name = [1, 2];
list_name.every(helper); // true

typescript

// method 1
let numArr: number[] = [1, 2, 3];
let strArr: string[] = ["a", "bc", "def"];

// method 2
let numArr2: Array<number> = [1, 2, 3];
let strArr2: Array<string> = ["a", "bc", "def"];

// declare more than 1 type
// with tuples
let strOrNumArr1: [string, number] = ["a", 1]; // must follow and limited to declared format
// with union
let strOrNumArr2: (string | number)[]; // allows unlimited mixture of number and/or string values in 1 array

ruby

# Empty list
list_name = []  # method 1
list_name = Array.new  # method 2
# List with elements
list_name = [1, "one", True]
list_name = Array.new(3)  # creates 3 slots of nil in array [nil, nil, nil]
list_name = Array.new(3, "new")  # creates 3 slots of object in array ["new", "new", "new"]
# Nested lists
list_name = [1, ["two", 3]]

# join elements in array at index into a string (to join all elements, all indexes must be listed)
list_name.values_at(0, 1).join(", ")  # "1, two, 3"

# join all elements in array into a string
list_name.join(", ")  # "1, two, 3"

# Add element to list (left to right)
# method 1
list_name.push(element);
# method 2
list_name << element;

# Add element to list (right to left)
list_name.unshift("new")  # ["new", 1, ["two", 3]]

# delete element from list (right to left)
list_name.pop()  # ["new", 1]

# delete element from list (left to right)
list_name.shift()  # [1]

# concat 2 arrays
# method 1
[1] + [2]  # [1, 2]
# method 2
[1].concat([2])  # [1, 2]

# find length of array
[1, 2].size  # 2

# check if element exist in array
[1, 2].include?(1)  # true

# count how many similar elements are in the array
[1, 2, 1].count(1)  # 2

# check if array is empty
[1, 2].empty?  # false

# Add 0 to 10 to an array
(0..10).to_a  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Add 0 to 10 excluding 10 to an array
(0...10).to_a  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Access an elment
list_name[index]

# Sort an array in ascending
list_name = [3, 4, 1, 2]
# method 1
list_name1 = list_name.sort  # [1, 2, 3, 4]
# method 2
list_name.sort!  # [1, 2, 3, 4]
# Reverse sort an array, only works on already sorted array
# arrays that are not sorted will be reversed without sorting
# method 1 (modify list_name temporarily)
list_name1 = list_name.reverse  # [4, 3, 2, 1]
# method 2 (directly modify list_name)
list_name.reverse!

# Modifies every value in an array
# (modify list_name temporarily)
# method 1
list_name2 = list_name.collect {|num| num * 2}  # [8, 6, 4, 2]
# method 2
list_name2 = list_name.map {|num| num * 2}  # [8, 6, 4, 2]
# (directly modify list_name)
# method 1
list_name.collect! {|num| num * 2}  # [8, 6, 4, 2]
# method 2
list_name.map! {|num| num / 2}  # [4, 3, 2, 1]

java

// Arrays: can only have 1 data type: string, int, etc.
// printing this only shows the memory
// Empty string array of desired array size
String[] string_array = new String[length_of_desired_array];
// New string array with elements inside
String [] string_array = new String [] {string1, string2,...};  // Method 1
String[] string_array = {string1, string2,...};  // Method 2

// Add string array element, limited to array size
// Modify string array element value
string_array[index] = element;

// Access an element
string_array[index];

// Find array size
string_array.length;

// Sort array, can sort numbers, strings, etc.
// must import
// import java.util.Arrays;
String[] sourceArr = {"orange", "apple", "pear"};
Arrays.sort(sourceArr);  // {"apple", "orange", "pear"}

// Copy array
int sourceArrStartingIndex = 1;
int destinationArrStartingIndex = 0;
int copiedArrLen = 2;
String[] copiedArr = new String[copiedArrLen];
System.arraycopy(sourceArr, sourceArrStartingIndex, copiedArr, destinationArrStartingIndex, copiedArrLen);  // {"apple", "pear"}

// multidimensional array
String[][] states = new String[3][2];
states[0][0] = "Japan";
states[0][1] = "Tokyo";


// Arraylists: it is a class, extends the AbstractList class and implements List interface
// can be instantiated
// used to create a dynamic array that contains objects
// creates an array of objects where the array can grow dynamically
// can only have 1 data type: string, int, etc.
// import java.util.ArrayList;  // Must import to use

// Empty string arrayList
ArrayList<String> arrayList = new ArrayList<String>();

// Add element to string arrayList (left to right)
arrayList.add(element);

// Modify an element at index
arrayList.set(index, element);

// Access an element
arrayList.get(index);

// Remove element from arrayList at index
arrayList.remove(index);

// Find arrayList size
arrayList.size();

// Remove all elements
arrayList.clear();


// List: it is an interface, extends the Collection framework
// cannot be instantiated
// used to create a list of elements(objects) which are associated with their index numbers
// creates a collection of elements that are stored in a sequence and they are identified and accessed using the index
// print this shows the actual array
// import java.util.List;  // must import to use
// import java.util.ArrayList;  // Must import to use
List<String> list = new ArrayList<>();  // from java 7 onwards redundent <String> is not required, can just use <>

// Add element to string List (left to right)
list.add(element);

// Remove element from list at index
list.remove(index);

// Access an element
list.get(index);

// Find index of an element
list.indexOf(element);

c#

• Arrays: can only have 1 data type: string, int, etc. (size cannot be modified after declaration)

// Empty string array of desired array size
string[] stringArray = new string[lengthOfDesiredArray];
// New string array with elements inside
string [] stringArray2 = new string [] {string1, string2, ...};  // Method 1, size is determined by number of elements declared
string [] stringArray2 = new string [2] {string1, string2};  // Method 2, size is determined by the array size declared
string[] stringArray3 = {string1, string2, ...};  // Method 3, size is determined by number of elements declared
string[] stringArray5 = new[] {string1, string2, ...};  // Method 4
var stringArray6 = new[] {string1, string2, ...};  // Method 5, use var to auto determine data type

// Multi-dimensional Rectangular Arrays
int[] rectArray = new int[3, 5];
int[] rectArray2 = new int[3, 5] {
  {1, 2, 3, 4, 5},
  {6, 7, 8, 9, 10},
  {11, 12, 13, 14, 15}
};

// Multi-dimensional Jagged Arrays
int[] jaggedArray = new int[3][];  // create an array of 3 empty arrays
jaggedArray[0] = new int[4];  // create an array of size 4
jaggedArray[1] = new int[5];  // create an array of size 5
jaggedArray[2] = new int[3];  // create an array of size 3

// Add string array element, limited to array size
// Modify string array element value
stringArray[index] = element;


// Access an element
stringArray[index];
rectArray2[index1, index2];
jaggedArray[0][0];


// Find array size
string[] strArr = {"a", "b", "c"};
strArr.Length;  // 3


// Find index of an element in an array
string element = "a";
int index = System.Array.IndexOf(strArr, element);  // 0


// Clear the element in the array (0 for int, false for bool, null for other objects), exclude the endIndex value
int startIndex = 0;
int endIndex = 1;
System.Array.Clear(strArr, startIndex, endIndex);


// Copy the elements into a new array
int firstFewElem = 3;
string[] copiedStrArr = new string[3];
System.Array.Copy(strArr, copiedStrArr, firstFewElem);


// Sort (ascending order)
System.Array.Sort(strArr);


// Reverse (only works on sorted arrays)
System.Array.Reverse(strArr);  // ["c", "b", "a"]
System.Array.Reverse(strArr);  // ["a", "b", "c"]


// Join elements of an array into a string
System.String.Join("", strArr);  // "abc"
System.String.Join(",", strArr);  // "a,b,c"

• List (dynamic array)

// Empty int array of desired array size
System.Collections.Generic.List<int> intList = new System.Collections.Generic.List<int>();  // empty list
System.Collections.Generic.List<int> intList2 = new System.Collections.Generic.List<int>() {1, 2, 3, 4};  // list with values
// import to write less code when declaring
using System.Collections.Generic;
List<int> intList3 = new List<int>();  // empty list
List<int> intList4 = new List<int>() {1, 2, 3, 4};  // list with values


// Add 1 new element to the list (left to right)
intList4.Add(5);  // [1, 2, 3, 4, 5]

// Add a range of elements to the list with an array
intList4.AddRange(new int[3] {6, 7, 8});  // [1, 2, 3, 4, 5, 6, 7, 8]


// Find index of an element in a list (return -1 if element is not found)
intList4.IndexOf(2);  // 1

// Find last index of elements with similar values in a list
int[] intList5 = new List<int>() {1, 2, 1, 3};
intList5.LastIndexOf(1);  // 2


// Get length of list
intList4.Count;  // 8


// Remove an element at element in list
intList4.Remove(2);  // [1, 3, 4, 5, 6, 7, 8]


// Remove an element at index of list
intList4.RemoveAt(0);  // [3, 4, 5, 6, 7, 8]


// Remove all elements from the list
intList4.Clear();  // [];

• ArrayList (dynamic list of multiple data types, does not offer the best performance)

// Empty array list
System.Collections.ArrayList list = new System.Collections.ArrayList();  // empty list


// Add 1 new element to the list (left to right)
list.Add(1);  // [1]
list.Add("abc")  // [1, "abc"]

// methods are similar to List

c++

// Arrays
// Empty int array of desired array size
int int_array[length_of_desired_array];
// New int array with elements inside
int int_array [length_of_desired_array] {element1, element2,...};  // size declared
int int_array[] = {element1, element2,...};  // size automatically calculated

// Assign int element, limited to array size
// Modify int element value
int_array[index] = element;

// Access an element
int_array[index];

// Find array size: size of array (bytes) / size of an element of an array (bytes)
sizeof(int_array) / sizeof(int_array[0]);


// Vectors: a type of dynamic array
#include <vector>  // Must import to use

// Empty int vector of desired vector size, each element of 0 value will automatically be included
std::vector <int> int_vector (length_of_desired_array);
// New int vector with elements inside
std::vector <int> int_vector {element1, element2,...};
// New int vector with length of desired array and all value in parameter
// Method 1
std::vector <int> int_vector (length_of_desired_array, constant_value_for_all_elements);
// Method 2
std::vector <int> int_vector;
int_vector.assign(length_of_desired_array, constant_value_for_all_elements);

// Assign int element
int_vector[index] = element;

// Access an element
int_vector[index];
int_vector.at(index);

// Add element to vector (left to right), vector size will automatically increase
int_vector.push_back(element);
// Add element to vector at index
std::vector<int>::iterator it;  // Must create iterator for inserting or emplacing to work
it = int_vector.begin()  // Set it at index 0
// insert method: copies or moves the elements into the container by calling copy constructor or move constructor
int_vector.insert(it + index, element);  // Add element at index
// emplace method: elements are constructed in place, no copy or move operations are performed (better performance)
int_vector.emplace(it + index, element);  // Add element at index

// Remove element from vector at index
std::vector<int>::iterator it;  // Must create iterator for erase to work
it = int_vector.begin()  // Set it at index 0
int_vector.erase(it + index)  // Remove element at index
int_vector.erase(it + index, it + index)  // Remove a range of elements in the vector
// Remove element from vector (right to left)
int_vector.pop_back();  // does not return value

// Find vector size
int_vector.size();

// Resize vector
int_vector.resize(length_of_desired_array);

// Remove all elements
int_vector.clear();

back to top

Conditional Statement

python 2 & 3

# If else statement
if condition_a:
    do_A
elif condition_b:
    do_B
else:
    do_something_else


# Ternary operator
do_A if condition_a else do_B


# Switch Statement is not available in python, but can create similar function
def switch(choice):
    case = {
        1: do_A,
        2: do_B,
    }
    case.get(choice, do_something_else)


# comparing between 2 objects (array, dictionaries, etc.) is allowed
x = [1, 2, 3]
y = [1, 2, 3]
x == y  # returns True

javascript

// If else statement
if (condition_a) {
  do_A;
} else if (condition_b) {
  do_B;
} else {
  do_something_else;
}

// Ternary operator
condition_a ? do_A : do_B;

// Switch statement
switch (choice) {
  case choice_A:
    do_A;
    break;
  case choice_B:
    do_B;
    break;
  default:
    do_something_else;
}

// comparing between 2 objects (array, object, etc.) is NOT allowed
var x = [1, 2, 3];
var y = [1, 2, 3];
x === y ? true : false; // returns false
// solution: use JSON.stringify()
JSON.stringify(x) === JSON.stringify(y) ? true : false; // return true

ruby

# If else statement
if condition_a
    do_A
elsif condition_b
    do_B
else
    do_something_else
end


# Unless statement
condition_variable = boolValue
do_A unless condition_variable

# Unless else statement
# Check if something is false
unless condition_a
    do_A
else
    do_something_else
end


# check if a string exist in a string
if word.include? alphabet
    do_something
end


# check if value is nil, if not nil return false
object.nil?  # if object != nil returns false, else returns true

# check if array, hash, set, string is empty, return true if empty else false
object.empty?  # if object == [] or {} or "" or Set.new, return true


# Ternary operator
condition_a ? (do_A) : (do_B);
# example 1
puts true ? "yes" : "no"
# example 2
true ? (puts "yes") : (puts "no")

# Simpler if
do_A if condition_a

# One line Unless
do_A unless condition_a  # do_A if condition_a is false


# Case expression (similar to switch statement)
case choice
when choice_A:
    do_A;
when choice_B:
    do_B;
else
    do_something_else
end


# Conditional Assignment: assign only if variable is nil
favorite_book = nil
favorite_book ||= "book 1"
puts favorite_book # "book 1"
favorite_book ||= "book 2"
puts favorite_book # "book 1"

java

// If else statement
if (condition_a) {
    do_A;
} else if (condition_b) {
    do_B;
} else {
    do_something_else;
}


// {} not required if statement is a single line
if (condition_a)
    do_A;  // Single line statement
else if (condition_b)
    do_B;  // Single line statement
else
    do_something_else;  // Single line statement


// Ternary operator
condition_a ? do_A : do_B;

//Using Boolean Value for Return:
boolean result = condition_a ? true : false;


// Switch statement
switch(choice) {  // choice value can only be primitive values in java 7, since java 8 strings are also accepted
    case choice_A:
        do_A;
        break;
    case choice_B:
        do_B;
        break;
    default:
        do_something_else;
        break;  // not required, but good to have in Java
}

c#

// If else statement
if (condition_a) {
    do_A;
} else if (condition_b) {
    do_B;
} else {
    do_something_else;
}


// Ternary operator
condition_a ? do_A : do_B;


// Switch statement
switch(choice) {
  case choiceA:
    doA;
    break;
  case choiceB:
    doB;
    goto doSomethingSpecial;  // go to a special case that is written outside the switch statement and run it (not advised to use it
  default:
    do_something_else;
    break;
}

doSomethingSpecial:
  doingSomething;

c++

// If else statement
if (condition_a) {
    do_A;
} else if (condition_b) {
    do_B;
} else {
    do_something_else;
}


// {} not required if statement is a single line
if (condition_a)
    do_A;  // Single line statement
else if (condition_b)
    do_B;  // Single line statement
else
    do_something_else;  // Single line statement


// Ternary operator
condition_a ? do_A : do_B;


// Null coalescing operator
return_this_variable_value_if_not_null ?? else_return_this_value


// Switch statement
switch(choice) {
    case choice_A:
        do_A;
        break;
    case choice_B:
        do_B;
        break;
    default:
        do_something_else;
}

back to top

Loops

python 2

# While loop
# declare_initial_conditional_value
i = 0
# Set condition
while i<5:  # Start from 0 to 4
    do_this
    # Include condition_increment_or_decrement
    i += 1
    # Can use break, continue, and pass statements to add additional functionality, or not use any
    break  # Breaks out of the current closest enclosing loop
    continue  # Goes to the top of the closest enclosing loop
    pass  # Does nothing at all


# For loop
# range() creates a list in python 2
# Looping with xrange()
for i in xrange(5):  # Starts from 0 to 4 (5 - 1)
    do_this
    # Can use break, continue, and pass statements to add additional functionality, or not use any
    break  # Breaks out of the current closest enclosing loop
    continue  # Goes to the top of the closest enclosing loop
    pass  # Does nothing at all

# Looping with xrange() and multiple parameters
for i in xrange(0, 5, 2):  # Start from 0 to 4 at every 2 steps (0,2,4)
    do_this

# Reverse loop
for i in xrange(4, -1, -1):  # Start from 4 to 0 at every -1 steps
    do_this


# Looping and getting each value
for value in list_name:  # [i1_value, i2_value, i3_value,...]
    print value


# Looping and getting index and value
for index, value in enumerate(list_name):
    print index, value  # output index, value

python 3

# For loop
# Looping with range()
for i in range(5):  # Starts from 0 to (5 - 1)
    do_this
    # Can use break, continue, and pass statements to add additional functionality, or not use any
    break  # Breaks out of the current closest enclosing loop
    continue  # Goes to the top of the closest enclosing loop
    pass  # Does nothing at all

# Looping with range() and multiple parameters
for i in range(0, 5, 2):  # Start from 0 to 4 at every 2 steps (0,2,4)
    do_this

# Reverse loop
for i in range(4, -1, -1):  # Start from 4 to 0 at every -1 steps
    do_this


# Looping and getting each value
for value in list_name:  # [value1, value2, value3,...]
    print(value)


# Looping and getting index and value
for index, value in enumerate(list_name):
    print(index, value)  # output index, value


# Loops and getting both key and value of a dict
x = { "one": 1, "two": 2}
for k, v in x.items():
    print(f"k: {k}, v: {v}")

javascript ES5

// While loop
// declare_initial_conditional_value
var i = 0;
// Set condition
while (i < 5) {
  // Start from 0 to 4
  do_this;
  // Include condition_increment_or_decrement;
  i++;
  // Can use break or continue to add additional functionality, or not use any
  break; // Breaks out of the current closest enclosing loop
  continue; // Goes to the top of the closest enclosing loop
}

// Do While loop
var i = 0;
do {
  do_this;
  i++;
} while (i < 5);

// For loop
for (var i = 0; i < 5; i++) {
  // Start from 0 to 4
  do_this;
  // Can use break or continue to add additional functionality, or not use any
  break; // Breaks out of the current closest enclosing loop
  continue; // Goes to the top of the closest enclosing loop
}

// Reverse loop
for (var i = 4; i >= 0; i--) {
  // Start from 4 to 0
  do_this;
}

// forEach loop
// Looping through a list while calling a function
list_name.forEach(function (value, index, list) {
  // do not need to include all 3 parameters, but must be in order
  console.log(index, value, list); // outputs index value list
});

javascript ES6: Use let in loops when declaring

// For of loop
// Looping and getting each value
for (let value of list_name) {
  // [value1, value2, value3,...]
  console.log(value); // output value
}
// Looping and getting index and value
for (let index_and_value of list_name.entries()) {
  console.log(index_and_value); // output a list [index, value]
}

// For in loop
for (let index in list_name) {
  console.log(list_name[index]);
}
// For in loop normally used to get values from objects (hash table, dictionaries) than to arrays
// object = {key1:value1, key2:value2,...}
for (let key in object) {
  console.log(object[key]); // outputs value, normally calling this way will not output value from objects
}

ruby

# While loop
# declare_initial_conditional_value
i = 0
# Set condition
while i<5 do  # Start from 0 to 4, do keyword is not mandatory
    do_this
    # Include condition_increment_or_decrement
    i += 1
end

# Until loop, backward while loop
i = 0
until i == 4  # Start from 0 to 4
    i += 1
end

# For loop, with ... (3 dots)
for i in numStart...numEnd  # for i in the range numStart up to but don't include numEnd
    do_this
end

# For loop, with .. (2 dots)
for i in numStart..numEnd  ## for i in the range numStart up to and include numEnd
    dot_this
end

# Loop method, an infinite loop, requireds break to stop loop
i = 4
loop do
    i -= 1
    break if i ==0  # Breaks out of the current closest enclosing loop
end

# Next keyword: used to skip over certain steps in loop
for i in 0...5
    next if i % 2 == 0   # do not do anything if i is an even number
    do_this
end

# Each Iterator
array = [1, 2, 3, 4, 5]
array2 = []
array.each { |value|  # Method 1: using {}
    value += 10
    array2.push(value)
}
puts array2  # [11, 12, 13, 14, 15]

array3 = []
array2.each do |value|  # Method 2: using do keyword
    value -= 10
    array3.push(value)
end
puts array3  # [1, 2, 3, 4, 5]

# Iterating over Multidimensional Arrays with Each Iterator
multiArray = [[1, 2], [3, 4], [5, 6]]
multiArray.each {
    |sub_array| sub_array.each {
        |value| do_something
    }
}

# Times Iterator
n.times { do_this }  # do_this will repeat n times

# Upto Iterator
# method 1: number
0.upto(5) { |num| print num, " " }  # 0 1 2 3 4 5
# method 2: alphabet
"A".upto("D") { |letter| prints letter, " " }  # A B C D

# Downto Iterator, "string" don't work
100.downto(95) { |num| print num, " " }  # 100 99 98 97 96 95

java

// While loop
// declare_initial_conditional_value
int i = 0;
// Set condition
while (i<5) {  // Start from 0 to 4
    doThis;
    // Include condition_increment_or_decrement;
    i++;
    // Can use break or continue to add additional functionality, or not use any
    break;  // Breaks out of the current closest enclosing loop
    continue;  // Goes to the top of the closest enclosing loop
}

// Do while loop: execute first before setting conditions
// declare_initial_conditional_value
int i = 0;
do {  // Start from 0 to 4
    doThis;
    // Include condition_increment_or_decrement;
    i++;
// Set condition
} while (i<5);

// For loop
for (int i=0; i<5; i++) {  // Start from 0 to 4
    doThis;
    // Can use break or continue to add additional functionality, or not use any
    break;  // Breaks out of the current closest enclosing loop
    continue;  // Goes to the top of the closest enclosing loop
}
// Reverse loop
for (int i=4; i>=0; i--) {  // Start from 4 to 0
    doThis;
}

// for each loop, can also loop collections with iterators
char[] chars = {'H', 'e', 'l', 'l', 'o'};  // an array can only have a single data type
for (char c : chars) {  // for each element in the array
  doThis;
}


// some more methods of implementing loops in java while dealing with arrays
int [] arr={1,2,3,4,5};
for(int num:arr)
{
  System.out.println(num);
}

c#

// While loop
// declare_initial_conditional_value
int i = 0;
// Set condition
while (i<5) {  // Start from 0 to 4
  do_this;
  // Include condition_increment_or_decrement;
  i++;
  // Can use break or continue to add additional functionality, or not use any
  break;  // Breaks out of the current closest enclosing loop
  continue;  // Goes to the top of the closest enclosing loop
}


// Do while loop: execute first before setting conditions
// declare_initial_conditional_value
int i = 0;
do {  // Start from 0 to 4
  do_this;
  // Include condition_increment_or_decrement;
  i++;
// Set condition
} while (i<5);


// For loop
for (int i=0; i<5; i++) {  // Start from 0 to 4
  do_this;
  // Can use break or continue to add additional functionality, or not use any
  break;  // Breaks out of the current closest enclosing loop
  continue;  // Goes to the top of the closest enclosing loop
}
// Reverse loop
for (int i=4; i>=0; i--) {  // Start from 4 to 0
  do_this;
}


// For each loop: cycles through every item in an array or collection (List)
// Modifications of an array or collection is not allowed, need to use normal loops
string stringName = "a random string of characters";

foreach(char c in stringName) {
  do_this;
}

c++

// While loop
// declare_initial_conditional_value
int i = 0;
// Set condition
while (i<5) {  // Start from 0 to 4
    do_this;
    // Include condition_increment_or_decrement;
    i++;
    // Can use break or continue to add additional functionality, or not use any
    break;  // Breaks out of the current closest enclosing loop
    continue;  // Goes to the top of the closest enclosing loop
}

// Do while loop: execute first before setting conditions
// declare_initial_conditional_value
int i = 0;
do {  // Start from 0 to 4
    do_this;
    // Include condition_increment_or_decrement;
    i++;
// Set condition
} while (i<5);

// For loop
for (int i=0; i<5; i++) {  // Start from 0 to 4
    do_this;
    // Can use break or continue to add additional functionality, or not use any
    break;  // Breaks out of the current closest enclosing loop
    continue;  // Goes to the top of the closest enclosing loop
}
// Reverse loop
for (int i=4; i>=0; i--) {  // Start from 4 to 0
    do_this;
}

// Range-based for loop
// Looping and getting each value
for (int value : int_array) {
    cout << value << endl;  // output value per line
}
// Use auto to automatically detect array data type
for (auto value : array_name) {
    cout  << value << endl;
}

// Infinite for loops
for (;;)
    cout << "This will print forever" << endl;

back to top

Instantiation

python 2 & 3

t = Thing()  # everything

javascript

v = getValue(); // plain function
t = new Thing(); // instantiation

ruby

t = thing.new  # instantiation
t = thing.new(argument)  # instantiation with arguments

java

public class ClassName {
  public String type;  // instance variable

  public static void main(String[] args) {
    ClassName t = new ClassName();  // instantiation
    t.type = "something";
    t.display();

    doSomething();  // can call static method directly
  }

  // instance method

  //Instance methods are functions that belong to a specific object or instance of a class. Imagine a class as a blueprint for creating objects, and instance methods are actions that these objects can perform.


  private void display() {}

  // static method
  //Static methods are functions defined within a class that are associated with the class itself, rather than any specific instance of the class. This means you can call a static method without creating an object.

  // PRO TIP: Avoid using static methods when security is a primary concern as without object creation manipulating the data is possible



  static void doSomething() {}
}

c#

// method 1
ClassName t = new ClassName();  // instantiation
ClassName t = new ClassName(argument);  // instantiation with arguments
// method 2
var t = new ClassName();  // instantiation
var t = new ClassName(argument);  // instantiation with arguments


public class Person {
  public int Age;
}

public class Program {
  public static void Main() {
    Person person = new Person() {Age=20};  // instantiation & assigning value
    increment(person);
    System.Console.WriteLine(person.Age);
  }

  public static void increment(Person person) {
    person.Age += 10;
  }
}

c++

back to top

Functions

python 2 & 3

• Function returns None by default if return statement is not declared

# Normal function, use return to return values
def myFunction():
    do_something

# Normal function with parameters
def myFunction(a):
    do_something_with_a

# Default parameters
def myFunction(a=value):
    do_something_with_a

# Lambda function: a small anonymous function
# can take any number of arguments, but can only have 1 expression
myFunction = lambda a : do_something_with_a
myFunction = lambda a, b : do_something_with_a_and_b

# Function annotation (python 3)
def get_sum(num1: int, num2: int):
    return num1 + num2

# Function annotation with default parameters (python 3)
def get_sum(num1: int=1, num2: int=2):
    return num1 + num2

javascript ES5

• Function returns undefined by default if return statement is not declared

// Normal function, use return to return values
function myFunction() {
  do_something;
}
// Normal function with parameters
function myFunction(a) {
  do_something_with_a;
}

// Function expression
let myFunction = function () {
  do_something;
};
// Function expression with parameters
let myFunction = function (a) {
  do_something_with_a;
};

// Arrow function: do not have their own "this" keyword
// 1 line arrow function
let myFunction = () => do_something; // () at (do_something) not necessary if on single line
// 1 line arrow function with arguments
let myFunction = (a) => do_something_with_a;
// arrow function, must use return keyword
let myFunction = () => {
  return do_something;
};
// arrow function with arguments
let myFunction = (a) => {
  return do_something_with_a;
};

// Immediately Invoked Function Expressions (IIFE)
// method 1
(function () {
  do_something;
})();
// method 2
(function () {
  do_something;
})();
// method 3: no returning of value
!(function () {
  do_something;
})();

javascript ES6

// Default parameters
function myFunction(a = value) {
  do_something_with_a;
}

typescript

// return void
function greetByName(name: string): void {
  console.log("Well hi there,", name);
}

function makeGreen(name: string): string {
  const newName = `Green ${name}`;
  return newName;
}

function getStr(): string {
  return "string";
}

function getNum(): number {
  return 123;
}

function getArr(): object {
  return [1, "string"];
}

// accept multiple types in the parameter with "|"
function totalLength(x: string | any[], y: string | any[]): number {
  // allow mix of string and array parameters
  let total: number = x.length + y.length;
  return total;
}

// function overloading
function totalLength(x: string, y: string): number; // allows either only string parameters
function totalLength(x: any[], y: any[]): number; // or only array parameters
function totalLength(x: string | any[], y: string | any[]): number {
  // does not allow mix of string and array parameters
  var total: number = x.length + y.length;
  return total;
}

// using anonymous types
function totalLength(x: { length: number }, y: { length: number }): number {
  // in this case, allow any parameter types that is able to calculate length (string, array)
  var total: number = x.length + y.length;
  return total;
}

ruby

• Function returns result regardless of whether return statement is declared or not
  • Reason: ruby applies Implicit Return feature

# Normal function, use return to return values
def myFunction
    do_something
end


# Normal function with parameters
def myFunction(parameter)
    do_something
end

# Default parameters
def myFunction(a=value)
    do_something_with_a
end


# Blocks: nameless methods, similar to anonymous functions in JavaScript or lambdas in Python
# can replace "do" and "end" with {}
# 1st type
# original way
arrayName.each do |num|
    do_something_with_num
end
# blocks way
arrayName.each { |num| do_something_with_num }


# 2nd type: Yield
def myFunction
    yield  # can have multpile yield
    yield
end
myFunction { print "test" }  # "testtest"

def myFunction
    yield(1)  # can pass any number of arguments to yield
    yield 2  # () is not a must
end
myFunction { |num| print num * 10 }  # 1020


# Explicit Blocks
def myFunction(&blockName)  # & is used to define the block's name
    blockName.call
end
myFunction { print "test" }  # "test"


# Lambda
# lambda checks the number of arguments passed to it
# when a lambda returns, it passes control back to the calling method
# method 1
myFunction = -> { puts "test" }
myFunction.call  # "test", call is required to call the lambda function

# method 2
myFunction = lambda { puts "test" }
myFunction.call


# Procs: a saved block
# it is a full-fledged objects, so they have all the powers and abilities of objects (blocks do not)
# Unlike blocks, procs can be called over and over without rewriting them
# procs does not checks the number of arguments passed to it
# when a proc returns, it does so immediately, without going back to the calling method
blockName = Proc.new do |n|
    do_something_with_n
end

java

// Normal functions
public static void myFunction() {
  do_something;
}


// Normal function with parameters
public static void myFunction(dataType a){
  do_something_with_a
}


// Normal function with return value (change void to data type to return)
public static int sum(int a){
  return a + 1;
}


// lamda
// store returning function
interface StringFunction {
  String run(String str);
}

StringFunction strFunc = (s) -> s;
strFunc.run("test");  // "test"

// store non returning function
// import java.util.ArrayList;
// import java.util.function.Consumer;  // must import
ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(5);
Consumer<Integer> method = (n) -> { System.out.println(n); };
numbers.forEach( method );

// using inside forEach loop
numbers.forEach( (n) -> { System.out.println(n); } );

• method overloading

static double addValues(String s1, String s2) {
  double d1 = Double.parseDouble(s1);
  double d2 = Double.parseDouble(s2);
  double result = d1 + d2;
  return result;
}

static double addValues(String s1, String s2, String s3) {
  double d1 = Double.parseDouble(s1);
  double d2 = Double.parseDouble(s2);
  double d3 = Double.parseDouble(s3);
  double result = d1 + d2 + d3;
  return result;
}

c#

// Normal functions
public static void MyFunction() {
  do_something
}


// Normal function with parameters
public static void MyFunction(dataType a){
  do_something_with_a
}


// Normal function with default parameters
public static void MyFunction(dataType a=value) {
  do_something_with_a;
}


// Normal function with return value (change void to data type to return)
public static int Sum(int a){
  return a + 1;
}


// Lambda  expression
public static void MyFunction() => do_something;


// Lambda expression with parameters
public static void MyFunction(dataType a) => do_something_with_a;

// () not required if single input, use {} if have multi-lines
var MyFunction = (dataType a) => do_something_with_a;
var MyFunction = dataType a => do_something_with_a;
var MyFunction = (dataType a) => { do_something_with_a; };
var MyFunction = dataType a => { do_something_with_a; };

// dataType not required if data type is obvious
var MyFunction = a => do_something_with_a;
var MyFunction = a => { do_something_with_a; };

// Lambda expression with default parameters
public static void MyFunction(dataType a=someValue) => do_something_with_a;

c++

• Function Signature: return type | name of function | (parameters)
• Signature / prototype
  • Normally add these in a .hpp or .h file then #include it into the .cpp file

public void functionName();

public void functionName2(int arg1, int arg2);

• Function definition

void functionName()
{
   // do something
}

• Function prototype

// prototype
int sumTwoNumbers(int a, int b);

int main()
{
   int result = sumTwoNumbers(2, 2);
   return 0;
}

// function definition
int sumTwoNumbers(int a, int b)
{
   return a + b;
}

back to top

Higher order functions

python 2

# Map: applies a given function to each item of an iterable (list, tuple etc.) and returns a list of the results
# map(function, iterable, ...)
arr = [1, 2, 3]
def add(n):
    return n + n
map(add, arr)  # return <map object at 0x10473e518>
list(map(add, arr))  # return [2, 4, 6]


# Filter: filter and return a new array based on the conditions
# filter(function, iterable)
arr = [1, 2, 3]
def condition(n):
    if n < 3:
        return n
filter(condition, arr)  # return <filter object at 0x10473e550>
list(filter(condition, arr))  # return [1, 2]


# Reduce: executes a function on each element, resulting in a single output value
arr = [1, 2, 3]
def compute(n, m):
    return n * m
reduce(compute, arr)  # return 6

# Zip: combines 2 arrays or tuples into an array of tuples
arr1 = [1, 2, 3]
arr2 = ["1", "2", "3"]
zpp(arr1, arr2)  # [(1, '1'), (2, '2'), (3, '3')]

python 3

# Reduce: executes a function on each element, resulting in a single output value
arr = [1, 2, 3]
def compute(n, m):
    return n * m
from functools import reduce  # requires import in python 3
reduce(compute, arr)  # return 6

# Zip: must call a list() or tuple() on the zip method
list(zip(s, t))  # [(1, '1'), (2, '2'), (3, '3')]
tuple(zip(s, t)) # ((1, '1'), (2, '2'), (3, '3'))

javascript

// Map: create a new array from a current array
// array.map(element, currentIndex, originalArray)
const companies = [
    {name: "company1", category: "industry1"},
    {name: "company2", category: "industry2"}
];
// callback method
const companyNames = companies.map(function(company) {
    return company.name;
}
// arrow function method
const companynames = companies.map((company) => company.name);


// Filter: creates a new array with all elements that pass the condition implemented by the provided function
// array.filter(element, currentIndex, originalArray)
const ages = [age1, age2, age3];
// callback method
const canDrink = ages.filter(function(age) {
    if (condition) {
        return true;
    }
}
// arrow function method
const canDrink = ages.filter(age => condition);


// Reduce: executes a function on each element of the array, resulting in a single output value
// array.reduce(function(accumulator, currentValue){ do_something }, initialValue)
let arr = [1, 2, 3];
// no initial value
arr.reduce(function(accumulator, currentValue) {
    return accumulator + currentValue;
});  // returns a value of 6
/*
accumulator | currentValue | returned value
    1       |       2      |        3
    3       |       3      |        6
*/

// initial value included
arr.reduce(function(accumulator, currentValue) {
    return accumulator + currentValue;
}, 10);  // returns a value of 16
/*
accumulator | currentValue | returned value
    10      |       1      |        11
    11      |       2      |        13
    13      |       3      |        16
*/


// Sort: sorts the elements of an array in place and returns the sorted array
// array.sort(compareFunction)
// if compareFunction is not used, all sorted elements will be sorted based on it's string value
let array = ["1", 30, 4, 21, 100000];
array.sort();  // returns ["1", 100000, 21, 30, 4]

// sort in ascending order
array.sort((a, b) => a - b);  // returns ["1", 4, 21, 30, 100000]

// sort in descending order
array.sort((a, b) => b - a);  // returns [100000, 30, 21, 4, "1"]

// Zip is not available in Javascript, use Maps instead
const arr1 = [1, 2, 3];
const arr2 = ["1", "2", "3"];
function zip(arrays) {
    return arrays[0].map(function(_,i){
        return arrays.map(function(array){return array[i]})
    });
}
zip([arr1, arr2]);  // [[1, '1'], [2, '2'], [3, '3']]

ruby

# Zip: combine 2 arrays
arr1 = [1, 2, 3]
arr2 = ["1", "2", "3"]
puts arr1.zip(arr2)  # [[1, '1'], [2, '2'], [3, '3']]

java

c++

back to top

Hash Tables

• Hash Tables, Dictionaries, Objects

python 2 & 3

# Create dictionary
newDict = {}

# Create dictionary and assign key value pairs
# method 1
newDict = {
    "key1": "value1",
    "key2": 123,
    "key3": True,
    "key4": myFunction
}
# method 2
newDict = dict(key1="value1", key2="value2")

# Add or reassign key value pair
newDict["Key"] = "Value"  # method 1
newDict.update({"key": "value"})  # method 2

# Set multiple keys with a similar value
newKeys = ("key1", "key2", "key3")
newValue = value
newDict = dict.fromkeys(newKeys, newValue)

# Return value of the item with the specified key
# If the key does not exist, insert the key, with the specified value
newVariable = newDict.setdefault("key", "newValue")

# Get value
newDict["key"]  # method 1 # return KeyError if key does not exist
newDict.get("key")  # method 2 # return None if key does not exist

# Get list of keys
list(newDict.keys())

# Get list of values
list(newDict.values())

# Get list of key value tuples
list(newDict.items())

# Loop through Dictionary and get each key
# method 1
for key in newDict:
    print(key)
# method 2
for key in newDict.keys():
    print(key)

# Loop through Dictionary and get each value
# method 1
for key in newDict:
    print(newDict[key])
# method 2
for value in newDict.values():
    print(value)

# Loop through both keys and values
for key, value in newDict.items():
    print(key, value)

# Check if key exists
if "key" in newDict:
    return True

# Get dictionary length
len(newDict)

# Copy dictionary
# cannot copy just from dict2 = dict1 as it is just referencing to dict1
# method 1
newDict2 = newDict.copy()
# method 2
newDict2 = dict(newDict)

# Remove items
newDict.pop("key")  # method 1
del newDict["key1"]  # method 2

# Remove last inserted item
newDict.popitem()

# Delete entire dictionary
del newDict  # method 1
newDict.clear()  # method 2

javascript ES5

// Objects
// Create object
let newObj = new Object(); // method 1
let newObj = {}; // method 2, literal notation

// Create object and assign values
// keys can only be strings without quotes
let newObj = {
  key1: "stringValue",
  key2: 123,
  key3: true,
  key4: ["array", "array2"],
  key5: { anotherKey: anotherValue },
  key6: function (arg) {
    return do_something_with_arg;
  },
};

// dynamic key
let myKey = "emotion";
let newObj2 = {
  [myKey]: "Happy",
}; // key = "emotion"

// Creates a new object, using an existing object as the prototype of the newly created object
// method 1
newObj2 = Object.create(newObj); // copies the prototype of newObj, key value pairs will become inherited
let newObj2pt2 = Object.create(null, {
  // creates a new object but without default object properties, default object properties can't be used
  key1: value,
});
let newObj2pt3 = Object.create(null, {
  // set object configuration
  key: {
    value: "something",
    writable: true,
    enumerable: true,
    configurable: true,
  },
});
let newObj2pt4 = Object.create(Object.prototype, {
  // creates a new object with all default object properties
  key: {
    value: "something",
    writable: true,
    enumerable: true,
    configurable: true,
  },
});
// method 2: merge 2 object together
newObj2 = Object.assign(oldObj, newObj);

// Assign and Reassign values
newObj["key1"] = "newString"; // method 1, bracket notation
newObj.key1 = "newString2"; // method 2, dot notation

// Copy the values of all enumerable own properties from one or more source objects to a target object
// return the target object
const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const newObj = Object.assign(target, source); // newObj, target = { a: 1, b: 4, c: 5 }

// Copy without mutating the target source
const target2 = { a: 1, b: 2 };
const source2 = { b: 4, c: 5 };
const newObj2 = Object.assign({}, target2, source2); // newObj2 = { a: 1, b: 4, c: 5 }, target2 = { a: 1, b: 2 }

// Get value
newObj["key1"]; // method 1
newObj.key1; // method 2

// Get an array of keys
Object.keys(newObj);

// Get an array of values
Object.values(newObj);

// Loop through all key value pairs
// must be (key, value)
for (let [key, value] of Object.entries(newObj)) {
  console.log(`Key: ${key}, Value: ${value}`);
}

// Defines a new property directly on an object, or modifies an existing property on an object, and returns the object
// Object.defineProperty(obj, propertyName, descriptor)
Object.defineProperty(newObj, "property1", {
  value: "123",
  writable: true,
  enumerable: true,
  configurable: false,
}); // newObj.property1 = 123

let descriptor = Object.getOwnPropertyDescriptor(newObj, "property1");
console.log(descriptor);
/*
{
  value: 123,
  writable: true,  // if false cannot reassign new primitive values, but can reassign values of an object
  enumerable: true,  // if false will skip this property when looping
  configurable: true,  // if false cannot delete and redefine property (except writable); once set to false, cannot change back to true
}
*/

// Seals an object
// prevent addition of properties, however defined properties still can be changed
Object.seal(newObj);

// Freeze an object
// makes the object immutable, meaning no change to defined property allowed, unless they are objects.
Object.freeze(newObj);

javascript ES6

// Merge 2 objects
const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const newObj = { ...target, ...source }; // { a: 1, b: 4, c: 5 }

// Maps or Hash tables
// Create new Map or hash table
const newDict = new Map();

// Add key value pair data
// keys does not need to be strings, can be numbers, booleans, etc.
newDict.set(key1, value1);
newDict.set(key2, value2);

// Get all keys
newDict.keys();

// Get all values
newDict.values();

// Iterate over Maps to get each key
for (let key of newDict.keys()) {
  console.log(key);
}

// Iterate over Maps to get each value
for (let value of newDict.values()) {
  console.log(value);
}

// Get value
newDict.get(key);

// Get hash table size
newDict.size;

// Check if key value pair exist with key input
newDict.has(key);

// Loop through all key value pairs
// method 1, must be (value, key)
newDict.forEach((value, key) => console.log(`Key: ${key}, Value: ${value}`));
// method 2, must be (key, value)
for (let [key, value] of newDict.entries()) {
  console.log(`Key: ${key}, Value: ${value}`);
}

// Delete key value pair
newDict.delete(key);
// Delete all key value pairs
newDict.clear();

// WeakMap: similar to Map, but all keys must be objects
// Create new weak map
const newDict = new WeakMap();

// Add key value pair data
// key MUST be and Object
newDict.set(obj1, value1);
newDict.set(obj2, value2);

// Get value
newDict.get(obj);

// Delete key value pair
newDict.delete(obj);

// Check if key value pair exist with key input
newDict.has(obj);

typescript

// object is a type that represents the non-primitive type, i.e. anything that is not number, string, boolean, symbol, null, or undefined
let objName: object = {
  key1: 123,
  key2: "string",
};

ruby

# Hash literal notation, OLD SYNTAX
hash_name = {
    key1 => value1,
    "name" => "myName",
    "age" => 123,
    "hungry?" => true,
    111 => "one one one",
    false => "weird"
}

# NEW SYNTAX
# keys are symbols in this case
hash_name = {
    key1: value1,
    name: "myName",
    age: 123,
    hungry: true,
}

# Hash constructor notation
# Create a new empty hash
hash_name = Hash.new


# Adding to a Hash
hash_name["newKey"] = "new value"


# Accessing hash value
hash_name["hungry"]  # true


# Delete a key value pair
hash_name.delete(key)


# Update hash (duplicates will be removed)
hash_name.update(hash_name2)


# Merge hash (duplicates will not be removed)
hash_name.merge(hash_name2)


# Check if key exist
hash_name.has_key?("keyName")


# Check if value exit
hash_name.has_value?("valueName")


# Check if hash is empty
hash_name.empty?


# Get hash size
hash_name.size


# Iterating over Hashes
hash_name.each do [keyName, valueName|
    do_something_with_keyName_and_valueName
end


# sort_by: Maps Hash into an array and then sort them via values in ascending order
colors = {
    "blue" => 3,
    "green" => 1,
    "red" => 2
}
colors = colors.sort_by do |color, count|
    count
end
puts colors  # [["green", 1], ["red", 2], ["blue", 3]]


# nil does not display anything
myHash = Hash.new()
puts myHash  # {}
puts myHash["nonexistent key"] # display nothing
# Replace nil and Set default value when key does not exist
myHash = Hash.new("no such key")
puts myHash  # {}
puts myHash["nonexistent key"]  # "no such key"


# Symbols used in Hashes
myHash = {
    :cat => "meow",
    :number => 123
}


# Select method: Grab specific value(s) from a hash with key or value
grades = {
    alice: 100,
    bob: 92,
    chris: 95,
    dave: 97
}
newHash = grades.select { |nameKey, gradeValue| gradeValue < 97 }  # Grab values with value
puts newHash  # { :bob => 92, :chris => 95 }

newHash = grades.select { |nameKey, gradeValue| nameKey == :alice }  # Grab values with key
puts newHash  # { :alice => 100 }


# Loop all keys
grades.each_key { |key| print key, " " }  # alice bob chris dave

# Loop all values
grades.each_value { |value| print value, " " }  # 100 92 95 97

java

// Map: it is an interface used to store data in key-value pair
// import java.util.Map;  // must import

// HashMap: it is the implementation class of the Map interface
// import java.util.HashMap;  // must import

// declaration
Map<String, String> map = new HashMap<>();

// add key value pair
map.put("jp", "Japan");
map.put("sg", "Singapore");
map.put("usa", "United States");
System.out.println(map);  // { jp=Japan, sg=Singapore, usa=United States }

// get value with key
map.get("jp");  // "Japan"

// remove key value pair with key
map.remove("sg");  // { jp=Japan, usa=United States }

// get a set of keys
// import java.util.Set;  // must import
Set<String> keys = map.keySet();  // [ usa, jp ]

c#

// method 1 (can be used within a method)
System.Collections.Generic.Dictionary<string, string> _dictionary = new System.Collections.Generic.Dictionary<string, string>();  // declaration
_dictionary["name"] = "xyz" // assigning key value pairs
System.Console.WriteLine(_dictionary["name"]);  // getting value with key


// method 2: indexer (need to create a class)
public class Person {
  private readonly System.Collections.Generic.Dictionary<string, string> _dictionary = new System.Collections.Generic.Dictionary<string, string>();

  public string this[string key] {  // this keyword is required
    get { return _dictionary[key]; }
    set { _dictionary[key] = value; }  // value is a keyword
  }
}

class MainClass {
  public static void Main() {
    Person p = new Person();
    p["name"] = "xyz";
    System.Console.WriteLine(p["name"]);  // "xyz"
  }
}

c++

back to top

Destructuring

python 2 & 3

# Tuples
xVariable, yVariable = (xValue, yValue)

# Arrays
xVariable, yVariable = [xValue, yValue]

# String
xVariable, yVariable = "xy"

# Dictionaries
xKey, yKey = {"xKey": xValue, "yKey": yValue}

javascript ES6

// Arrays
const [xVariable, yVariable] = [xValue, yValue];

// Objects
const obj = {
  xKey: xValue,
  yKey: yValue,
};
// declaring variables
const { xKey, yKey } = obj; // variable names must be the same as object key names

// assigning different variable names
const { xKey: xNewKey, yKey: yNewKey } = obj;

// Set default values if extracted variables does not exist
const { xKey, yKey, zKey = "test" } = obj;

// Use optional chaining for async code where data type will change
let data = null; // value before fetch
const { a = "", b = "" } = data?.[0] || []; // checks if data is undefined or null, then checks if there is value inside array
console.log(a); // ""

data = [{ a: "hello", b: "world" }]; // value after fetch
const { a = "", b = "" } = data?.[0] || []; // checks if data is undefined or null, then checks if there is value inside array
console.log(a); // "hello"

typescript

type myFunctionProps = {
  arg1: string;
  [k: string]: any; // to enable ...rest
};

function myFunction({ arg1, ...rest }: myFunctionProps) {
  let argsObj = rest; // args is an object of arguments
}

ruby

java

c++

back to top

Spread Operator

python 2 & 3

# *args (splat)
# Takes an array and transform (unpacks) it into single values
# Must utitlize all of the element of the array to work
myFunction(a, b, c)  # normal method
myFunction(*Tuple)  # (a, b, c)
myFunction(*List)  # [a, b, c]
myFunction(*String)  # "abc"
myFunction(*Dict)  # {"a": value1, "b": value2}  only utilize the keys

# **kwargs
myFunction(**Dict) # {"a": value1, "b": value2}  utilize both keys and values

javascript ES6

// Takes an array and transform (unpacks) it into single values
// Must utitlize all of the element of the array to work
let arr = [a, b, c];
myFunction(a, b, c); // normal method
myFunction.apply(null, arr); // using the apply() method
myFunction(...arr); // spread method

// join multiple arrays together
let arr1 = [a, b, c];
let arr2 = [d, e, f];
let totalArr = arr1.concat(arr2); // concat method
let totalArr = [...arr1, ...arr2];

ruby

java

c++

back to top

Rest parameters

python 2 & 3

# *args
# Receive a couple of single values and transform them into an array
def myFunction(*args):
    newArr = args  # args is an array of arugments

# **kwargs
# Receive a couple of keys and values and transform them into a dictionary
def myFunction(**kwargs):
    newDict = kwargs  # kwargs is a dictionary of keys and values
# calling example
myFunction(var1=value1, var2=value2)

javascript ES6

// Receive a couple of single values and transform them into an array
function myFunction(...args) {
  let argsArr = args; // args is an array of arguments
}

ruby

# *parameter
# Receive a couple of single values and transform them into an array
def myFunction(*parameter):
    newArr = args  # args is an array of arugments
end

java

static double myFunction(String ... args) {
  String[] argsArr = args;  // args is an array of arguments
}

c#

// hard coded method
public class Calculator1 {
  public in Add(int n1, int n2){
    return n1 + n2;
  }
  public in Add(int n1, int n2, int n3){
    return n1 + n2 + n3;
  }
}


// dynamic method
public class Calculator2 {
  public in Add(int[] numbers){
    int result = 0;
    foreach (int num in numbers)
      result += num
    return result;
  }
}

class MainClass {
  public static void Main(string[] args) {
    Calculator cal = new Calculator2();
    int result = cal.Add(new int[]{1, 2});  // need to initialize a new array
  }
}


// Using Params Modifier
public class Calculator3 {
  public in Add(params int[] numbers){  // add params keyword
    int result = 0;
    foreach (int num in numbers)
      result += num
    return result;
  }
}

class MainClass {
  public static void Main(string[] args) {
    Calculator cal = new Calculator3();
    int result = cal.Add(new int[]{1, 2});  // method 1: initialize a new array
    int result2 = cal.Add(1, 2);  // method 2: only possible if used params keyword
  }
}

c++

back to top

Class

python 2

class MathClass:
    def __init__(self, arg1, arg2):
        self.arg1 = arg1
        self.arg2 = arg2
        self.total = self.outterAdd(arg1, arg2)

    def innerAdd(self, arg3):
        return self.arg1 + self.arg2 + arg3

    # Static method knows nothing about the class and just deals with the parameters
    def outterAdd(number1, number2):
        return number1 + number2
    outterAdd = staticmethod(outterAdd)


test = MathClass(2, 4)
print (test.total)  # 6
print (test.innerAdd(2))  # 8
print (test.outterAdd(3, 7))  # 10
print (MathClass.outterAdd(4, 5)  # 9

python 3

class MathClass:
    def __init__(self, arg1, arg2):
        self.arg1 = arg1
        self.arg2 = arg2
        self.total = self.outterAdd(arg1, arg2)

    def innerAdd(self, arg3):
        return self.arg1 + self.arg2 + arg3

    # Static method knows nothing about the class and just deals with the parameters
    @staticmethod
    def outterAdd(number1, number2):
        return number1 + number2


test = MathClass(2, 4)
print(test.total)  # 6
print(test.innerAdd(2))  # 8
print(test.outterAdd(3, 7))  # 10
print(MathClass.outterAdd(4, 5))  # 9


# Using classmethod: method 1
class Person:
    name = "Default name"

    @classmethod
    def change_name(clas, new_name):
        cls.name = new_name


person1 = Person()
print(person1.name)  # Default name
person1.change_name("New name")
print(person1.name)  # New name


# Using classmethod: method 2
class Person2:
    def __init__(self, name):
        self.name = name

    @classmethod
    def use_default_name(cls):
        return cls("Default name")


person2 = Person2("My name")
print(person2.name)  # My name
person3 = Person2.use_default_name()
print(person3.name)  # Default name


# Inheritance
class Employee:  # parent
    raise_amt = 1.04

    def __init__(self, first, last, pay):
        self.first = first
        self.last = last
        self.pay = pay

    def apply_raise(self):
        self.pay = int(self.pay * self.raise_amt)


class Developer(Employee):  # child
    raise_amt = 1.1

    def __init__(self, first, last, pay, prog_lang):
        super().__init__(first, last, pay)  # method 1: implement parent class init method
        Employee.__init__(self, first, last, pay)  # method 2: implement parent class init method
        self.prog_lang = prog_lang


dev = Developer("abc", "xyz", 5000, "Python")
print(dev.pay)  # 5000
dev.apply_raise()
print(dev.pay)  # 5500

• python magic method guide
  • https://rszalski.github.io/magicmethods/

javascript ES5

// method 1
var MathClass = {
  arg1: 2,
  arg2: 0,

  get getTotal() {
    return this.arg1 + this.arg2;
  },

  set getTotal(arg2) {
    // can only have 1 parameter
    this.arg2 = arg2;
  },
};

MathClass.getTotal; // 2
MathClass.getTotal = 4;
MathClass.getTotal; // 6

// method 2
// Constructor
var MathClass = function (arg1) {
  this.arg1 = arg1;
  this.arg2 = 0;
};

// Instantiation
var test = new MathClass(2);

// Add method
MathClass.prototype.innerAdd = function (arg3) {
  return this.arg1 + this.arg2 + arg3;
};

test.innerAdd(4); // 6

// Add getter and setter
Object.defineProperty(MathClass.prototype, "getTotal", {
  get: function () {
    return this.arg1 + this.arg2;
  },
  set: function (arg2) {
    // can only have 1 parameter
    this.arg2 = arg2;
  },
});

var total = new MathClass(2);
total.getTotal; // 2
total.getTotal = 4;
total.getTotal; // 6

// inheritance
function Employee(first, last, pay) {
  this.raiseAmt = 1.04;
  this.first = first;
  this.last = last;
  this.pay = pay;
}

Employee.prototype.applyRaise = function () {
  this.pay = parseInt(this.pay * this.raiseAmt);
};

function Developer(first, last, pay, progLang) {
  Employee.call(this, first, last, pay);
  this.raiseAmt = 1.1;
  this.progLang = progLang;
}

Developer.prototype = Object.create(Employee.prototype);

Developer.prototype.constructor = Developer;

const dev = new Developer("abc", "xyz", 5000, "Javascript");
console.log(dev.pay); // 5000
dev.applyRaise();
console.log(dev.pay); // 5500

javascript ES6

// Case 1: normal javascript way
class MathClass {
  #privateVariable; // required if want to declare private variable

  constructor(arg1, arg2) {
    this.arg1 = arg1;
    this.arg2 = arg2;
    this.#privateVariable = "this is a real private variable"; // cannot be accessed directly
    this.total = this.constructor.outterAdd(arg1, arg2);
  }

  innerAdd(arg3) {
    return this.arg1 + this.arg2 + arg3;
  }

  // Static method knows nothing about the class and just deals with the parameters
  static outterAdd(number1, number2) {
    return number1 + number2;
  }

  get privateVariable() {
    return this.#privateVariable;
  }

  set privateVariable(newValue) {
    // can only have 1 parameter
    this.#privateVariable = newValue;
  }
}

const test = new MathClass(2, 4);
console.log(test.total); // 6
console.log(test.innerAdd(2)); // 8
console.log(test.constructor.outterAdd(3, 7)); // 10
console.log(MathClass.outterAdd(4, 5)); // 9

console.log(test.privateVariable); // "this is a real private variable"
test.privateVariable = "changed private variable value";
console.log(test.privateVariable); // "changed private variable value"

// Case 2: event handlers in React
class MathClass {
  constructor() {
    this.arg1 = 2;
    this.arg2 = 4;
    this.innerAdd = this.innerAdd.bind(this); // this is required to prevent TypeError
  }

  innerAdd(arg3) {
    return this.arg1 + this.arg2 + arg3;
  }
}
const test = new MathClass();
console.log(test.innerAdd(2)); // 8

// Inheritance
class Employee {
  // parent
  raiseAmt = 1.04;

  constructor(first, last, pay) {
    this.first = first;
    this.last = last;
    this.pay = pay;
  }

  applyRaise() {
    this.pay = parseInt(this.pay * this.raiseAmt);
  }
}

class Developer extends Employee {
  // child
  raiseAmt = 1.1;

  constructor(first, last, pay, progLang) {
    super(first, last, pay); // implement parent class init method
    this.progLang = progLang;
  }
}

const dev = new Developer("abc", "xyz", 5000, "Javascript");
console.log(dev.pay); // 5000
dev.applyRaise();
console.log(dev.pay); // 5500

typescript

class Person {
  name: string;
  age: number;
  isWorking: boolean;
}

class Page {
  private content: string;

  constructor(content: string = "") {
    this.content = content;
  }

  public getContent(): string {
    return this.content;
  }
}

class Book {
  private pages: Page[] = [];

  public add(page: Page): void {
    this.pages.push(page);
  }
}

// Interface
interface ClockInterface {
  h: number;
  m: number;
  tick(): void;
}

class DigitalClock implements ClockInterface {
  h: number; // must be declared to use "this.h"
  m: number;

  constructor(h: number, m: number) {
    this.h = h;
    this.m = m;
  }

  tick(): void {
    console.log(`beep beep ${this.h}:${this.m}`);
  }
}

class AnalogClock implements ClockInterface {
  h: number;
  m: number;

  constructor(h: number, m: number) {
    this.h = h;
    this.m = m;
  }

  tick(): void {
    console.log(`tick tok ${this.h}:${this.m}`);
  }
}

const digital = new DigitalClock(12, 17);
const analog = new AnalogClock(7, 32);
digital.tick();
analog.tick();

// abstract
abstract class Department {
  constructor(public name: string) {}

  printName(): void {
    console.log(`Department name: ${this.name}`);
  }

  abstract printMeeting(): void; // must be implemented in derived classes
}

class AccountingDepartment extends Department {
  // must use all and only methods declared in the abstract class
  constructor() {
    super("Accounting and Auditing"); // constructors in derived classes must call super()
  }

  printMeeting(): void {
    // methods can be customized and modified
    console.log("The Accounting Department meets each Monday at 10am.");
  }

  generateReports(): void {
    // does not exist in the abstract class, will produce an error if run
    console.log("Generating accounting reports...");
  }
}

let department: Department; // ok to create a reference to an abstract type
//department = new Department(); // error: cannot create an instance of an abstract class
department = new AccountingDepartment(); // ok to create and assign a non-abstract subclass
department.printName();
department.printMeeting();
//department.generateReports(); // error: method doesn't exist on declared abstract type

ruby

• class variables (@@variableName) are like instance variables but belongs to the class
• global variables ($variableName) must be declared with a $ symbol, if declared within the class

class MathClass
  $globalVariable = "global variable"
  @@count = 0

  def initialize(arg1, arg2)  # constructor
    @arg1 = arg1  # @ signify that it's an instance variable
    @arg2 = arg2
  end

  def innerAdd(arg3)
    @@count += 1
    return @arg1 + @arg2 + arg3
  end
end

# Instantiation
test = MathClass.new(2, 4)
puts test.innerAdd(2)  # 8


# Setters & Getters
# method 1
class Student
  def initialize
    puts "New student"
  end

  def set_name(new_name)
    @name = new_name
  end

  def get_name
    @name
  end
end

test = Student.new
test.set_name("Foo")
puts test.get_name  # "Foo"

# method 2
class Student2
  attr_reader :name
  attr_writer :name
end

test2 = Student2.new
test2.name = "Foo2"
puts test2.name  # "Foo2"

# method 3
class Student3
  attr_accessor :name
end

test3 = Student3.new
test3.name = "Foo3"
puts test3.name  # "Foo3"


# Module: similar to classes, but cannot be instantiated
module MathClass
  def innerAdd(arg1, arg2)
    return arg1 + arg2
  end
end

# method 1
class CalculatorClass1
  include MathClass  # use this to enable method override

  def innerAdd(arg1, arg2)
    return arg1 + arg1
  end
end

calculate1 = CalculatorClass1.new
calculate1.innerAdd(1, 3)  # 2

# method 2
class CalculatorClass2
  prepend MathClass  # use this to disable method override

  def innerAdd(arg1, arg2)
    return arg1 + arg1
  end
end

calculate2 = CalculatorClass2.new
calculate2.innerAdd(1, 3)  # 4


# Inheritance
class CalculatorClass < MathClass
end

calculate = CalculatorClass.new(2, 4)
puts calculate.innerAdd(2)  # 8

# override parent method
class CalculatorClass < MathClass
  def innerAdd(arg3)
    return (@arg1 + @arg2 + arg3) / 3
  end
end

calculate = CalculatorClass.new(2, 4)
puts calculate.innerAdd(2)  # 2

# use super to access parent's attributes or methods of an overridden class method
class CalculatorClass < MathClass
  def innerAdd(arg3)
    print super
    print " "
    return (@arg1 + @arg2 + arg3) / 3
  end
end

calculate = CalculatorClass.new(2, 4)
puts calculate.innerAdd(2)  # 8 2

java

• class
  • if not constructor has been defined, a constructor with no args will be auto generated
  • if a constructor with args has been defined, a constructor with no args will not be auto generated

public class Math {
  public int arg1;
  public int arg2;
  public int total;
  public static final String NAME = "Math";  // declaring a constant variable

  // constructor (must have the same name as class name, no return data type)
  public Math(int arg1, int arg2) {
    // this keyword is not a must, however, variable name must be different from the parameter
    this.arg1 = arg1;
    this.arg2 = arg2;
    this.total = OuterAdd(arg1, arg2);
  }

  public int InnerAdd(int arg3) {
    return this.arg1 + this.arg2 + arg3;
  }

  public static int OuterAdd(int number1, int number2) {
    return number1 + number2;
  }
}

class MainClass {
  public static void main(String[] args) {
    Math test = new Math(2, 4);  // instantiation
    // non-static variables or methods requires instantiation
    System.out.println(test.total);  // 6
    System.out.println(test.InnerAdd(2));  // 8
    // static variables or methods does not requires instantiation
    System.out.println(Math.OutterAdd(4, 5));  // 9
  }
}

• private key

public class Person {
  private int age = 0;  // cannot be accessed other than within the class

  // age can only be modified with the setter method
  public void setAge(int age) {
    this.age = age;
  }

  // age can only be retrieve with the getter method
  public int getAge() {
    return this.age;
  }
}

• protected key

  // class with protected method
  package p1;
  
  // Class A
  public class A {
    protected void display() {
      System.out.println("test");
    }
  }

  • Calling protected function without extending the parent class

    package p2;
    
    // import all classes in package p1
    import p1.*;
    
    class B {
      public static void main(String args[]) {
        B obj = new B();
        // not be able to access the function “display” since child class has not inherited its value from the main class
        obj.display();  // throw an exception
      }
    }

    • throw an error Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - Erroneous sym type: p2.B.display

  • Accessing a protected class

    package p1;
    
    // Class A
    protected class A {
      void display()
      {
        System.out.println("test");
      }
    }

    package p2;
    
    // import all classes in package p1
    import p1.*;
    
    // Class B is a subclass of A
    class B extends A {
        public static void main(String args[])
        {
            B obj = new B();
            obj.display();  // throw an exception
        }
    }

    • throw an error Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - Erroneous sym type: p2.B.display

  • Accessing display function from the same package but different class

    public class C {
      public static void main(String args[]) {
        A obj = new A();
        obj.display();  // test
      }
    }

  • Accessing display function from a different package

    package p2;
    
    // import all classes in package p1
    import p1.*;
    
    // Class B is a subclass of A
    class B extends A {
      public static void main(String args[]) {
        B obj = new B();
        obj.display();  // test
      }
    }

  • Accessing a protected class by overriding to sub-class within same package

    public class C extends A {
      // overridden function
      protected void display() {
        System.out.println("overridden");
      }
    
      public static void main(String args[]) {
        C obj1 = new C();
        obj1.display();  // overridden
      }
    }

• Anonymous classes

import java.util.Scanner;

public class Calculator {
  public static void main(String[] args) {
    ClassName c = new ClassName();
    c.calculate();
  }

  // can be accessed from within the same class, subclasses of same packages,
  // different classes of same packages, subclasses of different packages
  protected void calculate() {
    InputHelper helper = new InputHelper();
    String s1 = helper.getInput("Please do something");
  }

  // only Calculator class can use this
  class InputHelper {
    // can only be accessed from the same class
    private String getInput(String prompt) {
      System.out.println(prompt);
      Scanner sc = new Scanner(System.in);
      return sc.nextLine();
    }
  }
}

• inheritance

// enum
public enum Names {
  JOHN, PETER;
}

// parent / base / superclass
public class Person {
  private int age;
  private Names name;

  public Person(int age, Names name) {
    this.age = age;
    this.name = name;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public int getAge() {
    return this.age;
  }

  public Names getName() {
    return this.name;
  }

  public void whoAmI() {
    System.out.println("I am a Person");
  }
}

// Inheritance: child / derived / subclass
public class John extends Person {
  public John() {
    super(25, Names.JOHN);
  }

  // Polymorphism: overriding the parent's method
  @Override  // use this even if it is not required for 2 benefits: take adv of compiler check, easier to read
  public void whoAmI() {
    System.out.println("I a John");
  }
}

public class Main {
  public static void main(String[] args) {
    Person p = new Person(0, Names.JOHN);
    p.whoAmI();  // "I am a Person
    John j = new John();
    j.setAge(25);
    System.out.println(j.getAge());
    System.out.println(j.getName());
    j.whoAmI();  // "I am John"
  }
}

• interface
  • it is a contract that defines a set of methods with a particular signatures
  • any class that implement that interface must implement those methods

// enum
public enum Names {
  JOHN, PETER;
}

// interface: declaring of implementations are not required
// declaring of implementations in Android might be required during instantiation
public interface Human {
  public void setAge(int age);

  public int getAge();

  public Names getName();

  public void whoAmI();
}

// class that implements an interface
// if not all of the methods declared in the interface are implemented, an error will occur
// additional methods not declared in the interface can be declared
public class Person implements Human {
  private int age;
  private Names name;

  public Person(int age, Names name) {
    this.age = age;
    this.name = name;
  }

  @Override  // not required but better to be explicit
  public void setAge(int age) {
    this.age = age;
  }

  @Override
  public int getAge() {
    return this.age;
  }

  @Override
  public Names getName() {
    return this.name1;
  }

  @Override
  public void whoAmI() {
    System.out.println("I am a Person");
  }
}

• abstract
  • the abstract keyword is added
  • it can contain a mixture of fully implemented methods & abstract methods
    • abstract method is similar to a method in an interface
      • no implementation & only indicates method signature
      • any subclasses of an abstract method must implement that method
  • cannot be instantiated directly, only their subclasses can be instantiated

// enum
public enum Names {
  JOHN, PETER;
}

// interface
public interface Human {
  public void setAge(int age);

  public int getAge();

  public Names getName();

  public void whoAmI();
}

// abstract parent / base / superclass
public abstract class Person implements Human {
  private int age;
  private Names name;

  public Person(int age, Names name) {
    this.age = age;
    this.name = name;
  }

  @Override
  public void setAge(int age) {
    this.age = age;
  }

  @Override
  public int getAge() {
    return this.age;
  }

  @Override
  public Names getName() {
    return this.name1;
  }

  @Override
  public void whoAmI() {
    System.out.println("I am a Person");
  }

  // this means that every subclass of this class must declare its own origin
  public abstract String getOrigin();
}

// child / derived / subclass
public class John extends Person {
  public John() {
    super(25, Names.JOHN);
  }

  @Override
  public void whoAmI() {
    System.out.println("I a John");
  }

  @Override
  public String getOrigin() {  // this must be declared here, else an error will occur
    return "Japan";
  }
}

public class Main {
  public static void main(String[] args) {
    // Person p = new Person(0, Names.JOHN);  // abstract classes cannot be instantiated and will cause an error
    John j = new John();
    j.setAge(25);
    System.out.println(j.getAge());
    System.out.println(j.getName());
    j.whoAmI();  // "I am John"
  }
}

c#

• Struct vs Class
  • https://github.com/reshinto/Basic_technologies_revision/blob/master/c%23_summary.md#classes-vs-structs
• Stuct (structures)

public struct Math {
  public int arg1;
  public int arg2;
  public int total;

  // constructor (must have the same name as class name, must have parameters)
  public Math(int arg1, int arg2) {
    // this keyword is not a must, however, variable name must be different from the parameter
    this.arg1 = arg1;
    this.arg2 = arg2;
    this.total = OuterAdd(arg1, arg2);
  }

  public int InnerAdd(int arg3) {
    return this.arg1 + this.arg2 + arg3;
  }

  public static int OuterAdd(int number1, int number2) {
    return number1 + number2;
  }
}

class MainClass {
  public static void Main() {
    Math test = new Math(2, 4);
    System.Console.WriteLine(test.total);  // 6
    System.Console.WriteLine(test.InnerAdd(2));  // 8
    System.Console.WriteLine(Math.OutterAdd(4, 5));  // 9
  }
}

• Class

public class Math {
  public int arg1;
  public int arg2;
  public int total;

  // constructor (must have the same name as class name, no return data type)
  public Math(int arg1, int arg2) {
    // this keyword is not a must, however, variable name must be different from the parameter
    this.arg1 = arg1;
    this.arg2 = arg2;
    this.total = OuterAdd(arg1, arg2);
  }

  public int InnerAdd(int arg3) {
    return this.arg1 + this.arg2 + arg3;
  }

  public static int OuterAdd(int number1, int number2) {
    return number1 + number2;
  }
}

class MainClass {
  public static void Main() {
    Math test = new Math(2, 4);
    System.Console.WriteLine(test.total);  // 6
    System.Console.WriteLine(test.InnerAdd(2));  // 8
    System.Console.WriteLine(Math.OutterAdd(4, 5));  // 9
  }
}

• Inheritance

public class Employee {  // parent
  protected float raiseAmt = 1.04f;  // use protected to allow modification from other classes
  protected string first;
  protected string last;
  public int pay;  // only public allows display of value externally

  public Employee(string first, string last, int pay) {
    this.first = first;
    this.last = last;
    this.pay = pay;
  }

  public void applyRaise() {
    this.pay = System.Convert.ToInt32(this.pay * this.raiseAmt);
  }
}

public class Developer : Employee {  // child
  private string progLang;

  public Developer(string first, string last, int pay, string progLang) : base(first, last, pay) { // base initiates the parent's constructor
    raiseAmt = 1.1f;  // this will modifiy the base variable value in the parent class
    this.progLang = progLang;
  }
}

class MainClass {
  public static void Main(string[] args){
    Developer developer = new Developer("abc", "xyz", 5000, "c#");
    System.Console.WriteLine(developer.pay);  // 5000
    developer.applyRaise();
    System.Console.WriteLine(developer.pay);  // 5500


    // Upcasting: reduce the methods avaliable to only the parent class
    Empoyee employee = developer;

    // Downcasting: add methods avaliable to the child class
    Developer developer2 = (Developer) employee;  // return an exception if cannot be converted

    // use "as" keyword if not sure about the runtime type of the object
    Developer developer3 = employee as Developer;  // return a null if cannot be converted
    if (developer3 != null) {
      do_something;
    }

    // use "is" keyword to check
    if (employee is Developer) {
      Developer developer4 = (Developer) e;
    }
  }
}

• Composition

public class Employee {  // parent
  protected float raiseAmt;
  protected string first;
  protected string last;
  public int pay;

  public Employee(string first, string last, int pay, float raiseAmt = 1.04f) {
    this.first = first;
    this.last = last;
    this.pay = pay;
    this.raiseAmt = raiseAmt;
  }

  public void applyRaise() {
    this.pay = System.Convert.ToInt32(this.pay * this.raiseAmt);
  }
}

public class Developer {  // child
  private string progLang;
  public readonly Employee _employee;

  public Developer(Employee employee, string progLang) {
    _employee = employee;
    this.progLang = progLang;
  }
}

class MainClass
{
  public static void Main(string[] args)
  {
    Developer d = new Developer(new Employee("abc", "xyz", 5000, 1.1f), "c#");
    Console.WriteLine(d._employee.pay);  // 5000
    d._employee.applyRaise();
    Console.WriteLine(d._employee.pay);  // 5500
  }
}

• Polymorphism

public class Subject {
  public string subjName;

  public virtual void Study() {
    System.Console.WriteLine("Study all subjects");
  }
}

public class Math : Subject {
  public string mathName;

  public override void Study() {
    System.Console.WriteLine("Study Maths");
  }
}

class MainClass {
  public static void Main() {
    Subject s = new Subject();
    s.Study();  // "Study all subjects"
    s.subjName;  // accessible

    // polymorphism
    Subject sm = new Math();  // create a Subject object but override the Study method with the Math object
    sm.Study();  // "Study Maths"
    sm.subjName;  // only subjName is accessible, mathName is not
  }
}

• Properties
  • Properties is a kind of class member that is used for providing access to fields of a class
  • best practive to declare fields as private & create public properties to provide access to them
  • a property encapsulates a get and a set method

// method 1
public class Person {
  private string _name;

  public void SetName(string name) {
    this._name = name;
  }

  public string GetName() {
    return _name;
  }
}

class MainClass {
  public static void Main() {
    Person p = new Person();
    p.SetName("xyz");
    System.WriteLine(p.GetName());  // "xyz"
  }
}


// method 2: using setter and getter properties
public class Person {
  private string _name;

  public string name {
    get { return _name; }
    set { _name = value; }  // value is a keyword
  }
}

class MainClass {
  public static void Main() {
    Person p = new Person();
    p.name = "xyz";
    System.WriteLine(p.name);  // "xyz"
  }
}


// method 3: using auto-implemented properties (does not work if logic is involved in get or set method, use method 2 instead)
public class Person {
  public string name { get; set; }
}

class MainClass {
  public static void Main() {
    Person p = new Person();
    p.name = "xyz";
    System.WriteLine(p.name);  // "xyz"
  }
}


// method 4: using auto-implemented properties with private set method
public class Person {
  public string name { get; private set; }  // if private keyword is used, need constructor to set

  public Person(string inputName) {  // constructor
    name = inputName;
  }
}

class MainClass {
  public static void Main() {
    Person p = new Person("xyz");
    System.WriteLine(p.name);  // "xyz"
  }
}

• Interfaces
  • it is similar to a class but with abstract methods
  • use of "interface" keyword is required
  • does not have implementations (similar to abstract methods)
  • does not have access modifiers (eg: public, private, etc) in methods
  • interface is for building loosely-coupled extensible and testable apps
    • enable easy modifications with less or 0 impact on other components
  • has polymorphism behavior

public interface IFeatureName {  // in .net all interfaces start with "I" convention
  int Method1 { get; set; }
  void Method2();
  void Method3(int arg);
}

public class ProductName : IFeatureName {  // similar to inheritance, but different because methods have to be declared
  public int Method1 { get; set; }

  public void Method2() {
    do_something;
  }

  public void Method3(int arg) {
    do_something
  }
}

class MainClass {
  public static void Main() {
    ProductName p = new ProductName();
    if (p is IFeatureName) {  // check if IFeatureName exists
      p.Method2();
    }
  }
}


// Multiple Interfaces
public interface IFeatureName1 {
  void MethodName1();
}

public interface IFeatureName2 {
  void MethodName2();
}

public class ProductName : IFeatureName1, IFeatureName2 {
  public void MethodName1() {
    do_something;
  }

  public void MethodName2() {
    do_something;
  }
}

c++

// Math.h
class Math
{
   private:
     int num1 = 2;
     int num2;

   public:
     Math();  // constructor
     int sumOfValues();  // class method prototype
};

// Math.cpp
#include <iostream>
#include "Math.h"

Math::Math()  // class constructor definition
{
   num2 = 5;
}

int Math::sumOfValues()  // class method definition
{
   return num1 + num2;
}

int main()
{
   Math math;
   std::cout << math.sumOfValues();
}

back to top

Importing Libraries

python 2 & 3

# import module from libraries
import module_name  # must call module_name to use

# Using alias
import module_name as mn  # must call mn to use

# import class or function from a module
from module_name import function_name
from module_name import function_name1, function_name2  # multiple imports

# Absoute imports within the same project (file extensions not required)
from folder1 import module1  # example 1
from folder1.module2 import function1  # example 2
from folder2 import class1  # example 3
from folder2.subfolder1.module5 import function2  # example 4


# Relative imports (dot feature is similar to terminal)
from .module1 import class1  # example 1
from ..folder2 import function1 # example 2
from . import class2 # example 3

javascript ES5

// Before a module can be imported, it has to be exported first
var objectName.functionName = function();
module.exports = objectName;  // can be an object of functions
// alternative exports, import rules also change
exports.moduleName = objectName;  // preset a name to the module

// importing a module
// moduleName can be path too
var mn = require("moduleName");  // must call mn to use
var {function1, function2} = require("moduleName");  // importing multiple functions from a module
// import for alternative export
var mn = require("moduleName").moduleName;

javascript ES6

// Before a module can be imported, it has to be exported first
export default objectName; // exporting a single or nested functions or class

// {} must be used when importing
// method 1
export { functionName }; // export only 1 class or function (can be used for importing multiple functions or classes
// method 2, can be function, class, objects, etc.
export const functionName = () => {
  do_something;
};

// import class or function from module
import "moduleName"; // import module
import name from "moduleName"; // name can be anything if only have 1 export
import * as name from "moduleName"; // import multiple exports as name
import { function1 } from "moduleName"; // import a function from a module of multiple exports
import { function1 as f1 } from "moduleName"; // import a function with alias
import { function1, function2 } from "moduleName"; // import multiple functions
import name, { function1 } from "/modules/path/moduleName"; // function1 can be used directly or via name.function1

ruby

# import another ruby file
load "./anotherFile.rb"  # ./ not mandatory

# import module files
require_relative "moduleFileName"  # extension not required

java

// folder name that the current file is in, all other files that are in this folder can be imported without additional code
package com.example.demoapi.student;

// importing of custom nested class
import com.example.demoapi.student.utilities.Helper;

import java.time.LocalDate;
import java.time.Period;

// allows imports of all static members of the class
import static java.time.LocalDate.*;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;

// method 2
import javax.persistence.*;  // allows imports of all classes

@Entity
@Table
public class Student {
  @Id
  private Long id;
  @Transient
  private Integer age;

  // using import java.time.LocalDate;
  public Integer getAge1() {
    return Period.between(dob, LocalDate.now()).getYears();
  }

  // using import static java.time.LocalDate.*;
  public Integer getAge() {
    return Period.between(dob, now()).getYears();
  }
}

c++

back to top

Type Conversions

python 2 & 3

# Convert to Integer, floats will round down
int(type_to_convert)

# Convert to floats
float(type_to_convert)

# Convert to strings
str(type_to_convert)

# Convert to arrays
list(type_to_convert)  # cannot be a number

# Convert to tuples
tuple(type_to_convert)  # cannot be a number

# Convert to sets
set(type_to_convert)  # cannot be a number

javascript

// number to string
let num = 123;
let str = String(num); // "123"

// number to bigInt
let bigNum = BigInt(num);  // "123n"

// bigInt to number
let bigInt = 1234n;
// method 1
num = parseInt(bigInt);  // 1234
// method 2
num = Number(bigInt);  // 1234

// string to integer (remove all non numbers automatically)
str = "12 kg";
num = parseInt(str); // 12

// string to float (remove all non number automatically)
str = "12.5 kg";
num = parseFloat(str) // 12.5

//string to integer or float (return NaN if non number in string)
str = "12"
num = Number(str) // 12
str = 12.5";
num = Number(str) // 12.5
str = "12.5 kg";
num = Number(str); // NaN

ruby

# String to symbol
# method 1
"string".to_sym  # :string
# method 2
"string".intern  # :string

# Object to string
:string.to_s  # "string"
123.to_s  # "123"

# String to integer
"123".to_i  # 123

# array of strings to array of integers
strings = ["1", "2", "3"]
nums = strings.map(&:to_i)  # [1, 2, 3]

# array of integers to array of strings
nums = [1, 2, 3]
strings = nums.map(&:to_s)

java

// implicit type conversion (small value to big only)
byte b = 1;
int i = b;
float f = i;

// casting
// explicit type conversion (can convert big value to small, however, data loss will occur)
float pi = 3.14f;
int intPi = (int) pi;  // 3

int num = 256;
byte b = (byte) num; // 0 (surplus value will assigned if converting big data type value to smaller data type value)

int num2 = 255;
byte b2 = (byte) num2; // 255

// convert number to strings (user helper class)
int i = 1234;
String str = Integer.toString(i);  // "1234"

// convert string to double
String s = "423";
double d1 = Double.parseDouble(s);
System.out.println(d1);  // 423.0

c#

// implicit type conversion (small value to big only)
byte b = 1;
int i = b;
float f = i;


// casting
// explicit type conversion (can convert big value to small, however, data loss will occur)
float pi = 3.14f;
int intPi = (int) pi;  // 3

int num = 256;
byte b = (byte) num; // 0 (surplus value will assigned if converting big data type value to smaller data type value)

int num2 = 255;
byte b2 = (byte) num2; // 255


// convert non-compatible types
// string to integer
string s = "1";
// method 1
int i = Systen.Convert.ToInt32(s);  // returns 0 if string is null
// method 2
int j = int.Parse(s);  // returns an exception if string is null

/* other methods
ToByte()
ToInt16()  // short
ToInt32()  // integer
ToInt64()  // long
*/


// convert number to strings
// convert to normal string
int i = 1234;
string str = i.ToString();  // "1234"
// convert to currency with decimal places
string floatCurrency = i.ToString("C");  // "$1,234.00"
// convert to currency without decimal places
string currency = i.ToString("C0");  // "$1,234"

/* Format strings
format specific | description | example
c or C          | currency    | 123456 (C) -> $123,456
d or D          | decimal     | 1234 (D6) -> 001234
e or E          | exponential | 1052.0329112756 (E) -> 1.052033E+003
f or F          | fixed point | 1234.567 (F1) -> 1234.5
x or X          | Hexadecimal | 255 (X) -> FF
*/

c++

back to top

Find Data Type

python 2 & 3

# Get data type
num = 123
type(num)  # int

# Get boolean value
isinstance(num, int)  # True
isinstance(num, str)  # False

# check if all characters in string are uppercase
"abc".isupper()  # False
"Abc".isupper()  # False
"ABC".isupper()  # True
"AB1".isupper()  # True

# check if all characters in string are lowercase
"abC".islower()  # False
"abc".islower()  # True
"ab1".islower()  # True

# check if all characters in string are digits
"ab1".isdigit()  # False
"123".isdigit()  # True


# check if 2 objects are exactly the same even if they have the same value
# primitive values have the exact same objects
x = 1
y = 1
id(x)  # 4357474608
id(y)  # 4357474608

# reference type objects are different even if they have the same value
x = [1]
y = [1]
id(x)  # 4360090688
id(y)  # 4359972032

javascript

// Get data type: "number", "string", "boolean", "object", "undefined", "function"
// null and arrays are classified as object
// classes and methods are classfied as function
let num = 123;
typeof num; // "number"

let array = [1, 2, 3];
typeof array; // "object"

let variable1 = 10 / undefined; // NaN
Number.isNaN(variable1); // true

ruby

# Get data type, function won't provide a specify class type
puts "test".class  # String
puts :stringSym.class  # Symbol
puts 123.class  # Fixnum
puts 1.23.class  # Float
puts true.class  # TrueClass
puts false.class  # FalseClass
puts nil.class  # NilClass
puts [1, 2].class # Array
hashName = Hash.new()
puts hashName.class  # Hash
class Myclass
    def myFunc
        do_something
    end
end
puts Myclass.class  # Class

# Get id of object
puts "string".object_id  # 2343215, some random number where object is stored in memory

# check if object is the correct type, obj.is_a? data_type
[1, 2].is_a? Array  # true

java

c#

• typeof: takes a type name (which you specify at compile time)
• GetType: gets the runtime type of an instance
• is: returns true if an instance is in the inheritance tree

public class Animal { }
public class Dog : Animal { }

public class MainClass {
  public static void Main() {
    Dog spot = new Dog();
    PrintTypes(spot);
    int num = 123;
    System.Console.WriteLine(num.GetType());  // System.Int32
    System.Console.WriteLine(num.GetTypeCode());  // Int32
    System.Console.WriteLine(num.GetType() == typeof(int));  // true (System.Int32 == System.Int32)
  }

  public static void PrintTypes(Animal a) {
    System.Console.WriteLine(a.GetType() + " " + typeof(Animal));  // Dog Animal
    System.System.Console.WriteLine(a.GetType() == typeof(Animal));  // false
    System.Console.WriteLine(a is Animal);  // true  (Dog is Animal)
    System.Console.WriteLine(a.GetType() + " " + typeof(Dog));  // Dog Dog
    System.Console.WriteLine(a.GetType() == typeof(Dog));  // true
    System.Console.WriteLine(a is Dog);  // true (Dog is Dog)
  }
}

c++

back to top

String Concatenation

python 2

string_name = "string1" + "string2"  # "string1string2"

# String formatting
# % string operator: old style, soon to be deprecated
string_name = "%s %s" % ("string1", "string2")  # "string1 string2"

# {} operator: python 2.6 and above
# method 1
string_name = "{} {}".format("string1", "string2")  # "string1 string2"
# method 2
string_name = "{0} {1}".format("string1", "string2")  # "string1 string2"

python 3

# f string: python 3.6 and above
string1 = "string1"
string2 = "string2"
string_name = f"{string1} {string2}"  # "string1 string2"

• string formatting for numbers

a = 8

# set number of digits
# add spaces to the right for missing digits
print(f"{a:<2}")  # "8 "
#add 0s (can only be number 0) to the right for missing digits
print(f"{a:<02}")  # "80"

# add spaces to the left for missing digits
print(f"{a:>2}")  # " 8"
# add 0s (can only be number 0) to the right for missing digits
print(f"{a:>02}")  # "08"

javascript ES5

// javascript allows data type mashups, numbers will be converted to strings when concatenated with a string.
let stringName = "string1" + "string2" + 123; // "string1string2123"

javascript ES6

let string1 = "string 1 value";
let string2 = "string 2 value";
let stringName = `${string1} ${string2} 123`; // "string 1 value string 2 value 123"

ruby

string1 = "string1"
string2 = "string2"
string_name = "#{string1} #{string2}"  # "string1 string2"

string_name << "string 3"  # "string1 string2string3"

# to_s: numbers need to be converted to a string to be concatenated
puts "one" + 1.to_s  # "one1"

# %s for strings, %d for integers, %f for floats, %.3f for float with 3 decimals
printf "%s %s", "string1", "string2"  # "string1 string2"

java

String string1 = "string";
int num1 = 1;

// method 1
String stringName1 = string1 + num1;  // "string1"

// method 2
StringBuilder sb1 = new StringBuilder(string1);
sb1.append(num1);  // "string1"
// or
StringBuilder sb2 = new StringBuilder();
sb2.append(string1).append(num1);  // "string1"

sb2.delete(1, sb2.length());  // "s"

// method 3
StringBuffer sBuffer1 = new StringBuffer(string1);
sBuffer1.append(num1);
sBuffer1.toString();  // "string1"
// or
StringBuffer sBuffer2 = new StringBuffer();
sBuffer2.append(string1).append(num1);
sBuffer2.toString();  // "string1"

// method 4 (concat value must be string type)
String newString1 = string1.concat(Integer.toString(num1));  // "string1"

// method 5 (%s = string, %d = "byte, short, int, long, bigint", %c = char)
String newString2 = String.format("%s%d", string1, num1);  // "string1"

• String format reference

c#

string string1 = "string 1 value";
string string2 = "string 2 value";

// method 1
string stringName1 = string1 + string2;  // "string 1 value string 2 value"
// method 2
string stringName2 = String.Format("{0} {1}", string1, string2);  // "string 1 value string 2 value"
// method 3
string stringName3 = $"{string1} {string2}";  // "string 1 value string 2 value"

c++

back to top

JSON

python 2 & 3

import json  # must import to use

# python objects that can be converted: dict, list, tuple, string, int, float, True, False, None
# Convert JSON to python
json.loads(json_object)

# Convert python to JSON
json.dumps(python_object)

javascript

// JSON (JavaScript Object Notation): a lightweight, text-based data format that's based on JavaScript.
// convert js to JSON
let objName = { title: "Black Panther" };
objName = JSON.stringify(objName);

// convert JSON to js
let objName = { title: "Black Panther" };
objName = JSON.parse(objName);

ruby

java

c++

back to top

Program Entry Point

python 2 & 3

if __name__ === "__main__":
    # do something

javascript

// only works in node js
if (require.main === module) {
  // do something
}

ruby

java

c#

class MainClass {
  public static void Main(string[] args) {
    // do something
  }
}

c++

back to top

Swapping values

python 2 & 3

a, b = 1, 2
# method 1
temp = a
a = b
b = temp

# method 2
a, b = b, a

javascript ES5

let a = 1;
let b = 2;
const temp = a;
a = b;
b = temp;

javascript ES6

[a, b] = [b, a];

ruby

java

c++

back to top

Error Handling

python 2 & 3

• try: lets you test a block of code for errors
• except: except block lets you handle the error
  • covers all error types

    except:

  • define exception type (can write multiple except statements)

    except NameError:

  • save error to variable e

    except ValueError as e:

  • list of important error types
    • AssertionError, AttributeError, EOFError, FloatingPointError, GeneratorExit, ImportError, IndexError, KeyError
    • KeyboardInterrupt, MemoryError, NameError, NotImplementedError, OSError, OverflowError, ReferenceError, RuntimeError
    • StopIteration, SyntaxError, IndentationError, TabError, SystemError, TypeError, UnboundLocalError, UnicodeError
    • UnicodeEncodeError, UnicodeDecodeError, UnicodeTranslateError, ValueError, ZeroDivisionError
• else: code to be executed if no errors were raised
• finally: if specified, will be executed regardless if the try block raises an error or not
  • useful to close objects and clean up resources

# similar to if else
try:  # must start with try
    do_something
except:  # must have to handle errors
    do_something_if_error_occurs
else:  # not required
    do_something_if_no_error
finally:  # not required
    do_something_when_try_&_except_or_else_is_completed

javascript

• try: lets you test a block of code for errors
• catch: lets you handle the error
• finally: lets you execute code, after try and catch, regardless of the result

try {
  doSomething;
} catch (error) {
  doSomethingIfErrorOccurs;
} finally {
  doSomethingWhenTryAndCatchIsCompleted;
}

ruby

• begin: something which might raise an exception
• rescue: code that deals with some exception
• else: code that runs only if no exception was raised
• ensure: ensure that this code always runs, no matter what

begin
  doSomething
rescue SomeExceptionClass => storeErrorToThisVariable
  doSomethingIfErrorOccurs
else
  doSomethingIfNoError
ensure
  doSomethingWhenEverythingIsCompleted
end

java

• try: lets you test a block of code for errors
• catch: lets you handle the error
  • use "Exception" keyword to catch all exception types
  • use specific exception types to catch that specific exception
    • exceptions are from java.lang library, so no imports are required
  • catch block can be chained (specific exception with highest priority should come first)
• finally: lets you execute code, after try and catch, regardless of the result
  • very important for closing a file when an opened file in the try block triggered an exception

try {
  doSomething;
} catch(SomeSpecificException e) {
  doSomethingIfErrorOccursRelatedToSomESpecificException;
} catch(Exception e) {  // e is an arg (mandatory), e can be used to print general or more detailed error
  doSomethingIfErrorOccursRelatedToAllExceptions;
} finally {
  doSomethingWhenTryAndCatchIsCompleted;
}

• try with resources statement
  • only for java 8 or later versions, can't be used on android
  • it is a try statement that declares 1 or more ressources
  • a resource is an object that must be closed after the program is finished with it

// type 1
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.FileWriter;

public class Main {
    // try-with-resources
    try (BufferedReader bReader = new BufferedReader(new FileReader(sourceFile))) {
      return bReader.readLine();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

// type 2
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.FileWriter;

public class Main {
  public static void main(String[] args) {
    String sourceFile = "textfile";  // textfile path
    String targetFile = "newtextfile";  // newtextfile path

    // try-with-resources
    try (
      FileReader fReader = new FileReader(sourceFile);  // read file
      BufferedReader bReader = new BufferedReader(fReader);  // read lines in file
      FileWriter writer = new FileWriter(targetFile);  // write file
      ) {
      while (true) {
        String line = bReader.readLine();
        if (line == null) {
          break;
        } else {
          writer.write(line + "\n");
        }
      }
      System.out.println("File copied");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

c#

• try: lets you test a block of code for errors
• catch: lets you handle the error
  • use "Exception" keyword to catch all exception types
  • use specific exception types to catch that specific exception
  • catch block can be chained (specific exception with highest priority should come first)
• finally: lets you execute code, after try and catch, regardless of the result
  • very important for closing a file when an opened file in the try block triggered an exception

try {
  doSomething;
} catch(SomeSpecificException e) {
  doSomethingIfErrorOccursRelatedToSomESpecificException;
} catch(Exception e) {  // e is an arg (is not mandatory), e can be used to print general or more detailed error
  doSomethingIfErrorOccursRelatedToAllExceptions;
} finally {
  doSomethingWhenTryAndCatchIsCompleted;
}

• Create custom exception

public class NewExceptionName : System.Exception {
  public NewExceptionName(string message, System.Exception innerException)
    : base(message, innerException)
    {}
}

c++

back to top

Custom Error

python 2 & 3

# raise generic exception
raise Exception("custom message")

# raise specific exception
raise ValueError("custom message")

javascript

throw "custom message"; // throw a text

throw 123; // throw a number

ruby

# method 1
raise errorType, "custom error message"
# method 2
raise errorType.new("custom error message")

java

• must use either try catch statements or be inside a conditional statement to work

// if using try catch, both throw and catch must handle the same Exception type
try {
  // raise specific exception
  throw new SpecificExceptionName("custom message");

  // raise generic exception
  throw new Exception("custom message");
} catch (SpecificExceptionName e) {
} catch (Exception e) {
}


if (true) {
  // raise generic exception
  throw new Exception("custom message");
}

c#

// raise generic exception
throw new System.Exception("custom message");


// raise specific exception
throw new SpecificExceptionName("custom message");

c++

back to top

Asynchronous

• Handling asynchronous code (making it synchronous)

python

javascript ES5

var posts = [
  { title: "Post 1", body: "body of post 1" },
  { title: "Post 2", body: "body of post 2" },
];

// callback is required if need getPost to display data after createPost is called
// reason is because createPost takes longer time to complete compared to getPost
function createPost(post, callback) {
  setTimeout(() => {
    posts.push(post);
    callback();
  }, 2000);
}

// method 1
// callback function
function getPosts() {
  setTimeout(() => {
    var output = "";
    posts.forEach((post, index) => {
      output += post.title;
    });
    console.log(output);
  }, 1000);
}
createPost({ title: "Post 3", body: "body of post 3" }, getPosts);

// method 2:
// Using anonymous callback function can lead to callback hell if over used
createPost({ title: "Post 3", body: "body of post 3" }, function () {
  setTimeout(() => {
    var output = "";
    posts.forEach((post, index) => {
      output += post.title;
    });
    console.log(output);
  }, 1000);
});

javascript ES6

// Change createPost to return a Promise
function createPost(post) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (post) {
        posts.push(post);
        resolve();
      } else {
        reject("error");
      }
    }, 2000);
  });
}

// method 3
// use .then() instead of callback
createPost({ title: "Post 3", body: "body of post 3" })
  .then(getPosts) // can chain multiple promises by adding .then(do_something)
  .catch((error) => console.log(error));

// method 4
// use Promise.all
Promise.all([
  // can chain multiple promises
  createPost({ title: "Post 3", body: "body of post 3" }),
]).then((values) => {
  getPosts();
  console.log(values); // output array of results e.g [promise1_output, promise2_output, ...]
});

javascript ES8

// method 5
// use async / await when calling functions
async function init() {
  await createPost({ title: "Post 3", body: "body of post 3" });
  getPosts();
}
init();

• the difference between process.nextTick vs asynchronous / callback
  • process.nextTick() runs immediately after the current synchronous execution, before I/O and timers.
    • it is not part of the event loop phases! Instead, it uses the Next Tick Queue, which has the highest priority.
  • asynchronous code runs after the event loop finishes processing the current execution, in the Timer Queue.
• Order which comes first
  1. Synchronous Code runs first. (take note that anything in a Promise constructor might come first based on sequential order whichever was called first)
  2. Next Tick Queue (process.nextTick()) runs immediately before moving to the event loop.
  3. Microtask Queue (Promise.then(), queueMicrotask()) runs after the Next Tick Queue before the event loop continues.
  4. Timer Queue (setTimeout(), setInterval()) runs in the Timers Phase of the event loop.

async function example() {
    return new Promise((resolve) => {
        console.log("promise constructor");
        resolve();
    }).then(() => {
        console.log("promise");
    });
}

async function run() {
    console.log("start");

    setTimeout(() => console.log("timeout"), 0);

    example();

    process.nextTick(() => console.log("next tick"));

    console.log("end");
}

await run();
// start
// promise constructor ✅ (appears before next tick, because it runs immediately inside the Promise constructor. Unlike Promise.then() (which would defer execution), this runs synchronously)
// end
// next tick
// promise
// timeout

ruby

java

c#

class MainClass {
    public static void Main(string[] args) {
        System.Console.WriteLine("Starting");
        Worker worker = new Worker();
        worker.DoWork();  // since this is any async function, add this to stack then move on
        while (!worker.IsComplete) {
            System.Threading.Thread.Sleep(100);
            System.Console.Write(".");
        }
        System.Console.WriteLine("Done");
    }

    public static System.Threading.Tasks.Task DelayOperation() {
        return System.Threading.Tasks.Task.Factory.StartNew(() => {
            System.Threading.Thread.Sleep(2000);
        });
    }
}

public class Worker {
    public bool IsComplete { get; private set; }

    public async void DoWork() {  // add async to make function an async
        this.IsComplete = false;
        System.Console.WriteLine("Doing work");
        await LongOperation();  // wait for the function to finish before proceeding
        IsComplete = true;
        System.Console.WriteLine("Work completed");
    }

    private System.Threading.Tasks.Task LongOperation() {
        return System.Threading.Tasks.Task.Factory.StartNew(() => {
            System.Console.WriteLine("Working!");
            System.Threading.Thread.Sleep(2000);
        });
    }
}

c++

back to top

Math

python 3

import math

print("abs(-1) ", abs(-1))  # abs(-1)  1
print("max(5, 4) ", max(5, 4))  # max(5, 4)  5
print("min(5, 4) ", min(5, 4))  # min(5, 4)  4
print("pow(2, 2) ", pow(2, 2))  # pow(2, 2)  4
print("ceil(4.5) ", math.ceil(4.5))  # ceil(4.5)  5
print("floor(4.5) ", math.floor(4.5))  # floor(4.5)  4
print("round(4.5) ", round(4.5))  # round(4.5)  4
print("exp(1) ", math.exp(1))  # e**x  # exp(1)  2.718281828459045
print("log(e) ", math.log(math.exp(1)))  # log(e)  1.0
print("log(100) ", math.log(100, 10))  # Base 10 Log  # log(100)  2.0
print("sqrt(100) ", math.sqrt(100))  # sqrt(100)  10.0
print("sin(0) ", math.sin(0))  # sin(0)  0.0
print("cos(0) ", math.cos(0))  # cos(0)  1.0
print("tan(0) ", math.tan(0))  # tan(0)  0.0
print("asin(0) ", math.asin(0))  # asin(0)  0.0
print("acos(0) ", math.acos(0))  # acos(0)  1.5707963267948966
print("atan(0) ", math.atan(0))  # atan(0)  0.0
print("sinh(0) ", math.sinh(0))  # sinh(0)  0.0
print("cosh(0) ", math.cosh(0))  # cosh(0)  1.0
print("tanh(0) ", math.tanh(0))  # tanh(0)  0.0
print("asinh(0) ", math.asinh(0))  # asinh(0)  0.0
print("acosh(pi) ", math.acosh(math.pi))  # acosh(pi)  1.811526272460853
print("atanh(0) ", math.atanh(0))  # atanh(0)  0.0
print("hypot(0) ", math.hypot(10, 10))  # sqrt(x*x + y*y)  # hypot(0)  14.142135623730951
print("radians(0) ", math.radians(0))  # radians(0)  0.0
print("degrees(pi) ", math.degrees(math.pi))  # degrees(pi)  180.0

# infinity value
math.inf

import random
# random integer
random.randint(1, 3)  # any number from 1 to 3

javascript

Math.abs(-1); // 1

Math.pow(-4, 2); // 16, same as (-4) ** 2

// random integer from 0 to 9
Math.floor(Math.random() * 10);
// similar to
~~(Math.random() * 10);

// random integer from 0 to 10
Math.floor(Math.random() * 11);

// random integer from 0 to 10
Math.floor(Math.random() * 11);

// random integer from 1 to 10
Math.floor(Math.random() * 10) + 1;

ruby

java

import java.util.Random;

double number1 = 10.5;
double number2 = 15;

System.out.println("Math.abs(number1) " + (Math.abs(number1)));  // Math.abs(number1) 10.5
System.out.println("Math.ceil(number1) " + (Math.ceil(number1)));  // Math.ceil(number1) 11
System.out.println("Math.floor(number1) " + (Math.floor(number1)));  // Math.floor(number1) 10
System.out.println("Math.max(number1, number2) " + (Math.max(number1, number2)));  // Math.max(number1, number2) 15
System.out.println("Math.min(number1, number2) " + (Math.min(number1, number2)));  // Math.min(number1, number2) 10.5
System.out.println("Math.pow(number1, 2) " + (Math.pow(number1, 2)));  // Math.pow(number1, 2) 110.25
System.out.println("Math.round(number1) " + (Math.round(number1)));  // Math.round(number1) 10
System.out.println("Math.sqrt(number1) " + (Math.sqrt(number1)));  // Math.sqrt(number1) 3.24037034920393

System.out.println("Random Number Between 0 and 10 = " + (int)(Math.random() * 11 + 1 + 0));  // Math.random() * (max - min + 1) + min2 = change min2 to 1 to become between 1 and 10

Random rand = new Random();
System.out.println("Random Number Between 0 and 10 " + (rand.nextInt(11)));
System.out.println("Random Number Between 1 and 10 " + (rand.nextInt(10 - 1 + 1) + 1));  // rand.nextInt((max - min) + 1) + min;

c#

double number1 = 10.5;
double number2 = 15;

System.Console.WriteLine("Math.Abs(number1) " + (Math.Abs(number1)));  // Math.Abs(number1) 10.5
System.Console.WriteLine("Math.Ceiling(number1) " + (Math.Ceiling(number1)));  // Math.Ceiling(number1) 11
System.Console.WriteLine("Math.Floor(number1) " + (Math.Floor(number1)));  // Math.Floor(number1) 10
System.Console.WriteLine("Math.Max(number1, number2) " + (Math.Max(number1, number2)));  // Math.Max(number1, number2) 15
System.Console.WriteLine("Math.Min(number1, number2) " + (Math.Min(number1, number2)));  // Math.Min(number1, number2) 10.5
System.Console.WriteLine("Math.Pow(number1, 2) " + (Math.Pow(number1, 2)));  // Math.Pow(number1, 2) 110.25
System.Console.WriteLine("Math.Round(number1) " + (Math.Round(number1)));  // Math.Round(number1) 10
System.Console.WriteLine("Math.Sqrt(number1) " + (Math.Sqrt(number1)));  // Math.Sqrt(number1) 3.24037034920393

Random rand = new Random();
System.Console.WriteLine("Random Number Between 1 and 10 " + (rand.Next(1,11)));

c++

// Seed the random number generator with the time method, then convert value to integer
srand((int)time(0));
// Get the random number from the seed & save it to a variable
int randomNumber = rand() % 100;  // number range from 0 to 99

back to top

Date and Time

python3

from datetime import date, datetime, timedelta
import calendar

# get today's date from the today method from the date class
today = date.today()
print("Today's date is ", today)  # Today's date is  2021-07-16

# print out the date's individual components
print("Date components: ", today.day, today.month,
      today.year)  # Date components:  16 7 2021

# retrieve today's weekday (0=Monday, 6=Sunday)
print("Today's weekday # is: ", today.weekday())  # Today's weekday # is:  4

# get today's date from the datetime class
today = datetime.now()
print("The current date and time is ", today)  # The current date and time is  2021-07-16 18:33:33.510322

# get the current time
t = datetime.time(datetime.now())
print(t)  # 18:34:40.676073

# Times and dates can be formatted using a set of predefined string control codes
now = datetime.now()
# Date formatting
# %y/%Y - year, %a/%A - weekday, %b/%B - month, %d - day of month
print(now.strftime("%a/%A, %d %D %b/%B, %y/%Y"))  # Fri/Friday, 16 07/16/21 Jul/July, 21/2021

# %c - locale's date and time, %x - locale's date, %X - locale's time
print(now.strftime("Locale date and time: %c"))  # Locale date and time: Fri Jul 16 18:47:27 2021
print(now.strftime("Locale date: %x"))  # Locale date: 07/16/21
print(now.strftime("Locale time: %X"))  # Locale time: 18:48:32

# Time formatting
# %I/%H - 12/24 hour, %M - minute, %S - second, %p - locale's AM/PM
print(now.strftime("Current time: %I:%M:%S %p"))  # Current time: 06:58:10 PM
print(now.strftime("24-hour time: %H:%M"))  # 24-hour time: 18:58

# construct a basic timedelta
print(timedelta(days=365, hours=5, minutes=1))  # 365 days, 5:01:00

# today's date
now = datetime.now()
print("today is: ", str(now))  # today is:  2021-07-16 19:05:19.744915

# today's date 1 year from now
print("one year from now it will be: ", str(now + timedelta(days=365)))  # one year from now it will be:  2022-07-16 19:06:45.299792

# create a timedelta that uses more than one argument
print("In 2 days and 3 weeks, it will be ",
      str(now + timedelta(days=2, weeks=3)))  # In 2 days and 3 weeks, it will be  2021-08-08 19:40:39.554060

# calculate the date 1 week ago, formatted as a string
t = datetime.now() - timedelta(weeks=1)
s = t.strftime("%A %B %d, %Y")
print("One week ago it was: ", s)  # One week ago it was:  Friday July 09, 2021

# How many days until April Fools' Day
today = date.today()  # 2021-07-16
afd = date(today.year, 4, 1)  # 2021-04-01
print((today - afd).days)  # 106
afd = afd.replace(year=today.year + 1)  # 2022-04-01

# calculate the amount of time until April Fool's day
time_to_afd = afd - today  # 259

# create a text calendar
# the day (SUNDAY) states the 1st day of the week in the calendar
c = calendar.TextCalendar(calendar.SUNDAY)
st = c.formatmonth(2017, 1, 0, 0)
print(st)
'''
    January 2017
Su Mo Tu We Th Fr Sa
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31
'''

# create an HTML formatted calendar
hc = calendar.HTMLCalendar(calendar.SUNDAY)
st = hc.formatmonth(2017, 1)
print(st)  # bunch of html tags

# loop over the days of a month
# 0s mean that the day of the week is in an overlapping month
for i in c.itermonthdays(2017, 8):
    print(i)

# Calendar module provides useful utilities for the given locale
# such as the names of days and months in both full and abbreviated forms
for month_name in calendar.month_name:
    print(month_name)
for day_name in calendar.day_name:
    print(day_name)

# calculate all the first Fridays of every month
for m in range(1, 13):
    cal = calendar.monthcalendar(2018, m)
    weekone = cal[0]
    weektwo = cal[1]
    meetday = weekone[calendar.FRIDAY] if weekone[calendar.FRIDAY] != 0 else weektwo[calendar.FRIDAY]
    print("%10s %2d" % (calendar.month_name[m], meetday))

javascript

ruby

# get current date and time
Time.now

java

• must import

import java.util.Date;
import java.util.GregorianCalendar;
import java.text.DateFormat;
import java.util.Locale;
import java.time.LocalDateTime;  // java 8
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

Date d = new Date();  // Fri Jul 09 00:46:09 SGT 2021

// January = 0, Feburary = 1, ...
GregorianCalendar gc = new GregorianCalendar(2009, 1, 28);
gc.add(GregorianCalendar.DATE, 1);  // add a day
Date d2 = gc.getTime();  // Sun Mar 01 00:00:00 SGT 2009

// format date
// method 1, with no specific style and locale
DateFormat df = DateFormat.getDateInstance();
System.out.println(df.format(d2));  // Mar 1, 2009
// method 2, with style and no locale
DateFormat df2 = DateFormat.getDateInstance(DateFormat.FULL);
System.out.println(df2.format(d2));  // Sunday, March 1, 2009
// method 3, with style and locale
Locale locale = new Locale("en_SG", "SGP");  // set as Singapore
DateFormat df3 = DateFormat.getDateInstance(DateFormat.FULL, locale);
System.out.println(df3.format(d2));  // 2009 Mar 1, Sun

LocalDateTime ldt = LocalDateTime.now();  // 2021-07-09T01:03:50.874932

// January = 1, Feburary = 2, ...
LocalDate ld = LocalDate.of(2009, 1, 28);  // 2009-01-28

DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE;
System.out.println(dtf.format(ld));  // 2009-01-28

// format with a specific pattern
DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("M/d/yyyy");
System.out.println(dtf2.format(ld));  // 1/28/2009

c#

// Set date (time set to default at 12:00:00 AM)
System.DateTime newDate = new System.DateTime(2015, 1, 1);


// Get current date (time set to default at 12:00:00 AM)
System.DateTime todayDate = System.DateTime.Today;  // 1/14/2020 12:00:00 AM


// Get current date and time
System.DateTime now = System.DateTime.Now;  // 1/14/2020 10:19:54 AM


// Add or reduce days
now.AddDays(1);  // add 1 day
now.AddDays(-10;  // reduce 1 day


// Display formats
System.Console.WriteLine(now);  // 1/14/2020 10:23:09 AM
System.Console.WriteLine(now.ToLongDateString());  // Tuesday, January 14, 2020
System.Console.WriteLine(now.ToShortDateString());  // 1/14/2020
System.Console.WriteLine(now.ToLongTimeString());  // 10:23:09 AM
System.Console.WriteLine(now.ToShortTimeString());  // 10:23 AM
System.Console.WriteLine(now.ToString());  // 1/14/2020 10:23:09 AM
System.Console.WriteLine(now.ToString("yyyy-MM-dd"));  // 2020-01-14
System.Console.WriteLine(now.ToString("yyyy-MM-dd HH:mm"));  // 2020-01-14 10:26

c++

back to top

File System

python

• Modifying files

# Open a file for writing and create file if it doesn't exist
# file will be rewritten if contents already exists
f = open("textfile", "w+")
for i in range(10):  # write some lines of data to the file
    f.write(f"this is line {str(i)}\r\n")
f.close()  # close file when done


# Open a file and append text to the end
f = open("textfile", "a")
for i in range(10):
    f.write(f"this is line {str(i)}\r\n")
f.close()


# Open and read file
f = open("textfile", "r")
if f.mode == "r":
    contents = f.read()  # reads the entire content
    print(contents)


f = open("textfile", "r")
if f.mode == "r":
    fl = f.readlines()  # reads per line
    for x in fl:
        print(x)

• path utilities

import os
from os import path
import datetime
import time


print(os.name)  # get OS name

# check if file exist and file type
print(path.exists("textfile"))  # True
print(path.isfile("textfile"))  # True
print(path.isdir("textfile"))  # False

# get file paths
print(path.realpath("textfile"))  # /path/to/textfile
print(path.split(path.realpath("textfile")))  # ('/path/to', 'textfile')

# get modificaton time
t = time.ctime(path.getmtime("textfile"))  # method 1
print(t)  # Sun Jul 18 00:16:20 2021
t2 = datetime.datetime.fromtimestamp(path.getmtime("textfile"))  # method 2
print(t2)  # 2021-07-18 00:16:20.360159

# calculate how long ago file was modified
td = datetime.datetime.now() - datetime.datetime.fromtimestamp(
    path.getmtime("textfile")
)
print(td)  # 0:19:02.185160
print(td.total_seconds())  # 1142.18516

• copy and zip files

import os
from os import path
import shutil
from shutil import make_archive
from zipfile import ZipFile


if path.exists("textfile"):
    src = path.realpath("textfile")  # get path of file in current directory
    dst = src + ".bak"  # create a backup copy by appending "bak"

    shutil.copy(src, dst)  # copy over only the the contents of file
    shutil.copytree(src, dst)  # copy over contents and all other metadata of file

    os.rename("textfile", "newtextfile")

    # zip files
    root_dir, tail = path.split(src)
    shutil.make_archive("archive", "zip", root_dir)  # zip all files in the folder

    with ZipFile("testzip.zip", "w") as newzip:  # zip only selected files
        newzip.write("textfile")
        newzip.write("textfile.bak")

javascript

ruby

java

import java.io.FileReader;
import java.io.BufferedReader;
import java.io.FileWriter;

public class Main {
  public static void main(String[] args) {
    String sourceFile = "textfile";  // sourceFile path
    String targetFile = "newtextfile";  // targetFile path

    // try with resources statement, only available for java 8 and later versions
    // can't be used on android
    try (
      FileReader fReader = new FileReader(sourceFile);  // read file
      BufferedReader bReader = new BufferedReader(fReader);  // read lines in file
      FileWriter writer = new FileWriter(targetFile);  // write file
      ) {
      while (true) {
        String line = bReader.readLine();
        if (line == null) {
          break;
        } else {
          writer.write(line + "\n");
        }
      }
      System.out.println("File copied");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    String subDirectory = "";  // parent folder where the file is located
    String sourceFilename = "textfile";
    String targetFilename = "newtargetfile3";

    // only for java 7 or later versions, not available for android
    Path sourceFile = Paths.get(subDirectory, sourceFilename);
    Path targetFile = Paths.get(subDirectory, targetFilename);

    try {
      // copy existing file contents into the new file
      Files.copy(sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

• using commons-io library to copy file
  • for latest versions and for android
  • download the commons-io jar file
  • create a lib folder inside the root folder of your project and move the commons-io jar file into it
  • then add the jar file into the class path

import org.apache.commons.io.FileUtils;  // common-io library

import java.io.File;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    File sourceFile = new File("path/to/file.txt");
    File targetFile = new File("path/to/newfile.txt");

    try {
      // use commons-io
      FileUtils.copyFile(sourceFile, targetFile);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

• reading a text file over the internet

import java.net.URL;
import java.io.InputStream;
import java.io.BufferedInputStream;
import java.io.IOException;

public class Main {
  private static final String FLOWERS_FEED = "https://services.hanselandpetal.com/feeds/flowers.xml";

  // adding the throws block allow code to run safely without having to write another try catch statement in the finally block
  public static void main(String[] args) throws IOException {
    InputStream stream = null;
    BufferedInputStream buf = null;
    try {
      URL url = new URL(FLOWERS_FEED);
      stream = url.openStream();
      buf = new BufferedInputStream(stream);

      StringBuilder sb = new StringBuilder();

      while (true) {
        int data = buf.read();  // gets a single character from stream, returns a character integer value if found else returns -1

        if (data == -1) {
          break;
        } else {
          sb.append((char) data);  // translate the integer value into a character
        }
      }
      System.out.println(sb);
    } catch(IOException e) {
      e.printStackTrace();
    } finally {
      // use finally to explicitly close the stream
      stream.close();
      buf.close();
    }
  }
}

c#

// Create or Save file
string filename = @"/my/file/path/fileFolder/filename.txt";
string textString = "data to save in file";
System.IO.File.WriteAllText(filename, textString);  // existing file will be overwritten

// Copy file
bool overwrite = true;  // overwrite file if exist, else return an File already exists exception
string toBeCopiedFile = @"/my/file/path/fileFolder/filename.txt";
string toPasteFile = @"/my/file/path/fileFolder/filenameCopied";
// method 1
System.IO.File.Copy(toBeCopiedFile, toPasteFile, overwrite);
// method 2
System.IO.FileInfo file = new System.IO.FileInfo(toBeCopiedFile);
file.CopyTo(toPasteFile, overwrite);


// Check if file exists
// method 1
System.IO.File.Exists(toPasteFile);  // true
// method 2
file.Exists;  // true


// Get text from file
string content = System.IO.File.ReadAllText(toPasteFile);


// Delete file
System.IO.File.Delete(toPasteFile);  // method 1
file.Delete();  // method 2 (deletes toBeCopiedFile)


// Create new folder
string folder = @"/my/file/path/folderName";
System.IO.Directory.CreateDirectory(folder);  // does not overwrite if folder already exists


// Get file in folder
// method 1
string searchPattern = "*.*";  // eg. get only .jpg files -> "*.jpg"
string[] filesArray = System.IO.Directory.GetFiles(folder, searchPattern, SearchOption.AllDirectories);
// method 2
System.IO.DirectoryInfo dirInfo = new System.IO.DirectoryInfo(folder);
System.IO.FileInfo[] filesArray2 = dirInfo.GetFiles("*", SearchOption.AllDirectories);


// Get folders in folder
string[] foldersArray = System.IO.Directory.GetDirectories(folder, searchPattern, SearchOption.AllDirectories);
System.IO.DirectoryInfo[] foldersArray = dirInfo.GetDirectories();


// Check if folder exists
System.IO.Directory.Exists(folder);  // true


// Get filename of a file from path
Path.GetFileName(toBeCopiedFile);  // "filename.txt"


// Get file extension of a file from path
Path.GetExtension(toBeCopiedFile);  // ".txt"


// Get filename without file extension of a file from path
Path.GetFileNameWithoutExtension(toBeCopiedFile);  // "filename"


// Get directory name of a file from path
Path.GetDirectoryName(toBeCopiedFile);  // "fileFolder"


// Open file (not in app)
System.Diagnostics.Process.Start(filename);

c++

back to top

Access modifier

• use to hide the implementation details of a class

python

javascript

typescript

• 3 types
  • Public:
    • By default, members (properties and methods) of TypeScript class are public
    • Public members are accessible everywhere without restrictions
  • Private:
    • A private member cannot be accessed outside of its containing class
    • Private members can be accessed only within the class.
  • Protected:
    • A protected member cannot be accessed outside of its containing class
    • Protected members can be accessed only within the class and by the instance of its sub/child class.

ruby

java

c#

• 6 types
  • public: accessible from everywhere in project, no accessibility restrictions

class NumberClass
{
    public int number = 10;
}

class MainClass
{
    static void Main(string[] args)
    {
        NumberClass num = new NumberClass();
        System.Console.WriteLine(num.number);  // This is OK. The number variable has the public access modifier.
    }
}

• private: accessible only from inside a class or a structure, can't access them outside the class they are created

class NumberClass
{
    private int number = 10;
}

class MainClass
{
    static void Main(string[] args)
    {
        NumberClass num = new NumberClass();
        System.Console.WriteLine(num.number);  // Error. We can't access the number variable because
        // it has the private access modifier and its only accessible in the NumberClass class
    }
}

• protected: object is accessible inside the class and in all classes that derive from that class

class NumberClass
{
    protected int number = 10;  // we can access this variable inside this class
}

class DerivedClass: NumberClass  // this is inheritance. DerivedClass derives from the NumberClass class
{
    void Print()
    {
        System.Console.WriteLine(number);  // we can access it in this class as well because it derives from the NumberClass class
    }
}

class MainClass
{
    void Print()
    {
        NumberClass num = new NumberClass();
        System.Console.WriteLine(num.number);  // Error. The number variable is inaccessible due to its protection level.
        // The Program class doesn't derive from the NumberClass
    }
}

• internal: object is accessible only inside its own assembly (project) but not in other assemblies (projects)

//First Project (ASSEMBLY)
public class NumberClassInFirstProject
{
    internal int number = 10;  // we can access this variable inside this class
}

class Program1
{
    public static void Main()
    {
        NumberClassInFirstProject num = new NumberClassInFirstProject();
        System.Console.WriteLine(num.number);  // This is OK. Anywhere in this project (assembly)
        // we can access the number variable.
    }
}


//Second project (ASSEMBLY)
class Program2
{
    public static void Main()
    {
        NumberClassInFirstProject num = new NumberClassInFirstProject();
        System.Console.WriteLine(num.number);  // Error. The number variable is inaccessible due to its protection level.
        // The Program class in second project can't access the internal members from another project
    }
}

• protected internal: a combination of protected and internal, can access the protected internal member only in the same assembly (project) or in a derived class in other assemblies (projects)

//First Project (ASSEMBLY)
public class NumberClassInFirstProject
{
    protected internal int number = 10;  // we can access this variable inside this class
}

class Program1
{
    public static void Main()
    {
        NumberClassInFirstProject num = new NumberClassInFirstProject();
        System.Console.WriteLine(num.number);  // This is OK. Anywhere in this project (assembly) we can access the number variable.
    }
}

//Second project (ASSEMBLY)
class Program2: NumberClassInFirstProject  // Inheritance
{
    public static void Main()
    {
        System.Console.WriteLine(number);  // This is OK as well. The class Program derives from the NumberClassInFirstProject class.
    }
}

• private protected: a combination of private and protected, can access members inside the containing class or in a class that derives from a containing class, but only in the same assembly (project)

c++

back to top

Iterators

python

javascript

let i = [1, 2];

let iterator = i[Symbol.iterator]();

iterator.next(); // { value: 1, done: false }
iterator.next(); // { value: 2, done: false }
iterator.next(); // { value: undefined, done: true }

ruby

java

• using iterators to loop through collections

// import java.util.List;
// import java.util.ArrayList;
// import java.util.Iterator;  // must import

List<String> list = new ArrayList<>();
list.add("Japan");
list.add("China");
list.add("USA");

// method 1: using Iterator
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
  String value = iterator.next();
  System.out.println(value);
}
// method 2: using forEach loop
for (String value: list) {
  System.out.println(value);
}
// method 3: using List's forEach method, only available for Java 8 onwards, not included in android java 8
list.forEach(System.out::println);  // method 1
list.forEach((s) -> {System.out.println(s});  // method 2


// loop hash maps with Iterator
// import java.util.Map;
// import java.util.HashMap;
// import java.util.Set;
// import java.Iterator;
Map<String, String> map = new HashMap<>();
map.put("jp", "Japan");
map.put("sg", "Singapore");
map.put("usa", "United States");
Set<String> keys = map.keySet();

Iterator<String> iterator = keys.iterator();
while (iterator.hasNext()) {
  String key = iterator.next();
  System.out.println(map.get(key));
}

// loop has maps with forEach
for (String key : keys) {
  System.out.println(map.get(key));
}

c#

c++

back to top

Generators

python

def generator_example():
    yield 1

x = generator_example():
next(x)  # 1

def infinite_maker():
    i = 0
    while True:
        yield i
        i += 1

x = infinite_maker()
next(x)  # 0
next(x)  # 1

# generator expression
y = (i for i in range(10))
print(next(y))  # 0
print(next(y))  # 1


# send, throw, close method
def generator_ex():
    num = 0
    while True:
        j = yield num
        if j is not None:
            num = j
        num += 1


x = generator_ex()
for i in x:
    print(i)  # prints out the yield result of num
    digits = len(str(i))
    if (i > 100):
        # method 1
        x.throw(ValueError("value is above 100"))
        # method 2
        x.close()  # raises StopIteration, an exception used to signal the end of a finite iterator
    # when a yield result is available, return the new value into the generator (eg.: j takes the new value)
    x.send(10 ** (digits))  # 0 12 102

javascript

function* generatorExample1() {
  yield 1;
  yield 2;
}

function* generatorExample2() {
  yield 1;
  yield 2;
}

let iterator1 = generatorExample1();
let iterator2 = generatorExample2();

iterator1.next(); // { value: 1, done: false }
iterator1.next(); // { value: 2, done: false }
iterator1.next(); // { value: undefined, done: true }

iterator2.next(); // { value: 1, done: false }
iterator2.next(); // { value: 2, done: false }
iterator2.next(); // { value: undefined, done: true }

// does not cause stackoverflow for infinite loops
function* infiniteMaker() {
  let i = 0;
  while (true) {
    yield i;
    i++;
  }
}

let iterator3 = infiteMaker();
iterator3.next(); // { value: 0, done: false }
iterator3.next(); // { value: 1, done: false }

// nested generators
function* nestedGenerator() {
  yield* generatorExample1(); // add * after yield to add another generator
  yield 3;
}

let iterator4 = nestedGenerator();
iterator4.next(); // { value: 1, done: false }
iterator4.next(); // { value: 2, done: false }
iterator4.next(); // { value: 3, done: false }
iterator4.next(); // { value: undefined, done: true }

// using return keyword will stop the generator
function* generatorWithReturn() {
  yield 1;
  return "hello"; // done will become true here
  yield 2;
}

let iterator5 = generatorWithReturn();
iterator5.next(); // { value: 1, done: false }
iterator5.next(); // { value: "hello", done: true }
iterator5.next(); // { value: undefined, done: true }

ruby

java

c#

c++

back to top

Fetching Web Data

python

• fetching a webpage

import urllib.request


response = urllib.request.urlopen("http://www.google.com")
print(response.getcode())  # get response status code

data = response.read()
print(data)  # google html tags

• fetching a json from an api

import urllib.request
import json


def print_json(raw_data):
    get_json_data = json.loads(raw_data)  # load string data into a dictionary
    if "title" in get_json_data["metadata"]:
        print(get_json_data["metadata"]["title"])

    count = get_json_data["metadata"]["count"]
    print(count)

    for feature in get_json_data["features"]:
        print(feature["properties"]["place"])


api_url = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_day.geojson"

# open the URL and read the data
response = urllib.request.urlopen(api_url)
status_code = response.getcode()

print(status_code)

if (status_code == 200):
    data = response.read()
    print_json(data)
else:
    print("Error")

• manipulate XML

import xml.dom.minidom


doc = xml.dom.minidom.parse("samplexml.xml")  # parse the xml file
print(doc.nodeName)
print(doc.firstChild.tagName)

skills = doc.getElementsByTagName("skill")
print(f"%d skills: {skills.length}")
for skill in skills:
    print(skill.getAttribute("name"))

# create a new XML tag and add it into the document
new_skill = doc.createElement("skill")  # create a new skill tag
new_skill.setAttribute("name", "jQuery")
doc.firstChild.appendChild(new_skill)  # adds to memory but not persisted

skills = doc.getElementsByTagName("skill")
print(f"%d skills: {skills.length}")
for skill in skills:
    print(skill.getAttribute("name"))

Javascript

ruby

java

c#

c++

back to top

Enum

python 3

from enum import Enum

class Methods(Enum):
  GET = "GET_VALUE"

# get value
print(Method.GET.value)  # "GET_VALUE"
print(Method("GET_VALUE").value)  # "GET_VALUE"

# get key
print(Method.GET.name)  # "GET"
print(Method("GET_VALUE").name)  # "GET"

# check if value exist in Enum
print("GET_VALUE" in Methods._value2member_map_)  # True
print("GET" in Methods._value2member_map_)  # False

# check if name exist in Enum
print("GET_VALUE" in Methods._member_names_)  # False
print("GET" in Methods._member_names_)  # True

Javascript

const color = {
  Red: 1,
  Green: 2,
  Blue: 3,
};

Typescript

• Enum: By default, enums begin numbering their members starting at 0

enum Color {
  Red,
  Green,
  Blue,
}
let c: Color = Color.Green; // 1
let colorName: string = Color[1]; // "Green"

enum Color {
  Red = 1,
  Green,
  Blue,
}
let c: Color = Color.Green; // 2
let colorName: string = Color[2]; // "Green"

ruby

java

• ENUM
• Enumerations are lists of possible values that you can use for any particular variable
• An enumeration in java is called an enum class.

// usual enums
public enum Names1 {
  JOHN, PETER;
}

// setting a string value for enums
public enum Names2 {
  JOHN("John"), PETER("Peter");

  private String name;

  Names2(String name) {
    this.name = name;
  }

  @Override
  public String toString() {
    return this.name;
  }
}

public class Person {
  private Names1 name1 = Names1.JOHN;  // using enum to set a constant variable
  private Names2 name2 = Names2.JOHN;

  public Names1 getName1() {
    return this.name1;
  }

  public Names2 getName2() {
    return this.name2;
  }
}

public class Main {
  public static void main(String[] args) {
    Person p = new Person();
    System.out.println(p.getName1());  // "JOHN"
    System.out.println(p.getName2());  // "John"
  }
}

c#

• Enum
  • Used to manage number type constants for better clarity and maintainability
  • Can be declared in namespace, in classes
  • By default, enums begin numbering their members starting at 0

// not reccommended method
const int RegularAirMail = 1;
const int RegisteredAirMail = 2;
const int Express = 3;

// Use enums for better management and for clarity
// default data type is an integer
public enum ShippingMethod : byte  // use : byte to change default data type
{
  // if value is not assigned, 1st value will start with 0
  // subsequent value will be incremented by 1 automatically if value is not assigned
  RegularAirMail = 1,
  RegisteredAirMail = 2,
  Express = 3
}

// get string value (ToString method not required if using System.Console.WriteLine)
ShippingMethod method = ShippingMethod.Express.ToString();  // Express
// get number value
ShippingMethod method = (int) ShippingMethod.Express;  // 3

// retrieve string value with number value
ShippingMethod methodType = (ShippingMethod) 3;  // Express

c++

enum Color { red, green, blue };

// enum limitations
// 2 enumerations cannot share the same names (use enum class instead)
enum Color2 { red, green, blue };  // throws a compilation error

// no variable can have a name which is already in some enumeration
int red = 0;  // throws a compilation error

// enums are not type safe
enum Gender { male, female };
Gender gender = male;
Color color = red;
if (gender == color)  // gender != color but will return true as both value are 0
{
   cout << "Equal";
}

• Enum class / scoped enumerations
  • makes enumeration both strongly typed & strongly scoped
  • does not allow implicit conversion to int
  • does not compare enumerators from a different enumerations

// Declaration
enum class Color{ Red, Green, Blue};

// Initialisation
Color col = Color::Red;

back to top

Language Specific

python

• Shebang line / hashbang
  • it is a common pattern for unix based systems
  • allows a script to be invoked from the command line
  • written on the first line in the python file
  • #! marks the shebang

#!/usr/bin/env python3

# List comprehension
# original method
arr = []
for i in range(5):
 arr.append(i)
print(arr)  # [0, 1, 2, 3, 4]

# List comprehension method
arr = [i for i in range(5)]
print(arr)  # [0, 1, 2, 3, 4]

# List comprehension with conditional statement
arr = [i for i in range(5) if i < 3]
print(arr)  # [0, 1, 2]

# Tuples (similar to list, but are immutable)
tuple1 = (1, 2, "3")

# Sets (only have unique values)
# create set
set1 = set([1, 2])  # method 1
set2 = {1, 2}  # method 2

# join 2 sets together
set3 = set1 | set2  # {1, 2}

# add element to set
set1.add(3)  # {1, 2, 3}

# add set2 to set1
set1 |= set2  # {1, 2, 3}

# remove element from set from element
set1.discard(2)  # {1, 3}

# Get intersection of 2 sets
set1.intersection(set2)  # {1}

# Get unique value from the 2 sets
set1.symmetric_difference(set2)  # {2, 3}

# Get values from set1 that set2 does not have
set1.difference(set2)  # {3}

# delete all values from set
set1.clear()  # set()

# Create a set that cannot be modified
set_fixed = frozenset([1, 2, 3])

# modify global variable from local
var = "from global"

print(var)  # from global

def convert_local_to_global:
    global var  # without the keyword global, cannot modify global variable var locally unlike javascript
    var = "from local"

print(var)  # from local

# undefine an existing variable
var = 123

print(var)  # 123

del var

print(var)  # NameError: name 'var' is not defined

# find the sum of values that are True in an array
sum([True, False, True])  # 2

# convert character to number
ord("a")  # 97

# convert number to character
chr(97)  # a

• function annotatins
• int, float, bool, str, bytes, None
• python 3.8 & earlier, list, set, dict, tuple
  • list[int], dict[float, str], Tuple[int, ...]
• python 3.9+
  • can import types from typing library

from typing import List, Set, Dict, Tuple, Optional, Callable, Iterator, Union, Any, cast, Mapping, MutableMapping, Sequence, Match, AnyStr, IO

isValid: bool = True;

def foo(a:”int”, b:”float”=5.0)  -> ”int”:
    pass


x: Optional[str] = some_function()  # use Optional[] for values that could be None

x: Callable[[int, float], float] = f

# A generator function that yields ints is secretly just a function that
# returns an iterator of ints,
def g(n: int) -> Iterator[int]:
    i = 0
    while i < n:
        yield i
        i += 1

# can also split a function annotation over multiple lines
def send_email(address: Union[str, List[str]],
               sender: str,
               cc: Optional[List[str]],
               bcc: Optional[List[str]],
               subject='',
               body: Optional[List[str]] = None
               ) -> bool:

# An argument can be declared positional-only by giving it a name starting with two underscores:
def quux(__x: int) -> None:
    pass

quux(3)  # Fine
quux(__x=3)  # Error

# To find out what type mypy infers for an expression anywhere in
# your program, wrap it in reveal_type().  Mypy will print an error
# message with the type; remove it again before running the code.
reveal_type(1)  # -> Revealed type is "builtins.int"

# Use Union when something could be one of a few types
x: List[Union[int, str]] = [3, 5, "test", "fun"]

# Use Any if you don't know the type of something or it's too
# dynamic to write a type for
x: Any = mystery_function()

# If you initialize a variable with an empty container or "None"
# you may have to help mypy a bit by providing a type annotation
x: List[str] = []
x: Optional[str] = None

# This makes each positional arg and each keyword arg a "str"
def call(self, *args: str, **kwargs: str) -> str:
    request = make_request(*args, **kwargs)
    return self.do_api_query(request)

# Use a "type: ignore" comment to suppress errors on a given line,
# when your code confuses mypy or runs into an outright bug in mypy.
# Good practice is to comment every "ignore" with a bug link
# (in mypy, typeshed, or your own code) or an explanation of the issue.
x = confusing_function()  # type: ignore  # https://github.com/python/mypy/issues/1167

# "cast" is a helper function that lets you override the inferred
# type of an expression. It's only for mypy -- there's no runtime check.
a = [4]
b = cast(List[int], a)  # Passes fine
c = cast(List[str], a)  # Passes fine (no runtime check)
reveal_type(c)  # -> Revealed type is "builtins.list[builtins.str]"
print(c)  # -> [4]; the object is not cast

# If you want dynamic attributes on your class, have it override "__setattr__"
# or "__getattr__" in a stub or in your source code.
#
# "__setattr__" allows for dynamic assignment to names
# "__getattr__" allows for dynamic access to names
class A:
    # This will allow assignment to any A.x, if x is the same type as "value"
    # (use "value: Any" to allow arbitrary types)
    def __setattr__(self, name: str, value: int) -> None: ...

    # This will allow access to any A.x, if x is compatible with the return type
    def __getattr__(self, name: str) -> int: ...

a.foo = 42  # Works
a.bar = 'Ex-parrot'  # Fails type checking

# Use Iterable for generic iterables (anything usable in "for"),
# and Sequence where a sequence (supporting "len" and "__getitem__") is
# required
def f(ints: Iterable[int]) -> List[str]:
    return [str(x) for x in ints]

f(range(1, 3))

# Mapping describes a dict-like object (with "__getitem__") that we won't
# mutate, and MutableMapping one (with "__setitem__") that we might
def f(my_mapping: Mapping[int, str]) -> List[int]:
    my_mapping[5] = 'maybe'  # if we try this, mypy will throw an error...
    return list(my_mapping.keys())

f({3: 'yes', 4: 'no'})

def f(my_mapping: MutableMapping[int, str]) -> Set[str]:
    my_mapping[5] = 'maybe'  # ...but mypy is OK with this.
    return set(my_mapping.values())

f({3: 'yes', 4: 'no'})

# User-defined classes are valid as types in annotations
x: MyClass = MyClass()

# "typing.Match" describes regex matches from the re module
import re
x: Match[str] = re.match(r'[0-9]+', "15")

# Use IO[] for functions that should accept or return any
# object that comes from an open() call (IO[] does not
# distinguish between reading, writing or other modes)
def get_sys_IO(mode: str = 'w') -> IO[str]:
    if mode == 'w':
        return sys.stdout
    elif mode == 'r':
        return sys.stdin
    else:
        return sys.stdout

• Async await

import asyncio

# A coroutine is typed like a normal function
async def countdown35(tag: str, count: int) -> str:
    while count > 0:
        print('T-minus {} ({})'.format(count, tag))
        await asyncio.sleep(0.1)
        count -= 1
    return "Blastoff!"

javascript

• Set

// Create a Set
const letters = new Set(["a", "b"]); // or new Set();

// Add Values to the Set
letters.add("c");

// size of set
letters.size; // 3

// check if value exist
letters.has("a"); // true

// delete an element
letters.delete("a");

// loop through a set, keys and values are the same
for (const letter of letters.keys()) {
  // similar to letters.values
  console.log(letter);
}

// loop through a set and get both keys and values
for (const letter of letters.entries()) {
  // similar to letters.values
  console.log(letter); // ["b", "b"]
}

// delete everything in the set
letters.clear();

// convert character at index 0 to number
"a".charCodeAt(); // 97

// convert character at a specific index to number
"abc".charCodeAt(1); // 98

// convert number to character
String.fromCharCode(97); // "a"

• Explicit Binding
  • choose what we want the context of "this" to be by using call, apply or bind
  • by refering to the call, apply, or bind methods, you can determine the value of "this"
  • can only be used on FUNCTIONS

/*
NAME OF METHOD  | PARAMETERS                | INVOKE IMMEDIATELY?
    CALL        |   thisArg,a,b,c,...       |       Yes
    APPLY       |   thisArg,[a,b,c,...]     |       Yes
    BIND        |   thisArg,a,b,c,...       |       No

CALL args can be set to anything and can have infinite arguments, function is immediately invoked
APPLY only takes 2 args, the 2nd arg is an array of infinite arguments, function is immediately invoked
BIND can have infinite arguments, and is a method that returns a function definition
*/
var foo = {
  firstName: "Foo",
  say: function() {
    return "Hi " + this.firstName;
  },
  add: function(a, b, c) {
    return this.firstName + " just calculated " + (a + b + c);
  }
}
var bar = {
  firstName: "Bar"
}
// Call: allow this to be referenced to bar instead of foo, all arguments must not be undefined
foo.say() // returns "Hi Foo"
foo.say.call(bar) // returns "Hi Bar"
foo.add.call(bar, 1, 2, 3); // returns "Bar just calculated 6"

// Apply: simlar to Call for the 1st argument, 2nd argument has to be an array of values, all arguments must not be undefined
foo.say.apply(bar) // returns "Hi Bar"
foo.add.apply(bar, [1, 2, 3]); // returns "Bar just calculated 6"

// Bind: returns the function, then requires it to be called
// all agruments need not be defined upfront, but must provide remaining arguments when calling
var say = foo.say.bind(bar);
say(); // returns "Hi Bar"
var add = foo.add.bind(bar, 1, 2);
add(3); // returns "Bar just calculated 6"

// Bind is commonly used when dealing with asynchronous code
var foo = {
  firstName: "Foo",
  say: function() {
    setTimeout(function() {
      console.log("Hi " + this.firstName;
    }.bind(this), 1000);
  }
}
foo.say(); // prints "Hi Foo", if without bind(this), prints "Hi undefined"

• Proxy
  • checks for the number of times the field in the object has been accessed
  • each time the field has been accessed, the defined logic will occur

const target = {};
const handler = {
  get: function (targetObj, field) {
    if (field === "nextId") {
      // field name must be the same when called
      if (targetObj[field] === undefined) {
        targetObj[field] = 1;
        return targetObj[field];
      }
      targetObj[field]++;
      return targetObj[field];
    }
    return undefined;
  },
};

const proxy = new Proxy(target, handler);
console.log(proxy.nextId); // 1  (field name must be the same as when doing the conditional check)
console.log(proxy.nextId); // 2
console.log(proxy.nextId); // 3

typescript

• Declaring with type as "any": use to declare variable type if you do not know its type
  • will receive an error if use methods for the wrong type (no auto checking)

let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean

• Tuples: allow you to express an array with a fixed number of elements whose types are known, but need not be the same (immutable)

// Declare a tuple type
let x: [string, number];
// Initialize it
x = ["hello", 10]; // OK
// Initialize it incorrectly
x = [10, "hello"]; // Error

• Generics

// "T" can be name as anything, used "T" due to convention
function genericFunc<T>(value: T): T {
  // T is the type base on the value type given in the parameter when called
  return value;
}

console.log(genericFunc("str type")); // type are declared base on the input value type
console.log(genericFunc(123));
console.log(genericFunc(false));

ruby

java

• Number formatting

long longValue = 10_000_000;
// method 1
// using "import java.text.NumberFormat;"
NumberFormat formatter = NumberFormat.getNumberInstance();
String formatted = formatter.format(lognValue);  // "10,000,000" (us locale)
// method 2
// using "import java.util.Locale;"
Locale locale = new Locale("da", "DK");  // set as Denmark
NumberFormat formatter = NumberFormat.getNumberInstance(locale);
String formatted = formatter.format(lognValue);  // "10.000.000" (dk locale)

• Currency formatting

long longValue = 10_000_000.00;
// method 1
// using "import java.text.NumberFormat;"
NumberFormat formatter = NumberFormat.getCurrencyInstance();
String formatted = formatter.format(lognValue);  // "$10,000,000.00" (us locale)
// method 2
// using "import java.util.Locale;"
Locale locale = new Locale("da", "DK");  // set as Denmark
NumberFormat formatter = NumberFormat.getCurrencyInstance(locale);
String formatted = formatter.format(lognValue);  // "kr10.000.000,00" (dk locale)

• Integer formatting

long longValue = 10_000_000.89;
// method 1
// using "import java.text.NumberFormat;"
NumberFormat formatter = NumberFormat.getIntegerInstance();
String formatted = formatter.format(lognValue);  // "10,000,001" (us locale)
// method 2
// using "import java.util.Locale;"
Locale locale = new Locale("da", "DK");  // set as Denmark
NumberFormat formatter = NumberFormat.getIntegerInstance(locale);
String formatted = formatter.format(lognValue);  // "10.000.001" (dk locale)

• double colon operator / method reference operator

  • <Class name>::<method name>

  • can be used for

    • a static method

    import java.util.*;
    
    class GFG {
      // static function to be called
      static void someFunction(String s)
      {
        System.out.println(s);
      }
    
      public static void main(String[] args)
      {
        List<String> list = new ArrayList<String>();
        list.add("Geeks");
        list.add("For");
        list.add("GEEKS");
    
        // call the static method
        // using double colon operator
        list.forEach(GFG::someFunction);
      }
    }

    • an instance method

    import java.util.*;
    
    class GFG {
      // instance function to be called
      void someFunction(String s)
      {
        System.out.println(s);
      }
    
      public static void main(String[] args)
      {
        List<String> list = new ArrayList<String>();
        list.add("Geeks");
        list.add("For");
        list.add("GEEKS");
    
        // call the instance method
        // using double colon operator
        list.forEach((new GFG())::someFunction);
      }
    }

    • super method

    import java.util.*;
    import java.util.function.*;
    
    class Test {
      // super function to be called
      String print(String str)
      {
        return ("Hello " + str + "\n");
      }
    }
    
    class GFG extends Test {
      // instance method to override super method
      @Override
      String print(String s)
      {
        // call the super method
        // using double colon operator
        Function<String, String> func = super::print;
    
        String newValue = func.apply(s);
        newValue += "Bye " + s + "\n";
        System.out.println(newValue);
        return newValue;
      }
    
      // Driver code
      public static void main(String[] args)
      {
        List<String> list = new ArrayList<String>();
        list.add("Geeks");
        list.add("For");
        list.add("GEEKS");
    
        // call the instance method
        // using double colon operator
        list.forEach(new GFG()::print);
      }
    }

    • Instance method of an arbitrary object of a particular type

    import java.util.*;
    
    class Test {
      String str=null;
    
      Test(String s)
      {
        this.str=s;
      }
      // instance function to be called
      void someFunction()
      {
        System.out.println(this.str);
      }
    }
    
    class GFG {
      public static void main(String[] args)
      {
        List<Test> list = new ArrayList<Test>();
        list.add(new Test("Geeks"));
        list.add(new Test("For"));
        list.add(new Test("GEEKS"));
    
        // call the instance method
        // using double colon operator
        list.forEach(Test::someFunction);
      }
    }

    • a constructor

    import java.util.*;
    
    class GFG {
      // Class constructor
      public GFG(String s)
      {
        System.out.println("Hello " + s);
      }
    
      // Driver code
      public static void main(String[] args)
      {
        List<String> list = new ArrayList<String>();
        list.add("Geeks");
        list.add("For");
        list.add("GEEKS");
    
        // call the class constructor
        // using double colon operator
        list.forEach(GFG::new);
      }
    }

c#

• Overloading
  • having multiple similar methods with different signatures
  • allows multiple different input data types for the same feature

// Overloading constructors
// overloaded constructors are separate
public class Print {
  public Print() {
    System.Console.Write("test");
  }

  public Print(string x) {
    System.Console.Write(x);
  }
}

class MainClass {
  public static void Main(string[] args) {
    Print print = new Print();  // "first"
    Print print2 = new Print("second");  // "second"
  }
}


// overloaded constructors are linked
public class Print {
  public Print() {
    System.Console.Write("first");
  }

  public Print(string x) : this() {  // add ": this()" to link with default constructor
    System.Console.Write(x);
  }
}

class MainClass {
  public static void Main(string[] args) {
    Print print = new Print("second");  // "firstsecond"
  }
}


// Overloading methods
public class Point {
  public int X;
  public int Y;

  public Point(int x, int y) {  // constructor
    this.X = x;
    this.Y = y;
  }

  public void Move (int x, int y) {
    this.X = x;
    this.Y = y;
  }

  public void Move(Point newLocation) {  // overloading the 1st Move method
    Move(newLocation.X, newLocation.Y);
  }
}

• Overflowing
  • c# does not check for overflow
    • this means that value of a variable can be modified during runtime and when the value goes beyond the boundary of it's data type, overflow will occur
    • e.g.: byte num = 255; num++; // num value will be the surplus value (in this case 0)

// If overflow is not desired, use checked keyword to enable overflow checking
// In the following example, increment will not occur and an exception will be thrown, which will cause an error
checked {
  byte number = 255;
  number++;
}

• Ref Modifier
  • Modifies value type
  • when pasing a value type to a method, a copy of the variable is sent to the method
    • changes applied to that variable in the method will not be visible upon return from the method
  • the value type can be modified using the ref modifier
    • when the ref modifier is used, a reference to the original variable will be sent to the target method

// typical value type cannot be modified case
public class Calculator {
  public int Add(int num){
    num += 2;
  }
}

class MainClass {
  public static void Main(string[] args) {
    Calculator cal = new Calculator3();
    int num = 1;
    cal.Add(num);
    System.Console.WriteLine(num);  // 1
  }
}


// using Ref Modifier
public class Calculator {
  public int Add(ref int num){  // add ref keyword
    num += 2;
  }
}

class MainClass {
  public static void Main(string[] args) {
    Calculator cal = new Calculator3();
    int num = 1;
    cal.Add(ref num);  // add ref keyword
    System.Console.WriteLine(num);  // 3
  }
}

• Out Modifier
  • use to return multiple values from a method
  • any parameter declared with the out modifier is expected to receive a value at the end of the method

// not using the "out" keyword will result in an error
public class Person {
  public void GetName(string name){
    name = "myName";
  }
}

class MainClass {
  public static void Main(string[] args) {
    Person person = new Person();
    string name;  // unassigned local variable error
    person.GetName(name);
    System.Console.WriteLine(name);
  }
}


// using the "out" keyword
public class Person {
  public void GetName(out string name){
    name = "myName";
  }
}

class MainClass {
  public static void Main(string[] args) {
    Person person = new Person();
    string name;
    person.GetName(out name);
    System.Console.WriteLine(name);  // "myName"
  }
}

• Readonly modifier
  • Prevents accidental overwriting of the value

// without readonly modifier
public System.Collections.Generic.List<int> orders = new System.Collections.Generic.List<int>();

public void MakeOrder() {
  orders = new System.Collections.Generic.List<int>();  // a new list will be reassigned
}


// using readonly modifier
public readonly System.Collections.Generic.List<int> orders = new System.Collections.Generic.List<int>();

public void MakeOrder() {
  orders = new System.Collections.Generic.List<int>();  // this will produce an error that the variable cannot be assigned
}

• Abstract modifier (polymorphism)
  • what?
    • indicates that a class or a member (method) is missing implementation
    • if a method is declared as abstract, the containing class needs to be declared as abstract too
    • the abstract methods must be implemented in the child class
    • abstract classes cannot be instantiated
  • why?
    • use abstract when you want to provide some common behavior, while forcing other developers to follow your design

public abstract class ParentClassName {  // if a method has an abstract keyword, the class must also have the abstract keyword
  public abstract void FunctionName();  // this will allow the child class to override this method
}

• Virtual modifier (polymorphism)
  • Used to modify a method, property, indexer, or event declaration and allow for it to be overridden in a derived (child) class
  • cannot be used with the static, abstract, private, or override modifiers

public class ParentClassName {
  public virtual void FunctionName() {  // this will allow the child class to override this method
    do_something;
  }
}

• Override modifier (polymorphism)
  • required to extend or modify the abstract or virtual implementation of an inherited method, property, indexer, or event

public class ChildClassName : ParentClassName {
  public override void FunctionName() {  // this will override the inherited method
    do_something;
  }
}

• Sealed modifier (polymorphism)
  • prevents other classes from inheriting from it
  • it is the opposite of abstract classes
  • Use sealed modifier because selaed classes are slightly faster due to some run-time optimizations

// method 1: applying sealed modifier to the child class will prevent us from being able to create a class that derives from the child class
public sealed class ChildClassName : ParentClassName {  // new class will not be able to inherit from ChildClassName
  public override void FunctionName() {
    do_something;
  }
}


// method 2: applying sealed modifier to the overriding methods
public class ChildClassName : ParentClassName {
  public sealed override void FunctionName() {  // new class will be able to inherit from ChildClassName but will be unable to override the FunctionName that is sealed
    do_something;
  }
}

• Dynamic type
  • does not work on Apple products (Mac, IOS)
  • converting dynamic to static type does not require casting

// static type
string a = "test";  // cannot reassign to a different data type

// dynamic type
dynamic b = "test";  // allows variable to be reassigned to a different data type
b = 123;

• Generics
  • allows the creating of types that use other types
  • make classes reusable and with type-safety

public class Stack<T> {  // let data type be T
  public T testValue { get; set; }
  private System.Collections.Generic.List<T> stack = new System.Collections.Generic.List<T>();  // use data type

  public T Peek() {  // set return data type as T
    try {
      return stack[stack.Count - 1];
    } catch (System.ArgumentOutOfRangeException) {
      return default(T);  // return default value of data type T
    }
  }

  public void Push(T data) {  // set arg data type as T
    stack.Add(data);
  }

  public T Pop() {
    int lastIndex = stack.Count - 1;
    T val = stack[lastIndex];  // set data type as T
    stack.RemoveAt(lastIndex);
    return val;
  }
}

public class Printer {
  public void Print<T>(Stack<T> stack) {
    System.Console.WriteLine(stack.testValue);
  }
}

class MainClass {
  public static void Main() {
    Stack<string> s = new Stack<string>() {testValue="abc"};  // method 1
    // Stack<string> s = new Stack<string> {testValue="abc"};  // method 2
    // Stack<string> s = new Stack<string>();  // method 3
    Printer p = new Printer();
    p.Print(s);  // "abc", method 3 will cause this to result with ""
  }
}

• Generic contraints
  • Contraints are validations that we can put on generic type parameter
  • at the instantiation time of generic class, if client provides invalid type parameter then compiler will give an error
  • 6 types of contraints

1. where T : InterfaceName

// method 1: defining generics in methods with contraints
public class Maths {
  public int Max(int a, int b) {  // normal method
    return a > b ? a : b;
  }

  public T Max<T>(T a, T b) where T : System.IComparable {
    // return a > b ? a : b;  // this will produce an error
    return a.CompareTo(b) > 0 ? a : b;
  }
}

class MainClass {
  public static void Main() {
    Maths m = new Maths();
    int max1 = m.Max(2, 8);  // 8
    float max2 = m.Max(3.3f, 6.5f);  // 6.5
  }
}


// method 2: defining generics at class with contraints
public class Maths<T> where T : System.IComparable {
  public int Max(int a, int b) {  // normal method
    return a > b ? a : b;
  }

  public T Max(T a, T b) {
    return a.CompareTo(b) > 0 ? a : b;
  }
}

class MainClass {
  public static void Main() {
    Maths<int> m = new Maths<int>();
    int max1 = m.Max(2, 8);  // 8
    Maths<float> m = new Maths<float>();
    float max2 = m.Max(3.3f, 6.5f);  // 6.5
  }
}

2. where T : parentClass

public class Product {
  public string Title { get; set; }
  public float Price { get; set; }
}

public class Calculator<T> where T : Product {
  public float Cost(T product) {
    return product.Price;
  }
}

class MainClass {
  public static void Main() {
    Product p = new Product { Price = 2.3f };
    Calculator<Product> c = new Calculator<Product>();
    System.Console.WriteLine(c.Cost(p));  // 2.3
  }
}

3. where T : struct

public class Nullable<T> where T : struct {
    private object _value;

    public bool HasValue {
        get { return _value != null; }
    }

    public Nullable() { }

    public Nullable(T value) {
        _value = value;
    }

    public T GetValueOrDefault() {
        if (HasValue)
            return (T)_value;
        return default(T);
    }
}

class MainClass {
    public static void Main() {
        Nullable<int> num = new Nullable<int>(5);
        System.Console.WriteLine(num.HasValue);  // true
        System.Console.WriteLine(num.GetValueOrDefault());  // 5

        Nullable<int> num2 = new Nullable<int>();
        System.Console.WriteLine(num2.HasValue);  // false
        System.Console.WriteLine(num2.GetValueOrDefault());  // 0

        Nullable<string> str = new Nullable<string>();  // error as string is not a value type
    }
}

4. where T : class

public class NodeList<T> where T : class
{}

class MainClass {
    public static void Main(string[] args) {
        NodeList<int> nodesOfInt = new NodeList<int>();  // error as int is a value type
        NodeList<string> nodesOfString = new NodeList<string>();  // string is a reference type
        NodeList<Employee> nodesOfEmployee = new NodeList<Employee>();  // Employee is a reference type
        NodeList<EventHandler> nodesOfAction = new NodeList<EventHandler>();  //EventHandler is a delegate and a reference type
    }
}

5. where T : new()

• new() represents default constructor
• no parameters allowed

public class NodeList<T> where T : new()
{}

public class ClassName1 {
    public ClassName1()
    {}
}

public class ClassName2 {
    public ClassName2(dataType argName)
    {}
}

class MainClass {
    public static void Main(string[] args){
        NodeList<ClassName1> c1 = new NodeList<ClassName1>();  // no error
        NodeList<ClassName2> c2 = new NodeList<ClassName2>();  // error as parameters are not allowed
    }
}

6. where T : U

• 2 argument types (T and U)
• U can be an interface, abstract class, or simple class
• T must inherit or implements the U class

public class NodeList<T, U> where T : U {
    public void DoWork(T subClass, U baseClass)
    {}
}

public interface IEmployee
{}

public class Employee : IEmployee
{}

class MainClass{
    public static void Main() {
        NodeList<Employee, IEmployee> employeeNodes = new NodeList<Employee, IEmployee>();
    }
}

• Delegates
  • it is an object that knows how to call a method (or a group of methods)
  • it is a reference or a pointer to a function
  • it is for designing extensible and flexible apps (eg frameworks)

// without parameters
public delegate void DelegateName();  // use of "delegate" keyword is required

class MainClass {
  public static void Main() {
    // initialize delegate
    DelegateName delegateName = new DelegateName(DoSomethingMethod);  // method 1
    delegateName();  // run delegate

    DelegateName delegateName2 = DoSomethingMethod;  // method 2
    delegateName2();

    DelegateName delegateName3 = DoSomethingMethod;
    RunDelegate(delegateName3);  // method 3

    DelegateName delegateName4 = GetMyDelegate();  // method 4
    RunDelegate(delegateName4);

    DelegateName delegateName5 = delegate() { doSomething; }  // method 5: using anonymous methods
    delegateName5();

    DelegateName delegateName6 = delegate() { return doSomething; }  // method 6: return value with anonymous methods
    dataType variableName = delegateName6();

    DelegateName delegateName7 = () => { return doSomething; }  // method 7: return value with lambda expression
    dataType variableName = delegateName7();
  }

  public static void DoSomethingMethod() {
    doSomething;
  }

  public static void RunDelegate(DelegateName delegateName3) {
    delegateName3();
  }

  public static DelegateName GetMyDelegate() {
    return new DelegateName(DoSomethingMethod);
  }
}


// with parameters
public delegate void DelegateName(dataType argName);  // dataType must be the same as the pointed function

class MainClass {
  public static void Main() {
    // initialize delegate
    DelegateName delegateName = new DelegateName(DoSomethingMethod);  // method 1
    delegateName(argName_contents);  // must pass in argument

    DelegateName delegateName2 = DoSomethingMethod;  // method 2
    delegateName2(argName_contents);  // must pass in argument

    DelegateName delegateName3 = DoSomethingMethod;
    RunDelegate(delegateName3);  // method 3

    DelegateName delegateName4 = GetMyDelegate();  // method 4
    RunDelegate(delegateName4);

    DelegateName delegateName5 = delegate(dataType argName) { doSomethingWith_argName; }  // method 5: using anonymous methods
    delegateName5(argName_contents);

    DelegateName delegateName6 = delegate(dataType argName) { return doSomethingWith_argName; }  // method 6: return value with anonymous methods
    dataType variableName = delegateName6(argName_contents);

    DelegateName delegateName7 = (dataType argName) => { return doSomethingWith_argName; }  // method 7: return value with lambda expression
    dataType variableName = delegateName7(argName_contents);
  }

  public static void DoSomethingMethod(dataType argName) {  // dataType must be the same as the delegate
    doSomethingWith_argName;
  }

  public static void RunDelegate(DelegateName delegateName3) {
    delegateName3(argName_contents);  // must pass in argument
  }

  public static DelegateName GetMyDelegate() {
    return new DelegateName(DoSomethingMethod);
  }
}


// usage example
public delegate void Operation(int num);

class MainClass
{
    public static void Main(string[] args)
    {
        // method 1
        Operation op = Double;
        ExecuteOperation(2, op);  // result 4, display 4
        op = Triple;
        ExecuteOperation(2, op);  // result 6, display 46

        // method 2: use chaining
        Operation op2 = Double;
        op2 += Triple;
        ExecuteOperation(2, op2);  // 46
    }

    public static void Double(int num) {
        System.Console.Write(num * 2);
    }

    public static void Triple(int num) {
        System.Console.Write(num * 3);
    }

    public static void ExecuteOperation(int num, Operation operation) {
        operation(num);
    }
}

• Generic Delegates
  • Action: does not return a value
  • Func: returns a value

class MainClass
{
    public static void Main(string[] args)
    {
        // Declares delegate and operation in 1 line, does not return a value
        System.Action<int> op = num => { System.Console.WriteLine(num * 2); };  // similar to the Double example above
        op(3);  // 4

        // Declares delegate and operation in 1 line, returns a value
        // set input dataTypes first then output dataType
        System.Func<int, int> op2 = num => { return num * 3; };
        System.Console.WriteLine(op2(2));  // 6
    }
}

• Events
  • it is a way for 1 object to subscribe to events that are happening within another object and then do some sort of logic around that

// naive way of writing events
public class Person {
    private string _name;
    private ClockTower _tower;

    public Person(string name, ClockTower tower) {
        _name = name;
        _tower = tower;

        // chain events
        _tower.Chime += () => System.Console.WriteLine($"{_name} heard the chime.");
    }
}

public delegate void ChimeEventHandler();

public class ClockTower {
    public event ChimeEventHandler Chime;  // more events can be created to handle the different chime timings but it is hard coding

    public void ChimeFivePM() {
        Chime();
    }

    public void ChimeSixAM() {
        Chime();
    }
}

class MainClass {
    static void Main(string[] args) {
        // 1 tower
        ClockTower tower = new ClockTower();
        // 1 tower watched by multiple People
        Person person1 = new Person("John", tower);
        Person person2 = new Person("Sally", tower);
        tower.ChimeFivePM();  // can't tell the difference between the 2 events
        /*
        John heard the chime.
        Sally heard the chime.
        */
        tower.ChimeSixAM();  // can't tell the difference between the 2 events
        /*
        John heard the chime.
        Sally heard the chime.
        */
    }
}


// Using Event args
public class Person {  // subscriber
    private string _name;
    private ClockTower _tower;

    public Person(string name, ClockTower tower) {
        _name = name;
        _tower = tower;

        // chain events with +=
        // use event args in switch case to manage multiple cases
        _tower.Chime += (object sender, ClockTowerEventArgs args) =>
        {
            System.Console.WriteLine($"{_name} heard the chime from {((ClockTower)sender).name}.");
            switch(args.Time) {
                case 6: System.Console.WriteLine($"{_name} is waking up!");
                    break;
                case 17: System.Console.WriteLine($"{_name} is going home!");
                    break;
                default: break;
            }
        };
    }
}

public class ClockTowerEventArgs : System.EventArgs {  // create event class to distinsh between multiple cases
    public int Time { get; set; }
}

public delegate void ChimeEventHandler(object sender, ClockTowerEventArgs args);  // add event args to enable handling of multiple cases for 1 event type

public class ClockTower {  // publisher
    public string name = "tower A";
    public event ChimeEventHandler Chime;  // 1 event type to handle multiple cases

    public void ChimeFivePM() {
        Chime(this, new ClockTowerEventArgs { Time = 17 });  // use event class to create unique case
    }

    public void ChimeSixAM() {
        Chime(this, new ClockTowerEventArgs { Time = 6 });  // use event class to create unique case
    }
}

class MainClass {
    static void Main(string[] args) {
        // 1 tower
        ClockTower tower = new ClockTower();
        // 1 tower watched by multiple People
        Person person1 = new Person("John", tower);
        Person person2 = new Person("Sally", tower);
        tower.ChimeSixAM();
        /*
        John heard the chime from tower A.
        John is waking up!
        Sally heard the chime from tower A.
        Sally is waking up!
        */
        tower.ChimeFivePM();
        /*
        John heard the chime from tower A.
        John is going home!
        Sally heard the chime from tower A.
        Sally is going home!
        */
    }
}


// Using System.EventHandler (auto generate delegates)
public class Person {  // subscriber
    private string _name;
    private ClockTower _tower;

    public Person(string name, ClockTower tower) {
        _name = name;
        _tower = tower;

        // chain events with +=
        // use event args in switch case to manage multiple cases
        _tower.Chime += (object sender, ClockTowerEventArgs args) =>
        {
            System.Console.WriteLine($"{_name} heard the chime from {((ClockTower)sender).name}.");
            switch(args.Time) {
                case 6: System.Console.WriteLine($"{_name} is waking up!");
                    break;
                case 17: System.Console.WriteLine($"{_name} is going home!");
                    break;
                default: break;
            }
        };
    }
}

public class ClockTowerEventArgs : System.EventArgs {  // create event class to distinsh between multiple cases
    public int Time { get; set; }
}

// public delegate void ChimeEventHandler(object sender, ClockTowerEventArgs args);  // not required

public class ClockTower {
    public string name = "tower A";
    // public event ChimeEventHandler Chime;  // convert to the following
    public event System.EventHandler<ClockTowerEventArgs> Chime;  // by using Sysmtem.EventHandler it handles the delegate declaration for us

    public void ChimeFivePM() {
        Chime(this, new ClockTowerEventArgs { Time = 17 });
    }

    public void ChimeSixAM() {
        Chime(this, new ClockTowerEventArgs { Time = 6 });
    }
}

class MainClass {
    static void Main(string[] args) {
        ClockTower tower = new ClockTower();
        Person person1 = new Person("John", tower);
        Person person2 = new Person("Sally", tower);
        tower.ChimeSixAM();
        tower.ChimeFivePM();
    }
}

• Extension methods
  • allow us to add methods to an existing class without changing its source code or creating a new class that inherits from it
  • if have source code, modify source code instead of creating extension methods

public class Person {  // given to us by others, this source code we can't see or modify directly
    public string Name { get; set; }
    public int Age { get; set; }
}

public static class Extensions {  // creates an extension of the Person class by using the static in class declaration
    public static void SayHello(this Person person, Person person2) {  // this keyword must be added only for the 1st arg
        System.Console.WriteLine($"{person.Name} says hello to {person2.Name}");
    }
}

class MainClass {
    static void Main(string[] args) {
        Person p = new Person { Name = "John", Age = 21 };
        Person p2 = new Person { Name = "Sally", Age = 25 };
        p.SayHello(p2);  // "John says hello to Sally"
    }
}

• LINQ: Language Integrated Query
  • gives the capability to query objects
  • can qury
    • objects in memory, eg collections (LINQ to Objects)
    • Databases (LINQ to Entities)
    • XML (LINQ to XML)
    • ADO.NET Data Sets (LINQ to Data Sets)
  • keywords
    • where: set conditions
    • orderby
      • ascending order

        orderby variableName

      • descending order

        orderby variableName descending

    • select
      • cannot be used with group keyword
      • query result will become an array of values
      • must end with a ;

        select variableName;

    • group
      • cannot be used with select keyword
      • query result will become an array of dictionaries
      • must end with a ;

        group variableName by variableName;

// simple example
using System.Linq;  // this is required for query usage

class MainClass {
  public static void Main() {
    string sample = "The quick brown fox jumps over the lazy dog.";

    var resultArr = from c in sample.ToLower()
                    where c== 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'
                    orderby c
                    select c;
                    // group c by c;
    foreach (var c in resultArr)
      System.Console.WriteLine(c);  // use for select to get value
      // System.Console.WriteLine(c.Key);  // use for group to get value
  }
}


// realistic example
using System.Linq;

public class Person {
  public string FirstName { get; set; }
  public string LastName { get; set; }
  public int Age { get; set; }
}

class MainClass {
  public static void Main() {
    System.Collections.Generic.List<Person> people = new System.Collections.Generic.List<Person> {
      new Person{FirstName="John", LastName="Doe", Age=25},
      new Person{FirstName="John2", LastName="Doe2", Age=26},
      new Person{FirstName="John3", LastName="Doe3", Age=20},
    };

    // method 1: LINQ Query Operators
    var resultArr = from p in people
                    where p.Age < 25
                    select p;

    // method 2: LINQ Extension methods
    // var resultArr = person.Where(p => p.Age < 25).Select(p => p);

    foreach (var item in resultArr)
      System.Console.WriteLine(item.FirstName);  // prints out firstnames of those with age less than 25
  }
}

• Reflection

public class Sample {
    public string Name { get; set; }
    public int Age;

    public void MyMethod() { }
}

class Program
{
    static void Main(string[] args)
    {
        var assembly = System.Reflection.Assembly.GetExecutingAssembly();
        System.Console.WriteLine(assembly.FullName);  // Override, Version=1.0.7333.32664, Culture=neutral, PublicKeyToken=null
        var types = assembly.GetTypes();
        foreach (var type in types) {
            System.Console.WriteLine("class: " + type.Name + " BaseType: " + type.BaseType);  // class: Program BaseType: System.Object
            var props = type.GetProperties();
            foreach (var prop in props)
                System.Console.WriteLine("Property name: " + prop.Name + " Property type: " + prop.PropertyType);  // Property name: Name Property type: System.String
            var fields = type.GetFields();
            foreach (var field in fields)
                System.Console.WriteLine("Field: " + field.Name);  // Field: Age
            var methods = type.GetMethods();
            foreach (var method in methods)
                System.Console.WriteLine("Method: " + method.Name);
                /*
                // class: Program
                Method: Equals
                Method: GetHashCode
                Method: GetType
                Method: ToString

                // class: Sample
                Method: get_Name
                Method: set_Name
                Method: MyMethod
                Method: Equals
                Method: GetHashCode
                Method: GetType
                Method: ToString
                */
        }
    }
}

c++

• References

// using without references
int num = 10;
int newNum = num;

num++;  // num = 11, newNum = 10
newNum++;  // num = 11, newNum = 11


// using references
int num = 10;
int& referenceNum = num;  // add & when referencing

num++;  // num = 11, referenceNum = 11
referenceNum++;  // num = 12, referenceNum = 12

back to top