<!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>
<link rel="stylesheet" href="style.css">
Ceci joint un fichier css au nom de "style.css"
<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 :
<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 :
<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 :
<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
<img src="img/roller_jump.jpg" alt="roller" width=200px />
résultat :
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)
<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
<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 :
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 :
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
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"
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
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"
}
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é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
<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 :
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>'; ?>"
<?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 :
/!\ 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 :
$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
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
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".
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
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.