Initial commit

Author: Ritik Prasad

.DS_Store

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitattributes

@@ -0,0 +1,118 @@
+// Basic types
+let myNumber: number = 42;
+let myString: string = "Hello, TypeScript!";
+let isDone: boolean = true;
+
+// Arrays
+let numberArray: number[] = [1, 2, 3, 4];
+let stringArray: string[] = ["apple", "banana", "cherry"];
+let booleanArray: boolean[] = [true, false, true];
+
+// const tsName: string | undefined = 'Ritik';
+
+// let lowercase = tsName![0].toUpperCase();
+
+
+// in jS
+// const name = 'Ritik'; // Note: no type annotations
+
+// let lowercase = name && name[0] ? name[0].toUpperCase() : undefined;
+
+
+// Tuples
+let myTuple: [number, string, boolean] = [1, "hello", true];
+
+// Enum
+enum Color {
+  Red,
+  Green,
+  Blue,
+}
+let myColor: Color = Color.Green;
+
+// Any
+let anything: any = "Could be a string";
+anything = 42; // Now it's a number
+
+// Unknown
+let notSure: unknown = 4;
+if (typeof notSure === "number") {
+  let newNumber: number = notSure; // TypeScript knows it's a number here
+}
+
+// Never
+function error(message: string): never {
+  throw new Error(message);
+}
+
+// Void
+function warnUser(): void {
+  console.log("This is a warning message");
+}
+
+// Null and Undefined
+let u: undefined = undefined;
+let n: null = null;
+
+// BigInt
+let bigIntNumber: bigint = 9007199254740991n;
+
+// Object
+let user: { name: string; age: number } = { name: "John", age: 30 };
+
+// Type assertion
+let someValue: any = "this is a string";
+let strLength: number = (someValue as string).length;
+
+// Union Types
+let unionType: string | number;
+unionType = "hello";
+unionType = 42;
+
+// Intersection Types
+interface Person {
+  name: string;
+}
+
+interface Employee {
+  employeeId: number;
+}
+
+let employee: Person & Employee = { name: "Jane", employeeId: 1234 };
+
+// Function with parameter and return type annotations
+// function add(a: number, b: number): number {
+//   return a + b;
+// }
+
+// Interface
+interface Point {
+  x: number;
+  y: number;
+}
+
+let point: Point = { x: 10, y: 20 };
+
+// Type alias
+type StringOrNumber = string | number;
+
+let sample: StringOrNumber;
+sample = "hello";
+sample = 123;
+
+// Optional properties
+interface Rectangle {
+  width: number;
+  height?: number; // optional property
+}
+
+let rect1: Rectangle = { width: 100 };
+let rect2: Rectangle = { width: 100, height: 50 };
+
+// Readonly properties
+interface Circle {
+  readonly radius: number;
+}
+
+let circle: Circle = { radius: 10 };
+// circle.radius = 20; // Error: Cannot assign to 'radius' because it is a read-only property.

1Datatypes.ts

@@ -0,0 +1,102 @@
+
+// Type assertions in TypeScript are a way to tell the compiler to treat a value as a specific type. 
+// They don’t perform any runtime checks or
+//  type conversions but are useful for cases where you, as the developer,
+//   have more information about the type than TypeScript’s type inference system.
+
+// Syntax
+// TypeScript provides two syntaxes for type assertions:
+
+// Angle-Bracket Syntax: (value as Type)
+// as Keyword Syntax: <Type>value
+// Here’s how you can use both syntaxes:
+
+// let someValue: any = "This is a string";
+
+// // Using 'as' syntax
+// let strLength1: number = (someValue as string).length;
+
+// // Using angle-bracket syntax
+// let strLength2: number = (<string>someValue).length;
+
+// console.log(strLength1); // Output: 16
+// console.log(strLength2); // Output: 16
+
+// Example 2: Assertions with DOM Manipulation
+// Sometimes, when working with the DOM, you might need to assert that an element has a certain type.
+
+
+// let myInput = document.getElementById("myInput") as HTMLInputElement;
+// myInput.value = "Hello, TypeScript!";
+
+// let anotherInput = <HTMLInputElement>document.getElementById("anotherInput");
+// anotherInput.value = "Another input";
+// Example 3: Assertions with Custom Types
+// You can also use type assertions with custom types or interfaces.
+
+
+// interface Person {
+//     name: string;
+//     age: number;
+// }
+
+// let personData: any = {
+//     name: "Alice",
+//     age: 30
+// };
+
+// // Using 'as' syntax
+// let person1: Person = personData as Person;
+
+// // Using angle-bracket syntax
+// let person2: Person = <Person>personData;
+
+// console.log(person1.name); // Output: Alice
+// console.log(person2.age); // Output: 30
+// Example 4: Narrowing Down Types
+// Type assertions can also help in narrowing down types when working with union types.
+
+
+// function printId(id: number | string) {
+//     // Assert that id is a number
+//     let idNumber: number = id as number;
+//     console.log(idNumber.toFixed(2)); // Output depends on id's value
+// }
+
+// // Example usage
+// printId(123); // Output: 123.00
+// printId("456"); // Output: Error at runtime, but TypeScript assumes id is a number
+// Example 5: Working with JSON
+// When parsing JSON data, you might want to assert the shape of the data.
+
+
+// interface User {
+//     id: number;
+//     name: string;
+// }
+
+// let jsonData: any = '{"id": 1, "name": "Bob"}';
+// let user: User = JSON.parse(jsonData) as User;
+
+// console.log(user.id);   // Output: 1
+// console.log(user.name); // Output: Bob
+// Example 6: Conditional Type Assertions
+// You can use type assertions in combination with conditional checks to ensure type safety.
+
+
+// function handleResponse(response: any) {
+//     if (response.success) {
+//         let successData = response.data as { message: string };
+//         console.log(successData.message);
+//     } else {
+//         console.log("Error:", response.error as string);
+//     }
+// }
+
+// // Example usage
+// handleResponse({ success: true, data: { message: "Operation successful" } });
+// handleResponse({ success: false, error: "Something went wrong" });
+// Summary
+// Type assertions let you override TypeScript’s type inference, asserting a value to be of a specific type.
+// They do not perform type checks or type conversions but are useful for scenarios where you know more about the type than TypeScript can infer.
+// Use angle-bracket syntax (<Type>value) or the as keyword syntax (value as Type) depending on your preference or coding standards.

