Programming Cheatsheet

Author : MD TAREQ HASSAN | Updated : 2023/02/18

First program

Hello world:

namespace PracticeXyz
{
    public class Program
    {
        public static void Main(string[] args)
        {
            
            Console.WriteLine("Hello, World!");
        }
    }
}

Simple user input:

namespace PracticeXyz
{
    public class Program
    {
        public static void Main(string[] args)
        {

            Console.WriteLine("Enter some text: ");

            string userInput = Console.ReadLine() ?? "nothing";

            Console.WriteLine("You entered: " + userInput);
        }
    }
}

Hello world:

"use strict";

function main(){
  
  console.log("Hello, World!");
  
  alert("Hello, World!");
  
}

main();

Simple user input:

<!DOCTYPE html>
<html lang="en">

<head>

  <meta charset="UTF-8">
  <title>Simple user input</title>

</head>

<body>

  <input type="text" id="user-input-field" value="Hovermind">

  <script>

    "use strict";

    function main() {

      let userInputFiled = document.getElementById("user-input-field");

      let userInputText = userInputFiled.value;

      console.log("You entered: " + userInputText);
      //alert("You entered: " + userInputText);

    }

    main();

  </script>

</body>

</html>

Hello world:

let message: string = "Hello, World!";

console.log(message);

// Commands:
// tsc program.ts   
// node program.js

Hello world:

print("Hello, World!")

Simple user input:

userInput = input("Enter some text: ")

print("You entered: " + userInput)

Hello world:

package com.company.practicexyz;

public class Program {

    public static void main(String[] args) {

        System.out.println("Hello, World!");

    }
}

Simple user input:

package com.company.practicexyz;

import java.util.Scanner;

public class Program {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        
        System.out.print("Enter some text: ");
		
        String userInput = scanner.nextLine();
        
        System.out.println("You entered: " + userInput);

        scanner.close();
    }
}

Print

Print syntax:

// Same line (no newline at end)
Console.Write("Same");
Console.Write(" Line");
// "Same Line"

// Newline at end
Console.WriteLine("Part 1");
Console.WriteLine("Part 2");
/*
"Part 1"
"Part 2"
*/

Newline and tab:

// Newline '\n'
Console.WriteLine("Part1\nPart2");
/*
"Part1
Part2"
*/

// Tab '\t'
Console.WriteLine("Part1\tPart2");
// "Part1	Part2"

Print syntax:

// Newline at end
console.log("Part 1");
console.log("Part 2");
/*
"Part 1"
"Part 2"
*/

Newline and tab:

// Newline '\n'
console.log("Part1\nPart2");
/*
"Part1
Part2"
*/

// Tab '\t'
console.log("Part1\tPart2");
// "Part1	Part2"

Print syntax:

// Newline at end
console.log("Part 1");
console.log("Part 2");
/*
"Part 1"
"Part 2"
*/

Newline and tab:

// Newline '\n'
console.log("Part1\nPart2");
/*
"Part1
Part2"
*/

// Tab '\t'
console.log("Part1\tPart2");
// "Part1	Part2"

Print syntax:

# Newline at end
print("Part 1")
print("Part 2")
"""\
"Part 1"
"Part 2"
"""

Newline and tab:

# Newline '\n'
print("Part1\nPart2");
"""\
"Part1
Part2"
"""

# Tab '\t'
print("Part1\tPart2");
# "Part1	Part2"

Print syntax:

// Same line (no newline at end)
System.out.print("Same");
System.out.print(" Line");
// "Same Line"

// Newline at end
System.out.println("Part 1");
System.out.println("Part 2");
/*
"Part 1"
"Part 2"
*/

Newline and tab:

// Newline '\n'
System.out.println("Part1\nPart2");
/*
"Part1
Part2"
*/

// Tab '\t'
System.out.println("Part1\tPart2");
// "Part1	Part2"

Comment

Single line comment:

// this is a single line comment in C#
// xyz

Multiline comment:

/*
this is a multiline comment in C#
xyz
*/

/*
* another multiline comment
* in C#
*/

Single line comment:

