Merge 97d77ddfae into 8557d4f3d8

adding the at() method

README.md

@@ -124,6 +124,7 @@ Feel free to take a look. You might learn new things. They have been designed to
 - [Nginx](tools/nginx.sh)
 - [PM2](tools/pm2.sh)
 - [Ubuntu](tools/ubuntu.sh)
+- [Firebase CLI](tools/firebase_cli.md)
   </details>
 
 ## 🙌🏼 How to Contribute?

backend/laravel.php

@@ -8,6 +8,8 @@
 // MAIN.
 
 php artisan clear-compiled       // Remove the compiled class file
+php artisan db                   // Start a new database CLI session
+php artisan docs                 // Access the Laravel documentation
 php artisan down                 // Put the application into maintenance mode
 php artisan dump-server          // Start the dump server to collect dump information.
 php artisan env                  // Display the current framework environment
@@ -43,6 +45,9 @@ php artisan config:clear         // Remove the configuration cache file
 // DB
 
 php artisan db:seed              // Seed the database with records
+php artisan db:show              // Display information about the given database
+php artisan db:table             // Display information about the given database table
+php artisan db:wipe              // Drop all tables, views, and types
 
 // EVENT
 
@@ -54,9 +59,10 @@ php artisan key:generate         // Set the application key
 
 // MAKE
 
-php artisan make:auth            // Scaffold basic login and registration views and routes
+php artisan make:cast            // Create a new custom Eloquent cast class
 php artisan make:channel         // Create a new channel class
 php artisan make:command         // Create a new Artisan command
+php artisan make:component       // Create a new view component class
 php artisan make:controller      // Create a new controller class
 php artisan make:event           // Create a new event class
 php artisan make:exception       // Create a new custom exception class
@@ -74,6 +80,7 @@ php artisan make:provider        // Create a new service provider class
 php artisan make:request         // Create a new form request class
 php artisan make:resource        // Create a new resource
 php artisan make:rule            // Create a new validation rule
+php artisan make:scope           // Create a new scope class
 php artisan make:seeder          // Create a new seeder class
 php artisan make:test            // Create a new test class
 
@@ -86,6 +93,10 @@ php artisan migrate:reset        // Rollback all database migrations
 php artisan migrate:rollback     // Rollback the last database migration
 php artisan migrate:status       // Show the status of each migration
 
+// MODEL
+php artisan model:prune          // Prune models that are no longer needed
+php artisan model:show           // Show information about an Eloquent model
+
 // NOTIFICATIONS
 
 php artisan notifications:table  // Create a migration for the notifications table
@@ -100,13 +111,19 @@ php artisan package:discover     // Rebuild the cached package manifest
 
 // QUEUE
 
+php artisan queue:batches-table  // Create a migration for the batches database table
+php artisan queue:clear          // Delete all of the jobs from the specified queue
 php artisan queue:failed         // List all of the failed queue jobs
 php artisan queue:failed-table   // Create a migration for the failed queue jobs database table
 php artisan queue:flush          // Flush all of the failed queue jobs
 php artisan queue:forget         // Delete a failed queue job
 php artisan queue:listen         // Listen to a given queue
+php artisan queue:monitor        // Monitor the size of the specified queues
+php artisan queue:prune-batches  // Prune stale entries from the batches database
+php artisan queue:prune-failed   // Prune stale entries from the failed jobs table
 php artisan queue:restart        // Restart queue worker daemons after their current job
 php artisan queue:retry          // Retry a failed queue job
+php artisan queue:retry-batch    // Retry the failed jobs for a batch
 php artisan queue:table          // Create a migration for the queue jobs database table
 php artisan queue:work           // Start processing jobs on the queue as a daemon
 
@@ -116,9 +133,26 @@ php artisan route:cache          // Create a route cache file for faster route r
 php artisan route:clear          // Remove the route cache file
 php artisan route:list           // List all registered routes
 
+// SAIL
+
+php artisan sail:install         // Install Laravel Sail's default Docker Compose file
+php artisan sail:publish         // Publish the Laravel Sail Docker files
+
+// SANCTUM
+
+php artisan sanctum:prune-expired // Prune tokens expired for more than specified number of hours.
+
 // SCHEDULE
 
+php artisan schedule:clear-cache  // Delete the cached mutex files created by scheduler
+php artisan schedule:list         // List the scheduled commands
 php artisan schedule:run          // Run the scheduled commands
