mirror of
https://github.com/m-lamonaca/dev-notes.git
synced 2025-04-05 18:36:41 +00:00
show line numbers in conde snippets
This commit is contained in:
parent
cd1df0e376
commit
255a68d673
82 changed files with 1249 additions and 1251 deletions
|
|
@ -63,7 +63,7 @@ VMs incur a lot of overhead beyond what is being consumed by your application lo
|
|||
|
||||
### [`docker run`](https://docs.docker.com/engine/reference/commandline/run/)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
docker run <image> # run selected app inside a container (downloaded from Docker Hub if missing from image)
|
||||
docker run -d|--detach <image> # run docker container in the background (does not occupy stdout & stderr)
|
||||
docker run -i|--interactive <image> # run docker container in interactive mode (read stdin)
|
||||
|
|
@ -80,7 +80,7 @@ docker run --name=<container_name> <image> # set container name
|
|||
|
||||
### [`docker container`](https://docs.docker.com/engine/reference/commandline/container/)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
docker container ls # list of currently running containers
|
||||
docker container ls -a|--all # list of all containers, running and exited
|
||||
docker container rm <container> # remove one or more containers
|
||||
|
|
@ -97,7 +97,7 @@ docker container exec <container> <command> # exec a command inside a container
|
|||
|
||||
### [`docker image`](https://docs.docker.com/engine/reference/commandline/image/)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
docker image ls # list of existing images
|
||||
docker image rm <image> # remove one or more images
|
||||
docker image prune <image> # remove unused images
|
||||
|
|
@ -106,20 +106,20 @@ docker image pull <image> # download an image w/o starting the container
|
|||
|
||||
### [`docker build`](https://docs.docker.com/engine/reference/commandline/build/)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
docker build -t <tag> -f <dockerfile> <context> # build image with specific tag (usually user/app:version)
|
||||
docker build -t <tag> -f <dockerfile> --build-arg ARG=value <context> # pass args to ARG steps
|
||||
```
|
||||
|
||||
### [`docker push`](https://docs.docker.com/engine/reference/commandline/push/)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
docker push <image> # publish image to registry (defaults to Docker Hub)
|
||||
```
|
||||
|
||||
## [Dockerfile](https://docs.docker.com/engine/reference/builder/)
|
||||
|
||||
```docker
|
||||
```docker linenums="1"
|
||||
# starting image or scratch
|
||||
FROM <base_image>:<tag>
|
||||
|
||||
|
|
@ -149,7 +149,7 @@ ENTRYPOINT <executable> <arg1> <arg2>
|
|||
|
||||
### `CMD` vs `ENTRYPOINT`
|
||||
|
||||
`CMD` is used to provide all the default scenarios which can be overridden. _Anything_ defined in CMD can be overridden by passing arguments in `docker run` command.
|
||||
`CMD` is used to provide all the default scenarios which can be overridden. *Anything* defined in CMD can be overridden by passing arguments in `docker run` command.
|
||||
|
||||
`ENTRYPOINT` is used to define a specific executable (and it's arguments) to be executed during container invocation which cannot be overridden.
|
||||
The user can however define arguments to be passed in the executable by adding them in the `docker run` command.
|
||||
|
|
@ -160,7 +160,7 @@ With multi-stage builds, it's possible to use multiple `FROM` statements in the
|
|||
|
||||
It's possible to selectively copy artifacts from one stage to another, leaving behind everything not wanted in the final image.
|
||||
|
||||
```docker
|
||||
```docker linenums="1"
|
||||
FROM <base_image>:<tag> AS <runtime_alias>
|
||||
RUN <command> # install external dependencies (apt get ...)
|
||||
|
||||
|
|
@ -186,7 +186,7 @@ COPY --from=<build_alias|stage_number> <src> <dir_in_container>
|
|||
CMD ["executable"] # run app
|
||||
```
|
||||
|
||||
```docker
|
||||
```docker linenums="1"
|
||||
FROM mcr.microsoft.com/dotnet/<runtime|aspnet>:<alpine_tag> AS runtime
|
||||
RUN <command> # install external dependencies (apt get ...)
|
||||
|
||||
|
|
@ -219,7 +219,7 @@ ENTRYPOINT ["dotnet", "<project>.dll"]
|
|||
|
||||
Starting container networks: `bridge` (default), `none`, `host`.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
docker run <image> --network=none/host # specify a non-default network to be used
|
||||
docker network ls # list all available networks
|
||||
```
|
||||
|
|
@ -233,7 +233,7 @@ None: Containers are not attached to a network and cannot access other container
|
|||
|
||||
## User-defined Networks
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
docker network create \
|
||||
--driver NETWORK_TYPE \
|
||||
--subnet GATEWAY_TP/SUBNET_MASK_SIZE
|
||||
|
|
@ -250,7 +250,7 @@ Docker has an internal DNS that allows finding other container by their name ins
|
|||
|
||||
## File System
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
/var/lib/docker
|
||||
|_<storage_driver>
|
||||
|_containers
|
||||
|
|
@ -270,7 +270,7 @@ To modify a file during while the container runs docker creates a local copy in
|
|||
**volume mounting**: create a volume under the docker installation folder (`/var/lib/docker/volumes/`).
|
||||
**bind mounting**: link docker to an exiting folder to be used as a volume.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
docker run -v <existing_dir>:<container_dir> <image>:<tag> # older command for bind mounting
|
||||
docker run --mount type=bind, source=:<existing_dir>, target=<container_dir> <image>:<tag> # modern command for bind mounting
|
||||
```
|
||||
|
|
@ -287,7 +287,7 @@ Using Compose is basically a three-step process:
|
|||
2. Define the services that make up your app in `docker-compose.yml` so they can be run together in an isolated environment.
|
||||
3. Run `docker-compose up` and Compose starts and runs the entire app.
|
||||
|
||||
```yaml
|
||||
```yaml linenums="1"
|
||||
version: 3.x
|
||||
services:
|
||||
<service_name>:
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ As pods successfully complete, the Job tracks the successful completions. When a
|
|||
|
||||
## Kubernetes Configuration
|
||||
|
||||
Each kubernetes configuration file is composed by 3 parts:
|
||||
Each kubernetes configuration file is composed by 3 parts:
|
||||
|
||||
- metadata
|
||||
- specification
|
||||
|
|
@ -110,7 +110,7 @@ Each kubernetes configuration file is composed by 3 parts:
|
|||
|
||||
### `kubectl get`
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
kubectl config get-contexts # list available contexts
|
||||
|
||||
kubectl get namespaces # list namespaces inside current context
|
||||
|
|
@ -121,11 +121,12 @@ kubectl get pod [-n|--namespace <namespace>] <pod> -o|--output jsonpath='{.spec.
|
|||
|
||||
### `kubectl exec`
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
kubectl exec [-i|--stdin] [-t|--tty] [-n|--namespace <namespace>] <pod> [-c|--container <container>] -- <command> # execute a command inside a container
|
||||
```
|
||||
|
||||
### `kubectl logs`
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
kubectl logs [-f|--follow] [-n|--namespace <namespace>] <pod> [-c|--container] # get pod/container logs
|
||||
```
|
||||
```
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ MongoDB automatically creates an `ObjectId()` if it's not provided.
|
|||
To create a database is sufficient to switch towards a non existing one with `use <database>` (implicit creation).
|
||||
The database is not actually created until a document is inserted.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
show dbs # list all databases
|
||||
use <database> # use a particular database
|
||||
show collections # list all collection for the current database
|
||||
|
|
@ -38,7 +38,7 @@ db.<collection>.insertOne({document}) # implicit collection creation
|
|||
|
||||
## Operators (MQL Syntax)
|
||||
|
||||
```json
|
||||
```json linenums="1"
|
||||
/* --- Update operators --- */
|
||||
{ "$inc": { "<key>": "<increment>", ... } } // Increment value
|
||||
{ "$set": { "<key>": "<value>", ... } } // Set value
|
||||
|
|
@ -79,7 +79,7 @@ db.<collection>.insertOne({document}) # implicit collection creation
|
|||
|
||||
> **Note**: `$<key>` is used to access the value of the field dynamically
|
||||
|
||||
```json
|
||||
```json linenums="1"
|
||||
{ "$expr": { "<expression>" } } // aggregation expression, variables, conditional expressions
|
||||
{ "$expr": { "$<comparison_operator>": [ "$<key>", "$<key>" ] } } // compare field values (operators use aggregation syntax)
|
||||
```
|
||||
|
|
@ -95,7 +95,7 @@ Insertion results:
|
|||
- error -> rollback
|
||||
- success -> entire documents gets saved
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
# explicit collection creation, all options are optional
|
||||
db.createCollection( <name>,
|
||||
{
|
||||
|
|
@ -128,7 +128,7 @@ db.<collection>.insertMany([ { document }, { document } ] , { "ordered": false }
|
|||
|
||||
### Querying
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.findOne() # find only one document
|
||||
db.<collection>.find(filter) # show selected documents
|
||||
db.<collection>.find().pretty() # show documents formatted
|
||||
|
|
@ -172,7 +172,7 @@ db.<collection>.find().hint( { $natural : -1 } ) # force the query to perform a
|
|||
|
||||
[Update Operators](https://docs.mongodb.com/manual/reference/operator/update/ "Update Operators Documentation")
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.replaceOne(filter, update, options)
|
||||
db.<collection>.updateOne(filter, update, {upsert: true}) # modify document if existing, insert otherwise
|
||||
|
||||
|
|
@ -181,7 +181,7 @@ db.<collection>.updateOne(filter, { "$push": { ... }, "$set": { ... }, { "$inc":
|
|||
|
||||
### Deletion
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.deleteOne(filter, options)
|
||||
db.<collection>.deleteMany(filter, options)
|
||||
|
||||
|
|
@ -199,7 +199,7 @@ Utility to import all docs into a specified collection.
|
|||
If the collection already exists `--drop` deletes it before reuploading it.
|
||||
**WARNING**: CSV separators must be commas (`,`)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
mongoimport <options> <connection-string> <file>
|
||||
|
||||
--uri=<connectionString>
|
||||
|
|
@ -218,7 +218,7 @@ mongoimport <options> <connection-string> <file>
|
|||
|
||||
Utility to export documents into a specified file.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
mongoexport --collection=<collection> <options> <connection-string>
|
||||
|
||||
--uri=<connectionString>
|
||||
|
|
@ -272,7 +272,7 @@ Indexes _slow down writing operations_ since the index must be updated at every
|
|||
|
||||
### Diagnosis and query planning
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.find({...}).explain() # explain won't accept other functions
|
||||
db.explain().<collection>.find({...}) # can accept other functions
|
||||
db.explain("executionStats").<collection>.find({...}) # more info
|
||||
|
|
@ -280,7 +280,7 @@ db.explain("executionStats").<collection>.find({...}) # more info
|
|||
|
||||
### Index Creation
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.createIndex( <key and index type specification>, <options> )
|
||||
|
||||
db.<collection>.createIndex( { "<key>": <type>, "<key>": <type>, ... } ) # normal, compound or multikey (field is array) index
|
||||
|
|
@ -302,7 +302,7 @@ db.<collection>.createIndex(
|
|||
|
||||
### [Index Management](https://docs.mongodb.com/manual/tutorial/manage-indexes/)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
# view all db indexes
|
||||
db.getCollectionNames().forEach(function(collection) {
|
||||
indexes = db[collection].getIndexes();
|
||||
|
|
@ -339,7 +339,7 @@ handling connections, requests and persisting the data.
|
|||
|
||||
### Basic Shell Helpers
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<method>() # database interaction
|
||||
db.<collection>.<method>() # collection interaction
|
||||
rs.<method>(); # replica set deployment and management
|
||||
|
|
@ -378,7 +378,7 @@ Log Verbosity Level:
|
|||
- `0`: Default Verbosity (Information)
|
||||
- `1 - 5`: Increases the verbosity up to Debug messages
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.getLogComponents() # get components and their verbosity
|
||||
db.adminCommand({"getLog": "<scope>"}) # retrieve logs (getLog must be run on admin db -> adminCommand)
|
||||
db.setLogLevel(<level>, "<component>"); # set log level (output is OLD verbosity levels)
|
||||
|
|
@ -404,7 +404,7 @@ Events captured by the profiler:
|
|||
|
||||
> **Note**: Logs are saved in the `system.profile` _capped_ collection.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.setProfilingLevel(n) # set profiler level
|
||||
db.setProfilingLevel(1, { slowms: <ms> })
|
||||
db.getProfilingStatus() # check profiler status
|
||||
|
|
@ -454,7 +454,7 @@ Built-in Roles Groups and Names:
|
|||
- Backup/Restore: `backup`, `restore`
|
||||
- Super User: `root`
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.createUser(
|
||||
{
|
||||
user: "<username>",
|
||||
|
|
@ -509,7 +509,7 @@ Variable syntax in aggregations:
|
|||
|
||||
Filters the documents to pass only the documents that match the specified condition(s) to the next pipeline stage.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{ "$match": { "<query>" } },
|
||||
|
||||
|
|
@ -541,7 +541,7 @@ Passes along the documents with the requested fields to the next stage in the pi
|
|||
- [`$sum`][$sum_docs]
|
||||
- [`$avg`][$avg_docs]
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{
|
||||
"$project": {
|
||||
|
|
@ -598,7 +598,7 @@ db.<collection>.aggregate([
|
|||
Adds new fields to documents (can be result of computation).
|
||||
`$addFields` outputs documents that contain _all existing fields_ from the input documents and newly added fields.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate({
|
||||
{ $addFields: { <newField>: <expression>, ... } }
|
||||
})
|
||||
|
|
@ -610,7 +610,7 @@ db.<collection>.aggregate({
|
|||
|
||||
The $`group` stage separates documents into groups according to a "group key". The output is one document for each unique group key.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{
|
||||
"$group": {
|
||||
|
|
@ -629,7 +629,7 @@ db.<collection>.aggregate([
|
|||
Deconstructs an array field from the input documents to output a document for each element.
|
||||
Each output document is the input document with the value of the array field replaced by the element
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{ "$unwind": "<array-key>" }
|
||||
|
||||
|
|
@ -647,7 +647,7 @@ db.<collection>.aggregate([
|
|||
|
||||
### [`$count` Aggregation Stage][$count_docs]
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{ "$count": "<count-key>" }
|
||||
])
|
||||
|
|
@ -657,7 +657,7 @@ db.<collection>.aggregate([
|
|||
|
||||
### [`$sort` Aggregation Stage][$sort_docs]
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{
|
||||
"$sort": {
|
||||
|
|
@ -676,7 +676,7 @@ db.<collection>.aggregate([
|
|||
|
||||
### [`$skip` Aggregation Stage][$skip_docs]
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{ "$skip": "<positive 64-bit integer>" }
|
||||
])
|
||||
|
|
@ -686,7 +686,7 @@ db.<collection>.aggregate([
|
|||
|
||||
### [`$limit` Aggregation Stage][$limit_docs]
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{ "$limit": "<positive 64-bit integer>" }
|
||||
])
|
||||
|
|
@ -701,7 +701,7 @@ The `$lookup` stage adds a new array field to each input document. The new array
|
|||
|
||||
> **Note**: To combine elements from two different collections, use the [`$unionWith`][$unionWith_docs] pipeline stage.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{
|
||||
"$lookup": {
|
||||
|
|
@ -724,7 +724,7 @@ Performs a recursive search on a collection, with options for restricting the se
|
|||
|
||||
The collection on which the aggregation is performed and the `from` collection can be the same (in-collection search) or different (cross-collection search)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{
|
||||
$graphLookup: {
|
||||
|
|
@ -754,7 +754,7 @@ Each output document contains two fields: an `_id` field containing the distinct
|
|||
|
||||
The documents are sorted by count in descending order.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
db.<collection>.aggregate([
|
||||
{ $sortByCount: <expression> }
|
||||
])
|
||||
|
|
|
|||
|
|
@ -10,14 +10,14 @@ Often Redis it is called a *data structure* server because it has outer key-valu
|
|||
|
||||
### Server Startup
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
redis-server # start the server
|
||||
redis-cli
|
||||
```
|
||||
|
||||
### [Key-Value Pairs](https://redis.io/commands#generic)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
SET <key> <value> [ EX <seconds> ] # store a key-value pair, TTL optional
|
||||
GET <key> # read a key content
|
||||
EXISTS <key> # check if a key exists
|
||||
|
|
@ -40,7 +40,7 @@ PERSIST <key> # make the key permanent
|
|||
|
||||
A list is a series of ordered values.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
RPUSH <key> <value1> <value2> ... # add one or more values to the end of the list
|
||||
LPUSH <key> <value1> <value2> ... # add one or more values to the start of a list
|
||||
|
||||
|
|
@ -55,7 +55,7 @@ RPOP # remove and return the last item fro the list
|
|||
|
||||
A set is similar to a list, except it does not have a specific order and each element may only appear once.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
SADD <key> <value1> <value2> ... # add one or more values to the set (return 0 if values are already inside)
|
||||
SREM <key> <value> # remove the given member from the set, return 1 or 0 to signal if the member was actually there or not.
|
||||
SPOP <key> <value> # remove and return value from the set
|
||||
|
|
@ -72,7 +72,7 @@ Sets are a very handy data type, but as they are unsorted they don't work well f
|
|||
|
||||
A sorted set is similar to a regular set, but now each value has an associated score. This score is used to sort the elements in the set.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
ZADD <key> <score> <value> # add a value with it's score
|
||||
|
||||
ZRANGE <key> <start_index> <end_index> # return a subset of the sortedSet
|
||||
|
|
@ -84,7 +84,7 @@ ZRANGE <key> <start_index> <end_index> # return a subset of the sortedSet
|
|||
|
||||
Hashes are maps between string fields and string values, so they are the perfect data type to represent objects.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
HSET <key> <field> <value> [ <field> <value> ... ] # set the string of a hash field
|
||||
HSETNX <key> <field> <value> # set the value of a hash field, only if the field does not exist
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## DDL
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
show databases; -- mostra database
|
||||
CREATE DATABASE <database>; -- database creation
|
||||
use <database_name>; -- usa un database particolare
|
||||
|
|
@ -16,7 +16,7 @@ show tables; -- mostra tabelle del database
|
|||
|
||||
### Table Creation
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
CREATE TABLE <table_name>
|
||||
(<field_name> <field_type> <option>,
|
||||
...);
|
||||
|
|
@ -24,7 +24,7 @@ CREATE TABLE <table_name>
|
|||
|
||||
### PRIMARY KEY from multiple fields
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
CREATE TABLE <table_name>(
|
||||
...,
|
||||
PRIMARY KEY (<field1>, ...),
|
||||
|
|
@ -33,7 +33,7 @@ CREATE TABLE <table_name>(
|
|||
|
||||
### Table Field Options
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
PRIMARY KEY -- marks primary key as field option
|
||||
NOT NULL -- marks a necessary field
|
||||
REFERENCES <table> (<field>) -- adds foreign key reference
|
||||
|
|
@ -43,7 +43,7 @@ UNIQUE (<field>) -- set field as unique (MySQL)
|
|||
|
||||
### Table Modification
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
ALTER TABLE <table>
|
||||
ADD PRIMARY KEY (<field>, ...), -- definition of PK after table creation
|
||||
ADD <field_name> <field_type> <option>; -- addition of a new field, field will have no value in the table
|
||||
|
|
@ -63,20 +63,20 @@ ALTER TABLE <table>
|
|||
|
||||
### Data Insertion
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
INSERT INTO <table> (field_1, ...) VALUES (value_1, ...), (value_1, ...);
|
||||
INSERT INTO <table> VALUES (value_1, ...), (value_1, ...); -- field order MUST respect tables's columns order
|
||||
```
|
||||
|
||||
### Data Update
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
UPDATE <table> SET <field> = <value>, <field> = <value>, ... WHERE <condition>;
|
||||
```
|
||||
|
||||
### Data Elimination
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
DELETE FROM <table> WHERE <condition>
|
||||
DELETE FROM <table> -- empty the table
|
||||
```
|
||||
|
|
@ -85,7 +85,7 @@ DELETE FROM <table> -- empty the table
|
|||
|
||||
`*`: denotes all table fields
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT * FROM <table>; -- show table contents
|
||||
SHOW columns FROM <table>; -- show table columns
|
||||
DESCRIBE <table>; -- shows table
|
||||
|
|
@ -93,13 +93,13 @@ DESCRIBE <table>; -- shows table
|
|||
|
||||
### Alias
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT <field> as <alias>; -- shows <field/funzione> with name <alias>
|
||||
```
|
||||
|
||||
### Conditional Selection
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT * FROM <table> WHERE <condition>; -- shows elements that satisfy the condition
|
||||
AND, OR, NOT -- logic connectors
|
||||
|
||||
|
|
@ -108,7 +108,7 @@ SELECT * FROM <table> WHERE <field> Between <value_1> AND <value_2>;
|
|||
|
||||
### Ordering
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT * FROM <table> ORDER BY <field>, ...; -- shows the table ordered by <field>
|
||||
SELECT * FROM <table> ORDER BY <field>, ... DESC; -- shows the table ordered by <field>, decreasing order
|
||||
SELECT * FROM <table> ORDER BY <field>, ... LIMIT n; -- shows the table ordered by <field>, shows n items
|
||||
|
|
@ -117,7 +117,7 @@ SELECT TOP(n) * FROM <table> ORDER BY <field>, ...; -- T-SQL
|
|||
|
||||
## Grouping
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT * FROM <table> GROUP BY <field>;
|
||||
SELECT * FROM <table> GROUP BY <field> HAVING <condition>;
|
||||
SELECT DISTINCT <field> FROM <table>; -- shows elements without repetitions
|
||||
|
|
@ -127,7 +127,7 @@ SELECT DISTINCT <field> FROM <table>; -- shows elements without repetitions
|
|||
|
||||
`%`: any number of characters
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT * FROM <table> WHERE <field> LIKE '<char>%'; -- selects items in <field> that start with <char>
|
||||
SELECT * FROM <table> WHERE <field> LIKE '%<char>'; -- selects items in <field> that end with <char>
|
||||
SELECT * FROM <table> WHERE <field> LIKE '%<char>%'; -- selects items in <field> that contain <char>
|
||||
|
|
@ -136,14 +136,14 @@ SELECT * FROM <table> WHERE <field> NOT LIKE '%<char>%'; -- selects items in
|
|||
|
||||
### Selection from multiple tables
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT a.<field>, b.<field> FROM <table> AS a, <table> AS b
|
||||
WHERE a.<field> ...;
|
||||
```
|
||||
|
||||
## Functions
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT COUNT(*) FROM <field>; -- count of items in <field>
|
||||
SELECT MIN(*) FROM <table>; -- min value
|
||||
SELECT MAX(*) FROM <table>; -- max value
|
||||
|
|
@ -154,7 +154,7 @@ ANY (SELECT ...)
|
|||
|
||||
## Nested Queries
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT * FROM <table> WHERE EXISTS (SELECT * FROM <table>) -- selected field existing in subquery
|
||||
SELECT * FROM <table> WHERE NOT EXISTS (SELECT * FROM <table>) -- selected field not existing in subquery
|
||||
```
|
||||
|
|
@ -163,7 +163,7 @@ SELECT * FROM <table> WHERE NOT EXISTS (SELECT * FROM <table>) -- selected fiel
|
|||
|
||||
Create new table with necessary fields:
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
CREATE TABLE <table> (
|
||||
(<field_name> <field_type> <option>,
|
||||
...);
|
||||
|
|
@ -172,14 +172,14 @@ CREATE TABLE <table> (
|
|||
|
||||
Fill fields with data from table:
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
INSERT INTO <table>
|
||||
SELECT <fields> FROM <TABLE> WHERE <condition>;
|
||||
```
|
||||
|
||||
## Join
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT * FROM <table1> JOIN <table2> ON <table1>.<field> = <table2>.<field>;
|
||||
SELECT * FROM <table1> LEFT JOIN <table2> ON <condition>;
|
||||
SELECT * FROM <table1> RIGHT JOIN <table2> ON <condition>
|
||||
|
|
@ -189,7 +189,7 @@ SELECT * FROM <table1> RIGHT JOIN <table2> ON <condition>
|
|||
|
||||
## Multiple Join
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
SELECT * FROM <table1>
|
||||
JOIN <table2> ON <table1>.<field> = <table2>.<field>
|
||||
JOIN <table3> ON <table2>.<field> = <table3>.<field>;
|
||||
|
|
@ -203,7 +203,7 @@ JOIN <table3> ON <table2>.<field> = <table3>.<field>;
|
|||
|
||||
### T-SQL Insert From table
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
USE [<db_name>]
|
||||
|
||||
SET IDENTITY_INSERT [<destination_table>] ON
|
||||
|
|
@ -217,7 +217,7 @@ SET IDENTITY_INSERT [<destination_table>] OFF
|
|||
|
||||
### T-SQL Parametric Query
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
-- variable declaration
|
||||
DECLARE @var_name <type>
|
||||
|
||||
|
|
@ -238,7 +238,7 @@ GO
|
|||
|
||||
A view represents a virtual table. Join multiple tables in a view and use the view to present the data as if the data were coming from a single table.
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
CREATE VIEW <name> AS
|
||||
SELECT * FROM <table> ...
|
||||
```
|
||||
|
|
@ -250,7 +250,7 @@ SELECT * FROM <table> ...
|
|||
|
||||
Stored Procedure Definition:
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
CREATE PROCEDURE <Procedure_Name>
|
||||
-- Add the parameters for the stored procedure here
|
||||
<@Param1> <Datatype_For_Param1> = <Default_Value_For_Param1>,
|
||||
|
|
@ -268,7 +268,7 @@ GO
|
|||
|
||||
Stored Procedure call in query:
|
||||
|
||||
```sql
|
||||
```sql linenums="1"
|
||||
USE <database>
|
||||
GO
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ SwiftUI memorizes internally the value of the `@State` property and updates the
|
|||
- Permits the visualization of simple UIs.
|
||||
- Constituted by a body of type `View`
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
struct SimpleViewName: View {
|
||||
|
||||
let CONSTANT: Type
|
||||
|
|
@ -38,7 +38,7 @@ struct SimpleViewName: View {
|
|||
|
||||
Used to organize elements without dealing with constraints or forcing the visualization on devices wih different screen sizes.
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
struct ContentView: View {
|
||||
var body: some View {
|
||||
|
||||
|
|
@ -61,7 +61,7 @@ The basic object that creates the table view is the `List()`. It's job is to cre
|
|||
The array can be filtered with a *search bar*.
|
||||
The array elements can be grouped with the `Section()` object that groups cells under a common name in the table.
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
// view name can be any
|
||||
struct TableView: View {
|
||||
var array = [...]
|
||||
|
|
@ -88,7 +88,7 @@ Every cell can have a link to visualize the details of the selected object. This
|
|||
The `NavigationView` contains the list and the property `.navigationBarTitle()` sets the view title.
|
||||
It's possible to add other controls in the top part of the view (buttons, ...) using the property `.navigationBarItems()`.
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
struct ContentView: View {
|
||||
let array = [...]
|
||||
var body: some View {
|
||||
|
|
@ -108,7 +108,7 @@ struct ContentView: View {
|
|||
This view handles a bar on the bottom of the screen with links to simple or more complex views.
|
||||
This is useful for designing pages that can be easily navigated by the user.
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
struct TabBarView: View {
|
||||
var body: some View {
|
||||
|
||||
|
|
@ -143,20 +143,20 @@ It's possible to integrate the NavigationView in the TabBar in two ways:
|
|||
|
||||
### Text
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
Text("")
|
||||
```
|
||||
|
||||
### Shapes
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
Rectangle()
|
||||
Circle()
|
||||
```
|
||||
|
||||
### Spacing
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
Divider()
|
||||
Spacer()
|
||||
```
|
||||
|
|
@ -165,13 +165,13 @@ Spacer()
|
|||
|
||||
[System Images](https://developer.apple.com/design/human-interface-guidelines/sf-symbols/overview/)
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
Image(systemName: "sfsymbol")
|
||||
```
|
||||
|
||||
### Button
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
Button(action: { /* statements */ }) {
|
||||
Text("Label")
|
||||
//or
|
||||
|
|
@ -202,7 +202,7 @@ Common syle options:
|
|||
- `shadow()`: Sets the object's shadow
|
||||
- `lineLimit()`: limits the number of visible lines in `TextField`
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
View().styleOption()
|
||||
// or
|
||||
View {
|
||||
|
|
@ -212,7 +212,7 @@ View {
|
|||
|
||||
## Forms & Input
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
Form {
|
||||
Section (header: Text("Section Title")) {
|
||||
// form components
|
||||
|
|
@ -222,7 +222,7 @@ Form {
|
|||
|
||||
### Picker
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
// list item picker
|
||||
Picker(selction: $index, label: Text("Selection Title")) {
|
||||
ForEach(0..<itemArray.count){
|
||||
|
|
@ -233,26 +233,26 @@ Picker(selction: $index, label: Text("Selection Title")) {
|
|||
|
||||
### Stepper
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
Stepper("\(number)", value: $number, in: start...end)
|
||||
```
|
||||
|
||||
### TextField
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
TextField("Placeholder Text", text: $result)
|
||||
.keyboardType(.<kb_type>)
|
||||
```
|
||||
|
||||
### Slider
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
Slider(value: $numVariable)
|
||||
```
|
||||
|
||||
## API Interaction
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
@State private var apiItems = [<struct>]()
|
||||
|
||||
// struct should be Identifiable & Codable
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
## Compiling & Linking
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
# compiling
|
||||
nasm -g -f elf64 src.asm # -g adds debug info, -f specifies the 64bit ELF format
|
||||
|
||||
|
|
@ -25,7 +25,7 @@ Every program in ELF has several sections:
|
|||
- `bss`: space reserved at program startup
|
||||
- `text`: CPU instructions
|
||||
|
||||
```asm
|
||||
```asm linenums="1"
|
||||
; export the '_start' symbol for linking
|
||||
global _start
|
||||
|
||||
|
|
@ -49,7 +49,7 @@ Declaration instructions:
|
|||
> **Note**: See the NASM manual, section 3.2.1 for the full list.
|
||||
> **Note**: all byte declaarations are [Little Endian](https://en.wikipedia.org/wiki/Endianness "Endiannes")
|
||||
|
||||
```asm
|
||||
```asm linenums="1"
|
||||
arr: db 0x12,0x34,0x56,0x78,0x90
|
||||
```
|
||||
|
||||
|
|
@ -85,14 +85,14 @@ For registers `rax` through `rdx`, it's possible to access:
|
|||
Instructions are operations that the CPU knowns how to execute directly.
|
||||
They are separated from their operands by whitespace, and the operands are separated from other with commas.
|
||||
|
||||
```asm
|
||||
```asm linenums="1"
|
||||
<instr> <operand1>, <operand2>, ..., <operand_n>
|
||||
|
||||
; Intel syntax dictates the first operand is the destination, and the second is the source
|
||||
<instr> DEST, SOURCE
|
||||
```
|
||||
|
||||
```asm
|
||||
```asm linenums="1"
|
||||
mov eax, 0x12345678 ; copies 4 bytes to eax
|
||||
inc rdi ; INC: increment
|
||||
dec rsi ; DEC: decrement
|
||||
|
|
@ -102,7 +102,7 @@ dec rsi ; DEC: decrement
|
|||
|
||||
Adds the two operands and stores the result in the _destination_.
|
||||
|
||||
```asm
|
||||
```asm linenums="1"
|
||||
add rdi, rbx ; Equivalent to rdi += rbx
|
||||
```
|
||||
|
||||
|
|
@ -110,7 +110,7 @@ add rdi, rbx ; Equivalent to rdi += rbx
|
|||
|
||||
Subtract the two operands and stores the result in the _destination_.
|
||||
|
||||
```asm
|
||||
```asm linenums="1"
|
||||
sub rsi, rbx ; Equivalent to rsi -= rbx
|
||||
```
|
||||
|
||||
|
|
@ -130,7 +130,7 @@ The **quotient** is a _64-bit_ value stored in `rax`, and the **remainder** is a
|
|||
|
||||
### `and`, `or`, `xor`
|
||||
|
||||
```asm
|
||||
```asm linenums="1"
|
||||
and rdi, rsi ; bitwise AND
|
||||
or rdi, rsi ; bitwise OR
|
||||
xor rdi, rsi ; bitwise XOR
|
||||
|
|
@ -138,7 +138,7 @@ xor rdi, rsi ; bitwise XOR
|
|||
|
||||
### `shr`, `shl`
|
||||
|
||||
```asm
|
||||
```asm linenums="1"
|
||||
shr rsi, 2 ; right (logical) bitshift: equivalent to rsi >> 2
|
||||
shl rsi, 3 ; left (logical) bitshift: equivalent to rsi << 3
|
||||
```
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
[sudo vs su](https://unix.stackexchange.com/questions/35338/su-vs-sudo-s-vs-sudo-i-vs-sudo-bash/35342)
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
sudo su # login as root (user must be sudoers, root password not required) DANGEROUS
|
||||
sudo -s # act as root and inherit current user environment (env as is now, along current dir and env vars) SAFE (can modify user environment)
|
||||
sudo -i # act as root and and use a clean environment (goes to user's home, runs .bashrc) SAFEST
|
||||
|
|
@ -22,7 +22,7 @@ su USER # change user but don't load it's home folder
|
|||
|
||||
### Getting Info
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
man COMMAND # show command manual
|
||||
help COMMAND # show command info
|
||||
whatis COMMAND # one-line command explanation
|
||||
|
|
@ -35,7 +35,7 @@ id # Print user and group information for the specified USER, or (when USER omi
|
|||
|
||||
### Moving & Showing Directory Contents
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
pwd # print working (current) directory
|
||||
ls [option]... [FILE]... # list directory contents ("list storage")
|
||||
cd rel_path # change directory to path (rel_path must be inside current directory)
|
||||
|
|
@ -49,7 +49,7 @@ popd # return to previous directory (before pushd)
|
|||
|
||||
### Creating, Reading, Copying, Moving, Modifying Files And Directories
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
touch FILE # change FILE timestamp fi exists, create file otherwise
|
||||
cat [FILE] # concatenate files and print on standard output (FD 1)
|
||||
cat >> FILE # append following content ot file (Ctrl+D to stop)
|
||||
|
|
@ -84,7 +84,7 @@ cp SOURCE DESTINATION # copy SOURCE to DESTINATION
|
|||
|
||||
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
chmod MODE FILE # change file (or directory) permissions
|
||||
chmod OCTAL-MODE FILE # change file (or directory) permissions
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ chgrp [OPTION]... GROUP FILE... # change group ownership
|
|||
|
||||
### Finding Files And Directories
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
find [path] [expression] # search file in directory hierarchy
|
||||
find [start-position] -type f -name FILENAME # search for a file named "filename"
|
||||
find [start-position] -type d -name DIRNAME # search for a directory named "dirname"
|
||||
|
|
@ -134,7 +134,7 @@ find [path] -exec <command> {} \; # execute command on found items (identified
|
|||
|
||||
### Other
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
tee # copy standard input and write to standard output AND files simultaneously
|
||||
tee [FILE]
|
||||
command | sudo tee FILE # operate on file w/o using shell as su
|
||||
|
|
@ -171,7 +171,7 @@ watch -n SECONDS COMMAND # execute command every SECONDS seconds (no less than
|
|||
|
||||
**Data wrangling** is the process of transforming and mapping data from one "raw" data form into another format with the intent of making it more appropriate and valuable for a variety of downstream purposes such as analytics.
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
sed # stream editor for filtering and transforming text
|
||||
sed -E "s/REGEX/replacement/" # substitute text ONCE (-E uses modern REGEX)
|
||||
sed -E "s/REGEX/replacement/g" # substitute text multiple times (every match)
|
||||
|
|
|
|||
|
|
@ -44,20 +44,20 @@ shebang indicating which interpreter to use
|
|||
|
||||
### Simple Command
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
[ var=value ... ] command [ arg ... ] [ redirection ... ] # [.] is optional component
|
||||
```
|
||||
|
||||
### Pipelines (commands concatenation)
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
command | file.ext # link the first process' standard output to the second process' standard input
|
||||
command |& file.ext # link the first process' standard output & standard error to the second process' standard input
|
||||
```
|
||||
|
||||
### Lists (sequence of commands)
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
command_1; command_2; ... # execute command in sequence, one after the other
|
||||
command_1 || command_2 || ... # execute successive commands only if preceding ones fail
|
||||
command_1 && command_2 && .. # execute successive commands only if preceding ones succeeds
|
||||
|
|
@ -65,7 +65,7 @@ command_1 && command_2 && .. # execute successive commands only if preceding on
|
|||
|
||||
### COMPOUND COMMANDs (multiple commands as one)
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
# block of commands executed as one
|
||||
<keyword>
|
||||
command_1; command_2; ...
|
||||
|
|
@ -108,7 +108,7 @@ We can copy file descriptors to make them share a stream. There are also many ot
|
|||
|
||||
### Redirections
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
[x]>file # make FD x write to file
|
||||
[x]<file # make FD x read from file
|
||||
|
||||
|
|
@ -142,7 +142,7 @@ x>&-, x<&- # close FD x (stream disconnected from FD x)
|
|||
|
||||
With Command Substitution, we effectively write a command within a command, and we ask bash to expand the inner command into its output and use that output as argument data for the main command.
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
$(inner_command) # $ --> value-expansion prefix
|
||||
command !* # !* expands to everything except the first argument in the previous line
|
||||
command !$ # refers to the last argument of the previous command
|
||||
|
|
@ -151,7 +151,7 @@ sudo !! # !! expands to the entire previous command
|
|||
|
||||
## Shell Variables
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
varname=value # variable assignment
|
||||
varname="$(command)" # command substitution, MUST be double-quoted
|
||||
"$varname", "${varname}" # variable expansion, MUST be double-quoted (name substituted w/ variable content)
|
||||
|
|
@ -188,7 +188,7 @@ Omit the pattern to match any character.
|
|||
|
||||
Only the final exit code after executing the entire list is relevant for the branch's evaluation.
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
if command_list; then
|
||||
command_list;
|
||||
elif command_list; then
|
||||
|
|
@ -207,7 +207,7 @@ fi
|
|||
|
||||
### Comparison Operators
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
[[ "$a" -eq "$b" ]] # is equal to
|
||||
[[ "$a" -ne "$b" ]] # in not equal to
|
||||
[[ "$a" -gt "$b" ]] # greater than
|
||||
|
|
@ -218,7 +218,7 @@ fi
|
|||
|
||||
### Arithmetic Comparison Operators
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
(("$a" > "$b")) # greater than
|
||||
(("$a" >= "$b")) # greater than or equal to
|
||||
(("$a" < "$b")) # less than
|
||||
|
|
@ -227,7 +227,7 @@ fi
|
|||
|
||||
### String Comparison Operators
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
[ "$a" = "$b" ] # is equal to (whitespace around operator)
|
||||
|
||||
[[ $a == z* ]] # True if $a starts with an "z" (pattern matching)
|
||||
|
|
@ -246,14 +246,14 @@ fi
|
|||
|
||||
## Commands short circuit evaluation
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
command_1 || command_2 # if command_1 fails executes command_2
|
||||
command_1 && command_2 # executes command_2 only if command_1 succeeds
|
||||
```
|
||||
|
||||
## Loops
|
||||
|
||||
```bash
|
||||
```bash linenums="1"
|
||||
for var in iterable ; do
|
||||
# command here
|
||||
done
|
||||
|
|
@ -261,7 +261,7 @@ done
|
|||
|
||||
## Script Hardening
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
set -o errexit # exit on error
|
||||
set -o nounset # fail on unset variable (bypass with ${VAR:-})
|
||||
set -o pipefail # file entire pipeline if one step fails
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Library Import
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
#include <stdio.h> // search in current + system directories
|
||||
#include "lib.h" // search in current directory
|
||||
```
|
||||
|
|
@ -22,7 +22,7 @@ Can be omitted and replaced by namespace`::`
|
|||
|
||||
## Main Function
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
int main(int argc, char *argv[]) { }
|
||||
```
|
||||
|
||||
|
|
@ -30,14 +30,14 @@ int main(int argc, char *argv[]) { }
|
|||
|
||||
### Constant Declaration
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
#define constant_name value
|
||||
const type constant_name = value;
|
||||
```
|
||||
|
||||
### Variable Declaration
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type var_name = value; //c-like initialization
|
||||
type var_name (value); //constructor initialization
|
||||
type var_name {value}; //uniform initialization
|
||||
|
|
@ -124,7 +124,7 @@ Escape Character | Character
|
|||
|
||||
### Standard Output
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
#include <stdio.h>
|
||||
|
||||
printf_s("text %<fmt_spec>", variable);
|
||||
|
|
@ -132,13 +132,13 @@ printf_s("text %<fmt_spec>", variable);
|
|||
|
||||
### Standard Input
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
#include <stdio.h>
|
||||
|
||||
scanf_s("%<fmt_spec>", &variable); //return number of successfully accepted inputs
|
||||
```
|
||||
|
||||
### Format Specifiers %[width].[length][specifier]
|
||||
### Format Specifiers `%[width].[length][specifier]`
|
||||
|
||||
Specifier | Specified Format
|
||||
------------|-----------------------------------------
|
||||
|
|
@ -236,7 +236,7 @@ a `>>=` b | a = a >> b
|
|||
|
||||
### Mathematical Functions
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
#include <cmath>
|
||||
|
||||
abs(x); // absolute value
|
||||
|
|
@ -263,7 +263,7 @@ tanh(x); //hyperbolic tan(X)
|
|||
|
||||
### Character Functions
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
isalnum(c); //true if c is alphanumeric
|
||||
isalpha(c); //true if c is a letter
|
||||
isdigit(c); //true if char is 0 1 2 3 4 5 6 7 8 9
|
||||
|
|
@ -283,7 +283,7 @@ toupper(c); //transform character in uppercase
|
|||
|
||||
### String Functions
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
strlen(string); //return length (num of chars) of the string
|
||||
strcat(destination, source); //appends chars of string2 to string1
|
||||
strncat(string1, string2, nchar); //appends the first n chars of string 2 to string1
|
||||
|
|
@ -301,7 +301,7 @@ strpbrk(string, charSet); //Returns a pointer to the first occurrence of any
|
|||
|
||||
### String Conversion
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
atof(string); //converts string in double if possible
|
||||
atoi(string); //converts string in integer if possible
|
||||
atol(string); //converts string in long if possible
|
||||
|
|
@ -309,7 +309,7 @@ atol(string); //converts string in long if possible
|
|||
|
||||
### String Methods
|
||||
|
||||
```C++
|
||||
```C linenums="1"++
|
||||
string.at(pos); // returns char at index pos
|
||||
string.substr(start, end); // returns substring between indexes START and END
|
||||
string.c_str(); //reads string char by char
|
||||
|
|
@ -318,7 +318,7 @@ string.find(substring); // The zero-based index of the first character in str
|
|||
|
||||
## Vectors
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
#include <vector>
|
||||
vector<type> vector_name = {values}; //variable length array
|
||||
```
|
||||
|
|
@ -327,7 +327,7 @@ vector<type> vector_name = {values}; //variable length array
|
|||
|
||||
### If Statements
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
if (condition) { }
|
||||
|
||||
if (condition)
|
||||
|
|
@ -346,7 +346,7 @@ else
|
|||
|
||||
### Switch
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
switch (expression) {
|
||||
case constant_1:
|
||||
//code here
|
||||
|
|
@ -365,7 +365,7 @@ switch (expression) {
|
|||
|
||||
### While Loop
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
while (condition) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -373,7 +373,7 @@ while (condition) {
|
|||
|
||||
### Do While
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
do {
|
||||
//code here
|
||||
} while (condition);
|
||||
|
|
@ -381,7 +381,7 @@ do {
|
|||
|
||||
### For Loop
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
for (initialization; condition; increase) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -401,7 +401,7 @@ Functions **must** be declared **before** the main function.
|
|||
It is possible to declare functions **after** the main only if the *prototype* is declared **before** the main.
|
||||
To return multiple variables those variables can be passed by reference so that their values is adjourned in the main.
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type function_name(type argument1, ...); // function prototype
|
||||
|
||||
type functionName (parameters) {
|
||||
|
|
@ -416,7 +416,7 @@ void functionName (parameters) { }
|
|||
Passing arguments by reference causes modifications made inside the function to be propagated to the values outside.
|
||||
Passing arguments by values copies the values to the arguments: changes remain inside the function.
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type functionName (type &argument1, ...) {
|
||||
//code here
|
||||
return <expression>;
|
||||
|
|
@ -430,7 +430,7 @@ type functionName (type &argument1, ...) {
|
|||
Passing arguments by reference causes modifications made inside the function to be propagated to the values outside.
|
||||
Passing arguments by values copies the values to the arguments: changes remain inside the function.
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type function_name (type *argument_1, ...) {
|
||||
instructions;
|
||||
return <expression>;
|
||||
|
|
@ -441,7 +441,7 @@ type function_name (type *argument_1, ...) {
|
|||
|
||||
## Arrays
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type arrayName[dimension]; //array declaration
|
||||
type arrayName[dimension] = {value1, value2, ...}; //array declaration & initialization, values number must match dimension
|
||||
|
||||
|
|
@ -454,7 +454,7 @@ array[index] = value; //value assignment at position index
|
|||
The dimension is not specified because it is determined by the passed array.
|
||||
The array is passed by reference.
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type function(type array[]){
|
||||
//code here
|
||||
}
|
||||
|
|
@ -469,14 +469,14 @@ function(array); //array passed w/out square brackets []
|
|||
|
||||
### Multi-Dimensional Array (Matrix)
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type matrix[rows][columns];
|
||||
matrix[i][j] //element A_ij of the matrix
|
||||
```
|
||||
|
||||
### Matrix as function parameter
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
//matrix passed by reference, second dimension is mandatory
|
||||
type function(type matrix[][columns]){
|
||||
//code here
|
||||
|
|
@ -496,7 +496,7 @@ type function(type matrix[][dim2]...[dimN]){
|
|||
|
||||
### Struct Definition
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
struct Struct {
|
||||
type field1;
|
||||
type field2;
|
||||
|
|
@ -512,7 +512,7 @@ variable.field // field access
|
|||
|
||||
Pointers hold memory addresses of declared variables, they should be initialized to NULL.
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type *pointer = &variable; //pointer init and assignment
|
||||
type *pointer = NULL;
|
||||
type *pointer = otherPointer;
|
||||
|
|
@ -523,7 +523,7 @@ type **pointerToPointer = &pointer; // pointerToPointer -> pointer -> variabl
|
|||
pointer type and variable type **must** match.
|
||||
(*) --> "value pointed to by"
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
pointer //address of pointed value (value of variable)
|
||||
*pointer //value of pointed variable
|
||||
**pointer //value pointed by *pointer (pointer to pointer)
|
||||
|
|
@ -531,7 +531,7 @@ pointer //address of pointed value (value of variable)
|
|||
|
||||
### Pointer to array
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type *pointer;
|
||||
type array[dim] = {};
|
||||
|
||||
|
|
@ -542,7 +542,7 @@ pointer++; //change pointed value to successive "cell" of array
|
|||
|
||||
### Pointers, Arrays & Functions
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
func(array) //pass entire array to function (no need to use (&) to extract address)
|
||||
|
||||
type func(type* array){
|
||||
|
|
@ -552,7 +552,7 @@ type func(type* array){
|
|||
|
||||
### Pointer to Struct
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
(*structPointer).field //access to field value
|
||||
structPointer->structField //access to field value
|
||||
```
|
||||
|
|
@ -576,7 +576,7 @@ Every node is composed by two parts:
|
|||
A **Stack** is a list in with nodes can be extracted from one *side* only (*LIFO*).
|
||||
The extraction of an item from the *top* is called **pop**
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
// node structure
|
||||
struct Node {
|
||||
type value;
|
||||
|
|
@ -586,7 +586,7 @@ struct Node {
|
|||
|
||||
#### Node Insertion
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
Node *stackNode; //current node
|
||||
Node* head = NULL; //pointer to head of stack
|
||||
|
||||
|
|
@ -603,7 +603,7 @@ head = stackNode; //update head to point to new first node
|
|||
|
||||
#### Node Deletion
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
stackNode = head->next; //memorize location of second node
|
||||
free(head); //delete first node
|
||||
head = stackNode; //update head to point to new first node
|
||||
|
|
@ -611,7 +611,7 @@ head = stackNode; //update head to point to new first node
|
|||
|
||||
#### Passing Head To Functions
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
type function(Node** head) //value of head passed by address (head is Node*)
|
||||
{
|
||||
*head = ... //update value of head (pointed variable/object/Node)
|
||||
|
|
@ -644,7 +644,7 @@ C does not automatically free allocated memory when nodes are deleted. It must b
|
|||
* `malloc()` returns a void pointer if the allocation is successful.
|
||||
* `free()` frees the memory
|
||||
|
||||
```C
|
||||
```C linenums="1"
|
||||
list *pointer = (list*)malloc(sizeof(list)); //memory allocation
|
||||
free(pointer) //freeing of memory
|
||||
```
|
||||
|
|
@ -666,7 +666,7 @@ The available classes in C++ to operate on files are:
|
|||
|
||||
Filename can be string literal or CharArray (use `c_str()`).
|
||||
|
||||
```c
|
||||
```c linenums="1"
|
||||
ifstream file;
|
||||
file.open("filename"); //read from file
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
### Inline CSS
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<tag style="property:value"></tag>
|
||||
```
|
||||
|
||||
|
|
@ -14,7 +14,7 @@ Not recommended except in cases where choices are constrained.
|
|||
|
||||
### Embedded CSS
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<head>
|
||||
<style>
|
||||
selector {
|
||||
|
|
@ -40,7 +40,7 @@ Not Recommended, only use when the number of rules is small and there are constr
|
|||
|
||||
### External CSS
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<head>
|
||||
<link rel="stylesheet" href="style.css">
|
||||
</head>
|
||||
|
|
@ -54,7 +54,7 @@ Easier to maintain, especially in larger projects.
|
|||
|
||||
The selector points to the html element to style.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {property: value; property: value}
|
||||
|
||||
selector {
|
||||
|
|
@ -65,7 +65,7 @@ selector {
|
|||
|
||||
### Multiple Selectors
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector1, selector2 {property: value;}
|
||||
```
|
||||
|
||||
|
|
@ -73,7 +73,7 @@ selector1, selector2 {property: value;}
|
|||
|
||||
Used to select tags nested inn other tags.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
outerSelector innerSelector {property: value;}
|
||||
```
|
||||
|
||||
|
|
@ -81,7 +81,7 @@ outerSelector innerSelector {property: value;}
|
|||
|
||||
Should apply to one element on a page.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
#selector {property: value;} /* selects <tag id="selector"> */
|
||||
```
|
||||
|
||||
|
|
@ -89,13 +89,13 @@ Should apply to one element on a page.
|
|||
|
||||
Many elements can have the same class, classes are used to group HTML elements together.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
.selector {property: value;} /* selects <tag class="selector"> */
|
||||
```
|
||||
|
||||
### Universal Selector
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
* {property: value;} /* selects every HTML element */
|
||||
```
|
||||
|
||||
|
|
@ -107,11 +107,11 @@ A CSS selector can contain more than one basic selector.
|
|||
|
||||
Selects an element that resides anywhere within an identified ancestor element.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
article h2 { property: value; }
|
||||
```
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- Will NOT match -->
|
||||
<h2>title</h2>
|
||||
<article>
|
||||
|
|
@ -128,11 +128,11 @@ article h2 { property: value; }
|
|||
|
||||
Selects an elements that resides immediately inside an identified parent element.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
article > p { property: value; }
|
||||
```
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- Will NOT match -->
|
||||
<p>Lorem ipsum dolor sit amet</p>
|
||||
<article>
|
||||
|
|
@ -150,11 +150,11 @@ article > p { property: value; }
|
|||
Selects an element that follows anywhere after the prior element.
|
||||
Both elements share the same parent.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
h2 ~ p { property: value; }
|
||||
```
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<section>
|
||||
<!-- Will NOT match -->
|
||||
<p>Lorem ipsum dolor sit amet</p>
|
||||
|
|
@ -177,11 +177,11 @@ h2 ~ p { property: value; }
|
|||
Selects an element that follows directly after the prior element.
|
||||
Both elements share the same parent.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
h2 + p { property: value; }
|
||||
```
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<section>
|
||||
<!-- Will NOT match -->
|
||||
<p>Lorem ipsum dolor sit amet</p>
|
||||
|
|
@ -209,7 +209,7 @@ Select elements based on whether an attribute is present and what it's value may
|
|||
|
||||
`a[target]{ property: value; }` will match
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<a href="#" target="_blank">click here</a>
|
||||
```
|
||||
|
||||
|
|
@ -217,7 +217,7 @@ Select elements based on whether an attribute is present and what it's value may
|
|||
|
||||
`a[href="https://google.com"] { property: value; }` will match
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<a href="http://google.com/">search on google</a>
|
||||
```
|
||||
|
||||
|
|
@ -225,7 +225,7 @@ Select elements based on whether an attribute is present and what it's value may
|
|||
|
||||
`a[href*="login"] { property: value; }` will match
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<a href="/login.php">login page</a>
|
||||
```
|
||||
|
||||
|
|
@ -233,7 +233,7 @@ Select elements based on whether an attribute is present and what it's value may
|
|||
|
||||
`a[href^="Https://"] { property: value; }` will match
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<a href="https://www.bbc.com/">The BBC</a>
|
||||
```
|
||||
|
||||
|
|
@ -241,7 +241,7 @@ Select elements based on whether an attribute is present and what it's value may
|
|||
|
||||
`a[href$=".pdf"] { property: value; }`
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- WILL match -->
|
||||
<a href="/docs/menu.pdf">download menu</a>
|
||||
<!-- Will NOT match -->
|
||||
|
|
@ -252,7 +252,7 @@ Select elements based on whether an attribute is present and what it's value may
|
|||
|
||||
`img[alt~="child"] { property: value; }`
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- WILL match -->
|
||||
<img src="child.jpg" alt='a small child'>
|
||||
<!-- Will NOT match -->
|
||||
|
|
@ -265,7 +265,7 @@ Select elements based on whether an attribute is present and what it's value may
|
|||
|
||||
`p[lang|="en"] { property: value; }`
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- WILL match -->
|
||||
<p lang="en">English</p>
|
||||
<!-- WILL match -->
|
||||
|
|
@ -278,7 +278,7 @@ Select elements based on whether an attribute is present and what it's value may
|
|||
|
||||
Pseudo-classes can style elements based on their current state. They must be specified after the base case.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector:pseudo-class { property: value; }
|
||||
```
|
||||
|
||||
|
|
@ -337,7 +337,7 @@ When used within selectors allow unique parts of the page to be stylized. Only o
|
|||
`selector::after {...}` creates a pseudo-element after, or behind, the selected element.
|
||||
**These pseudo-elements appear nested within the selected element, not outside of it.**
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
a::after/before {
|
||||
property: value;
|
||||
content: " (" attr(attribute_name) ")";
|
||||
|
|
@ -385,7 +385,7 @@ a::after/before {
|
|||
|
||||
The color property changes the color of the text,
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
color: color-name;
|
||||
color: #<hex-digits>;
|
||||
|
|
@ -401,7 +401,7 @@ selector {
|
|||
- All background definitions are optional, but at least one must be stated
|
||||
- Default values are given to background if some are not defined
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
background:
|
||||
url('texture.jpg') /* image */
|
||||
|
|
@ -454,7 +454,7 @@ Specifies whether the background image should scroll with the page or be fixed
|
|||
|
||||
The font family defines which font is used. When listing multiple fonts, always list a generic name last.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
/* specific font name */
|
||||
font-family: "Font Name";
|
||||
|
|
@ -473,14 +473,14 @@ selector {
|
|||
|
||||
In `page.html`:
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- Google Font -->
|
||||
<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=FontFamily&display=swap">
|
||||
```
|
||||
|
||||
In `style.css`:
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
font-family: 'Font Name';
|
||||
}
|
||||
|
|
@ -488,7 +488,7 @@ selector {
|
|||
|
||||
### Font Size
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
font-size: 11px; /* pixels */
|
||||
font-size: 1.5em;
|
||||
|
|
@ -498,7 +498,7 @@ selector {
|
|||
|
||||
### Fonts (shorthand)
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
font-style: italic;
|
||||
font-weight: bold;
|
||||
|
|
@ -514,7 +514,7 @@ selector {
|
|||
|
||||
### Text Decoration & Text Align
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
text-decoration: line color style thickness;
|
||||
text-align: alignment;
|
||||
|
|
@ -544,7 +544,7 @@ selector {
|
|||
Sets the width of a block-level element or img; does not work for inline elements (unless their display property is changed).
|
||||
Accepts a variety of length units.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
width: 200px;
|
||||
width: 20em ; /* relative to font size */
|
||||
|
|
@ -558,7 +558,7 @@ selector {
|
|||
Sets the height of a block-level element or img; does not work for inline elements (unless their display property is changed).
|
||||
Accepts a variety of length units.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
height: 200px;
|
||||
height: 20em ; /* relative to font size */
|
||||
|
|
@ -571,7 +571,7 @@ selector {
|
|||
|
||||
The aspect-ratio CSS property sets a preferred aspect ratio for the box, which will be used in the calculation of auto sizes and some other layout functions.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
aspect-ratio: <width> / <height>;
|
||||
}
|
||||
|
|
@ -583,7 +583,7 @@ Set upper or lower limits to the size of elements.
|
|||
An element cannot be smaller than its `min-width` or `min-height`.
|
||||
An element cannot be larger than its `max-width` or `max-height`.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
max-width: 100%; /* may be no wider than the containing element */
|
||||
width: 30%; /* will be 30% of the width of the containing element */
|
||||
|
|
@ -613,7 +613,7 @@ Only use `!important` when:
|
|||
- overriding foreign CSS (e.g. from a library)
|
||||
- overriding inline CSS
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector[style*="property:value"] {
|
||||
property: value !important;
|
||||
}
|
||||
|
|
@ -652,7 +652,7 @@ Space between the border and the content.
|
|||
|
||||
It's possible to specify the padding for each side of the element:
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
padding-top: 15px;
|
||||
padding-right: 10%;
|
||||
|
|
@ -663,7 +663,7 @@ selector {
|
|||
|
||||
#### Padding shortcuts
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
padding: top right bottom left; /* Four values (TRBL) */
|
||||
padding: top right/left bottom; /* Three values (T/TL/B) */
|
||||
|
|
@ -678,7 +678,7 @@ selector {
|
|||
|
||||
Borders are specified as "thickness, style, color".
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
border-width: 10px;
|
||||
border-style: dashed;
|
||||
|
|
@ -690,7 +690,7 @@ selector {
|
|||
|
||||
#### Border shortcuts
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
border: thickness style color;
|
||||
}
|
||||
|
|
@ -702,7 +702,7 @@ selector {
|
|||
|
||||
Defines whether the width and height (and min/max) of an element should include padding and borders or not.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
box-sizing: content-box; /* Border and padding are not included */
|
||||
box-sizing: border-box; /* Include the content, padding and border */
|
||||
|
|
@ -713,7 +713,7 @@ selector {
|
|||
|
||||
Universal Box Sizing with Inheritance
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
html {
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
|
@ -730,7 +730,7 @@ Transparent area around the box that separates it from other elements.
|
|||
|
||||
It's possible to specify the margin for each side of the element:
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
padding-top: 15px;
|
||||
padding-right: 10%;
|
||||
|
|
@ -741,7 +741,7 @@ selector {
|
|||
|
||||
#### Margin shortcuts
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
margin: top right bottom left; /* Four values (TRBL) */
|
||||
margin: top right/left bottom; /* Three values (T/TL/B) */
|
||||
|
|
@ -756,7 +756,7 @@ selector {
|
|||
|
||||
If a margin is set to auto on a box that has width it will take up as much space as possible.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
/* Centered */
|
||||
margin: 0 auto;
|
||||
|
|
@ -779,7 +779,7 @@ Top and bottom margins of near elements are collapsed into a single margin that
|
|||
|
||||
### Display Property
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
div {
|
||||
display: inline; /* Default of all elements, unless UA (user agent) stylesheet overrides */
|
||||
display: block; /* block is default for elements like <div> and <section>*/
|
||||
|
|
@ -841,7 +841,7 @@ It's possible to specify whether an element is floated or not and which side it
|
|||
|
||||
To place two block level elements to be side by side float both elements, one left and one right.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
.float-child-left {
|
||||
float: left;
|
||||
width: 200px;
|
||||
|
|
@ -862,7 +862,7 @@ appear.
|
|||
|
||||
Clearing both ensures the element doesn't wrap next to floats on either side.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
clear: right;
|
||||
clear: left;
|
||||
|
|
@ -879,7 +879,7 @@ Static elements ignore top, bottom, right, or left property specifications.
|
|||
In normal flow block elements flow from top to bottom making a new line after every element.
|
||||
In normal flow inline elements flow from left to right wrapping to next line when needed.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
position: static;
|
||||
}
|
||||
|
|
@ -891,7 +891,7 @@ Takes the element out of the normal flow, allowing it to be moved in relation to
|
|||
Makes an element a "positioning context" in which to position other elements relative to it.
|
||||
The relative value will still put the element in the normal flow, but then offset it according to top, bottom, right and left properties.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
position: relative;
|
||||
}
|
||||
|
|
@ -904,7 +904,7 @@ An absolutely positioned element is offset from its container block, set with th
|
|||
Its container block is the first surrounding element that has any position other than static.
|
||||
If no such element is found, the container block is `<html>`.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
position: absolute;
|
||||
}
|
||||
|
|
@ -915,7 +915,7 @@ selector {
|
|||
The fixed value takes an element out of the normal flow, it positions it relative to the viewport.
|
||||
Parent positioning will no longer affect fixed elements.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
position: fixed;
|
||||
}
|
||||
|
|
@ -926,7 +926,7 @@ selector {
|
|||
Sticky positioning is a hybrid of relative and fixed positioning.
|
||||
The element is treated as relative positioned until it crosses a specified threshold, at which point it is treated as fixed positioned.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
position: sticky;
|
||||
position: -webkit-sticky;
|
||||
|
|
@ -945,7 +945,7 @@ When elements overlap, the order of overlapping can be changed with z-index:
|
|||
|
||||
**Nesting is important**: if element *B* is on top of element *A*, a child of element *A* can never be higher than element *B*.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
z-index: <int>;
|
||||
}
|
||||
|
|
@ -953,7 +953,7 @@ selector {
|
|||
|
||||
### [Grid](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Grid_Layout)
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
display: grid;
|
||||
grid-template-columns: 1fr 1fr 1fr; /* 3 equal columns */
|
||||
|
|
@ -970,7 +970,7 @@ The `clamp()` function can be used anywhere a `<length>`, `<frequency>`, `<angle
|
|||
|
||||
clamp(MIN, VAL, MAX) is resolved as max(MIN, min(VAL, MAX))
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
selector {
|
||||
length: clamp(MIN, VAL, MAX) /* is resolved as max(MIN, min(VAL, MAX)) */
|
||||
}
|
||||
|
|
@ -978,7 +978,7 @@ selector {
|
|||
|
||||
### Var & Variables
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
:root {
|
||||
/* define variables on :root element */
|
||||
--variable: value;
|
||||
|
|
@ -1094,7 +1094,7 @@ Some of the most common widths used:
|
|||
|
||||
Example of *Bootstrap* (front-end framework) breakpoints:
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
/* Extra small devices (portrait phones, less than 576px) */
|
||||
/* No media query for `xs` since this is the default in Bootstrap */
|
||||
/* Small devices (landscape phones, 576px and up) */
|
||||
|
|
@ -1133,7 +1133,7 @@ A media query is a logical expression: true or false; if a media query is true,
|
|||
| `screen` | computer screens, tablets, smart-phones, etc |
|
||||
| `speech` | screen readers that "reads" the page out loud |
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
@media type operator (feature) {
|
||||
selector {
|
||||
/* css rule */
|
||||
|
|
@ -1168,14 +1168,14 @@ A media query is a logical expression: true or false; if a media query is true,
|
|||
|
||||
It's possible to specify a media attribute in the link element. This applies a whole stylesheet when the condition is true. Possible to do but preferable to specify a single stylesheet with individual media queries.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<link rel="stylesheet" media="screen and (min-width: 900px)" href="widescreen.css">
|
||||
<link rel="stylesheet" media="screen and (max-width: 600px)" href="smallscreen.css">
|
||||
```
|
||||
|
||||
It's also possible to have different stylesheets based on media type. This might make sense for some use cases.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<link rel="stylesheet" type="text/css" href="screen.css" media="screen">
|
||||
<link rel="stylesheet" type="text/css" href="print.css" media="print">
|
||||
```
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ The component class is usually written in the form of a Razor markup page with a
|
|||
|
||||
[Blazor Components](https://docs.microsoft.com/en-us/aspnet/core/blazor/components/)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
@page "/route/{RouteParameter}" // make component accessible from a URL
|
||||
@page "/route/{RouteParameter?}" // specify route parameter as optional
|
||||
@page "/route/{RouteParameter:<type>}" // specify route parameter type
|
||||
|
|
@ -59,7 +59,7 @@ The component class is usually written in the form of a Razor markup page with a
|
|||
|
||||
It's now possible to pass state when navigating in Blazor apps using the `NavigationManager`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
navigationManager.NavigateTo("/<route>", new NavigationOptions { HistoryEntryState = value });
|
||||
```
|
||||
|
||||
|
|
@ -67,12 +67,12 @@ This mechanism allows for simple communication between different pages. The spec
|
|||
|
||||
### Blazor WASM
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// setup state singleton
|
||||
builder.Services.AddSingleton<StateContainer>();
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// StateContainer singleton
|
||||
using System;
|
||||
|
||||
|
|
@ -96,7 +96,7 @@ public class StateContainer
|
|||
}
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// component that changes the state
|
||||
@inject StateContainer State
|
||||
|
||||
|
|
@ -113,7 +113,7 @@ public class StateContainer
|
|||
}
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// component that should be update on state change
|
||||
@implements IDisposable
|
||||
@inject StateContainer State
|
||||
|
|
@ -139,7 +139,7 @@ public class StateContainer
|
|||
|
||||
## Data Binding & Events
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
<p>
|
||||
<button @on{DOM EVENT}="{DELEGATE}" />
|
||||
<button @on{DOM EVENT}="{DELEGATE}" @on{DOM EVENT}:preventDefault /> // prevent default action
|
||||
|
|
@ -186,7 +186,6 @@ public class StateContainer
|
|||
```
|
||||
|
||||
> **Note**: When a user provides an unparsable value to a data-bound element, the unparsable value is automatically reverted to its previous value when the bind event is triggered.
|
||||
|
||||
> **Note**: The `@bind:get` and `@bind:set` modifiers are always used together.
|
||||
> `The @bind:get` modifier specifies the value to bind to and the `@bind:set` modifier specifies a callback that is called when the value changes
|
||||
|
||||
|
|
@ -199,7 +198,7 @@ public class StateContainer
|
|||
|
||||
To render a Blazor component from JavaScript, first register it as a root component for JavaScript rendering and assign it an identifier:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// Blazor Server
|
||||
builder.Services.AddServerSideBlazor(options =>
|
||||
{
|
||||
|
|
@ -212,7 +211,7 @@ builder.RootComponents.RegisterForJavaScript<Counter>(identifier: "counter");
|
|||
|
||||
Load Blazor into the JavaScript app (`blazor.server.js` or `blazor.webassembly.js`) and then render the component from JavaScript into a container element using the registered identifier, passing component parameters as needed:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let containerElement = document.getElementById('my-counter');
|
||||
await Blazor.rootComponents.add(containerElement, 'counter', { incrementAmount: 10 });
|
||||
```
|
||||
|
|
@ -224,6 +223,6 @@ Custom elements use standard HTML interfaces to implement custom HTML elements.
|
|||
|
||||
To create a custom element using Blazor, register a Blazor root component as custom elements like this:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
options.RootComponents.RegisterAsCustomElement<Counter>("my-counter");
|
||||
```
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ Filter attributes:
|
|||
|
||||
## **Filter scopes**
|
||||
|
||||
A filter can be added to the pipeline at one of three *scopes*:
|
||||
A filter can be added to the pipeline at one of three _scopes_:
|
||||
|
||||
- Using an attribute on a controller action. Filter attributes cannot be applied to Razor Pages handler methods.
|
||||
|
||||
|
|
@ -124,14 +124,14 @@ builder.Services.AddControllersWithViews(options =>
|
|||
|
||||
When there are multiple filters for a particular stage of the pipeline, scope determines the default order of filter execution. Global filters surround class filters, which in turn surround method filters.
|
||||
|
||||
As a result of filter nesting, the *after* code of filters runs in the reverse order of the *before* code. The filter sequence:
|
||||
As a result of filter nesting, the _after_ code of filters runs in the reverse order of the _before_ code. The filter sequence:
|
||||
|
||||
- The *before* code of global filters.
|
||||
- The *before* code of controller and Razor Page filters.
|
||||
- The *before* code of action method filters.
|
||||
- The *after* code of action method filters.
|
||||
- The *after* code of controller and Razor Page filters.
|
||||
- The *after* code of global filters.
|
||||
- The _before_ code of global filters.
|
||||
- The _before_ code of controller and Razor Page filters.
|
||||
- The _before_ code of action method filters.
|
||||
- The _after_ code of action method filters.
|
||||
- The _after_ code of controller and Razor Page filters.
|
||||
- The _after_ code of global filters.
|
||||
|
||||
### Cancellation and Short-Circuiting
|
||||
|
||||
|
|
@ -156,7 +156,7 @@ public class ShortCircuitingResourceFilterAttribute : Attribute, IResourceFilter
|
|||
|
||||
## Dependency Injection
|
||||
|
||||
Filters can be added _by type_ or _by instance_. If an instance is added, that instance is used for every request. If a type is added, it's type-activated.
|
||||
Filters can be added _by type_ or _by instance_. If an instance is added, that instance is used for every request. If a type is added, it's type-activated.
|
||||
|
||||
A type-activated filter means:
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ Short-circuiting is often desirable because it avoids unnecessary work.
|
|||
|
||||
It's possible to perform actions both *before* and *after* the next delegate:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// "inline" middleware, best if in own class
|
||||
app.Use(async (context, next) =>
|
||||
{
|
||||
|
|
@ -45,7 +45,7 @@ app.Use(async (context, next) =>
|
|||
|
||||
`Run` delegates don't receive a next parameter. The first `Run` delegate is always terminal and terminates the pipeline.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// "inline" middleware, best if in own class
|
||||
app.Use(async (context, next) =>
|
||||
{
|
||||
|
|
@ -69,7 +69,7 @@ The Endpoint middleware executes the filter pipeline for the corresponding app t
|
|||
|
||||
The order that middleware components are added in the `Startup.Configure` method defines the order in which the middleware components are invoked on requests and the reverse order for the response. The order is **critical** for security, performance, and functionality.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
if (env.IsDevelopment())
|
||||
{
|
||||
app.UseDeveloperExceptionPage();
|
||||
|
|
@ -121,7 +121,7 @@ Unlike with `MapWhen`, this branch is rejoined to the main pipeline if it doesn'
|
|||
|
||||
Middleware is generally encapsulated in a class and exposed with an extension method.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class CustomMiddleware
|
||||
{
|
||||
private readonly RequestDelegate _next;
|
||||
|
|
@ -152,7 +152,7 @@ The middleware class **must** include:
|
|||
|
||||
## Middleware Extension Methods
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using Microsoft.AspNetCore.Builder;
|
||||
|
||||
public static class MiddlewareExtensions
|
||||
|
|
@ -164,7 +164,7 @@ public static class MiddlewareExtensions
|
|||
}
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// other middlewares
|
||||
|
||||
app.UseCustom(); // add custom middleware in the pipeline
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
> **Note**: Requires .NET 6+
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
var builder = WebApplication.CreateBuilder(args);
|
||||
|
||||
builder.Services.AddSingleton<IService, Service>();
|
||||
|
|
@ -18,7 +18,6 @@ app.Run();
|
|||
app.RunAsync();
|
||||
```
|
||||
|
||||
|
||||
## Application Settings
|
||||
|
||||
App settings are loaded (in order) from:
|
||||
|
|
@ -42,7 +41,7 @@ Setting a value is done with `dotnet user-secrets set <key> <value>`, keys can b
|
|||
|
||||
## Swagger
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
builder.Services.AddEndpointsApiExplorer();
|
||||
builder.Services.AddSwaggerGen();
|
||||
|
||||
|
|
@ -60,7 +59,7 @@ app.MapPost("/route", Handler).Accepts<Type>(contentType);
|
|||
|
||||
## MVC
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
builder.Services.AddControllersWithViews();
|
||||
//or
|
||||
builder.Services.AddControllers();
|
||||
|
|
@ -96,7 +95,7 @@ app.MapControllerRoute(
|
|||
|
||||
To define routes and handlers using Minimal APIs, use the `Map(Get|Post|Put|Delete)` methods.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// the dependencies are passed as parameters in the handler delegate
|
||||
app.MapGet("/route/{id}", (IService service, int id) => {
|
||||
|
||||
|
|
@ -113,7 +112,7 @@ IResult Search(int id, int? page = 1, int? pageSize = 10) { /* ... */ }
|
|||
The `MapGroup()` extension method, which helps organize groups of endpoints with a common prefix.
|
||||
It allows for customizing entire groups of endpoints with a singe call to methods like `RequireAuthorization()` and `WithMetadata()`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
var group = app.MapGroup("<route-prefix>");
|
||||
|
||||
group.MapGet("/", GetAllTodos); // route: /<route-prefix>
|
||||
|
|
@ -127,14 +126,14 @@ group.MapGet("/{id}", GetTodo); // route: /<route-prefix>/{id}
|
|||
The `Microsoft.AspNetCore.Http.TypedResults` static class is the “typed” equivalent of the existing `Microsoft.AspNetCore.Http.Results` class.
|
||||
It's possible to use `TypedResults` in minimal APIs to create instances of the in-framework `IResult`-implementing types and preserve the concrete type information.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public static async Task<IResult> GetAllTodos(TodoDb db)
|
||||
{
|
||||
return TypedResults.Ok(await db.Todos.ToArrayAsync());
|
||||
}
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
[Fact]
|
||||
public async Task GetAllTodos_ReturnsOkOfObjectResult()
|
||||
{
|
||||
|
|
@ -153,7 +152,7 @@ public async Task GetAllTodos_ReturnsOkOfObjectResult()
|
|||
|
||||
The `Results<TResult1, TResult2, TResultN>` generic union types, along with the `TypesResults` class, can be used to declare that a route handler returns multiple `IResult`-implementing concrete types.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// Declare that the lambda returns multiple IResult types
|
||||
app.MapGet("/todos/{id}", async Results<Ok<Todo>, NotFound> (int id, TodoDb db)
|
||||
{
|
||||
|
|
@ -165,7 +164,7 @@ app.MapGet("/todos/{id}", async Results<Ok<Todo>, NotFound> (int id, TodoDb db)
|
|||
|
||||
## Filters
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class ExampleFilter : IRouteHandlerFilter
|
||||
{
|
||||
public async ValueTask<object?> InvokeAsync(RouteHandlerInvocationContext context, RouteHandlerFilterDelegate next)
|
||||
|
|
@ -178,7 +177,7 @@ public class ExampleFilter : IRouteHandlerFilter
|
|||
}
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
app.MapPost("/route", Handler).AddFilter<ExampleFilter>();
|
||||
```
|
||||
|
||||
|
|
@ -192,7 +191,7 @@ With Minimal APIs it's possible to access the contextual information by passing
|
|||
- `ClaimsPrincipal`
|
||||
- `CancellationToken` (RequestAborted)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
app.MapGet("/hello", (ClaimsPrincipal user) => {
|
||||
return "Hello " + user.FindFirstValue("sub");
|
||||
});
|
||||
|
|
@ -202,7 +201,7 @@ app.MapGet("/hello", (ClaimsPrincipal user) => {
|
|||
|
||||
The `Microsoft.AspNetCore.OpenApi` package exposes a `WithOpenApi` extension method that generates an `OpenApiOperation` derived from a given endpoint’s route handler and metadata.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
app.MapGet("/todos/{id}", (int id) => ...)
|
||||
.WithOpenApi();
|
||||
|
||||
|
|
@ -218,7 +217,7 @@ app.MapGet("/todos/{id}", (int id) => ...)
|
|||
Using [Minimal Validation](https://github.com/DamianEdwards/MinimalValidation) by Damian Edwards.
|
||||
Alternatively it's possible to use [Fluent Validation](https://fluentvalidation.net/).
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
app.MapPost("/widgets", (Widget widget) => {
|
||||
var isValid = MinimalValidation.TryValidate(widget, out var errors);
|
||||
|
||||
|
|
@ -241,7 +240,7 @@ class Widget
|
|||
|
||||
## JSON Serialization
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// Microsoft.AspNetCore.Http.Json.JsonOptions
|
||||
builder.Services.Configure<JsonOptions>(opt =>
|
||||
{
|
||||
|
|
@ -251,7 +250,7 @@ builder.Services.Configure<JsonOptions>(opt =>
|
|||
|
||||
## Authorization
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer();
|
||||
|
||||
builder.Services.AddAuthorization();
|
||||
|
|
@ -284,13 +283,13 @@ app.MapGet("/special-secret", () => "This is a special secret!")
|
|||
The `user-jwts` tool is similar in concept to the existing `user-secrets` tools, in that it can be used to manage values for the app that are only valid for the current user (the developer) on the current machine.
|
||||
In fact, the `user-jwts` tool utilizes the `user-secrets` infrastructure to manage the key that the JWTs will be signed with, ensuring it’s stored safely in the user profile.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
dotnet user-jwts create # configure a dev JWT fot the current user
|
||||
```
|
||||
|
||||
## Output Caching
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
builder.Services.AddOutputCaching(); // no special options
|
||||
builder.Services.AddOutputCaching(options =>
|
||||
{
|
||||
|
|
@ -322,7 +321,7 @@ app.MapGet("/<route>", [OutputCache(/* options */)]RouteHandler);
|
|||
|
||||
### Cache Eviction
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
|
||||
app.MapGet("/<route-one>", RouteHandler).CacheOutput(x => x.Tag("<tag>")); // tag cache portion
|
||||
|
||||
|
|
@ -334,11 +333,11 @@ app.MapGet("/<route-two>", (IOutputCacheStore cache, CancellationToken token) =>
|
|||
|
||||
### Custom Cache Policy
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
app.MapGet("/<route-one>", RouteHandler).CacheOutput(x => x.AddCachePolicy<CustomCachePolicy>());
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
class CustomCachePolicy : IOutputCachePolicy
|
||||
{
|
||||
public ValueTask CacheRequestAsync(OutputCacheContext context, CancellationToken cancellationToken) { }
|
||||
|
|
@ -353,7 +352,7 @@ class CustomCachePolicy : IOutputCachePolicy
|
|||
|
||||
The *options pattern* uses classes to provide strongly-typed access to groups of related settings.
|
||||
|
||||
```json
|
||||
```json linenums="1"
|
||||
{
|
||||
"SecretKey": "Secret key value",
|
||||
"TransientFaultHandlingOptions": {
|
||||
|
|
@ -370,7 +369,7 @@ The *options pattern* uses classes to provide strongly-typed access to groups of
|
|||
}
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// options model for binding
|
||||
public class TransientFaultHandlingOptions
|
||||
{
|
||||
|
|
@ -379,13 +378,13 @@ public class TransientFaultHandlingOptions
|
|||
}
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// setup the options
|
||||
builder.Services.Configure<TransientFaultHandlingOptions>(builder.Configuration.GetSection<TransientFaultHandlingOptions>(nameof(Options)));
|
||||
builder.Services.Configure<TransientFaultHandlingOptions>(builder.Configuration.GetSection<TransientFaultHandlingOptions>(key));
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
class DependsOnOptions
|
||||
{
|
||||
private readonly IOptions<TransientFaultHandlingOptions> _options;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Markup
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
@page // set this as razor page
|
||||
|
||||
@model <App>.Models.Entity // if MVC set type of elements passed to the view
|
||||
|
|
@ -35,7 +35,7 @@
|
|||
|
||||
Example:
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- tag helpers for a lin in ASP.NET MVC -->
|
||||
<a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
|
||||
```
|
||||
|
|
@ -44,7 +44,7 @@ Example:
|
|||
|
||||
The `@addTagHelper` directive makes Tag Helpers available to the view. Generally, the view file is `Pages/_ViewImports.cshtml`, which by default is inherited by all files in the `Pages` folder and subfolders, making Tag Helpers available.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
@using <App>
|
||||
@namespace <App>.Pages // or <Project>.Models
|
||||
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
|
||||
|
|
@ -57,7 +57,7 @@ The first parameter after `@addTagHelper` specifies the Tag Helpers to load (`*`
|
|||
|
||||
It's possible to disable a Tag Helper at the element level with the Tag Helper opt-out character (`!`)
|
||||
|
||||
```cshtml
|
||||
```cshtml linenums="1"
|
||||
<!-- disable email validation -->
|
||||
<!span asp-validation-for="Email" ></!span>
|
||||
```
|
||||
|
|
@ -66,7 +66,7 @@ It's possible to disable a Tag Helper at the element level with the Tag Helper o
|
|||
|
||||
The `@tagHelperPrefix` directive allows to specify a tag prefix string to enable Tag Helper support and to make Tag Helper usage explicit.
|
||||
|
||||
```cshtml
|
||||
```cshtml linenums="1"
|
||||
@tagHelpersPrefix th:
|
||||
```
|
||||
|
||||
|
|
@ -74,7 +74,7 @@ The `@tagHelperPrefix` directive allows to specify a tag prefix string to enable
|
|||
|
||||
[Understanding Html Helpers](https://stephenwalther.com/archive/2009/03/03/chapter-6-understanding-html-helpers)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
@model <App>.Models.Entity
|
||||
|
||||
// Display the name of the property
|
||||
|
|
@ -112,7 +112,7 @@ The `@tagHelperPrefix` directive allows to specify a tag prefix string to enable
|
|||
|
||||
In `ViewModel.cs`:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
class ViewModel
|
||||
{
|
||||
public int EntityId { get; set; } // value selected in form ends up here
|
||||
|
|
@ -126,7 +126,7 @@ class ViewModel
|
|||
|
||||
In `View.cs`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
@model ViewModel
|
||||
|
||||
<form asp-controller="Controller" asp-action="PostAction">
|
||||
|
|
@ -140,7 +140,7 @@ In `View.cs`
|
|||
|
||||
In `Controller.cs`:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public IActionResult GetAction()
|
||||
{
|
||||
var vm = new ViewModel();
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ The SignalR Hubs API enables to call methods on connected clients from the serve
|
|||
|
||||
In `Startup.cs`:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
builder.Services.AddSignalR();
|
||||
|
||||
var app = builder.Build();
|
||||
|
|
@ -21,7 +21,7 @@ app.UseEndpoints(endpoints =>
|
|||
|
||||
### Creating Hubs
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class CustomHub : Hub
|
||||
{
|
||||
public task HubMethod(Type args)
|
||||
|
|
@ -46,7 +46,7 @@ A drawback of using `SendAsync` is that it relies on a magic string to specify t
|
|||
|
||||
An alternative to using SendAsync is to strongly type the Hub with `Hub<T>`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public interface IHubClient
|
||||
{
|
||||
// matches method to be called on the client
|
||||
|
|
@ -54,7 +54,7 @@ public interface IHubClient
|
|||
}
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class CustomHub : Hub<IHubClient>
|
||||
{
|
||||
public Task HubMethod(Type args)
|
||||
|
|
@ -72,7 +72,7 @@ Using a strongly typed `Hub<T>` disables the ability to use `SendAsync`. Any met
|
|||
|
||||
The SignalR Hubs API provides the OnConnectedAsync and OnDisconnectedAsync virtual methods to manage and track connections. Override the OnConnectedAsync virtual method to perform actions when a client connects to the Hub, such as adding it to a group.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public override async Task OnConnectedAsync()
|
||||
{
|
||||
await Groups.AddToGroupAsync(Context.ConnectionId, "GroupName");
|
||||
|
|
@ -98,7 +98,7 @@ If the Hub throws an exception, connections aren't closed. By default, SignalR r
|
|||
|
||||
If you have an exceptional condition you *do* want to propagate to the client, use the `HubException` class. If you throw a `HubException` from your hub method, SignalR will send the entire message to the client, unmodified.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public Task ThrowException()
|
||||
{
|
||||
throw new HubException("This error will be sent to the client!");
|
||||
|
|
@ -109,7 +109,7 @@ public Task ThrowException()
|
|||
|
||||
### Installing the client package
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
npm init -y
|
||||
npm install @microsoft/signalr
|
||||
```
|
||||
|
|
@ -118,7 +118,7 @@ npm installs the package contents in the `node_modules\@microsoft\signalr\dist\b
|
|||
|
||||
Reference the SignalR JavaScript client in the `<script>` element. For example:
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<script src="~/lib/signalr/signalr.js"></script>
|
||||
```
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ Reference the SignalR JavaScript client in the `<script>` element. For example:
|
|||
|
||||
[Reconnect Clients Docs](https://docs.microsoft.com/en-us/aspnet/core/signalr/javascript-client#reconnect-clients)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
const connection = new signalR.HubConnectionBuilder()
|
||||
.withUrl("/hub/endpoint")
|
||||
.configureLogging(signalR.LogLevel.Information)
|
||||
|
|
@ -158,7 +158,7 @@ JavaScript clients call public methods on hubs via the `invoke` method of the `H
|
|||
- The name of the hub method.
|
||||
- Any arguments defined in the hub method.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
try {
|
||||
await connection.invoke("HubMethod", args);
|
||||
} catch (err) {
|
||||
|
|
@ -177,6 +177,6 @@ To receive messages from the hub, define a method using the `on` method of the `
|
|||
- The name of the JavaScript client method.
|
||||
- Arguments the hub passes to the method.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
connection.on("ClientMethod", (args) => { /* ... */});
|
||||
```
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
The fist loaded page is `Default.aspx` and its underlying code.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- directive -->
|
||||
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="Project.Default" %>
|
||||
|
||||
|
|
@ -26,7 +26,7 @@ The fist loaded page is `Default.aspx` and its underlying code.
|
|||
|
||||
### Page Directive
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
<%@ Page Language="C#" // define language used (can be C# or VB)
|
||||
AutoEventWireup="true" // automatically create and setup event handlers
|
||||
CodeBehind="Default.aspx.cs" // define the underlying code file
|
||||
|
|
@ -35,7 +35,7 @@ The fist loaded page is `Default.aspx` and its underlying code.
|
|||
|
||||
### Web Controls
|
||||
|
||||
```xml
|
||||
```xml linenums="1"
|
||||
<asp:Control ID="" runat="server" ...></asp:Control>
|
||||
|
||||
<!-- Label: empty text will diplay ID, use empty space as text for empty label -->
|
||||
|
|
@ -59,7 +59,7 @@ The fist loaded page is `Default.aspx` and its underlying code.
|
|||
|
||||
## `Page.aspx.cs`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public partial class Default : System.Web.UI.Page
|
||||
{
|
||||
protected void Page_Load(object sender, EventArgs e)
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ In performance-sensitive code, asynchronous APIs are useful, because instead of
|
|||
|
||||
The `async` and `await` keywords in C# are the heart of async programming.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public async Task<TResult> MethodAsync
|
||||
{
|
||||
Task<TResult> resultTask = obj.OtherMethodAsync();
|
||||
|
|
@ -90,7 +90,7 @@ Because `Task` and `Task<TResult>` are **reference types**, memory allocation in
|
|||
|
||||
### Async Composition
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public async Task DoOperationsConcurrentlyAsync()
|
||||
{
|
||||
Task[] tasks = new Task[3];
|
||||
|
|
@ -132,7 +132,7 @@ If work starting from a UI thread is performed, but there is no particular need
|
|||
If the asynchronous operation is a `Task`, `Task<T>`, `ValueTask` or `ValueTask<T>`, it's possible to discard the *synchronization context* by calling the `ConfigureAwait(false)`.
|
||||
This returns a different representation of the asynchronous operation, and if this iss awaited that instead of the original task, it will ignore the current `SynchronizationContext` if there is one.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
private async Task DownloadFileAsync(string fileName)
|
||||
{
|
||||
await OperationAsync(fileName).ConfigureAwait(false); // discarding original context
|
||||
|
|
@ -156,7 +156,7 @@ This is true even of exceptions thrown before the first `await`.
|
|||
If the calling method immediately calls `await` on the return task, this won’t matter much—it will see the exception in any case.
|
||||
But some code may choose not to wait immediately, in which case it won’t see the argument exception until later.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
async Task<string> MethodWithValidationAsync(string argument)
|
||||
{
|
||||
if(sting.IsNullOrEmpty(argument))
|
||||
|
|
@ -173,7 +173,7 @@ async Task<string> MethodWithValidationAsync(string argument)
|
|||
In cases where you want to throw this kind of exception straightaway, the usual technique is to write a normal method that validates the arguments before calling an async method that does the
|
||||
work, and to make that second method either private or local.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// not marked with async, exception propagate directly to caller
|
||||
public static Task<string> MethodWithValidationAsync(string argument)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ An array is an object that contains multiple elements of a particular type. The
|
|||
|
||||
An array type is always a reference type, regardless of the element type. Nonetheless, the choice between reference type and value type elements makes a significant difference in an array's behavior.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
type[] array = new type[dimension];
|
||||
type array[] = new type[dimension]; //invalid
|
||||
|
||||
|
|
@ -24,7 +24,7 @@ array.OfType<Type>(); // filter array based on type, returns IEnumerable<Type>
|
|||
|
||||
### [Array Methods](https://docs.microsoft.com/en-us/dotnet/api/system.array?view=netcore-3.1#methods)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// overloaded search methods
|
||||
Array.IndexOf(array, item); // return index of searched item in passed array
|
||||
Array.LastIndexOf(array, item); // return index of searched item staring from the end of the array
|
||||
|
|
@ -54,7 +54,7 @@ C# supports two multidimensional array forms: [jagged][jagg_arrays] arrays and [
|
|||
[jagg_arrays]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/arrays/jagged-arrays
|
||||
[rect_arrays]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/arrays/multidimensional-arrays
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
//specify first dimension
|
||||
type[][] jagged = new type[][]
|
||||
{
|
||||
|
|
@ -87,7 +87,7 @@ matrix.GetLength(int dimension); // get the size of a particular direction
|
|||
|
||||
`List<T>` stores sequences of elements. It can grow or shrink, allowing to add or remove elements.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using System.Collections.Generics;
|
||||
|
||||
List<T> list = new List<T>();
|
||||
|
|
@ -140,7 +140,7 @@ It's possible to use a `yield break` statement or exception to end the iteration
|
|||
|
||||
**Note**: Since an iterator returns an `IEnumerable<T>` is can be used to implement a `GetEnumerator()`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// simple iterator
|
||||
public static System.Collections.IEnumerable<int> IterateRange(int start = 0, int end)
|
||||
{
|
||||
|
|
@ -156,7 +156,7 @@ public static System.Collections.IEnumerable<int> IterateRange(int start = 0, in
|
|||
|
||||
Exposes the enumerator, which supports a simple iteration over a collection of a specified type.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public interface IEnumerable<out T> : IEnumerable
|
||||
{
|
||||
IEnumerator<T> GetEnumerator(); // return an enumerator
|
||||
|
|
@ -179,7 +179,7 @@ public interface IEnumerator<T>
|
|||
|
||||
### [`ICollection<T>`](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.icollection-1)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public interface ICollection<T> : IEnumerable<T>
|
||||
{
|
||||
// properties
|
||||
|
|
@ -197,7 +197,7 @@ public interface ICollection<T> : IEnumerable<T>
|
|||
|
||||
### [`IList<T>`](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.ilist-1)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public interface IList<T> : ICollection<T>, IEnumerable<T>
|
||||
{
|
||||
// properties
|
||||
|
|
@ -228,7 +228,7 @@ public interface IList<T> : ICollection<T>, IEnumerable<T>
|
|||
- Enumerating a dictionary will return `KeyValuePair<TKey, TValue>`.
|
||||
- The `Dictionary<TKey, TValue>` collection class relies on hashes to offer fast lookup (`TKey` should have a good `GetHashCode()`).
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Dictionary<TKey, TValue> dict = new Dictionary<TKey, TValue>(); // init empty dict
|
||||
Dictionary<TKey, TValue> dict = new Dictionary<TKey, TValue>(IEqualityComparer<TKey>); // specify key comparer (TKey must implement Equals() and GetHashCode())
|
||||
|
||||
|
|
@ -270,7 +270,7 @@ dict.TryGetValue(key, out var); // put the value associated with kay in the var
|
|||
|
||||
Collection of non duplicate items.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
HashSet<T> set = new HashSet<T>();
|
||||
|
||||
set.Add(T); // adds an item to the set; true if the element is added, false if the element is already present.
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ to native code later.
|
|||
|
||||
### Comments
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// comment
|
||||
/* multi line comment */
|
||||
/// single line xml comment (docstring)
|
||||
|
|
@ -44,7 +44,7 @@ to native code later.
|
|||
|
||||
Hierarchic organization of programs an libraries.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using System; // import the System Namespace
|
||||
using Alias = Namespace; // set an alias for a specific namespace
|
||||
using static System.Console; // statically import a class to use its static methods w/o qualification
|
||||
|
|
@ -62,13 +62,13 @@ namespace Namespace // namespace declaration
|
|||
|
||||
To enable .NET 6/C# 10 **implicit namespace imports**:
|
||||
|
||||
```xml
|
||||
```xml linenums="1"
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
```
|
||||
|
||||
### Top Level Statements/Programs (C# 9)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// imports
|
||||
|
||||
// code here, no main, no namespace
|
||||
|
|
@ -76,7 +76,7 @@ To enable .NET 6/C# 10 **implicit namespace imports**:
|
|||
|
||||
### Main Method
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public static void Main(string[] args)
|
||||
{
|
||||
// code here
|
||||
|
|
@ -85,7 +85,7 @@ public static void Main(string[] args)
|
|||
|
||||
### Constant Declaration
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
const type CONSTANT_NAME = value;
|
||||
```
|
||||
|
||||
|
|
@ -97,7 +97,7 @@ If a variable has not been assigned it assumes the `default` value.
|
|||
|
||||
### Input
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// input is a string, convert before saving in a non String variable
|
||||
Console.ReadLines(); // read util <Return> is pressed
|
||||
Console.Read(); // read until space
|
||||
|
|
@ -115,7 +115,7 @@ Console.ReadKey(); // read a key from keyboard and display pressed kay immedi
|
|||
|
||||
### Screen Output
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Console.WriteLine(); // single line output
|
||||
```
|
||||
|
||||
|
|
@ -123,7 +123,7 @@ Console.WriteLine(); // single line output
|
|||
|
||||
`{index[,alignment][:<formatString><num_decimal_digits>]}`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Console.WriteLine("Name is {0}, Marks are {1}", name, marks); // string composite formatting
|
||||
Console.WriteLine($"Name is {name}, Marks are {marks}"); // string interpolation
|
||||
|
||||
|
|
@ -197,7 +197,7 @@ The static fields and methods of the `MathF` class correspond to those of the `M
|
|||
`BigInteger` represents an integer that will grow as large as is necessary to accommodate values.
|
||||
Unlike the builtin numeric types, it has no theoretical limit on its range.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using System;
|
||||
using System.Numerics;
|
||||
|
||||
|
|
@ -209,7 +209,7 @@ BigInteger bi;
|
|||
Binary literal: `0b<digits>`
|
||||
Hexadecimal literal: `0x<digits>`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// three variables that store the number 2 million
|
||||
int decimalNotation = 2_000_000;
|
||||
int binaryNotation = 0b_0001_1110_1000_0100_1000_0000;
|
||||
|
|
@ -229,19 +229,19 @@ int hexadecimalNotation = 0x_001E_8480;
|
|||
|
||||
The compiler determines the required type based on the assigned value.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
var variable = value; // Inferred tipe cant change after first assignment
|
||||
```
|
||||
|
||||
### Dynamic Type
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
dynamic variable = value;
|
||||
```
|
||||
|
||||
### Anonymous types (Reference Type)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// cannot be used as return types
|
||||
var x = new { Key = value, ...}; // read only properties
|
||||
x.Key; // member access
|
||||
|
|
@ -257,7 +257,7 @@ A [System.Range][range_type] represents a range that has start and end indexes.
|
|||
[index_type]: https://docs.microsoft.com/en-us/dotnet/api/system.index
|
||||
[range_type]: https://docs.microsoft.com/en-us/dotnet/api/system.range
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Index i = position;
|
||||
Index i = new Index(position, IsFromEnd: false); // start-relative index
|
||||
|
||||
|
|
@ -285,7 +285,7 @@ Tuples are designed as a convenient way to package together a few values in case
|
|||
Tuples support comparison, so it's possible to use the `==` and `!=` relational operators.
|
||||
To be considered equal, two tuples must have the same shape and each value in the first tuple must be equal to its counterpart in the second tuple.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
(Type Var1, Type Var2, ...) variable = (value1, value2, ...);
|
||||
var variable = (Var1: value1, Var2: value2, ...); // if name are not supplied they default to Item1, Item2, ...
|
||||
var variable = (var1, var2); // constructed w/ pre-existing values, tuple attributes named after the variables
|
||||
|
|
@ -293,14 +293,14 @@ var variable = (var1, var2); // constructed w/ pre-existing values, tuple attri
|
|||
|
||||
Since the names of the attributes of a tuple do not matter (a tuple is an instance of `ValueTuple<Type, Type, ...>`) it's possible to assign any tuple to another tuple with the same structure.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
(int X, Int Y) a = (1 , 0);
|
||||
(int Width, int Height) b = a;
|
||||
```
|
||||
|
||||
### Tuple Deconstruction
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
(int X, int Y) point = (10, 35);
|
||||
(int a, int b) = point; // extract data based on position into two variables
|
||||
```
|
||||
|
|
@ -309,7 +309,7 @@ Since the names of the attributes of a tuple do not matter (a tuple is an instan
|
|||
|
||||
I'ts possible to create record types with immutable properties by using standard property syntax or positional parameters:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public record Person
|
||||
{
|
||||
public string FirstName { get; init; } = default!;
|
||||
|
|
@ -330,7 +330,7 @@ public readonly record struct Point(double X, double Y, double Z);
|
|||
|
||||
it's also possible to create record types with mutable properties and fields:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// mutable record
|
||||
public record Person
|
||||
{
|
||||
|
|
@ -358,7 +358,7 @@ While records can be mutable, they're primarily intended for supporting immutabl
|
|||
When working with immutable data, a common pattern is to create new values from existing ones to represent a new state.
|
||||
To help with this style of programming, records allow for a new kind of expression; the with-expression.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
var newRecord = oldRecord with { Property = value };
|
||||
```
|
||||
|
||||
|
|
@ -366,7 +366,7 @@ With-expressions use object initializer syntax to state what's different in the
|
|||
A record implicitly defines a protected "copy constructor", a constructor that takes an existing record object and copies it field by field to the new one.
|
||||
The `with` expression causes the copy constructor to get called, and then applies the object initializer on top to change the properties accordingly.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
protected Record(Record original) { /* copy all the fields */ } // generated
|
||||
```
|
||||
|
||||
|
|
@ -378,7 +378,7 @@ Records have a hidden virtual method that is entrusted with "cloning" the whole
|
|||
Every derived record type overrides this method to call the copy constructor of that type, and the copy constructor of a derived record chains to the copy constructor of the base record.
|
||||
A with-expression simply calls the hidden "clone" method and applies the object initializer to the result.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public record Base{ Type Prop1, Type Prop2 };
|
||||
public record Derived : Base { Type Prop3 };
|
||||
|
||||
|
|
@ -391,7 +391,7 @@ var newBase = @base with { Prop2 = value }; // new Derived record even if type
|
|||
Records have a virtual protected property called `EqualityContract`.
|
||||
Every derived record overrides it, and in order to compare equal, the two objects musts have the same `EqualityContract`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public record Base{ Type Prop1, Type Prop2 };
|
||||
public record Derived : Base { Type Prop3 };
|
||||
|
||||
|
|
@ -408,7 +408,7 @@ This creates a lot of extra work for .NET's garbage collector, causing the progr
|
|||
|
||||
In these situations, it's possible to can use a type called `StringBuilder`. This is conceptually similar to a string but it is modifiable.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
"string contents here" // string literal
|
||||
@"string contents here" // verbatim string, escape characters printed as-is (raw string literal)
|
||||
$"{variable} contents here" // string interpolation
|
||||
|
|
@ -419,7 +419,7 @@ String.Length // returns the length of the string
|
|||
|
||||
### String Methods (Not In-Place)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
string_.IndexOf(<character/string>, startIndex, endIndex); // index of first occurrence of character/string, -1 otherwise
|
||||
string_.LastIndexOf(<character/string>, startIndex, endIndex); // index last occurrence of character/string, -1 otherwise
|
||||
string_.IndexOfAny(char_array, startIndex, endIndex); // index of any of the characters in the supplied array
|
||||
|
|
@ -454,7 +454,7 @@ A raw string literal starts with at least three double-quote (`"""`) characters.
|
|||
Typically, a raw string literal uses three double quotes on a single line to start the string, and three double quotes on a separate line to end the string.
|
||||
The newlines following the opening quote and preceding the closing quote aren't included in the final content:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
|
||||
string longMessage = """
|
||||
This is a long message.
|
||||
|
|
@ -470,7 +470,7 @@ string longMessage = """
|
|||
|
||||
Raw string literals can be combined with _string interpolation_ to include braces in the output text. Multiple `$` characters denote how many consecutive braces start and end the interpolation
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
var location = $$"""
|
||||
You are at {{{Longitude}}, {{Latitude}}}
|
||||
""";
|
||||
|
|
@ -493,7 +493,7 @@ When a nullable type is boxed, the common language runtime automatically boxes t
|
|||
|
||||
If the `HasValue` property of a nullable type is `false`, the result of a boxing operation is `null`. Consequently, if a boxed nullable type is passed to a method that expects an object argument, that method must be prepared to handle the case where the argument is `null`. When `null` is unboxed into a nullable type, the common language runtime creates a new `Nullable<T>` structure and initializes its `HasValue` property to `false`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Type? nullableValueType = default; // assigns null
|
||||
|
||||
nullableValueType.HasValue // boolean, use for null check
|
||||
|
|
@ -545,7 +545,7 @@ Valid settings are:
|
|||
|
||||
In `Project.csproj`:
|
||||
|
||||
```xml
|
||||
```xml linenums="1"
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
|
|
@ -559,7 +559,7 @@ In `Project.csproj`:
|
|||
|
||||
In `Program.cs`:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
#nullable enable // Sets the nullable annotation context and nullable warning context to enabled.
|
||||
#nullable disable // Sets the nullable annotation context and nullable warning context to disabled.
|
||||
#nullable restore // Restores the nullable annotation context and nullable warning context to the project settings.
|
||||
|
|
@ -573,7 +573,7 @@ In `Program.cs`:
|
|||
|
||||
### Null Conditional, Null Coalescing, Null Forgiving Operator, Null Checks
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Type? variable = null; // the variable can also contain the NULL value (nullable type)
|
||||
|
||||
<expr>! // declare explicitly that the expression is not null (null forgiving operator)
|
||||
|
|
@ -624,7 +624,7 @@ That information helps the compiler perform static analysis and determine when a
|
|||
|
||||
## Type Conversion
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
variable.GetType(); // System type of variable
|
||||
|
||||
(type) variable // explicit conversion
|
||||
|
|
@ -677,7 +677,7 @@ The _.NET SDK_ defines certain symbols by default. It supports two configuration
|
|||
It defines a `DEBUG` compilation symbol in the Debug configuration, whereas Release will define `RELEASE` instead.
|
||||
It defines a symbol called `TRACE` in both configurations.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
#if DEBUG
|
||||
// instructions
|
||||
#endif
|
||||
|
|
@ -687,7 +687,7 @@ C# provides a more subtle mechanism to support this sort of thing, called a _con
|
|||
The compiler recognizes an attribute defined by the .NET class libraries, called `ConditionalAttribute`, for which it provides special compile time behavior.
|
||||
Method annotated with this attribute will not be present in a non-Debug release.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
[System.Diagnostics.Conditional("DEBUG")]
|
||||
Type Method() { ... }
|
||||
```
|
||||
|
|
@ -696,7 +696,7 @@ Type Method() { ... }
|
|||
|
||||
C# allows choose to generate _compiler errors_ or warnings with the `#error` and `#warning` directives. These are typically used inside conditional regions.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
#if NETSTANDARD
|
||||
#error .NET Standard is not a supported target for this source file
|
||||
#endif
|
||||
|
|
@ -707,7 +707,7 @@ C# allows choose to generate _compiler errors_ or warnings with the `#error` and
|
|||
The `#pragma` directive provides two features: it can be used to disable selected compiler warnings, and it can also be used to override the checksum values the compiler puts into the `.pdb` file it generates containing debug information.
|
||||
Both of these are designed primarily for code generation scenarios, although they can occasionally be useful to disable warnings in ordinary code.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
#pragma warning disable CS<number>
|
||||
```
|
||||
|
||||
|
|
@ -806,7 +806,7 @@ Both of these are designed primarily for code generation scenarios, although the
|
|||
|
||||
### `If`-`Else If`-`Else`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Object o;
|
||||
|
||||
if (condition)
|
||||
|
|
@ -829,7 +829,7 @@ else
|
|||
|
||||
A pattern describes one or more criteria that a value can be tested against. It's usable in switch statements, switch expressions and if statements.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// type pattern
|
||||
<expr> is Type t // type pattern
|
||||
|
||||
|
|
@ -882,7 +882,7 @@ The `when` keyword can be used to specify a filter condition that causes its ass
|
|||
|
||||
[Switch Expressions](https://dotnetcoretutorials.com/2019/06/25/switch-expressions-in-c-8/)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
switch (expr)
|
||||
{
|
||||
// multiple labels for same block
|
||||
|
|
@ -921,7 +921,7 @@ variable switch
|
|||
|
||||
### `While` Loop
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
while (condition)
|
||||
{
|
||||
// code here
|
||||
|
|
@ -932,7 +932,7 @@ while (condition)
|
|||
|
||||
Executes at least one time.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
do
|
||||
{
|
||||
// code here
|
||||
|
|
@ -942,7 +942,7 @@ while (condition);
|
|||
|
||||
### `For` Loop
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
for (initializer; condition; iterator)
|
||||
{
|
||||
// code here
|
||||
|
|
@ -959,7 +959,7 @@ Technically, the `foreach` statement will work on any type that follows these ru
|
|||
|
||||
There are interfaces named `IEnumerable` and `IEnumerable<T>` that formally define these rules but technically the compiler does not require the type to implement these interfaces.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
foreach (type item in iterabile)
|
||||
{
|
||||
// code here
|
||||
|
|
@ -971,7 +971,7 @@ foreach (type item in iterabile)
|
|||
|
||||
Example:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// make integers enumerable
|
||||
public static IEnumerator<int> GetEnumerator(this int source)
|
||||
{
|
||||
|
|
@ -989,14 +989,14 @@ public static IEnumerator<int> GetEnumerator(this int source)
|
|||
|
||||
### Yield Statement
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
yield return <expression>; // returns the results one at a time.
|
||||
yield break; // concludes the iteration
|
||||
```
|
||||
|
||||
### Context Statement & Using Declarations
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using (Type obj = new Type()) // obj disposed at the end of the using block
|
||||
{
|
||||
// code here
|
||||
|
|
@ -1020,7 +1020,7 @@ It is done by editing the `.csproj` file, adding `<CheckForOverflowUnderflow>tru
|
|||
|
||||
> **Note**: checking can make individual integer operations several times slower.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
checked
|
||||
{
|
||||
// code here
|
||||
|
|
@ -1042,7 +1042,7 @@ unchecked(<expr>);
|
|||
|
||||
[Exception Object](https://docs.microsoft.com/en-us/dotnet/api/system.exception)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
try
|
||||
{
|
||||
// "dangerous" code
|
||||
|
|
@ -1068,7 +1068,7 @@ finally
|
|||
|
||||
### Throwing Exceptions
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
throw new ExceptionClass();
|
||||
throw new ExceptionClass("message");
|
||||
|
||||
|
|
@ -1089,7 +1089,7 @@ Environment.FailFast(causeOfFailure);
|
|||
|
||||
### Custom Exceptions
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class CustomException : Exception // must derive from Exception (either directly or indirectly)
|
||||
{
|
||||
public CustomException()
|
||||
|
|
@ -1115,7 +1115,7 @@ public class CustomException : Exception // must derive from Exception (either
|
|||
An enumeration type (or enum type) is a value type defined by a set of **named constants** of the underlying _integral numeric_ type (`int`, `long`, `byte`, ...).
|
||||
Consecutive names increase the value by one.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
[Flags] // indicate that the flag can be combined (best if values are binary) as a bit mask
|
||||
enum EnumType : IntegralNumericType // named values MUST match IntegerNumericType allowed values
|
||||
{
|
||||
|
|
@ -1150,7 +1150,7 @@ The method signature is the number & type of the input parameters defined for th
|
|||
C# makes the fairly common distinction between _parameters_ and _arguments_: a method defines a list of the inputs it expects (the parameters) and the code inside the method refers to these parameters by name.
|
||||
The values seen by the code could be different each time the method is invoked, and the term argument refers to the specific value supplied for a parameter in a particular invocation.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
type MethodName (type parameter, ...)
|
||||
{
|
||||
// code here
|
||||
|
|
@ -1165,13 +1165,13 @@ void MethodName (type parameter, ...) {
|
|||
|
||||
### Expression Body Definition
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
type MethodName() => <expression>; // expression result type MUST match method type
|
||||
```
|
||||
|
||||
### Arbitrary Number Of Parameter In Methods
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// params keyword must be last parameter and must be an array
|
||||
type MethodName (type parameter, params type[] args)
|
||||
{
|
||||
|
|
@ -1181,7 +1181,7 @@ type MethodName (type parameter, params type[] args)
|
|||
|
||||
### [Named Arguments](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments#named-arguments)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
type MethodName (type param1, type param2, ...) { }
|
||||
|
||||
MethodName(param1: value, param2: value);
|
||||
|
|
@ -1205,7 +1205,7 @@ A default value must be one of the following types of expressions:
|
|||
- an expression of the form new ValType(), where ValType is a value type, such as an enum or a struct;
|
||||
- an expression of the form default(ValType), where ValType is a value type.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
type MethodName (type required, type firstOptional = default_value, type secondOptional = default_value, ...) { }
|
||||
MethodName(value1); // use defaults for optional arguments
|
||||
MethodName(required: value, secondOptional: value); // use default for first optional but pass second optional
|
||||
|
|
@ -1238,7 +1238,7 @@ Use cases:
|
|||
While the method can use members of the passed reference type, it can't normally replace it with a different object.
|
||||
But if a reference type argument is marked with ref, the method has access to the variable, so it could replace it with a reference to a completely different object.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// method declaration
|
||||
type MethodName (type param1, ref type param2, out type param3, in type param4, ...)
|
||||
{
|
||||
|
|
@ -1258,7 +1258,7 @@ OutMethod(arg1, out var arg2); // create out variable on the fly
|
|||
**Must** be C# 7+.
|
||||
The retuned tuple MUST match the tuple-type in the instantiation
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
(type returnedVar1, type returnedVar2, ...) MethodName (type parameter, ...)
|
||||
{
|
||||
// code here
|
||||
|
|
@ -1268,7 +1268,7 @@ The retuned tuple MUST match the tuple-type in the instantiation
|
|||
|
||||
### Returning Multiple Values W/ Structs (Return Struct Variable)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
StructName MethodName (args)
|
||||
{
|
||||
// code here
|
||||
|
|
@ -1282,7 +1282,7 @@ StructName MethodName (args)
|
|||
|
||||
### Local Functions
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
type OuterMethod(...)
|
||||
{
|
||||
var foo = InnerMethod();
|
||||
|
|
@ -1299,7 +1299,7 @@ It's just an illusion maintained by the C# compiler, one that it keeps up even i
|
|||
|
||||
> **Note**: Extension Method can be declared only inside static classes. Extension methods are available only if their namespace is imported with the `using` keyword.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public static class ExtensionMethods
|
||||
{
|
||||
type ExtensionMethod(this type param)
|
||||
|
|
@ -1325,7 +1325,7 @@ It's possible to use a `yield break` statement or exception to end the iteration
|
|||
|
||||
> **Note**: Since an iterator returns an `IEnumerable<T>` is can be used to implement a `GetEnumerator()`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// simple iterator
|
||||
public static System.Collections.IEnumerable<int> IterateRange(int start = 0, int end)
|
||||
{
|
||||
|
|
@ -1358,7 +1358,7 @@ Modifiable value types tend to be problematic, because it's all too easy to end
|
|||
So it's usually a good idea for value types to be immutable. This doesn't mean that variables of these types cannot be modified;
|
||||
it just means that to modify the variable, its contents must be replaced entirely with a different value.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public struct Point
|
||||
{
|
||||
public Point(double x, double y)
|
||||
|
|
@ -1387,7 +1387,7 @@ If you attempt to access the variable outside of the code block, you'll get a co
|
|||
|
||||
[Access Modifiers](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// ACCESS MODIFIERS
|
||||
public // visible from everywhere
|
||||
private // not visible outside of the class (default for members)
|
||||
|
|
@ -1426,7 +1426,7 @@ A _property_ is a member that provides a flexible mechanism to read, write, or c
|
|||
|
||||
The `static` keyword declares that a member is not associated with any particular instance of the class.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
class Class
|
||||
{
|
||||
// if static contractor exists the initializer is runned immediately before the static constructor,
|
||||
|
|
@ -1473,7 +1473,7 @@ class Class
|
|||
|
||||
[Properties Docs](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
class Class
|
||||
{
|
||||
private type _backingField;
|
||||
|
|
@ -1525,7 +1525,7 @@ Because `init` accessors can only be called during initialization, they are allo
|
|||
**Object initializers** allow to assign values to any accessible fields or properties of an object at creation time without having to invoke a constructor followed by lines of assignment statements.
|
||||
The object initializer syntax enables to specify arguments for a constructor or omit the arguments (and parentheses syntax).
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class Class
|
||||
{
|
||||
// Auto-implemented properties.
|
||||
|
|
@ -1557,7 +1557,7 @@ Class obj = new Class(arg1) { Prop2 = arg2 }; // w/ constructor
|
|||
var copy = original with { Prop = newValue }; // other props are copies of the original
|
||||
```
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class Matrix
|
||||
{
|
||||
private double[,] matrix = new double[3, 3];
|
||||
|
|
@ -1593,7 +1593,7 @@ List<int> digits = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
|||
|
||||
Static classes **can't** instantiate objects and all their methods **must** be static.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
static class Class
|
||||
{
|
||||
static type variable = value;
|
||||
|
|
@ -1625,7 +1625,7 @@ static class Class
|
|||
An **indexer** is a property that takes one or more arguments, and is accessed with the same syntax as is used for arrays.
|
||||
This is useful when writing a class that contains a collection of objects.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class Class<T>
|
||||
{
|
||||
public T this[int i]
|
||||
|
|
@ -1671,7 +1671,7 @@ Members marked as `abstract` must be implemented by non-abstract classes that de
|
|||
- It is an error to use the `abstract` modifier on a `static` property.
|
||||
- An `abstract` inherited property can be overridden in a derived class by including a property declaration that uses the `override` modifier.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public abstract class Abstract : Interface
|
||||
{
|
||||
public abstract Type Property { get; set; }
|
||||
|
|
@ -1696,7 +1696,7 @@ public class Derived : Abstract
|
|||
|
||||
### Cloning
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Class obj = new Class()
|
||||
|
||||
Object.MemberwiseClone(); // Returns shallow copy of the object
|
||||
|
|
@ -1709,7 +1709,7 @@ Deconstruction is not limited to tuples. By providing a `Deconstruct(...)` metho
|
|||
|
||||
> **Note**: Types with a deconstructor can also use _positional pattern matching_.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public readonly struct Size
|
||||
{
|
||||
public Size(double w, double h)
|
||||
|
|
@ -1762,7 +1762,7 @@ Use the operator keyword to declare an operator. An operator declaration must sa
|
|||
|
||||
[Overloadable operators](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading#overloadable-operators)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using System;
|
||||
|
||||
public readonly struct Fraction
|
||||
|
|
@ -1852,7 +1852,7 @@ An interface is effectively a list of the members that a type will need to provi
|
|||
|
||||
C# 8.0 adds the ability to define default implementations for some or all methods, and also to define nested types and static fields.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// can only be public or internal if not nested, any accessibility otherwise
|
||||
public interface IContract
|
||||
{
|
||||
|
|
@ -1909,7 +1909,7 @@ which is effectively an object that holds a copy of a struct in a way that can b
|
|||
[Generics Docs](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/)
|
||||
[Generic Methods Docs](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/generic-methods)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// type parameter T in angle brackets
|
||||
// WARNING: T is not instantiable, new t(), new t[] are INVALID
|
||||
public class GenericClass<T> {
|
||||
|
|
@ -1936,7 +1936,7 @@ obj.GenericMethodName(Type param); // type deduced by input, input type and gen
|
|||
|
||||
### Multiple Generics
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class GenericClass<T1, T2, ...> { } // number of generic types is not limited
|
||||
```
|
||||
|
||||
|
|
@ -1953,7 +1953,7 @@ C# supports only six kinds of constraints on a type argument:
|
|||
- `unmanaged`
|
||||
- `new()`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// type constraints
|
||||
public class GenericClass<T> where T : Interface { }
|
||||
public class GenericClass<T> where T: GenericClass { }
|
||||
|
|
@ -2002,7 +2002,7 @@ both public and private—an instance of the derived class can do anything an in
|
|||
> **Note**: When deriving from a class, it's not possible to make the derived class more visible than its base. This restriction does not apply to interfaces.
|
||||
A `public` class is free to implement `internal` or `private` interfaces. However, it does apply to an interface's bases: a `public` interface cannot derive from an `internal` interface.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
class BaseClass
|
||||
{
|
||||
public virtual Property { get; set; }
|
||||
|
|
@ -2027,7 +2027,7 @@ class ChildClass : BaseClass, Interface, Interface<Type>
|
|||
|
||||
Downcasting is the conversion from a base class type to one of it's derived types.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Base b;
|
||||
var d = (Derived) b; // explicit casting (if conversion fails throws InvalidCastException)
|
||||
var d = b as Derived; // as operator (if conversion fails AS will return NULL)
|
||||
|
|
@ -2048,7 +2048,7 @@ Initialization order:
|
|||
3. Base class constructor
|
||||
4. Derived class constructor
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class Base
|
||||
{
|
||||
public Base(Type param) {}
|
||||
|
|
@ -2066,7 +2066,7 @@ public class Derived
|
|||
If you derive from a generic class, you must supply the type arguments it requires.
|
||||
You must provide concrete types unless your derived type is generic, in which case it can use its own type parameters as arguments.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class GenericBase1<T>
|
||||
{
|
||||
public T Item { get; set; }
|
||||
|
|
@ -2085,7 +2085,7 @@ public class MixedDerived<T> : GenericBase2<T, Type> // derived is generic but
|
|||
|
||||
It's allowed to use derived type as a type argument to the base class. And it's also possible to specify a constraint on a type argument requiring it to derive from the derived type.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class Derived : base<Derived> {}
|
||||
public class Derived<T> where T : Derived<T>
|
||||
```
|
||||
|
|
@ -2105,7 +2105,7 @@ Generic type parameters support covariance and contravariance to provide greater
|
|||
|
||||
> **Note**: annotate generic type parameters with `out` and `in` annotations to specify whether they should behave covariantly or contravariantly.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class Base {};
|
||||
public class Derived : Base {}
|
||||
|
||||
|
|
@ -2147,7 +2147,7 @@ This ability to refer to a method as a parameter makes delegates ideal for defin
|
|||
Any method from any accessible class or struct that matches the delegate type can be assigned to the delegate. The method can be either static or an instance method.
|
||||
This makes it possible to programmatically change method calls, and also plug new code into existing classes.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// delegate definition
|
||||
public delegate Type Delegate(Type param, ...); // can take any method with specified type params and return type
|
||||
public delegate Type Delegate<T>(T param); // generic delegate
|
||||
|
|
@ -2161,7 +2161,7 @@ Delegate<Type> delegate = Method; // implicit creation
|
|||
|
||||
**Multicast Delegates** are delegates that can have more than one element in their invocation list.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Delegate<Type> multicastDelegate = Method1 + Method2 + ...; // multicast delegate creation
|
||||
multicastDelegate += Method; // add method to delegate
|
||||
multicastDelegate -= Method; // remove method from delegate
|
||||
|
|
@ -2175,7 +2175,7 @@ Subtraction of a multicast delegate succeeds only if the delegate from which sub
|
|||
Invoking a delegate with a single target method works as though the code had called the target method in the conventional way.
|
||||
Invoking a multicast delegate is just like calling each of its target methods in turn.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Delegate<Type> delegate = Method;
|
||||
|
||||
delegate(args); // use delegate as standard method
|
||||
|
|
@ -2188,7 +2188,7 @@ multicastDelegate.GetInvocationList(); // list of methods called by the delegat
|
|||
|
||||
> **Note**: Each delegate has an overload taking from zero to 16 arguments;
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public delegate void Action<in T1, ...>(T1 arg1, ...);
|
||||
public delegate TResult Func<in T1, ..., out TResult>(T1 arg1, ...);
|
||||
public delegate bool Predicate<in T1, ...>(T1 arg1, ...);
|
||||
|
|
@ -2203,7 +2203,7 @@ However, the type system supports certain implicit reference conversions for gen
|
|||
|
||||
Delegates without explicit separated method.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// lambda variations
|
||||
Delegate<Type> lambda = () => <expr>;
|
||||
Delegate<Type> lambda = input => <expr>;
|
||||
|
|
@ -2240,7 +2240,7 @@ Structs and classes can declare events. This kind of member enables a type to pr
|
|||
The class who raises events is called _Publisher_, and the class who receives the notification is called _Subscriber_. There can be multiple subscribers of a single event.
|
||||
Typically, a publisher raises an event when some action occurred. The subscribers, who are interested in getting a notification when an action occurred, should register with an event and handle it.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public delegate void EventDelegate(object sender, CustomEventArgs args); // called on event trigger
|
||||
|
||||
public class Publisher
|
||||
|
|
@ -2257,7 +2257,7 @@ public class Publisher
|
|||
|
||||
### Registering Event Handlers
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class Subscriber
|
||||
{
|
||||
Publisher publisher = new Publisher();
|
||||
|
|
@ -2278,7 +2278,7 @@ public class Subscriber
|
|||
Typically, any event should include two parameters: the _source_ of the event and event _data_.
|
||||
The `EventHandler` delegate is used for all events that do not include event data, the `EventHandler<TEventArgs>` delegate is used for events that include data to be sent to handlers.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class Publisher
|
||||
{
|
||||
public event EventHandler Event;
|
||||
|
|
@ -2304,7 +2304,7 @@ public class Subscriber
|
|||
|
||||
### Custom Event Args
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public class CustomEventArgs : EventArgs { }
|
||||
|
||||
public class Publisher
|
||||
|
|
@ -2485,7 +2485,7 @@ To be used as an attribute, a type must derive from the `System.Attribute` class
|
|||
|
||||
It's possible to pass arguments to the attribute _constructor_ in the annotation.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
[AttName] // simple attribute
|
||||
|
||||
[AttName(value)] // valorize private fields (through the constructor)
|
||||
|
|
@ -2496,7 +2496,7 @@ It's possible to pass arguments to the attribute _constructor_ in the annotation
|
|||
|
||||
### Multiple Attributes
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
[Attribute1]
|
||||
[Attribute2]
|
||||
|
||||
|
|
@ -2505,7 +2505,7 @@ It's possible to pass arguments to the attribute _constructor_ in the annotation
|
|||
|
||||
### Defining Custom Attribute Types
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// specify what the attribute can be applied to (enforced by c# compiler)
|
||||
[AttributeUsage(AttributeTargets.<TargetType>)]
|
||||
public class CustomAttribute : Attribute
|
||||
|
|
@ -2523,7 +2523,7 @@ public class CustomAttribute : Attribute
|
|||
It's possible to discover which attributes have been applied through the reflection API.
|
||||
The various targets of attribute have a reflection type representing them (`MethodInfo`, `PropertyInfo`, ...) which all implement the interface `ICustomAttributeProvider`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public interface ICustomAttributeProvider
|
||||
{
|
||||
object[] GetCustomAttributes(bool inherit);
|
||||
|
|
@ -2542,7 +2542,7 @@ A console application uses streams to represent its input and output.
|
|||
The `Stream` class is defined in the `System.IO` namespace.
|
||||
It is an abstract base class, with concrete derived types such as `FileStream` or `GZipStream` representing particular kinds of streams.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// The most important members of Stream
|
||||
public abstract int Read(byte[] buffer, int offset, int count);
|
||||
public abstract void Write(byte[] buffer, int offset, int count);
|
||||
|
|
@ -2571,7 +2571,7 @@ This is not guaranteed to work because it's not always possible to support it. S
|
|||
Stream also defines a Seek method, this allows to specify the position required relative to the stream's current position.
|
||||
Passing `SeekOrigin.Current` as second argument will set the position by adding the first argument to the current position.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public abstract long Seek(long offset, SeekOrigin origin); // offset can be negative
|
||||
```
|
||||
|
||||
|
|
@ -2602,7 +2602,7 @@ It's possible to constructing them by passing a `Stream` as a constructor argume
|
|||
|
||||
[Encoding](https://docs.microsoft.com/en-us/dotnet/api/system.text.encoding)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// Will detect encoding from stream contents
|
||||
StreamReader file = new StreamReader(string path);
|
||||
StreamReader file = new StreamReader(string path, System.Text.Encoding encoding); // encoding is System.Text.Encoding
|
||||
|
|
@ -2649,7 +2649,7 @@ The `FileStream` class derives from `Stream` and represents a file from the file
|
|||
It' common to use the constructors in which the `FileStream` uses OS APIs to create the file handle. It's possible to provide varying levels of detail on how this si to be done.
|
||||
At a minimum the file's path and a value from the `FileMode` enumeration must be provided.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// overloaded FileStream Constructors
|
||||
public FileStream(string path, FileMode mode);
|
||||
public FileStream(string path, FileMode mode, FileAccess access);
|
||||
|
|
@ -2693,7 +2693,7 @@ public FileStream(string path, FileMode mode, FileAccess access, FileShare share
|
|||
|
||||
> **Note**: The `WriteThrough` flag will ensure that when the stream is disposed or flushed, all the data written will have been delivered to the drive, but the drive will not necessarily have written that data persistently (drives can defer writing for performance), so data loss id still possible if the power fails.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// object to read or write to a file (file can be binary)
|
||||
{
|
||||
using(FileStream fstream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite))
|
||||
|
|
@ -2707,7 +2707,7 @@ public FileStream(string path, FileMode mode, FileAccess access, FileShare share
|
|||
|
||||
The static `File` class provides methods for performing various operations on files.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
File.Create(string path); // Return Read/Write FileStream to file
|
||||
File.Open(string path, System.IO.FileMode mode); // Open a FileStream on the specified path with read/write access with no sharing.
|
||||
File.Open(string path, System.IO.FileMode mode, System.IO.FileAccess access); // Opens a FileStream on the specified path, with the specified mode and access with no sharing.
|
||||
|
|
@ -2747,7 +2747,7 @@ File.Replace(string sourceFileName, string destinationFileName, string destinati
|
|||
|
||||
Exposes static methods for creating, moving, and enumerating through directories and subdirectories.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Directory.CreateDirectory(string path); // Create directory as specified
|
||||
Directory.Delete(string path); // Delete an empty directory from a specified path (dir must be writable)
|
||||
Directory.Delete(string path, bool recursive); // Delete the specified directory and, if indicated, any subdirectories and files in the directory
|
||||
|
|
@ -2775,7 +2775,7 @@ Directory.GetFileSystemEntries (string path, string searchPattern, SearchOption
|
|||
|
||||
### [Path](https://docs.microsoft.com/en-us/dotnet/api/system.io.path) Class
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Combine(string path1, string path2); // Combine two strings into a path
|
||||
Combine(string[] paths); // Combine strings into a path
|
||||
|
||||
|
|
@ -2822,7 +2822,7 @@ Classes to hold multiple info about a file or directory. If some property change
|
|||
|
||||
Types are required to opt into CLR serialization. .NET defines a `[Serializable]` attribute that must be present before the CLR will serialize the type (class).
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
[Serializable]
|
||||
class Class { }
|
||||
```
|
||||
|
|
@ -2839,7 +2839,7 @@ Serialization works directly with an object's fields. It uses reflection, which
|
|||
|
||||
Object that represents the difference between two dates
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
TimeSpan Interval = new DateTime() - new DateTime() // difference between dates
|
||||
|
||||
// constructors
|
||||
|
|
@ -2872,7 +2872,7 @@ length.
|
|||
|
||||
Access to a span contents is done like an and since a `Span<T>` knows its own length, its indexer checks that the index is in range, just as the built-in array type does.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Span<int> numbers = stackalloc int[] { 1, 2, 3 };
|
||||
var first = numbers[0];
|
||||
```
|
||||
|
|
@ -2912,7 +2912,7 @@ This makes these memory types useful when you want something span-like, but in a
|
|||
|
||||
[regex reference](https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Match match = Regex.Match(string, pattern, regexOptions);
|
||||
|
||||
match.Success; // whether there was a match or not
|
||||
|
|
@ -2949,7 +2949,7 @@ The `fixed` statement sets a pointer to a managed variable and "pins" that varia
|
|||
Pointers to movable managed variables are useful only in a fixed context. Without a fixed context, garbage collection could relocate the variables unpredictably.
|
||||
The C# compiler only allows to assign a pointer to a managed variable in a fixed statement.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
unsafe Type UnsafeMethod() { /* unsafe context */ }
|
||||
// or
|
||||
unsafe
|
||||
|
|
@ -2976,7 +2976,7 @@ unsafe
|
|||
|
||||
### Native Memory
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
unsafe
|
||||
|
|
@ -2993,7 +2993,7 @@ The `extern` modifier is used to declare a method that is implemented externally
|
|||
A common use of the extern modifier is with the `DllImport` attribute when using Interop services to call into _unmanaged_ code.
|
||||
In this case, the method must also be declared as `static`.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
[DllImport("avifil32.dll")]
|
||||
private static extern void AVIFileInit();
|
||||
```
|
||||
|
|
@ -3004,13 +3004,13 @@ Methods needed to implement a behaviour which do not need an interface to work.
|
|||
|
||||
### Enumerable
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public bool MoveNext(/* ... */);
|
||||
public T Current { get; }
|
||||
```
|
||||
|
||||
### Awaitable
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public TaskAwaiter GetAwaiter(/* ... */);
|
||||
```
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ LINQ to Objects will be used when any `IEnumerable<T>` is specified as the sourc
|
|||
All query expressions are required to begin with a `from` clause, which specifies the source of the query.
|
||||
The final part of the query is a `select` (or `group`) clause. This determines the final output of the query and its system type.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// query expression
|
||||
var result = from item in enumerable select item;
|
||||
|
||||
|
|
@ -35,7 +35,7 @@ var result = from item in enumerable group item by item.property; // returns IE
|
|||
The compiler converts all query expressions into one or more method calls. Once it has done that, the LINQ provider is selected through exactly the same mechanisms that C# uses for any other method call.
|
||||
The compiler does not have any built-in concept of what constitutes a LINQ provider.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
// expanded query expression
|
||||
var result = Enumerable.Where(item => condition).Select(item => item);
|
||||
```
|
||||
|
|
@ -44,7 +44,7 @@ The `Where` and `Select` methods are examples of LINQ operators. A LINQ operator
|
|||
|
||||
### Methods on `Enumerable` or `IEnumerable<T>`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Enumerable.Range(int start, int end); // IEnumerable<int> of values between start & end
|
||||
|
||||
IEnumerable<TSource>.Select(Func<TSource, TResult> selector); // map
|
||||
|
|
@ -77,7 +77,7 @@ IEnumerable<TFirst>.Zip(IEnumerable<TSecond> enumerable); // Produces a sequence
|
|||
|
||||
> **Note**: `Enumerable` provides a set of `static` methods for querying objects that implement `IEnumerable<T>`. Most methods are extensions of `IEnumerable<T>`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
Enumerable.Method(IEnumerable<T> source, args);
|
||||
// if extension method same as
|
||||
IEnumerable<T>.Method(args);
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ Because Rx implements standard LINQ operators, it's possible to write queries ag
|
|||
The two most important types in Rx are the `IObservable<T>` and `IObserver<T>` interfaces.
|
||||
They are important enough to be in the System namespace. The other parts of Rx are in the `System.Reactive` NuGet package.
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
public interface IObservable<out T>
|
||||
{
|
||||
IDisposable Subscribe(IObserver<T> observer);
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
## xUnit
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using System;
|
||||
using Xunit;
|
||||
|
||||
|
|
@ -37,7 +37,7 @@ For context cleanup, add the `IDisposable` interface to the test class, and put
|
|||
|
||||
## Mocking with Moq
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
var mockObj = new Mock<MockedType>();
|
||||
|
||||
mockObj.Setup(m => m.Method(It.IsAny<InputType>())).Returns(value);
|
||||
|
|
@ -48,4 +48,4 @@ mockObj.Verify(m => m.Method(It.IsAny<InputType>()), Times.Once());
|
|||
|
||||
// check that the invocation is forwarded to the mock with a specific input
|
||||
mockObj.Verify(m => m.Method(input), Times.Once());
|
||||
```
|
||||
```
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ The `ADO.NET` classes are found in `System.Data.dll`, and are integrated with th
|
|||
|
||||
## Connection to DB
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using System;
|
||||
using System.Data.SqlClient; // ADO.NET Provider, installed through NuGet
|
||||
|
||||
|
|
@ -55,7 +55,7 @@ namespace <namespace>
|
|||
|
||||
### `SqlConnection`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using (SqlConnection connection = new SqlConnection())
|
||||
{
|
||||
connection.ConnectionString = connectionString.ConnectionString;
|
||||
|
|
@ -70,7 +70,7 @@ using (SqlConnection connection = new SqlConnection(connectionString)) {
|
|||
|
||||
### [SqlCommand](https://docs.microsoft.com/en-us/dotnet/api/system.data.sqlclient.sqlcommand)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
string sql = "<sql_instruction>";
|
||||
|
||||
using (SqlCommand command = new SqlCommand())
|
||||
|
|
@ -94,7 +94,7 @@ using (SqlCommand command = new SqlCommand())
|
|||
|
||||
### `SqlDataReader`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using (SqlDataReader cursor = command.ExecuteReader()) // object to get data from db
|
||||
{
|
||||
while (cursor.Read()) // get data till possible
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Model & Data Annotations
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel.DataAnnotations;
|
||||
|
|
@ -35,7 +35,7 @@ NuGet Packages to install:
|
|||
- `Microsoft.EntityFrameworkCore.Design` *or* `Microsoft.EntityFrameworkCore.<db_provider>.Design` needed for tools to work (bundled w\ tools)
|
||||
- `Microsoft.EntityFrameworkCore.<db_provider>`
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace <Project>.Model
|
||||
|
|
@ -69,14 +69,14 @@ Create & Update DB Schema if necessary.
|
|||
|
||||
In Package Manager Shell:
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
PM> Add-Migration <migration_name>
|
||||
PM> update-database [-Verbose] # use the migrations to modify the db, -Verbose to show SQL queries
|
||||
```
|
||||
|
||||
In dotnet cli:
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
dotnet tool install --global dotnet-ef # if not already installed
|
||||
|
||||
dotnet ef migrations add <migration_name>
|
||||
|
|
@ -87,7 +87,7 @@ dotnet ef database update
|
|||
|
||||
### Create
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
context.Add(entity);
|
||||
context.AddRange(entities);
|
||||
|
||||
|
|
@ -98,7 +98,7 @@ context.SaveChanges();
|
|||
|
||||
[Referenced Object Not Loading Fix](https://stackoverflow.com/a/5385288)
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
context.Entities.ToList();
|
||||
context.Entities.Find(id);
|
||||
|
||||
|
|
@ -108,7 +108,7 @@ context.Entities.Include(c => c.ForeignObject).Find(id);
|
|||
|
||||
### Update
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
context.Entities.Update(entity);
|
||||
context.UpdateRange(entities);
|
||||
|
||||
|
|
@ -117,7 +117,7 @@ context.SaveChanges();
|
|||
|
||||
### Delete
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
context.Entities.Remove(entity);
|
||||
context.RemoveRange(entities);
|
||||
|
||||
|
|
|
|||
|
|
@ -26,14 +26,14 @@ The first thing on an HTML page is the doctype, which tells the browser which ve
|
|||
|
||||
### XHTML 1.0 Strict
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
||||
```
|
||||
|
||||
### HTML4 Transitional
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
|
||||
"http://www.w3.org/TR/html4/loose.dtd">
|
||||
```
|
||||
|
|
@ -46,7 +46,7 @@ The first thing on an HTML page is the doctype, which tells the browser which ve
|
|||
|
||||
After `<doctype>`, the page content must be contained between tags.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<!-- page contents -->
|
||||
|
|
@ -66,7 +66,7 @@ HTML5: `<meta charset="utf-8">`
|
|||
|
||||
Used to make old browsers understand newer HTML5 and newer components.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!--[if lt IE 9]>
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv.js"></script>
|
||||
<![endif]-->
|
||||
|
|
@ -76,7 +76,7 @@ Used to make old browsers understand newer HTML5 and newer components.
|
|||
|
||||
The body contains the actual content of the page. Everything that is contained in the body is visible to the user.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<body>
|
||||
<!-- page contents -->
|
||||
</body>
|
||||
|
|
@ -147,7 +147,7 @@ Before using build-in validation make sure that it's supported by the target bro
|
|||
|
||||
## General structure of HTML page
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- HTML Boilerplate -->
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
|
|
@ -189,7 +189,7 @@ Attributes describe additional characteristics of an HTML element.
|
|||
|
||||
Paragraphs allow to format the content in a readable fashion.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<p> paragraph-content </p>
|
||||
<p> paragraph-content </p>
|
||||
```
|
||||
|
|
@ -198,7 +198,7 @@ Paragraphs allow to format the content in a readable fashion.
|
|||
|
||||
Heading numbers indicates hierarchy, not size.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<h1> Heading 1 </h1>
|
||||
<h2> Heading 2 </h2>
|
||||
```
|
||||
|
|
@ -225,7 +225,7 @@ Without semantic value, used as last resort:
|
|||
|
||||
Surround content to turn into links.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- Link to absolute URL -->
|
||||
<a href="uri/url" title="content-title" target="_self"> text/image </a>
|
||||
|
||||
|
|
@ -260,12 +260,12 @@ Surround content to turn into links.
|
|||
|
||||
### Images
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<img src="image-location" alt="brief-description"/> <!-- image element -->
|
||||
<!-- alt should be always be populated for accessibility and SEO purposes -->
|
||||
```
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- supported by modern browsers -->
|
||||
<figure>
|
||||
<img src="img-location" alt="description">
|
||||
|
|
@ -275,7 +275,7 @@ Surround content to turn into links.
|
|||
|
||||
### Unordered list (bullet list)
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<ul>
|
||||
<li></li> <!-- list element -->
|
||||
<li></li>
|
||||
|
|
@ -284,7 +284,7 @@ Surround content to turn into links.
|
|||
|
||||
### Ordered list (numbered list)
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<ol>
|
||||
<li></li>
|
||||
<li></li>
|
||||
|
|
@ -293,7 +293,7 @@ Surround content to turn into links.
|
|||
|
||||
### Description list (list of terms and descriptions)
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<dl>
|
||||
<dt>term</dt> <!-- define term/name -->
|
||||
<dd>definition</dd> <!-- describe term/name -->
|
||||
|
|
@ -304,7 +304,7 @@ Surround content to turn into links.
|
|||
|
||||
### Tables
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<table>
|
||||
<thead> <!-- table head row -->
|
||||
<th></th> <!-- table head, one for each column-->
|
||||
|
|
@ -332,7 +332,7 @@ Code | Character
|
|||
|
||||
Used to group elements together into sections, eventually to style them differently.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<div>
|
||||
<!-- content here -->
|
||||
</div>
|
||||
|
|
@ -342,13 +342,13 @@ Used to group elements together into sections, eventually to style them differen
|
|||
|
||||
Used to apply a specific style inline.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<p> non-styled content <span class="..."> styled content </span> non-styled content </p>
|
||||
```
|
||||
|
||||
### HTML5 new tags
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<header></header>
|
||||
<nav></nav>
|
||||
<main></main>
|
||||
|
|
@ -360,7 +360,7 @@ Used to apply a specific style inline.
|
|||
|
||||
## HTML Forms & Inputs
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<form action="data-receiver" target="" method="http-method">
|
||||
<!-- ALL form elements go here -->
|
||||
</form>
|
||||
|
|
@ -392,7 +392,7 @@ PROs & CONs of `POST` method:
|
|||
|
||||
### Basic Form Elements
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<form action="" method="">
|
||||
<label for="target-identifier">label-here</label>
|
||||
<input type="input-type" name="input-name" value="value-sent" id="target-identifier">
|
||||
|
|
@ -421,7 +421,7 @@ Input Attributes:
|
|||
|
||||
One line areas that allow the user to input text.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="text" placeholder="placeholder-text" spellcheck="true" pattern="\regex\">
|
||||
```
|
||||
|
||||
|
|
@ -429,27 +429,27 @@ One line areas that allow the user to input text.
|
|||
|
||||
### Password Field
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="password">
|
||||
```
|
||||
|
||||
### Radio Buttons
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="radio" value="value">
|
||||
<input type="radio" value="value" checked>
|
||||
```
|
||||
|
||||
### Checkboxes
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="checkbox">
|
||||
<input type="checkbox" checked>
|
||||
```
|
||||
|
||||
### Dropdown Menus
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<select multiple>
|
||||
<option value="value">Value</option>
|
||||
<option value="value">Value</option>
|
||||
|
|
@ -467,7 +467,7 @@ Conceptually, `<select>` becomes more similar to checkboxes.
|
|||
Upload a local file as an attachment. The `accept` attribute value is a string that defines the file types the file input should accept.
|
||||
This string is a comma-separated list of [unique file type specifiers][file_type_specifiers_docs].
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="file" value="filename" accept=".txt,application/json,audio/*">
|
||||
```
|
||||
|
||||
|
|
@ -477,13 +477,13 @@ This string is a comma-separated list of [unique file type specifiers][file_type
|
|||
|
||||
Multi line text input.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<textarea rows="row-number" cols="column-number" >pre-existing editable test</textarea>
|
||||
```
|
||||
|
||||
### Submit & Reset
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="submit" value="label">
|
||||
<input type="reset" value="label">
|
||||
<!-- OR -->
|
||||
|
|
@ -496,7 +496,7 @@ Multi line text input.
|
|||
|
||||
### Button
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<button type="button/reset/submit" value="label"/>
|
||||
|
||||
<!-- can contain HTML -->
|
||||
|
|
@ -507,7 +507,7 @@ Multi line text input.
|
|||
|
||||
Group controls into categories. Particularly important for screen readers.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<fieldset>
|
||||
<legend>Color</legend>
|
||||
<input type="radio" name="colour" value="red" id="colour_red">
|
||||
|
|
@ -524,7 +524,7 @@ Group controls into categories. Particularly important for screen readers.
|
|||
Used to receive a valid e-mail address from the user. Most browsers can validate this without needing javascript.
|
||||
Older browsers don't support this input type.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<form>
|
||||
<label for="user-email">Email:</label>
|
||||
<input type="email" name="user-email" id="form-email">
|
||||
|
|
@ -534,13 +534,13 @@ Older browsers don't support this input type.
|
|||
|
||||
### Progress Bar
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<progress max="100" value="70"> 70% </progress>
|
||||
```
|
||||
|
||||
### Slider
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="range" min="0" max="20">
|
||||
```
|
||||
|
||||
|
|
@ -548,13 +548,13 @@ Older browsers don't support this input type.
|
|||
|
||||
The `<meter>` HTML element represents either a scalar value within a known range or a fractional value.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<meter min="0" max="100" low="33" high="66" optimum="80" value="50" />
|
||||
```
|
||||
|
||||
### More Input Types
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="email" id="email" name="email">
|
||||
<input type="url" id="url" name="url">
|
||||
<input type="number" name="" id="identifier" min="min-value" max="max-value" step="">
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
Connection to the DB.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package dao;
|
||||
|
||||
import java.sql.Connection;
|
||||
|
|
@ -51,7 +51,7 @@ public class DB {
|
|||
|
||||
Interface for CRUD methods on a database.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package dao;
|
||||
|
||||
import java.sql.SQLException;
|
||||
|
|
@ -69,7 +69,7 @@ public interface I<Type>DAO {
|
|||
|
||||
Class implementing `I<Type>DAO` and handling the communication with the db.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package dao;
|
||||
|
||||
import java.sql.ResultSet;
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ The **Java Collection Framework** is constituted by:
|
|||
|
||||
### Collection Functions
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
boolean add (Object o) e.g., <x>.add (<y>) //append to collection, false if fails
|
||||
boolean add (int index, Object o) //insertion at given index
|
||||
boolean addAll (Collection c) //appends a collection to another
|
||||
|
|
@ -36,7 +36,7 @@ Iterator iterator() //returns iterator to iterate over the collection
|
|||
|
||||
### Collections Methods
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Collection<E>.forEach(Consumer<? super T> action);
|
||||
```
|
||||
|
||||
|
|
@ -52,7 +52,7 @@ Abstracts the problem of iterating over all the elements of a collection;
|
|||
|
||||
**Note**: ArrayLists can't contain *primitive* values. *Use wrapper classes* instead.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
import java.util.ArrayList;
|
||||
ArrayList<Type> ArrayListName = new ArrayList<Type>(starting_dim); //resizable array
|
||||
ArrayList<Type> ArrayListName = new ArrayList<Type>(); //resizable array
|
||||
|
|
@ -82,7 +82,7 @@ ArrayListName.forEach(item -> function(v));
|
|||
|
||||
To sort a collection it's items must implement `Comparable<T>`:
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
class ClassName implements Comparable<ClassName> {
|
||||
|
||||
@override
|
||||
|
|
@ -99,7 +99,7 @@ Collections.sort(list); //"natural" sorting uses compareTo()
|
|||
|
||||
Otherwise a `Comparator()` must be implemented:
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
class Classname {
|
||||
//code here
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# Java
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
//single line comment
|
||||
/* multi line comment */
|
||||
/** javaDoc docstring */
|
||||
|
|
@ -19,7 +19,7 @@ Package definition: `package <package_location>;`
|
|||
|
||||
### Main Method (entry point of algorithm)
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public static void main (String[] args) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -31,21 +31,21 @@ public static void main (String[] args) {
|
|||
|
||||
### Constant Definition (outside of main method/function)
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public static final Type CONSTANT_NAME = value;
|
||||
public static final double PI = 3.14159; //example
|
||||
```
|
||||
|
||||
### Constant Definition (inside main method/function)
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
final Type CONSTANT_NAME = value;
|
||||
final double PI = 3.14159; //example
|
||||
```
|
||||
|
||||
### Screen Output
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
System.out.println(output_1 + _ + output_n); //newline at every invocation
|
||||
System.out.print(output_1 + _ + output_n);
|
||||
```
|
||||
|
|
@ -54,7 +54,7 @@ System.out.print(output_1 + _ + output_n);
|
|||
|
||||
[String.format() Examples](https://dzone.com/articles/java-string-format-examples)
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
System.out.printf("string %..", variable);
|
||||
System.out.println(String.format(format, args));
|
||||
```
|
||||
|
|
@ -65,7 +65,7 @@ Methods inherited from C. The value pf the variable substitutes %.
|
|||
|
||||
`NumberFormat` class is used to format a number output.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Locale locale = new Locale("language", "country"); // as defined by IETF lang tag, RCF 5646, RCF 4647
|
||||
NumberFormat fmt = NumberFormat.getCurrencyInstance(locale); // format a number as a currency based on a Locale
|
||||
fmt.format(number); // apply format to a number, returns a String
|
||||
|
|
@ -73,7 +73,7 @@ fmt.format(number); // apply format to a number, returns a String
|
|||
|
||||
## Keyboard Input
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
import java.util.Scanner; //package import
|
||||
Scanner scanner = new Scanner(System.in); //Scanner obj init
|
||||
scanner.useDelimiter("delimitatore"); //delimiter setting
|
||||
|
|
@ -92,7 +92,7 @@ Thus when switching to a different input method is necessary to call `nextLine()
|
|||
|
||||
### Primitive Types
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
TYPE WRAPPER SIZE MIN_VALUE MAX_VALUE
|
||||
int Integer -2147483648 2147483647
|
||||
byte Byte 8 bit -128 127
|
||||
|
|
@ -115,7 +115,7 @@ For high precision calcs is best to use `BigDecimal`.
|
|||
|
||||
### Type Conversion (casting) & Type checking
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Type variable = (Type) <expression>; // convert to other Type
|
||||
var instanceof Type; // true if var is an instance of Type
|
||||
```
|
||||
|
|
@ -125,7 +125,7 @@ var instanceof Type; // true if var is an instance of Type
|
|||
Every primitive type has a corresponding wrapper class.
|
||||
Wrapper classes permits the creation of an object with the same type of a primitive type but with added methods and constants.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
WrapperClass objectName = new WrapperClass(primitiveValue); //declaration
|
||||
WrapperClass objectName = primitiveValue; //shortened declaration
|
||||
|
||||
|
|
@ -143,7 +143,7 @@ WrapperClass.toString(primitive); // converts the wrapper class value to a stri
|
|||
|
||||
### String & Char
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
String string = "text"; //strings always in double quotes
|
||||
char character = 'C'; //chars always in single quotes
|
||||
```
|
||||
|
|
@ -172,7 +172,7 @@ String are immutable. Concatenation creates a new string.
|
|||
|
||||
### String Conversion to Number
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
double d = Double.parseDouble(string);
|
||||
float f = Float.parseFloat(string);
|
||||
int i = integer.parseInt(string);
|
||||
|
|
@ -180,7 +180,7 @@ int i = integer.parseInt(string);
|
|||
|
||||
### String Class Methods
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
string.equals(otherString); // returns TRUE if the strings are equal
|
||||
string.equalsIgnoreCase(otherString); // returns TRUE if the strings are equals ignoring the case
|
||||
string.charAt(index); // returns the character at position INDEX
|
||||
|
|
@ -211,7 +211,7 @@ To compare in alphabetical order both strings must have the same case.
|
|||
|
||||
### Mathematical Operations
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Math.PI // value of pi
|
||||
Math.E // value of e
|
||||
|
||||
|
|
@ -317,7 +317,7 @@ Full evaluation can be forced using `&` and `|`.
|
|||
|
||||
### `If Else`
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
if (condition) {
|
||||
//code here
|
||||
} else {
|
||||
|
|
@ -327,7 +327,7 @@ if (condition) {
|
|||
|
||||
### `If, Else If, Else`
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
if (condition) {
|
||||
//code here
|
||||
} else if (condition) {
|
||||
|
|
@ -346,7 +346,7 @@ if condition is `true` executes instruction1 otherwise executes instruction2.
|
|||
|
||||
### `Switch`
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
switch (matchExpression) {
|
||||
case matchingPattern:
|
||||
//code here
|
||||
|
|
@ -366,7 +366,7 @@ Omitting the `break` keyword causes multiple branches to execute the same code.
|
|||
|
||||
### `While` Loop
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
while (condition) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -374,7 +374,7 @@ while (condition) {
|
|||
|
||||
### `Do While` Loop
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
do {
|
||||
//code here
|
||||
} while (espressione_booleana);
|
||||
|
|
@ -384,7 +384,7 @@ Loop body executed *at least* one time
|
|||
|
||||
### `For` Loop
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
for (initializer; condition; iterator) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -392,7 +392,7 @@ for (initializer; condition; iterator) {
|
|||
|
||||
### `Foreach` Loop
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
for (Type variable : iterable){
|
||||
//code here
|
||||
}
|
||||
|
|
@ -400,7 +400,7 @@ for (Type variable : iterable){
|
|||
|
||||
### Multiple iterators in `For` Loop
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
for (initializer1, initializer2; condition; iterator1, iterator2) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -417,7 +417,7 @@ The iterator declared in the for is a local variable and can be used only in the
|
|||
If the assertion check is enabled (`java -ebableassetrions programName`) the execution of the algorithm is terminated if an assertion fails.
|
||||
Assertions can be used to check if a variable has a wanted value in a precise point in the code (Sanity Check).
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
assert <booleanExpression>;
|
||||
```
|
||||
|
||||
|
|
@ -427,7 +427,7 @@ Static methods are not bound to an *instance* of a class but they act on the cla
|
|||
|
||||
### Static Void Method Definition
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
static void methodName (parameters) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -435,7 +435,7 @@ static void methodName (parameters) {
|
|||
|
||||
### Static Method Definition
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
static tipo_metodo methodName (parameters) {
|
||||
//code here
|
||||
return <espressione>; //returned type MUST match method type
|
||||
|
|
@ -444,7 +444,7 @@ static tipo_metodo methodName (parameters) {
|
|||
|
||||
### Static Method Invocation
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
methodName(arguments);
|
||||
ClassName.methodName(arguments); //if method is used outside its class
|
||||
```
|
||||
|
|
@ -453,7 +453,7 @@ ClassName.methodName(arguments); //if method is used outside its class
|
|||
|
||||
## Array Declaration
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Type[] arrayName = new Type[dimension];
|
||||
|
||||
Type arrayName[] = new Type[dimension];
|
||||
|
|
@ -463,7 +463,7 @@ arrayName.length //length of the array
|
|||
|
||||
Its possible to break the declaration in two lines
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Type[] arrayName;
|
||||
arrayType = new Type[dimension];
|
||||
```
|
||||
|
|
@ -475,7 +475,7 @@ Array dimension is determined by the number of values.
|
|||
|
||||
### Arrays as method parameters
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
static Type methodName (Type[] arrayName) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -492,7 +492,7 @@ Array contents must be confronted by looping through the array.
|
|||
|
||||
### Methods returning Arrays
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
static Type[] methodName (parameters) {
|
||||
Type[] arrayName = new Type[dimension]; //array declaration
|
||||
//array valorization
|
||||
|
|
@ -502,7 +502,7 @@ static Type[] methodName (parameters) {
|
|||
|
||||
## Variable numbers of parameters in a method
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
static Type methodName (parameters, tipo[] ArrayName) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -512,14 +512,14 @@ It's not necessary to specify a dimension of the array, it's determined by Java
|
|||
|
||||
### Multi-Dimensional Arrays
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Type[]...[] arrayName = new Type[dimension1]...[dimensionN];
|
||||
Type arrayName[]...[] = new Type[dimension1]...[dimensionN];
|
||||
```
|
||||
|
||||
### Multi-Dimensional Arrays as parameters
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
static Type methodName (Type[]...[] ArrayName) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -527,7 +527,7 @@ static Type methodName (Type[]...[] ArrayName) {
|
|||
|
||||
### Methods returning multi-dimensional arrays
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
static Type[]...[] methodName (parameters) {
|
||||
Type[]...[] array = new Type[dimension1]...[dimensionN];
|
||||
//array valorization
|
||||
|
|
@ -537,14 +537,14 @@ static Type[]...[] methodName (parameters) {
|
|||
|
||||
### Array Length of multi-dimensional arrays
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
array.length //row length
|
||||
array[rowIndex].length //column length
|
||||
```
|
||||
|
||||
### Irregular Table Visualization
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
static void viewTable (Type[][] matrix){
|
||||
for (int row = 0; row < matrix.length; row++){ //run through the rows
|
||||
for (int column = 0; column < arrayName[row].length; column++){ //run through the columns
|
||||
|
|
@ -571,7 +571,7 @@ Unchecked exceptions usually mean that there is an error in the logic of the pro
|
|||
|
||||
This construct permits to monitor what happens in a block of code and to specify what to do in case of errors (*exceptions*).
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
try {
|
||||
//monitored code
|
||||
} catch (SpecificException e) {
|
||||
|
|
@ -590,7 +590,7 @@ A `try-catch` construct can handle multiple exceptions at once. Every `catch` i
|
|||
|
||||
### Try with Resources
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
try (
|
||||
//resource definition
|
||||
){
|
||||
|
|
@ -607,7 +607,7 @@ try (
|
|||
The `throw` keyword is used to generate a custom exception in a point of the code.
|
||||
`throw` is used together with an exception type.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Type methodName(parameters) {
|
||||
if (condition) {
|
||||
throw new Exception("error message");
|
||||
|
|
@ -618,7 +618,7 @@ Type methodName(parameters) {
|
|||
The `throws` keyword is used to indicate what exception Type may be thrown by a method.
|
||||
`throws` is used together with a exception class. It's used to send the exception to the method caller.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Type methodName(parameters) throws ExceptionClass {
|
||||
if (condition) {
|
||||
throw new SpecificException("error message");
|
||||
|
|
@ -630,7 +630,7 @@ Type methodName(parameters) throws ExceptionClass {
|
|||
|
||||
A user-defined exception has to inherit from `Exception` or one of it's descendants.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public class CustomException extends Exception {
|
||||
|
||||
public CustomException(){
|
||||
|
|
@ -659,7 +659,7 @@ If not specified variables, methods and classes are *only* accessible from the s
|
|||
|
||||
### Instance Method Definition
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Type methodName (parameters) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -667,7 +667,7 @@ Type methodName (parameters) {
|
|||
|
||||
### `Void` Instance Method
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
void methodName (parameters) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -675,7 +675,7 @@ void methodName (parameters) {
|
|||
|
||||
### Class Definition
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public class ClassName {
|
||||
//instance variables declaration
|
||||
|
||||
|
|
@ -711,7 +711,7 @@ Constructors are special methods that are invoked with the `new` operator when a
|
|||
Constructors assign the starting values of the object attributes.
|
||||
If a constructor id defined Java doesn't create the default constructor.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
class ClassName (){
|
||||
|
||||
//attributes declaration (aka instance variables)
|
||||
|
|
@ -736,7 +736,7 @@ Static variable do not belong to the class objects.
|
|||
|
||||
### Getters & Setter Methods
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public void setAttribute(Type attribute){
|
||||
this.attribute = attribute;
|
||||
}
|
||||
|
|
@ -750,7 +750,7 @@ public Type getAttribute(){
|
|||
|
||||
Automatically returns a string if the object is directly called in a print method.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
@Override
|
||||
Public String toString(){
|
||||
return "string-representation-of-object"
|
||||
|
|
@ -777,7 +777,7 @@ A child class can inherit from *only* one parent class.
|
|||
Child class **must** implement a constructor that instantiates the parent (super) class.
|
||||
`super()` instantiates the superclass of the child class.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
class ChildClass extends ParentClass{
|
||||
|
||||
public ChildClass(parentParameters, childParameters){
|
||||
|
|
@ -800,7 +800,7 @@ An overridden method can change the access modifier as long as the new modifier
|
|||
|
||||
A `ParentClass` type can contain a `ChildClass` object. This is useful for using collections and arrays of objects.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
ParentClass objectName = ChildClass(); // upcast
|
||||
(ChildClass)ParentClassObject; // downcast
|
||||
```
|
||||
|
|
@ -814,7 +814,7 @@ Abstract classes are marked by the `abstract` keyword.
|
|||
An abstract method is a method without implementation.
|
||||
The methods **must** be `public` and marked with the `abstract` keyword.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
//abstract class
|
||||
abstract class className{
|
||||
//attributes here
|
||||
|
|
@ -838,7 +838,7 @@ Interfaces' attributes are always `public static final`, no need for the keyword
|
|||
|
||||
A class can implement *more than one* Interface.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public interface InterfaceName{
|
||||
//attributes here
|
||||
|
||||
|
|
@ -869,7 +869,7 @@ Enums are used to restrict the type of data to a set of the possible constant va
|
|||
Enums are classes which constructor is private by default.
|
||||
It's still possible to create a custom constructor to add values.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
enum enumName {
|
||||
value1,
|
||||
value2,
|
||||
|
|
@ -904,7 +904,7 @@ enumName variable; //creation of a variable of type enumName
|
|||
|
||||
*Anonymous classes* make the code more concise. They enable to declare and instantiate a class at the same time. They are like local classes except that they do not have a name. Useful if is needed a local class that is used once.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
AnonymousClass objectName = new AnonymousClass(Type parameter, ...) {
|
||||
|
||||
// attributes
|
||||
|
|
@ -915,7 +915,7 @@ AnonymousClass objectName = new AnonymousClass(Type parameter, ...) {
|
|||
|
||||
### Cloning
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
class ClassName implements Clonable {
|
||||
|
||||
}
|
||||
|
|
@ -923,7 +923,7 @@ class ClassName implements Clonable {
|
|||
|
||||
## Generics
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
// WARNING: T is not instantiable, new t(), new t[] are INVALID
|
||||
public class GenericClass<T> {
|
||||
private T generic;
|
||||
|
|
@ -949,7 +949,7 @@ GenericClass<Type>[] obj = new GenericClass<>[]; // invalid
|
|||
|
||||
### Multiple Generics
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public class GenericClass<T1, T2, ...> { } // number of generic types is not limited
|
||||
```
|
||||
|
||||
|
|
@ -957,7 +957,7 @@ public class GenericClass<T1, T2, ...> { } // number of generic types is not li
|
|||
|
||||
Specify an interface or class that the generic type must implement/inherit.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public class GenericClass<T extends Interface1 & Interface2> { }
|
||||
public class GenericClass<T1 extends Interface1 & Interface2, T2 extends Class1> { }
|
||||
public class GenericClass<T extends Class1> { }
|
||||
|
|
@ -965,7 +965,7 @@ public class GenericClass<T extends Class1> { }
|
|||
|
||||
### Generic Methods
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
public class ClassName{
|
||||
|
||||
public <T> methodName() {
|
||||
|
|
@ -1001,7 +1001,7 @@ obj.<Type>methodName(); // generic method call
|
|||
|
||||
#### Writing on a file
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
// opening/creating the file for writing
|
||||
PrintWriter outStream = null; // output stream creation
|
||||
try{
|
||||
|
|
@ -1022,7 +1022,7 @@ outStream.close() // close stream and write buffer contents.
|
|||
|
||||
#### Reading from a file
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
Filereader filereader = new Filereader("filename"); //open the file
|
||||
Scanner scanner = new Scanner(filereader); //scanner for the file
|
||||
|
||||
|
|
@ -1058,7 +1058,7 @@ public void close() throws IOException // closes the stream
|
|||
|
||||
The File class is an abstraction of the file and it's path. The abstraction is independent from the OS.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
File("path/to/file") // UNIX like path
|
||||
File("path\\to\\file") // Windows path
|
||||
|
||||
|
|
@ -1075,7 +1075,7 @@ file.length() // file length in bytes
|
|||
|
||||
#### Writing to a binary file
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
ObjectOutputStream outStream;
|
||||
try {
|
||||
outStream = new ObjectOutputStream(new FileOutputSteam(filename));
|
||||
|
|
@ -1104,7 +1104,7 @@ public void close()
|
|||
|
||||
#### Reading from a binary file
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
ObjectInputStream inStream;
|
||||
try {
|
||||
inStream = new ObjectInputStream(new FileinputSteam(filename));
|
||||
|
|
@ -1148,7 +1148,7 @@ Needed for a class to be *serializable*:
|
|||
|
||||
An array is serializable if it's base type is a serializable object.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
SerializableObject[] array = (SerializableObject[])inStream.readObject(); // read returns Object, cast needed
|
||||
```
|
||||
|
||||
|
|
@ -1160,7 +1160,7 @@ Functional interfaces provide target types for *lambda expressions*.
|
|||
|
||||
General purpose `@functionalInterfaces`:
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
// takes input, performs actions, return boolean
|
||||
public interface Predicate<T> {
|
||||
boolean test(T t);
|
||||
|
|
@ -1215,7 +1215,7 @@ The features of Java stream are:
|
|||
|
||||
Usable only by a `@FunctionalInterface`'s method or a method of a *stream*.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
lambda operator -> body;
|
||||
|
||||
//zero parameter
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
File specifing project dependencies.
|
||||
|
||||
```xml
|
||||
```xml linenums="1"
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
## application.properties
|
||||
|
||||
```ini
|
||||
```ini linenums="1"
|
||||
spring.datasource.url=DB_url
|
||||
spring.datasource.username=user
|
||||
spring.datasource.password=password
|
||||
|
|
@ -24,7 +24,7 @@ server.port=server_port
|
|||
|
||||
Model of a table of the DB
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package <base_package>.entities;
|
||||
|
||||
import javax.persistence.Entity;
|
||||
|
|
@ -54,7 +54,7 @@ public class Entity {
|
|||
|
||||
Spring Interface for DB connection and CRUD operations.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package <base_package>.dal // or .repository
|
||||
|
||||
import org.springframework.data.repository.JpaRepository;
|
||||
|
|
@ -77,7 +77,7 @@ Interfaces and method to access the Data Access Layer (DAL).
|
|||
|
||||
In `IEntityService.java`:
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package <base_package>.services;
|
||||
|
||||
import java.util.List;
|
||||
|
|
@ -105,7 +105,7 @@ public interface IEntityService {
|
|||
|
||||
In `EntityService.java`:
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package <base_package>.services;
|
||||
|
||||
import java.util.List;
|
||||
|
|
@ -161,7 +161,7 @@ public class EntityService implements IEntityService {
|
|||
|
||||
REST API routes & endpoints to supply data as JSON.
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package <base_package>.integration;
|
||||
|
||||
import java.util.List;
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ Although servlets can respond to many types of requests, they most commonly impl
|
|||
|
||||
## Basic Structure
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
package <package>;
|
||||
|
||||
import java.io.IOException;
|
||||
|
|
@ -39,7 +39,7 @@ public class <className> extends HttpServlet {
|
|||
|
||||
## Servlet Instructions
|
||||
|
||||
```java
|
||||
```java linenums="1"
|
||||
request.getParameter() // read request parameter
|
||||
|
||||
response.setContentType("text/html"); // to return HTML in the response
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ AJAX Interaction:
|
|||
|
||||
## XMLHttpRequest
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var request = new XMLHttpRequest();
|
||||
|
||||
request.addEventListener(event, function() {...});
|
||||
|
|
@ -39,7 +39,7 @@ To check the status use `XMLHttpRequest.status` and `XMLHttpRequest.statusText`.
|
|||
|
||||
**Alternative `XMLHttpRequest` using `onLoad`**:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var request = new XMLHttpRequest();
|
||||
request.open('GET', 'myservice/username?id=some-unique-id');
|
||||
request.onload = function(){
|
||||
|
|
@ -54,7 +54,7 @@ request.send();
|
|||
|
||||
**Alternative `XMLHttpRequest` using `readyState`**:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var request = new XMLHttpRequest(), method ='GET', url ='https://developer.mozilla.org/';
|
||||
|
||||
request.open(method, url, true);
|
||||
|
|
@ -77,7 +77,7 @@ request.send();
|
|||
|
||||
Old versions of IE don't implement XMLHttpRequest. You must use the ActiveXObject if XMLHttpRequest is not available
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var request =window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');
|
||||
|
||||
// OR
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ The document object is *globally available* in the browser. It allows to access
|
|||
`getElementById()` and `querySelector()` return a single element.
|
||||
`getElementsByClassName()`, `getElementsByTagName()`, and `querySelectorAll()` return a collection of elements.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
Javascript
|
||||
// By Id
|
||||
var node = document.getElementById('id');
|
||||
|
|
@ -32,7 +32,7 @@ var nodes = document.querySelectorAll('css-selector');
|
|||
|
||||
It's possible access and change the attributes of a DOM node using the *dot notation*.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// Changing the src of an image:
|
||||
var image = document.getElementById('id');
|
||||
var oldImageSource = image.src;
|
||||
|
|
@ -48,7 +48,7 @@ node.className = 'new-class';
|
|||
It's possible to access and change the styles of a DOM nodes via the **style** property.
|
||||
CSS property names with a `-` must be **camelCased** and number properties must have a unit.
|
||||
|
||||
```css
|
||||
```css linenums="1"
|
||||
body {
|
||||
color: red;
|
||||
background-color: pink;
|
||||
|
|
@ -56,7 +56,7 @@ body {
|
|||
}
|
||||
```
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var pageNode = document.body;
|
||||
pageNode.style.color = 'red';
|
||||
pageNode.style.backgroundColor = 'pink';
|
||||
|
|
@ -67,7 +67,7 @@ pageNode.style.paddingTop = '10px';
|
|||
|
||||
Each DOM node has an `innerHTML` attribute. It contains the HTML of all its children.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var pageNode = document.body;
|
||||
console.log(pageNode.innerHTML);
|
||||
|
||||
|
|
@ -96,13 +96,13 @@ To change the actual text of a node, `textContent` may be a better choice:
|
|||
|
||||
In `page.html`:
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<input type="" id="identifier" value="">
|
||||
```
|
||||
|
||||
In `script.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var formNode = document.getElementById("Identifier");
|
||||
var value = formNode.value;
|
||||
```
|
||||
|
|
@ -111,7 +111,7 @@ var value = formNode.value;
|
|||
|
||||
The document object also allows to create new nodes from scratch.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// create node
|
||||
document.createElement('tagName');
|
||||
document.createTextNode('text');
|
||||
|
|
@ -129,7 +129,7 @@ node.parentNode.removeChild(node);
|
|||
|
||||
Example:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var body = document.body;
|
||||
|
||||
var newImg = document.createElement('img');
|
||||
|
|
@ -148,7 +148,7 @@ body.appendChild(newParagraph);
|
|||
|
||||
### Creating DOM Nodes with Constructor Functions
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
function Node(params) {
|
||||
this.node = document.createElement("tag");
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ Event Types:
|
|||
|
||||
### Managing Event Listeners
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var domNode = document.getElementById("id");
|
||||
|
||||
var onEvent = function(event) { // parameter contains info on the triggered event
|
||||
|
|
@ -38,7 +38,7 @@ Event Options:
|
|||
- `bubbles` (bool): whether the event propagates through bubbling
|
||||
- `cancellable` (bool): if `true` the "default action" may be prevented
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let event = new Event(type [,options]); // create the event, type can be custom
|
||||
let event = new CustomEvent(type, { detail: /* custom data */ }); // create event w/ custom data
|
||||
domNode.dispatchEvent(event); // launch the event
|
||||
|
|
@ -53,7 +53,7 @@ The window object is the assumed global object on a page.
|
|||
Animation in JavascriptThe standard way to animate in JS is to use window methods.
|
||||
It's possible to animate CSS styles to change size, transparency, position, color, etc.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
//Calls a function once after a delay
|
||||
window.setTimeout(callbackFunction, delayMilliseconds);
|
||||
|
||||
|
|
@ -73,7 +73,7 @@ window.requestAnimationFrame(callbackFunction);
|
|||
[StackOverflow](https://stackoverflow.com/a/294273/8319610)
|
||||
[Wrong dimensions at runtime](https://stackoverflow.com/a/46772849/8319610)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
> console.log(document.getElementById('id').getBoundingClientRect());
|
||||
DOMRect {
|
||||
bottom: 177,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# JavaScript
|
||||
# JavaScript
|
||||
|
||||
## Basics
|
||||
|
||||
|
|
@ -11,14 +11,14 @@
|
|||
|
||||
### Comments
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
//single line comment
|
||||
/*multiline comment*/
|
||||
```
|
||||
|
||||
### File Header
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
/**
|
||||
* @file filename.js
|
||||
* @author author's name
|
||||
|
|
@ -32,7 +32,7 @@
|
|||
|
||||
If located at the top of the script the whole script works the “modern” way (enables post-ES5 functionalities).
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
"use strict"
|
||||
|
||||
// script contents
|
||||
|
|
@ -42,7 +42,7 @@ If located at the top of the script the whole script works the “modern” way
|
|||
|
||||
Interrupts script execution until closure, **to be avoided**
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
alert("message");
|
||||
```
|
||||
|
||||
|
|
@ -69,7 +69,7 @@ Variable names can only contain numbers, digits, underscores and $. Variable nam
|
|||
Variable declared with `let` are in local to the code block in which are declared.
|
||||
Variable declared with `var` are local only if declared in a function.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
function func(){
|
||||
variable = value; // implicitly declared as a global variable
|
||||
var variable = value; // local variable
|
||||
|
|
@ -99,7 +99,7 @@ Hard-coded values are UPPERCASE and snake_case, camelCase otherwise.
|
|||
|
||||
Only numeric type is `number`.
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
let number = 10; //integer numbers
|
||||
number = 15.7; //floating point numbers
|
||||
number = Infinity; //mathematical infinity
|
||||
|
|
@ -115,7 +115,7 @@ Mathematical expression will *never* cause an error. At worst the result will be
|
|||
|
||||
### String data type
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
let string = "text";
|
||||
let string$ = 'text';
|
||||
let string_ = `text ${expression}`; //string interpolation (needs backticks)
|
||||
|
|
@ -137,7 +137,7 @@ Property access is unpredictable:
|
|||
|
||||
If the parameters to slice are negative, they reference the string from the end. Substring and substr doesn´t.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
string.slice(begin [, end]);
|
||||
string.substring(from [, to]);
|
||||
string.substr(start [, length]);
|
||||
|
|
@ -145,27 +145,27 @@ string.substr(start [, length]);
|
|||
|
||||
### Boolean data type
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
let boolean = true;
|
||||
let boolean_ = false;
|
||||
```
|
||||
|
||||
### Null data type
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
let _ = null;
|
||||
```
|
||||
|
||||
### Undefined
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
let $; //value is "undefined"
|
||||
$ = undefined;
|
||||
```
|
||||
|
||||
### Typeof()
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
typeof x; //returns the type of the variable x as a string
|
||||
typeof(x); //returns the type of the variable x as a string
|
||||
```
|
||||
|
|
@ -176,7 +176,7 @@ It is a special value with a separate type of its own. So, again, this is an err
|
|||
|
||||
### Type Casting
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
String(value); //converts value to string
|
||||
|
||||
Number(value); //converts value to a number
|
||||
|
|
@ -200,7 +200,7 @@ typeof var_ == "number"; // typeof returns a string with the name of the type
|
|||
|
||||
### Type Checking
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
isNaN(var); // converts var in number and then check if is NaN
|
||||
|
||||
Number("A") == NaN; //false ?!?
|
||||
|
|
@ -209,7 +209,7 @@ Number("A") == NaN; //false ?!?
|
|||
|
||||
### Dangerous & Stupid Implicit Type Casting
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
2 + 'text'; //"2text", implicit conversion and concatenation
|
||||
1 + "1"; //"11", implicit conversion and concatenation
|
||||
"1" + 1; //"11", implicit conversion and concatenation
|
||||
|
|
@ -305,7 +305,7 @@ Number("A") == NaN; //false ?!?
|
|||
|
||||
### IF-ELSE
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
if (condition) {
|
||||
//code here
|
||||
} else {
|
||||
|
|
@ -315,7 +315,7 @@ if (condition) {
|
|||
|
||||
### IF-ELSE Multi-Branch
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
if (condition) {
|
||||
//code here
|
||||
} else if (condition) {
|
||||
|
|
@ -331,7 +331,7 @@ if (condition) {
|
|||
|
||||
### Switch Statement
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
switch (expression) {
|
||||
case expression:
|
||||
//code here
|
||||
|
|
@ -347,7 +347,7 @@ switch (expression) {
|
|||
|
||||
### While Loop
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
while (condition) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -355,7 +355,7 @@ while (condition) {
|
|||
|
||||
### Do-While Loop
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
do {
|
||||
//code here
|
||||
} while (condition);
|
||||
|
|
@ -363,7 +363,7 @@ do {
|
|||
|
||||
### For Loop
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
// basic for
|
||||
for (begin; condition; step) { }
|
||||
|
||||
|
|
@ -384,7 +384,7 @@ iterable.forEach(() => { /* statements */ });
|
|||
`break;` exits the loop.
|
||||
`continue;` skip to next loop cycle.
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
label: for(begin; condition; step) {
|
||||
//code here
|
||||
}
|
||||
|
|
@ -394,7 +394,7 @@ break label; //breaks labelled loop and nested loops inside it
|
|||
|
||||
## Arrays
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let array = []; // empty array
|
||||
let array = ["text", 3.14, [1.41]]; // array declaration and initialization
|
||||
|
||||
|
|
@ -417,7 +417,7 @@ array.splice(start, deleteCount, [items_to_add]); // remove and RETURN items fr
|
|||
|
||||
### `filter()` & `map()`, `reduce()`
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let array = [ items ];
|
||||
|
||||
// execute an operation on each item, producing a new array
|
||||
|
|
@ -432,7 +432,7 @@ array.reduce((x, y) => ...);
|
|||
|
||||
## Spread Operator (...)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// arrays
|
||||
let array1 = [ 1, 2, 3, 4, 5, 6 ];
|
||||
let array2 = [ 7, 8, 9, 10 ];
|
||||
|
|
@ -457,7 +457,7 @@ func(arg0, ...args);
|
|||
|
||||
## Dictionaries
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let dict = { FirstName: "Chris", "one": 1, 1: "some value" };
|
||||
|
||||
|
||||
|
|
@ -471,7 +471,7 @@ dict.FirstName = "Chris";
|
|||
|
||||
### Iterating Key-Value pairs
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
for(let key in dict) {
|
||||
let value = dict[key];
|
||||
|
||||
|
|
@ -485,7 +485,7 @@ Object.keys(dict).forEach(key => { });
|
|||
|
||||
### JSDOC documentation standard
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
/**
|
||||
* @param {type} parameter - description
|
||||
* @returns {type} parameter - description
|
||||
|
|
@ -494,7 +494,7 @@ Object.keys(dict).forEach(key => { });
|
|||
|
||||
### Function Declaration
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
// ...args will contain extra parameters (rest argument)
|
||||
function functionName(parameter=default-value, ...args) {
|
||||
//code here
|
||||
|
|
@ -504,7 +504,7 @@ function functionName(parameter=default-value, ...args) {
|
|||
|
||||
### Default Parameters (old versions)
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
function functionName(parameters) {
|
||||
if (parameter == undefined) {
|
||||
parameter = value;
|
||||
|
|
@ -517,7 +517,7 @@ function functionName(parameters) {
|
|||
|
||||
### Function Expressions
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
let functionName = function(parameters) {
|
||||
//code here
|
||||
return expression;
|
||||
|
|
@ -526,7 +526,7 @@ let functionName = function(parameters) {
|
|||
|
||||
### Arrow Functions
|
||||
|
||||
```javascript
|
||||
```javascript linenums="1"
|
||||
(input) => { /* statements */ }
|
||||
(input) => expression;
|
||||
input => expression; // parenthesis are optional
|
||||
|
|
@ -552,7 +552,7 @@ An object is a collection of related data and/or functionality.
|
|||
|
||||
**Note**: It's not possible to transform a variable in an object simply by using the object assignment.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let variable = value;
|
||||
|
||||
// object literal
|
||||
|
|
@ -596,7 +596,7 @@ Object.entries(obj); // list contents as key-value pairs
|
|||
JavaScript uses special functions called **constructor functions** to define and initialize objects and their features.
|
||||
Notice that it has all the features you'd expect in a function, although it doesn't return anything or explicitly create an object — it basically just defines properties and methods.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// constructor function definition
|
||||
function Class(params) {
|
||||
this.property = param;
|
||||
|
|
@ -622,7 +622,7 @@ An object's prototype object may also have a prototype object, which it inherits
|
|||
This is often referred to as a **prototype chain**, and explains why different objects have properties and methods defined on other objects available to them.
|
||||
If a method is implemented on an object (and not it's prototype) then only that object will heve that method and not all the ones that come from the same prototype.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// constructor function
|
||||
function Obj(param1, ...) {
|
||||
this.param1 = param1,
|
||||
|
|
@ -640,7 +640,7 @@ obj.method(); // call method from prototype
|
|||
|
||||
### Extending with prototypes
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// constructor function
|
||||
function DerivedObj(param1, param2, ...) {
|
||||
Obj.call(this, param1); // use prototype constructor
|
||||
|
|
@ -661,7 +661,7 @@ dobj.method(); // call method from prototype
|
|||
|
||||
### Classes (ES6+)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
class Obj {
|
||||
constructor(param1, ...) {
|
||||
this.param1 = param1,
|
||||
|
|
@ -686,7 +686,7 @@ obj.func(); // call method
|
|||
|
||||
### Extending with Classes
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
class DerivedObj extends Obj {
|
||||
constructor(param1, param2, ...){
|
||||
super(param1); // use superclass constructor
|
||||
|
|
@ -704,7 +704,7 @@ dobj.newFunc();
|
|||
|
||||
### Object deconstruction
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let obj = {
|
||||
property: value,
|
||||
...
|
||||
|
|
@ -717,14 +717,14 @@ let { property: var1, var2 = default_value } = obj; // use default values if ob
|
|||
|
||||
### Array Deconstruction
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let array = [ 1, 2, 3, 4, 5, 6 ];
|
||||
let [first, , third, , seventh = "missing" ] = array; // extract specific values from array
|
||||
```
|
||||
|
||||
## Serialization
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let object = {
|
||||
// object attributes
|
||||
}
|
||||
|
|
@ -741,7 +741,7 @@ let object = JSON.parse(json); // deserialize to Object
|
|||
|
||||
Function runs *once* after an interval of time.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// param1, param2, ... are the arguments passed to the function (IE9+)
|
||||
let timerId = setTimeout(func [, milliseconds, param1, param2, ... ]); // wait milliseconds before executing the code (params are read at execution time)
|
||||
|
||||
|
|
@ -776,7 +776,7 @@ useTimeout();
|
|||
|
||||
### `let` vs `var` with `setTimeout`
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// let instantiates a new variable for each iteration
|
||||
for (let i = 0; i < 3; ++i) {
|
||||
setTimeout(function() {
|
||||
|
|
@ -795,7 +795,7 @@ for (var i = 0; i < 3; ++i) {
|
|||
|
||||
### Preserving the context
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let obj = {
|
||||
prop: value,
|
||||
|
||||
|
|
@ -824,7 +824,7 @@ let obj = {
|
|||
|
||||
Function runs regularly with a specified interval. JavaScript is **Single Threaded**.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// param1, param2, ... are the arguments passed to the function (IE9+)
|
||||
let timerId = setInterval(func, milliseconds [, param1, param2, ... ]); // (params are read at execution time)
|
||||
|
||||
|
|
@ -852,7 +852,7 @@ There are generally 4 types of JavaScript date input formats:
|
|||
- Long Date: `"Mar 25 2015"` or `"25 Mar 2015"`
|
||||
- Full Date: `"Wednesday March 25 2015"`
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// constructors
|
||||
new Date();
|
||||
new Date(milliseconds);
|
||||
|
|
@ -892,7 +892,7 @@ let date = new Date(msec);
|
|||
|
||||
Comparison operators work also on dates
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let date1 = new Date();
|
||||
let date2 = new Date("May 24, 2017 10:50:00");
|
||||
|
||||
|
|
@ -909,20 +909,20 @@ if(date1 > date2){
|
|||
|
||||
> **Note**: Firefox 68 and later define the origin of a page opened using a `file:///` URI as unique. Therefore, other resources in the same directory or its subdirectories no longer satisfy the CORS same-origin rule. This new behavior is enabled by default using the `privacy.file_unique_origin` preference.
|
||||
|
||||
```json
|
||||
```json linenums="1"
|
||||
"privacy.file_unique_origin": "false"
|
||||
```
|
||||
|
||||
In `page.html`
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<script src="scripts/module.js"></script>
|
||||
<script src="scripts/script.js"></script>
|
||||
```
|
||||
|
||||
In `module.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// exporting individual fractures
|
||||
export default function() {} // one per module
|
||||
export func = () => expression; // zero or more per module
|
||||
|
|
@ -942,7 +942,7 @@ export { func } from "other_script.js"
|
|||
|
||||
In `script.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import default_func_alias, { func as alias } from "./module.js"; // import default and set alias
|
||||
import { default as default_func_alias, func as alias } from "./module.js"; // import default and set alias
|
||||
|
||||
|
|
@ -951,7 +951,7 @@ default_func_alias();
|
|||
alias();
|
||||
```
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import * from "./module.js"; // import all
|
||||
|
||||
module.function(); // use imported content with fully qualified name
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
### Download and link the file
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<head>
|
||||
<script src="jquery-x.x.x.min.js"></script>
|
||||
</head>
|
||||
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
### Use a CDN
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<head>
|
||||
<script src="https://ajax.googleapis.com/ajax/libs/jquery/x.x.x/jquery.min.js"></script>
|
||||
</head>
|
||||
|
|
@ -34,7 +34,7 @@ CDNs serve a large fraction of the Internet content today, including web objects
|
|||
|
||||
### [Finding DOM elements](https://api.jquery.com/category/selectors/)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
$('tag');
|
||||
$("#id");
|
||||
$(".class");
|
||||
|
|
@ -42,11 +42,11 @@ $(".class");
|
|||
|
||||
### Manipulating DOM elements
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
$("p").addClass("special");
|
||||
```
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- before -->
|
||||
<p>Welcome to jQuery<p>
|
||||
|
||||
|
|
@ -56,11 +56,11 @@ $("p").addClass("special");
|
|||
|
||||
### Reading Elements
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<a id="yahoo" href="http://www.yahoo.com" style="font-size:20px;">Yahoo!</a>
|
||||
```
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// find it & store it
|
||||
var link = $('a#yahoo');
|
||||
|
||||
|
|
@ -72,14 +72,14 @@ link.css('font-size'); // '20px
|
|||
|
||||
### Modifying Elements
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// jQuery
|
||||
$('a').html('Yahoo!');
|
||||
$('a').attr('href', 'http://www.yahoo.com');
|
||||
$('a').css({'color': 'purple'});
|
||||
```
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- before -->
|
||||
<a href="http://www.google.com">Google</a>
|
||||
|
||||
|
|
@ -89,7 +89,7 @@ $('a').css({'color': 'purple'});
|
|||
|
||||
### Create, Store, Manipulate and inject
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let paragraph = $('<p class="intro">Welcome<p>'); // create and store element
|
||||
|
||||
paragraph.css('property', 'value'); // manipulate element
|
||||
|
|
@ -99,7 +99,7 @@ $("body").append(paragraph); // inject in DOM
|
|||
|
||||
### Regular DOM Nodes to jQuery Objects
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var paragraphs = $('p'); // an array
|
||||
var aParagraph = paragraphs[0]; // a regular DOM node
|
||||
var $aParagraph = $(paragraphs[0]); // a jQuery Object
|
||||
|
|
@ -114,7 +114,7 @@ for(var i = 0; i < paragraphs.length; i++) {
|
|||
|
||||
## [Events](https://api.jquery.com/category/events/)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
var onButtonClick = function() {
|
||||
console.log('clicked!');
|
||||
}
|
||||
|
|
@ -133,7 +133,7 @@ $('button').click(onButtonClick);
|
|||
|
||||
### Preventing Default Event
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
$('selector').on('event', function(event) {
|
||||
event.preventDefault();
|
||||
// custom logic
|
||||
|
|
@ -144,13 +144,13 @@ $('selector').on('event', function(event) {
|
|||
|
||||
In the HTML, add a `<script>` ag that hotlinks to the CDN or source file:
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-validate/1.17.0/jquery.validate.min.js"><script>
|
||||
```
|
||||
|
||||
In the JavaScript call the jQuery plugin on the DOM:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
$("form").validate();
|
||||
```
|
||||
|
||||
|
|
@ -160,7 +160,7 @@ $("form").validate();
|
|||
|
||||
### Patters & Anti-Patterns
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// Pattern: name variables with $var
|
||||
$myVar =$('#myNode');
|
||||
|
||||
|
|
@ -179,7 +179,7 @@ $(document).on('click', 'p', function(argument){
|
|||
|
||||
### Chaining
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
banner.css('color', 'red');
|
||||
banner.html('Welcome!');
|
||||
banner.show();
|
||||
|
|
@ -197,7 +197,7 @@ banner.css('color', 'red')
|
|||
|
||||
DOM manipulation and event binding doesn't work if the `<script>` is in the `<head>`
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
$(document).ready(function() {
|
||||
// the DOM is fully loaded
|
||||
});
|
||||
|
|
@ -209,7 +209,7 @@ $(window).on('load', function(){
|
|||
|
||||
## AJAX (jQuery `1.5`+)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
$.ajax({
|
||||
method: 'POST',
|
||||
url: 'some.php',
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ Router Types:
|
|||
- *BrowserRouter*: `/route`, uses HTML5 history API to provide clean URLs
|
||||
- *MemoryRouter*: no URL
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// index.js
|
||||
|
||||
//other imports ...
|
||||
|
|
@ -31,7 +31,7 @@ React.render(
|
|||
)
|
||||
```
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// Component.js
|
||||
import { Route, Route } from "react-router-dom";
|
||||
|
||||
|
|
@ -52,7 +52,7 @@ import { Route, Route } from "react-router-dom";
|
|||
|
||||
### URL Parameters & Query String
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// Given
|
||||
<Route path="/route/:placeholder" element={<Component props={props} />} />
|
||||
// URL: app.com/route/sub-route?param=value
|
||||
|
|
@ -66,7 +66,7 @@ function Component(props) {
|
|||
|
||||
### Redirecting
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { Navigate } from "react-router-dom";
|
||||
|
||||
// redirects to another URL on render, shouldn't be rendered on component mount but after an action
|
||||
|
|
@ -80,7 +80,7 @@ props.history.push("/new-route");
|
|||
|
||||
### Prompts
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { Prompt } from "react-router-dom";
|
||||
|
||||
// displays a prompt when the condition is true
|
||||
|
|
@ -91,7 +91,7 @@ import { Prompt } from "react-router-dom";
|
|||
|
||||
Clicks on a link created with React-Router will be captured by react an all the routing will happen client side.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { Link } from "react-router-dom";
|
||||
|
||||
// TARGET: <Route path="/route/:itemId" />
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
### Jest Configuration
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// jest.config.js
|
||||
module.exports = {
|
||||
testEnvironment: 'jsdom',
|
||||
|
|
@ -18,7 +18,7 @@ module.exports = {
|
|||
|
||||
[Expect docs](https://jestjs.io/docs/expect)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// .spec.js or .test.js
|
||||
it("test description", () => {
|
||||
// test body
|
||||
|
|
@ -36,7 +36,7 @@ describe("test group name", () => {
|
|||
|
||||
In `Component.Snapshots.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import React from "react";
|
||||
import renderer from "react-test-renderer";
|
||||
|
||||
|
|
@ -60,7 +60,7 @@ it("test description", () => {
|
|||
|
||||
### Enzyme Configuration
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// testSetup.js
|
||||
import { configure } from "enzyme";
|
||||
import Adapter from "enzyme-adapter-react-<version>";
|
||||
|
|
@ -72,7 +72,7 @@ configure({ adapter: new Adapter() });
|
|||
|
||||
In `Component.test.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import React from "react";
|
||||
import { shallow, mount } from "enzyme";
|
||||
// eventual wrapper components (react-router, react-redux's provider, ...) for mount render
|
||||
|
|
@ -125,7 +125,7 @@ Encourages to write test based on what the user sees. So components are always *
|
|||
|
||||
In `Components.test.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import React from "react";
|
||||
import { cleanup, render } from "@testing-library/react";
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ There are two types of react components:
|
|||
|
||||
Both types can be stateful and have side effects or be purely presentational.
|
||||
|
||||
```jsx
|
||||
```jsx linenums="1"
|
||||
// functional component
|
||||
const Component = (props) => {
|
||||
return (
|
||||
|
|
@ -33,7 +33,7 @@ Within the component state can be changed while the props object represent fixed
|
|||
|
||||
JSX syntax can represent HTML but gets converted to pure JavaScript before being sent to the browser:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// JSX
|
||||
const element = (
|
||||
<h1 className="greeting">Hello, world!</h1>
|
||||
|
|
@ -49,7 +49,7 @@ const element = React.createElement(
|
|||
|
||||
### App Entry-point
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
const container = document.getElementById('root')!;
|
||||
const root = createRoot(container);
|
||||
|
||||
|
|
@ -59,7 +59,7 @@ root.render(element)
|
|||
|
||||
### Dynamic Expressions
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
<tag>{expression}</tag> // expression is evaluated an it's result is displayed
|
||||
<tag onEvent={funcReference}>{expression}</tag>
|
||||
<tag onEvent={() => func(args)}>{expression}</tag>
|
||||
|
|
@ -67,7 +67,7 @@ root.render(element)
|
|||
|
||||
### Props
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
<Component propName={value} /> // pass a value the component
|
||||
<Component propName={funcReference} /> // pass a function to the component
|
||||
|
||||
|
|
@ -83,7 +83,7 @@ class Component extends React.Component{
|
|||
|
||||
### Simple Function Component
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// Button.js
|
||||
import { useState } from "react";
|
||||
|
||||
|
|
@ -105,7 +105,7 @@ export default Button;
|
|||
|
||||
### Simple Class Component
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
class Button extends React.Component {
|
||||
|
||||
state = {count: 0};
|
||||
|
|
@ -137,7 +137,7 @@ class Button extends React.Component {
|
|||
|
||||
### Nesting Components
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { useState } from "react";
|
||||
|
||||
function Button(props) {
|
||||
|
|
@ -173,7 +173,7 @@ export default App;
|
|||
|
||||
### User Input (Forms)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
function Form() {
|
||||
const [userName, setUserName] = useState("");
|
||||
|
||||
|
|
@ -198,7 +198,7 @@ function Form() {
|
|||
|
||||
### Lists of Components
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// ...
|
||||
<div>
|
||||
{array.map(item => <Component key={uniqueID}>)}
|
||||
|
|
@ -219,7 +219,7 @@ Hook used to create a state object.
|
|||
- state object (getter)
|
||||
- updater function (setter)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
const [state, setState] = useState(default);
|
||||
```
|
||||
|
||||
|
|
@ -227,7 +227,7 @@ const [state, setState] = useState(default);
|
|||
|
||||
Hook used to trigger an action on each render of the component or when one of the watched items changes.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
|
||||
useEffect(() => {
|
||||
// "side effects" operations
|
||||
|
|
@ -238,7 +238,7 @@ useEffect(() => {
|
|||
|
||||
### Custom Hooks
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// hook definitions
|
||||
const useCustomHook = () => {
|
||||
// eventual state definitions
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ Connected components are wrapped in a call to `connect`. Way of solving the prob
|
|||
|
||||
In `Component.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
export function Component(props) { /* ... */ } // export unconnected component
|
||||
|
||||
export default connect(mapStateToProps, mapDispatchToProps)(Component) // default export of connected component
|
||||
|
|
@ -17,7 +17,7 @@ export default connect(mapStateToProps, mapDispatchToProps)(Component) // defau
|
|||
|
||||
In `Component.test.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import React from "react";
|
||||
// import enzyme or react testing library
|
||||
|
||||
|
|
@ -48,7 +48,7 @@ it("test description", () => {
|
|||
|
||||
## Tests for Action Creators
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import * as actions from "path/to/actionCreators";
|
||||
// import eventual action types constants
|
||||
// import mock data
|
||||
|
|
@ -65,7 +65,7 @@ it("test description", () => {
|
|||
|
||||
## Tests for Reducers
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import reducer from "path/to/reducer";
|
||||
import * as actions from "path/to/actionCreators";
|
||||
|
||||
|
|
@ -83,7 +83,7 @@ it("test description", () => {
|
|||
|
||||
## Tests for the Store
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { createStore } from "redux";
|
||||
|
||||
import rootReducer from "path/to/rootReducer";
|
||||
|
|
@ -111,7 +111,7 @@ Thunk testing requires the mocking of:
|
|||
- store (using `redux-mock-store`)
|
||||
- HTTP calls (using `fetch-mock`)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import thunk from "redux-thunk";
|
||||
import fetchMock from "fetch-mock";
|
||||
import configureMockStore from "redux-mock-store";
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ By convention, that information is stored in a field called `payload`.
|
|||
|
||||
**Action Creators** are functions that create and return action objects.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
function actionCreator(data)
|
||||
{
|
||||
return { type: ACTION_TYPE, payload: data }; // action obj
|
||||
|
|
@ -30,7 +30,7 @@ The store will run its reducer function and save the new state value inside.
|
|||
|
||||
In `initialState.js`;
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
export default {
|
||||
// initial state here
|
||||
}
|
||||
|
|
@ -38,7 +38,7 @@ export default {
|
|||
|
||||
In `configStore.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// configStore.js
|
||||
import { createStore, applyMiddleware, compose } from "redux";
|
||||
|
||||
|
|
@ -71,7 +71,7 @@ Reducers must **always** follow some specific rules:
|
|||
Instead, they must make *immutable updates*, by copying the existing `state` and making changes to the copied values.
|
||||
- They must not do any asynchronous logic, calculate random values, or cause other "side effects"
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import initialState from "path/to/initialState";
|
||||
|
||||
function reducer(state = initialState, action) {
|
||||
|
|
@ -118,7 +118,7 @@ Presentational Components:
|
|||
|
||||
Used at the root component and wraps all the application.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// index.js
|
||||
import React from 'react';
|
||||
import ReactDOM from 'react-dom';
|
||||
|
|
@ -139,7 +139,7 @@ ReactDOM.render(
|
|||
);
|
||||
```
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// Component.js
|
||||
import { connect } from 'react-redux';
|
||||
import { increment, decrement, reset } from './actionCreators';
|
||||
|
|
@ -183,7 +183,7 @@ A "thunk" is a function that wraps an expression to delay it's evaluation.
|
|||
|
||||
In `configStore.js`:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { createStore, applyMiddleware, compose } from "redux";
|
||||
import thunk from "redux-thunk";
|
||||
|
||||
|
|
@ -199,7 +199,7 @@ function configStore(initialState) {
|
|||
}
|
||||
```
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// usually action on async func success
|
||||
function actionCreator(arg) {
|
||||
return { type: TYPE, data: arg };
|
||||
|
|
@ -241,7 +241,7 @@ Using Create React App
|
|||
|
||||
The recommended way to start new apps with React and Redux is by using the official Redux+JS template or Redux+TS template for Create React App, which takes advantage of Redux Toolkit and React Redux's integration with React components.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
# Redux + Plain JS template
|
||||
npx create-react-app my-app --template redux
|
||||
|
||||
|
|
@ -286,7 +286,7 @@ Included Default Middleware:
|
|||
|
||||
Currently, the return value of `getDefaultMiddleware()` is:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// development
|
||||
const middleware = [thunk, immutableStateInvariant, serializableStateInvariant]
|
||||
|
||||
|
|
@ -294,7 +294,7 @@ const middleware = [thunk, immutableStateInvariant, serializableStateInvariant]
|
|||
const middleware = [thunk]
|
||||
```
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
|
||||
import { combineReducers } from 'redux'
|
||||
import { configureStore } from '@reduxjs/toolkit'
|
||||
|
|
@ -320,7 +320,7 @@ export default store
|
|||
|
||||
### [`createAction`](https://redux-toolkit.js.org/api/createAction)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { createAction } from '@reduxjs/toolkit';
|
||||
|
||||
const increment = createAction<number | undefined>('counter/increment');
|
||||
|
|
@ -333,7 +333,7 @@ increment.toString(); // 'counter/increment'
|
|||
|
||||
### [`createReducer`](https://redux-toolkit.js.org/api/createReducer)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { createAction, createReducer } from '@reduxjs/toolkit'
|
||||
|
||||
interface CounterState {
|
||||
|
|
@ -368,7 +368,7 @@ Internally, it uses `createAction` and `createReducer`, so it's possible to use
|
|||
|
||||
**Note**: action types will have the `<slice-name>/<reducer-name>` shape.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { createSlice, PayloadAction } from '@reduxjs/toolkit'
|
||||
|
||||
interface CounterState {
|
||||
|
|
@ -415,7 +415,7 @@ The `payloadCreator` function will be called with two arguments:
|
|||
|
||||
The logic in the `payloadCreator` function may use any of these values as needed to calculate the result.
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import { createAsyncThunk, createSlice } from '@reduxjs/toolkit'
|
||||
|
||||
const payloadCreator = async (arg, ThunkAPI): Promise<T> => { /* ... */ };
|
||||
|
|
@ -444,7 +444,7 @@ It is intended to simplify common cases for loading data in a web application, e
|
|||
|
||||
RTK Query is included within the installation of the core Redux Toolkit package. It is available via either of the two entry points below:
|
||||
|
||||
```cs
|
||||
```cs linenums="1"
|
||||
import { createApi } from '@reduxjs/toolkit/query'
|
||||
|
||||
/* React-specific entry point that automatically generates hooks corresponding to the defined endpoints */
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# [Svelte](https://svelte.dev/docs)
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
npx degit sveltejs/template <project name>
|
||||
|
||||
# set project to use typescript
|
||||
|
|
@ -12,7 +12,7 @@ npm init vite@latest
|
|||
|
||||
## App Entry-point
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
import App from "./App.svelte"; // import the component
|
||||
|
||||
const app = new App({
|
||||
|
|
@ -29,7 +29,7 @@ export default app;
|
|||
|
||||
### Basic Structure
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- code for the component -->
|
||||
<script lang="ts">
|
||||
import { Component } from "Component.svelte";
|
||||
|
|
@ -57,7 +57,7 @@ export default app;
|
|||
|
||||
### If-Else
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
{#if <condition>}
|
||||
// markup here
|
||||
{:else if <condition>}
|
||||
|
|
@ -69,7 +69,7 @@ export default app;
|
|||
|
||||
### Loops
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
{#each array as item, index} // index is optional
|
||||
// markup here
|
||||
{/each}
|
||||
|
|
@ -81,7 +81,7 @@ export default app;
|
|||
|
||||
### Await Blocks
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
{#await promise}
|
||||
<p>...waiting</p>
|
||||
{:then number}
|
||||
|
|
@ -103,7 +103,7 @@ The full list of modifiers:
|
|||
- `once` — remove the handler after the first time it runs
|
||||
- `self` — only trigger handler if `event.target` is the element itself
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
<script>
|
||||
const eventHandler = () => {};
|
||||
</script>
|
||||
|
|
@ -119,7 +119,7 @@ The full list of modifiers:
|
|||
|
||||
## Binding
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<script>
|
||||
let name = "Foo";
|
||||
</script>
|
||||
|
|
@ -137,7 +137,7 @@ Often, some parts of a component's state need to be computed from other parts an
|
|||
|
||||
For these, Svelte has reactive declarations. They look like this:
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
let count = 0;
|
||||
$: double = count * 2; // recalculated when count changes
|
||||
// or
|
||||
|
|
@ -149,7 +149,7 @@ $: <expression>
|
|||
|
||||
[Svelte Routing](https://github.com/EmilTholin/svelte-routing)
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
<!-- App.svelte -->
|
||||
<script>
|
||||
import { Router, Link, Route } from "svelte-routing";
|
||||
|
|
@ -177,14 +177,14 @@ $: <expression>
|
|||
|
||||
## Data Stores
|
||||
|
||||
```js
|
||||
```js linenums="1"
|
||||
// stores.js
|
||||
import { writable } from "svelte/store";
|
||||
|
||||
export const count = writable(0);
|
||||
```
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<script>
|
||||
import { onDestroy } from "svelte";
|
||||
import { count } from ".path/to/stores.js";
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Package & Imports
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
package com.app.uniqueID
|
||||
|
||||
import <package>
|
||||
|
|
@ -10,7 +10,7 @@ import <package>
|
|||
|
||||
## Variable & Constants
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
|
||||
var variable: Type //variable declaration
|
||||
var variable = value //type can be omitted if it can be deduced by initialization
|
||||
|
|
@ -23,7 +23,7 @@ val CONSTANT_NAME: Type = value //constant declaration
|
|||
For a variable to hold a null value, it must be of a nullable type.
|
||||
Nullable types are specified suffixing `?` to the variable type.
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
var nullableVariable: Type? = null
|
||||
|
||||
nullableVariable?.method() //correct way to use
|
||||
|
|
@ -37,7 +37,7 @@ nullablevariavle!!.method() //unsafe way
|
|||
|
||||
### `If` - `Else If` - `Else`
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
if (condition) {
|
||||
//code here
|
||||
} else if (condition) {
|
||||
|
|
@ -49,7 +49,7 @@ if (condition) {
|
|||
|
||||
### Conditional Expressions
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
var variable: Type = if (condition) {
|
||||
//value to be assigned here
|
||||
} else if (condition) {
|
||||
|
|
@ -65,7 +65,7 @@ Each branch in a `when` expression is represented by a condition, an arrow (`->`
|
|||
If the condition on the left-hand side of the arrow evaluates to true, then the result of the expression on the right-hand side is returned.
|
||||
Note that execution does not fall through from one branch to the next.
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
when (variable){
|
||||
condition -> value
|
||||
condition -> value
|
||||
|
|
@ -90,7 +90,7 @@ when {
|
|||
|
||||
### `For` Loop
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
for (item in iterable){
|
||||
//code here
|
||||
}
|
||||
|
|
@ -103,7 +103,7 @@ for(i in start..end) {
|
|||
|
||||
## Functions
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
fun functionName(parameter: Type): Type {
|
||||
//code here
|
||||
|
||||
|
|
@ -113,7 +113,7 @@ fun functionName(parameter: Type): Type {
|
|||
|
||||
### Simplifying Function Declarations
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
fun functionName(parameter: Type): Type {
|
||||
return if (condition) {
|
||||
//returned value
|
||||
|
|
@ -132,7 +132,7 @@ fun functionName(parameter: Type): Type = if (condition) {
|
|||
|
||||
### Anonymous Functions
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
val anonymousFunction: (Type) -> Type = { input ->
|
||||
//code acting on input here
|
||||
}
|
||||
|
|
@ -145,7 +145,7 @@ val variableName: Type = anonymousFunction(input)
|
|||
A function can take another function as an argument. Functions that use other functions as arguments are called *higher-order* functions.
|
||||
This pattern is useful for communicating between components in the same way that you might use a callback interface in Java.
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
fun functionName(parameter: Type, function: (Type) -> Type): Type {
|
||||
//invoke function
|
||||
return function(parameter)
|
||||
|
|
@ -156,7 +156,7 @@ fun functionName(parameter: Type, function: (Type) -> Type): Type {
|
|||
|
||||
### Class
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
//primary constructor
|
||||
class ClassName(private var attribute: Type) {
|
||||
|
||||
|
|
@ -177,7 +177,7 @@ class ClassName {
|
|||
|
||||
[Companion Object Docs](https://kotlinlang.org/docs/tutorials/kotlin-for-py/objects-and-companion-objects.html)
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
class ClassName {
|
||||
|
||||
// in java: static
|
||||
|
|
@ -191,7 +191,7 @@ class ClassName {
|
|||
|
||||
### ArrayList
|
||||
|
||||
```kotlin
|
||||
```kotlin linenums="1"
|
||||
var array:ArrayList<Type>? = null // List init
|
||||
|
||||
array.add(item) //add item to list
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Headings
|
||||
|
||||
```markdown
|
||||
```markdown linenums="1"
|
||||
Heading 1
|
||||
=========
|
||||
|
||||
|
|
@ -16,7 +16,7 @@ Heading 2
|
|||
|
||||
## Text Formatting
|
||||
|
||||
```markdown
|
||||
```markdown linenums="1"
|
||||
*Italic* _Italic_
|
||||
**Bold** __Bold__
|
||||
|
||||
|
|
@ -25,7 +25,7 @@ Heading 2
|
|||
|
||||
## Links & Images
|
||||
|
||||
```markdown
|
||||
```markdown linenums="1"
|
||||
[link text](http://b.org "title")
|
||||
|
||||
[link text][anchor]
|
||||
|
|
@ -37,7 +37,7 @@ Heading 2
|
|||
[anchor]: http://url/b.jpg "title"
|
||||
```
|
||||
|
||||
```markdown
|
||||
```markdown linenums="1"
|
||||
> Blockquote
|
||||
|
||||
* unordered list - unordered list
|
||||
|
|
@ -54,16 +54,16 @@ Heading 2
|
|||
|
||||
### Horizontal rule
|
||||
|
||||
```markdown
|
||||
```markdown linenums="1"
|
||||
--- ***
|
||||
```
|
||||
|
||||
## Code
|
||||
|
||||
```markdown
|
||||
```markdown linenums="1"
|
||||
`inline code`
|
||||
|
||||
```lang
|
||||
```lang linenums="1"
|
||||
multi-line
|
||||
code block
|
||||
```
|
||||
|
|
@ -71,7 +71,7 @@ Heading 2
|
|||
|
||||
## Table
|
||||
|
||||
```markdown
|
||||
```markdown linenums="1"
|
||||
| column label | column label | column label |
|
||||
|:-------------|:------------:|--------------:|
|
||||
| left-aligned | centered | right-aligned |
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ The function [spl_autoload_register()](https://www.php.net/manual/en/function.sp
|
|||
|
||||
In `autoload.php`:
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# custom function
|
||||
function autoloader($class) {
|
||||
|
||||
|
|
@ -31,7 +31,7 @@ spl_autoload_register('autoloader'); // register function
|
|||
|
||||
In `file.php`:
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
require "autoload.php";
|
||||
|
||||
# other code
|
||||
|
|
@ -43,7 +43,7 @@ require "autoload.php";
|
|||
|
||||
It's possible to resister multiple autoloading functions by calling `spl_autoload_register()` multiple times.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# prepend adds the function at the start of the queue
|
||||
# throws selects if errors in loading throw exceptions
|
||||
spl_autoload_register(callable $func, $throw=TRUE, $prepend=FALSE);
|
||||
|
|
@ -60,7 +60,7 @@ Libraries are downloaded through [Packagist](https://packagist.org/) and [GitHub
|
|||
|
||||
In `composer.json`:
|
||||
|
||||
```json
|
||||
```json linenums="1"
|
||||
{
|
||||
"require": {
|
||||
"php": ">=7.0",
|
||||
|
|
@ -93,7 +93,7 @@ To update dependencies use `composer update`. To update only the autoloading sec
|
|||
|
||||
Composer can also autoload classes belonging to the current project. It's sufficient to add the `autoload` keyword in the JSON and specify the path and autoload mode.
|
||||
|
||||
```json
|
||||
```json linenums="1"
|
||||
{
|
||||
"autoload": {
|
||||
"psr-4": {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ PDO is the PHP extension for database access through a single API. It supports v
|
|||
|
||||
### Database Connection
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$dsn = "mysql:dbname=<dbname>;host=<ip>";
|
||||
$user="<db_user>";
|
||||
$password="<db_password>";
|
||||
|
|
@ -25,7 +25,7 @@ try {
|
|||
|
||||
To execute a query it's necessary to "prepare it" with *parameters*.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# literal string with markers
|
||||
$sql = 'SELECT fields
|
||||
FROM tables
|
||||
|
|
@ -44,7 +44,7 @@ $result = $stmt->fetchAll(PDO::FETCH_CLASS, ClassName::class); # result as obje
|
|||
|
||||
### Parameter Binding
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# bindValue
|
||||
$stmt = pdo->prepare(sql);
|
||||
$stmt->bindValue(':marker', value, PDO::PARAM_<type>);
|
||||
|
|
@ -64,7 +64,7 @@ Its possible to disable this behaviour setting `PDO::ATTR_STRINGIFY_FETCHES` and
|
|||
|
||||
> **Note**: `FETCH_OBJ` abd `FETCH_CLASS` return classes and don't have this behaviour.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
pdo->setAttribute()
|
||||
|
||||
$pdo->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
|
|
@ -77,7 +77,7 @@ $result = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|||
|
||||
### PDO Debug
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute([':marker' => value]);
|
||||
$result = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
|
@ -87,7 +87,7 @@ $stmt->debugDumpParams(); # print the SQL query that has been sent to the datab
|
|||
|
||||
## [SQLite3](https://www.php.net/manual/en/book.sqlite3.php)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$db = SQLite3("db_file.sqlite3"); // connection
|
||||
|
||||
$stmt = $db->prepare("SELECT fields FROM tables WHERE field <operator> :marker"); // prepare query
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
Explicit definition of a class dependencies with the injection through the constructor or *getters*/*setters*.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
class Foo
|
||||
{
|
||||
public function __construct(PDO $pdo) // depends on PDO
|
||||
|
|
@ -24,7 +24,7 @@ The dependency injection container for humans. Installation: `composer require p
|
|||
- Use of [Reflection](https://www.php.net/manual/en/intro.reflection.php)
|
||||
- Configuration of the container through annotations & PHP code.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
class Foo
|
||||
{
|
||||
private $bar;
|
||||
|
|
@ -42,7 +42,7 @@ $foo = $container->get('Foo'); // get instance of Foo (automatic DI of Bar)
|
|||
|
||||
### DIC Configuration
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
// Foo.php
|
||||
class Foo
|
||||
{
|
||||
|
|
@ -53,7 +53,7 @@ class Foo
|
|||
}
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
// config.php
|
||||
use Psr\Container\ContainerInterface;
|
||||
|
||||
|
|
@ -68,7 +68,7 @@ return [
|
|||
];
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$builder = new \DI\ContainerBuilder();
|
||||
$builder->addDefinitions("config.php"); // load config
|
||||
$container = $builder->build(); // construct container
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
[PHP Docs](https://www.php.net/docs.php)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
declare(strict_types=1); # activates variable type checking on function arguments
|
||||
# single line comment
|
||||
//single line comment
|
||||
|
|
@ -11,7 +11,7 @@ declare(strict_types=1); # activates variable type checking on function argumen
|
|||
|
||||
## Include, Require
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
include "path\\file.php"; # import an external php file, E_WARNING if fails
|
||||
include_once "path\\file.php"; # imports only if not already loaded
|
||||
|
||||
|
|
@ -23,7 +23,7 @@ require_once "path\\file.php"; # imports only if not already loaded
|
|||
|
||||
In `config.php`:
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
//config.php
|
||||
|
||||
//store configuration options in associative array
|
||||
|
|
@ -33,7 +33,7 @@ return [
|
|||
]
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$config = include "config.php"; // retrieve config and store into variable
|
||||
```
|
||||
|
||||
|
|
@ -41,7 +41,7 @@ $config = include "config.php"; // retrieve config and store into variable
|
|||
|
||||
[PSR-4 Spec](https://www.php-fig.org/psr/psr-4/)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
namespace Foo\Bar\Baz; # set namespace for all file contents, \ for nested namespaces
|
||||
|
||||
use <PHP_Class> # using a namespace hides standard php classes (WHY?!?)
|
||||
|
|
@ -68,7 +68,7 @@ fnn\func(); # use function from Foo\Bar\Baz
|
|||
|
||||
## Basics
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
declare(strict_types=1); # activates type checking
|
||||
# single line comment
|
||||
//single line comment
|
||||
|
|
@ -77,7 +77,7 @@ declare(strict_types=1); # activates type checking
|
|||
|
||||
### Screen Output
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
echo "string"; # string output
|
||||
echo 'string\n'; # raw string output
|
||||
printf("format", $variables); # formatted output of strings and variables
|
||||
|
|
@ -86,7 +86,7 @@ sprintf("format", $variables); # return formatted string
|
|||
|
||||
### User Input
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$var = readline("prompt");
|
||||
|
||||
# if readline is not installed
|
||||
|
|
@ -105,7 +105,7 @@ if (!function_exists('readline')) {
|
|||
|
||||
## Variables
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$variableName = value; # weakly typed
|
||||
echo gettype(&variable); # output type of variable
|
||||
|
||||
|
|
@ -114,7 +114,7 @@ var_dump($var); # prints info of variable (bit dimension, type & value)
|
|||
|
||||
### Integers
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
&max = PHP_INT_MAX; # max value for int type -> 9223372036854775807
|
||||
&min = PHP_INT_MIN; # min value for int type -> -9223372036854775808
|
||||
&bytes = PHP_INT_SIZE; # bytes for int type -> 8
|
||||
|
|
@ -127,7 +127,7 @@ var_dump($var); # prints info of variable (bit dimension, type & value)
|
|||
|
||||
### Double
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$a = 1.234; // 1.234
|
||||
$b = 1.2e3; // 1200
|
||||
$c = 7E-10; // 0.0000000007
|
||||
|
|
@ -163,14 +163,14 @@ A string is a sequence of ASCII characters. In PHP a string is an array of chara
|
|||
|
||||
### String Concatenation
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$string1 . $string2; # method 1
|
||||
$string1 .= $string2; # method 2
|
||||
```
|
||||
|
||||
### String Functions
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
strlen($string); # returns the string length
|
||||
strpos($string, 'substring'); # position of substring in string
|
||||
substr($string, start, len); # extract substring of len from position start
|
||||
|
|
@ -184,7 +184,7 @@ $var = sprintf("format", $variables) # construct and return a formatted string
|
|||
|
||||
## Constants
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
define ('CONSTANT_NAME', 'value')
|
||||
```
|
||||
|
||||
|
|
@ -201,7 +201,7 @@ define ('CONSTANT_NAME', 'value')
|
|||
|
||||
Heterogeneous sequence of values.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$array = (sequence_of_items); # array declaration and valorization
|
||||
$array = [sequence_of_items]; # array declaration and valorization
|
||||
|
||||
|
|
@ -216,7 +216,7 @@ $array[] = value; # value appending
|
|||
|
||||
Array of array. Can have arbitrary number of nested array
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$matrix = [
|
||||
[1, 2, 3],
|
||||
[4, 5, 6],
|
||||
|
|
@ -228,14 +228,14 @@ $matrix = [
|
|||
|
||||
Single instruction to print whole array is ``
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$array = [1, 2, 3];
|
||||
print_r($array); # print all the array values
|
||||
```
|
||||
|
||||
### Array Functions
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
count($array); # returns number of items in the array
|
||||
array_sum($array) # sum of the array value
|
||||
sort($array); # quick sort
|
||||
|
|
@ -263,7 +263,7 @@ list($array1 [, $array2, ...]) = $data; # Python-like tuple unpacking
|
|||
|
||||
Associative arrays have a value as an index. Alternative names are _hash tables_ or _dictionaries_.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$italianDay = [
|
||||
'Mon' => 'Lunedì',
|
||||
'Tue' => 'Martedì',
|
||||
|
|
@ -309,14 +309,14 @@ With `==` a string evaluates to `0`.
|
|||
|
||||
### Ternary Operator
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
condition ? result_if_true : result_if_false;
|
||||
condition ?: result_if_false;
|
||||
```
|
||||
|
||||
### NULL Coalesce
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$var1 = $var2 ?? value; # if variable == NULL assign value, otherwise return value of $var2
|
||||
|
||||
# equivalent to
|
||||
|
|
@ -325,7 +325,7 @@ $var1 = isset($var2) ? $var2 : value
|
|||
|
||||
### Spaceship Operator
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$a <=> $b;
|
||||
|
||||
# equivalent to
|
||||
|
|
@ -339,7 +339,7 @@ if $a < $b
|
|||
|
||||
### `If` - `Elseif` - `Else`
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
if (condition) {
|
||||
# code here
|
||||
} elseif (condition) {
|
||||
|
|
@ -359,7 +359,7 @@ endif;
|
|||
|
||||
### Switch Case
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# weak comparison
|
||||
switch ($var) {
|
||||
case value:
|
||||
|
|
@ -385,7 +385,7 @@ switch (true) {
|
|||
|
||||
`match` can return values, doesn't require break statements, can combine conditions, uses strict type comparisons and doesn't do any type coercion.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$result = match($input) {
|
||||
0 => "hello",
|
||||
'1', '2', '3' => "world",
|
||||
|
|
@ -396,7 +396,7 @@ $result = match($input) {
|
|||
|
||||
### For, Foreach
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
for (init, condition, increment){
|
||||
# code here
|
||||
}
|
||||
|
|
@ -421,7 +421,7 @@ foreach($sequence as $key => $value) {
|
|||
|
||||
### While, Do-While
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
while (condition) {
|
||||
# code here
|
||||
}
|
||||
|
|
@ -447,7 +447,7 @@ do {
|
|||
|
||||
Parameters with default values are optional in the function call and must be the last ones in the function declaration. Return type is optional if type checking is disabled.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
declare(strict_types=1); # activates type checking
|
||||
|
||||
/**
|
||||
|
|
@ -475,7 +475,7 @@ function functionName (type $parameter, $parameter = default_value): Type
|
|||
|
||||
### Void function
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
function functionName (type $parameter, $parameter = default_value): Void
|
||||
{
|
||||
# code here
|
||||
|
|
@ -484,7 +484,7 @@ function functionName (type $parameter, $parameter = default_value): Void
|
|||
|
||||
### Passing a parameter by reference (`&$`)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
function functionName (type &$parameter): Type
|
||||
{
|
||||
# code here
|
||||
|
|
@ -494,7 +494,7 @@ function functionName (type &$parameter): Type
|
|||
|
||||
### Variable number of parameters, variadic operator (`...`)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
function functionName (type $parameter, ...$args): Type
|
||||
function functionName (type $parameter, type ...$args): Type
|
||||
{
|
||||
|
|
@ -505,7 +505,7 @@ function functionName (type $parameter, type ...$args): Type
|
|||
|
||||
### Nullable parameters
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
function functionName (?type $parameter): ?Type
|
||||
{
|
||||
# code here
|
||||
|
|
@ -515,7 +515,7 @@ function functionName (?type $parameter): ?Type
|
|||
|
||||
## Anonymous Functions (Closure)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# declaration and assignment to variable
|
||||
$var = function (type $parameter) {
|
||||
# code here
|
||||
|
|
@ -526,7 +526,7 @@ $var($arg);
|
|||
|
||||
### Use Operator
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# use imports a variable into the closure
|
||||
$foo = function (type $parameter) use ($average) {
|
||||
# code here
|
||||
|
|
@ -537,7 +537,7 @@ $foo = function (type $parameter) use ($average) {
|
|||
|
||||
**Union types** are a collection of two or more types which indicate that _either_ one of those _can be used_.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
public function foo(Foo|Bar $input): int|float;
|
||||
```
|
||||
|
||||
|
|
@ -546,7 +546,7 @@ public function foo(Foo|Bar $input): int|float;
|
|||
Named arguments allow to pass in values to a function, by specifying the value name, to avoid taking their order into consideration.
|
||||
It's also possible to skip optional parameters.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
function foo(string $a, string $b, ?string $c = null, ?string $d = null) { /* … */ }
|
||||
|
||||
foo(
|
||||
|
|
@ -568,7 +568,7 @@ foo(
|
|||
|
||||
### Class Declaration & Instantiation
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# case insensitive
|
||||
class ClassName
|
||||
{
|
||||
|
|
@ -611,7 +611,7 @@ $object instanceof ClassName // check type of the object
|
|||
Inside static methods it's impossible to use `$this`.
|
||||
A static variable is unique for the class and all instances.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
class ClassName {
|
||||
|
||||
public static $var;
|
||||
|
|
@ -636,7 +636,7 @@ $obj::$var; // access to the static variable
|
|||
|
||||
Parameters of the dependency can be modified before passing the required class to the constructor.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
class ClassName
|
||||
{
|
||||
private $dependency;
|
||||
|
|
@ -653,7 +653,7 @@ class ClassName
|
|||
If a class is defined `final` it can't be extended.
|
||||
If a function is declared `final` it can't be overridden.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
class Child extends Parent
|
||||
{
|
||||
public __construct() {
|
||||
|
|
@ -666,7 +666,7 @@ class Child extends Parent
|
|||
|
||||
Abstract classes cannot be instantiated;
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
abstract class ClassName
|
||||
{
|
||||
# code here
|
||||
|
|
@ -679,7 +679,7 @@ An interface is a "contract" that defines what methods the implementing classes
|
|||
|
||||
A class can implement multiple interfaces but there must be no methods in common between interface to avoid ambiguity.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
interface InterfaceName {
|
||||
|
||||
// it is possible to define __construct
|
||||
|
|
@ -703,7 +703,7 @@ It can be used to mitigate the problem of _multiple inheritance_, which is absen
|
|||
|
||||
In case of functions name conflict it's possible to use `insteadof` to specify which function to use. It's also possible to use an _alias_ to resolve the conflicts.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
trait TraitName {
|
||||
// code here
|
||||
}
|
||||
|
|
@ -716,7 +716,7 @@ class ClassName {
|
|||
|
||||
### Anonymous Classes
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$obj = new ClassName;
|
||||
|
||||
$obj->method(new class implements Interface {
|
||||
|
|
@ -728,7 +728,7 @@ $obj->method(new class implements Interface {
|
|||
|
||||
## Serialization & JSON
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$serialized = serialize($obj); # serialization
|
||||
$obj = unserialize($serialized); # de-serialization
|
||||
|
||||
|
|
@ -740,7 +740,7 @@ $json = json_encode($value); # Returns a string containing the JSON representat
|
|||
|
||||
### Read/Write on Files
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
file(filename); // return file lines in an array
|
||||
|
||||
// problematic with large files (allocates memory to read all file, can fill RAM)
|
||||
|
|
@ -750,7 +750,7 @@ file_get_contents(filename); // read whole file
|
|||
|
||||
## Regular Expressions
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
preg_match('/PATTERN/', string $subject, array $matches); # returns 1 if the pattern matches given subject, 0 if it does not, or FALSE if an error occurred
|
||||
# $matches[0] = whole matched string
|
||||
# $matches[i] = i-th group of the regex
|
||||
|
|
@ -774,7 +774,7 @@ Supported hashing algrithms:
|
|||
- `joaat`
|
||||
- `haval128,3`, `haval160,3`, `haval192,3`, `haval224,3`, `haval256,3`, `haval128,4`, `haval160,4`, `haval192,4`, `haval224,4`, `haval256,4`, `haval128,5`, `haval160,5`, `haval192,5`, `haval224,5`, `haval256,5`
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
hash($algorithm, $data);
|
||||
```
|
||||
|
||||
|
|
@ -804,7 +804,7 @@ Algorithms currently supported:
|
|||
- **time_cost** (integer) - Maximum amount of time it may take to compute the Argon2 hash. Defaults to PASSWORD_ARGON2_DEFAULT_TIME_COST.
|
||||
- **threads** (integer) - Number of threads to use for computing the Argon2 hash. Defaults to PASSWORD_ARGON2_DEFAULT_THREADS.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
password_hash($password, $algorithm); # create a new password hash using a strong one-way hashing algorithm.
|
||||
password_verify($password, $hash); # Verifies that a password matches a hash
|
||||
```
|
||||
|
|
@ -817,17 +817,17 @@ Types of PHP errors:
|
|||
- **Warning**: generated at runtime, does not stop the execution (non-blocking).
|
||||
- **Notice**: informative errors or messages, non-blocking.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$a = new StdClass()
|
||||
$a->foo(); // PHP Fatal Error: foo() does not exist
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$a = 0;
|
||||
echo 1/$a; // PHP Warning: Division by zero
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
echo $a; // PHP Notice: $a undefined
|
||||
```
|
||||
|
||||
|
|
@ -837,7 +837,7 @@ echo $a; // PHP Notice: $a undefined
|
|||
|
||||
Its possible to configure PHP to signal only some type of errors. Errors below a certain levels are ignored.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
error_reporting(E_<type>); // set error report threshold (for log file)
|
||||
// does not disable PARSER ERROR
|
||||
|
||||
|
|
@ -847,7 +847,7 @@ ini_set("error_log", "path\\error.log"); // set log file
|
|||
|
||||
### Triggering Errors
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
// generate E_USER_ errors
|
||||
trigger_error("message"); // default type: E_USER_NOTICE
|
||||
trigger_error("message", E_USER_<Type>);
|
||||
|
|
@ -859,7 +859,7 @@ trigger_error("Deprecated Function", E_USER_DEPRECATED);
|
|||
|
||||
It's possible to use log files unrelated to the php log file.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
error_log("message", 3, "path\\log.log"); // write log message to a specified file
|
||||
|
||||
//example
|
||||
|
|
@ -870,7 +870,7 @@ error_log(sprintf("[%s] Error: _", date("Y-m-d h:i:s")), 3, "path\\log.log")
|
|||
|
||||
PHP offers the possibility to handle errors with the _exception model_.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
try {
|
||||
// dangerous code
|
||||
} catch(ExceptionType1 | ExceptionType2 $e) {
|
||||
|
|
@ -884,7 +884,7 @@ throw new ExceptionType("message"); // throw an exception
|
|||
|
||||
All exceptions in PHP implement the interface `Throwable`.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
Interface Throwable {
|
||||
abstract public string getMessage ( void )
|
||||
abstract public int getCode ( void )
|
||||
|
|
@ -899,7 +899,7 @@ Interface Throwable {
|
|||
|
||||
### Custom Exceptions
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
/**
|
||||
* Define a custom exception class
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ To separate HTML code and PHP code it's possible to use **templates** with marke
|
|||
Variables are created in the PHP code and are passed to the template in the **rendering** phase.
|
||||
The server transmits only the `index.php` file to the user. The php file renders the templates as needed.
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<html>
|
||||
<head>
|
||||
<title><?= $this->e($title)?></title>
|
||||
|
|
@ -24,7 +24,7 @@ Plates is a template engine for PHP. A template engine permits to separate the P
|
|||
|
||||
Installation through composer: `composer require league/plates`.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# index.php
|
||||
require "vendor/autoload.php";
|
||||
|
||||
|
|
@ -38,7 +38,7 @@ echo $templates->render("template_name", [
|
|||
]);
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# template.php
|
||||
<html>
|
||||
<head>
|
||||
|
|
@ -60,7 +60,7 @@ In a layout it's possible to create a section called **content** that identifies
|
|||
|
||||
> **Note**: Since only the template has the data passed eventual loops have to be done there.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# index.php
|
||||
require 'vendor/autoload.php';
|
||||
use League\Plates\Engine;
|
||||
|
|
@ -68,7 +68,7 @@ $template = new Engine('/path/to/templates');
|
|||
echo $template->render('template_name', [ "marker" => value, ... ]);
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# template.php
|
||||
|
||||
# set the layout used for this template
|
||||
|
|
@ -78,7 +78,7 @@ echo $template->render('template_name', [ "marker" => value, ... ]);
|
|||
<p> <?= $this->e($marker) ?> </p>
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# layout.php
|
||||
<html>
|
||||
<head>
|
||||
|
|
@ -101,7 +101,7 @@ In general the output validation allows to prevent [Cross-Site Scripting][owasp-
|
|||
|
||||
### Folders
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# index.php
|
||||
$templates->addFolder("alias", "path/to/template/folder"); # add a template folder
|
||||
echo $templates->render("folder::template"); # use a template in a specific folder
|
||||
|
|
@ -111,7 +111,7 @@ echo $templates->render("folder::template"); # use a template in a specific fol
|
|||
|
||||
It's possible to inject templates in a layout or template. It is done by using the `insert()` function.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# layout.php
|
||||
<html>
|
||||
<head>
|
||||
|
|
@ -132,7 +132,7 @@ It's possible to inject templates in a layout or template. It is done by using t
|
|||
It's possible to insert page contest from another template with the `section()` function.
|
||||
The content to be inserted must be surrounded with by the `start()` and `stop()` functions.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
# template.php
|
||||
|
||||
<?php $this->start("section_name") ?> # start section
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ Standard of the PHP Framework Interop Group that defines common interfaces for h
|
|||
|
||||
Example:
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
// empty array if not found
|
||||
$header = $request->getHeader('Accept');
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Routing (Example)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
// config/route.php
|
||||
return [
|
||||
[ 'GET', '/api/user[/{id}]', Controller\User::class ],
|
||||
|
|
@ -14,7 +14,7 @@ return [
|
|||
|
||||
## Controller (Example)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
public class UserController implements ControllerInterface
|
||||
{
|
||||
public function __construct(UserModel $user)
|
||||
|
|
|
|||
|
|
@ -6,18 +6,17 @@ This framework is mainly used as tutorial for introducing the Model-View-Control
|
|||
|
||||
[php-di]: https://php-di.org/
|
||||
[fastroute]: https://github.com/nikic/FastRoute
|
||||
[psr7]:https://github.com/Nyholm/psr7
|
||||
[plates]: https://platesphp.com/
|
||||
|
||||
## Installation
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
composer create-project ezimuel/simple-mvc
|
||||
```
|
||||
|
||||
## Structure
|
||||
|
||||
```txt
|
||||
```txt linenums="1"
|
||||
|- config
|
||||
| |- container.php --> DI Container Config (PHP-DI)
|
||||
| |- route.php --> routing
|
||||
|
|
@ -35,7 +34,7 @@ composer create-project ezimuel/simple-mvc
|
|||
|
||||
### `index.php`
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
<?php
|
||||
declare(strict_types=1);
|
||||
|
||||
|
|
@ -99,7 +98,7 @@ $controller->execute($request);
|
|||
|
||||
### `route.php`
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
<?php
|
||||
use SimpleMVC\Controller;
|
||||
|
||||
|
|
@ -112,7 +111,7 @@ return [
|
|||
|
||||
### `container.php`
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
<?php
|
||||
use League\Plates\Engine;
|
||||
use Psr\Container\ContainerInterface;
|
||||
|
|
@ -131,7 +130,7 @@ return [
|
|||
|
||||
Each controller *must* implement this interface.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
<?php
|
||||
declare(strict_types=1);
|
||||
|
||||
|
|
|
|||
|
|
@ -4,11 +4,11 @@
|
|||
|
||||
### Dev-Only Installation
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
composer require --dev phpunit/phpunit
|
||||
```
|
||||
|
||||
```json
|
||||
```json linenums="1"
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "<version>"
|
||||
}
|
||||
|
|
@ -18,7 +18,7 @@ composer require --dev phpunit/phpunit
|
|||
|
||||
PHPUnit can be configured in a XML file called `phpunit.xml`:
|
||||
|
||||
```xml
|
||||
```xml linenums="1"
|
||||
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
|
||||
bootstrap="vendor/autoload.php"
|
||||
|
|
@ -46,7 +46,7 @@ PHPUnit can be configured in a XML file called `phpunit.xml`:
|
|||
A test is a method of a *test class* prefixed with `test`.
|
||||
PHPUnit is executed from the command line with `vendor/bin/phpunit --colors`.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
namespace App;
|
||||
|
||||
class Filter
|
||||
|
|
@ -58,7 +58,7 @@ class Filter
|
|||
}
|
||||
```
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
namespace App\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use App\Filter;
|
||||
|
|
@ -92,7 +92,7 @@ class FilterTest extends TestCase
|
|||
|
||||
### [PHPUnit Testing Exceptions](https://phpunit.readthedocs.io/en/9.3/writing-tests-for-phpunit.html#testing-exceptions)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
public function testAggiungiEsameException(string $esame)
|
||||
{
|
||||
$this->expectException(Exception::class);
|
||||
|
|
@ -131,7 +131,7 @@ public function testNoExceptions(string $esame)
|
|||
|
||||
### Test Setup & Teardown (Example)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
class ClassTest extends TestCase
|
||||
{
|
||||
// initialize the test
|
||||
|
|
@ -157,7 +157,7 @@ class ClassTest extends TestCase
|
|||
|
||||
### Data Provider
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
class DataTest extends TestCase
|
||||
{
|
||||
/**
|
||||
|
|
@ -195,7 +195,7 @@ class DataTest extends TestCase
|
|||
|
||||
### Mock Objects
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
class UnitTest extends TestCase
|
||||
{
|
||||
public function setUp()
|
||||
|
|
@ -225,6 +225,6 @@ class UnitTest extends TestCase
|
|||
|
||||
### Code Coverage (needs [XDebug](https://xdebug.org/))
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
vendor/bin/phpunit --coverage-text # code coverage analysis in the terminal
|
||||
```
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
Command Line Web Server in PHP, useful in testing phase. Limited since handles only one request at a time. **Do not use in production**.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
PHP -S <ip:post> # start web server
|
||||
PHP -S <ip:post> -t /path/to/folder # execute in specified folder at specified address
|
||||
PHP -S <ip:post> file.php # redirect requests to single file
|
||||
|
|
@ -22,7 +22,7 @@ Handling of HTTP requests happens using the following global variables:
|
|||
|
||||
### `$_FILES`
|
||||
|
||||
```html
|
||||
```html linenums="1"
|
||||
<!-- method MUST BE post -->
|
||||
<!-- must have enctype="multipart/form-data" attribute -->
|
||||
<form name="<name>" action="file.php" method="POST" enctype="multipart/form-data">
|
||||
|
|
@ -33,7 +33,7 @@ Handling of HTTP requests happens using the following global variables:
|
|||
|
||||
Files in `$_FILES` are memorized in a system temp folder. They can be moved with `move_uploaded_file()`
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
if (! isset($_FILES['photo']['error'])) {
|
||||
http_response_code(400); # send a response code
|
||||
echo'<h1>No file has been sent</h1>';
|
||||
|
|
@ -61,7 +61,7 @@ echo'<h1>File successfully sent</h1>';
|
|||
|
||||
Request Header Access:
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$_SERVER["REQUEST_METHOD"];
|
||||
$_SERVER["REQUEST_URI"];
|
||||
$_SERVER["SERVER_PROTOCOL"]; // HTTP Versions
|
||||
|
|
@ -83,7 +83,7 @@ All sites **must** have a page for the consensus about using cookies.
|
|||
**Cookies** are HTTP headers used to memorize key-value info *on the client*. They are sent from the server to the client to keep track of info on the user that is visiting the website.
|
||||
When a client receives a HTTP response that contains `Set-Cookie` headers it has to memorize that info and reuse them in future requests.
|
||||
|
||||
```http
|
||||
```http linenums="1"
|
||||
Set-Cookie: <cookie-name>=<cookie-value>
|
||||
Set-Cookie: <cookie-name>=<cookie-value>; Expires=<date>
|
||||
Set-Cookie: <cookie-name>=<cookie-value>; Max-Age=<seconds>
|
||||
|
|
@ -97,13 +97,13 @@ Anyone can modify the contents of a cookie; for this reason cookies **must not c
|
|||
|
||||
When a client has memorized a cookie, it is sent in successive HTTP requests through the `Cookie` header.
|
||||
|
||||
```http
|
||||
```http linenums="1"
|
||||
Cookie: <cookie-name>=<cookie-value>
|
||||
```
|
||||
|
||||
[PHP setcookie docs](https://www.php.net/manual/en/function.setcookie.php)
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
setcookie (
|
||||
string $name,
|
||||
[ string $value = "" ],
|
||||
|
|
@ -130,7 +130,7 @@ PHP generates a cookie named `PHPSESSID` containing a *session identifier* and a
|
|||
To use the session it's necessary to recall the function `session_start()` at the beginning of a PHP script that deals with sessions.
|
||||
After starting the session information in be saved in the `$_SESSION` array.
|
||||
|
||||
```php
|
||||
```php linenums="1"
|
||||
$_SESSION["key"] = value; // save data in session file (serialized data)
|
||||
|
||||
unset($_SESSION["key"]); // delete data from the session
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# Powershell Commands
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
Get-Location # Gets information about the current working location or a location stack
|
||||
Set-Location -Path <path> # change current working directory to specified path (DEFAULTs to ~)
|
||||
Get-ChildItem -Path <path> # Gets the items and child items in one or more specified locations.
|
||||
|
|
|
|||
|
|
@ -11,20 +11,20 @@ If you do call a cmdlet/PS function with parentheses, it is the same as passing
|
|||
|
||||
## Screen Output
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
Write-Host "message"
|
||||
```
|
||||
|
||||
## User Input
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# Reading a value from input:
|
||||
$variable = Read-Host "prompt"
|
||||
```
|
||||
|
||||
## Variables
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# Declaration
|
||||
[type]$var = value
|
||||
$var = value -as [type]
|
||||
|
|
@ -52,7 +52,7 @@ Write-Host (<expression>)
|
|||
|
||||
### Built-in Variables
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
$True, $False # boolean
|
||||
$null # empty value
|
||||
$? # last program return value
|
||||
|
|
@ -71,7 +71,7 @@ $Args # Unbound arguments
|
|||
|
||||
### Lists & Dictionaries
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
$List = @(5, "ice", 3.14, $True) # Explicit syntax
|
||||
$List = 2, "ice", 3.14, $True # Implicit syntax
|
||||
$List = (1..10) # Inclusive range
|
||||
|
|
@ -93,7 +93,7 @@ foreach ($k in $Dict.keys) {
|
|||
|
||||
## Flow Control
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
if (condition) {
|
||||
# Code here
|
||||
} elseif (condition) {
|
||||
|
|
@ -113,7 +113,7 @@ if (condition) {
|
|||
- **File**: Takes input from a file rather than a value statement. If multiple File parameters are included, only the last one is used. Each line of the file is read and evaluated by the Switch statement. The comparison is case-insensitive.
|
||||
- **Regex**: Performs regular expression matching of the value to the condition. If the match clause is not a string, this parameter is ignored. The comparison is case-insensitive. The `$matches` automatic variable is available for use within the matching statement block.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
switch(variable) {
|
||||
20 { "Exactly 20"; break }
|
||||
{ $_ -eq 42 } { "The answer equals 42"; break }
|
||||
|
|
@ -142,7 +142,7 @@ switch [-regex|-wildcard|-exact][-casesensitive] -file filename
|
|||
|
||||
### Loops
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# The classic for
|
||||
for(setup; condition; iterator) {
|
||||
# Code here
|
||||
|
|
@ -169,7 +169,7 @@ do {
|
|||
|
||||
### Operators
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# Conditionals
|
||||
$a -eq $b # is equal to
|
||||
$a -ne $b # in not equal to
|
||||
|
|
@ -186,7 +186,7 @@ $True -Or $False
|
|||
|
||||
### Exception Handling
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
try {} catch {} finally {}
|
||||
try {} catch [System.NullReferenceException] {
|
||||
echo $_.Exception | Format-List -Force
|
||||
|
|
@ -195,7 +195,7 @@ try {} catch [System.NullReferenceException] {
|
|||
|
||||
## [Functions](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_functions?view=powershell-7)
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
function func() {}
|
||||
|
||||
# function with named parameters
|
||||
|
|
@ -221,7 +221,7 @@ If the function defines a `Begin`, `Process` or `End` block, all the code **must
|
|||
|
||||
If the function has a `Process` keyword, each object in `$input` is removed from `$input` and assigned to `$_`.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
function [<scope:>]<name> [([type]$parameter1[,[type]$parameter2])]
|
||||
{
|
||||
param([type]$parameter1 [,[type]$parameter2]) # other way to specify named parameters
|
||||
|
|
@ -236,7 +236,7 @@ function [<scope:>]<name> [([type]$parameter1[,[type]$parameter2])]
|
|||
|
||||
Optionally, it's possible to provide a brief help string that describes the default value of the parameter, by adding the `PSDefaultValue` attribute to the description of the parameter, and specifying the `Help` property of `PSDefaultValue`.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
function Func {
|
||||
param (
|
||||
[PSDefaultValue(Help = defValue)]
|
||||
|
|
@ -249,7 +249,7 @@ function Func {
|
|||
|
||||
### Parsing Script Arguments
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
$args # array of passed arguments
|
||||
$args[$index] # access to the arguments
|
||||
$args.count # number of arguments
|
||||
|
|
@ -259,7 +259,7 @@ $args.count # number of arguments
|
|||
|
||||
In `scripts.ps1`:
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
param($param1, $param2, ...) # basic usage
|
||||
param($param1, $param2=defvalue, ...) # with default values
|
||||
param([Type] $param1, $param2, ...) # specify a type
|
||||
|
|
@ -270,7 +270,7 @@ param([switch]$flag=$false, ...) # custom flags
|
|||
|
||||
In PowerShell:
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
.\script.ps1 arg1 arg2 # order of arguments will determine which data goes in which parameter
|
||||
|
||||
.\script.ps1 -param2 arg2 -param1 arg1 # custom order
|
||||
|
|
@ -280,7 +280,7 @@ In PowerShell:
|
|||
|
||||
A filter is a type of function that runs on each object in the pipeline. A filter resembles a function with all its statements in a `Process` block.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
filter [<scope:>]<name> {<statement list>}
|
||||
```
|
||||
|
||||
|
|
@ -288,14 +288,14 @@ filter [<scope:>]<name> {<statement list>}
|
|||
|
||||
The syntax for comment-based help is as follows:
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# .<help keyword>
|
||||
# <help content>
|
||||
```
|
||||
|
||||
or
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
<#
|
||||
.<help keyword>
|
||||
<help content>
|
||||
|
|
@ -322,7 +322,7 @@ The description of a parameter. Add a `.PARAMETER` keyword for each parameter in
|
|||
|
||||
Type the parameter name on the same line as the `.PARAMETER` keyword. Type the parameter description on the lines following the `.PARAMETER` keyword. Windows PowerShell interprets all text between the `.PARAMETER` line and the next keyword or the end of the comment block as part of the parameter description. The description can include paragraph breaks.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
.PARAMETER <Parameter-Name>
|
||||
```
|
||||
|
||||
|
|
@ -332,7 +332,7 @@ You can also specify a parameter description by placing a comment in the functio
|
|||
|
||||
If you use both a syntax comment and a `.PARAMETER` keyword, the description associated with the `.PARAMETER` keyword is used, and the syntax comment is ignored.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
<#
|
||||
.SYNOPSIS
|
||||
Short description here
|
||||
|
|
@ -389,7 +389,7 @@ The keywords that describe the intended use of the function. The **Functionality
|
|||
|
||||
Redirects to the help topic for the specified command. You can redirect users to any help topic, including help topics for a function, script, cmdlet, or provider.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# .FORWARDHELPTARGETNAME <Command-Name>
|
||||
```
|
||||
|
||||
|
|
@ -397,7 +397,7 @@ Redirects to the help topic for the specified command. You can redirect users to
|
|||
|
||||
Specifies the help category of the item in `.ForwardHelpTargetName`. Valid values are `Alias`, `Cmdlet`, `HelpFile`, `Function`, `Provider`, `General`, `FAQ`, `Glossary`, `ScriptCommand`, `ExternalScript`, `Filter`, or `All`. Use this keyword to avoid conflicts when there are commands with the same name.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# .FORWARDHELPCATEGORY <Category>
|
||||
```
|
||||
|
||||
|
|
@ -406,7 +406,7 @@ Specifies the help category of the item in `.ForwardHelpTargetName`. Valid value
|
|||
Specifies a session that contains the help topic. Enter a variable that contains a **PSSession** object. This keyword is used by the [Export-PSSession](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/export-pssession?view=powershell-7)
|
||||
cmdlet to find the help topics for the exported commands.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# .REMOTEHELPRUNSPACE <PSSession-variable>
|
||||
```
|
||||
|
||||
|
|
@ -414,7 +414,7 @@ cmdlet to find the help topics for the exported commands.
|
|||
|
||||
Specifies an XML-based help file for the script or function.
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
# .EXTERNALHELP <XML Help File>
|
||||
|
||||
```
|
||||
|
|
@ -425,7 +425,7 @@ The `.ExternalHelp` keyword takes precedence over other comment-based help keywo
|
|||
|
||||
If the function is exported by a module, set the value of the `.ExternalHelp` keyword to a filename without a path. `Get-Help` looks for the specified file name in a language-specific subdirectory of the module directory. There are no requirements for the name of the XML-based help file for a function, but a best practice is to use the following format:
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
<ScriptModule.psm1>-help.xml
|
||||
```
|
||||
|
||||
|
|
@ -439,7 +439,7 @@ For more information about the cmdlet help XML-based help file format, see [How
|
|||
|
||||
### Classes
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
[class]::func() # use function from a static class
|
||||
[class]::attribute # access to static class attribute
|
||||
```
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Making the Soup
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
|
||||
from bs4 import BeautifulSoup
|
||||
import requests
|
||||
|
|
@ -24,7 +24,7 @@ Beautiful Soup transforms a complex HTML document into a complex tree of Python
|
|||
|
||||
A Tag object corresponds to an XML or HTML tag in the original document
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
soup = BeautifulSoup('<b class="boldest">Extremely bold</b>', 'html.parser') # parse HTML/XML
|
||||
|
||||
tag = soup.b
|
||||
|
|
@ -44,7 +44,7 @@ A string corresponds to a bit of text within a tag. Beautiful Soup uses the `Nav
|
|||
|
||||
### Going Down
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
soup.<tag>.<child_tag> # navigate using tag names
|
||||
|
||||
<tag>.contents # direct children as a list
|
||||
|
|
@ -61,14 +61,14 @@ soup.<tag>.<child_tag> # navigate using tag names
|
|||
|
||||
### Going Up
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
<tag>.parent # tags direct parent (BeautifulSoup has parent None, html has parent BeautifulSoup)
|
||||
<tag>.parents # iterable over all parents
|
||||
```
|
||||
|
||||
### Going Sideways
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
<tag>.previous_sibling
|
||||
<tag>.next_sibling
|
||||
|
||||
|
|
@ -78,7 +78,7 @@ soup.<tag>.<child_tag> # navigate using tag names
|
|||
|
||||
### Going Back and Forth
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
<tag>.previous_element # whatever was parsed immediately before
|
||||
<tag>.next_element # whatever was parsed immediately afterwards
|
||||
|
||||
|
|
@ -90,7 +90,7 @@ soup.<tag>.<child_tag> # navigate using tag names
|
|||
|
||||
## Filter Types
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
soup.find_all("tag") # by name
|
||||
soup.find_all(["tag1", "tag2"]) # multiple tags in a list
|
||||
soup.find_all(function) # based on a bool function
|
||||
|
|
@ -107,7 +107,7 @@ Methods arguments:
|
|||
- `limit` (int). limit number of results
|
||||
- `**kwargs`: be turned into a filter on one of a tag's attributes.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
find_all(name, attrs, recursive, string, limit, **kwargs) # several results
|
||||
find(name, attrs, recursive, string, **kwargs) # one result
|
||||
|
||||
|
|
@ -135,7 +135,7 @@ soup.select("css_selector") # search for CSS selectors of HTML tags
|
|||
|
||||
### Changing Tag Names an Attributes
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
<tag>.name = "new_html_tag" # modify the tag type
|
||||
<tag>["attribute"] = "value" # modify the attribute value
|
||||
del <tag>["attribute"] # remove the attribute
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## MOST IMPORTANT ATTRIBUTES ATTRIBUTES
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
array.ndim # number of axes (dimensions) of the array
|
||||
array.shape # dimensions of the array, tuple of integers
|
||||
array.size # total number of elements in the array
|
||||
|
|
@ -15,7 +15,7 @@ array.data # buffer containing the array elements
|
|||
Unless explicitly specified `np.array` tries to infer a good data type for the array that it creates.
|
||||
The data type is stored in a special dtype object.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
var = np.array(sequence) # creates array
|
||||
var = np.asarray(sequence) # convert input to array
|
||||
var = np.ndarray(*sequence) # creates multidimensional array
|
||||
|
|
@ -33,7 +33,7 @@ var = np.linspace(start, stop, num_of_elements) # step of elements calculated b
|
|||
|
||||
## DATA TYPES FOR NDARRAYS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
var = array.astype(np.dtype) # copy of the array, cast to a specified type
|
||||
# return TypeError if casting fails
|
||||
```
|
||||
|
|
@ -72,7 +72,7 @@ array_1 `/` array_2 --> element-wise division (`[1, 2, 3] / [3, 2, 1] = [0.33, 1
|
|||
|
||||
## SHAPE MANIPULATION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.reshape(array, new_shape) # changes the shape of the array
|
||||
np.ravel(array) # returns the array flattened
|
||||
array.resize(shape) # modifies the array itself
|
||||
|
|
@ -84,7 +84,7 @@ np.swapaxes(array, first_axis, second_axis) # interchange two axes of an array
|
|||
|
||||
## JOINING ARRAYS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.vstack((array1, array2)) # takes tuple, vertical stack of arrays (column wise)
|
||||
np.hstack((array1, array2)) # takes a tuple, horizontal stack of arrays (row wise)
|
||||
np.dstack((array1, array2)) # takes a tuple, depth wise stack of arrays (3rd dimension)
|
||||
|
|
@ -94,7 +94,7 @@ np.concatenate((array1, array2, ...), axis) # joins a sequence of arrays along a
|
|||
|
||||
## SPLITTING ARRAYS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.split(array, indices) # splits an array into equall7 long sub-arrays (indices is int), if not possible raises error
|
||||
np.vsplit(array, indices) # splits an array equally into sub-arrays vertically (row wise) if not possible raises error
|
||||
np.hsplit(array, indices) # splits an array equally into sub-arrays horizontally (column wise) if not possible raises error
|
||||
|
|
@ -104,7 +104,7 @@ np.array_split(array, indices) # splits an array into sub-arrays, arrays can be
|
|||
|
||||
## VIEW()
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
var = array.view() # creates a new array that looks at the same data
|
||||
# slicing returns a view
|
||||
# view shapes are separated but assignment changes all arrays
|
||||
|
|
@ -112,7 +112,7 @@ var = array.view() # creates a new array that looks at the same data
|
|||
|
||||
## COPY()
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
var = array.copy() # creates a deep copy of the array
|
||||
```
|
||||
|
||||
|
|
@ -136,7 +136,7 @@ iteration on first index, use .flat() to iterate over each element
|
|||
|
||||
Functions that performs element-wise operations (vectorization).
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.abs(array) # vectorized abs(), return element absolute value
|
||||
np.fabs(array) # faster abs() for non-complex values
|
||||
np.sqrt(array) # vectorized square root (x^0.5)
|
||||
|
|
@ -193,7 +193,7 @@ np.logical_xor(x_array, y_array) # vectorized x ^ y
|
|||
|
||||
## CONDITIONAL LOGIC AS ARRAY OPERATIONS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.where(condition, x, y) # return x if condition == True, y otherwise
|
||||
```
|
||||
|
||||
|
|
@ -202,7 +202,7 @@ np.where(condition, x, y) # return x if condition == True, y otherwise
|
|||
`np.method(array, args)` or `array.method(args)`.
|
||||
Boolean values are coerced to 1 (`True`) and 0 (`False`).
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.sum(array, axis=None) # sum of array elements over a given axis
|
||||
np.median(array, axis=None) # median along the specified axis
|
||||
np.mean(array, axis=None) # arithmetic mean along the specified axis
|
||||
|
|
@ -220,21 +220,21 @@ np.cumprod(array, axis=None) # cumulative sum of the elements along a given axi
|
|||
|
||||
## METHODS FOR BOOLEAN ARRAYS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.all(array, axis=None) # test whether all array elements along a given axis evaluate to True
|
||||
np.any(array, axis=None) # test whether any array element along a given axis evaluates to True
|
||||
```
|
||||
|
||||
## SORTING
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
array.sort(axis=-1) # sort an array in-place (axis = None applies on flattened array)
|
||||
np.sort(array, axis=-1) # return a sorted copy of an array (axis = None applies on flattened array)
|
||||
```
|
||||
|
||||
## SET LOGIC
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.unique(array) # sorted unique elements of an array
|
||||
np.intersect1d(x, y) # sorted common elements in x and y
|
||||
np.union1d(x, y) # sorte union of elements
|
||||
|
|
@ -245,7 +245,7 @@ np.setxor1d() # Set symmetric differences; elements that are in either of the a
|
|||
|
||||
## FILE I/O WITH ARRAYS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.save(file, array) # save array to binary file in .npy format
|
||||
np.savez(file, *array) # save several arrays into a single file in uncompressed .npz format
|
||||
np.savez_compressed(file, *args, *kwargs) # save several arrays into a single file in compressed .npz format
|
||||
|
|
@ -266,7 +266,7 @@ np.loadtxt(file, dtype=float, comments="#", delimiter=None)
|
|||
|
||||
## LINEAR ALGEBRA
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.diag(array, k=0) # extract a diagonal or construct a diagonal array
|
||||
# K: {int} -- k>0 diagonals above main diagonal, k<0 diagonals below main diagonal (main diagonal k = 0)
|
||||
|
||||
|
|
@ -290,7 +290,7 @@ np.linalg.lstsq(A, B) # return the least-squares solution to a linear matrix eq
|
|||
|
||||
## RANDOM NUMBER GENERATION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
np.random.seed()
|
||||
np.random.rand()
|
||||
np.random.randn()
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Basic Pandas Imports
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from pandas import Series, DataFrame
|
||||
|
|
@ -13,7 +13,7 @@ from pandas import Series, DataFrame
|
|||
1-dimensional labelled array, axis label referred as INDEX.
|
||||
Index can contain repetitions.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
s = Series(data, index=index, name='name')
|
||||
# DATA: {python dict, ndarray, scalar value}
|
||||
# NAME: {string}
|
||||
|
|
@ -22,7 +22,7 @@ s = Series(dict) # Series created from python dict, dict keys become index valu
|
|||
|
||||
### INDEXING / SELECTION / SLICING
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
s['index'] # selection by index label
|
||||
s[condition] # return slice selected by condition
|
||||
s[ : ] # slice endpoint included
|
||||
|
|
@ -34,7 +34,7 @@ s[condition] = *value # modify slice by condition
|
|||
|
||||
Missing data appears as NaN (Not a Number).
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.isnull(array) # return a Series index-bool indicating which indexes don't have data
|
||||
pd.notnull(array) # return a Series index-bool indicating which indexes have data
|
||||
array.isnull()
|
||||
|
|
@ -43,7 +43,7 @@ array.notnull()
|
|||
|
||||
### SERIES ATTRIBUTES
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
s.values # NumPy representation of Series
|
||||
s.index # index object of Series
|
||||
s.name = "Series name" # renames Series object
|
||||
|
|
@ -52,7 +52,7 @@ s.index.name = "index name" # renames index
|
|||
|
||||
### SERIES METHODS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.isin(self, values) # boolean Series showing whether elements in Series matches elements in values exactly
|
||||
|
||||
# Conform Series to new index, new object produced unless the new index is equivalent to current one and copy=False
|
||||
|
|
@ -80,7 +80,7 @@ pd.Series.value_counts(self, normalize=False, sort=True, ascending=False, bins=N
|
|||
2-dimensional labeled data structure with columns of potentially different types.
|
||||
Index and columns can contain repetitions.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
df = DataFrame(data, index=row_labels, columns=column_labels)
|
||||
# DATA: {list, dict (of lists), nested dicts, series, dict of 1D ndarray, 2D ndarray, DataFrame}
|
||||
# INDEX: {list of row_labels}
|
||||
|
|
@ -112,7 +112,7 @@ del df[col] # delete column
|
|||
|
||||
### DATAFRAME ATTRIBUTES
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
df.index # row labels
|
||||
df.columns # column labels
|
||||
df.values # NumPy representation of DataFrame
|
||||
|
|
@ -123,7 +123,7 @@ df.T # transpose
|
|||
|
||||
### DATAFRAME METHODS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.DataFrame.isin(self , values) # boolean DataFrame showing whether elements in DataFrame matches elements in values exactly
|
||||
|
||||
# Conform DataFrame to new index, new object produced unless the new index is equivalent to current one and copy=False
|
||||
|
|
@ -146,7 +146,7 @@ Holds axis labels and metadata, immutable.
|
|||
|
||||
### INDEX TYPES
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Index # immutable ordered ndarray, sliceable. stores axis labels
|
||||
pd.Int64Index # special case of Index with purely integer labels
|
||||
pd.MultiIndex # multi-level (hierarchical) index object for pandas objects
|
||||
|
|
@ -156,7 +156,7 @@ pd.DatetimeIndex # nanosecond timestamps (uses Numpy datetime64)
|
|||
|
||||
### INDEX ATTRIBUTERS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Index.is_monotonic_increasing # Return True if the index is monotonic increasing (only equal or increasing) values
|
||||
pd.Index.is_monotonic_decreasing # Return True if the index is monotonic decreasing (only equal or decreasing) values
|
||||
pd.Index.is_unique # Return True if the index has unique values.
|
||||
|
|
@ -165,7 +165,7 @@ pd.Index.hasnans # Return True if the index has NaNs
|
|||
|
||||
### INDEX METHODS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Index.append(self, other) # append a collection of Index options together
|
||||
|
||||
pd.Index.difference(self, other, sort=None) # set difference of two Index objects
|
||||
|
|
@ -197,7 +197,7 @@ Missing values propagate in arithmetic computations (NaN `<operator>` value = Na
|
|||
|
||||
### ADDITION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
self + other
|
||||
pd.Series.add(self, other, fill_value=None) # add(), supports substitution of NaNs
|
||||
pd,Series.radd(self, other, fill_value=None) # radd(), supports substitution of NaNs
|
||||
|
|
@ -210,7 +210,7 @@ pd.DataFrame.radd(self, other, axis=columns, fill_value=None) # radd(), support
|
|||
|
||||
### SUBTRACTION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
self - other
|
||||
pd.Series.sub(self, other, fill_value=None) # sub(), supports substitution of NaNs
|
||||
pd.Series.radd(self, other, fill_value=None) # radd(), supports substitution of NaNs
|
||||
|
|
@ -223,7 +223,7 @@ pd.DataFrame.rsub(self, other, axis=columns, fill_value=None) # rsub(), support
|
|||
|
||||
### MULTIPLICATION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
self * other
|
||||
pd.Series.mul(self, other, fill_value=None) # mul(), supports substitution of NaNs
|
||||
pd.Series.rmul(self, other, fill_value=None) # rmul(), supports substitution of NaNs
|
||||
|
|
@ -236,7 +236,7 @@ pd.DataFrame.rmul(self, other, axis=columns, fill_value=None) # rmul(), support
|
|||
|
||||
### DIVISION (float division)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
self / other
|
||||
pd.Series.div(self, other, fill_value=None) # div(), supports substitution of NaNs
|
||||
pd.Series.rdiv(self, other, fill_value=None) # rdiv(), supports substitution of NaNs
|
||||
|
|
@ -253,7 +253,7 @@ pd.DataFrame.rtruediv(self, other, axis=columns, fill_value=None) # rtruediv(),
|
|||
|
||||
### FLOOR DIVISION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
self // other
|
||||
pd.Series.floordiv(self, other, fill_value=None) # floordiv(), supports substitution of NaNs
|
||||
pd.Series.rfloordiv(self, other, fill_value=None) # rfloordiv(), supports substitution of NaNs
|
||||
|
|
@ -266,7 +266,7 @@ pd.DataFrame.rfloordiv(self, other, axis=columns, fill_value=None) # rfloordiv(
|
|||
|
||||
### MODULO
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
self % other
|
||||
pd.Series.mod(self, other, fill_value=None) # mod(), supports substitution of NaNs
|
||||
pd.Series.rmod(self, other, fill_value=None) # rmod(), supports substitution of NaNs
|
||||
|
|
@ -279,7 +279,7 @@ pd.DataFrame.rmod(self, other, axis=columns, fill_value=None) # rmod(), support
|
|||
|
||||
### POWER
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
other ** self
|
||||
pd.Series.pow(self, other, fill_value=None) # pow(), supports substitution of NaNs
|
||||
pd.Series.rpow(self, other, fill_value=None) # rpow(), supports substitution of NaNs
|
||||
|
|
@ -296,7 +296,7 @@ pd.DataFrame.rpow(self, other, axis=columns, fill_value=None) # rpow(), support
|
|||
|
||||
NumPy ufuncs work fine with pandas objects.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.DataFrame.applymap(self, func) # apply function element-wise
|
||||
|
||||
pd.DataFrame.apply(self, func, axis=0, args=()) # apply a function along an axis of a DataFrame
|
||||
|
|
@ -324,7 +324,7 @@ pd.DataFrame.sort_values(self, axis=0, ascending=True, **kwargs) # sort object
|
|||
|
||||
### COUNT
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.count(self) # return number of non-NA/null observations in the Series
|
||||
pd.DataFrame.count(self, numeric_only=False) # count non-NA cells for each column or row
|
||||
# NUMERIC_ONLY: {bool} -- Include only float, int or boolean data -- DEFAULT False
|
||||
|
|
@ -334,7 +334,7 @@ pd.DataFrame.count(self, numeric_only=False) # count non-NA cells for each colu
|
|||
|
||||
Generate descriptive statistics summarizing central tendency, dispersion and shape of dataset's distribution (exclude NaN).
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.describe(self, percentiles=None, include=None, exclude=None)
|
||||
pd.DataFrame.describe(self, percentiles=None, include=None, exclude=None)
|
||||
# PERCENTILES: {list-like of numbers} -- percentiles to include in output,between 0 and 1 -- DEFAULT [.25, .5, .75]
|
||||
|
|
@ -344,7 +344,7 @@ pd.DataFrame.describe(self, percentiles=None, include=None, exclude=None)
|
|||
|
||||
### MAX - MIN
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.max(self, skipna=None, numeric_only=None) # maximum of the values for the requested axis
|
||||
pd.Series.min(self, skipna=None, numeric_only=None) # minimum of the values for the requested axis
|
||||
pd.DataFrame.max(self, axis=None, skipna=None, numeric_only=None) # maximum of the values for the requested axis
|
||||
|
|
@ -355,7 +355,7 @@ pd.DataFrame.min(self, axis=None, skipna=None, numeric_only=None) # minimum of
|
|||
|
||||
### IDXMAX - IDXMIN
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.idxmax(self, skipna=True) # row label of the maximum value
|
||||
pd.Series.idxmin(self, skipna=True) # row label of the minimum value
|
||||
pd.DataFrame.idxmax(self, axis=0, skipna=True) # Return index of first occurrence of maximum over requested axis
|
||||
|
|
@ -366,7 +366,7 @@ pd.DataFrame.idxmin(self, axis=0, skipna=True) # Return index of first occurre
|
|||
|
||||
### QUANTILE
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.quantile(self, q=0.5, interpolation='linear') # return values at the given quantile
|
||||
pd.DataFrame.quantile(self, q=0.5, axis=0, numeric_only=True, interpolation='linear') # return values at the given quantile over requested axis
|
||||
# Q: {flaot, array} -- value between 0 <= q <= 1, the quantile(s) to compute -- DEFAULT 0.5 (50%)
|
||||
|
|
@ -376,7 +376,7 @@ pd.DataFrame.quantile(self, q=0.5, axis=0, numeric_only=True, interpolation='lin
|
|||
|
||||
### SUM
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.sum(self, skipna=None, numeric_only=None, min_count=0) # sum of the values
|
||||
pd.DataFrame.sum(self, axis=None, skipna=None, numeric_only=None, min_count=0) # sum of the values for the requested axis
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -387,7 +387,7 @@ pd.DataFrame.sum(self, axis=None, skipna=None, numeric_only=None, min_count=0)
|
|||
|
||||
### MEAN
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.mean(self, skipna=None, numeric_only=None) # mean of the values
|
||||
pd.DataFrame.mean(self, axis=None, skipna=None, numeric_only=None) # mean of the values for the requested axis
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -397,7 +397,7 @@ pd.DataFrame.mean(self, axis=None, skipna=None, numeric_only=None) # mean of th
|
|||
|
||||
### MEDIAN
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.median(self, skipna=None, numeric_only=None) # median of the values
|
||||
pd.DataFrame.median(self, axis=None, skipna=None, numeric_only=None) # median of the values for the requested axis
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -407,7 +407,7 @@ pd.DataFrame.median(self, axis=None, skipna=None, numeric_only=None) # median o
|
|||
|
||||
### MAD (mean absolute deviation)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.mad(self, skipna=None) # mean absolute deviation
|
||||
pd.DataFrame.mad(self, axis=None, skipna=None) # mean absolute deviation of the values for the requested axis
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -416,7 +416,7 @@ pd.DataFrame.mad(self, axis=None, skipna=None) # mean absolute deviation of the
|
|||
|
||||
### VAR (variance)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.var(self, skipna=None, numeric_only=None) # unbiased variance
|
||||
pd.DataFrame.var(self, axis=None, skipna=None, ddof=1, numeric_only=None) # unbiased variance over requested axis
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -427,7 +427,7 @@ pd.DataFrame.var(self, axis=None, skipna=None, ddof=1, numeric_only=None) # un
|
|||
|
||||
### STD (standard deviation)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.std(self, skipna=None, ddof=1, numeric_only=None) # sample standard deviation
|
||||
pd.Dataframe.std(self, axis=None, skipna=None, ddof=1, numeric_only=None) # sample standard deviation over requested axis
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -438,7 +438,7 @@ pd.Dataframe.std(self, axis=None, skipna=None, ddof=1, numeric_only=None) # sam
|
|||
|
||||
### SKEW
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.skew(self, skipna=None, numeric_only=None) # unbiased skew Normalized bt N-1
|
||||
pd.DataFrame.skew(self, axis=None, skipna=None, numeric_only=None) # unbiased skew over requested axis Normalized by N-1
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -450,7 +450,7 @@ pd.DataFrame.skew(self, axis=None, skipna=None, numeric_only=None) # unbiased
|
|||
|
||||
Unbiased kurtosis over requested axis using Fisher's definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.kurt(self, skipna=None, numeric_only=None)
|
||||
pd.Dataframe.kurt(self, axis=None, skipna=None, numeric_only=None)
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -460,7 +460,7 @@ pd.Dataframe.kurt(self, axis=None, skipna=None, numeric_only=None)
|
|||
|
||||
### CUMSUM (cumulative sum)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.cumsum(self, skipna=True) # cumulative sum
|
||||
pd.Dataframe.cumsum(self, axis=None, skipna=True) # cumulative sum over requested axis
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -469,7 +469,7 @@ pd.Dataframe.cumsum(self, axis=None, skipna=True) # cumulative sum over request
|
|||
|
||||
### CUMMAX - CUMMIN (cumulative maximum - minimum)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.cummax(self, skipna=True) # cumulative maximum
|
||||
pd.Series.cummin(self, skipna=True) # cumulative minimum
|
||||
pd.Dataframe.cummax(self, axis=None, skipna=True) # cumulative maximum over requested axis
|
||||
|
|
@ -480,7 +480,7 @@ pd.Dataframe.cummin(self, axis=None, skipna=True) # cumulative minimum over req
|
|||
|
||||
### CUMPROD (cumulative product)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.cumprod(self, skipna=True) # cumulative product
|
||||
pd.Dataframe.cumprod(self, axis=None, skipna=True) # cumulative product over requested axis
|
||||
# AXIS: {0, 1, index, columns} -- axis for the function to be applied on
|
||||
|
|
@ -492,7 +492,7 @@ pd.Dataframe.cumprod(self, axis=None, skipna=True) # cumulative product over re
|
|||
Calculates the difference of a DataFrame element compared with another element in the DataFrame.
|
||||
(default is the element in the same column of the previous row)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.diff(self, periods=1)
|
||||
pd.DataFrame.diff(self, periods=1, axis=0)
|
||||
# PERIODS: {int} -- Periods to shift for calculating difference, accepts negative values -- DEFAULT 1
|
||||
|
|
@ -503,7 +503,7 @@ pd.DataFrame.diff(self, periods=1, axis=0)
|
|||
|
||||
Percentage change between the current and a prior element.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.Pct_change(self, periods=1, fill_method='pad', limit=None, freq=None)
|
||||
pd.Dataframe.pct_change(self, periods=1, fill_method='pad', limit=None)
|
||||
# PERIODS:{int} -- periods to shift for forming percent change
|
||||
|
|
@ -515,7 +515,7 @@ pd.Dataframe.pct_change(self, periods=1, fill_method='pad', limit=None)
|
|||
|
||||
### FILTERING OUT MISSING DATA
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.dropna(self, inplace=False) # return a new Series with missing values removed
|
||||
pd.DataFrame.dropna(axis=0, how='any', tresh=None, subset=None, inplace=False) # return a new DataFrame with missing values removed
|
||||
# AXIS: {tuple, list} -- tuple or list to drop on multiple axes. only a single axis is allowed
|
||||
|
|
@ -529,7 +529,7 @@ pd.DataFrame.dropna(axis=0, how='any', tresh=None, subset=None, inplace=False)
|
|||
|
||||
Fill NA/NaN values using the specified method.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.fillna(self, value=None, method=None, inplace=False, limit=None)
|
||||
pd.DataFrame.fillna(self, value=None, method=None, axis=None, inplace=False, limit=None)
|
||||
# VALUE: {scalar, dict, Series, DataFrame} -- value to use to fill holes, dict/Series/DataFrame specifying which value to use for each index or column
|
||||
|
|
@ -546,7 +546,7 @@ In lower dimensional data structures like Series (1d) and DataFrame (2d).
|
|||
|
||||
### MULTIIINDEX CREATION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.MultiIndex.from_arrays(*arrays, names=None) # convert arrays to MultiIndex
|
||||
pd.MultiIndex.from_tuples(*arrays, names=None) # convert tuples to MultiIndex
|
||||
pd.MultiIndex.from_frame(df, names=None) # convert DataFrame to MultiIndex
|
||||
|
|
@ -559,7 +559,7 @@ pd.DataFrame(*arrays) # Index constructor makes MultiINdex from DataFrame
|
|||
|
||||
Vector of label values for requested level, equal to the length of the index.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.MultiIndex.get_level_values(self, level)
|
||||
```
|
||||
|
||||
|
|
@ -567,7 +567,7 @@ pd.MultiIndex.get_level_values(self, level)
|
|||
|
||||
Partial selection "drops" levels of the hierarchical index in the result in a completely analogous way to selecting a column in a regular DataFrame.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.Series.xs(self, key, axis=0, level=None, drop_level=True) # cross-section from Series
|
||||
pd.DataFrame.xs(self, key, axis=0, level=None, drop_level=True) # cross-section from DataFrame
|
||||
# KEY: {label, tuple of label} -- label contained in the index, or partially in a MultiIndex
|
||||
|
|
@ -580,7 +580,7 @@ pd.DataFrame.xs(self, key, axis=0, level=None, drop_level=True) # cross-sectio
|
|||
|
||||
Multi index keys take the form of tuples.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
df.loc[('lvl_1', 'lvl_2', ...)] # selection of single row
|
||||
df.loc[('idx_lvl_1', 'idx_lvl_2', ...), ('col_lvl_1', 'col_lvl_2', ...)] # selection of single value
|
||||
|
||||
|
|
@ -591,7 +591,7 @@ df.loc[('idx_lvl_1', 'idx_lvl_2') : ('idx_lvl_1', 'idx_lvl_2')] # slice of rows
|
|||
|
||||
### REORDERING AND SORTING LEVELS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.MultiIndex.swaplevel(self, i=-2, j=-1) # swap level i with level j
|
||||
pd.Series.swaplevel(self, i=-2, j=-1) # swap levels i and j in a MultiIndex
|
||||
pd.DataFrame.swaplevel(self, i=-2, j=-1, axis=0) # swap levels i and j in a MultiIndex on a partivular axis
|
||||
|
|
@ -604,7 +604,7 @@ pd.MultiIndex.sortlevel(self, level=0, ascending=True, sort_remaining=True) # s
|
|||
|
||||
## DATA LOADING, STORAGE FILE FORMATS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
pd.read_fwf(filepath, colspecs='infer', widths=None, infer_nrows=100) # read a table of fixed-width formatted lines into DataFrame
|
||||
# FILEPATH: {str, path object} -- any valid string path is acceptable, could be a URL. Valid URLs: http, ftp, s3, and file
|
||||
# COLSPECS: {list of tuple (int, int), 'infer'} -- list of tuples giving extents of fixed-width fields of each line as half-open intervals { [from, to) }
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
Get or retrieve data from specified resource
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
response = requests.get('URL') # returns response object
|
||||
|
||||
# PAYLOAD -> valuable information of response
|
||||
|
|
@ -18,7 +18,7 @@ The response message consists of:
|
|||
- empty line
|
||||
- optional message body
|
||||
|
||||
```text
|
||||
```text linenums="1"
|
||||
1xx -> INFORMATIONAL RESPONSE
|
||||
2xx -> SUCCESS
|
||||
200 OK -> request successful
|
||||
|
|
@ -28,7 +28,7 @@ The response message consists of:
|
|||
5xx -> SERVER ERRORS
|
||||
```
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# raise exception HTTPError for error status codes
|
||||
response.raise_for_status()
|
||||
|
||||
|
|
@ -41,7 +41,7 @@ response.headers # response headers (dict)
|
|||
|
||||
### QUERY STRING PARAMETERS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
response = requests.get('URL', params={'q':'query'})
|
||||
response = requests.get('URL', params=[('q', 'query')])
|
||||
response = requests.get('URL', params=b'q=query')
|
||||
|
|
@ -49,7 +49,7 @@ response = requests.get('URL', params=b'q=query')
|
|||
|
||||
### REQUEST HEADERS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
response = requests.get(
|
||||
'URL',
|
||||
params={'q': 'query'},
|
||||
|
|
@ -61,7 +61,7 @@ response = requests.get(
|
|||
|
||||
### DATA INPUT
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# requests that entity enclosed be stored as a new subordinate of the web resource identified by the URI
|
||||
requests.post('URL', data={'key':'value'})
|
||||
# requests that the enclosed entity be stored under the supplied URI
|
||||
|
|
@ -78,13 +78,13 @@ requests.options('URL')
|
|||
|
||||
### SENDING JSON DATA
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
requests.post('URL', json={'key': 'value'})
|
||||
```
|
||||
|
||||
### INSPECTING THE REQUEST
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# requests lib prepares the requests before sending it
|
||||
response = requests.post('URL', data={'key':'value'})
|
||||
response.request.something # inspect request field
|
||||
|
|
@ -92,7 +92,7 @@ response.request.something # inspect request field
|
|||
|
||||
## AUTHENTICATION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
requests.get('URL', auth=('username', 'password')) # use implicit HTTP Basic Authorization
|
||||
|
||||
# explicit HTTP Basic Authorization and other
|
||||
|
|
@ -103,7 +103,7 @@ requests.get('URL', auth=HTTPBasicAuth('username', getpass()))
|
|||
|
||||
### PERSONALIZED AUTH
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
from requests.auth import AuthBase
|
||||
class TokenAuth(AuthBase):
|
||||
"custom authentication scheme"
|
||||
|
|
@ -121,7 +121,7 @@ requests.get('URL', auth=TokenAuth('1234abcde-token'))
|
|||
|
||||
### DISABLING SSL VERIFICATION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
requests.get('URL', verify=False)
|
||||
```
|
||||
|
||||
|
|
@ -129,14 +129,14 @@ requests.get('URL', verify=False)
|
|||
|
||||
### REQUEST TIMEOUT
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# raise Timeout exception if request times out
|
||||
requests.get('URL', timeout=(connection_timeout, read_timeout))
|
||||
```
|
||||
|
||||
### MAX RETRIES
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
from requests.adapters import HTTPAdapter
|
||||
URL_adapter = HTTPAdapter(max_retries = int)
|
||||
session = requests.Session()
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Basic Imports For Seaborn
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import matplotlib.pyplot as plt
|
||||
|
|
@ -15,7 +15,7 @@ sns.set(style='darkgrid')
|
|||
|
||||
## REPLOT (relationship)
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
sns.replot(x='name_in_data', y='name_in_data', hue='point_color', size='point_size', style='point_shape', data=data)
|
||||
# HUE, SIZE and STYLE: {name in data} -- used to differentiate points, a sort-of 3rd dimension
|
||||
# hue behaves differently if the data is categorical or numerical, numerical uses a color gradient
|
||||
|
|
@ -38,7 +38,7 @@ sns.scatterplot() # underlying axis-level function of replot()
|
|||
|
||||
Using semantics in lineplot will determine the aggregation of data.
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
sns.replot(ci=None, sort=bool, kind='line')
|
||||
sns.lineplot() # underlying axis-level function of replot()
|
||||
```
|
||||
|
|
@ -47,7 +47,7 @@ sns.lineplot() # underlying axis-level function of replot()
|
|||
|
||||
Categorical: divided into discrete groups.
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
sns.catplot(x='name_in_data', y='name_in_data', data=data)
|
||||
# HUE: {name in data} -- used to differenziate points, a sort-of 3rd dimension
|
||||
# COL, ROW: {name in data} -- categorical variables that will determine the grid of plots
|
||||
|
|
@ -68,7 +68,7 @@ sns.stripplot()
|
|||
|
||||
Adjusts the points along the categorical axis preventing overlap.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
sns.catplot(kind='swarm')
|
||||
sns.swarmplot()
|
||||
# SIZE: {float} -- Diameter of the markers, in points
|
||||
|
|
@ -84,7 +84,7 @@ sns.boxplot()
|
|||
|
||||
Combines a boxplot with the kernel density estimation procedure.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
sns.catplot(kind='violin')
|
||||
sns.violonplot()
|
||||
```
|
||||
|
|
@ -94,7 +94,7 @@ sns.violonplot()
|
|||
Plot similar to boxplot but optimized for showing more information about the shape of the distribution.
|
||||
It is best suited for larger datasets.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
sns.catplot(kind='boxen')
|
||||
sns.boxenplot()
|
||||
```
|
||||
|
|
@ -103,7 +103,7 @@ sns.boxenplot()
|
|||
|
||||
Show point estimates and confidence intervals using scatter plot glyphs.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
sns.catplot(kind='point')
|
||||
sns.pointplot()
|
||||
# CI: {float, sd} -- size of confidence intervals to draw around estimated values, sd -> standard deviation
|
||||
|
|
@ -120,7 +120,7 @@ sns.pointplot()
|
|||
|
||||
Show point estimates and confidence intervals as rectangular bars.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
sns.catplot(kind='bar')
|
||||
sns.barplot()
|
||||
# CI: {float, sd} -- size of confidence intervals to draw around estimated values, sd -> standard deviation
|
||||
|
|
@ -134,7 +134,7 @@ sns.barplot()
|
|||
|
||||
Show the counts of observations in each categorical bin using bars.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
sns.catplot(kind='count')
|
||||
sns.countplot()
|
||||
# DODGE: {bool} -- whether elements should be shifted along the categorical axis if hue is used
|
||||
|
|
@ -146,7 +146,7 @@ sns.countplot()
|
|||
|
||||
Flexibly plot a univariate distribution of observations
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# A: {series, 1d-array, list}
|
||||
sns.distplot(a=data)
|
||||
# BINS: {None, arg for matplotlib hist()} -- specification of hist bins, or None to use Freedman-Diaconis rule
|
||||
|
|
@ -160,7 +160,7 @@ sns.distplot(a=data)
|
|||
|
||||
Plot datapoints in an array as sticks on an axis.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# A: {vector} -- 1D array of observations
|
||||
sns.rugplot(a=data) # -> axes obj with plot on it
|
||||
# HEIGHT: {scalar} -- height of ticks as proportion of the axis
|
||||
|
|
@ -172,7 +172,7 @@ sns.rugplot(a=data) # -> axes obj with plot on it
|
|||
|
||||
Fit and plot a univariate or bivariate kernel density estimate.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# DATA: {1D array-like} -- input data
|
||||
sns.kdeplot(data=data)
|
||||
# DATA2 {1D array-like} -- second input data. if present, a bivariate KDE will be estimated.
|
||||
|
|
@ -185,7 +185,7 @@ sns.kdeplot(data=data)
|
|||
|
||||
Draw a plot of two variables with bivariate and univariate graphs.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# X, Y: {string, vector} -- data or names of variables in data
|
||||
sns.jointplot(x=data, y=data)
|
||||
# DATA:{pandas DataFrame} -- DataFrame when x and y are variable names
|
||||
|
|
@ -203,7 +203,7 @@ sns.jointplot(x=data, y=data)
|
|||
|
||||
Plot pairwise relationships in a dataset.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# DATA: {pandas DataFrame} -- tidy (long-form) dataframe where each column is a variable and each row is an observation
|
||||
sns.pairplot(data=pd.DataFrame)
|
||||
# HUE: {string (variable name)} -- variable in data to map plot aspects to different colors
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Standard Imports
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
from tkinter import * # import Python Tk Binding
|
||||
from tkinter import ttk # import Themed Widgets
|
||||
```
|
||||
|
|
@ -19,7 +19,7 @@ geometry managers determine size and oder widget drawing properties
|
|||
event loop receives events from the OS
|
||||
customizable events provide a callback as a widget configuration
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
widget.bind('event', function) # method to capture any event and than execute an arbitrary piece of code (generally a function or lambda)
|
||||
```
|
||||
|
||||
|
|
@ -29,7 +29,7 @@ VIRTUAL EVENT --> hig level event generated by widget (listed in widget docs)
|
|||
|
||||
Widgets are objects and all things on screen. All widgets are children of a window.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
widget_name = tk_object(parent_window) # widget is inserted into widget hierarchy
|
||||
```
|
||||
|
||||
|
|
@ -37,7 +37,7 @@ widget_name = tk_object(parent_window) # widget is inserted into widget hierarc
|
|||
|
||||
Displays a single rectangle, used as container for other widgets
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
frame = ttk.Frame(parent, width=None, height=None, borderwidth=num:int)
|
||||
# BORDERWIDTH: sets frame border width (default: 0)
|
||||
# width, height MUST be specified if frame is empty, otherwise determined by parent geometry manager
|
||||
|
|
@ -47,7 +47,7 @@ frame = ttk.Frame(parent, width=None, height=None, borderwidth=num:int)
|
|||
|
||||
Extra space inside widget (margin).
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
frame['padding'] = num # same padding for every border
|
||||
frame['padding'] = (horizontal, vertical) # set horizontal THEN vertical padding
|
||||
frame['padding'] = (left, top, right, bottom) # set left, top, right, bottom padding
|
||||
|
|
@ -60,13 +60,13 @@ frame['relief'] = border_style
|
|||
|
||||
Display text or image without interactivity.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
label = ttk.Label(parent, text='label text')
|
||||
```
|
||||
|
||||
### DEFINING UPDATING LABEL
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
var = StringVar() # variable containing text, watches for changes. Use get, set methods to interact with the value
|
||||
label['textvariable'] = var # attach var to label (only of type StringVar)
|
||||
var.set("new text label") # change label text
|
||||
|
|
@ -74,14 +74,14 @@ var.set("new text label") # change label text
|
|||
|
||||
### DISPLAY IMAGES (2 steps)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
image = PhotoImage(file='filename') # create image object
|
||||
label['image'] = image # use image config
|
||||
```
|
||||
|
||||
### DISPLAY IMAGE AND-OR TEXT
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
label['compound'] = value
|
||||
```
|
||||
|
||||
|
|
@ -97,20 +97,20 @@ Compound value:
|
|||
|
||||
Specifies edge or corner that the label is attached.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
label['anchor'] = compass_direction #compass_direction: n, ne, e, se, s, sw, w, nw, center
|
||||
```
|
||||
|
||||
### MULTI-LINE TEXT WRAP
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# use \n for multi line text
|
||||
label['wraplength'] = size # max line length
|
||||
```
|
||||
|
||||
### CONTROL TEXT JUSTIFICATION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
label['justify'] = value #value: left, center, right
|
||||
|
||||
label['relief'] = label_style
|
||||
|
|
@ -120,7 +120,7 @@ label['background'] = color # color passed with name or HEX RGB codes
|
|||
|
||||
### FONT STYLE (use with caution)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# used outside style option
|
||||
label['font'] = font
|
||||
```
|
||||
|
|
@ -141,19 +141,19 @@ Fonts:
|
|||
|
||||
Press to perform some action
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
button = ttk.Button(parent, text='button_text', command=action_performed)
|
||||
```
|
||||
|
||||
### TEXT or IMAGE
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
button['text/textvariable'], button['image'], button['compound']
|
||||
```
|
||||
|
||||
### BUTTON INVOCATION
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
button.invoke() # button activation in the program
|
||||
```
|
||||
|
||||
|
|
@ -161,7 +161,7 @@ button.invoke() # button activation in the program
|
|||
|
||||
Activate or deactivate the widget.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
button.state(['disabled']) # set the disabled flag, disabling the button
|
||||
button.state(['!disabled']) # clear the disabled flag
|
||||
button.instate(['disabled']) # return true if the button is disabled, else false
|
||||
|
|
@ -174,7 +174,7 @@ button.instate(['!disabled'], cmd) # execute 'cmd' if the button is not disable
|
|||
|
||||
Button with binary value of some kind (e.g a toggle) and also invokes a command callback
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
checkbutton_var = TkVarType
|
||||
check = ttk.Checkbutton(parent, text='button text', command=action_performed, variable=checkbutton_var, onvalue=value_on, offvalue=value_off)
|
||||
```
|
||||
|
|
@ -189,7 +189,7 @@ checkbutton won't set the linked variable (MUST be done in the program)
|
|||
|
||||
### CONFIG OPTIONS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
check['text/textvariable']
|
||||
check['image']
|
||||
check['compound']
|
||||
|
|
@ -201,7 +201,7 @@ check.instate(['flag'])
|
|||
|
||||
Multiple-choice selection (good if options are few).
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
#RADIOBUTTON CREATION (usually as a set)
|
||||
radio_var = TkVarType
|
||||
radio_1 = ttk.Radiobutton(parent, text='button text', variable=radio_var, value=button_1_value)
|
||||
|
|
@ -221,7 +221,7 @@ radio.instate(['flag'])
|
|||
|
||||
Single line text field accepting a string.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
entry_var = StringVar()
|
||||
entry = ttk.Entry(parent, textvariable=entry_var, width=char_num, show=symbol)
|
||||
# SHOW: replaces the entry test with symbol, used for password
|
||||
|
|
@ -230,7 +230,7 @@ entry = ttk.Entry(parent, textvariable=entry_var, width=char_num, show=symbol)
|
|||
|
||||
### CHANGE ENTRY VALUE
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
entry.get() # returns entry value
|
||||
entry.delete(start, 'end') # delete between two indices, 0-based
|
||||
entry.insert(index, 'text value') # insert new text at a given index
|
||||
|
|
@ -238,7 +238,7 @@ entry.insert(index, 'text value') # insert new text at a given index
|
|||
|
||||
### ENTRY CONFIG OPTIONS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
radio.state(['flag'])
|
||||
radio.instate(['flag'])
|
||||
```
|
||||
|
|
@ -247,7 +247,7 @@ radio.instate(['flag'])
|
|||
|
||||
Drop-down list of available options.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
combobox_var = StringVar()
|
||||
combo = ttk.Combobox(parent, textvariable=combobox_var)
|
||||
combobox.get() # return combobox current value
|
||||
|
|
@ -259,7 +259,7 @@ combobox.bind('<<ComboboxSelected>>', function)
|
|||
|
||||
### PREDEFINED VALUES
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
combobox['values'] = (value_1, value_2, ...) # provides a list of choose-able values
|
||||
combobox.state(['readonly']) # restricts choose-able values to those provided with 'values' config option
|
||||
# SUGGESTION: call selection clear method on value change (on ComboboxSelected event) to avoid visual oddities
|
||||
|
|
@ -269,7 +269,7 @@ combobox.state(['readonly']) # restricts choose-able values to those provided w
|
|||
|
||||
Display list of single-line items, allows browsing and multiple selection (part og Tk classic, missing in themed Tk widgets).
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
lstbx = Listbox(parent, height=num, listvariable=item_list:list)
|
||||
# listvariable links a variable (MUST BE a list) to the listbox, each element is a item of the listbox
|
||||
# manipulation of the list changes the listbox
|
||||
|
|
@ -277,7 +277,7 @@ lstbx = Listbox(parent, height=num, listvariable=item_list:list)
|
|||
|
||||
### SELECTING ITEMS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
lstbx['selectmode'] = mode # MODE: browse (single selection), extended (multiple selection)
|
||||
lstbx.curselection() # returns list of indices of selected items
|
||||
# on selection change: generate event <ListboxSelect>
|
||||
|
|
@ -288,7 +288,7 @@ lstbx.curselection() # returns list of indices of selected items
|
|||
|
||||
## SCROLLBAR
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
scroll = ttk.Scrollbar(parent, orient=direction, command=widget.view)
|
||||
# ORIENT: VERTICAL, HORIZONTAL
|
||||
# WIDGET.VIEW: .xview, .yview
|
||||
|
|
@ -301,7 +301,7 @@ widget.configure(yscrollcommand=scroll.set)
|
|||
|
||||
Box in right bottom of widget, allows resize.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
ttk.Sizegrip(parent).grid(column=999, row=999, sticky=(S, E))
|
||||
```
|
||||
|
||||
|
|
@ -309,7 +309,7 @@ ttk.Sizegrip(parent).grid(column=999, row=999, sticky=(S, E))
|
|||
|
||||
Area accepting multiple line of text.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
txt = Text(parent, width=num:int, height=num:int, wrap=flag) # width is character num, height is row num
|
||||
# FLAG: none (no wrapping), char (wrap at every character), word (wrap at word boundaries)
|
||||
txt['state'] = flag # FLAG: disabled, normal
|
||||
|
|
@ -323,7 +323,7 @@ txt.delete(start, end) # delete range of text
|
|||
|
||||
Feedback about progress of lenghty operation.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
progbar = ttk.Progressbar(parent, orient=direction, length=num:int, value=num, maximum=num:float mode=mode)
|
||||
# DIRECTION: VERTICAL, HORIZONTAL
|
||||
# MODE: determinate (relative progress of completion), indeterminate (no estimate of completion)
|
||||
|
|
@ -334,13 +334,13 @@ progbar = ttk.Progressbar(parent, orient=direction, length=num:int, value=num, m
|
|||
|
||||
### DETERMINATE PROGRESS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
progbar.step(amount) # increment value of given amount (DEFAULT: 1.0)
|
||||
```
|
||||
|
||||
### INDETERMINATE PROGRESS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
progbar.start() # starts progressbar
|
||||
progbar.stop() #stoops progressbar
|
||||
```
|
||||
|
|
@ -349,7 +349,7 @@ progbar.stop() #stoops progressbar
|
|||
|
||||
Provide a numeric value through direct manipulation.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
scale = ttk.Scale(parent, orient=DIR, length=num:int, from_=num:float, to=num:float, command=cmd)
|
||||
# COMMAND: calls cmd at every scale change, appends current value to func call
|
||||
scale['value'] # set or read current value
|
||||
|
|
@ -361,7 +361,7 @@ scale.get() # get current value
|
|||
|
||||
Choose numbers. The spinbox choses item from a list, arrows permit cycling lits items.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
spinval = StringVar()
|
||||
spin = Spinbox(parent, from_=num, to=num, textvariable=spinval, increment=num, value=lst, wrap=boolean)
|
||||
# INCREMENT specifies increment\decrement by arrow button
|
||||
|
|
@ -402,7 +402,7 @@ A single value for the option puts the same padding on both left and right (or t
|
|||
while a two-value list lets you put different amounts on left and right (or top and bottom).
|
||||
To add padding around an entire row or column, the "columnconfigure" and "rowconfigure" methods accept a "pad" option.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
widget.grid(column=num, row=num, columnspan=num, rowspan=num, sticky=(), padx=num, pady=num) # sticky: N, S, E, W
|
||||
widget.columnconfigure(pad=num, weight=num)
|
||||
widget.rowconfigure(pad=num, weight=num)
|
||||
|
|
@ -419,7 +419,7 @@ widget.grid_remove(slaves) # takes a list of slaves, removes slaves from grid (
|
|||
|
||||
### CREATING TOPLEVEL WINDOW
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
tlw = Toplevel(parent) # parent of root window, no need to grid it
|
||||
|
||||
window.destroy()
|
||||
|
|
@ -429,7 +429,7 @@ window.destroy()
|
|||
|
||||
### CHANGING BEHAVIOR AND STYLE
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# WINDOW TILE
|
||||
window.title() # returns title of the window
|
||||
window.title('new title') # sets title
|
||||
|
|
@ -469,7 +469,7 @@ window.deiconify() # deiconifies window
|
|||
|
||||
### STANDARD DIALOGS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# SLEETING FILE AND DIRECTORIES
|
||||
# on Windows and Mac invokes underlying OS dialogs directly
|
||||
from tkinter import filedialog
|
||||
|
|
@ -507,7 +507,7 @@ POSSIBLE ALERT/CONFIRMATION RETURN VALUES:
|
|||
|
||||
## SEPARATOR
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# horizontal or vertical line between groups of widgets
|
||||
separator = ttk.Separator(parent, orient=direction)
|
||||
# DIRECTION: horizontal, vertical
|
||||
|
|
@ -532,7 +532,7 @@ pw.forget(position) # remove widget from pane
|
|||
|
||||
Allows switching between multiple pages
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
nb = ttk.Notebook(parent)
|
||||
f1 = ttk.Frame(parent, ...) # child of notebook
|
||||
f2 = ttk.Frame(parent, ...)
|
||||
|
|
@ -555,7 +555,7 @@ nb.tab(tabid, option=value) # change tab option
|
|||
|
||||
Creation of personalized fonts
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
from tkinter import font
|
||||
font_name = font.Font(family='font_family', size=num, weight='bold/normal', slant='roman/italic', underline=boolean, overstrike=boolean)
|
||||
# FAMILY: Courier, Times, Helvetica (support guaranteed)
|
||||
|
|
@ -573,7 +573,7 @@ label['image'] = imgobj
|
|||
|
||||
#### IMAGES W/ Pillow
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
from PIL import ImageTk, Image
|
||||
myimg = ImageTk.PhotoImage(Image.open('filename'))
|
||||
```
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Creating a parser
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="description", allow_abbrev=True)
|
||||
|
|
@ -25,7 +25,7 @@ parser = argparse.ArgumentParser(description="description", allow_abbrev=True)
|
|||
|
||||
## [Adding Arguments](https://docs.python.org/3/library/argparse.html#the-add-argument-method)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
ArgumentParser.add_argument("name_or_flags", nargs="...", action="...")
|
||||
```
|
||||
|
||||
|
|
@ -47,7 +47,7 @@ ArgumentParser.add_argument("name_or_flags", nargs="...", action="...")
|
|||
|
||||
`store`: This just stores the argument's value. This is the default action.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--foo')
|
||||
>>> parser.parse_args('--foo 1'.split())
|
||||
|
|
@ -56,7 +56,7 @@ Namespace(foo='1')
|
|||
|
||||
`store_const`: This stores the value specified by the const keyword argument. The `store_const` action is most commonly used with optional arguments that specify some sort of flag.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--foo', action='store_const', const=42)
|
||||
>>> parser.parse_args(['--foo'])
|
||||
|
|
@ -65,7 +65,7 @@ Namespace(foo=42)
|
|||
|
||||
`store_true` and `store_false`: These are special cases of `store_const` used for storing the values True and False respectively. In addition, they create default values of False and True respectively.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--foo', action='store_true')
|
||||
>>> parser.add_argument('--bar', action='store_false')
|
||||
|
|
@ -76,7 +76,7 @@ Namespace(foo=True, bar=False, baz=True)
|
|||
|
||||
`append`: This stores a list, and appends each argument value to the list. This is useful to allow an option to be specified multiple times. Example usage:
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--foo', action='append')
|
||||
>>> parser.parse_args('--foo 1 --foo 2'.split())
|
||||
|
|
@ -85,7 +85,7 @@ Namespace(foo=['1', '2'])
|
|||
|
||||
`append_const`: This stores a list, and appends the value specified by the const keyword argument to the list. (Note that the const keyword argument defaults to None.) The `append_const` action is typically useful when multiple arguments need to store constants to the same list. For example:
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--str', dest='types', action='append_const', const=str)
|
||||
>>> parser.add_argument('--int', dest='types', action='append_const', const=int)
|
||||
|
|
@ -96,7 +96,7 @@ Namespace(types=[<class 'str'>, <class 'int'>])
|
|||
`count`: This counts the number of times a keyword argument occurs. For example, this is useful for increasing verbosity levels:
|
||||
**Note**: the default will be None unless explicitly set to 0.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--verbose', '-v', action='count', default=0)
|
||||
>>> parser.parse_args(['-vvv'])
|
||||
|
|
@ -107,7 +107,7 @@ Namespace(verbose=3)
|
|||
|
||||
`version`: This expects a version= keyword argument in the add_argument() call, and prints version information and exits when invoked:
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> import argparse
|
||||
>>> parser = argparse.ArgumentParser(prog='PROG')
|
||||
>>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')
|
||||
|
|
@ -117,7 +117,7 @@ PROG 2.0
|
|||
|
||||
`extend`: This stores a list, and extends each argument value to the list. Example usage:
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument("--foo", action="extend", nargs="+", type=str)
|
||||
>>> parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"])
|
||||
|
|
@ -133,7 +133,7 @@ The `nargs` keyword argument associates a different number of command-line argum
|
|||
|
||||
`N` (an integer): N arguments from the command line will be gathered together into a list.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--foo', nargs=2)
|
||||
>>> parser.add_argument('bar', nargs=1)
|
||||
|
|
@ -147,7 +147,7 @@ Namespace(bar=['c'], foo=['a', 'b'])
|
|||
|
||||
For optional arguments, there is an additional case: the option string is present but not followed by a command-line argument. In this case the value from const will be produced.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--foo', nargs='?', const='c', default='d')
|
||||
>>> parser.add_argument('bar', nargs='?', default='d')
|
||||
|
|
@ -161,7 +161,7 @@ Namespace(bar='d', foo='d')
|
|||
|
||||
`*`: All command-line arguments present are gathered into a list. Note that it generally doesn't make much sense to have more than one positional argument with `nargs='*'`, but multiple optional arguments with `nargs='*'` is possible.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--foo', nargs='*')
|
||||
>>> parser.add_argument('--bar', nargs='*')
|
||||
|
|
@ -172,7 +172,7 @@ Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
|
|||
|
||||
`+`: All command-line args present are gathered into a list. Additionally, an error message will be generated if there wasn't at least one command-line argument present.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser(prog='PROG')
|
||||
>>> parser.add_argument('foo', nargs='+')
|
||||
>>> parser.parse_args(['a', 'b'])
|
||||
|
|
@ -184,7 +184,7 @@ PROG: error: the following arguments are required: foo
|
|||
|
||||
`argparse.REMAINDER`: All the remaining command-line arguments are gathered into a list. This is commonly useful for command line utilities that dispatch to other command line utilities.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
>>> parser = argparse.ArgumentParser(prog='PROG')
|
||||
>>> parser.add_argument('--foo')
|
||||
>>> parser.add_argument('command')
|
||||
|
|
@ -195,7 +195,7 @@ Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B')
|
|||
|
||||
## Parsing Arguments
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# Convert argument strings to objects and assign them as attributes of the namespace. Return the populated namespace.
|
||||
ArgumentParser.parse_args(args=None, namespace=None)
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## FTP CLASSES
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
ftplib.FTP(host="", user="", password="", acct="")
|
||||
# if HOST => connect(host)
|
||||
# if USER => login(user, password, acct)
|
||||
|
|
@ -13,7 +13,7 @@ ftplib.FTP_TLS(host="", user="", password="", acct="")
|
|||
|
||||
## EXCEPTIONS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
ftplib.error_reply # unexpected error from server
|
||||
ftplib.error_temp # temporary error (response codes 400-499)
|
||||
ftplib.error_perm # permanent error (response codes 500-599)
|
||||
|
|
@ -23,7 +23,7 @@ ftplib.all_errors # tuple of all exceptions
|
|||
|
||||
## FTP OBJECTS
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# method on text files: -lines
|
||||
# method on binary files: -binary
|
||||
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ WHITESPACE can be inserted between any pair of tokens.
|
|||
|
||||
## Usage
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
|
||||
# serialize obj as JSON formatted stream to fp
|
||||
json.dump(obj, fp, cls=None, indent=None, separators=None, sort_keys=False)
|
||||
|
|
@ -90,7 +90,7 @@ Conversions (Python -> Json):
|
|||
|
||||
## Extending JSONEncoder (Example)
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
import json
|
||||
|
||||
class ComplexEncoder(json.JSONEncoder):
|
||||
|
|
@ -103,7 +103,7 @@ class ComplexEncoder(json.JSONEncoder):
|
|||
|
||||
## Retrieving Data from json dict
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
data = json.loads(json)
|
||||
data["key"] # retrieve the value associated with the key
|
||||
data["outer key"]["nested key"] # nested key value retrieval
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Configuration
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
# basic configuration for the logging system
|
||||
logging.basicConfig(filename="relpath", level=logging.LOG_LEVEL, format=f"message format", **kwargs)
|
||||
# DATEFMT: Use the specified date/time format, as accepted by time.strftime().
|
||||
|
|
@ -76,7 +76,7 @@ Log Levels (Low To High):
|
|||
- error: `40`
|
||||
- critical: `50`
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
logging.debug(msg) # Logs a message with level DEBUG on the root logger
|
||||
logging.info(msg) # Logs a message with level INFO on the root logger
|
||||
logging.warning(msg) # Logs a message with level WARNING on the root logger
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
High-level file operations
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
# copy file src to fil dst, return dst in most efficient way
|
||||
shutil.copyfile(src, dst)
|
||||
# dst MUST be complete target name
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# SMTPlib Module
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
import smtplib
|
||||
|
||||
# SMTP instance that encapsulates a SMTP connection
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ In this context, sockets are assumed to be associated with a specific socket add
|
|||
|
||||
## Socket Creation & Connection
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
import socket
|
||||
|
||||
# socket over the internet, socket is a stream of data
|
||||
|
|
@ -21,7 +21,7 @@ socket.close() # close connection
|
|||
|
||||
## Making HTTP Requests
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
import socket
|
||||
HTTP_Method = "GET http://url/resource HTTP/version\n\n".encode() # set HTTP request (encoded string from UTF-8 to bytes)
|
||||
socket.send(HTTP_Method) # make HTTP request
|
||||
|
|
|
|||
|
|
@ -4,14 +4,14 @@
|
|||
|
||||
To use the module, you must first create a Connection object that represents the database.
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
import sqlite3
|
||||
connection = sqlite3.connect("file.db")
|
||||
```
|
||||
|
||||
Once you have a `Connection`, you can create a `Cursor` object and call its `execute()` method to perform SQL commands.
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
cursor = connection.cursor()
|
||||
|
||||
cursor.execute(sql)
|
||||
|
|
@ -31,7 +31,7 @@ it makes your program vulnerable to an [SQL injection attack](https://en.wikiped
|
|||
|
||||
Put `?` as a placeholder wherever you want to use a value, and then provide a _tuple of values_ as the second argument to the cursor's `execute()` method.
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
# Never do this -- insecure!
|
||||
c.execute("SELECT * FROM stocks WHERE symbol = value")
|
||||
|
||||
|
|
@ -50,7 +50,7 @@ c.executemany('INSERT INTO stocks VALUES (?,?,?,?,?)', purchases)
|
|||
|
||||
### Writing Operations to Disk
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
cursor = connection.cursor()
|
||||
cursor.execute("SQL")
|
||||
connection.commit()
|
||||
|
|
@ -58,7 +58,7 @@ connection.commit()
|
|||
|
||||
### Multiple SQL Instructions
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
connection = sqlite3.connect("file.db")
|
||||
cur = con.cursor()
|
||||
cur.executescript("""
|
||||
|
|
@ -73,7 +73,7 @@ con.close()
|
|||
|
||||
### Retrieving Records
|
||||
|
||||
```python
|
||||
```python linenums="1"
|
||||
# Fetches the next row of a query result set, returning a single sequence.
|
||||
# Returns None when no more data is available.
|
||||
cursor.fetchone()
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Time
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# epoch: elapsed time in seconds (in UNIX starts from 01-010-1970)
|
||||
import time # UNIX time
|
||||
variable = time.time () # returns the time (in seconds) elapsed since 01-01-1970
|
||||
|
|
@ -42,7 +42,7 @@ var = time.perf_counter () # returns the current running time
|
|||
|
||||
## Datetime
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
import datetime
|
||||
today = datetime.date.today () # returns current date
|
||||
today = datetime.datetime.today () # returns the current date and time
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# Unittest Module
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
import unittest
|
||||
import module_under_test
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ Class -> PascalCase
|
|||
Method, Function -> snake_case
|
||||
Variable -> snake_case
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# standard comment
|
||||
'''multiline comment'''
|
||||
"""DOCSTRING"""
|
||||
|
|
@ -38,7 +38,7 @@ string.whitespace
|
|||
|
||||
### Assignment Operation
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
"""instructions to the right of = executed before instructions to the left of ="""
|
||||
variable = expression # the type of the variable is dynamically decided by python based on the content
|
||||
var_1, var_2 = value1, value2 # parallel assignment
|
||||
|
|
@ -56,7 +56,7 @@ x = a or b # If bool (a) returns False, then x is assigned the value of b
|
|||
|
||||
### Expression Assignment
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
(var: = expression) # assign an expression to a variable to avoid repeating the expression
|
||||
```
|
||||
|
||||
|
|
@ -67,7 +67,7 @@ x = a or b # If bool (a) returns False, then x is assigned the value of b
|
|||
|
||||
### On Screen Output
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
print() # print blank line and wrap
|
||||
print('string' * n) # print string n times
|
||||
print('string1 \ n string2') # wrap with \ n
|
||||
|
|
@ -131,7 +131,7 @@ Format: `[[fill]align] [sign] [#] [width] [grouping] [.precision] [type]`
|
|||
|
||||
### Keyboard Input
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# input always returns a STRING
|
||||
s = input() # input request without message
|
||||
s = input('Prompt') # request input
|
||||
|
|
@ -144,7 +144,7 @@ list = [int(x) for x in input('prompt'). split('separator')]
|
|||
|
||||
## Numeric Types
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
a = 77
|
||||
b = 1_000_000 # underscore can be used to separate groups of digits
|
||||
c = -69
|
||||
|
|
@ -189,7 +189,7 @@ It is worth checking if the difference between the numbers is small enough.
|
|||
|
||||
## Strings
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
|
||||
string = 'string content' # assignment and creation of string variable
|
||||
string = '''multi
|
||||
|
|
@ -266,7 +266,7 @@ string.center(width, 'char') # stretch the string with char to width
|
|||
|
||||
## Lists
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
list = [9, 11, 'WTC', -5.6, True] # lists can contain data of different types
|
||||
|
||||
list[3] # indexing
|
||||
|
|
@ -339,7 +339,7 @@ var = [(exp_1, exp_2) for item_1 in seq_1 for item_2 in seq_2] # -> [(..., ...),
|
|||
|
||||
## Tuple
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# TUPLES CANNOT BE MODIFIED
|
||||
tuple = (69, 420, 69, 'abc') # tuple assignment
|
||||
tuple = (44,) # single element tuples need a comma
|
||||
|
|
@ -370,7 +370,7 @@ var_1, * body, var_2, var_3 = sequence # var_1 = seq [0], body = seq [1: -2], va
|
|||
|
||||
## Set
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# SETS MAY NOT CONTAIN REPEATED ELEMENTS (THEY ARE OMITTED)
|
||||
# THE ORDER DOES NOT MATTER (NO SLICING, INDEXING, REPETITION, ...)
|
||||
set = {10, 20, 30, 'abc', 20}
|
||||
|
|
@ -426,7 +426,7 @@ var[i, ...] # -> shortcut for var [i,:,:,:,]
|
|||
|
||||
## Bytes e Bytearray
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# THE BYTES CANNOT BE MODIFIED OR INDEXED
|
||||
# THE BYTEARRAYS CAN BE MODIFIED AND INDEXED
|
||||
# YOU CANNOT DO REPETITION AND SLICING ON BYTE OR BYTEARRAY
|
||||
|
|
@ -453,7 +453,7 @@ Unicode Literals:
|
|||
- `\U00000041` --> 'A'
|
||||
- `\x41` --> 'A'
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# ENCODING
|
||||
# transform string into literal byte
|
||||
# UnicodeEncodeError on error
|
||||
|
|
@ -494,7 +494,7 @@ def fold_equal (str_1, str_2):
|
|||
|
||||
## Memoryview
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# memoryview objects allow python to access the data inside the object
|
||||
# without copy if it supports the buffer protocol
|
||||
v = memoryview(object) # create a memoryview with reference to object
|
||||
|
|
@ -538,7 +538,7 @@ v.shape # tuple of integers indicating the shape of the memoryview
|
|||
|
||||
## Dictionaries
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# SET OF KEY-VALUE PAIRS
|
||||
d = {1: 'Alex', 2: 'Bob', 3: 'Carl'}
|
||||
d = dict (one = 'Alex', two = 'Bob', three = 'Carl')
|
||||
|
|
@ -677,7 +677,7 @@ built-in objects considered *false*:
|
|||
|
||||
### `if-else`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
if (condition):
|
||||
# code here
|
||||
elif (condition):
|
||||
|
|
@ -688,7 +688,7 @@ else:
|
|||
|
||||
### Context Manager
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
with resource as target:
|
||||
# code here
|
||||
|
||||
|
|
@ -709,7 +709,7 @@ contextmanager.__exit__(self, exc_type, exc_value, traceback)
|
|||
|
||||
### `while`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
while(condition):
|
||||
# code here
|
||||
else:
|
||||
|
|
@ -720,7 +720,7 @@ else:
|
|||
|
||||
### `for`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
for index in sequence: # sequence can be a list, set, tuple, etc ..
|
||||
# code here
|
||||
else:
|
||||
|
|
@ -742,21 +742,21 @@ for key, value in dict.items ():
|
|||
|
||||
### `range`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
range(start, end, step) # generate sequence num integers (does not include num stops) with possible step
|
||||
list(range(start, end, step)) # return sequence of integers in a list
|
||||
```
|
||||
|
||||
### `enumerate`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
enumerate(iterable) # iterable of item & index pairs
|
||||
list(enumerate(iterable)) # returns list of tuples [(1, iterable [0]), (2, iterable [1]), (3, iterable [2])]
|
||||
```
|
||||
|
||||
### `zip`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
list_1 = [1, 2, 3, 4, 5]
|
||||
list_2 = ['a', 'b', 'c', 'd', 'e']
|
||||
|
||||
|
|
@ -766,7 +766,7 @@ list(zip(list_1, list_2)) # returns list of tuples by merging list [(list_1 [0],
|
|||
|
||||
### `shuffle` & `randint`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
from random import shuffle, randint
|
||||
shuffle(iterable) # shuffle the list
|
||||
randint(start, end) # returns a random integer between start and end
|
||||
|
|
@ -774,7 +774,7 @@ randint(start, end) # returns a random integer between start and end
|
|||
|
||||
### `in`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
item in iterable # check for the presence of item in iterable (returns True or False)
|
||||
```
|
||||
|
||||
|
|
@ -782,7 +782,7 @@ item in iterable # check for the presence of item in iterable (returns True or F
|
|||
|
||||
### Function Definition
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
def function_name (parameters):
|
||||
"" "DOCSTRING" ""
|
||||
# code here
|
||||
|
|
@ -795,14 +795,14 @@ def function_name (parameters):
|
|||
- parameters between `/` and `*` can be *positional* or *keyworded*
|
||||
- parameters after `*` can only be *keyworded*
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
def func (a, b, /, c, d, *, e, f):
|
||||
# code here
|
||||
```
|
||||
|
||||
### Docstring Style
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
"""function description
|
||||
|
||||
Args:
|
||||
|
|
@ -823,14 +823,14 @@ Raises:
|
|||
|
||||
When used in combination `*args` always goes before`**kwargs` (in def function and in function call)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
def func(*args, **kwargs):
|
||||
# code here
|
||||
```
|
||||
|
||||
### Function with default parameters
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
def function(parameter1 = value1, parameter2 = value3): # default values in case of omitted use of arguments in the call
|
||||
# code here
|
||||
return expression
|
||||
|
|
@ -840,7 +840,7 @@ function(parameter2 = value2, parameter1 = value1) # arguments passed with keywo
|
|||
|
||||
### Global And Local Variables
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# global scope
|
||||
|
||||
def external_func():
|
||||
|
|
@ -859,7 +859,7 @@ def external_func():
|
|||
|
||||
`Note`: variables declared inside a function are not usable outside
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
def function():
|
||||
# global statement makes a variable global
|
||||
# actions on global variable within the function also have an effect outside
|
||||
|
|
@ -887,7 +887,7 @@ Operation `iter()`:
|
|||
|
||||
### `next()` & `iter()`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
next(iterable) # next item of the iterable or error StopIteration
|
||||
|
||||
iter(object) # get an iterator from an object
|
||||
|
|
@ -900,7 +900,7 @@ iter(callable_obj, sentinel)
|
|||
|
||||
Used to generate a sequence of values to be used once (they are not stored)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
def custom_generator(parameters):
|
||||
while condition: # or for loop
|
||||
yield variable # returns the value without terminating the function, values passed to the caller without storing in a variable
|
||||
|
|
@ -912,7 +912,7 @@ for item in custom_generator(parameters):
|
|||
|
||||
### Termination Generator And Exception Handling
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# raise exception at the suspension point and return generator value
|
||||
# if the generator terminates without returning values it raises StopIteration
|
||||
# if an exception is not handled it is propagated to the caller
|
||||
|
|
@ -926,7 +926,7 @@ generator.close()
|
|||
|
||||
### Generator Comprehensions
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# zero-length sequence (instantaneously generated values)
|
||||
var = (for expression iterable in sequence if condition)
|
||||
# EDUCATION ENUMERATE ()
|
||||
|
|
@ -937,7 +937,7 @@ enumerate(sequence) # -> enumerate object
|
|||
|
||||
## Coroutines
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
def simple_coroutine():
|
||||
"""coroutine defined as a generator: yield in block"""
|
||||
|
||||
|
|
@ -994,7 +994,7 @@ coroutine.close()
|
|||
**SUBGENERATOR**: generator obtained from `yield from`
|
||||
**CALLER-CLIENT**: code calling *delegating generator*
|
||||
|
||||
The main function of `yield from` is to open a bidirectional channel between the external caller (* client *) and the internal * subgenerator * so that values and exceptions can pass between the two.
|
||||
The main function of `yield from` is to open a bidirectional channel between the external caller (*client*) and the internal *subgenerator* so that values and exceptions can pass between the two.
|
||||
|
||||
1. client calls delegating generator, delegating generator calls subgenerator
|
||||
2. exhausted subgenerator returns value to `yield from <expr>` (`return <result>` statement)
|
||||
|
|
@ -1020,7 +1020,7 @@ The main function of `yield from` is to open a bidirectional channel between the
|
|||
- If this call results in an exception, it is propagated to the delegating generator.
|
||||
- Otherwise, `GeneratorExit` is raised in the delegating generator
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
def sub_gen():
|
||||
sent_input = yield
|
||||
# result of sub_gen() returned to delegating_gen()
|
||||
|
|
@ -1040,7 +1040,7 @@ def client():
|
|||
|
||||
Possible use within functions. Useful for replacing functions if the logic is simple.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
var = lambda argument_list: <expression>
|
||||
```
|
||||
|
||||
|
|
@ -1048,7 +1048,7 @@ var = lambda argument_list: <expression>
|
|||
|
||||
### Class Definition
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
class Class:
|
||||
|
||||
static_var = expression
|
||||
|
|
@ -1077,7 +1077,7 @@ class Class:
|
|||
|
||||
### Setter & Getter with `@Property`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
class Class:
|
||||
def __init__(self, parameter):
|
||||
self.__parameter = parameter
|
||||
|
|
@ -1102,7 +1102,7 @@ The `__slots__` attribute implements the **Flyweight Design Pattern**: it saves
|
|||
|
||||
### Inner Classes
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
class Class:
|
||||
def __init__(self, parameters):
|
||||
...
|
||||
|
|
@ -1122,7 +1122,7 @@ object_2 = Class.InnerClass(arguments) # inner class created as object of the 'e
|
|||
|
||||
Special methods are defined by the use of double underscores; they allow the use of specific functions (possibly adapted) on the objects defined by the class.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
class Class():
|
||||
|
||||
def __init__(self, parameters):
|
||||
|
|
@ -1148,7 +1148,7 @@ del object # delete object
|
|||
|
||||
**Note**: if the operator cannot be applied, returns `NotImplemented`
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# arithmetic operators
|
||||
__add__(self, other) # +
|
||||
__sub__(self, other) # -
|
||||
|
|
@ -1309,7 +1309,7 @@ however, if the underlying method is linear (as it would be with a linked list),
|
|||
|
||||
### Inheritance
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
class Parent ():
|
||||
def __init __ (self, parameters):
|
||||
...
|
||||
|
|
@ -1350,7 +1350,7 @@ class Child(Parent): # parent class in brackets to inherit properties
|
|||
|
||||
**Note**: python does not support method overloading
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# DUCKTYPING
|
||||
# Working with objects regardless of their type, as long as they implement certain protocols
|
||||
|
||||
|
|
@ -1396,7 +1396,7 @@ Virtual subclasses are used to include third-party classes as subclasses of a cl
|
|||
|
||||
The `@Class.register` or `Class.register(subclass)` decorators are used to mark subclasses.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
from abc import abstractmethod, ABC
|
||||
|
||||
class Abstract(ABC): # abstract class MUST INHERIT from parent class ABC
|
||||
|
|
@ -1429,7 +1429,7 @@ class Child(Abstract):
|
|||
|
||||
## Exception Handling
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# CHECK ASERATIONS
|
||||
assert condition, 'error message' # if the assertion is false show an error message
|
||||
|
||||
|
|
@ -1490,7 +1490,7 @@ Open binary file mode:
|
|||
|
||||
**Note**: Linux and MacOSX use `UTF-8` everywhere while windows uses `cp1252`, `cp850`,`mbcs`, `UTF-8`. Don't rely on default encoding and use **explicitly** `UTF-8`.
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
object = open('filename', mode = 'r', encoding = 'utf-8') # encoding MUST BE utf-8 for compatibility
|
||||
# filename can be the absolute path to the file location (default: file created in the source code folder)
|
||||
# double slash to avoid \ escaping
|
||||
|
|
@ -1525,7 +1525,7 @@ else:
|
|||
**SHALLOW COPY**: copies the "container" and references to the content
|
||||
**DEEP COPY**: copies the "container" and contents (no reference)
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
copy (x) # returns shallow copy of xor
|
||||
deepcopy (x) # returns shallow copy of x
|
||||
```
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Creating a project
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
cargo new project_name # creates project folder and basic files
|
||||
cargo new --vcs=git project_name # init project as git repo
|
||||
```
|
||||
|
|
@ -11,7 +11,7 @@ cargo new --vcs=git project_name # init project as git repo
|
|||
|
||||
Inside the project directory:
|
||||
|
||||
```ps1
|
||||
```ps1 linenums="1"
|
||||
cargo build # build project and download eventual needed dependencies
|
||||
cargo build --release # build project for release (build + optimisations)
|
||||
cargo run # executes the built executable
|
||||
|
|
@ -22,7 +22,7 @@ cargo check # verifies buildability without producing an executable
|
|||
|
||||
In `Cargo.toml`:
|
||||
|
||||
```toml
|
||||
```toml linenums="1"
|
||||
[dependencies]
|
||||
crate_name = "<version_number>"
|
||||
```
|
||||
|
|
@ -70,7 +70,7 @@ A path can take two forms:
|
|||
|
||||
Both absolute and relative paths are followed by one or more identifiers separated by double colons (`::`).
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
module::function(); // rel path (same crate)
|
||||
super::function();; // rel path starting in outer module (same crate)
|
||||
|
||||
|
|
@ -88,7 +88,7 @@ The way privacy works in Rust is that all items (functions, methods, structs, en
|
|||
Items in a parent module can’t use the private items inside child modules, but items in child modules can use the items in their ancestor modules.
|
||||
The reason is that child modules wrap and hide their implementation details, but the child modules can see the context in which they’re defined.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
mod module {
|
||||
fn func() {}
|
||||
}
|
||||
|
|
@ -109,7 +109,7 @@ In contrast, if an enum is made public, all of its variants are then public.
|
|||
|
||||
### `use`
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
use <crate_name>::module; // import module (abs path, other crate)
|
||||
use crate::module; // import module (abs path, same crate)
|
||||
use self::module; // import module (rel path, same crate)
|
||||
|
|
@ -125,7 +125,7 @@ module::function(); // use func w/ shorter path
|
|||
|
||||
## Separating into multiple files
|
||||
|
||||
```txt
|
||||
```txt linenums="1"
|
||||
src
|
||||
|_main.rs --> default executable file
|
||||
|_lib.rs --> default library file
|
||||
|
|
@ -134,7 +134,7 @@ src
|
|||
| |_submodule.rs --> submodule
|
||||
```
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// main.rs
|
||||
mod module; // declare module directory as a module
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Basics
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
use <module>; // bring a type into scope
|
||||
|
||||
fn main() { //program entry point
|
||||
|
|
@ -12,7 +12,7 @@ fn main() { //program entry point
|
|||
|
||||
### Standard Output
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// macro (func have no "!")
|
||||
println!("Value: {}", value); // {} is a placeholder for a value or variable
|
||||
println!("Values: {1}, {0}", value1, value2); // use index to print values
|
||||
|
|
@ -30,7 +30,7 @@ print!();
|
|||
|
||||
### Standard Input
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
use io;
|
||||
|
||||
let mut buffer = String::new();
|
||||
|
|
@ -50,7 +50,7 @@ An associated function is implemented on a type rather than on a particular inst
|
|||
|
||||
By default variables are *immutable*.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let var1 = value; // immutable var init
|
||||
let var2: Type = value; // explicit type annotation
|
||||
|
||||
|
|
@ -68,7 +68,7 @@ By using let, it's possible to perform a few transformations on a value but have
|
|||
The other difference between *mut* and *shadowing* is that because we're effectively creating a new variable when we use the let keyword again,
|
||||
we can change the type of the value but reuse the same name.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let x: u32 = 10;
|
||||
let x: i32 = 11; // shadowing
|
||||
```
|
||||
|
|
@ -88,7 +88,7 @@ let x: i32 = 11; // shadowing
|
|||
|
||||
#### Explicit Mathematical Operations (Integers)
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
i32::MAX.checked_add(value); // Option<i32> => None if overflow
|
||||
i32::MAX.wrapping_add(value); // i32 => Wrap around
|
||||
i32::MAX.saturating_add(value); // i32 => MIN <= x <= MAX (Clamp)
|
||||
|
|
@ -164,7 +164,7 @@ Rust's `char` type is the language's most primitive alphabetic type.
|
|||
|
||||
Rust's `char` type is four bytes in size and represents a Unicode Scalar Value: range from `U+0000` to `U+D7FF` and `U+E000` to `U+10FFFF` inclusive.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let c: char = 'C'; // SINGLE QUOTES
|
||||
let c: char = '\u{261D}'; // Unicode Code Point U+261D
|
||||
let c: char = '\x2A'; // ASCII for *
|
||||
|
|
@ -179,7 +179,7 @@ std::char::from:digit(2, 10); // Some(2)
|
|||
|
||||
### String Types
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let s = String::new(); // create empty string
|
||||
let s = String::from("string literal"); // construct string from literal
|
||||
|
||||
|
|
@ -205,7 +205,7 @@ s.push_str(""); // appending string literals
|
|||
A tuple is a general way of grouping together a number of values with a variety of types into one compound type.
|
||||
Tuples have a *fixed length*: once declared, they cannot grow or shrink in size.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let tup: (i32, f64, u8) = (500, 6.4, 1);
|
||||
let tup = (500, 6.4, 1);
|
||||
|
||||
|
|
@ -219,7 +219,7 @@ tup.0 = value; // member access & update (mut be mutable)
|
|||
Every element of an array must have the *same type*. Arrays in Rust have a fixed length, like tuples.
|
||||
An array isn't as flexible as the `vector` type, though. A vector is a similar collection type provided by the standard library that *is allowed to grow or shrink in size*.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let array = [0, 1, 2, 3, 4];
|
||||
let array: [Type; length] = [...];
|
||||
let array: [value; length]; // repeat expression (same as python's [value] * length)
|
||||
|
|
@ -249,7 +249,7 @@ The reverse is not possible since the slice lacks some information about the Str
|
|||
|
||||
> **Note**: When working with functions is easier to always expect a `&str` instead of a `&String`.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let s = String::from("string literal");
|
||||
let slice: &str = &s[start..end];
|
||||
|
||||
|
|
@ -262,7 +262,7 @@ sequence[..end] // slice from start to end (excluded)
|
|||
|
||||
### Type Aliases
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
type Alias = T;
|
||||
```
|
||||
|
||||
|
|
@ -275,7 +275,7 @@ The curly brackets tell the compiler where the function body begins and ends.
|
|||
|
||||
Rust doesn't care where the functions are defined, only that they're defined somewhere.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
fn func(param: Type) { // parameters MUST have the Type annotation
|
||||
// code here
|
||||
}
|
||||
|
|
@ -301,7 +301,7 @@ fn func() {
|
|||
|
||||
### if - else if - else
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
if condition {
|
||||
// [...]
|
||||
} else if condition {
|
||||
|
|
@ -313,13 +313,13 @@ if condition {
|
|||
|
||||
### let if
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let var = if condition { value } else { value }; // returned types must be the same
|
||||
```
|
||||
|
||||
### [if-let](https://doc.rust-lang.org/rust-by-example/flow_control/if_let.html)
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
if let <pattern> = <expr> {
|
||||
<block1>
|
||||
} else {
|
||||
|
|
@ -335,20 +335,20 @@ match <expr> {
|
|||
|
||||
### loop
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// loop's forever if not explicitly stopped (return or break)
|
||||
loop { }
|
||||
```
|
||||
|
||||
### while
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
while condition { }
|
||||
```
|
||||
|
||||
### for
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
for item in sequence.iter() { }
|
||||
for item in sequence.iter_mut() { } // iterate over mutable items
|
||||
|
||||
|
|
@ -362,7 +362,7 @@ for i in (start..end) { }
|
|||
|
||||
### Range
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
.. // RangeFull
|
||||
a .. // RangeFrom { start: a }
|
||||
.. b // RangeTo { end: b }
|
||||
|
|
@ -373,7 +373,7 @@ a ..= b // RangeInclusive::new(a, b)
|
|||
|
||||
### `break` & `continue`
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
while <condition> {
|
||||
// [...]
|
||||
|
||||
|
|
@ -449,7 +449,7 @@ Cloning is an explicit action, `x.clone()`. The implementation of Clone can prov
|
|||
|
||||
Rust won't allow to annotate a type with the `Copy` trait if the type, or any of its parts, has implemented the `Drop` trait.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let s = String::new()
|
||||
let t = s; // MOVE, s is now uninitialized
|
||||
let u = t.clone(); // deep copy, t is still valid
|
||||
|
|
@ -462,7 +462,7 @@ let x = n; // x holds a COPY of the VALUE of n
|
|||
|
||||
The semantics for passing a value to a function are similar to those for assigning a value to a variable. Passing a variable to a function will move or copy, just as assignment does.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
fn main() {
|
||||
let s = String::from("hello"); // s comes into scope
|
||||
|
||||
|
|
@ -487,7 +487,7 @@ fn makes_copy(some_integer: i32) { // some_integer comes into scope
|
|||
|
||||
Returning values can also transfer ownership.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
fn main() {
|
||||
let s1 = gives_ownership(); // gives_ownership moves its return value into s1
|
||||
|
||||
|
|
@ -537,7 +537,7 @@ A data race is similar to a race condition and happens when these three behavior
|
|||
- At least one of the pointers is being used to write to the data.
|
||||
- There's no mechanism being used to synchronize access to the data.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
fn borrow(var: &Type) { // &Type indicates that the var is a reference
|
||||
// here var cannot be modified
|
||||
} // when var goes out of scope it doesn't get dropped because the scope didn't own it
|
||||
|
|
@ -554,7 +554,7 @@ fn borrow2(var: &mut Type) {
|
|||
|
||||
The `.` operator can **implicitly borrow or dereference** a reference
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let struct = Struct { field: /* [...] */ }
|
||||
let ref = &struct;
|
||||
|
||||
|
|
@ -578,7 +578,7 @@ To define a struct enter the keyword struct and name the entire struct.
|
|||
A struct's name should describe the significance of the pieces of data being grouped together.
|
||||
Then, inside curly brackets, define the names and types of the pieces of data, which we call *fields*.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct Struct {
|
||||
field: Type,
|
||||
...
|
||||
|
|
@ -591,7 +591,7 @@ struct UnitStruct; // no field, useful in generics
|
|||
|
||||
To use a struct after defining it, create an instance of that struct by specifying concrete values for each of the fields.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let mut var = Struct {
|
||||
field: value,
|
||||
...
|
||||
|
|
@ -600,7 +600,7 @@ let mut var = Struct {
|
|||
|
||||
### Field Init Shorthand
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let mut var = Struct {
|
||||
field, // shortened form since func param is named as the struct's field
|
||||
...
|
||||
|
|
@ -613,7 +613,7 @@ var.field = value; // member access
|
|||
|
||||
### Struct Update Syntax
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let struct1 = Struct {
|
||||
field1: value,
|
||||
field2: value,
|
||||
|
|
@ -631,7 +631,7 @@ let struct2 = Struct {
|
|||
Use Tuple Structs to create different types easily.
|
||||
To define a **tuple struct**, start with the `struct` keyword and the struct name followed by the types in the tuple.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct Point(i32, i32, i32);
|
||||
struct Color(i32, i32, i32);
|
||||
|
||||
|
|
@ -640,7 +640,7 @@ let origin = Point(0, 0, 0);
|
|||
|
||||
### Struct Printing
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
#[derive(Debug)] // inherit the debug trait
|
||||
struct Struct { }
|
||||
|
||||
|
|
@ -650,7 +650,7 @@ println!("{:?}", s) // debug output: { field: value, ... }
|
|||
|
||||
### Associated Functions & Type-Associated Functions (aka Methods)
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct Struct { };
|
||||
impl Struct
|
||||
{
|
||||
|
|
@ -667,7 +667,7 @@ Struct::type_associated_function(arg);
|
|||
|
||||
### Associated Consts
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct Struct {
|
||||
const ASSOCIATED_CONST: Type = <value>;
|
||||
}
|
||||
|
|
@ -680,7 +680,7 @@ Struct::ASSOCIATED_CONST;
|
|||
A Trait is a collection of methods representing a set of behaviours necessary to accomplish some task.
|
||||
Traits can be used as generic types constraints and can be implemented by data types.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
trait Trait {
|
||||
fn method_signature(&self, param: Type) -> Type;
|
||||
fn method_signature(&self, param: Type) -> Type {
|
||||
|
|
@ -701,7 +701,7 @@ impl Trait for Struct {
|
|||
|
||||
### Fully Qualified Method Calls
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
value.method();
|
||||
Type::method(value);
|
||||
Trait::method(value);
|
||||
|
|
@ -726,7 +726,7 @@ Derivable Traits:
|
|||
- `Default`
|
||||
- `Debug`
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
#[derive(Trait)] // derive a trait for the struct
|
||||
#[derive(Trait, Trait, ...)] // derive multiple traits
|
||||
struct Struct {
|
||||
|
|
@ -738,7 +738,7 @@ struct Struct {
|
|||
|
||||
Trait Bound are used to require a generic to implement specific traits and guarantee that a type will have the necessary behaviours.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
fn generic_method<T: RequiredTrait>() {}
|
||||
fn generic_method<T: RequiredTrait + RequiredTrait>() {} // multiple bounds
|
||||
// or
|
||||
|
|
@ -760,7 +760,7 @@ fn method_signature(param: &(impl TraitOne + TraitTwo)) -> Type {}
|
|||
|
||||
### Trait Extensions
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
extern crate foo;
|
||||
use foo::Foo;
|
||||
|
||||
|
|
@ -784,7 +784,7 @@ Rust accomplishes this by performing *monomorphization* of the code that is usin
|
|||
Monomorphization is the process of turning generic code into specific code by filling in the concrete types that are used when compiled.
|
||||
For this reason if a function as a trait as return type (trait bound), only a single type that implements the trait can be returned.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct GenericStruct<T, U> {
|
||||
T generic_field,
|
||||
U generic_field,
|
||||
|
|
@ -817,10 +817,10 @@ fn generic<T: Trait>() -> Type { } // use generic constraint
|
|||
|
||||
### Associated Types
|
||||
|
||||
_Associated types_ connect a type placeholder with a trait such that the trait method definitions can use these placeholder types in their signatures.
|
||||
*Associated types* connect a type placeholder with a trait such that the trait method definitions can use these placeholder types in their signatures.
|
||||
The implementor of a trait will specify the concrete type to be used instead of the placeholder type for the particular implementation.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
trait Iterator {
|
||||
type Item;
|
||||
|
||||
|
|
@ -848,7 +848,7 @@ In memory, a trait object is a fat pointer consisting of a pointer to the value,
|
|||
|
||||
> **Note**: Rust automatically converts ordinary references into trait objects when needed
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let trait_object = &mut dyn Trait = &mut source;
|
||||
let trait_object: Box<dyn Trait> = Box::new(source); // same for Rc<T>, Arc<T>, ...
|
||||
```
|
||||
|
|
@ -856,7 +856,7 @@ let trait_object: Box<dyn Trait> = Box::new(source); // same for Rc<T>, Arc<T>,
|
|||
This works differently from defining a struct or function that uses a generic type parameter with trait bounds.
|
||||
A generic type parameter can only be substituted with *one concrete type* at a time, whereas trait objects allow for *multiple* concrete types to fill in for the trait object at runtime.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
fn func() -> Box<dyn Trait> { } // return something that implements the specified trait
|
||||
```
|
||||
|
||||
|
|
@ -881,7 +881,7 @@ The annotation does not affect how long the references live.
|
|||
|
||||
In case of different lifetimes the complier will use the most restrictive.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// lifetime annotation syntax
|
||||
fn func<'a>(x: &'a Type, y: &'a Type) -> &'a Type { }
|
||||
|
||||
|
|
@ -914,7 +914,7 @@ They describe situations that do not require explicit lifetime annotations.
|
|||
|
||||
## Enums
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// enum definition
|
||||
enum Enum
|
||||
{
|
||||
|
|
@ -948,7 +948,7 @@ A *match expression* is made up of *arms*. An arm consists of a *pattern* and th
|
|||
|
||||
> **Note**: `match` arms must be exhaustive for compilation.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
enum Enum {
|
||||
Variant1,
|
||||
Variant2,
|
||||
|
|
@ -988,7 +988,7 @@ Guard Expression | `<pattern> if <condition>` | `match` only
|
|||
|
||||
> **Note**: `..` in slices matches *any number* of elements. `..` in structs *ignores* all remaining fields
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// unpack a struct into local variables
|
||||
let Struct { local_1, local_2, local_3, .. } = source;
|
||||
|
||||
|
|
@ -1010,7 +1010,7 @@ A **refutable pattern** is one that might not match, like `Ok(x)`. Refutable pat
|
|||
|
||||
Refutable patterns are also allowed in `if let` and `while let` expressions:
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// handle just one enum variant specially
|
||||
if let Enum::VariantX(_, _) = source { }
|
||||
|
||||
|
|
@ -1032,7 +1032,7 @@ The `Option` type is used in many places because it encodes the very common scen
|
|||
|
||||
`Result<T, E>` is the type used for returning and propagating errors. It is an enum with the variants, `Ok(T)`, representing success and containing a value, and `Err(E)`, representing error and containing an error value.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// std implementation
|
||||
enum Option<T> {
|
||||
Some(T),
|
||||
|
|
@ -1099,7 +1099,7 @@ Ending an expression with `?` will result in the unwrapped success (`Ok`) value,
|
|||
|
||||
When working with multiple error types is useful to return a "generic error" type. All the standard library error types can be represented by `Box<dyn std::Error + Send + Sync + 'static>`.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// convenience type aliases for the generic error
|
||||
type GenericError = Box<dyn std::Error + Send + Sync + 'static>;
|
||||
type GenericResult<T> = Result<T; GenericError>;
|
||||
|
|
@ -1109,7 +1109,7 @@ type GenericResult<T> = Result<T; GenericError>;
|
|||
|
||||
### Custom Error Types
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
use thiserror::Error; // utility crate for custom errors
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
|
|
@ -1130,7 +1130,7 @@ pub struct JsonError {
|
|||
Vectors allow to store more than one value in a single data structure that puts all the values next to each other in memory. Vectors can only store values of the *same type*.
|
||||
Like any other struct, a vector is freed when it goes out of scope. When the vector gets dropped, all of its contents are also dropped.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let v: Vec<Type> = Vec<Type>::new(); // empty vec init
|
||||
let mut v: vec![item1, item2, ...]; // vec init (type inferred)
|
||||
|
||||
|
|
@ -1149,7 +1149,7 @@ for i in mut &v {
|
|||
|
||||
A vector can hold different types if those type are variants of the same enum. It's also possible to use trait objects.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
enum Enum {
|
||||
Int(i32),
|
||||
Float(f64),
|
||||
|
|
@ -1167,7 +1167,7 @@ let v = vec![
|
|||
|
||||
Stores data in key-value pairs.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
use std::collections::HashMap;
|
||||
|
||||
let map: HashMap<K, V> = HashMap::new();
|
||||
|
|
@ -1189,7 +1189,7 @@ Within these limited contexts, the compiler is reliably able to infer the types
|
|||
The first time a closure is called with an argument, the compiler infers the type of the parameter and the return type of the closure.
|
||||
Those types are then locked into the closure and a type error is returned if a different type is used with the same closure.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// closure definition
|
||||
let closure = |param1, param2| <expr>;
|
||||
let closure = |param1, param2| {/* multiple lines of code */};
|
||||
|
|
@ -1207,7 +1207,7 @@ To define structs, enums, or function parameters that use closures generics and
|
|||
|
||||
The `Fn` traits are provided by the standard library. All closures implement at least one of the traits: `Fn`, `FnMut`, or `FnOnce`.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct ClosureStruct<T> where T: Fn(u32) -> u32 {
|
||||
closure: T,
|
||||
}
|
||||
|
|
@ -1236,7 +1236,7 @@ All closures implement `FnOnce` because they can all be called at least once. Cl
|
|||
To force the closure to take ownership of the values it uses in the environment, use the `move` keyword before the parameter list.
|
||||
This technique is mostly useful when passing a closure to a new thread to move the data so it's owned by the new thread.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let closure = move |param| <expr>;
|
||||
```
|
||||
|
||||
|
|
@ -1246,7 +1246,7 @@ The *iterator pattern* allows to perform some task on a sequence of items in tur
|
|||
|
||||
In Rust, iterators are *lazy*, meaning they have no effect until a call to methods that consume the iterator to use it up.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// iterator trait
|
||||
pub trait Iterator {
|
||||
type Item;
|
||||
|
|
@ -1266,7 +1266,7 @@ Other methods defined on the `Iterator` trait, known as *iterator adaptors*, all
|
|||
It's possible to chain multiple calls to iterator adaptors to perform complex actions in a readable way.
|
||||
But because all iterators are lazy, a call one of the consuming adaptor methods is needed to get the results.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let iterator: = vec![1, 2, 3];
|
||||
iterator
|
||||
.map(|x| x + 1) // iterator adapter
|
||||
|
|
@ -1276,7 +1276,7 @@ iterator
|
|||
|
||||
### Custom Iterators
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct Counter {
|
||||
count: u32,
|
||||
}
|
||||
|
|
@ -1334,7 +1334,7 @@ Boxes don't have performance overhead, other than storing their data on the heap
|
|||
- Transferring ownership of a large amount of data but ensuring the data won't be copied when you do so
|
||||
- Owning a value and which implements a particular trait rather than being of a specific type
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let _box = Box::new(pointed_value);
|
||||
```
|
||||
|
||||
|
|
@ -1343,7 +1343,7 @@ let _box = Box::new(pointed_value);
|
|||
Implementing the `Deref` trait allows to customize the behavior of the dereference operator, `*`.
|
||||
By implementing `Deref` in such a way that a smart pointer can be treated like a regular reference.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct CustomSmartPointer<T>(T);
|
||||
|
||||
impl<T> CustomSmartPointer<T> {
|
||||
|
|
@ -1370,7 +1370,7 @@ let v = *(s.deref());
|
|||
It works only on types that implement the `Deref` trait and converts such a type into a reference to another type.
|
||||
Deref coercion was added to Rust so that programmers writing function and method calls don't need to add as many explicit references and dereferences with `&` and `*`.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
fn hello(name: &str) {
|
||||
println!("Hello {}", name);
|
||||
}
|
||||
|
|
@ -1395,7 +1395,7 @@ Rust does *deref coercion* when it finds types and trait implementations in thre
|
|||
|
||||
`Drop` allows to customize what happens when a value is about to go out of scope. It-s possible to provide an implementation for the `Drop` trait on any type.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
struct CustomSmartPointer<T>(T);
|
||||
|
||||
impl<T> Drop for CustomSmartPointer<T> {
|
||||
|
|
@ -1419,7 +1419,7 @@ Rust provides the *reference-counted* pointer types `Rc<T>` and `Arc<T>`.
|
|||
The `Rc<T>` and `Arc<T>` types are very similar; the only difference between them is that an `Arc<T>` is safe to share between
|
||||
threads directly (the name Arc is short for *atomic* reference count) whereas a plain `Rc<T>` uses faster non-thread-safe code to update its reference count.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
use std::rc::Rc;
|
||||
|
||||
let s: Rc<String> = Rc::new("some string".to_string());
|
||||
|
|
@ -1477,10 +1477,10 @@ This creates memory leaks because the reference count of each item in the cycle
|
|||
|
||||
### Creating Threads
|
||||
|
||||
The `thread::spawn` function creates a new tread that will execute the passed closure. Any data captured by the closure is _moved_ to the capturing thread.
|
||||
The `thread::spawn` function creates a new tread that will execute the passed closure. Any data captured by the closure is *moved* to the capturing thread.
|
||||
The thread's **handle** can be used to wait for completion and retieve the computation result or errors if any.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// if no data is captured the move keyword can be removed
|
||||
let handle = std::thread::spawn(move || { /* ... */ });
|
||||
|
||||
|
|
@ -1490,12 +1490,12 @@ handle.join().unwrap();
|
|||
> **Note**: a thread's execution can be termiated early if it's not joined and the main process terminates before the thread had completed it's work.
|
||||
> **Note**: if a thread panics the handle will return the panic message so that it can be handled.
|
||||
|
||||
### Channnels
|
||||
### Channels
|
||||
|
||||
To accomplish message-sending concurrently Rust's standard library provides an implementation of _channels_.
|
||||
To accomplish message-sending concurrently Rust's standard library provides an implementation of *channels*.
|
||||
A **channel** is a general programming concept by which data is sent from one thread to another.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
let (sender, receiver) = std::sync::mpsc::channel(); // the sender can be cloned to create multiple transmitters
|
||||
|
||||
let sender_1 = sender.clone();
|
||||
|
|
@ -1521,13 +1521,13 @@ for message in receiver { } // receive multiple values (iteration stops when cha
|
|||
|
||||
The `Send` marker trait indicates that ownership of values of the type implementing `Send` can be transferred between threads. Any type composed entirely of `Send` types is automatically marked as `Send`. Almost all primitive types are `Send`, aside from raw pointers.
|
||||
|
||||
The `Sync` marker trait indicates that it is safe for the type implementing `Sync` to be referenced from multiple threads. In other words, any type `T` is `Sync` if `&T` (an immutable reference to `T`) is `Send`, meaning the reference can be sent safely to another thread. Similar to `Send`, primitive types are `Sync`, and types composed entirely of types that are `Sync `are also `Sync`.
|
||||
The `Sync` marker trait indicates that it is safe for the type implementing `Sync` to be referenced from multiple threads. In other words, any type `T` is `Sync` if `&T` (an immutable reference to `T`) is `Send`, meaning the reference can be sent safely to another thread. Similar to `Send`, primitive types are `Sync`, and types composed entirely of types that are `Sync`are also `Sync`.
|
||||
|
||||
## Files
|
||||
|
||||
### Reading Files
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
use std::fs;
|
||||
|
||||
let contents: Vec<u8> = fs::read("path/to/file").unwrap_or_default();
|
||||
|
|
@ -1538,7 +1538,7 @@ contents.lines(); // iterator over text lines
|
|||
|
||||
### Writing Files
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
use std::fs;
|
||||
use std::io::Write; // write trait
|
||||
// or
|
||||
|
|
@ -1562,7 +1562,7 @@ The extern keyword is used in two places in Rust:
|
|||
|
||||
`extern` is used in two different contexts within FFI. The first is in the form of external blocks, for declaring function interfaces that Rust code can call foreign code by.
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
#[link(name = "my_c_library")]
|
||||
extern "C" {
|
||||
fn my_c_function(x: i32) -> bool;
|
||||
|
|
@ -1575,7 +1575,7 @@ Working with non-Rust languages and FFI is inherently unsafe, so wrappers are us
|
|||
|
||||
The mirror use case of FFI is also done via the extern keyword:
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
#[no_mangle]
|
||||
pub extern "C" fn callable_from_c(x: i32) -> bool {
|
||||
x % 3 == 0
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## Test Functions
|
||||
|
||||
```rs
|
||||
```rs linenums="1"
|
||||
// module code here
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -33,7 +33,7 @@ mod tests {
|
|||
|
||||
## Controlling How Tests Are Run
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
cargo test -- --test-threads=<number> # run tests in parallel (1 no parallelism)
|
||||
cargo test -- --show-output # show content printed in stdout in each test
|
||||
cargo test <test_name> # run only a specific test
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
### Macro
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
#if DEBUG
|
||||
|
||||
// contents compiled only if in DEBUG build
|
||||
|
|
@ -18,7 +18,7 @@
|
|||
|
||||
### Comments
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
// single line comment
|
||||
|
||||
/*
|
||||
|
|
@ -28,7 +28,7 @@ multi line comment
|
|||
|
||||
### Variables
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
var variable = value // implicit variable init (auto-determine type)
|
||||
var variable: Type = value // explicit variable init
|
||||
var variable: Type? = value // explicit nullable variable init
|
||||
|
|
@ -36,13 +36,13 @@ var variable: Type? = value // explicit nullable variable init
|
|||
|
||||
### Constants
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
let CONSTANT = value // constant init (value can be assigned at runtime)
|
||||
```
|
||||
|
||||
### Console Output
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
print() // empty line
|
||||
print(variable)
|
||||
print("string")
|
||||
|
|
@ -50,7 +50,7 @@ print("string")
|
|||
|
||||
## Strings
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
var string "Text: \(<expr>)" // string interpolation
|
||||
var string = "Hello" + "There" // string concatenation
|
||||
|
||||
|
|
@ -60,7 +60,7 @@ to make a string span multiple lines"""
|
|||
|
||||
## Array
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
var array = ["firstItem", "secondItem", ...]
|
||||
var array = [Type()] // init empty homogeneous array
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ It's possible to use a tuple type as the return type of a function to enable the
|
|||
It's possible to name the elements of a tuple type and use those names to refer to the values of the individual elements.
|
||||
An element name consists of an identifier followed immediately by a colon (:).
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
var tuple: (Type, Type) = (value, value) // explicit type
|
||||
var tuple = (value, value) // implicit type
|
||||
tuple.0 // item access
|
||||
|
|
@ -98,21 +98,21 @@ tuple.name1 // item access
|
|||
|
||||
### Tuple Decomposition
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
var tuple = (value1, value2)
|
||||
var (var1, var2) = tuple // var1 = value1, var2 = value2
|
||||
```
|
||||
|
||||
## Type Identifier
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
typealias Point = (Int, Int)
|
||||
var origin: (0, 0)
|
||||
```
|
||||
|
||||
## Dictionary
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
var dict = [
|
||||
"key": "value",
|
||||
...
|
||||
|
|
@ -208,7 +208,7 @@ dict[key] = value // value update
|
|||
|
||||
### Nil Checks
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
variable ?? value
|
||||
// same as
|
||||
if(variable == nil) { variable = value }
|
||||
|
|
@ -216,7 +216,7 @@ if(variable == nil) { variable = value }
|
|||
|
||||
## If-Else
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
if condition {
|
||||
// code here
|
||||
} else if condition {
|
||||
|
|
@ -233,7 +233,7 @@ if var0 != nil { /* statements */ }
|
|||
|
||||
### Switch
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
switch <value> {
|
||||
case <pattern/key>:
|
||||
// code here
|
||||
|
|
@ -253,7 +253,7 @@ switch <value> {
|
|||
|
||||
### For Loop
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
// range based for
|
||||
for i in start...end { /* statements */ } // end included
|
||||
for i in start..<end { /* statements */ } // end excluded
|
||||
|
|
@ -270,7 +270,7 @@ for (key, value) in dict {
|
|||
|
||||
### While Loop
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
while condition {
|
||||
// code here
|
||||
}
|
||||
|
|
@ -283,7 +283,7 @@ repeat {
|
|||
|
||||
## Functions
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
// "void function"
|
||||
func funcName(param: Type, ...) {
|
||||
// code here
|
||||
|
|
@ -318,14 +318,14 @@ funcWithLabels(value, label: value, ...)
|
|||
|
||||
### Passing Functions as Parameters
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
func f(param: Type) -> Type {}
|
||||
func g(f: (Type) -> Type) {} // (Type) -> Type are the passed func input and output types
|
||||
```
|
||||
|
||||
### Functions Returning Functions
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
func f() -> ((Type) -> Type) {
|
||||
func g(param: Type) -> type {}
|
||||
|
||||
|
|
@ -338,7 +338,7 @@ func f() -> ((Type) -> Type) {
|
|||
**Closures** are self-contained blocks of functionality that can be passed around and used in code.
|
||||
Closures in Swift are similar to blocks in C and Objective-C and to lambdas in other programming languages.
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
{ (parameters: Type) -> Type in
|
||||
// statements
|
||||
}
|
||||
|
|
@ -351,7 +351,7 @@ Closures in Swift are similar to blocks in C and Objective-C and to lambdas in o
|
|||
|
||||
### Enum Definition
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
enum EnumName {
|
||||
case key1
|
||||
case key2
|
||||
|
|
@ -363,7 +363,7 @@ EnumName.key1 // key1
|
|||
|
||||
### Enum with Raw Values
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
enum EnumName: Type {
|
||||
case key1 = value
|
||||
case key2 = value
|
||||
|
|
@ -382,7 +382,7 @@ enum IntegerEnum: Int {
|
|||
|
||||
### Matching Enumeration Values with a Switch Statement
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
enum Rank: Int {
|
||||
case ace = 1, two, three, four, five, six, seven, eight, nine, ten
|
||||
case jack, queen, king
|
||||
|
|
@ -411,7 +411,7 @@ Rank.jack.rawValue // 11
|
|||
|
||||
## Struct (Value Type)
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
struct StructName {
|
||||
var attribute = value // instance variable
|
||||
private var _attribute: Type // backing field for property
|
||||
|
|
@ -446,7 +446,7 @@ var structure = StructName() // struct instantiation
|
|||
|
||||
### Class Definition & Instantiation
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
class ClassName {
|
||||
var attribute = value // instance variable
|
||||
private var _attribute: Type // backing field for property
|
||||
|
|
@ -483,7 +483,7 @@ Do actions before/after modifying a property value.
|
|||
|
||||
> **Note**: `willSet` and `didSet` do not *set* the value of the property.
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
class ClassName {
|
||||
|
||||
var _attribute: Type
|
||||
|
|
@ -505,7 +505,7 @@ class ClassName {
|
|||
|
||||
### Inheritance
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
class Derived: SuperClass {
|
||||
|
||||
var attribute: Type
|
||||
|
|
@ -522,7 +522,7 @@ class Derived: SuperClass {
|
|||
|
||||
### Exception Handling
|
||||
|
||||
```swift
|
||||
```swift linenums="1"
|
||||
guard let variable = <expression>
|
||||
else {
|
||||
/* statements */
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
|
||||
Data Model Structure:
|
||||
|
||||
```txt
|
||||
```txt linenums="1"
|
||||
<root> (tree)
|
||||
|
|
||||
|_ foo (tree)
|
||||
|
|
@ -35,7 +35,7 @@ Data Model Structure:
|
|||
|
||||
Data Model as pseudocode:
|
||||
|
||||
```py
|
||||
```py linenums="1"
|
||||
# a file is a bunch of bytes
|
||||
blob = array<byte>
|
||||
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ A GraphQL service is created by defining types and fields on those types, then p
|
|||
|
||||
The most basic components of a GraphQL schema are object types, which just represent a kind of object fetchable from the service, and what fields it has.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
type Type {
|
||||
field: Type
|
||||
field: Type! # non-nullable type
|
||||
|
|
@ -29,7 +29,7 @@ Every field on a GraphQL object type can have zero or more arguments. All argume
|
|||
|
||||
Arguments can be either *required* or *optional*. When an argument is optional, it's possible to define a default value.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
type Type {
|
||||
field: Type,
|
||||
field(namedArg: Type = defaultValue): Type
|
||||
|
|
@ -55,7 +55,7 @@ GraphQL comes with a set of default scalar types out of the box:
|
|||
|
||||
In most GraphQL service implementations, there is also a way to specify custom scalar types.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
scalar ScalarType
|
||||
```
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ This allows to:
|
|||
1. Validate that any arguments of this type are one of the allowed values
|
||||
2. Communicate through the type system that a field will always be one of a finite set of values
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
enum Type{
|
||||
VALUE,
|
||||
VALUE,
|
||||
|
|
@ -97,7 +97,7 @@ Like many type systems, GraphQL supports interfaces. An Interface is an abstract
|
|||
|
||||
Interfaces are useful when returning an object or set of objects, but those might be of several different types.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
interface Interface {
|
||||
fieldA: TypeA
|
||||
fieldB: TypeB
|
||||
|
|
@ -115,7 +115,7 @@ type Type implements Interface {
|
|||
|
||||
Interfaces are useful when returning an object or set of objects, but those might be of several different types.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
union Union = TypeA | TypeB | TypeC
|
||||
```
|
||||
|
||||
|
|
@ -125,7 +125,7 @@ union Union = TypeA | TypeB | TypeC
|
|||
|
||||
In the GraphQL schema language, input types look exactly the same as regular object types, but with the keyword input instead of type:
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
input Input {
|
||||
field: Type,
|
||||
...
|
||||
|
|
@ -141,7 +141,7 @@ Input object types also can't have arguments on their fields.
|
|||
|
||||
### Simple Query
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
{
|
||||
field { # root field
|
||||
... # payload
|
||||
|
|
@ -149,7 +149,7 @@ Input object types also can't have arguments on their fields.
|
|||
}
|
||||
```
|
||||
|
||||
```json
|
||||
```json linenums="1"
|
||||
{
|
||||
"data" : {
|
||||
"field": {
|
||||
|
|
@ -167,7 +167,7 @@ But in GraphQL, every field and nested object can get its own set of arguments,
|
|||
|
||||
It's aldo possible to pass arguments into scalar fields, to implement data transformations once on the server, instead of on every client separately.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
{
|
||||
fieldA(arg: value) # filter results
|
||||
fieldB(arg: value)
|
||||
|
|
@ -177,7 +177,7 @@ It's aldo possible to pass arguments into scalar fields, to implement data trans
|
|||
|
||||
### Aliases
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
{
|
||||
aliasA: field(arg: valueA) {
|
||||
field
|
||||
|
|
@ -193,7 +193,7 @@ It's aldo possible to pass arguments into scalar fields, to implement data trans
|
|||
Fragments allow to construct sets of fields, and then include them in queries where that are needed.
|
||||
The concept of fragments is frequently used to split complicated application data requirements into smaller chunks.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
{
|
||||
aliasA: field(arg: valueA) {
|
||||
...fragment
|
||||
|
|
@ -214,7 +214,7 @@ fragment fragment on Type {
|
|||
|
||||
It is possible for fragments to access variables declared in the query or mutation.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
query Query($var: Type = value) {
|
||||
aliasA: field(arg: valueA) {
|
||||
...fragment
|
||||
|
|
@ -240,7 +240,7 @@ The *operation type* is either `query`, `mutation`, or `subscription` and descri
|
|||
|
||||
The *operation name* is a meaningful and explicit name for the operation. It is only required in multi-operation documents, but its use is encouraged because it is very helpful for debugging and server-side logging. When something goes wrong it is easier to identify a query in the codebase by name instead of trying to decipher the contents.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
query Operation {
|
||||
...
|
||||
}
|
||||
|
|
@ -254,7 +254,7 @@ When working with variables, three things need to be done:
|
|||
2. Declare `$variableName` as one of the variables accepted by the query
|
||||
3. Pass `variableName: value` in the separate, transport-specific (usually JSON) variables dictionary
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
query Operation($var: Type = defaultValue) {
|
||||
field(arg: $var) {
|
||||
field
|
||||
|
|
@ -288,7 +288,7 @@ Operations of mutations:
|
|||
- **Updating** existing data
|
||||
- **Deleting** existing data
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
mutation Operation {
|
||||
createObject(arg: value, ...) {
|
||||
field
|
||||
|
|
@ -301,7 +301,7 @@ mutation Operation {
|
|||
|
||||
Open a stable connection with the server to receive real-time updates on the operations happening.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
subscription Operation {
|
||||
event { # get notified when event happens
|
||||
field # data received on notification
|
||||
|
|
@ -314,7 +314,7 @@ subscription Operation {
|
|||
|
||||
If you are querying a field that returns an interface or a union type, you will need to use inline fragments to access data on the underlying concrete type. Named fragments can also be used in the same way, since a named fragment always has a type attached.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
query Operation($var: Type) {
|
||||
field(arg: $var) { # interface of union
|
||||
field
|
||||
|
|
@ -332,7 +332,7 @@ query Operation($var: Type) {
|
|||
|
||||
GraphQL allows to request `__typename`, a meta field, at any point in a query to get the name of the object type at that point.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
{
|
||||
field(arg: value) {
|
||||
__typename
|
||||
|
|
@ -357,7 +357,7 @@ If a field produces a scalar value like a string or number, then the execution c
|
|||
|
||||
At the top level of every GraphQL server is a type that represents all of the possible entry points into the GraphQL API, it's often called the *Root* type or the *Query* type.
|
||||
|
||||
```graphql
|
||||
```graphql linenums="1"
|
||||
# root types for entry-points
|
||||
|
||||
type Query {
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
## Basics
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
ssh user@destination <command> # exec <command> in remote machine ($SHELL if omitted)
|
||||
ssh user@destination -i <path/to/private-key> # use key for auth
|
||||
ssh user@destination -f # exec ssh in the background
|
||||
|
|
@ -19,7 +19,7 @@ ssh user@destination -t # force pseudo-tty emulation
|
|||
|
||||
Connect to the final destination jumping through the specifies other destinations.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
ssh -J user_1@destination_1,user_2@destination_2 user@final_destination
|
||||
```
|
||||
|
||||
|
|
@ -31,7 +31,7 @@ ssh -J user_1@destination_1,user_2@destination_2 user@final_destination
|
|||
|
||||
Start listening on `local_address:local_port` and forward any traffic to `remote_address:remote_port`.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
ssh -N -f -L local_address:local_port:remote_address:remote_port user@destination
|
||||
ssh -N -f -L local_port:remote_address:remote_port user@destination # local_address defaults to localhost
|
||||
```
|
||||
|
|
@ -40,6 +40,6 @@ ssh -N -f -L local_port:remote_address:remote_port user@destination # local_add
|
|||
|
||||
Start listening on `remote_address:remote_port` and forward any traffic to `local_address:local_port`.
|
||||
|
||||
```sh
|
||||
```sh linenums="1"
|
||||
ssh -N -f -R remote_address:remote_port:local_address:local_port user@destination
|
||||
```
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue