Fueling Curiosity, One Insight at a Time

user = User.first
user1 = user.dup
user1:
<User id: nil, name: "Rails">

user = User.first
user1 = user.clone
<User id: 1, name: "Rails">

# config/routes.rb

Rails.application.routes.draw do
  resources :students
end

GET     /students          # Index action (display a list of students)
GET     /students/new      # New action (display a form to create a new student)
POST    /students          # Create action (create a new student)
GET     /students/:id      # Show action (display details of a specific student)
GET     /students/:id/edit # Edit action (display a form to edit a specific student)
PATCH   /students/:id      # Update action (update a specific student)
PUT     /students/:id      # Update action (update a specific student)
DELETE  /students/:id      # Destroy action (delete a specific student)

function identityType<Type>(prop: Type): Type {
  return prop;
}
identityType(1);

class User {
  constructor(public name: string, public age: number) {}
}
const ue = new User("github", 24);

class User {
  private _currentCount: number = 0;
  constructor(public name: string, public age: number) {}

  get fetch_name(): string {
    return this._name;
  }

  get fetchCount(): number {
    return this._currentCount;
  }

  set increaseCount(prop: number) {
    this._currentCount = prop + this._currentCount;
    this.logData();
  }

  private logData(): void {
    console.log("Count Increased");
  }
}

const fetchUser = new User("github", 24);

abstract class Photo {
  constructor(public isCameraOn: boolean, public isFlashOn: boolean) {}
}

class Phone extends Photo {}
const ph = new Phone(true, true);

let myName: string = "Vijay";
    let age: number = 20;
    let isActive: boolean = false;

function sum(a: number, b: number = 2): number {
        return a + b;
    }

let sum = (a: number, b: number = 2): number => a + b;

For String
 let users: string[] = ["a", "b", "c", "d]

For Number
 let count: number[] = [1, 2, 3, 4]

For boolean
let isActive: boolean[] = [true, false]

For Mixed array
 let allDate: (string | number)[] = ["a", "b", "c", 1]
 Here Array contains only integers and strings

function logError(msg: string): void {
    console.log(msg);
}

function throwError(message: string): never {
    throw new Error(message);
}

function fetchData(pt: { x: number; y: number }) {
  return pt;
}
fetchData({ x: 3, y: 7 });

function fetchData(pt: { x: number; y?: number }) {
  return pt;
}
fetchData({ x: 3 });

function sum(a: string | number) {
        return a;
    }
Here you can see value can be anything string or number

type User = {
  name: string;
  age: number;
}

function displayUser(prop: User) {
  console.log(prop.name);
  console.log(prop.age);
}

displayUser({name: 'John', age: 22})

type User = {
  name: string;
  age: number;
}

type Role = {
  role: string
}

type UserDeatils = User & Role & {
  address: string;
}

const enum UserType {
  ADMIN,
  USER,
  GUEST,
}

const enum UserType {
  ADMIN = 10,
  USER,
  GUEST,
}

const enum UserType {
  ADMIN = "admin",
  USER = "user",
  GUEST = "guest",
}

const enum UserType {
  ADMIN = "admin",
  USER = 0,
  GUEST,
}

gem install flog

flog app lib

class Person
  def initialize(name, age)
    @name = name
    @age = age
  end

  def say_intro
    puts "Hello, my name is #{@name} and I am #{@age} years old"
  end
end

# Create a new instance of Person
person1 = Person.new("John", 18)

# Call the say_intro method
person1.say_intro

docker stats db370fc6b784
CONTAINER ID   NAME       CPU %     MEM USAGE / LIMIT     MEM %     NET I/O          BLOCK I/O       PIDS
db370fc6b784   minikube   43.70%    1.243GiB / 2.148GiB   57.87%    35.4MB / 414MB

SELECT column_name, column_default
FROM information_schema.columns
WHERE table_name = '<table_name_placeholder>' AND column_name = '<column_name_placeholder>';

SELECT column_name, is_nullable
FROM information_schema.columns
WHERE table_name = '<table_name_placeholder>' AND column_name = '<column_name_placeholder>';