Documentation personnelle

Sommaire

HTML / CSS CSS Javascript / Typescript PHP Laravel

HTML / CSS

Header :
            
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Page Title</title>
</head>
<body>

Ajouter du css :
            
<link rel="stylesheet" href="style.css">

Ceci joint un fichier css au nom de "style.css"

Font Awesome :
            
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
integrity="sha512-iecdLmaskl7CVkqkXNQ/ZH/XLlvWZOJyj7Yy7tcenmpD1ypASozpmT/E0iPtmFIB46ZmdtAc9eNBvH0H/ZpiBw=="
crossorigin="anonymous" referrerpolicy="no-referrer" />

Ceci permet de joindre les icônes de Font Awesome via ce lien :

                
<i class="fa-solid fa-thumbs-up"></i>

résultat :

Les listes :
                
<ul>
    <li>banane</li>
    <li>pastèque</li>
    <li>abricot</li>
</ul>
<ol>
    <li>a</li>
    <li>b</li>
    <li>c</li>
</ol>

résultat :

  • banane
  • pastèque
  • abricot
  1. a
  2. b
  3. c

<ul></ul> : liste désordonnée (unordered list)

<ol></ol> : liste ordonnée (ordered list)

<li></li> : élément d'une liste (list item)

On peut remplacer les points ou les numéros avec du css :

                
ul {
    list-style-type: square;
}

/* On peut aussi affecter 
les list item en remplaçant 
ul par li directement */

résultat :

  • banane
  • pastèque
  • abricot
  1. a
  2. b
  3. c
Les tableaux :
                
<table>
<thead>
    <tr>
        <th>Numéro</th>
        <th colspan='2'>Combinaison</th>
    </tr>
</thead>
<tbody>
    <tr>
        <td>1</td>
        <td>Fraise</td>
        <td>Banane</td>
    </tr><tr>
        <td>2</td>
        <td>Amande</td>
        <td>Noisette</td>
    </tr>
</tbody>
</table>

résultat :

Numéro Combinaison
1 Fraise Banane
2 Amande Noisette

<table></table> : créer un tableau

<tbody></tbody> et <thead></thead> servent à organiser le tableau de la même manière qu'une page html

<tr></tr> : ligne d'un tableau (table row)

<th></th> / <td></td> : les cellules d'un tableau (table header / table data)

Les attributs "colspan" et "rowspan" permettent de faire occuper plus de cases à une cellule d'un tableau

                
table td, table th , table  {
    border: solid;
    border-collapse:collapse;
    padding: 5px;
}

résultat :

Numéro Combinaison
1 Fraise Banane
2 Amande Noisette

Ce css permet d'ajouter les bordures d'un tableau en sélectionnant la table et les cellules et d'ajouter une marge (de 5px) dans les cellules histoire que les éléments ne colle pas les bordures

Les images :
                
<img src="img/roller_jump.jpg" alt="roller" width=200px />

résultat :

roller

Inserer une image depuis la source précisée avec "src" ou "url"

Modifier le nom de l'image avec "alt" : cela remplacera l'image par ce nom dans le cas où elle n'est pas trouvée