Assertions.ts

@@ -0,0 +1,61 @@
+// class Person {
+//     // Public property
+//     public name: string;
+
+//     // Private property
+//     private age: number;
+
+//     // Protected property
+//     protected address: string;
+
+//     // Readonly property
+//     readonly birthDate: Date;
+
+//     // Constructor
+//     constructor(name: string, age: number, address: string, birthDate: Date) {
+//         this.name = name;
+//         this.age = age;
+//         this.address = address;
+//         this.birthDate = birthDate;
+//     }
+
+//     // Getter for age
+//     public getAge(): number {
+//         return this.age;
+//     }
+
+//     // Setter for age
+//     public setAge(age: number): void {
+//         if (age > 0) {
+//             this.age = age;
+//         } else {
+//             console.error("Age must be positive.");
+//         }
+//     }
+
+//     // Getter for address
+//     protected getAddress(): string {
+//         return this.address;
+//     }
+
+//     // Setter for address
+//     protected setAddress(address: string): void {
+//         this.address = address;
+//     }
+// }
+
+// // Example usage
+// const person = new Person("John Doe", 30, "123 Main St", new Date("1990-01-01"));
+
+// console.log(person.name); // Public property, accessible
+// console.log(person.getAge()); // Using getter for private property
+
+// person.setAge(31); // Using setter for private property
+// console.log(person.getAge());
+
+// // Accessing protected property or methods directly from instance is not possible
+// // console.log(person.address); // Error: Property 'address' is protected and only accessible within class 'Person' and its subclasses.
+// // console.log(person.getAddress()); // Error: Property 'getAddress' is protected and only accessible within class 'Person' and its subclasses.
+
+// console.log(person.birthDate); // Readonly property, accessible but cannot be modified
+// // person.birthDate = new Date("2000-01-01"); // Error: Cannot assign to 'birthDate' because it is a read-only property.

Class.ts

@@ -0,0 +1,87 @@
+// Regular Functions
+
+function add(a: number, b: number): number {
+  return a + b;
+}
+
+console.log(add(5, 3)); // Output: 8
+
+// Function Expressions
+const multiply = function (a: number, b: number): number {
+  return a * b;
+};
+
+console.log(multiply(4, 5)); // Output: 20
+
+// Arrow Functions
+const subtract = (a: number, b: number): number => {
+  return a - b;
+};
+
+console.log(subtract(10, 4)); // Output: 6
+
+// Optional Parameters
+function greet(name: string, greeting?: string): string {
+  return greeting ? `${greeting}, ${name}!` : `Hello, ${name}!`;
+}
+
+console.log(greet("Alice")); // Output: Hello, Alice!
+console.log(greet("Alice", "Hi")); // Output: Hi, Alice!
+
+// Default Parameters
+
+function power(base: number, exponent: number = 2): number {
+  return base ** exponent;
+}
+
+console.log(power(3)); // Output: 9
+console.log(power(3, 3)); // Output: 27
+
+//  Rest Parameters
+
+function sum(...numbers: number[]): number {
+  return numbers.reduce((total, num) => total + num, 0);
+}
+
+console.log(sum(1, 2, 3)); // Output: 6
+console.log(sum(4, 5, 6, 7)); // Output: 22
+
+// Function Overloading
+
+function display(value: string): void;
+function display(value: number): void;
+function display(value: string | number): void {
+  console.log(`Value: ${value}`);
+}
+
+display("Hello"); // Output: Value: Hello
+display(42); // Output: Value: 42
+
+// Function Types
+type Operation = (a: number, b: number) => number;
+
+// const add: Operation = (a, b) => a + b;
+// const multiply: Operation = (a, b) => a * b;
+
+// console.log(add(5, 3)); // Output: 8
+// console.log(multiply(4, 5)); // Output: 20
+
+// Callback Functions
+
+function fetchData(url: string, callback: (data: string) => void): void {
+  // Simulate fetching data
+  const data = "Sample data from " + url;
+  callback(data);
+}
+
+fetchData("https://api.example.com", (data) => {
+  console.log(data); // Output: Sample data from https://api.example.com
+});
+
+// //   Generic Functions
+// function identity<T>(arg: T): T {
+//   return arg;
+// }
+
+// console.log(identity<string>("Hello")); // Output: Hello
+// console.log(identity<number>(42)); // Output: 42