+php artisan schedule:test         // Run a scheduled command
+php artisan schedule:work         // Start the schedule worker
+
+// SCHEMA
+
+php artisan schema:dump           // Dump the given database schema
 
 // SESSION
 
@@ -128,6 +162,10 @@ php artisan session:table        // Create a migration for the session database
 
 php artisan storage:link         // Create a symbolic link from "public/storage" to "storage/app/public"
 
+// STUD
+
+php artisan stub:publish         // Publish all stubs that are available for customization
+
 // VENDOR
 
 php artisan vendor:publish       // Publish any publishable assets from vendor packages

languages/javascript.js

@@ -72,6 +72,7 @@ array.splice(start, deleteCount, item1, item2, ...)  // Adds and/or removes elem
 arr.unshift([element1[, ...[, elementN]]])           // Adds one or more elements to the front of an array and returns the new length of the array.
 
 // Instance: accessor methods
+arr.at(index)                                        // Returns the element at the specified index in the array.
 arr.concat(value1[, value2[, ...[, valueN]]])        // Returns a new array comprised of this array joined with other array(s) and/or value(s).
 arr.includes(searchElement, fromIndex)               // Determines whether an array contains a certain element, returning true or false as appropriate.
 arr.indexOf(searchElement[, fromIndex])              // Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found.

languages/python.md

@@ -2,13 +2,13 @@
 
 * Python is an interpreted, high-level and general-purpose, dynamically typed programming language
 
-* It is also Object oriented, modular oriented and a scripting language.
+* It is seen as an object-oriented, modular scripting language.
 
-* In Python, everything is considered as an Object.
+* In Python, everything is considered as an object.
 
 * A python file has an extension of .py
 
-* Python follows Indentation to separate code blocks instead of flower brackets({}).
+* Python follows indentation to separate code blocks instead of using flower/curly brackets ({}).
 
 * We can run a python file by the following command in cmd(Windows) or shell(mac/linux).
 
@@ -138,11 +138,9 @@
 thislist = ["apple", "banana", "cherry"] 
 ```
 
-- List items are ordered, changeable, and allow duplicate values.
+- List items are ordered, changeable / mutable, and allow duplicate values. We can change, add, and remove items in a list after it has been created.
 
-- List items are indexed, the first item has index `[0]`, the second item has index `[1]` etc.
-
-- The list is changeable, meaning that we can change, add, and remove items in a list after it has been created.
+- List items are zero-indexed. The first item has index `[0]`, the second item has index `[1]` etc.
 
 - To determine how many items a list has, use the `len()` function.
 
@@ -150,11 +148,12 @@ thislist = ["apple", "banana", "cherry"]
 ```python
 list1 = ["abc", 34, True, 40, "male"]
 ```
-- It is also possible to use the list() constructor when creating a new list
+- Lists can either be created as above or using the list() constructor as follows:
 ```python
 thislist = list(("apple", "banana", "cherry"))  # note the double round-brackets
 ```
-- pop() function removes the last value in the given list by default.
+
+- pop() function removes and returns the last value in the given list by default. Should a different index be added in the brackets, the element with that index will be removed and returned.
 
   ```python
   thislist = ["apple", "banana", "cherry"] 
@@ -174,11 +173,11 @@ thislist = list(("apple", "banana", "cherry"))  # note the double round-brackets
 ```python
 thistuple = ("apple", "banana", "cherry")
 ```
-- Tuple items are ordered, unchangeable, and allow duplicate values.
+
+- Tuple items are ordered, unchangeable / immutable, and allow duplicate values. We cannot change, add or remove items after the tuple has been created.
 - Tuple items are indexed, the first item has index `[0]`, the second item has index `[1]` etc.
 - When we say that tuples are ordered, it means that the items have a defined order, and that order will not change.
 
-- Tuples are unchangeable, meaning that we cannot change, add or remove items after the tuple has been created.
 - Since tuple are indexed, tuples can have items with the same value:
 - Tuples allow duplicate values:
 ```python
@@ -187,18 +186,18 @@ thistuple = ("apple", "banana", "cherry", "apple", "cherry")
 - To determine how many items a tuple has, use the  `len()`function:
 ```python
 thistuple = ("apple", "banana", "cherry")
-print(len(thistuple))
+print(len(thistuple)) # 3
 ```
-- To create a tuple with only one item, you have to add a comma after the item, otherwise Python will not recognize it as a tuple.
+- To create a tuple with only one item, you have to *add a comma after the item*, otherwise Python will not recognize it as a tuple.
 ```python
 thistuple = ("apple",)