Ajuster la taille avec "width" et "height" (la hauteur sera ajusté automatiquement si elle n'est pas précisée)

Les liens hypertextes :
                
<a href ="https://github.com/PyGaVS" target='_blank'>Mon github</a>

résultat :

Ceci est un redirection sous forme de lien ou de bouton vers mon compte github

"target='_blank'" permet d'ouvrir un nouvel tab quand on clique sur le lien

Les formulaires :
                
<form method="GET" action="docs.html">
   <label for="nom"> Nom </label>
   <input type="string" name="nom">
   <label for="fruit"> Fruit </label>
   <select name="fruit">
       <option> Fraise </option>
       <option> Kiwi </option>
       <option> Melon </option>
   </select>
   <input type="submit">
</form>

résultat :

<form></form> : créer un formulaire

<input> : élément où l'utilisateur peut intéragir différemment selon le "type"

<label></label> : créer un label que l'on peut relier avec les attributs "for" et "name"

<select></select> : créer une liste de selection

L'attribut "action" sert à ajouter des éléments dans l'url (observer l'url lors du test)

L'attribut "type" sert à sert à modifier le type d'entrée, voici quelque exemples :

                
<p><input type="button" value="bouton"></p>

<p><input type="checkbox"></p>

<p><input type="color"></p>

<p><input type="date"></p>

<p><input type="time"></p>

<p><input type="file"></p>

<p><input type="hidden" value="texte caché pouvant être récupéré lors d'un POST"></p>

<p><input type="number" step="9"></p>

<p><input type="password" value="mdp"></p>

<p><input type="radio" name="fruit" id="fraise">
<label for="fraise">Fraise</label></p>
<p><input type="radio" name="fruit" id="banane" checked>
<label for="banane">Banane</label></p>

<p><input type="range"></p>

<p><input type="text" value="texte"></p>

résultat :

CSS

Flexbox :

Guide complet pour utiliser une Flexbox ici avec quelque exemple de propriétés d'une Flexbox si dessous :

    
<div class="container">
    <div class="item1"></div>
    <div class="item2"></div>
</div>

        
div {
    border: solid black;
    min-height: 60px;
    min-width: 60px;
    padding: 5px;
    margin: 5px;
}

.container {
    background-color: gray;
    height: 150px;

    display: flex;
    flex-direction: row;    /* Direction de la Flexbox */
    flex-wrap: wrap;    /* Gérer le débordement de la Flexbox*/
    flex-flow: row wrap;    /* Un raccourci qui rassemble les deux propriétés si-dessus*/
    justify-content: center;    /* Position des éléments par rapport à la flex-direction */
    align-items: flex-start;    /* Alignement des éléments */
    gap : 20px;     /* Espace entre les éléments */
}

.item1, .item2{
    background-color: lightblue;
}

résulat :

Javascript / Typescript

La syntaxe js :
            
const a = 3
let b = 3
b = 4
console.log("hello world")

                
function additionner(v1, v2){
    console.log(v1 + v2)
}
additionner(5,6)

résultat :

11

On utilise "let" pour définir une variable modifiable et "const" pour définir une variable non modifiable. "var" est une ancienne façon de définir une variables

On utilise console.log() pour afficher ce qu'on veux dans la console

Typer les variables :
            
const a: number = 3       
const c: string = 'ceci est une chaine de caractère'

function additionner(v1: number, v2: number){
    console.log(v1 + v2)
}

Le Typescript permet de typer les déclarations de varaible, on type une variable avec ":" suivi du nom du type

Les principaux types sont : "number", "string", "boolean" et "any"

Les listes indexés :
                
let liste0: number[] = [3, 7, 4.9, 3+6]
//le type indique que la liste doit contenir uniquement des nombres

let liste1: any[] = [5, "t"]
//Cette liste peut contenir n'importe quelle type

let liste2: [number, string, boolean] = [3, "a", false]
//Les types indiqués doivent être respectés dans l'ordre et cette liste doit obligatoirement contenir 3 éléments

let liste3: (number | string)[] = ["a", 4, 5]
//Cette liste peut contenir uniquement des nombres et des chaîne de caractères

console.log(liste0[0])   //Affiche le premier élément de liste0


//Parcourir une liste :

for(let i in liste1){
    console.log(n°${i} : ${liste1[i]})
}

for(let i of liste1){
    console.log(i)
}

résultat :

3

n°0 : 5

n°1 : t

5

t

Dans une boucle for, on peut utiliser "in" pour récupérer l'index ou "of" pour directement récupérer la valeur

Les conditions :
        
let x: number = 4;

if (x > 4){
    console.log('x est plus grand que 4')
} else if (x==4){
    console.log('x est égal à 4')
} else {
    console.log('x est plus petit que 4')
}

while(x >= 0){
    console.log(x)
    x -= 1
}

résulat :

x est égal à 4

4

3

2

1

0

"x -= 1" est un raccourci de "x = x - 1"

        
let age:number = 18

const check = (age: number): string => age >= 18 ? "majeur" : age > 0 ? "mineur" : "invalid"
console.log(check(age));

résulat :

majeur

La fonction check est simplifiée et elle se traduit comme :

    
function check(age: number): string {
    return age >= 18 ? "majeur" : age > 0 ? "mineur" : "invalid"
}

Les switchs :
        
let fruit: string = 'ba'

//ALTERNATIVE 1

switch (fruit){
    case 'ba':
        console.log('banane')
        break

    case 'ki':
        console.log('kiwi')
        break

    case 'ma':
        console.log('mango')
        break

    default:
        console.log('fruit inconnu')
}


//ALTERNATIVE 2

//Créer un type pour la variable fruits
type Switch = {
    [key: string]: (...params: unknown[]) => void
    default:  (...params: unknown[]) => void
}

const fruits: Switch = {
    ba: () => console.log('banane'),
    ki: () => console.log('kiwi'),
    ma: () => console.log('mango'),
    default: console.log
}

//Utiliser le switch avec une constante
const fruit2: (...params: unknown[]) => void = fruits['kidfgh'] ?? fruits.default
fruit2('des', 'paramètres', 'aléatoires', 4, 'fruit inconnu');

//Utiliser le switch sans intermédiaire
(fruits['ki'] ?? fruits.default)('fruit inconnu')

résulat :

banane

des paramètres aléatoires 4 fruit inconnu

kiwi

Si il n'y a pas de "break" à la fin d'un "case" le default sera aussi éxecuté

"() =>" défini une fonction anonyme

Si le fruit n'est pas trouvé la fonction executée fonctionnera de la même manière qu'un console.log()

Les types génériques :

Les types générique permettent de donner un type d'entrée ou de retour à une fonction que l'on pourra ensuite indiquer lors de l'appel de la fonction.

Dans l'exemple si dessous, les deux paramètres v1 et v2 doivent avoir le même type "T" dont T peut varier en fonction de l'appel.

        
function additionner<T extends number | string | unknown[]>(v1: T, v2: T): T {

    if (typeof v1 == "string"){
        return v1 + v2 as T
    } else if (typeof v1 == "number" && typeof v2 == "number"){
        return v1 + v2 as T
    } else if (v1 instanceof Array && v2 instanceof Array){
        return [...v1, ...v2] as T
    } else {
        return "params not valid" as T
    }
}

console.log(additionner<(string | number)[]>([1, 2, 3], ["a", "u"]))
console.log(additionner<string>("hello ", "world"))
console.log(additionner<number>(6, 4))
// On est pas obligé de mettre un type générique à l'appel de la fonction 
// mais les deux paramètres doivent avoir le même type :
console.log(additionner(6, 4))

résulat :

[ 1, 2, 3, 'a', 'u' ]

hello world

10

10

Ts cheat sheets :

https://www.typescriptlang.org/cheatsheets

Php

La syntaxe php :
        
<h1>Test</h1>
<?php
$a = 'Hello ';
$b = 'world'; 
$c = '';
$c .= $a.$b.' !';    // On ajoute à $c les chaines &a, &b et ' !'

echo $c;            // Afficher $c sur la page web
?>
<?= '<p>'.$c.'</p>'; ?>

résulat :

Test

Hello world !

Hello world !

Pour écrire du php il faut utiliser ces balises : <?php ?>

On utilise "$" pour définir ou utiliser une variable php.

Pour concaténer des chaînes de caractères il faut utiliser "."

"<?= '<p>'.$c.'</p>'; ?>" est un raccourci de "<?php echo '<p>'.$c.'</p>'; ?>"

Les listes indexés php :
        
<?php
$semaine = ['lundi','mardi','mercredi','jeudi','vendredi','samedi']; 
$semaine[] = 'dimanche';

echo '<p>';
foreach($semaine as $jour){
    echo $jour.' ';
}
echo '</p>';

echo '<p>';

// en utilisant la méthode range($start, $end, $step)
foreach( range(1, count($semaine), 2) as $numero){
    echo $numero.' '.$semaine[$numero-1].' / ';
}
echo '</p>';

résulat :

lundi mardi mercredi jeudi vendredi samedi dimanche

1 lundi / 3 mercredi / 5 vendredi / 7 dimanche /

En debug, on peut aussi utiliser la méthode var_dump() pour afficher une liste ainsi que sa structure :

        
var_dump($semaine);

résulat :

array(7) { [0]=> string(5) "lundi" [1]=> string(5) "mardi" [2]=> string(8) "mercredi" [3]=> string(5) "jeudi" [4]=> string(8) "vendredi" [5]=> string(6) "samedi" [6]=> string(8) "dimanche" }

/!\ La méthode echo ne peut pas être utilisé pour afficher une liste, il faut utiliser une boucle.

    
$string = "a b c";

$list = explode(' ', $string);  //explode($separator, $string)
// $list = ['a', 'b', 'c']

On peut utiliser la fonction explode() pour transformer une chaîne de caractère en liste

Rechercher un élément dans une liste :

        
$fruits = ['pomme', 'orange'];

if(in_array('orange', $fruits)){    //in_array($string, $list)
    echo '"orange" est bien présent dans la liste <br>';
    echo 'Clé : '.array_search('orange', $fruits);    //array_search($string, $list)
}



résulat :

"orange" est bien présent dans la liste
Clé : 1
Les listes associatives php :
        
$player = [
    'hp'    => 200,
    'atk'   => 90,
    'def'   => 85,
];

$player['spd'] = 70;

foreach($player as $clef => $valeur){
	echo '<p>le joueur possède '.$valeur.' en '.$clef.'</p>';
    }

résulat :

le joueur possède 200 en hp

le joueur possède 90 en atk

le joueur possède 85 en def

le joueur possède 70 en spd

Préparer et sécuriser une requête sql :

En utilisant une liste indexée comme paramètre :

    
$sql = 'SELECT * FROM characters
    WHERE hp > ? AND category = ?';
$request = $dbh->prepare($sql);
$request->execute([180, 'tank']);
$characters = $request->fetchAll();

En utilisant une liste associative comme paramètre :

    
$sql = 'SELECT * FROM characters
    WHERE hp > :hp AND category = :category';
$request = $dbh->prepare($sql, [PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY]);
$request->execute(['hp' => 180, 'category' => 'tank']);
$characters = $request->fetchAll();

$bdh étant une instance de la classe PDO

Laravel

Générer une fonctionnalité :
    
php artisan make:model ModelName -a

Cette commande permet de générer un modèle et le "-a" permet d'ajouter le contrôleur, la migration, le seeder, la factory et les policies en plus.

Le nom du modèle doit être au singulier et en "PascalCase".

Créer les routes :

La documentation laravel sur les routes :

https://laravel.com/docs/10.x/routing

        
Route::prefix('pre')->group(function () {
    //Route::ressource('nom de la fonctionnalité', le contrôleur correspondant)
    Route::resource('category', Controllers\CategoryController::class);
});


résulat :

Les routes GET POST PUT et DELETE seront créées à partir de l'url :

lien-du-site/pre/category/

Route::prefix() permet d'ajouter un préfixe dans l'url.

Route::ressource permet de créer toute les routes correspondante à la fonctionnalité (index, add, create, edit, update, delete).

La commande php artisan pour afficher les routes de l'appli :

    
php artisan route:list

Créer les migrations :

La documentation laravel sur les migrations :

https://laravel.com/docs/10.x/migrations

La commande pour générer un fichier de migration :

    
php artisan make:migration create_players_table

        
public function up(): void
{
    Schema::create('trios', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->float('score')->default(0.00);
        $table->foreignId('player1')->constrained('players');
        $table->foreignId('player2')->constrained('players');
        $table->foreignId('player3')->constrained('players');
        $table->foreignId('coach_id')->constrained();
        $table->timestamps();
    });
}


résulat :

Trios(id, name, score, player1, player2, player3, coach_id, created_at, updated_at)

clé primaire : id

clés étrangères :

-player1 référence à players

-player2 référence à players

-player3 référence à players

-coach_id référence à coachs

Si le nom de la clé étrangère n'est pas de la forme "[table_au_singulier]_id", il faut préciser en paramètre la table référencé dans la méthode constrained().

La méthode nullable() permet de définir que le champs peut être null.