// this is a single line comment in JavaScript
// xyz

Multiline comment:

/*
this is a multiline comment in JavaScript
xyz
*/

/*
* another multiline comment
* in JavaScript
*/

Single line comment:

// this is a single line comment in TypeScript
// xyz

Multiline comment:

/*
this is a multiline comment in TypeScript
xyz
*/

/*
* another multiline comment
* in TypeScript
*/

Single line comment:

# this is a single line comment in python
# Xyz

Multiline comment:

# Python does not have multi-line comment

#
# Single line comment as multi-line comment
# Bla bla bla
#

# docstring comment as multi-line comment
# to avoid new line after """, use '\'
"""\
This is an example
of using multi-line docstring comment as multi-line comment
in Python
"""

Single line comment:

// this is a single line comment in Java
// xyz

Multiline comment:

/*
this is a multiline comment in Java
xyz
*/

/*
* another multiline comment
* in Java
*/

Data type and variable

Declaring variable:

// format: <data type> <variable name> = <intial value>;
int count = 0;
string name = "";
bool isValid = false;

Data types:

Built-in value types (known as primitive types): byte, sbyte, short, ushort, int, uint, long, ulong, float, double, decimal, bool, char
Built-in reference types: object, string, dynamic

To get type of a variable: .GetType()

int unknownVal = 0;

// .GetType().Name
// .GetType().FullName
if (unknownVal.GetType() == typeof(int))
{
	Console.WriteLine($"unknownVal is {unknownVal.GetType().Name}"); // Int32
}

Type suffix:

uint personCount = 0U;
long bigNumber = 0L;
ulong bigPositiveNumber = 0UL;
float rectangleArea = 0.0F;
double circleArea = 0.0D;
decimal highPrecisionArea = 0.0M;

Default value:

// When creating a variable, always assign intial or default value

int x = default; // Using 'default' keyword

// Using literal
int wholeNumber = 0;
uint deviceCount = 0U;
float rectangleArea = 0.0F;
double circleArea = 0.0D;
decimal highPrecisionArea = 0.0M;
bool isValid = false;
char flag = '\0';
string name = "";

Type inference:

// `var` keywaord is used for type inference, data type is inferred from the assigned value
var count = 0; // 'int' type is inferred from value '0'
var rectangleArea = 0.0F; // 'float' type is inferred from value '0.0F'
var circleArea = 0.0D; // 'double' type is inferred from value '0.0D'
var highPrecisionArea = 0.0M; // 'decimal' type is inferred from value '0.0M'
var flag = '\0'; // 'char' type is inferred from value '\0'
var name = "Hassan"; // 'string' type is inferred from value "Hassan"

// Implicitly typed variables must be initialized with proper value
var str = null;          // invalid, compiler can't figure out type of str
var str = (string) null; // compiler can infer type of 'str' variable as 'string', and assigned value is null

Declaring variable:

// format: let <variable name> = <intial value>;
let count = 0;
let name = "";
let isValid = false;

Data types:
To get the value of a variable: typeof(x) (also there is an operator: typeof x)

// string
let name = "";

// number : integer or double (always 64 bit)
let count = 0;
let circleArea = 0.0;

// bigint: more than 64 bit whole number, created by appending 'n' to the end of an integer
let bigNumber = 100n;

// boolean
let isValid = false;

// symbol: unique and immutable data type to be used as an identifier for object properties
let foo = Symbol();
console.log(typeof(foo)); // object
typeof(foo) === "symbol"; // true

// undefined: this data type represents value that is not assigned (a variable is declared but the value is not assigned)
// a variable without a value, has the value undefined. The type is also undefined.
let x;
console.log(x); // undefined
console.log(typeof(x)); // undefined

// null: a special value which represents nothing or empty
let x = null;
console.log(x); // null
console.log(typeof(x)); // object (it's a bug in js)

// non-primitive data type: object
const person = {
    firstName: "MD TAREQ",
    lastName: "HASSAN",
};
console.log(typeof(person)); // object
console.log(typeof(Math)); // object

Declaring variable:

// format: let <variable name>:  <data type> = <intial value>;
let roll: number = 0;
let name: string = "";
let isValid: boolean = false;

Data types:
To check type of a variable: typeof x (it’s an operator, not function typeof(x))

// string
let fullName: string = "";

// number
let roll: number = 0;
let circleArea: number = 0.0;
let hex: number = 0xf00d;
let binary: number = 0b1010;

// bigint
let bigNumber: bigint = 100n;
console.log(typeof(bigNumber)); // bigint

// boolean
let isValid: boolean = false;

// symbol
let foo: symbol = Symbol("foo");
console.log(typeof(foo)); // symbol

// undefined
let x;
console.log(x); // undefined
console.log(typeof(x)); // undefined

// null
let y = null;
console.log(y); // null
console.log(typeof(y)); // object (it's a bug in js)

/*
never use the following types:
- any
- unknown
- never
*/

// non-primitive data type: object
const person = {
    firstName: "MD TAREQ",
    lastName: "HASSAN",
};
console.log(typeof(person)); // object
console.log(typeof(Math)); // object

Declaring variable:

# format: <variable name>: <type> = <intial value>
count: int = 0
name: str = ""
isValid: bool = False

Data types:
To check type of a variable: type(x)

# str
name: str = ""

# int
count: int = 0

# float
area: float = 0.0

# complex
imaginaryNumber: complex = 1 + 2j
print(imaginaryNumber) # (1+2j)

# bytes
nihongo: bytes = b'\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e'
print(nihongo.decode('utf-8')) # 日本語
# print("日本語".encode('utf-8')) # b'\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e'
# print(b'\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e'.decode('utf-8')) # 日本語

# bool
isDone: bool = False

# get type of a variable: type()
circleRadius: int = 5
circleArea: float = circleRadius * 3.1416
print(f"type of circleRadius: {type(circleRadius)}") # <class 'int'>
print(f"type of circleArea: {type(circleArea)}") # <class 'float'>

Type inference:

name = ""
print(type(name)) # <class 'str'>

count = 0
print(type(count)) # <class 'int'>

area = 0.0
print(type(area)) # <class 'float'>

isDone = False
print(type(isDone)) # <class 'float'>

nihongo = b'\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e'
print(type(nihongo)) # <class 'bytes'>

Declaring variable:

// Format: <data type> <variable name> = <intial value>;
int count = 0;
String name = "";
boolean isValid = false;

Data types:

Built-in value types (known as primitive types): byte, short, int, long, float, double, char, boolean
Built-in reference types: Object, String

To get type of a variable: x.getClass().getSimpleName() (wrap primitive types into wrapper class to use .getClass())

Type suffix:

long bigNumber = 0l; // long
float rectangleArea = 0.0f; // float
double circleArea = 0.0d; // double

Default value:

// When creating a variable, always assign intial or default value
byte cssColorCode = 0;
int wholeNumber = 0;
long bigNumber = 0L;
float rectangleArea = 0.0f;
double circleArea = 0.0d;
boolean isValid = false;
char flag = '\0';
String name = "";

Type inference:

// Java 10+: there is 'var' keyword for type inference of local variables (use only for primitive types and string)
var count = 10;
var area = 0.0f;
var name = "";
var isDone = false;

Character

Character type variable:

char ch = '\0';
var jChar = 'j';                 // char literal
var jCharFromInt =  (char) 106;  // 'j', from int value

Conversion to string:
Character to string

// interpolation
char ch = 'x';
string str = $"{ch}";

// string constructor
string str = new string(new char[] { 'x' });

// ToString()
char ch = 'x';
var str = ch.ToString();

// when char is int val
var val = 120;
string str = Char.ConvertFromUtf32(val);  // x

String to character

string str = "Hello";
char[] characters = str.ToCharArray();

// readonly indexer of string
var str = "hovermind";
var firstChar = str[0];  // h

Conversion to integer:
Character to integer

var ch = 'x';
var val = (int)ch;
Console.WriteLine(val);  // 120

integer to character

int val = 120;
char ch = Convert.ToChar(val);
Console.WriteLine(ch);  // x