Cheat-Sheet

Dart Cheat Sheet 1. Basic Syntax Comments // Single-line comment /* Multi-line comment */ /// Documentation comment Variables and Data Types // Type inference var name = 'Bob'; Object obj = 'Bob'; dynamic dyn = 'Bob'; // Explicit typing String name = 'Bob'; int age = 30; double height = 1.75; bool isStudent = true; List<int> numbers = [1, 2, 3]; Map<String, int> scores = {'Bob': 90, 'Alice': 95}; Constants const pi = 3.14; final currentTime = DateTime.now(); Operators // Arithmetic: +, -, *, /, ~/ (integer division), % // Increment/decrement: ++, -- // Equality and relational: ==, !=, >, <, >=, <= // Logical: &&, ||, ! // Cascade: .. // Null-aware: ??, ?. Type Casting int x = 1; double y = x.toDouble(); String s = x.toString(); 2. Control Structures Conditional Statements if (condition) { // code } else if (otherCondition) { // code } else { // code } switch (variable) { case value1: // code break; case value2: case value3: // code break; default: // code } Loops for (var i = 0; i < 5; i++) { // code } while (condition) { // code } do { // code } while (condition); for (var item in iterable) { // code } iterable.forEach((item) { // code }); 3. Functions Function Declaration and Definition int add(int a, int b) { return a + b; } // Arrow function int multiply(int a, int b) => a * b; Parameters and Return Values // Optional positional parameters String greet(String name, [String? greeting]) { greeting ??= 'Hello'; return '$greeting, $name!'; } // Named parameters void printPerson({required String name, int? age}) { print('Name: $name, Age: ${age ?? "Unknown"}'); } Anonymous Functions / Lambdas var list = ['apple', 'banana', 'cherry']; list.forEach((item) => print(item)); 4. Data Structures Lists var fruits = ['apple', 'banana', 'cherry']; fruits.add('date'); var firstFruit = fruits[0]; Maps var scores = {'Alice': 90, 'Bob': 85}; scores['Charlie'] = 95; var aliceScore = scores['Alice']; Sets var uniqueNumbers = {1, 2, 3, 4, 5}; uniqueNumbers.add(6); 5. Object-Oriented Programming Classes and Objects class Person { String name; int age; Person(this.name, this.age); void sayHello() { print('Hello, I am $name'); } } var person = Person('Alice', 30); person.sayHello(); Inheritance class Student extends Person { String school; Student(String name, int age, this.school) : super(name, age); } Interfaces and Abstract Classes abstract class Shape { double getArea(); } class Circle implements Shape { double radius; Circle(this.radius); @override double getArea() => 3.14 * radius * radius; } 6. Exception Handling try { // code that might throw an exception } on SpecificException catch (e) { // handle specific exception } catch (e) { // handle any exception } finally { // always executed } 7. File I/O import 'dart:io'; // Reading File file = File('example.txt'); String contents = await file.readAsString(); // Writing await file.writeAsString('Hello, Dart!'); // Working with directories Directory dir = Directory('path/to/directory'); await for (var entity in dir.list()) { print(entity.path); } 8. Modules and Packages // Importing import 'dart:math'; import 'package:http/http.dart' as http; // Exporting export 'src/my_module.dart'; 9. Standard Library dart:core: Built-in types, collections, and other core functionality dart:async: Asynchronous programming dart:math: Mathematical constants and functions dart:io: I/O for non-web applications dart:convert: Encoders and decoders for JSON and UTF-8 10. Asynchronous Programming Future<String> fetchData() async { // Simulating network request await Future.delayed(Duration(seconds: 2)); return 'Data'; } void main() async { var data = await fetchData(); print(data); } 11. Memory Management Dart uses automatic garbage collection 12. Important Language-Specific Features Null safety Futures and Streams for asynchronous programming Mixins for reusing code in multiple class hierarchies 13. Best Practices and Style Guide Use lowerCamelCase for variables and functions Use UpperCamelCase for classes and types Use underscores for libraries and file names Prefer using const for compile-time constants 14. Useful Resources Official Documentation: https://dart.dev/guides DartPad (Online Editor): https://dartpad.dev/ Pub.dev (Package repository): https://pub.dev/ Flutter (UI framework using Dart): https://flutter.dev/