-print(type(thistuple))
+print(type(thistuple)) # tuple
 
 # NOT a tuple
 thistuple = ("apple")
-print(type(thistuple))
+print(type(thistuple)) # string
 ```
-- It is also possible to use the tuple() constructor to make a tuple.
+- It is also possible to use the tuple() constructor to make a tuple:
 ```python
 
 thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets
@@ -206,24 +205,21 @@ print(thistuple)
 ```
 
 ### Set
-- Set is a collection which is unordered and unindexed. No duplicate members.
-- A set is a collection which is both unordered and unindexed.
+- Set is a collection which is unordered and unindexed. There can be no duplicate members.
+- Since sets are unordered and unindexed, the items in a set do not have a defined order. Set items can appear in a different order every time you use them, and cannot be referred to by index or key.
+- Duplicate values will be ignored.
+
 ```python
 thisset = {"apple", "banana", "cherry"}
 ```
-- Set items are unordered, unchangeable, and do not allow duplicate values.
-- Unordered means that the items in a set do not have a defined order.
 
-- Set items can appear in a different order every time you use them, and cannot be referred to by index or key.
-
-- Sets are unchangeable, meaning that we cannot change the items after the set has been created.
-- Duplicate values will be ignored.
 - To determine how many items a set has, use the `len()` method.
 ```python
 thisset = {"apple", "banana", "cherry"}
 
-print(len(thisset))
+print(len(thisset)) # 3
 ```
+
 - Set items can be of any data type:
 ```python
 set1 = {"apple", "banana", "cherry"}
@@ -231,25 +227,29 @@ set2 = {1, 5, 7, 9, 3}
 set3 = {True, False, False}
 set4 = {"abc", 34, True, 40, "male"}
 ```
-- It is also possible to use the `set()` constructor to make a set.
+
+- It is also possible to use the `set()` constructor to make a set:
 ```python
 thisset = set(("apple", "banana", "cherry")) # note the double round-brackets
 ```
+
 - frozenset()  is just an immutable version of Set. While elements of a set can be modified at any time, elements of the frozen set remain the same after creation.
 
 ```python
 set1 = {"apple", "banana", "cherry"}
 frzset=frozenset(set1)
