mirror of
https://github.com/LeCoupa/awesome-cheatsheets.git
synced 2026-06-17 18:39:24 -07:00
Compare commits
2 Commits
master
..
e75cca61b4
| Author | SHA1 | Date | |
|---|---|---|---|
 Shruti Agarwal
|
e75cca61b4 | ||
|
shrutiag14
|
2e6303c1f9 |
@@ -1,29 +1,17 @@
|
||||
<div align="center">
|
||||
|
||||
[](https://lecoupa.github.io/awesome-cheatsheets/)
|
||||
|
||||
<a href="https://trendshift.io/repositories/5584" target="_blank">
|
||||
<img src="https://trendshift.io/api/badge/repositories/5584" alt="LeCoupa%2Fawesome-cheatsheets | Trendshift" width="250" height="55"/>
|
||||
</a>
|
||||
|
||||
[](https://awesome.re) [](https://github.com/LeCoupa/awesome-cheatsheets/blob/master/LICENSE)
|
||||
|
||||
**WEBSITE DIRECTORY**: [Available here](https://lecoupa.github.io/awesome-cheatsheets/)
|
||||
**WEBSITE DIRECTORY**: [Available here](https://lecoupa.github.io/awesome-cheatsheets/).
|
||||
|
||||
> 📚 Awesome cheatsheets for popular programming languages, frameworks and development tools. They include everything you should know in one single file.
|
||||
|
||||
</div>
|
||||
|
||||
---
|
||||
|
||||
## 🤔 Why Awesome-Cheatsheets?
|
||||
|
||||
I usually make a cheat sheet when I want to improve my skills in a programming language, a framework or a development tool. [I started doing these kinds of things a long time ago on Gist](https://gist.github.com/LeCoupa). To better keep track of the history and to let people contribute, I re-organized all of them into this single repository. Most of the content is coming from official documentation and some books I have read.
|
||||
|
||||
Feel free to take a look. You might learn new things. They have been designed to provide a quick way to assess your knowledge and to save you time.
|
||||
|
||||
---
|
||||
|
||||
## 📚 Table of Contents
|
||||
|
||||
### 📃 Languages
|
||||
@@ -32,48 +20,46 @@ Feel free to take a look. You might learn new things. They have been designed to
|
||||
<summary>View cheatsheets</summary>
|
||||
|
||||
#### Command line interface
|
||||
|
||||
- [Bash](languages/bash.sh)
|
||||
|
||||
#### Imperative
|
||||
|
||||
- [C](languages/C.txt)
|
||||
- [C#](languages/C%23.txt)
|
||||
- [Go](languages/golang.md)
|
||||
- [Java](languages/java.md)
|
||||
- [PHP](languages/php.php)
|
||||
- [Python](languages/python.md)
|
||||
- [XML](languages/XML.md)
|
||||
|
||||
#### Functional
|
||||
|
||||
- [JavaScript](languages/javascript.js)
|
||||
- [Typescript](languages/typescript.md)
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
### 📦 Backend
|
||||
|
||||
<details>
|
||||
<summary>View cheatsheets</summary>
|
||||
|
||||
#### PHP
|
||||
|
||||
- [Laravel](backend/laravel.php)
|
||||
|
||||
#### Python
|
||||
|
||||
- [Django](backend/django.py)
|
||||
|
||||
#### JavaScript
|
||||
#### Javascript
|
||||
|
||||
- [Adonis.js](backend/adonis.js)
|
||||
- [Express.js](backend/express.js)
|
||||
- [Feathers.js](backend/feathers.js)
|
||||
- [Moleculer](backend/moleculer.js)
|
||||
- [Node.js](backend/node.js)
|
||||
- [Sails.js](backend/sails.js)
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
</details>
|
||||
|
||||
### 🌐 Frontend
|
||||
|
||||
@@ -81,20 +67,19 @@ Feel free to take a look. You might learn new things. They have been designed to
|
||||
<summary>View cheatsheets</summary>
|
||||
|
||||
#### Basics
|
||||
|
||||
- [HTML5](frontend/html5.html)
|
||||
- [CSS3](frontend/css3.css)
|
||||
- [Typescript](frontend/typescript.ts)
|
||||
|
||||
#### Frameworks
|
||||
|
||||
- [React.js](frontend/react.js)
|
||||
- [Vue.js](frontend/vue.js)
|
||||
- [Tailwind.css](frontend/tailwind.css)
|
||||
- [Ember.js](frontend/ember.js)
|
||||
- [Angular (2+)](frontend/angular.js)
|
||||
- [AngularJS](frontend/angularjs.js)
|
||||
</details>
|
||||
|
||||
---
|
||||
</details>
|
||||
|
||||
### 🗃️ Databases
|
||||
|
||||
@@ -102,15 +87,13 @@ Feel free to take a look. You might learn new things. They have been designed to
|
||||
<summary>View cheatsheets</summary>
|
||||
|
||||
#### SQL
|
||||
|
||||
- [MySQL](databases/mysql.sh)
|
||||
|
||||
#### NoSQL
|
||||
- [MongoDB](databases/mongodb.sh)
|
||||
|
||||
- [Redis](databases/redis.sh)
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
</details>
|
||||
|
||||
### 🔧 Tools
|
||||
|
||||
@@ -118,6 +101,7 @@ Feel free to take a look. You might learn new things. They have been designed to
|
||||
<summary>View cheatsheets</summary>
|
||||
|
||||
#### Development
|
||||
|
||||
- [cURL](tools/curl.sh)
|
||||
- [Drush](tools/drush.sh)
|
||||
- [Elasticsearch](tools/elasticsearch.js)
|
||||
@@ -130,35 +114,25 @@ Feel free to take a look. You might learn new things. They have been designed to
|
||||
- [Xcode](tools/xcode.txt)
|
||||
|
||||
#### Infrastructure
|
||||
|
||||
- [AWS CLI](tools/aws.sh)
|
||||
- [Docker](tools/docker.sh)
|
||||
- [GCP CLI](tools/gcp.md)
|
||||
- [Heroku CLI](tools/heroku.sh)
|
||||
- [Kubernetes](tools/kubernetes.md)
|
||||
- [macOS](tools/macos.sh)
|
||||
- [Nanobox Boxfile](tools/nanobox_boxfile.yml)
|
||||
- [Nanobox CLI](tools/nanobox_cli.sh)
|
||||
- [Nginx](tools/nginx.sh)
|
||||
- [PM2](tools/pm2.sh)
|
||||
- [Ubuntu](tools/ubuntu.sh)
|
||||
- [Firebase CLI](tools/firebase_cli.md)
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
</details>
|
||||
|
||||
## 🙌🏼 How to Contribute?
|
||||
|
||||
You are more than welcome to contribute and build your own cheat sheet for your favorite programming language, framework or development tool. Just submit changes via pull request and I will review them before merging.
|
||||
|
||||
---
|
||||
|
||||
## 👩💻👨💻 Our valuable Contributors
|
||||
|
||||
<div align="center">
|
||||
|
||||
<a href="https://github.com/LeCoupa/awesome-cheatsheets/graphs/contributors">
|
||||
<p align="center"><a href="https://github.com/LeCoupa/awesome-cheatsheets/graphs/contributors">
|
||||
<img src="https://contributors-img.web.app/image?repo=LeCoupa/awesome-cheatsheets" />
|
||||
</a>
|
||||
|
||||
</div>
|
||||
</a></p>
|
||||
|
||||
@@ -82,33 +82,3 @@ SELECT User, Host FROM mysql.user; # List all current MySQL users
|
||||
|
||||
SET GLOBAL general_log = 'ON'; # Enable query logging
|
||||
SHOW FULL PROCESSLIST; # Show the last queries executed in MySQL
|
||||
|
||||
# *****************************************************************************
|
||||
# Altering Table Structure
|
||||
# *****************************************************************************
|
||||
|
||||
ALTER TABLE table_name ADD COLUMN column_name datatype; # Add a new column to an existing table
|
||||
ALTER TABLE table_name MODIFY COLUMN column_name datatype; # Change the data type of a column
|
||||
ALTER TABLE table_name RENAME COLUMN old_name TO new_name; # Rename a column (MySQL 8.0+)
|
||||
ALTER TABLE table_name DROP COLUMN column_name; # Remove a column from a table
|
||||
ALTER TABLE old_table_name RENAME TO new_table_name; # Rename an entire table
|
||||
|
||||
# *****************************************************************************
|
||||
# Indexes (Performance Tuning)
|
||||
# *****************************************************************************
|
||||
|
||||
CREATE INDEX idx_name ON table_name (column_name); # Create a standard index to speed up queries
|
||||
CREATE UNIQUE INDEX idx_name ON table_name (column_name); # Create a unique index (no duplicate values)
|
||||
SHOW INDEX FROM table_name; # List all indexes on a specific table
|
||||
DROP INDEX idx_name ON table_name; # Remove an index from a table
|
||||
EXPLAIN SELECT * FROM table_name WHERE condition; # Analyze how MySQL executes a query (Check index usage)
|
||||
|
||||
# *****************************************************************************
|
||||
# Transactions (Data Integrity)
|
||||
# *****************************************************************************
|
||||
|
||||
START TRANSACTION; # Begin a new transaction
|
||||
COMMIT; # Save all changes made during the transaction
|
||||
ROLLBACK; # Undo all changes if an error occurs before commit
|
||||
SET AUTOCOMMIT = 0; # Disable automatic commits for the current session
|
||||
SET AUTOCOMMIT = 1; # Re-enable automatic commits after finishing manual transactions
|
||||
|
||||
+47
-71
@@ -43,14 +43,11 @@
|
||||
|
||||
.hidden /* display: none; */
|
||||
.block /* display: block; */
|
||||
.flow-root /* display: flow-root; */
|
||||
.inline-block /* display: inline-block; */
|
||||
.inline /* display: inline; */
|
||||
.flex /* display: flex; */
|
||||
.inline-flex /* display: inline-flex; */
|
||||
.grid /* display: grid; */
|
||||
.inline-grid /* display: inline-grid; */
|
||||
.contents /* display: contents; */
|
||||
.table /* display: table; */
|
||||
.table-caption /* display: table-caption; */
|
||||
.table-cell /* display: table-cell; */
|
||||
@@ -71,6 +68,7 @@
|
||||
.float-right /* float: right; */
|
||||
.float-left /* float: left; */
|
||||
.float-none /* float: none; */
|
||||
.clearfix /* &::after { content: ""; display: table; clear: both; } */
|
||||
|
||||
/*
|
||||
* Clear
|
||||
@@ -132,6 +130,8 @@
|
||||
.overflow-y-visible /* overflow-y: visible; */
|
||||
.overflow-x-scroll /* overflow-x: scroll; */
|
||||
.overflow-y-scroll /* overflow-y: scroll; */
|
||||
.scrolling-touch /* -webkit-overflow-scrolling: touch; */
|
||||
.scrolling-auto /* -webkit-overflow-scrolling: auto; */
|
||||
|
||||
/*
|
||||
* Position
|
||||
@@ -219,7 +219,7 @@
|
||||
* By default, only responsive variants are generated for flex-wrap utilities.
|
||||
*/
|
||||
|
||||
.flex-nowrap /* flex-wrap: nowrap; */
|
||||
.flex-no-wrap /* flex-wrap: nowrap; */
|
||||
.flex-wrap /* flex-wrap: wrap; */
|
||||
.flex-wrap-reverse /* flex-wrap: wrap-reverse; */
|
||||
|
||||
@@ -478,44 +478,44 @@
|
||||
.gap-56 /* gap: 14rem; */
|
||||
.gap-64 /* gap: 16rem; */
|
||||
.gap-px /* gap: 1px; */
|
||||
.gap-y-0 /* row-gap: 0; */
|
||||
.gap-y-1 /* row-gap: 0.25rem; */
|
||||
.gap-y-2 /* row-gap: 0.5rem; */
|
||||
.gap-y-3 /* row-gap: 0.75rem; */
|
||||
.gap-y-4 /* row-gap: 1rem; */
|
||||
.gap-y-5 /* row-gap: 1.25rem; */
|
||||
.gap-y-6 /* row-gap: 1.5rem; */
|
||||
.gap-y-8 /* row-gap: 2rem; */
|
||||
.gap-y-10 /* row-gap: 2.5rem; */
|
||||
.gap-y-12 /* row-gap: 3rem; */
|
||||
.gap-y-16 /* row-gap: 4rem; */
|
||||
.gap-y-20 /* row-gap: 5rem; */
|
||||
.gap-y-24 /* row-gap: 6rem; */
|
||||
.gap-y-32 /* row-gap: 8rem; */
|
||||
.gap-y-40 /* row-gap: 10rem; */
|
||||
.gap-y-48 /* row-gap: 12rem; */
|
||||
.gap-y-56 /* row-gap: 14rem; */
|
||||
.gap-y-64 /* row-gap: 16rem; */
|
||||
.gap-y-px /* row-gap: 1px; */
|
||||
.gap-x-0 /* column-gap: 0; */
|
||||
.gap-x-1 /* column-gap: 0.25rem; */
|
||||
.gap-x-2 /* column-gap: 0.5rem; */
|
||||
.gap-x-3 /* column-gap: 0.75rem; */
|
||||
.gap-x-4 /* column-gap: 1rem; */
|
||||
.gap-x-5 /* column-gap: 1.25rem; */
|
||||
.gap-x-6 /* column-gap: 1.5rem; */
|
||||
.gap-x-8 /* column-gap: 2rem; */
|
||||
.gap-x-10 /* column-gap: 2.5rem; */
|
||||
.gap-x-12 /* column-gap: 3rem; */
|
||||
.gap-x-16 /* column-gap: 4rem; */
|
||||
.gap-x-20 /* column-gap: 5rem; */
|
||||
.gap-x-24 /* column-gap: 6rem; */
|
||||
.gap-x-32 /* column-gap: 8rem; */
|
||||
.gap-x-40 /* column-gap: 10rem; */
|
||||
.gap-x-48 /* column-gap: 12rem; */
|
||||
.gap-x-56 /* column-gap: 14rem; */
|
||||
.gap-x-64 /* column-gap: 16rem; */
|
||||
.gap-x-px /* column-gap: 1px; */
|
||||
.row-gap-0 /* row-gap: 0; */
|
||||
.row-gap-1 /* row-gap: 0.25rem; */
|
||||
.row-gap-2 /* row-gap: 0.5rem; */
|
||||
.row-gap-3 /* row-gap: 0.75rem; */
|
||||
.row-gap-4 /* row-gap: 1rem; */
|
||||
.row-gap-5 /* row-gap: 1.25rem; */
|
||||
.row-gap-6 /* row-gap: 1.5rem; */
|
||||
.row-gap-8 /* row-gap: 2rem; */
|
||||
.row-gap-10 /* row-gap: 2.5rem; */
|
||||
.row-gap-12 /* row-gap: 3rem; */
|
||||
.row-gap-16 /* row-gap: 4rem; */
|
||||
.row-gap-20 /* row-gap: 5rem; */
|
||||
.row-gap-24 /* row-gap: 6rem; */
|
||||
.row-gap-32 /* row-gap: 8rem; */
|
||||
.row-gap-40 /* row-gap: 10rem; */
|
||||
.row-gap-48 /* row-gap: 12rem; */
|
||||
.row-gap-56 /* row-gap: 14rem; */
|
||||
.row-gap-64 /* row-gap: 16rem; */
|
||||
.row-gap-px /* row-gap: 1px; */
|
||||
.col-gap-0 /* column-gap: 0; */
|
||||
.col-gap-1 /* column-gap: 0.25rem; */
|
||||
.col-gap-2 /* column-gap: 0.5rem; */
|
||||
.col-gap-3 /* column-gap: 0.75rem; */
|
||||
.col-gap-4 /* column-gap: 1rem; */
|
||||
.col-gap-5 /* column-gap: 1.25rem; */
|
||||
.col-gap-6 /* column-gap: 1.5rem; */
|
||||
.col-gap-8 /* column-gap: 2rem; */
|
||||
.col-gap-10 /* column-gap: 2.5rem; */
|
||||
.col-gap-12 /* column-gap: 3rem; */
|
||||
.col-gap-16 /* column-gap: 4rem; */
|
||||
.col-gap-20 /* column-gap: 5rem; */
|
||||
.col-gap-24 /* column-gap: 6rem; */
|
||||
.col-gap-32 /* column-gap: 8rem; */
|
||||
.col-gap-40 /* column-gap: 10rem; */
|
||||
.col-gap-48 /* column-gap: 12rem; */
|
||||
.col-gap-56 /* column-gap: 14rem; */
|
||||
.col-gap-64 /* column-gap: 16rem; */
|
||||
.col-gap-px /* column-gap: 1px; */
|
||||
|
||||
/*
|
||||
* Grid Auto Flow
|
||||
@@ -1153,8 +1153,8 @@
|
||||
* By default, only responsive, hover and focus variants are generated for font weight utilities.
|
||||
*/
|
||||
|
||||
.font-thin /* font-weight: 100; */
|
||||
.font-extralight /* font-weight: 200; */
|
||||
.font-hairline /* font-weight: 100; */
|
||||
.font-thin /* font-weight: 200; */
|
||||
.font-light /* font-weight: 300; */
|
||||
.font-normal /* font-weight: 400; */
|
||||
.font-medium /* font-weight: 500; */
|
||||
@@ -1479,7 +1479,7 @@
|
||||
*/
|
||||
|
||||
.whitespace-normal /* white-space: normal; */
|
||||
.whitespace-nowrap /* white-space: nowrap; */
|
||||
.whitespace-no-wrap /* white-space: nowrap; */
|
||||
.whitespace-pre /* white-space: pre; */
|
||||
.whitespace-pre-line /* white-space: pre-line; */
|
||||
.whitespace-pre-wrap /* white-space: pre-wrap; */
|
||||
@@ -1902,6 +1902,7 @@
|
||||
* By default, only responsive, hover and focus variants are generated for box shadow utilities.
|
||||
*/
|
||||
|
||||
.shadow-xs /* box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.05); */
|
||||
.shadow-sm /* box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05); */
|
||||
.shadow /* box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px 0 rgba(0, 0, 0, 0.06); */
|
||||
.shadow-md /* box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); */
|
||||
@@ -1909,34 +1910,9 @@
|
||||
.shadow-xl /* box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04); */
|
||||
.shadow-2xl /* box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25); */
|
||||
.shadow-inner /* box-shadow: inset 0 2px 4px 0 rgba(0, 0, 0, 0.06); */
|
||||
.shadow-outline /* box-shadow: 0 0 0 3px rgba(66, 153, 225, 0.5); */
|
||||
.shadow-none /* box-shadow: none; */
|
||||
|
||||
/*
|
||||
* RING
|
||||
* --------------------
|
||||
* Utilities for creating outline rings with box-shadows.
|
||||
* Replaced the old .shadow-outline utility.
|
||||
*/
|
||||
|
||||
.ring-0 /* box-shadow: 0 0 0 0px; */
|
||||
.ring-1 /* box-shadow: 0 0 0 1px; */
|
||||
.ring-2 /* box-shadow: 0 0 0 2px; */
|
||||
.ring-4 /* box-shadow: 0 0 0 4px; */
|
||||
.ring-8 /* box-shadow: 0 0 0 8px; */
|
||||
.ring /* box-shadow: 0 0 0 3px; */
|
||||
.ring-inset /* --ring-inset: inset; */
|
||||
|
||||
.ring-transparent /* --ring-color: transparent; */
|
||||
.ring-black /* --ring-color: #000; */
|
||||
.ring-white /* --ring-color: #fff; */
|
||||
.ring-current /* --ring-color: currentColor; */
|
||||
|
||||
.ring-offset-0 /* --ring-offset-width: 0px; */
|
||||
.ring-offset-1 /* --ring-offset-width: 1px; */
|
||||
.ring-offset-2 /* --ring-offset-width: 2px; */
|
||||
.ring-offset-4 /* --ring-offset-width: 4px; */
|
||||
.ring-offset-8 /* --ring-offset-width: 8px; */
|
||||
|
||||
/*
|
||||
* OPACITY
|
||||
* --------------------
|
||||
|
||||
@@ -1,670 +0,0 @@
|
||||
/****************************
|
||||
* TYPESCRIPT CHEATSHEET - Quick Reference
|
||||
* Learn more: https://www.typescriptlang.org/docs/
|
||||
* Playground: https://www.typescriptlang.org/play
|
||||
* Handbook: https://www.typescriptlang.org/handbook/
|
||||
*
|
||||
* Table of contents
|
||||
* -------------------
|
||||
* 01 | Basic Types
|
||||
* 02 | Variables & Arrays
|
||||
* 03 | Functions
|
||||
* 04 | Objects & Interfaces
|
||||
* 05 | Classes
|
||||
* 06 | Generics
|
||||
* 07 | Union & Literal Types
|
||||
* 08 | Type Guards & Assertions
|
||||
* 09 | Utility Types
|
||||
* 10 | Enums
|
||||
* 11 | Modules
|
||||
* 12 | Advanced Types
|
||||
* 13 | Decorators
|
||||
* 14 | Configuration
|
||||
* 15 | Common Patterns
|
||||
*****************************/
|
||||
|
||||
/***************************
|
||||
------------ 01: Basic Types -----------
|
||||
*******************************/
|
||||
|
||||
// Primitive Types
|
||||
let str: string = "hello";
|
||||
let num: number = 42;
|
||||
let bool: boolean = true;
|
||||
let undef: undefined = undefined;
|
||||
let nul: null = null;
|
||||
|
||||
// Special Types
|
||||
let anything: any = "can be anything";
|
||||
let unknown: unknown = "type-safe any";
|
||||
let nothing: void = undefined;
|
||||
let never: never = (() => { throw new Error() })();
|
||||
|
||||
// Type Inference
|
||||
let auto = "TypeScript infers string";
|
||||
let nums = [1, 2, 3]; // number[]
|
||||
|
||||
/***************************
|
||||
------------ 02: Variables & Arrays -----------
|
||||
*******************************/
|
||||
|
||||
// Arrays
|
||||
let numbers: number[] = [1, 2, 3];
|
||||
let strings: Array<string> = ["a", "b"];
|
||||
let mixed: (string | number)[] = [1, "two"];
|
||||
|
||||
// Tuples
|
||||
let tuple: [string, number] = ["hello", 42];
|
||||
let namedTuple: [name: string, age: number] = ["John", 30];
|
||||
|
||||
// Destructuring
|
||||
let [first, second] = tuple;
|
||||
let [x, y, ...rest] = [1, 2, 3, 4, 5];
|
||||
|
||||
// Object Destructuring
|
||||
let {name, age} = {name: "John", age: 30};
|
||||
let {a: newName, b = 10} = {a: "value"}; // rename & default
|
||||
|
||||
/***************************
|
||||
------------ 03: Functions -----------
|
||||
*******************************/
|
||||
|
||||
// Function Declaration
|
||||
function add(x: number, y: number): number {
|
||||
return x + y;
|
||||
}
|
||||
|
||||
// Arrow Functions
|
||||
const multiply = (x: number, y: number): number => x * y;
|
||||
const greet = (name: string): void => console.log(`Hello ${name}`);
|
||||
|
||||
// Optional & Default Parameters
|
||||
function build(first: string, last?: string, age = 25): string {
|
||||
return `${first} ${last || ""} (${age})`;
|
||||
}
|
||||
|
||||
// Rest Parameters
|
||||
function sum(...nums: number[]): number {
|
||||
return nums.reduce((a, b) => a + b, 0);
|
||||
}
|
||||
|
||||
// Function Overloads
|
||||
function format(x: string): string;
|
||||
function format(x: number): string;
|
||||
function format(x: string | number): string {
|
||||
return x.toString();
|
||||
}
|
||||
|
||||
// Function Types
|
||||
type MathOp = (x: number, y: number) => number;
|
||||
const divide: MathOp = (x, y) => x / y;
|
||||
|
||||
/***************************
|
||||
------------ 04: Objects & Interfaces -----------
|
||||
*******************************/
|
||||
|
||||
// Object Types
|
||||
let person: {name: string, age: number} = {name: "John", age: 30};
|
||||
|
||||
// Interface
|
||||
interface User {
|
||||
readonly id: number;
|
||||
name: string;
|
||||
email?: string; // optional
|
||||
[key: string]: any; // index signature
|
||||
}
|
||||
|
||||
// Extending Interfaces
|
||||
interface Admin extends User {
|
||||
permissions: string[];
|
||||
}
|
||||
|
||||
// Multiple Inheritance
|
||||
interface Timestamped {
|
||||
createdAt: Date;
|
||||
}
|
||||
interface AdminUser extends User, Timestamped {
|
||||
role: "admin";
|
||||
}
|
||||
|
||||
// Function in Interface
|
||||
interface Calculator {
|
||||
add(x: number, y: number): number;
|
||||
subtract: (x: number, y: number) => number;
|
||||
}
|
||||
|
||||
/***************************
|
||||
------------ 05: Classes -----------
|
||||
*******************************/
|
||||
|
||||
// Basic Class
|
||||
class Animal {
|
||||
public name: string;
|
||||
private age: number;
|
||||
protected species: string;
|
||||
readonly id: number;
|
||||
|
||||
constructor(name: string, age: number) {
|
||||
this.name = name;
|
||||
this.age = age;
|
||||
this.species = "unknown";
|
||||
this.id = Math.random();
|
||||
}
|
||||
|
||||
speak(): void {
|
||||
console.log(`${this.name} makes a sound`);
|
||||
}
|
||||
}
|
||||
|
||||
// Inheritance
|
||||
class Dog extends Animal {
|
||||
breed: string;
|
||||
|
||||
constructor(name: string, age: number, breed: string) {
|
||||
super(name, age);
|
||||
this.breed = breed;
|
||||
}
|
||||
|
||||
speak(): void {
|
||||
console.log(`${this.name} barks`);
|
||||
}
|
||||
}
|
||||
|
||||
// Abstract Class
|
||||
abstract class Shape {
|
||||
abstract area(): number;
|
||||
|
||||
display(): void {
|
||||
console.log(`Area: ${this.area()}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Static Members
|
||||
class MathUtils {
|
||||
static PI = 3.14159;
|
||||
static circle(radius: number): number {
|
||||
return 2 * MathUtils.PI * radius;
|
||||
}
|
||||
}
|
||||
|
||||
// Getters/Setters
|
||||
class Person {
|
||||
private _age: number = 0;
|
||||
|
||||
get age(): number {
|
||||
return this._age;
|
||||
}
|
||||
|
||||
set age(value: number) {
|
||||
if (value >= 0) this._age = value;
|
||||
}
|
||||
}
|
||||
|
||||
/***************************
|
||||
------------ 06: Generics -----------
|
||||
*******************************/
|
||||
|
||||
// Generic Functions
|
||||
function identity<T>(arg: T): T { return arg; }
|
||||
const result = identity<string>("hello");
|
||||
const inferred = identity(42); // T inferred as number
|
||||
|
||||
// Multiple Type Parameters
|
||||
function pair<T, U>(first: T, second: U): [T, U] {
|
||||
return [first, second];
|
||||
}
|
||||
|
||||
// Generic Interface
|
||||
interface Container<T> {
|
||||
value: T;
|
||||
getValue(): T;
|
||||
}
|
||||
|
||||
// Generic Class
|
||||
class Box<T> {
|
||||
contents: T;
|
||||
constructor(value: T) {
|
||||
this.contents = value;
|
||||
}
|
||||
}
|
||||
|
||||
// Constraints
|
||||
interface HasLength {
|
||||
length: number;
|
||||
}
|
||||
|
||||
function logLength<T extends HasLength>(arg: T): void {
|
||||
console.log(arg.length);
|
||||
}
|
||||
|
||||
// Keyof Constraint
|
||||
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
|
||||
return obj[key];
|
||||
}
|
||||
|
||||
/***************************
|
||||
------------ 07: Union & Literal Types -----------
|
||||
*******************************/
|
||||
|
||||
// Union Types
|
||||
type StringOrNumber = string | number;
|
||||
type Status = "loading" | "success" | "error";
|
||||
|
||||
function process(id: string | number): void {
|
||||
if (typeof id === "string") {
|
||||
console.log(id.toUpperCase());
|
||||
} else {
|
||||
console.log(id.toFixed(2));
|
||||
}
|
||||
}
|
||||
|
||||
// Intersection Types
|
||||
type Person = {name: string};
|
||||
type Employee = {company: string};
|
||||
type Staff = Person & Employee; // has both properties
|
||||
|
||||
// Literal Types
|
||||
type Theme = "light" | "dark";
|
||||
type Port = 3000 | 8080 | 9000;
|
||||
type Success = true;
|
||||
|
||||
// Discriminated Unions
|
||||
interface Circle {
|
||||
kind: "circle";
|
||||
radius: number;
|
||||
}
|
||||
interface Square {
|
||||
kind: "square";
|
||||
sideLength: number;
|
||||
}
|
||||
type Shape = Circle | Square;
|
||||
|
||||
function area(shape: Shape): number {
|
||||
switch (shape.kind) {
|
||||
case "circle":
|
||||
return Math.PI * shape.radius ** 2;
|
||||
case "square":
|
||||
return shape.sideLength ** 2;
|
||||
}
|
||||
}
|
||||
|
||||
/***************************
|
||||
------------ 08: Type Guards & Assertions -----------
|
||||
*******************************/
|
||||
|
||||
// Type Guards
|
||||
function isString(value: any): value is string {
|
||||
return typeof value === "string";
|
||||
}
|
||||
|
||||
function isNumber(value: any): value is number {
|
||||
return typeof value === "number";
|
||||
}
|
||||
|
||||
// Using Type Guards
|
||||
function process(value: string | number) {
|
||||
if (isString(value)) {
|
||||
console.log(value.toUpperCase()); // TypeScript knows it's string
|
||||
} else {
|
||||
console.log(value.toFixed(2)); // TypeScript knows it's number
|
||||
}
|
||||
}
|
||||
|
||||
// in operator
|
||||
type Fish = { swim: () => void };
|
||||
type Bird = { fly: () => void };
|
||||
|
||||
function move(animal: Fish | Bird) {
|
||||
if ("swim" in animal) {
|
||||
animal.swim(); // Fish
|
||||
} else {
|
||||
animal.fly(); // Bird
|
||||
}
|
||||
}
|
||||
|
||||
// instanceof
|
||||
function handleError(error: Error | string) {
|
||||
if (error instanceof Error) {
|
||||
console.log(error.message);
|
||||
} else {
|
||||
console.log(error);
|
||||
}
|
||||
}
|
||||
|
||||
// Type Assertions
|
||||
let someValue: any = "hello world";
|
||||
let strLength = (someValue as string).length;
|
||||
// or: let strLength = (<string>someValue).length;
|
||||
|
||||
// Non-null Assertion
|
||||
let name: string | null = getName();
|
||||
let nameLength = name!.length; // Assert name is not null
|
||||
|
||||
/***************************
|
||||
------------ 09: Utility Types -----------
|
||||
*******************************/
|
||||
|
||||
interface Todo {
|
||||
title: string;
|
||||
description: string;
|
||||
completed: boolean;
|
||||
}
|
||||
|
||||
// Partial<T> - All properties optional
|
||||
type PartialTodo = Partial<Todo>;
|
||||
// {title?: string, description?: string, completed?: boolean}
|
||||
|
||||
// Required<T> - All properties required
|
||||
type RequiredTodo = Required<PartialTodo>;
|
||||
|
||||
// Readonly<T> - All properties readonly
|
||||
type ReadonlyTodo = Readonly<Todo>;
|
||||
|
||||
// Pick<T, K> - Select specific properties
|
||||
type TodoPreview = Pick<Todo, "title" | "completed">;
|
||||
|
||||
// Omit<T, K> - Exclude specific properties
|
||||
type TodoInfo = Omit<Todo, "completed">;
|
||||
|
||||
// Record<K, T> - Create object type
|
||||
type TodoStatus = Record<"pending" | "completed", Todo[]>;
|
||||
|
||||
// Exclude<T, U> - Remove types from union
|
||||
type NonString = Exclude<string | number | boolean, string>;
|
||||
// number | boolean
|
||||
|
||||
// Extract<T, U> - Extract types from union
|
||||
type StringOnly = Extract<string | number | boolean, string>;
|
||||
// string
|
||||
|
||||
// NonNullable<T> - Remove null/undefined
|
||||
type NonNullString = NonNullable<string | null | undefined>;
|
||||
// string
|
||||
|
||||
// ReturnType<T> - Get function return type
|
||||
function getName(): string { return "John"; }
|
||||
type NameType = ReturnType<typeof getName>; // string
|
||||
|
||||
// Parameters<T> - Get function parameters as tuple
|
||||
type GetNameParams = Parameters<typeof getName>; // []
|
||||
|
||||
/***************************
|
||||
------------ 10: Enums -----------
|
||||
*******************************/
|
||||
|
||||
// Numeric Enum
|
||||
enum Direction {
|
||||
Up, // 0
|
||||
Down, // 1
|
||||
Left, // 2
|
||||
Right // 3
|
||||
}
|
||||
|
||||
// String Enum
|
||||
enum Color {
|
||||
Red = "red",
|
||||
Green = "green",
|
||||
Blue = "blue"
|
||||
}
|
||||
|
||||
// Mixed Enum
|
||||
enum Mixed {
|
||||
No = 0,
|
||||
Yes = "yes"
|
||||
}
|
||||
|
||||
// Const Enum (inlined at compile time)
|
||||
const enum StatusCode {
|
||||
OK = 200,
|
||||
NotFound = 404,
|
||||
Error = 500
|
||||
}
|
||||
|
||||
// Usage
|
||||
let currentDirection = Direction.Up;
|
||||
let favoriteColor = Color.Blue;
|
||||
let status = StatusCode.OK;
|
||||
|
||||
/***************************
|
||||
------------ 11: Modules -----------
|
||||
*******************************/
|
||||
|
||||
// Named Exports
|
||||
export const PI = 3.14159;
|
||||
export function calculate(r: number): number {
|
||||
return PI * r * r;
|
||||
}
|
||||
export class Calculator {
|
||||
add(x: number, y: number): number { return x + y; }
|
||||
}
|
||||
|
||||
// Default Export
|
||||
export default class Logger {
|
||||
log(message: string): void {
|
||||
console.log(message);
|
||||
}
|
||||
}
|
||||
|
||||
// Re-exports
|
||||
export { Calculator as Calc } from "./calculator";
|
||||
export * from "./utilities";
|
||||
|
||||
// Import
|
||||
import Logger from "./logger"; // default import
|
||||
import { PI, calculate } from "./math"; // named imports
|
||||
import * as MathUtils from "./math"; // namespace import
|
||||
import { Calculator as Calc } from "./calculator"; // alias
|
||||
|
||||
// Dynamic Imports
|
||||
const module = await import("./dynamic-module");
|
||||
|
||||
/***************************
|
||||
------------ 12: Advanced Types -----------
|
||||
*******************************/
|
||||
|
||||
// Mapped Types
|
||||
type Nullable<T> = {
|
||||
[P in keyof T]: T[P] | null;
|
||||
};
|
||||
|
||||
type OptionalId<T> = {
|
||||
[P in keyof T]: P extends "id" ? T[P] | undefined : T[P];
|
||||
};
|
||||
|
||||
// Conditional Types
|
||||
type IsString<T> = T extends string ? true : false;
|
||||
type StringCheck = IsString<"hello">; // true
|
||||
|
||||
// Template Literal Types
|
||||
type EventName<T extends string> = `on${Capitalize<T>}`;
|
||||
type ClickEvent = EventName<"click">; // "onClick"
|
||||
|
||||
// Indexed Access Types
|
||||
type Person = { name: string; age: number; location: string };
|
||||
type PersonName = Person["name"]; // string
|
||||
type PersonKeys = keyof Person; // "name" | "age" | "location"
|
||||
|
||||
// Recursive Types
|
||||
type Json = string | number | boolean | null | Json[] | {[key: string]: Json};
|
||||
|
||||
/***************************
|
||||
------------ 13: Decorators -----------
|
||||
*******************************/
|
||||
|
||||
// Class Decorator
|
||||
function Component(name: string) {
|
||||
return function<T extends {new(...args: any[]): {}}>(constructor: T) {
|
||||
return class extends constructor {
|
||||
componentName = name;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
@Component("MyComponent")
|
||||
class MyClass {}
|
||||
|
||||
// Method Decorator
|
||||
function Log(target: any, propertyName: string, descriptor: PropertyDescriptor) {
|
||||
const method = descriptor.value;
|
||||
descriptor.value = function(...args: any[]) {
|
||||
console.log(`Calling ${propertyName} with`, args);
|
||||
return method.apply(this, args);
|
||||
};
|
||||
}
|
||||
|
||||
class Service {
|
||||
@Log
|
||||
getData(): string {
|
||||
return "data";
|
||||
}
|
||||
}
|
||||
|
||||
// Property Decorator
|
||||
function MinLength(length: number) {
|
||||
return function(target: any, propertyName: string) {
|
||||
let value: string;
|
||||
|
||||
const getter = () => value;
|
||||
const setter = (newVal: string) => {
|
||||
if (newVal.length < length) {
|
||||
throw new Error(`${propertyName} must be at least ${length} chars`);
|
||||
}
|
||||
value = newVal;
|
||||
};
|
||||
|
||||
Object.defineProperty(target, propertyName, {
|
||||
get: getter,
|
||||
set: setter
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
class User {
|
||||
@MinLength(3)
|
||||
username: string;
|
||||
}
|
||||
|
||||
/***************************
|
||||
------------ 14: Configuration -----------
|
||||
*******************************/
|
||||
|
||||
// tsconfig.json
|
||||
/*
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2020",
|
||||
"module": "commonjs",
|
||||
"lib": ["ES2020", "DOM"],
|
||||
"outDir": "./dist",
|
||||
"rootDir": "./src",
|
||||
"strict": true,
|
||||
"esModuleInterop": true,
|
||||
"skipLibCheck": true,
|
||||
"forceConsistentCasingInFileNames": true,
|
||||
"moduleResolution": "node",
|
||||
"allowSyntheticDefaultImports": true,
|
||||
"experimentalDecorators": true,
|
||||
"emitDecoratorMetadata": true,
|
||||
"sourceMap": true,
|
||||
"declaration": true,
|
||||
"removeComments": true,
|
||||
"noImplicitAny": true,
|
||||
"noImplicitReturns": true,
|
||||
"noUnusedLocals": true,
|
||||
"noUnusedParameters": true
|
||||
},
|
||||
"include": ["src/**/*"],
|
||||
"exclude": ["node_modules", "dist"]
|
||||
}
|
||||
*/
|
||||
|
||||
// Compiler Options Quick Reference
|
||||
// --target: ES5, ES6, ES2017, ES2018, ES2019, ES2020, ESNext
|
||||
// --module: commonjs, amd, es2015, es2020, esnext, system, umd
|
||||
// --lib: ES5, ES6, ES2017, DOM, WebWorker, ScriptHost
|
||||
// --strict: Enable all strict type checking options
|
||||
|
||||
/***************************
|
||||
------------ 15: Common Patterns -----------
|
||||
*******************************/
|
||||
|
||||
// API Response Type
|
||||
interface ApiResponse<T> {
|
||||
data: T;
|
||||
status: number;
|
||||
message: string;
|
||||
}
|
||||
|
||||
// Event Handler Pattern
|
||||
type EventHandler<T = Event> = (event: T) => void;
|
||||
const onClick: EventHandler<MouseEvent> = (e) => console.log(e.clientX);
|
||||
|
||||
// Builder Pattern
|
||||
class QueryBuilder {
|
||||
private query = "";
|
||||
|
||||
select(fields: string): this {
|
||||
this.query += `SELECT ${fields} `;
|
||||
return this;
|
||||
}
|
||||
|
||||
from(table: string): this {
|
||||
this.query += `FROM ${table} `;
|
||||
return this;
|
||||
}
|
||||
|
||||
build(): string {
|
||||
return this.query.trim();
|
||||
}
|
||||
}
|
||||
|
||||
// Factory Pattern
|
||||
interface Shape { area(): number; }
|
||||
class Circle implements Shape {
|
||||
constructor(private radius: number) {}
|
||||
area(): number { return Math.PI * this.radius ** 2; }
|
||||
}
|
||||
|
||||
class ShapeFactory {
|
||||
static createCircle(radius: number): Shape {
|
||||
return new Circle(radius);
|
||||
}
|
||||
}
|
||||
|
||||
// Promise/Async Patterns
|
||||
type AsyncResult<T> = Promise<T | Error>;
|
||||
|
||||
async function fetchUser(id: number): Promise<User | null> {
|
||||
try {
|
||||
const response = await fetch(`/api/users/${id}`);
|
||||
return await response.json();
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// Type-safe Environment Variables
|
||||
interface Env {
|
||||
NODE_ENV: "development" | "production" | "test";
|
||||
PORT: number;
|
||||
DATABASE_URL: string;
|
||||
}
|
||||
|
||||
declare global {
|
||||
namespace NodeJS {
|
||||
interface ProcessEnv extends Env {}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* QUICK TIPS
|
||||
* ----------
|
||||
* • Use 'unknown' instead of 'any' when possible
|
||||
* • Prefer 'interface' for object shapes, 'type' for unions/computed types
|
||||
* • Enable strict mode in tsconfig.json
|
||||
* • Use const assertions: const colors = ['red', 'blue'] as const
|
||||
* • Prefer type guards over type assertions
|
||||
* • Use utility types instead of manual type manipulation
|
||||
* • Enable noImplicitAny for better type safety
|
||||
* • Use discriminated unions for complex state management
|
||||
*/
|
||||
@@ -0,0 +1,485 @@
|
||||
|
||||
#DATA TYPES
|
||||
1)void - type with empty set of values.There is no structure assosciated with void except pointers.
|
||||
std::nullptr_t is a special pointer that is not itself a pointer type.
|
||||
|
||||
2) int - stores an integer value .
|
||||
4 bytes C++ standard since C11. (for 16-bit OS its 2 bytes)
|
||||
Hence,int value ranges from -2147483648 to 2147483647.
|
||||
|
||||
3) float - stores an decimal value.
|
||||
4 bytes .
|
||||
|
||||
4) char - stores a single character value(ASCII values)
|
||||
1 byte.(0 to 255)
|
||||
|
||||
5) bool - stores a boolean value.(true or false)
|
||||
1 byte.
|
||||
stores a value 0 or 1 indicating tue or false.
|
||||
|
||||
# MODIFIERS
|
||||
C++ has modifiers for extending the limits of the basic data types for some advanced calculation.There are 2 types of Modifiers:-
|
||||
1)Signedness
|
||||
# signed - by default,target will have signed representation ,which means a variable can take negative values.
|
||||
# unsigned - target data type will be unsigned means only positive(absolute) values will be taken by that type.
|
||||
|
||||
2) Size
|
||||
# short - Target data type will have a width of atleast 2 bytes.The data type is optimized for lower bounds using less space.
|
||||
# long - Target data type will have a width of atleast 4 bytes.
|
||||
# long long - Target data type will have a width of at least 8 bytes.
|
||||
|
||||
Character Types
|
||||
|
||||
1) signed char
|
||||
2) unsigned char
|
||||
3) char
|
||||
4) wchar_t
|
||||
|
||||
Float Types
|
||||
1) float
|
||||
2) double
|
||||
3) long double
|
||||
|
||||
# DATA STRUCTURES
|
||||
1) ARRAYS
|
||||
to declare an array of any type : data_type name_of_array[size of array];
|
||||
array cannot be re-intialized with the number of elements.
|
||||
|
||||
2) LINKED LIST
|
||||
a linked list in cpp is built-in in the form of vectors
|
||||
to declare an vector(linked list) in cpp : vector<data_type> name;
|
||||
you have to include vector library. #include<vector>
|
||||
|
||||
3) STACK
|
||||
to make a stack in cpp : stack<data_type> name;
|
||||
you have to include stack library .#include<stack>
|
||||
|
||||
4) QUEUE
|
||||
to make a queue in cpp : queue<data_type> name;
|
||||
you have to include queue library .#include<queue>
|
||||
|
||||
cout<<"Anything"<<variables<<endl;
|
||||
* This prints text on console (Console OUTput).
|
||||
cin>>x;
|
||||
* This inputs data from user and stores in specified variables.
|
||||
|
||||
cin.getline(variable,characters in it)
|
||||
* This is specially used for white sapced (Spaces) input.
|
||||
|
||||
|
||||
* Declare a variable named x
|
||||
DataType Description
|
||||
int x; // Integer var named x
|
||||
char x; // Character var stores one alphabet,numerics,special symbol and is one byte.
|
||||
string x; // Characterd back to back
|
||||
bool x; // Boolean value (1 or 0)(true or false)
|
||||
float x; // Real values (decimal numbers)
|
||||
|
||||
*
|
||||
|
||||
#KEYWORDS (reserved words ,have special functionality).There are 97 keywords in C++ as of C20 standard.
|
||||
1) alignas -specifies the alignment requirement of a type or an object.
|
||||
2) alignof -queries alignment requirements of a type.
|
||||
3) and -logical and operator.(alternative to &&)
|
||||
4) and_eq -bitwise and operator .(alternative to &= ,x&=y or x=x&y)
|
||||
5) asm -embed assembly code within C++ program.
|
||||
6) atomic_cancel -
|
||||
7) atomic_commit -
|
||||
8) atomic_noexcept
|
||||
9) auto -automatic intializer or return type evaluated.
|
||||
10) bitand -alternative for bitwise and. (&)
|
||||
11) bitor -alternative for bitwise or. (|)
|
||||
12) bool -data type,capable of holding either true or false.
|
||||
13) break -terminating statement for, loops and switch statements.
|
||||
14) case -transfer control to one of the several statements depending on the value of conditions.
|
||||
15) catch -used in exception handling.
|
||||
16) char -data type character.
|
||||
17) char8_t -character data type 1 byte.(UTF-8 bit character)
|
||||
18) char16_t -character data type 2 bytes.(UTF-16 bit character)
|
||||
19) char32_t -character data type 4 bytes.(UTF-32 bit character)
|
||||
20) class -declaration of user-defined data types.
|
||||
21) compl -compliment operator.(alternative to ~)
|
||||
22) concept -named set of requirements.
|
||||
23) const -defines that the type is constant.
|
||||
24) consteval -specifies that a function is an immediate function.
|
||||
25) constexpr -specifies that the value of a variable or function can appear in constant expression.
|
||||
26) constinit -asserts that a variable has static intialization.
|
||||
27) const_cast -converts between types with different cv-qualification.
|
||||
28) continue -causes the remaining body of loops to be skipped.
|
||||
29) co_await -suspend operation until resumed.
|
||||
30) co_return -complete execution returning a value.
|
||||
31) co_yield -suspend execution returning a value.
|
||||
32) decltype -inspects the declared type of an entity or the type and value category of an expression.
|
||||
33) default -transfer control to one of the several statements,explicitly defaultedfunction definition.
|
||||
34) delete -destroy previously allocated objects,ill-formed functions.
|
||||
35) do -do-while loop.(executes a statement repeatedly,until condition is false)
|
||||
36) double -double precision floating point.
|
||||
37) dynamic_cast -safely converts pointers and references to classes along the inheritance hierarchy.
|
||||
38) else -if the bool value of if() is false then this block gets executed.
|
||||
39) enum -enumeration is a distinct type whose value is restricted to a range of values.
|
||||
40) explicit -specifies that a constructor or conversion function cannot be used for implicit conversions and copy initialization.
|
||||
41) export -exports all namespace-scope declaration.
|
||||
42) extern -applies the language specification for external linkages of function names,types and variables.
|
||||
43) false -a boolean literal indicating condition is not satisfied.
|
||||
44) float -data type declaration for floating point numbers.
|
||||
45) for -intializes counter once and iterates over and over again incrementing the counter each time ,till the condition is met.Range based for loop executes over a range.
|
||||
46) friend -a friend declaration appears in a class body to grants a function or another class access to private and protected members.
|
||||
47) goto -transfers control unconditionally.
|
||||
48) if -if the condition yields true then the block of code gets executed.
|
||||
49) inline -declares a function to be inline function .
|
||||
50) int -basic integer data type.
|
||||
51) long -target type will have a width of atleast 4 bytes.
|
||||
52) mutable -permits modification of class members even if they are declared const.
|
||||
53) namespace -provide a method for preventing name conflicts in large projects.
|
||||
54) new -creates and initializes objects with dynamic storage duration.
|
||||
55) noexcept -performs a compile time check that returns true if an expression is declared not to throw exceptions.
|
||||
56) not -alternative operator for !
|
||||
57) not_eq -alternative operator for !=
|
||||
58) null_ptr -denotes a pointer literal.
|
||||
59) operator -customizes C++ operators for operands of user-defined data type
|
||||
60) or -alternative to | operator.
|
||||
61) or_eq -alternative to |= operator.
|
||||
62) private -member specification of class/struct or union ,define the accessibility of subsequent members.
|
||||
63) protected -member specification of class/struct or union ,define the accessibility of subsequent members and inherited members of base class.
|
||||
64) public - member specification of class/struct or union ,define the accessibility of subsequent members to any subsequent class.
|
||||
65) reflexpr -
|
||||
66) register -automatic storage duration.
|
||||
67) reinterpret_cast -converts between types by reinterpreting the underlying bit pattern.
|
||||
68) requires -used to introduce a requires-clause, which specifies constraints on template arguments or on a function declaration.
|
||||
69) return -terminates the current function and gives back a specified value to the caller.
|
||||
70) short -target type will be optimized for space and will have a width of 2 bytes atleast.
|
||||
71) signed -target will have a signed representation.
|
||||
72) sizeof -used when actual size of object must be known.
|
||||
73) static -specified variables will have static storage duration.
|
||||
74) static_asset -performs compile-time assertion check.
|
||||
75) static_cast -converts between types using a combination of implicit and user-defined conversions.
|
||||
76) struct -class with public member accessibility by default.
|
||||
77) switch -transfer control to one of the several statements,depending on the value of condition.
|
||||
78) synchronized -
|
||||
79) template -template is an entity of family of either classes,functions or variables.
|
||||
80) this -a prvalue expression whose value is the address of the implicit object parameter.
|
||||
81) thread_local -thread storage duration.
|
||||
82) throw -signals and erroneous conditions and executes an error handler.
|
||||
83) true -a boolean literal indicating condition is satisfied.
|
||||
84) try -associates one or more exception handlers with a compound statement.
|
||||
85) typedef -creates an alias that can be used anywhere in place of a type name.
|
||||
86) typeid -used where the dynamic type or polymorphic object must be known and for static type identification.
|
||||
87) typename -similar word for class.
|
||||
88) union -a special class type that can hold only one of its non-static data members at a time.
|
||||
89) unsigned -target type will have a unsigned representation.
|
||||
90) using -introduces a name that is defines elsewhere into the declarative region .
|
||||
91) virtual -virtual functions or classes are defined using the virtual keyword.
|
||||
92) void -type with empty set of values.
|
||||
93) volatile -defines that the type is volatile.
|
||||
94) wchar_t -type for wide character representation.
|
||||
95) while -executes statements repeatedly untill the condition becomes false.
|
||||
96) xor -alternative operator for ^
|
||||
97) xor_eq -alternative operatir for ^=
|
||||
|
||||
#HEADER FILES
|
||||
|
||||
#include<files>
|
||||
*This makes the compiler aware that other files are required for the complete working of this source code.
|
||||
|
||||
List of Header files and their respective functions in C++
|
||||
1) <cstdlib> General purpose library.
|
||||
|
||||
Function name use cases return type Parameters
|
||||
malloc allocates memory void* 1(number of bytes)
|
||||
calloc allocates and zeroes memory void* 2(no.of obj,size of each obj)
|
||||
realloc expands or shrinks previously allocated memory void* 2(pointer to mem area allocated,new size of array)
|
||||
free deallocates previously allocated memory void 1(pointer to memory to deallocate)
|
||||
atof converts a byte string to floating point value double 1(string)
|
||||
atoll converts a byte string to integer value int/long/long long 1(string)
|
||||
strtoull converts a byte string to unsigned integer long/long long 3(str ,str_end ,base)
|
||||
strtold convert a byte string to a float point value float/double/lonng double 2(str ,str_end)
|
||||
rand generate pseudo-random numbers int 0
|
||||
srand seeds pseudo-random number generation void 1(seed)
|
||||
qsort sorts range of element with unspecified type. void 4(ptr ,count ,size ,comp)
|
||||
bsearch searches an array for an element of unspecified type. void* 5(key ,ptr ,count ,size ,comp)
|
||||
abs/llabs completes absolute value of an integer value. int/long/long long 1(int)
|
||||
lldiv computes quotient and remainder of integer division obj 2(int,int)
|
||||
abort abnormal program termination without cleaning up. void 0
|
||||
exit normal program termination with cleaning up. void 1(exit_code)
|
||||
mblen returns number of bytes in next multibyte characters. int 2(ptr ,int)
|
||||
mbtowc converts a next multilayer character to wide characters. int 3(int , ptr , ptr)
|
||||
wctomb converts a next multilayer character to wide characters. int 2(wide char , ptr)
|
||||
|
||||
2) <bitset> general utility library
|
||||
|
||||
operator& performs binary logic operations on bitsets.(and)
|
||||
operator| performs binary logic operations on bitsets.(or) }obj 2(lhs ,rhs)
|
||||
operator^ performs binary logic operations on bitsets.(xor)
|
||||
operator>> performs stream output of bitsets
|
||||
operator<< performs stream input of bitsets
|
||||
|
||||
3) <utility> general utility library
|
||||
|
||||
swap swaps the value of two objects. obj 2(a ,b)
|
||||
exchange replaces the argument with a new value and returns its previous value. obj 2(obj , new_obj)
|
||||
forward forwards a function argument. obj 1(obj)
|
||||
move obtains an rvalue refrence. obj 1(obj)
|
||||
std::get access an element of a pair. refernce (ptr) 1(obj)
|
||||
operator<=> lexicographically compares the value in pair. boolean 2(lhs , rhs)
|
||||
in_range checks if an integer value is in the range of a given integer type. boolean 1(obj)
|
||||
|
||||
cmp_equal
|
||||
cmp_not_equal
|
||||
cmp_less } compares two integer values without value change caused by conversion. boolean 2(u , t )
|
||||
cmp_greater
|
||||
cmp_less_equal
|
||||
cmp_greater_equal
|
||||
|
||||
4) <functional> provudes standard hash functions
|
||||
|
||||
bind_front binds a variable number of arguments,in order,to a function object. obj 2(obj , args)
|
||||
bind binds one or more arguments to a function object. obj 2(obj , args)
|
||||
ref/cref creates a std::reference_wrapper with a type deduced from its argument. obj 1(ptr to obj)
|
||||
invoke invokes any callable object with given arguments. obj 2(obj , args)
|
||||
|
||||
5) <ctime> C-style time/date utility.
|
||||
|
||||
clock returns raw processor clock time since the program started. int (time) 0
|
||||
time returns the current time of the system since epoch. obj 1(ptr)
|
||||
difftime computes the difference between times. int (time) 2(time_begin , time_end)
|
||||
time_spec_get returns the calender time based on a given time base. int 2(ptr , base)
|
||||
|
||||
6) <chrono> C++ time/date utility
|
||||
|
||||
opeartors
|
||||
+
|
||||
-
|
||||
* }implements arithmetic operations with durations as arguments. obj 4(lhs , rhs , d , s)
|
||||
/
|
||||
%
|
||||
|
||||
operators
|
||||
==
|
||||
<
|
||||
> }compares two durations. obj 2(lhs , rhs )
|
||||
<=
|
||||
>=
|
||||
<=>
|
||||
|
||||
duration cast converts a duration to another. time duration(int ,float,etc) 1(duration time)
|
||||
floor converts a duration to another,rounding down. time duration(int ,float,etc) 1(duration time)
|
||||
ceil converts a duration to another,rounding up. time duration(int ,float,etc) 1(duration time)
|
||||
round converts a duration to another,rounding to nearest,ties to even. time duration(int ,float,etc) 1(duration time)
|
||||
abs obtain the absolute value of the duration. time duration(int ,float,etc) 1(duration time)
|
||||
|
||||
7) <algorithm>
|
||||
|
||||
all_of
|
||||
any_of } checks for any predicate is true for elements in a range. boolean 4(first ,last, policy ,predicate)
|
||||
none_of
|
||||
|
||||
for_each applies a function to a range of elements obj 4(first ,last, policy ,obj)
|
||||
for_each_n applies a function to a range of n elements in a sequence integer 4(first ,last, policy ,obj)
|
||||
count }returns the number of elements satisfying a criteria. integer 4(first ,last, policy ,predicate)
|
||||
count_if
|
||||
mismatch finds first position where two ranges differ. obj 6(first1 ,last1 ,first2 ,last2 ,policy ,binary predicate)
|
||||
find
|
||||
find_if }finds first element which satisfies specific criteria. obj 6(first, last ,policy ,valur,unary predicate,binary predicate)
|
||||
find_if
|
||||
find_if_not
|
||||
find_end finds the last sequence of elements in a range. obj 6(first ,last ,s_first ,s_last, ppolicy ,binary predicate)
|
||||
find_first_of searches for any one of a set of elements.
|
||||
adjacent_find finds first two adjacent items that are equal.
|
||||
search searches for a range of elements.
|
||||
search_n searches a range for a number of consecutive copies of an element
|
||||
|
||||
copy }copies a range of elements to a new location
|
||||
copy_if
|
||||
copy_n copies a range of elements to a new location.
|
||||
copy_backward copies a range of elements in backward order.
|
||||
move moves a range of elements to a new location.
|
||||
move_backward moves a range of elements to a new location in backward location.
|
||||
fill copy-assigns the given value to every element in a range.
|
||||
fill_n copy-assigns the given value to N elements in a range.
|
||||
transform applies a function to a range of elements, storing results in a destination range.
|
||||
generate assigns the results of successive function calls to every element in a range .
|
||||
generate_n assigns the results of successive function calls to N elements in a range.
|
||||
remove }removes elements satisfying specific criteria.
|
||||
remove_if
|
||||
remove_copy }copies a range of elements omitting those that satisfy specific criteria.
|
||||
remove_copy_if
|
||||
replace }replaces all values satisfying specific criteria with another value.
|
||||
replace_if
|
||||
replace_copy }copies a range, replacing elements satisfying specific criteria with another value.
|
||||
replace_copy_if
|
||||
swap swaps the values of two objects.
|
||||
swap_ranges swaps two ranges of elements.
|
||||
iter_swap swaps the elements pointed to by two iterators.
|
||||
reverse reverses the order of elements in a range.
|
||||
reverse_copy creates a copy of a range that is reversed.
|
||||
rotate rotates the order of elements in a range.
|
||||
rotate_copy copies and rotate a range of elements.
|
||||
shift_left }shifts elements in a range.
|
||||
shift_right
|
||||
shuffle }randomly re-orders elements in a range.
|
||||
random_shuffle
|
||||
sample selects n random elements from a sequence.
|
||||
unique removes consecutive duplicate elements in a range.
|
||||
unique_copy creates a copy of some range of elements that contains no consecutive duplicates.
|
||||
|
||||
is_partitioned determines if the range is partitioned by the given predicate.
|
||||
partition divides a range of elements into two groups.
|
||||
partition_copy copies a range dividing the elements into two groups.
|
||||
stable_partition divides elements into two groups while preserving their relative order.
|
||||
partition_point locates the partition point of a partitioned range.
|
||||
|
||||
is_sorted }checks whether a range is sorted into ascending order.
|
||||
is_sorted_until
|
||||
sort sorts a range into ascending order.
|
||||
partial_sort sorts the first N elements of a range.
|
||||
partial_sirt_copy copies and partially sorts a range of elements.
|
||||
stable_sort sorts a range of elements while preserving order between equal elements.
|
||||
nth_element partially sorts the given range, partitioned by the given element.
|
||||
|
||||
lower_bound returns an iterator to the first element not less than the given value.
|
||||
upper_bound returns an iterator to the first element greater than a certain value.
|
||||
binary_search determines if an element exists in a certain range.
|
||||
equal_range returns range of elements matching a specific key.
|
||||
|
||||
merge merges two sorted ranges.
|
||||
inplace_merge merges two ordered ranges in-place.
|
||||
|
||||
includes returns true if one sequence is a subsequence of another .
|
||||
set_differences computes the difference between two sets.
|
||||
set_interactions computes the intersection of two sets.
|
||||
set_symmetric_difference computes the symmetric difference between two sets.
|
||||
set_union computes the union of two sets.
|
||||
|
||||
is_heap checks if the given range is a max heap.
|
||||
is_heap_until finds the largest subrange that is a max heap.
|
||||
make_heap creates a max heap out of a range of elements.
|
||||
push_heap adds an element to a max heap.
|
||||
pop_heap removes the largest element from a max heap.
|
||||
sort_heap turns a max heap into a range of elements sorted in ascending order.
|
||||
|
||||
max returns the greater of the given values.
|
||||
max_element returns the largest element in a range.
|
||||
min returns the smaller of the given values.
|
||||
min_element returns the smallest element in a range.
|
||||
minmax returns the smaller and larger of two elements.
|
||||
minmax_element returns the smallest and the largest elements in a range.
|
||||
clamp clamps a value between a pair of boundary values.
|
||||
|
||||
equal determines if two sets of elements are the same.
|
||||
lexicographical_compare returns true if one range is lexicographically less than another.
|
||||
lexicographical_compare_three_way compares two ranges using three-way comparison.
|
||||
|
||||
is_permutation determines if a sequence is a permutation of another sequence.
|
||||
next_permutation generates the next greater lexicographic permutation of a range of elements.
|
||||
prev_permutation generates the next smaller lexicographic permutation of a range of elements.
|
||||
|
||||
range::all of the above functions in algorithm
|
||||
|
||||
8) <cmath>
|
||||
|
||||
abs
|
||||
fabs }absolute value of a floating point value.
|
||||
fabsf
|
||||
fabsl
|
||||
|
||||
fmod
|
||||
fmodf }remainder of the floating point division operation.
|
||||
fmodl
|
||||
|
||||
remainder
|
||||
remainderf }signed remainder of the division operation.
|
||||
remainderl
|
||||
|
||||
remquo
|
||||
remquof }signed remainder as well as the three last bits of the division operation.
|
||||
remquol
|
||||
|
||||
fma
|
||||
fmaf }fused multiply-add operation.
|
||||
fmal
|
||||
|
||||
fmax
|
||||
fmaxf }larger of two floating point values.
|
||||
fmaxl
|
||||
|
||||
fmin
|
||||
fminf }smaller of two floating point values.
|
||||
fminl
|
||||
|
||||
fdim
|
||||
fdimf }positive difference of two floating point values.
|
||||
fdiml
|
||||
|
||||
nan
|
||||
nanf }not-a-number (NaN).
|
||||
nanl
|
||||
|
||||
lerp linear interpolation function.
|
||||
|
||||
exp expf expl returns e raised to the given power.
|
||||
exp2 exp2f exp2l returns 2 raised to the given power.
|
||||
expm1 expm1f expm1l returns e raised to the given power, minus one.
|
||||
log logf logl computes natural (base e) logarithm.
|
||||
log10 log10f log10l computes common (base 10) logarithm.
|
||||
log2 log2f log2l base 2 logarithm of the given number.
|
||||
log1p log1pf log1pl natural logarithm (to base e) of 1 plus the given number.
|
||||
pow powf powl raises a number to the given power.
|
||||
sqrt sqrtf sqrtl computes square root.
|
||||
cbrt cbrtf cbrtl computes cubic root.
|
||||
hypot hypotf hypotl computes square root of the sum of the squares of two or three given numbers.
|
||||
sin sinf sinl computes sine.
|
||||
cos cosf cosl computes cosine.
|
||||
tan tanf tanl computes tangent.
|
||||
asin asinf asinl computes arc sine.
|
||||
acos acosf acosl computes arc cosine.
|
||||
atan atanf atanl computes arc tangent.
|
||||
sinh sinhf sinhl computes hyperbolic sine.
|
||||
cosh coshf coshl computes hyperbolic cosine.
|
||||
tanh tanhf tanhl computes hyperbolic tangent.
|
||||
asinh asinhf asinhl computes the inverse hyperbolic sine.
|
||||
acosh acochf acoshl computes the inverse hyperbolic cosine.
|
||||
atanh atanhf atanhl computes the inverse hyperbolic tangent.
|
||||
erf erff erfl error function.
|
||||
erfc erfcf erfcl complementary error function.
|
||||
tgamma tgammaf tgammal gamma function.
|
||||
lgamma lgammaf lgammal natural logarithm of the gamma function.
|
||||
ceil ceilf ceill nearest integer not less than the given value.
|
||||
floor floorf floorl nearest integer not greater than the given value.
|
||||
trunc truncf truncl nearest integer not greater in magnitude than the given value.
|
||||
round roundf roundl
|
||||
lround lroundf lroundl } nearest integer, rounding away from zero in halfway cases..
|
||||
llround llroundf llroundl
|
||||
nearbyint nearbyintf nearbyintl nearest integer using current rounding mode.
|
||||
|
||||
9) <complex>
|
||||
|
||||
operator+
|
||||
operator- }applies unary operators to complex numbers.
|
||||
opeartor* performs complex number arithmetics on two complex values or a complex and a scalar.
|
||||
operator/
|
||||
operator==
|
||||
operator!= }compares two complex numbers or a complex and a scalar.
|
||||
operator>>
|
||||
opeartor<< }serializes and deserializes a complex number.
|
||||
real returns the real component.
|
||||
imag returns the imaginary component.
|
||||
abs returns the magnitude of a complex number.
|
||||
arg returns the phase angle.
|
||||
norm returns the squared magnitude.
|
||||
conj returns the complex conjugate.
|
||||
proj returns the projection onto the Riemann sphere.
|
||||
polar constructs a complex number from magnitude and phase angle.
|
||||
exp complex base e exponential.
|
||||
log complex natural logarithm with the branch cuts along the negative real axis.
|
||||
log10 complex common logarithm with the branch cuts along the negative real axis.
|
||||
pow complex power, one or both arguments may be a complex number.
|
||||
sqrt complex square root in the range of the right half-plane.
|
||||
sin cos tan computes sine, cosine and tangent respectively of a complex number.
|
||||
asin acos atan computes arc sine, arc cosine and arc tangent respectively of a complex number.
|
||||
sinh cosh tanh computes hyperbolic sine, hyperbolic cosine and hyperbolic tangent respectively of a complex number.
|
||||
asinh acosh atanh computes area hyperbolic sine, area hyperbolic cosine and area hyperbolic tangent respectively of a complex number.
|
||||
operator""if
|
||||
operator""i } A std::complex literal representing pure imaginary number.
|
||||
operator""il
|
||||
|
||||
|
||||
@@ -95,9 +95,3 @@ arr.reduce(callback[, initialValue]) // Apply a function against
|
||||
arr.reduceRight(callback[, initialValue]) // Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value.
|
||||
arr.some(callback[, initialValue]) // Returns true if at least one element in this array satisfies the provided testing function.
|
||||
arr.values() // Returns a new Array Iterator object that contains the values for each index in the array.
|
||||
|
||||
// String methods
|
||||
String.charAt(index) // Returns the character at the specified index in a string.
|
||||
String.indexOf(character) // Returns the index of the first occurrence of a specified value in a string.
|
||||
String.substring(starting_index, ending_index) // Returns a new string that is a subset of the original string.
|
||||
String.substring(starting_index) // Returns a substring from starting index to last index of string.
|
||||
@@ -1,815 +0,0 @@
|
||||
# TypeScript
|
||||
|
||||
* TypeScript is a statically typed superset of JavaScript that compiles to plain JavaScript
|
||||
|
||||
* It adds optional static type definitions to JavaScript, enabling better tooling and error detection
|
||||
|
||||
* In TypeScript, types are checked at compile-time, not runtime
|
||||
|
||||
* A TypeScript file has an extension of .ts (or .tsx for React components)
|
||||
|
||||
* TypeScript follows JavaScript syntax but adds type annotations and advanced features
|
||||
|
||||
* We can compile and run a TypeScript file by the following commands:
|
||||
|
||||
`$ tsc filename.ts` (compile to JavaScript)
|
||||
`$ node filename.js` (run the compiled JavaScript)
|
||||
|
||||
Or directly: `$ ts-node filename.ts`
|
||||
|
||||
#### TypeScript requires compilation to JavaScript before execution.
|
||||
|
||||
## Create and execute a program
|
||||
|
||||
1. Install TypeScript globally: `npm install -g typescript`
|
||||
1. Create the program: `touch program.ts`
|
||||
1. Write the TypeScript code and save it
|
||||
1. Compile: `tsc program.ts`
|
||||
1. Run: `node program.js`
|
||||
|
||||
<br>
|
||||
|
||||
### Basic Data Types
|
||||
|
||||
| Data Type | Description | Example |
|
||||
| --------- | ----------- | ------- |
|
||||
| number | Integer and floating point values | `42`, `3.14`, `-7` |
|
||||
| string | Text values | `"hello"`, `'world'`, `` `template` `` |
|
||||
| boolean | True/false values | `true`, `false` |
|
||||
| undefined | Undefined value | `undefined` |
|
||||
| null | Null value | `null` |
|
||||
| any | Any type (disables type checking) | Can be anything |
|
||||
| unknown | Type-safe counterpart of any | Requires type checking |
|
||||
| void | Absence of any type | Function return type |
|
||||
| never | Type that never occurs | Functions that throw errors |
|
||||
| object | Non-primitive types | `{}`, `[]`, functions |
|
||||
|
||||
<br>
|
||||
|
||||
## Keywords and Reserved Words
|
||||
<br>
|
||||
|
||||
- TypeScript includes all JavaScript keywords plus additional TypeScript-specific ones
|
||||
|
||||
| Keyword | Description | Category |
|
||||
|---------- | ---------- | --------- |
|
||||
| let | Declares a block-scoped variable | Variable Declaration |
|
||||
| const | Declares a block-scoped constant | Variable Declaration |
|
||||
| var | Declares a function-scoped variable | Variable Declaration |
|
||||
| function | Declares a function | Function |
|
||||
| class | Declares a class | Class |
|
||||
| interface | Declares an interface | Type Definition |
|
||||
| type | Declares a type alias | Type Definition |
|
||||
| enum | Declares an enumeration | Type Definition |
|
||||
| namespace | Declares a namespace | Module System |
|
||||
| module | Declares a module | Module System |
|
||||
| import | Imports from another module | Module System |
|
||||
| export | Exports from current module | Module System |
|
||||
| extends | Class/interface inheritance | Inheritance |
|
||||
| implements | Class implements interface | Inheritance |
|
||||
| public | Public access modifier | Access Modifier |
|
||||
| private | Private access modifier | Access Modifier |
|
||||
| protected | Protected access modifier | Access Modifier |
|
||||
| readonly | Read-only property | Access Modifier |
|
||||
| static | Static class member | Class Member |
|
||||
| abstract | Abstract class/method | Class |
|
||||
| async | Asynchronous function | Async Programming |
|
||||
| await | Awaits a promise | Async Programming |
|
||||
| new | Creates new instance | Object Creation |
|
||||
| this | Current object reference | Object Reference |
|
||||
| super | Parent class reference | Inheritance |
|
||||
| typeof | Gets type of variable | Type Operation |
|
||||
| keyof | Gets keys of type | Type Operation |
|
||||
| in | Property existence check | Type Guard |
|
||||
| instanceof | Instance type check | Type Guard |
|
||||
| as | Type assertion | Type Assertion |
|
||||
| is | Type predicate | Type Guard |
|
||||
| infer | Infers type in conditional types | Advanced Types |
|
||||
| declare | Ambient declarations | Declaration |
|
||||
| get | Property getter | Accessor |
|
||||
| set | Property setter | Accessor |
|
||||
| yield | Generator yield | Generator |
|
||||
|
||||
<br>
|
||||
|
||||
## Operators
|
||||
|
||||
<br>
|
||||
|
||||
| Operator | Description |
|
||||
|-|-|
|
||||
| ( ) | Grouping, function call, type assertion |
|
||||
| [ ] | Array indexing, array/tuple types |
|
||||
| . | Property access |
|
||||
| ?. | Optional chaining |
|
||||
| ! | Non-null assertion, logical not |
|
||||
| ~ | Bitwise not |
|
||||
| \- | Unary minus, arithmetic subtraction |
|
||||
| \+ | Unary plus, arithmetic addition |
|
||||
| \* | Multiplication |
|
||||
| / | Division |
|
||||
| % | Modulo |
|
||||
| \*\* | Exponentiation |
|
||||
| << | Left shift |
|
||||
| \>> | Right shift |
|
||||
| \>>> | Unsigned right shift |
|
||||
| < | Less than |
|
||||
| <= | Less than or equal |
|
||||
| \> | Greater than |
|
||||
| \>= | Greater than or equal |
|
||||
| == | Equality (with coercion) |
|
||||
| === | Strict equality |
|
||||
| != | Inequality (with coercion) |
|
||||
| !== | Strict inequality |
|
||||
| & | Bitwise AND |
|
||||
| ^ | Bitwise XOR |
|
||||
| \| | Bitwise OR, Union types |
|
||||
| && | Logical AND |
|
||||
| \|\| | Logical OR |
|
||||
| ?? | Nullish coalescing |
|
||||
| ? : | Ternary conditional |
|
||||
| = | Assignment |
|
||||
| += | Add and assign |
|
||||
| -= | Subtract and assign |
|
||||
| *= | Multiply and assign |
|
||||
| /= | Divide and assign |
|
||||
| %= | Modulo and assign |
|
||||
| **= | Exponentiate and assign |
|
||||
| <<= | Left shift and assign |
|
||||
| \>>= | Right shift and assign |
|
||||
| &= | Bitwise AND and assign |
|
||||
| ^= | Bitwise XOR and assign |
|
||||
| \|= | Bitwise OR and assign |
|
||||
| , | Comma operator |
|
||||
| => | Arrow function |
|
||||
| ... | Spread/rest operator |
|
||||
|
||||
### Basic Data Structures
|
||||
|
||||
### Array
|
||||
|
||||
- Array is an ordered collection of elements of the same or different types.
|
||||
|
||||
- Arrays are created using square brackets or Array constructor:
|
||||
|
||||
```typescript
|
||||
let numbers: number[] = [1, 2, 3, 4];
|
||||
let fruits: Array<string> = ["apple", "banana", "cherry"];
|
||||
let mixed: (string | number)[] = [1, "two", 3];
|
||||
```
|
||||
|
||||
- Array elements are indexed starting from 0.
|
||||
|
||||
- Arrays are mutable - you can change, add, and remove elements.
|
||||
|
||||
- Common array methods:
|
||||
```typescript
|
||||
let arr = [1, 2, 3];
|
||||
arr.push(4); // Add to end: [1, 2, 3, 4]
|
||||
arr.pop(); // Remove from end: [1, 2, 3]
|
||||
arr.unshift(0); // Add to start: [0, 1, 2, 3]
|
||||
arr.shift(); // Remove from start: [1, 2, 3]
|
||||
arr.length; // Get length: 3
|
||||
```
|
||||
|
||||
### Tuple
|
||||
|
||||
- Tuple is an array with a fixed number of elements of specific types.
|
||||
|
||||
- Tuples are created using square brackets with type annotations:
|
||||
```typescript
|
||||
let person: [string, number] = ["John", 30];
|
||||
let coordinate: [number, number] = [10, 20];
|
||||
```
|
||||
|
||||
- Tuple elements are ordered and have specific types at each position.
|
||||
|
||||
- You can access elements by index, but type checking ensures correctness:
|
||||
```typescript
|
||||
let point: [number, number] = [10, 20];
|
||||
console.log(point[0]); // 10 (number)
|
||||
console.log(point[1]); // 20 (number)
|
||||
```
|
||||
|
||||
- Named tuples provide better readability:
|
||||
```typescript
|
||||
let user: [name: string, age: number] = ["Alice", 25];
|
||||
```
|
||||
|
||||
- Optional and rest elements in tuples:
|
||||
```typescript
|
||||
let optional: [string, number?] = ["hello"];
|
||||
let rest: [string, ...number[]] = ["coords", 1, 2, 3];
|
||||
```
|
||||
|
||||
### Set
|
||||
|
||||
- Set is a collection of unique values of any type.
|
||||
|
||||
- Sets are created using the Set constructor:
|
||||
```typescript
|
||||
let uniqueNumbers = new Set<number>([1, 2, 3, 2]); // {1, 2, 3}
|
||||
let stringSet = new Set<string>();
|
||||
```
|
||||
|
||||
- Set operations:
|
||||
```typescript
|
||||
let mySet = new Set<string>();
|
||||
mySet.add("apple"); // Add element
|
||||
mySet.has("apple"); // Check existence: true
|
||||
mySet.delete("apple"); // Remove element
|
||||
mySet.clear(); // Remove all elements
|
||||
mySet.size; // Get size
|
||||
```
|
||||
|
||||
- Iterating over Set:
|
||||
```typescript
|
||||
let fruits = new Set(["apple", "banana", "cherry"]);
|
||||
for (let fruit of fruits) {
|
||||
console.log(fruit);
|
||||
}
|
||||
```
|
||||
|
||||
### Map
|
||||
|
||||
- Map is a collection of key-value pairs where keys can be any type.
|
||||
|
||||
- Maps are created using the Map constructor:
|
||||
```typescript
|
||||
let userMap = new Map<string, number>();
|
||||
let mixedMap = new Map<string | number, any>();
|
||||
```
|
||||
|
||||
- Map operations:
|
||||
```typescript
|
||||
let map = new Map<string, number>();
|
||||
map.set("age", 30); // Add key-value pair
|
||||
map.get("age"); // Get value: 30
|
||||
map.has("age"); // Check key exists: true
|
||||
map.delete("age"); // Remove key-value pair
|
||||
map.clear(); // Remove all entries
|
||||
map.size; // Get size
|
||||
```
|
||||
|
||||
- Object vs Map:
|
||||
```typescript
|
||||
// Object - string/symbol keys only
|
||||
let obj: { [key: string]: number } = { "age": 30 };
|
||||
|
||||
// Map - any type keys
|
||||
let map = new Map<any, number>();
|
||||
map.set("age", 30);
|
||||
map.set(42, 100);
|
||||
map.set(true, 1);
|
||||
```
|
||||
|
||||
### Object Types and Interfaces
|
||||
|
||||
- Objects store key-value pairs and are fundamental to TypeScript.
|
||||
|
||||
- Object type annotation:
|
||||
```typescript
|
||||
let person: { name: string; age: number } = {
|
||||
name: "John",
|
||||
age: 30
|
||||
};
|
||||
```
|
||||
|
||||
- Interface definition for better reusability:
|
||||
```typescript
|
||||
interface User {
|
||||
readonly id: number; // Read-only property
|
||||
name: string;
|
||||
age?: number; // Optional property
|
||||
[key: string]: any; // Index signature
|
||||
}
|
||||
|
||||
let user: User = {
|
||||
id: 1,
|
||||
name: "Alice"
|
||||
};
|
||||
```
|
||||
|
||||
- Nested objects and complex types:
|
||||
```typescript
|
||||
interface Address {
|
||||
street: string;
|
||||
city: string;
|
||||
country: string;
|
||||
}
|
||||
|
||||
interface Person {
|
||||
name: string;
|
||||
address: Address;
|
||||
hobbies: string[];
|
||||
}
|
||||
```
|
||||
|
||||
### Conditional branching
|
||||
|
||||
```typescript
|
||||
// If-else statements
|
||||
if (condition) {
|
||||
// code block
|
||||
} else if (anotherCondition) {
|
||||
// code block
|
||||
} else {
|
||||
// code block
|
||||
}
|
||||
|
||||
// Ternary operator
|
||||
let result = condition ? valueIfTrue : valueIfFalse;
|
||||
|
||||
// Switch statement
|
||||
switch (variable) {
|
||||
case value1:
|
||||
// code
|
||||
break;
|
||||
case value2:
|
||||
// code
|
||||
break;
|
||||
default:
|
||||
// code
|
||||
break;
|
||||
}
|
||||
```
|
||||
|
||||
### Loops
|
||||
|
||||
TypeScript supports all JavaScript loop constructs:
|
||||
|
||||
#### For loop
|
||||
```typescript
|
||||
// Traditional for loop
|
||||
for (let i = 0; i < 5; i++) {
|
||||
console.log(i);
|
||||
}
|
||||
|
||||
// For-of loop (iterates over values)
|
||||
let fruits = ["apple", "banana", "cherry"];
|
||||
for (let fruit of fruits) {
|
||||
console.log(fruit);
|
||||
}
|
||||
|
||||
// For-in loop (iterates over keys/indices)
|
||||
for (let index in fruits) {
|
||||
console.log(index, fruits[index]);
|
||||
}
|
||||
```
|
||||
|
||||
#### While loop
|
||||
```typescript
|
||||
let i = 0;
|
||||
while (i < 5) {
|
||||
console.log(i);
|
||||
i++;
|
||||
}
|
||||
|
||||
// Do-while loop
|
||||
let j = 0;
|
||||
do {
|
||||
console.log(j);
|
||||
j++;
|
||||
} while (j < 5);
|
||||
```
|
||||
|
||||
#### Loop control
|
||||
```typescript
|
||||
for (let i = 0; i < 10; i++) {
|
||||
if (i === 3) continue; // Skip iteration
|
||||
if (i === 7) break; // Exit loop
|
||||
console.log(i);
|
||||
}
|
||||
```
|
||||
|
||||
### Function definition
|
||||
|
||||
```typescript
|
||||
// Function declaration
|
||||
function functionName(param1: type, param2: type): returnType {
|
||||
return value;
|
||||
}
|
||||
|
||||
// Function expression
|
||||
const functionName = function(param: type): returnType {
|
||||
return value;
|
||||
};
|
||||
|
||||
// Arrow function
|
||||
const functionName = (param: type): returnType => {
|
||||
return value;
|
||||
};
|
||||
|
||||
// Arrow function (concise)
|
||||
const functionName = (param: type): returnType => value;
|
||||
```
|
||||
|
||||
### Function variations
|
||||
|
||||
```typescript
|
||||
// Optional parameters
|
||||
function greet(name: string, age?: number): string {
|
||||
return age ? `Hello ${name}, you are ${age}` : `Hello ${name}`;
|
||||
}
|
||||
|
||||
// Default parameters
|
||||
function multiply(a: number, b: number = 1): number {
|
||||
return a * b;
|
||||
}
|
||||
|
||||
// Rest parameters
|
||||
function sum(...numbers: number[]): number {
|
||||
return numbers.reduce((total, num) => total + num, 0);
|
||||
}
|
||||
|
||||
// Function overloads
|
||||
function process(input: string): string;
|
||||
function process(input: number): number;
|
||||
function process(input: string | number): string | number {
|
||||
if (typeof input === 'string') {
|
||||
return input.toUpperCase();
|
||||
}
|
||||
return input * 2;
|
||||
}
|
||||
|
||||
// Generic functions
|
||||
function identity<T>(arg: T): T {
|
||||
return arg;
|
||||
}
|
||||
|
||||
let result = identity<string>("hello"); // Type is string
|
||||
let result2 = identity(42); // Type inferred as number
|
||||
```
|
||||
|
||||
### Function call
|
||||
|
||||
```typescript
|
||||
functionName(argument1, argument2);
|
||||
|
||||
// With optional parameters
|
||||
greet("John"); // "Hello John"
|
||||
greet("John", 25); // "Hello John, you are 25"
|
||||
|
||||
// With rest parameters
|
||||
sum(1, 2, 3, 4); // 10
|
||||
|
||||
// Generic function call
|
||||
identity<string>("hello");
|
||||
identity(42); // Type inferred
|
||||
```
|
||||
|
||||
### Classes
|
||||
|
||||
```typescript
|
||||
class ClassName {
|
||||
// Properties
|
||||
public publicProperty: type;
|
||||
private privateProperty: type;
|
||||
protected protectedProperty: type;
|
||||
readonly readonlyProperty: type;
|
||||
static staticProperty: type;
|
||||
|
||||
// Constructor
|
||||
constructor(param: type) {
|
||||
this.publicProperty = param;
|
||||
}
|
||||
|
||||
// Methods
|
||||
public method(): returnType {
|
||||
return value;
|
||||
}
|
||||
|
||||
// Getters and setters
|
||||
get property(): type {
|
||||
return this.privateProperty;
|
||||
}
|
||||
|
||||
set property(value: type) {
|
||||
this.privateProperty = value;
|
||||
}
|
||||
|
||||
// Static method
|
||||
static staticMethod(): returnType {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
// Inheritance
|
||||
class ChildClass extends ParentClass {
|
||||
constructor(param: type) {
|
||||
super(param); // Call parent constructor
|
||||
}
|
||||
|
||||
// Override method
|
||||
method(): returnType {
|
||||
return super.method(); // Call parent method
|
||||
}
|
||||
}
|
||||
|
||||
// Abstract class
|
||||
abstract class AbstractClass {
|
||||
abstract abstractMethod(): void;
|
||||
|
||||
concreteMethod(): void {
|
||||
console.log("This is implemented");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Key TypeScript Features
|
||||
|
||||
* **Static Typing**: Types are checked at compile-time
|
||||
* **Type Inference**: TypeScript can often infer types automatically
|
||||
* **Optional Typing**: You can gradually add types to existing JavaScript
|
||||
* **Generics**: Create reusable components that work with multiple types
|
||||
* **Interfaces**: Define contracts for objects and classes
|
||||
* **Enums**: Create named constants
|
||||
* **Union Types**: Variables can be one of several types
|
||||
* **Intersection Types**: Combine multiple types
|
||||
* **Type Guards**: Runtime type checking
|
||||
* **Decorators**: Add metadata to classes and methods
|
||||
|
||||
### Compilation
|
||||
|
||||
* TypeScript code must be compiled to JavaScript before execution
|
||||
* The TypeScript compiler (`tsc`) performs type checking and transpilation
|
||||
* Configuration is managed through `tsconfig.json`
|
||||
* TypeScript can target different JavaScript versions (ES5, ES6, etc.)
|
||||
* Source maps can be generated for debugging compiled code
|
||||
|
||||
#### Sample TypeScript Code
|
||||
|
||||
**hello.ts**
|
||||
```typescript
|
||||
// TypeScript source code
|
||||
interface User {
|
||||
name: string;
|
||||
age: number;
|
||||
isActive?: boolean;
|
||||
}
|
||||
|
||||
class UserManager {
|
||||
private users: User[] = [];
|
||||
|
||||
addUser(user: User): void {
|
||||
this.users.push(user);
|
||||
console.log(`Added user: ${user.name}`);
|
||||
}
|
||||
|
||||
getActiveUsers(): User[] {
|
||||
return this.users.filter(user => user.isActive ?? true);
|
||||
}
|
||||
|
||||
getUserCount(): number {
|
||||
return this.users.length;
|
||||
}
|
||||
}
|
||||
|
||||
// Generic function
|
||||
function processData<T>(data: T[], processor: (item: T) => T): T[] {
|
||||
return data.map(processor);
|
||||
}
|
||||
|
||||
// Usage
|
||||
const userManager = new UserManager();
|
||||
|
||||
const newUser: User = {
|
||||
name: "John Doe",
|
||||
age: 30,
|
||||
isActive: true
|
||||
};
|
||||
|
||||
userManager.addUser(newUser);
|
||||
|
||||
// Arrow functions with types
|
||||
const formatUser = (user: User): string =>
|
||||
`${user.name} (${user.age} years old)`;
|
||||
|
||||
// Union types and type guards
|
||||
function displayInfo(value: string | number | boolean): string {
|
||||
if (typeof value === "string") {
|
||||
return `Text: ${value.toUpperCase()}`;
|
||||
} else if (typeof value === "number") {
|
||||
return `Number: ${value.toFixed(2)}`;
|
||||
} else {
|
||||
return `Boolean: ${value ? "Yes" : "No"}`;
|
||||
}
|
||||
}
|
||||
|
||||
console.log(displayInfo("hello"));
|
||||
console.log(displayInfo(42.567));
|
||||
console.log(displayInfo(true));
|
||||
```
|
||||
|
||||
#### Compilation Commands
|
||||
|
||||
```bash
|
||||
# Compile single file
|
||||
tsc hello.ts
|
||||
|
||||
# Compile with specific target
|
||||
tsc hello.ts --target ES2020
|
||||
|
||||
# Compile with source maps
|
||||
tsc hello.ts --sourceMap
|
||||
|
||||
# Watch mode (recompile on changes)
|
||||
tsc hello.ts --watch
|
||||
|
||||
# Compile all files in project
|
||||
tsc
|
||||
|
||||
# Check for errors without generating files
|
||||
tsc --noEmit
|
||||
|
||||
# Compile with strict mode
|
||||
tsc hello.ts --strict
|
||||
```
|
||||
|
||||
#### Compiled JavaScript Output
|
||||
|
||||
**hello.js** (compiled from above TypeScript)
|
||||
```javascript
|
||||
"use strict";
|
||||
// JavaScript output (target ES2017)
|
||||
class UserManager {
|
||||
constructor() {
|
||||
this.users = [];
|
||||
}
|
||||
addUser(user) {
|
||||
this.users.push(user);
|
||||
console.log(`Added user: ${user.name}`);
|
||||
}
|
||||
getActiveUsers() {
|
||||
return this.users.filter(user => user.isActive ?? true);
|
||||
}
|
||||
getUserCount() {
|
||||
return this.users.length;
|
||||
}
|
||||
}
|
||||
// Generic function (types removed)
|
||||
function processData(data, processor) {
|
||||
return data.map(processor);
|
||||
}
|
||||
// Usage
|
||||
const userManager = new UserManager();
|
||||
const newUser = {
|
||||
name: "John Doe",
|
||||
age: 30,
|
||||
isActive: true
|
||||
};
|
||||
userManager.addUser(newUser);
|
||||
// Arrow functions
|
||||
const formatUser = (user) => `${user.name} (${user.age} years old)`;
|
||||
// Type guards remain as runtime checks
|
||||
function displayInfo(value) {
|
||||
if (typeof value === "string") {
|
||||
return `Text: ${value.toUpperCase()}`;
|
||||
}
|
||||
else if (typeof value === "number") {
|
||||
return `Number: ${value.toFixed(2)}`;
|
||||
}
|
||||
else {
|
||||
return `Boolean: ${value ? "Yes" : "No"}`;
|
||||
}
|
||||
}
|
||||
console.log(displayInfo("hello"));
|
||||
console.log(displayInfo(42.567));
|
||||
console.log(displayInfo(true));
|
||||
```
|
||||
|
||||
#### tsconfig.json Configuration
|
||||
|
||||
```json
|
||||
{
|
||||
"compilerOptions": {
|
||||
// Basic Options
|
||||
"target": "ES2020", // Target JavaScript version
|
||||
"module": "commonjs", // Module system
|
||||
"lib": ["ES2020", "DOM"], // Include library files
|
||||
"outDir": "./dist", // Output directory
|
||||
"rootDir": "./src", // Input directory
|
||||
"strict": true, // Enable strict type checking
|
||||
|
||||
// Additional Checks
|
||||
"noUnusedLocals": true, // Error on unused variables
|
||||
"noUnusedParameters": true, // Error on unused parameters
|
||||
"noImplicitReturns": true, // Error on missing return statements
|
||||
"noFallthroughCasesInSwitch": true, // Error on fallthrough cases
|
||||
|
||||
// Module Resolution
|
||||
"moduleResolution": "node", // Module resolution strategy
|
||||
"baseUrl": "./", // Base directory
|
||||
"paths": { // Path mapping
|
||||
"@/*": ["src/*"],
|
||||
"@utils/*": ["src/utils/*"]
|
||||
},
|
||||
|
||||
// Source Maps & Debugging
|
||||
"sourceMap": true, // Generate source maps
|
||||
"inlineSourceMap": false, // Don't inline source maps
|
||||
"declaration": true, // Generate .d.ts files
|
||||
"declarationMap": true, // Generate .d.ts.map files
|
||||
|
||||
// Experimental
|
||||
"experimentalDecorators": true, // Enable decorators
|
||||
"emitDecoratorMetadata": true, // Emit decorator metadata
|
||||
|
||||
// JavaScript Support
|
||||
"allowJs": true, // Allow JavaScript files
|
||||
"checkJs": false, // Type check JavaScript files
|
||||
|
||||
// Other Options
|
||||
"esModuleInterop": true, // CommonJS/ES6 interop
|
||||
"skipLibCheck": true, // Skip lib.d.ts type checking
|
||||
"forceConsistentCasingInFileNames": true, // Consistent file names
|
||||
"removeComments": true, // Remove comments from output
|
||||
"noEmitOnError": true // Don't emit if there are errors
|
||||
},
|
||||
"include": [
|
||||
"src/**/*", // Include all files in src
|
||||
"tests/**/*" // Include test files
|
||||
],
|
||||
"exclude": [
|
||||
"node_modules", // Exclude node_modules
|
||||
"dist", // Exclude output directory
|
||||
"**/*.test.ts", // Exclude test files from compilation
|
||||
"**/*.spec.ts"
|
||||
],
|
||||
"files": [
|
||||
// Explicitly include specific files (optional)
|
||||
"src/main.ts"
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
#### Package.json Scripts
|
||||
|
||||
```json
|
||||
{
|
||||
"name": "typescript-project",
|
||||
"version": "1.0.0",
|
||||
"scripts": {
|
||||
"build": "tsc",
|
||||
"start": "node dist/main.js",
|
||||
"dev": "ts-node src/main.ts",
|
||||
"watch": "tsc --watch",
|
||||
"clean": "rm -rf dist",
|
||||
"type-check": "tsc --noEmit"
|
||||
},
|
||||
"devDependencies": {
|
||||
"typescript": "^4.9.0",
|
||||
"ts-node": "^10.9.0",
|
||||
"@types/node": "^18.0.0"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Compilation Examples with Different Targets
|
||||
|
||||
**Original TypeScript:**
|
||||
```typescript
|
||||
const greet = (name: string = "World"): string => `Hello, ${name}!`;
|
||||
const user = { name: "Alice", age: 30 };
|
||||
const { name, age } = user;
|
||||
```
|
||||
|
||||
**Compiled to ES5:**
|
||||
```javascript
|
||||
var greet = function (name) {
|
||||
if (name === void 0) { name = "World"; }
|
||||
return "Hello, " + name + "!";
|
||||
};
|
||||
var user = { name: "Alice", age: 30 };
|
||||
var name = user.name, age = user.age;
|
||||
```
|
||||
|
||||
**Compiled to ES2020:**
|
||||
```javascript
|
||||
const greet = (name = "World") => `Hello, ${name}!`;
|
||||
const user = { name: "Alice", age: 30 };
|
||||
const { name, age } = user;
|
||||
```
|
||||
|
||||
#### Error Examples
|
||||
|
||||
**TypeScript with errors:**
|
||||
```typescript
|
||||
// Type errors that prevent compilation
|
||||
let message: string = 42; // Error: Type 'number' is not assignable to type 'string'
|
||||
let numbers: number[] = ["a", "b"]; // Error: Type 'string' is not assignable to type 'number'
|
||||
|
||||
function add(a: number, b: number): number {
|
||||
return a + b;
|
||||
}
|
||||
|
||||
add("hello", "world"); // Error: Argument of type 'string' is not assignable to parameter of type 'number'
|
||||
```
|
||||
|
||||
**Compiler output:**
|
||||
```bash
|
||||
$ tsc error-example.ts
|
||||
error-example.ts(2,5): error TS2322: Type 'number' is not assignable to type 'string'.
|
||||
error-example.ts(3,5): error TS2322: Type 'string[]' is not assignable to type 'number[]'.
|
||||
error-example.ts(8,5): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
|
||||
```
|
||||
@@ -21,7 +21,6 @@ cat /proc/<process_id>/maps # Show the current virtual memory usage of a Linux
|
||||
ip r # Display ip of the server
|
||||
|
||||
lsof -i :9000 # List process running on port 9000
|
||||
kill -9 $(lsof -t -i:PORT) # Kill the process running on whichever port specified
|
||||
|
||||
journalctl -u minio.service -n 100 --no-pager # List last 100 logs for specific service
|
||||
|
||||
|
||||
Reference in New Issue
Block a user