Golang Cheat Sheet 1. Basic Syntax Comments // Single-line comment /* Multi-line comment */ Variables and Data Types var x int = 5 y := 10 // Type inference // Basic types var ( a bool = true b int = 10 c float64 = 3.14 d string = "Hello" ) Constants const Pi = 3.14 const ( StatusOK = 200 StatusNotFound = 404 ) Operators // Arithmetic: +, -, *, /, %, ++, -- // Comparison: ==, !=, <, >, <=, >= // Logical: &&, ||, ! // Bitwise: &, |, ^, <<, >> Type Casting i := 42 f := float64(i) s := string(i) 2. Control Structures Conditional Statements if x > 0 { // code } else if x < 0 { // code } else { // code } switch day { case "monday": // code case "tuesday", "wednesday": // code default: // code } Loops for i := 0; i < 10; i++ { // code } for condition { // while loop equivalent } for { // infinite loop } for index, value := range collection { // range loop } Break and Continue Statements for { if condition { break } if otherCondition { continue } } 3. Functions Function Declaration and Definition func greet(name string) string { return "Hello, " + name } Parameters and Return Values func divide(a, b float64) (float64, error) { if b == 0 { return 0, errors.New("division by zero") } return a / b, nil } Anonymous Functions / Lambdas func() { fmt.Println("Anonymous function") }() add := func(a, b int) int { return a + b } Scope and Closures func adder() func(int) int { sum := 0 return func(x int) int { sum += x return sum } } 4. Data Structures Arrays/Slices var arr [5]int slice := []int{1, 2, 3, 4, 5} slice = append(slice, 6) Maps m := make(map[string]int) m["key"] = 42 value, exists := m["key"] Sets // Go doesn't have a built-in set type // Use a map[Type]bool instead set := make(map[string]bool) set["item"] = true 5. Object-Oriented Programming Structs and Methods type Rectangle struct { width, height float64 } func (r Rectangle) Area() float64 { return r.width * r.height } Interfaces type Shape interface { Area() float64 } 6. Error Handling if err != nil { log.Fatal(err) } // Custom errors type MyError struct { message string } func (e *MyError) Error() string { return e.message } 7. File I/O // Reading data, err := ioutil.ReadFile("file.txt") // Writing err := ioutil.WriteFile("file.txt", data, 0644) // Working with directories files, err := ioutil.ReadDir(".") 8. Modules and Packages import ( "fmt" "math" ) // Creating modules // In go.mod file: // module example.com/mymodule 9. Standard Library fmt: Formatted I/O os: Operating system functionality io: Basic I/O interfaces net/http: HTTP client and server implementations encoding/json: JSON encoding and decoding time: Time and duration functions 10. Concurrency // Goroutines go function() // Channels ch := make(chan int) ch <- 42 // Send value := <-ch // Receive // Select select { case msg1 := <-ch1: // Use msg1 case msg2 := <-ch2: // Use msg2 default: // Run if no channel is ready } 11. Memory Management Go uses automatic garbage collection defer keyword for cleanup operations 12. Important Language-Specific Features Goroutines and Channels Defer statements Panic and Recover go generate 13. Best Practices and Style Guide Use gofmt for standard formatting Follow naming conventions (camelCase for unexported, PascalCase for exported) Prefer composition over inheritance Handle errors explicitly 14. Useful Resources Official Documentation: https://golang.org/doc/ Go by Example: https://gobyexample.com/ Go Playground: https://play.golang.org/ Popular packages: gin-gonic/gin, spf13/cobra, gorm.io/gorm