-print(frzset)
+print(frzset) # {"apple", "banana", "cherry"}
 ```
 
 
 
 ### Dictionary
 
-- Dictionary is a collection which is unordered and changeable. No duplicate members.
+- Dictionary is a collection which is unordered and changeable. There can be no duplicate members.
 - Dictionaries are used to store data values in key:value pairs.
+- Dictionaries cannot have two items with the same key.
 - Dictionaries are written with curly brackets, and have keys and values:
+
 ```python
 thisdict = {
   "brand": "Ford",
@@ -257,6 +257,7 @@ thisdict = {
   "year": 1964
 }
 ```
+
 - Dictionary items are presented in key:value pairs, and can be referred to by using the key name.
 ```python
 thisdict = {
@@ -264,15 +265,17 @@ thisdict = {
   "model": "Mustang",
   "year": 1964
 }
-print(thisdict["brand"])
+print(thisdict["brand"]) # Ford
 ```
-- Dictionaries are changeable, meaning that we can change, add or remove items after the dictionary has been created.
-- Dictionaries cannot have two items with the same key.
+
+- Dictionaries are changeable / mutable, meaning that we can change, add or remove items after the dictionary has been created.
 - Duplicate values will overwrite existing values.
 - To determine how many items a dictionary has, use the `len()` function.
+- 
 ```python
-print(len(thisdict))
+print(len(thisdict)) # 3
 ```
+
 - The values in dictionary items can be of any data type
 ```python
 thisdict = {
@@ -304,12 +307,13 @@ thisdict = {
 
 ```python
     if condition:
-        pass
+        pass # Code to execute if condition is true.
     elif condition2:
-        pass
+        pass # Code to execute if condition2 is true.
     else:
-        pass
+        pass # Code to execute if neither condition nor condition2 is true.
 ```
+
 ### Loops
 
  Python has two primitive loop commands:
@@ -318,18 +322,58 @@ thisdict = {
 
 #### While loop
 - With the `while` loop we can execute a set of statements as long as a condition is true.
+
 - Example: Print i as long as i is less than 6
 ```python
 i = 1
 while i < 6:
   print(i)
   i += 1
-```
-- The while loop requires relevant variables to be ready, in this example we need to define an indexing variable, i, which we set to 1.
-- With the `break` statement we can stop the loop even if the while condition is true
-- With the continue statement we can stop the current iteration, and continue with the next.
   
-- With the else statement we can run a block of code once when the condition no longer is true.
+# Output: 1, 2, 3, 4, 5
+```
+
+- The while loop requires relevant variables to be ready. In this example we need to define an indexing variable, i, which we set to 1. This has to be done before starting with the loop.
+
+- With the `break` statement we can stop the loop even if the while condition is true.
+
+- Example: Print i as long as i is less than 6
+```python
+i = 1
+while True:
+    if i < 6:
+        print(i)
+        i += 1
+    else:
+        break
+# Output: 1, 2, 3, 4, 5
+```
+
+- With the `continue` statement we can stop the current iteration, and continue with the next.
+
+- Example: Print i as long as it is less than 6 and not equal to 3.
+```python
+i = 0
+while i < 6:
+  i += 1
+  if i == 3:
+    continue
+  else:
+    print(i)
+# Output: 1, 2, 4, 5
+```
+
+- With the `else` statement we can run a block of code once when the condition no longer is true.
+```python
+i = 1
+while i < 6:
+  print(i)
+  i += 1
+else:
+  print("The loop is finished")
+  
+# Output: 1, 2, 3, 4, 5, The loop is finished
+```
 
 #### For loop
 - A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).
@@ -340,16 +384,22 @@ while i < 6:
 ```python
 fruits = ["apple", "banana", "cherry"]
 for x in fruits:
-  print(x)
+  print(x) # apple banana cherry
 ```
 - The for loop does not require an indexing variable to set beforehand.
-- To loop through a set of code a specified number of times, we can use the range() function.
-- The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number.
-- The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parameter: range(2, 30, 3).
-- The else keyword in a for loop specifies a block of code to be executed when the loop is finished.
-A nested loop is a loop inside a loop.
 
-- The "inner loop" will be executed one time for each iteration of the "outer loop":
+- To loop through a set of code a specified number of times, we can use the range() function. 
+- The range function returns a list of integers starting at zero or the starting value up to but not including the ending value, in increments of 1 unless otherwise defined:
+
+```python
+range(4) # [0, 1, 2, 3]
+range(2, 4) # [2, 3]
+range(1, 10, 2) # [1, 3, 5, 7, 9]
+```
+
+- The else keyword in a for loop specifies a block of code to be executed when the loop is finished.
+
+- A nested loop is a loop inside a loop. The "inner loop" will be executed one time for each iteration of the "outer loop":
 
 ```python
 adj = ["red", "big", "tasty"]
@@ -359,6 +409,7 @@ for x in adj:
   for y in fruits:
     print(x, y)
 ```
+
 - for loops cannot be empty, but if you for some reason have a for loop with no content, put in the pass statement to avoid getting an error.
 
 ```python
@@ -377,6 +428,7 @@ def function_name():
 function_name()
 ```
 
+* A function must either return a value or have some content.
 * We need not to specify the return type of the function.
 * Functions by default return `None` 
 * We can return any datatype.

tools/firebase_cli.md

@@ -0,0 +1,140 @@
+# Firebase CLI Guide
+
+Firebase CLI (Command Line Interface) is a powerful tool that allows developers to interact with Firebase services and manage their Firebase projects directly from the command line. It provides a convenient and efficient way to deploy projects, manage databases, configure authentication, and more, streamlining the development and deployment processes.
+
+## Installation
+
+To use the Firebase CLI, you need to have Node.js and npm (Node Package Manager) installed on your system. Follow the steps below to install the Firebase CLI:
+
+1. Install Node.js and npm by downloading the installer from the [official Node.js website](https://nodejs.org/en/download/) and following the installation instructions for your operating system.
+
+2. Once Node.js and npm are installed, open your terminal or command prompt and run the following command to install the Firebase CLI globally:
+
+   ```
+   npm install -g firebase-tools
+   ```
+
+   This command will download and install the Firebase CLI package from the npm registry.
+
+3. After the installation is complete, you can verify that the Firebase CLI is installed correctly by running the following command:
+
+   ```
+   firebase --version
+   ```
+
+   If the installation was successful, you will see the version number of the Firebase CLI printed in the terminal.
+
+Congratulations! You have successfully installed the Firebase CLI.
+
+## Usage
+
+The Firebase CLI allows you to interact with Firebase services and manage your Firebase projects from the command line. Here are some common tasks you can perform using the Firebase CLI:
+
+- Initialize a new Firebase project in your current directory.
+- Deploy your Firebase project to Firebase hosting.
+- Manage Firebase Authentication, Realtime Database, Cloud Firestore, Cloud Functions, and other Firebase services.
+- Configure Firebase project settings.
+- Interact with Firebase emulators for local development and testing.
+
+To use the Firebase CLI, open your terminal or command prompt and run the `firebase` command followed by the desired command and options.
+
+Here's an example of the basic usage:
+
+```
+firebase <command> [options]
+```
+
+Replace `<command>` with the specific Firebase command you want to execute, and `[options]` with any additional options or flags required for that command.
+
+For more detailed usage information, you can run the following command:
+
+```
+firebase help
+```
+
+This command will display the available Firebase commands and provide detailed information about each command.
+
+## Commands
+
+Here are the commonly used Firebase CLI commands along with a brief explanation, syntax, and an example for each command:
+
+- `firebase init`: Initializes a new Firebase project in the current directory.
+
+  - Syntax: `firebase init [options]`
+  - Example: `firebase init hosting` initializes Firebase Hosting for the current project.
+
+- `firebase deploy`: Deploys your Firebase project to Firebase hosting or other Firebase services.
+
+  - Syntax: `firebase deploy [options]`
+  - Example: `firebase deploy --only hosting` deploys only the Firebase Hosting content.
+
+- `firebase serve`: Starts local development servers and Firebase emulators.
+
+  - Syntax: `firebase serve [options]`
+  - Example: `firebase serve --only functions,hosting` starts the Firebase emulators for functions and hosting.
+
+- `firebase login`: Authenticates the Firebase CLI with your Firebase account.
+
+  - Syntax: `firebase login [options]`
+  - Example: `firebase login --no-localhost` initiates an interactive login session without connecting to localhost.
+
+- `firebase logout`: Logs out from the Firebase CLI.
+
+  - Syntax: `firebase logout [options]`
+  - Example: `firebase logout` logs out the currently authenticated user.
+
+- `firebase use`: Sets the active Firebase project for the current directory.
+
+  - Syntax: `firebase use <project_id> [options]`
+  - Example: `firebase use my-project` sets "my-project" as the active Firebase project.
+
+- `firebase functions`: Interacts with Firebase Cloud Functions.
+
+  - Syntax: `firebase functions:command [options]`
+  - Example: `firebase functions:delete [function_name]` deletes all functions that match the specified name in all regions.
+
+- `firebase database`: Interacts with Firebase Realtime Database.
+
+  - Syntax: `firebase database:command [options]`
+  - Example: `firebase database:get /users` retrieves data from the Firebase Realtime Database.
+
+- `firebase firestore`: Interacts with Firebase Cloud Firestore.
+
+  - Syntax: `firebase firestore:command [options]`
+  - Example: `firebase firestore:delete collection/document` deletes a document from the Firestore database.
+
+- `firebase auth`: Interacts with Firebase Authentication.
+
+  - Syntax: `firebase auth:command [options]`
+  - Example: `firebase auth:export users.csv` exports user data to a CSV file.
+
+- `firebase hosting`: Interacts with Firebase Hosting.
+
+  - Syntax: `firebase hosting:command [options]`
+  - Example: `firebase hosting:disable` disables Firebase Hosting for the current project.
+
+- `firebase remoteconfig`: Interacts with Firebase Remote Config.
+
+  - Syntax: `firebase remoteconfig:command [options]`
+  - Example: `firebase remoteconfig:get template` retrieves the Remote Config template.
+
+- `firebase ext`: Interacts with Firebase Extensions.
+
+  - Syntax: `firebase ext:command [options]`
+  - Example: `firebase ext:install firebase/delete-user-data` installs the Firebase Extension named "firebase/delete-user-data".
+
+- `firebase appdistribution`: Interacts with Firebase App Distribution.
+
+  - Syntax: `firebase appdistribution:command [options]`
+  - Example: `firebase appdistribution:testers:add` Adds testers to the project.
+
+- `firebase use --add`: Adds an existing Firebase project to the current directory
+
+  - Syntax: `firebase use --add`
+  - Example: `firebase use --add` interactively adds an existing Firebase project.
+
+- `firebase projects:create`: Creates a new Firebase project.
+  - Syntax: `firebase projects:create [options]`
+  - Example: `firebase projects:create --display-name "My Project"` creates a new Firebase project with the given display name.
+
+These are just a few examples of the available commands. You can explore more commands and their options by running `firebase help` or visiting the [official Firebase CLI documentation](https://firebase.google.com/docs/cli).