Python Cheat Sheet 1. Basic Syntax Comments # Single-line comment """ Multi-line comment """ def function(): """ Docstring: used for function/class/module documentation """ pass Variables and Data Types # Python uses dynamic typing name = "Bob" # str age = 30 # int height = 1.75 # float is_student = True # bool numbers = [1, 2, 3] # list person = {"name": "Alice", "age": 25} # dict unique_numbers = {1, 2, 3} # set coordinates = (x, y) # tuple Constants # Python doesn't have built-in constant types # Convention: use uppercase for constants PI = 3.14159 MAX_SIZE = 100 Operators # Arithmetic: +, -, *, /, // (integer division), %, ** # Comparison: ==, !=, <, >, <=, >= # Logical: and, or, not # Identity: is, is not # Membership: in, not in Type Conversion x = 10 y = float(x) # Convert to float s = str(x) # Convert to string 2. Control Structures Conditional Statements if condition: # code elif other_condition: # code else: # code # Ternary operator x = value_if_true if condition else value_if_false # Match statement (Python 3.10+) match value: case pattern1: # code case pattern2: # code case _: # default case Loops for item in iterable: # code for i in range(5): # code while condition: # code # List comprehension squares = [x**2 for x in range(10)] # Dictionary comprehension square_dict = {x: x**2 for x in range(5)} 3. Functions Function Declaration and Definition def greet(name): return f"Hello, {name}!" # Lambda function multiply = lambda x, y: x * y Parameters and Return Values # Default parameters def greet(name, greeting="Hello"): return f"{greeting}, {name}!" # Arbitrary arguments def sum_all(*args): return sum(args) # Keyword arguments def person_info(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}") # Type hinting (Python 3.5+) def add(a: int, b: int) -> int: return a + b 4. Data Structures Lists fruits = ['apple', 'banana', 'cherry'] fruits.append('date') first_fruit = fruits[0] sliced_fruits = fruits[1:3] # ['banana', 'cherry'] Dictionaries person = {'name': 'Alice', 'age': 30} person['city'] = 'New York' age = person.get('age') Sets unique_numbers = {1, 2, 3, 4, 5} unique_numbers.add(6) Tuples point = (10, 20) x, y = point # Unpacking 5. Object-Oriented Programming Classes and Objects class Person: def __init__(self, name, age): self.name = name self.age = age def greet(self): return f"Hello, I'm {self.name}" person = Person("Alice", 30) print(person.greet()) Inheritance class Student(Person): def __init__(self, name, age, school): super().__init__(name, age) self.school = school Encapsulation class BankAccount: def __init__(self, balance): self._balance = balance # Protected attribute @property def balance(self): return self._balance 6. Exception Handling try: # code that might raise an exception except SpecificError as e: # handle specific exception except Exception as e: # handle any exception else: # executed if no exception occurs finally: # always executed 7. File I/O # Reading with open('file.txt', 'r') as file: content = file.read() # Writing with open('file.txt', 'w') as file: file.write('Hello, Python!') 8. Modules and Packages # Importing import math from datetime import datetime import numpy as np # Creating a module # In mymodule.py def my_function(): pass # Using the module import mymodule mymodule.my_function() 9. Standard Library os: Operating system interface sys: System-specific parameters and functions datetime: Date and time handling math: Mathematical functions random: Generate random numbers json: JSON encoder and decoder re: Regular expressions 10. Concurrency # Threading import threading def worker(): print("Worker thread") thread = threading.Thread(target=worker) thread.start() # Asyncio (Python 3.5+) import asyncio async def main(): print('Hello') await asyncio.sleep(1) print('World') asyncio.run(main()) 11. Context Managers class MyContext: def __enter__(self): print("Entering context") return self def __exit__(self, exc_type, exc_value, traceback): print("Exiting context") with MyContext() as ctx: print("Inside context") 12. Important Language-Specific Features List/Dict/Set comprehensions Generators and iterators Decorators Type hinting (Python 3.5+) f-strings (Python 3.6+) Walrus operator := (Python 3.8+) 13. Best Practices and Style Guide Follow PEP 8 style guide Use meaningful variable and function names Write docstrings for functions, classes, and modules Use virtual environments for project isolation Prefer import over from ... import * 14. Useful Resources Official Documentation: https://docs.python.org/ Python Package Index (PyPI): https://pypi.org/ Real Python Tutorials: https://realpython.com/ PEP 8 Style Guide: https://pep8.org/

TypeScript Cheat Sheet 1. Basic Syntax Comments // Single-line comment /* Multi-line comment */ /** * Documentation comment */ Variables and Data Types // Type inference let name = 'Bob'; let age = 30; // Explicit typing let name: string = 'Bob'; let age: number = 30; let isStudent: boolean = true; let numbers: number[] = [1, 2, 3]; let tuple: [string, number] = ['hello', 10]; let anyType: any = 'anything'; Constants const PI: number = 3.14; Operators // Arithmetic: +, -, *, /, %, ** // Increment/decrement: ++, -- // Equality and relational: ==, ===, !=, !==, >, <, >=, <= // Logical: &&, ||, ! // Nullish coalescing: ?? // Optional chaining: ?. Type Casting let x: any = 'hello'; let len: number = (x as string).length; 2. Control Structures Conditional Statements if (condition) { // code } else if (otherCondition) { // code } else { // code } switch (variable) { case value1: // code break; case value2: case value3: // code break; default: // code } Loops for (let i = 0; i < 5; i++) { // code } while (condition) { // code } do { // code } while (condition); for (let item of iterable) { // code } iterable.forEach((item) => { // code }); 3. Functions Function Declaration and Definition function add(a: number, b: number): number { return a + b; } // Arrow function const multiply = (a: number, b: number): number => a * b; Parameters and Return Values // Optional parameters function greet(name: string, greeting?: string): string { greeting = greeting || 'Hello'; return `${greeting}, ${name}!`; } // Default parameters function createPoint(x: number = 0, y: number = 0): [number, number] { return [x, y]; } // Rest parameters function sum(...numbers: number[]): number { return numbers.reduce((total, num) => total + num, 0); } Function Overloading function padding(all: number): number; function padding(topBottom: number, leftRight: number): number; function padding(top: number, right: number, bottom: number, left: number): number; function padding(...args: number[]): number { // Implementation } 4. Data Structures Arrays let fruits: string[] = ['apple', 'banana', 'cherry']; fruits.push('date'); let firstFruit: string = fruits[0]; Objects let person: { name: string; age: number } = { name: 'Alice', age: 30 }; person.age = 31; Maps let scores = new Map<string, number>(); scores.set('Alice', 90); scores.set('Bob', 85); let aliceScore = scores.get('Alice'); Sets let uniqueNumbers = new Set<number>([1, 2, 3, 4, 5]); uniqueNumbers.add(6); 5. Object-Oriented Programming Classes and Objects class Person { constructor(public name: string, public age: number) {} sayHello(): void { console.log(`Hello, I am ${this.name}`); } } const person = new Person('Alice', 30); person.sayHello(); Inheritance class Student extends Person { constructor(name: string, age: number, public school: string) { super(name, age); } } Interfaces and Abstract Classes interface Shape { getArea(): number; } abstract class AbstractShape implements Shape { abstract getArea(): number; } class Circle extends AbstractShape { constructor(private radius: number) { super(); } getArea(): number { return Math.PI * this.radius ** 2; } } 6. Exception Handling try { // code that might throw an error } catch (error) { if (error instanceof Error) { console.error(error.message); } else { console.error(String(error)); } } finally { // always executed } 7. Modules // Exporting export function sayHello(name: string): string { return `Hello, ${name}!`; } // Importing import { sayHello } from './greetings'; 8. Generics function identity<T>(arg: T): T { return arg; } let output = identity<string>("myString"); 9. Type Manipulation // Union types type StringOrNumber = string | number; // Intersection types type Employee = Person & { employeeId: number }; // Type aliases type Point = { x: number; y: number }; // Utility types type Readonly<T> = { readonly [P in keyof T]: T[P] }; type Partial<T> = { [P in keyof T]?: T[P] }; 10. Asynchronous Programming async function fetchData(): Promise<string> { // Simulating network request await new Promise(resolve => setTimeout(resolve, 2000)); return 'Data'; } async function main() { try { const data = await fetchData(); console.log(data); } catch (error) { console.error(error); } } 11. Decorators function logged(target: any, key: string, descriptor: PropertyDescriptor) { const original = descriptor.value; descriptor.value = function (...args: any[]) { console.log(`Calling ${key} with`, args); return original.apply(this, args); }; return descriptor; } class Example { @logged method(arg: string) { return `Hello, ${arg}`; } } 12. Important Language-Specific Features Strong static typing Type inference Interfaces Enums Tuple types Null and undefined handling (strict null checks) 13. Best Practices and Style Guide Use const for values that won’t be reassigned Use let for variables that will be reassigned Use PascalCase for type names and enum values Use camelCase for variable and function names Use meaningful and descriptive names 14. Useful Resources Official Documentation: https://www.typescriptlang.org/docs/ TypeScript Playground: https://www.typescriptlang.org/play DefinitelyTyped (Type definitions): https://github.com/DefinitelyTyped/DefinitelyTyped TSConfig Reference: https://www.typescriptlang.org/tsconfig