Transcription
1. Aperçu du cours: Bonjour à tous, merci
de vous joindre à moi. Voici la présentation du cours pour des scripts JavaScript
et TypeScript pratiques. Alors pourquoi devriez-vous apprendre
TypeScript ou JavaScript ? C'est un langage très, très polyvalent
et couramment utilisé. Il est donc utilisé par
les développeurs pour créer une logique côté serveur. Il est également utilisé par la majorité
des sites Web frontaux. Il est donc utilisé par les développeurs
front-end pour créer des sites Web et des applications. Et cela inclut les applications mobiles. Et il est couramment utilisé par tous les
développeurs pour les scripts. Alors, qu'est-ce que JavaScript ? Javascript est un langage
typé dynamiquement, ce qui signifie qu'
il n'y a
aucune vérification de type dans l'exemple de code. Vous voyez, vous verrez que nous
déclarons une variable nommée a. Nous l'attribuons,
qui est un nombre. Mais vous pouvez
également voir que vous pouvez l'attribuer à une chaîne. Cela signifie que la langue
est très, très flexible. Et c'est une bonne chose pour un certain nombre
de raisons, car cela vous
permet d'itérer et d'
écrire du code très rapidement. Mais cela peut entraîner de
nombreux problèmes, en particulier dans les grandes bases de code. Donc quelque chose comme ça. Supposons que vous vouliez dire qu' une constante b est
égale à a fois à. Disons que cela se trouve dans une partie
distincte du code. Maintenant, ce sera bien
si a est un nombre, vous pouvez
donc multiplier
deux pour n'importe quel nombre. Mais si a est une chaîne,
cela générera une erreur
et vous ne saurez pas qu'
il y a une erreur tant que vous n'aurez pas exécuté ce morceau de code. Entrez donc TypeScript. Typescript est essentiellement
une couche
typée statiquement située au-dessus de JavaScript. Il a amélioré JavaScript en
ajoutant cette vérification de type, ce qui le rend plus résistant aux bogues et facilite
la résolution des problèmes. Ainsi, par exemple, dans TypeScript, vous déclareriez une constante a, qui est hello, une chaîne. Et vous verrez
que cela ressemble beaucoup à l'apparence du code
JavaScript. Mais disons que vous essayez de
déclarer une autre constante, peut-être dans une autre partie
de la base de code nommée b. Et vous dites, d'accord, B est huit fois deux. Cela générera en
fait une erreur avant
même que vous n'exécutiez le code. Vous savez donc immédiatement que
cela ne fonctionnera pas et que vous devez corriger le bogue
détecté avant d'en
avoir besoin
pour publier quelque chose, disons à la production. Je pense que c'est la principale raison de
vouloir apprendre TypeScript avec JavaScript
et utiliser un TypeScript. La première approche est que la base de code
moderne utilise presque
exclusivement TypeScript. Si vous travaillez
dans la plupart des entreprises, leurs bases de code, nous serons
déjà passés à TypeScript. Javascript commence vraiment à devenir une relique du passé. Donc, bien sûr, des objectifs. Je veux que tu apprennes à coder, pas à mémoriser. Google existe pour une bonne raison. Et en tant que développeur, vous utiliserez Google à l'époque. Vous utiliserez
StackOverflow tout le temps. L'objectif de l'apprentissage de la
programmation n'est pas de mémoriser l'ensemble de la documentation pour un langage spécifique ou pour une API spécifique
que vous utilisez. Un bon développeur peut
décomposer un problème complexe en petits morceaux que
vous pouvez résoudre petit à petit. Ils peuvent ensuite résoudre ces problèmes en utilisant des connaissances de base. C'est donc ce que je vais
vous apprendre dans le cadre de ce cours. Et un bon développeur peut
également se référer à la documentation. Lorsque je consulte
constamment la documentation, j'utilise Google tout le temps. C'est ce que vous
devez vous attendre à faire. Je pense qu'en tant que développeur, vous devenez le plus précieux lorsque vous savez comment
résoudre les problèmes, non lorsque vous
apprenez à mémoriser. En conclusion, l'
objectif de ce cours est de
vous donner les bases et de vous apprendre à
penser comme un programmeur, à résoudre des problèmes et à
les résoudre en utilisant des connaissances très fondamentales que vous apprendrez tout au long de
ce cours. Pour simplifier les choses, pour la plupart des exercices, nous utiliserons un terrain de jeu TypeScript en ligne. À la fin du cours, nous expliquerons comment mettre en
place un véritable projet et comment intégrer des dépendances
externes. Donc du code que d'autres personnes ont
écrit pour vous aider à coder. Nous utiliserons TypeScript,
lang.org slash play. Il s'agit d'un terrain de jeu en ligne
pour le code TypeScript que vous pouvez utiliser directement
dans votre navigateur. Et vous pouvez exécuter
le code que vous écrivez directement dans le navigateur. Cela signifie donc que
vous n'avez
rien à configurer pour le moment. Vous pouvez écrire tous les exercices
dans ce terrain de jeu. Je vous recommande donc d'aller sur
ce lien, de le consulter
et de jouer avec. En fait, nous allons le faire
rapidement dès maintenant. En passant au lien, vous verrez que vous avez un éditeur de code
assez basique. C'est ici que vous pouvez
écrire tout votre code. Et il est
déjà pré-rempli avec un exemple de code. Vous verrez donc que
vous n'avez pas à vous soucier des détails. Mais essentiellement, ici, nous déclarons une chaîne
appelée exemple de variable. Nous lui attribuons la
chaîne Hello World. Et Console.log est un moyen
JavaScript ou TypeScript vous permet
d'imprimer quelque chose
sur la console ou dans les laboratoires. Vous verrez donc ce
petit bouton Exécuter ici. Si vous cliquez sur le bouton Exécuter, vous verrez que les
cornes afficheront Hello world. Alors jouez
avec ce site Web. Cela devrait être assez
simple et vous aurez un éditeur de
texte assez basique que nous utiliserons tout au long du cours. Alors,
les gars, dans le prochain.
2. Syntaxe de base: Bonjour à tous. Dans cette leçon, nous allons passer en
revue la syntaxe de base du code. Une instruction dans TypeScript est essentiellement une commande unique. C'est une chose que tu
veux exécuter en même temps. Et le moteur a essentiellement réduit toutes les instructions
et les a exécutées dans l'ordre. Ils se terminent généralement
par un point-virgule. n'est pas nécessaire, mais c'est une très bonne
pratique de le faire. Et généralement séparés
par de nouvelles lignes. Similaire à l'utilisation de points-virgules. Vous n'êtes pas
obligé de séparer les déclarations par une nouvelle ligne si elles se
terminent par un point-virgule. Mais c'est une très bonne pratique de toujours terminer
les déclarations par un point-virgule et de toujours séparer les déclarations
par de nouvelles lignes. Donc, dans cet exemple que nous avons, vous verrez que sur la première ligne,
il s'agit d'une déclaration assez basique que nous avons déjà vue dans console.log. Et cela se traduira
essentiellement par une impression
sur la console. Cette ligne est une déclaration. La deuxième ligne est très similaire. Mais si vous passez au numéro 4.5, vous verrez que si vous séparez les
déclarations par de nouvelles lignes, vous n'avez pas à les
terminer par un point-virgule. Vous verrez qu'il manque le
point-virgule dans les lignes 4.5, mais cela fonctionnera
parfaitement. Vous pouvez également
le retourner dans l'autre sens. Vous pouvez dire au numéro sept que vous pouvez terminer
les déclarations par un point-virgule, mais les placer sur la même ligne. La ligne numéro sept est donc très valide et ce
ne sera que console.log. Ou nous pouvons le faire au
coût de ce journal, qui fonctionne grâce
au point-virgule. Et ce code s'exécutera. Mais regardons la
ligne numéro huit. Nous n'utilisons pas de
point-virgule ni de nouvelle ligne. Donc, cette ligne, la ligne numéro huit, va
en fait générer une erreur. Vous ne pouvez pas exécuter ce
fichier car vous ne pouvez
pas associer deux instructions
à celles qui les séparent. Eh bien, vous pouvez réellement
utiliser de nouvelles lignes à votre avantage dans
une seule déclaration. Vous verrez que les lignes ont tendance à indiquer que nous ne terminons une instruction entre ces lignes. L'instruction se termine par point-virgule à la ligne numéro 12, mais vous pouvez insérer une nouvelle ligne
pour améliorer la lisibilité. C'est bien lorsque vous avez une déclaration très longue,
car vous pouvez la
diviser en gros morceaux
que vous pouvez lire très facilement sans que cela ne
déborde votre écran. Passons donc à l'éditeur et mettons
cela à l'épreuve. Entrez donc dans le
TypeScript Playground. Essayons-le. Je vais supprimer
ce qui est déjà là et utiliser console.log. Bonjour Nous verrons que cela fonctionnera
réellement si je cours. Mais vous verrez qu'
il n'y a pas de point-virgule. J'y insère un point-virgule. Il fonctionnera toujours. Si j'ajoute une autre instruction avec un point-virgule, elle fonctionnera toujours. Et bien sûr, je peux
choisir de les terminer par des points-virgules et c'est souvent
une bonne pratique de le faire. Je peux même placer ces
déclarations sur une nouvelle ligne. Pourquoi ? Parce qu'ils se terminent par
des points-virgules. Mais si vous voyez cela, si je supprime ce
premier point-virgule, vous mettez maintenant deux instructions
sur une seule ligne et vous
dites que les deux console.logs sont
techniquement une seule instruction. Donc, avec cela, le matin se lèvera
car vous devez terminer cette
première déclaration par un point-virgule
ou une nouvelle ligne. Vous verrez donc que
si vous passez la souris dessus, vous verrez que
le point-virgule est attendu. Et cela
vous aide réellement à résoudre le problème. En insérant un point-virgule. Vous avez maintenant résolu
ce problème. Et vous pouvez maintenant exécuter ce fichier. Très bien,
revenons aux diapositives, la syntaxe de
code de base suivante ou aux commentaires. Cela contribue, bien entendu,
à une meilleure lisibilité. Lorsque vous avez des
morceaux de code complexes, saisissez
généralement des commentaires
pour expliquer aux autres développeurs et à votre futur
ce que vous faites. Il existe deux manières
d'écrire un commun. Un. Si votre commentaire se trouve
sur une seule ligne, vous pouvez utiliser deux barres obliques. Et cela indique un commentaire
sur une seule ligne. Ou si vous souhaitez commenter
sur plusieurs lignes, vous pouvez commencer le commentaire
en utilisant une barre oblique et un astérisque et terminer par
un astérisque et une barre oblique. Essayons ça
très rapidement. Alors, en passant à l'éditeur,
essayez d'écrire un commentaire. Voyons voir si l'éditeur le
surlignera en vert, en
disant qu'il s'agit d'un commentaire indiquant
essentiellement à vous, le développeur, que cela
ne fera rien. Lorsque vous l'exécutez, vous
verrez que rien n'
est réellement imprimé sur la console. Rien de nouveau
n'est imprimé sur
la console car ce script ne fait rien. Essayons de bloquer les commentaires maintenant. Je commence donc par une
barre oblique et l'astérix. Je peux écrire ce que
je veux ici. Et chaque fois que je
veux y mettre fin, je fais l'astérix et la barre oblique. C'est donc essentiellement tout en
termes de syntaxe de code de base, les deux éléments les plus fondamentaux
sont en fait les déclarations
et les commentaires. Les exercices pour cela
seront donc assez brefs. Essayez d'abord d'utiliser le journal de la console. Donc, dans le terrain de jeu, essayez de connecter HelloWorld et
essayez d'enregistrer le numéro 42. L'avantage de
Console Log, c'est qu'ils peuvent
enregistrer la plupart des choses. Vous n'avez donc pas à jouer avec
les cordes comme vous le feriez
avec une autre langue. Vous pouvez mettre 42 directement dans les journaux de la console.
Alors essaie ça. Ensuite, essayez d'écrire un commentaire d'une
seule ligne et un commentaire de bloc. Ainsi, un commentaire en bloc signifie
un commentaire sur plusieurs lignes. Essayez-le. Faites-moi savoir si vous
avez des questions et je vous verrai
lors de la prochaine.
3. Introduction aux primitifs: Salut les gars, bon retour. Dans cette leçon, nous
allons passer en revue les primitives. Les primitives sont des types de base
intégrés au langage. Ainsi, un exemple de primitive
est le type numérique, qui représente un nombre, par exemple deux ou 3,5. Et en
composant des primitives, vous pouvez créer des structures
plus complexes à
intégrer à votre programme. Les variables et les
constantes contiennent des valeurs, et ces valeurs
sont souvent des primitives. Une vallée peut être presque n'importe quoi. Encore une fois, cela peut inclure
des primitives telles qu'un nombre, objet ou un tableau, et celles-ci peuvent également
contenir des fonctions. Nous allons donc
approfondir toutes ces primitives ainsi que fonctions plus tard dans
le cours. Mais pour l'instant, considérez
simplement une variable et une constante comme le nom de
quelque chose qui regroupe des valeurs. Vous pouvez déclarer des variables et des constantes à l'aide de var,
let ou comments. Encore une fois, nous y
reviendrons plus tard. Chaque constante de barre oblique variable
possède un nom qui vous permet y
référer ultérieurement dans votre programme ou
ailleurs dans votre programme. La principale différence entre les
variables et les constantes, comme leur nom l'indique, est que les variables peuvent changer,
alors que les constantes ne le peuvent pas. Vous déclarez les variables
avec une barre ou un plomb. Mais en réalité, vous
n'utiliseriez jamais vraiment var. Utilisez toujours du lead et
vous serez libre de rechercher sur Google toutes les différences entre une
déclaration avec var ou let. Mais de façon réaliste, il suffit de rester sur
Let et nous sommes prêts à partir. Les variables peuvent être réaffectées à différentes valeurs
du même type. Cela n'est vrai qu'en JavaScript, mais c'est vrai en TypeScript, c'est ce à quoi nous nous
en tenons pour le moment. Disons que vous avez une variable
qui contient le nombre. Appelons cette variable a. Vous pouvez d'abord
lui attribuer une valeur de cinq. Et plus tard
dans le programme, vous pouvez le réattribuer
à une valeur de dix. Les constantes, en revanche, sont définies avec const
et ne peuvent pas être réattribuées. La règle générale est
que vous devez utiliser des constantes sauf en cas de nécessité
absolue. Il est beaucoup plus facile de déboguer
votre programme et de raisonner votre programme si vous avez
des constantes plutôt que des variables. D'accord ? Donc, quelques conventions de dénomination. Les variables et les constantes sont
généralement nommées dans CamelCase. Donc, quelque chose comme
le prix est égal à dix, ou le prénom est Frank
avec le nom en majuscule. Les constantes, en revanche, peuvent parfois être utilisées dans le cas d'un serpent
majuscule. C'est très rare et je ne
le vois pas très souvent. Donc, si vous vous en tenez à CamelCase, généralement prêt à partir. Examinons donc rapidement quelques
exemples de déclaration de variables
et de leur utilisation. Très bien, donc dans le terrain de jeu
que nous avons ici, déclarons d'abord une variable. Comme vous vous en souvenez
peut-être, une variable déclarée avec le mot clé left. Alors donnons-lui un nom. Alors appelons-la
simplement ma variable et attribuons-lui une valeur de dix. Essayons maintenant d'
enregistrer myvariable. Et si je cours, vous verrez qu'il
est dixième. La valeur de ma variable
est donc le nombre dix. Maintenant, les variables peuvent être
réattribuées, alors essayons. Attribuons-la à 20, puis
reconnectons-la à la console. obtenant le code,
vous verrez que dix puis 20 sont
imprimés sur la console car la valeur de
ma variable commence à dix, puis elle est
réaffectée à 20. Essayons maintenant de
déclarer des constantes. J'utilise donc le mot clé const, je vais le nommer ma constante et lui donner
une valeur de chaîne. Donc un SDF. Essayez de l'enregistrer. Et vous verrez qu'un FCF
est imprimé sur la console. Mais essayons de changer.
Donc techniquement, si ma constante est une constante, vous ne devriez pas
pouvoir la modifier. Mettons cela à l'épreuve. Vous verrez qu'
une erreur s'affiche. Et si vous le
survolez, il indique que ne pouvez pas attribuer à ma constante
parce que c'est une constante. Et vous pouvez réellement l'exécuter. Une démonstration rapide de la dénomination des variables, ainsi que de la déclaration de
variables et constantes avec let et const. Très bien, revenons aux
diapositives qui concluent notre introduction
aux primitives
ainsi qu' aux variables et aux constantes. Donc, certains exercices que
j'ai indiqués ici devraient être assez
simples. Essayez-les et n'
hésitez pas à me contacter si
vous avez des questions, je vous verrai
dans la prochaine.
4. Primitives - chaîne: Salut les gars, dans cette leçon, nous allons passer en revue notre première primitive et
il y aura des cordes. Toutes les chaînes sont, sont
un morceau de texte. Vous pouvez déclarer trois manières. Ils sont
entourés de guillemets simples, guillemets
doubles ou de guillemets. guillemets simples et les guillemets
doubles sont donc utilisés de manière interchangeable. Mais les ticks arrières sont utilisés
pour l'interpolation des chaînes. Cela signifie donc placer
la valeur d'une autre variable ou constante
dans la chaîne elle-même. Dans TypeScript, string est
un nom de type TypeScript. Passons en revue l'exemple. Donc, d'abord, nous déclarons une variable avec le mot clé let, nous l'appelons des textes et nous disons que les deux-points et chaîne indiquent à
TypeScript que nous
déclarons une variable de chaîne. Nous l'attribuons à Hello. Et nous déclarons une constante, nombre de 42, que
nous utiliserons plus tard. La chaîne deux-points indique donc type script que certains
textes sont de type chaîne. Mais en fait, si vous
attribuez un bonjour tout de suite, vous n'avez pas besoin de la chaîne deux-points car TypeScript peut
déduire que le type de certains textes est déjà
une chaîne parce que vous
le remplissez déjà avec un chaîne. Parce que certains textes
sont variables. Vous pouvez le réattribuer. Vous pouvez le réaffecter au monde. La valeur de certains textes
sera donc mondiale par la suite. Vous pouvez le réattribuer à nouveau. Vous verrez donc que nous
déclarons certains textes
entre guillemets simples. Nous le réattribuons
avec des guillemets doubles. Et il n'y a pas
vraiment de différence entre les deux modes de déclaration. Mais pour l'interpolation de chaînes
, c'est ce que nous faisons
sur la dernière ligne. Nous utilisons des backticks. Pour utiliser l'interpolation de chaînes. Ce que vous faites, c'est enrouler
la valeur d'une autre variable ou constante à l'endroit où vous voulez qu'elle remplisse la valeur d'une autre
variable ou constante. Vous commencez par le
signe du dollar et les deux crochets. Vous verrez que nous insérons
la valeur du nombre total
dans cette chaîne. Et si vous deviez
console.log quelques textes, on dirait qu'
un nombre est 42 parce
que vous remplacez le signe dollar et le crochet par la
somme intermédiaire par la valeur réelle d'
un nombre, soit 42. Passons maintenant à quelques
exemples concernant le terrain de jeu. Très bien, alors maintenant
essayons de déclarer une constante de type string
et écrivons mon écran. Et nous donnons une chaîne de type
ts. Nous cédons entre une
variable et une chaîne. Nous disons donc explicitement que le type de microphone
ici est une chaîne. Donc, si je devais le remplacer par
un nombre, vous verrez
que cette erreur indique que le numéro n'est pas
assignable au type string. Mais disons que vous le
déclarez tout de suite. En fait, vous n'avez pas besoin la déclaration de type TypeScript
car TypeScript
commence simplement à déduire que le type de MyString est déjà une chaîne parce que vous le
renseignez déjà. Déclarez maintenant
une autre chaîne. Nous créons simplement une constante, mon autre chaîne avec la valeur
de celle-ci comme une autre chaîne. Essayons le printemps
et la fibrillation. Je vais donc tout de suite
accéder à console.log. Encore une fois, pour l'interpolation de chaînes, vous devez utiliser des backticks. C'est donc ce que je fais ici. Je dis que la première
est que nous commençons par le signe du dollar et que les deux
crochets sont ma chaîne. Et puis la deuxième est l'autre chaîne. Parce que je le peux, je pense à
ce qui sera imprimé ici. Comment fonctionne
l'interpolation de chaînes, est-ce
que c'est la déclaration de l'
endroit où interpoler ? Ainsi, par exemple, le signe
dollar entre crochets et ma chaîne sera remplacée lors de l'exécution par
la valeur réelle. Donc, au fur et à mesure que nous parcourons cette chaîne, commencez par deux points, puis vous allez
remplacer la valeur de mon écran. Il va lire le premier deux-points. Il s'agit d'une chaîne et il en va
de même pour la seconde.
Essayons de l'exécuter. Et vous verrez que c'
est ce à quoi nous nous attendions. Revenons maintenant aux diapositives. Très bien, ainsi s'achève
la section sur les cordes. Nous avons ici un exercice lié à l'interpolation de chaînes. Cela
nécessitera en fait une recherche sur Google. Je veux que vous trouviez deux manières
différentes de créer le script de type chaîne JavaScript avec deux constantes
distinctes. Essayez donc de le faire et contactez-nous si vous
avez des questions. Je vous verrai
au prochain.
5. Primitives - Booléen: Salut les gars. Dans cette section, nous allons passer en
revue la primitive booléenne, booléenne ou simplement
vraie ou fausse. booléen avec le b minuscule est le nom du type de script de type. Vous pouvez créer un booléen et le convertir
à partir d'un autre type. Ainsi, par exemple, vous pouvez convertir
un nombre en vrai
ou faux en utilisant le constructeur booléen B
majuscule ou utilisant deux points d'exclamation en
utilisant deux points d'exclamation devant la variable elle-même. Malheureusement, les booléens
peuvent en fait devenir assez compliqués en
JavaScript et TypeScript. Et nous y reviendrons un peu plus tard dans les diapositives. Passons en revue l'exemple. Vous pouvez déclarer un booléen comme vous feriez pour n'importe quelle variable
en lui donnant simplement le nom du type ou même
en omettant le nom du type si vous lui attribuez immédiatement un
vrai ou un faux. Ainsi, aux lignes 2.3, vous
verrez que nous
déclarons un booléen comme vous le
feriez pour n'importe quelle autre variable. Bien entendu, le nom du type
est facultatif si vous
attribuez immédiatement un vrai, un vrai
ou un faux. Dans les lignes 6.7, cependant, les choses deviennent
assez intéressantes. Vous verrez que nous pouvons réellement lancer un booléen
à partir d'un autre type. Cela signifie que
vous convertissez un type en type booléen. Vous verrez donc que si vous utilisez un booléen
console.log égal à deux, c'est vrai, mais un booléen
égal à zéro est faux. C'est donc
très étrange et ce
n'est pas similaire aux autres langages où un booléen est
simplement vrai ou faux dans TypeScript en JavaScript,
vous pouvez
en fait convertir un
booléen à partir d'un autre type. Et il y a des cas
très étranges que vous trouverez en ligne et nous en reparlerons également plus tard dans
les diapositives. Par souci de chiffres,
vous devez savoir que tout
autre nombre que zéro sera converti en vrai et que seul
zéro sera converti en faux. Comme dans d'autres langues, vous pouvez créer un booléen à
l'aide d'une comparaison. Donc, par exemple, les lignes 1.2 sont
assez simples, non ? Vous dites que c'est pour
plus de deux et
bien sûr c'est vrai. Est-ce que quatre est inférieur ou égal
à deux, et c'est faux. Mais si votre fichier console.log vaut quatre
égal à la chaîne quatre, vous verrez qu'il affiche
en fait vrai. Ce qui peut être un peu
contre-intuitif car vous
ne penseriez pas qu'un chiffre quatre est égal à la chaîne pour. Mais d'une manière ou d'une autre, cela est
vrai dans TypeScript. Cela nous amène donc à la
question de l'égalité stricte. Contrairement à d'autres langages, vous devez utiliser des
opérateurs d'égalité dans TypeScript. L'une est l'égalité fondamentale, qui correspond à deux signes égaux. Lorsque vous l'utilisez, si les types sont différents. Ainsi, par exemple, si vous comparez
un nombre et une chaîne, script de
type sera converti dans le même type, puis
comparera les valeurs. En revanche,
l'égalité stricte avec le signe triple égal
signifie que les types doivent être identiques pour qu'une
comparaison vous donne la vérité. Et une règle de base
est toujours, toujours,
toujours d'utiliser une stricte
égalité dans TypeScript. Où d'autre vous pourriez
rencontrer beaucoup de bugs. Donc,
pour reprendre l'
exemple, la première instruction, donc la ligne numéro trois est essentiellement égale à la chaîne,
est en fait vraie car TypeScript
convertira la chaîne pour deux, le nombre quatre, et
il le fait via le constructeur numérique, comme nous l'avons vu plus haut dans les diapositives. Et bien sûr, lorsqu'il est
converti, le nombre 44 est égal à quatre et
cela vous donnera la vérité. Cependant, si vous utilisez une égalité
stricte, car le chiffre quatre n'
est pas du même type que la chaîne correspondante, vous
obtiendrez faux, quoi vous vous
attendriez normalement. Maintenant, cela nous
amène également au sujet suivant, qui est de savoir si quelque chose
est vrai ou faux. Parce que vous pouvez
convertir n'importe quoi en JavaScript et
TypeScript en booléen. Les choses sont dites vraies si
elles peuvent être converties en Vrai et elles sont
dites fausses si elles peuvent être
converties en fausses. Et encore une fois, cela devient
très, très compliqué,
ce qui est à l'origine de nombreux bugs que
nous constatons en production. Dans les exemples, nous utilisons donc la syntaxe alternative
pour convertir un booléen. Donc, en utilisant le double point d'
exclamation, vous verrez que puisque
zéro est converti en faux, nous l'appelons faux, et parce que deux est
converti en vrai, nous l'appelons vrai. Donc, en général, les booléens
sont assez simples, mais vous devez faire attention
à la véracité et à la fantaisie. Voici quelques exercices. Pour le premier, assignez une
variable, nommez-la Ae, à la vallée indiquant
si moins deux est inférieur ou égal à zéro. Vous devez donc utiliser
une comparaison ici. Essayez d'enregistrer une chaîne sur la console
et ce n'est pas ce à quoi vous vous
attendriez pour essayer de
déterminer s'il s'agit d'une chaîne vide, donc rien dans la chaîne n'
est vrai ou faux. Et essayez de comparer la
différence entre l'utilisation de
l'opérateur d'égalité de base et l'opérateur d'égalité stricte. Et comparez la
chaîne vide au chiffre zéro. Je vous verrai
dans la prochaine.
6. Primitives - Null et indéfini: Salut les gars. Dans cette
leçon, nous allons passer aux primitives nulles
et non définies. Au niveau de base, les valeurs nulles et non définies vous donnent une
valeur nulle, ce
qui est
assez étrange. Ils sont souvent utilisés dans un type d'union
TypeScript, que nous aborderons en
détail un peu plus tard. La différence entre l'utilisation de
null et undefined est que vous utilisez
généralement null pour indiquer qu'il n'y a pas de valeur. Alors que non défini signifie que la valeur n'est pas assignée. Il y a une différence subtile
entre les deux. Mais pour l'instant,
considérez à la fois null et undefined comme une valeur
qui ne représente rien. Passons maintenant à l'exemple. Vous verrez qu'à la troisième
ligne, nous déclarons une variable a avec le type nombre ou nul. Et cet opérateur OR, qui est une ligne
verticale droite, est appelé création d'un type d'union. Vous le verrez dans
l'exemple ici. Nous pouvons initialement lui attribuer une valeur nulle, mais nous pouvons également l'attribuer à, et nous pouvons l'attribuer à nouveau
à un bloc nul. Cela indique donc essentiellement script de
type que
les nombres et le type nul sont absolument
valides pour la variable a. Passons aux
types d'union un peu plus loin. Ainsi, comme je l'ai mentionné, un type d'union vous donne
une condition de commande pour plusieurs types de base et il
n'y a aucune limite à ce
nombre de types de base. Donc, dans l'exemple ici, encore une fois, la variable a, ou maintenant, le fait de dire qu'elle peut être un nombre,
une chaîne ou une valeur nulle. Nous lui attribuons initialement
la valeur de chaîne, mais vous verrez
qu'aux lignes 3.4, nous pouvons également
l'attribuer à un nombre ou à une valeur nulle. Maintenant, dans ce cas précis, vous avez réellement besoin de
la déclaration de type. Vous avez donc besoin du deux-points
pour un nombre
ou une chaîne, ou nul, sinon si vous l'
affectez immédiatement à une chaîne, TypeScript pensera
que a ne peut être de type chaîne qu'en donnant la définition de type explicite
pour le type d'union. Vous dites à TypeScript que, accord, il s'agit d'une chaîne au début, mais vous autorisez également l'attribution de
deux chiffres à a et vous autorisez l'affectation de a
à une valeur nulle. Passer en revue un peu de
véracité et d'agitation, à la fois nulle et indéfinie
sur votre faux. Cela signifie
que lorsque vous convertissez undefined et
null en boolean, ils seront automatiquement convertis en faux. Maintenant, il est intéressant de noter que
si vous essayez comparer nul et
indéfini l'un à l'autre avec l'égalité de base telle
que nous
joignons la ligne, la troisième est
indéfinie, égale à zéro. C'est vrai en fait. Alors que si vous avez une égalité
stricte, undefined n'est pas égal à null car ils sont
de types différents. Encore une fois, je sais que cela
peut être un peu confus, mais il
suffit de connaître certaines
choses à la
main car sont
des particularités de la langue elle-même. Maintenant, en passant à quelques exercices, j'ai essayé de trouver un
type qui peut être un nombre ou non défini. Par exemple, définissez une
constante a et
faites-lui prendre des valeurs à la fois
numériques ou non définies. Deuxièmement, j'ai essayé de trouver un type qui puisse être
l'un des suivants. Donc chaîne, nulle et indéfinie. Vous pouvez essayer de l'attribuer à
une variable et de vous assurer que ce que vous faites est
correct en attribuant une chaîne, en signant à null et en l'
attribuant à une valeur non définie. Dans les trois cas, le code
doit être valide et TypeScript ne doit contenir aucune
erreur. Très bien, les gars,
faites-moi savoir si vous
avez des questions et je
vous verrai au prochain.
7. Primitives - tableaux: Salut les gars, Dans cette leçon,
nous allons passer en revue les tableaux. Les tableaux sont simplement
des listes de choses. Passons
directement à un exemple, car il est
préférable de
démontrer une augmentation en
regardant du code. La
syntaxe du script de type pour déclarer
un tableau est donc d'avoir le type de base
suivi des deux crochets. Ou bien, vous pouvez
également utiliser le tableau avec un a majuscule avec le type
de base entre crochets, comme vous le verrez dans le commentaire sur la première ligne et la ligne numéro deux, nous déclarons d'abord R, qui est un tableau de nombres. Vous verrez que nous
utilisons le premier type de TypeScript, la déclaration de type. Donc, en utilisant
le nombre entre crochets, nous créons
un tableau vide. Cela signifie que tout d'abord, R sera simplement une
liste de nombres et qu'il
ne contiendra aucun élément dans cette liste au début lorsqu'
elle sera initialisée. À la troisième ligne, nous
déclarons le deuxième art. Nous utilisons la
syntaxe alternative avec un rayon. Nous faisons
exactement la même chose, créant un tableau vide de
chiffres pour le deuxième bras. Vous vous souviendrez qu'
auparavant, lorsque nous
utilisions d'autres types de primitives, vous n'avez pas besoin d'utiliser la
déclaration de type TypeScript avec deux points et le type si vous initialisez
constant tout de suite. Mais ce n'est pas le cas un tableau vide car si
vous lui donnez un tableau vide, TypeScript ne
sait pas quel type d' éléments vous souhaitez
mettre dans ce tableau. Donc, si vous voulez que votre
tableau soit typé, vous devez déclarer le type
explicitement pour les tableaux. Toutefois, si vous n'
initialisez pas avec un tableau vide, TypeScript peut en déduire le type. Donc, à la ligne numéro huit, si vous avez la chaîne r et que vous remplissez avec
hello and world, TypeScript peut
en fait déduire que chaîne r est de
type string array. Les tableaux peuvent également être imbriqués. Jetons donc un coup d'œil
à la ligne numéro 14. Le type se lit de gauche à droite. Nous avons donc d'abord un tableau de nombres. Ainsi, chaque élément de base
ici est un tableau de nombres, et nous avons un tableau
de tableaux de nombres, ce qui signifie que nous avons un tableau
imbriqué de tableaux. Cela devient un peu confus, mais vous verrez ce que je veux dire
avec l'exemple ici. Vous verrez que nous avons une liste, mais chaque élément de cette
liste est une liste en soi. Le premier élément
est donc la liste avec 1.2 et le deuxième
élément de la liste est une autre liste avec 3.4. Donc, quelques opérations de base sur un tableau. Ainsi, pour accéder à un membre
du tableau par sa position, il
vous suffit d'utiliser le nom de la
variable du tableau, puis d'
utiliser les crochets avec l'index auquel vous
souhaitez accéder. Désormais, comme dans d'autres langues, les indices commencent à zéro. Vous verrez donc
sur l'image ici que le premier élément du
tableau a un indice de zéro, le second un, et ainsi de suite. Supposons donc que vous ayez
un rayon avec 12345, vous avez accès
au troisième membre
du tableau qui a
la valeur trois, en utilisant nos crochets. Et pour la suite, vous pouvez
obtenir la longueur d' un certain tableau en utilisant la longueur du point
r. Donc, par exemple ,
à partir de l'image, si vous deviez appeler r point length, vous en auriez cinq renvoyés. Vous pouvez ajouter à la fin
du tableau en utilisant r point push. Et entre ces crochets, vous pouvez placer ce que vous voulez
placer à l'extrémité du tableau. Vous pouvez également supprimer
un élément de la fin du tableau
en utilisant r point pop. Cette méthode
renverra en fait l'élément
qui a été affiché. Donc, si vous deviez appeler r point pop sur le rayon
de l'image, le résultat serait cinq car
c'est le dernier élément. Et après cette date, nous
n'en aurons plus que 1234. Et supposons que vous
appeliez r point length par la suite et que vous renverriez
quatre, car la longueur du tableau correspond maintenant à
quelques exemples supplémentaires pour
passer en revue les informations
précédemment contenues dans les diapositives. À la ligne numéro deux, nous créons un tableau de nombres. Donc, comme je l'ai mentionné, pour déclarer un
tableau vide et pour que TypeScript indique que le
nombre est un type, vous devez dire
explicitement que nombre r est de
type tableau de nombres. Et le numéro quatre en ligne, car nous donnons initialement
quelques éléments dans
le tableau de type chaîne. Typescript sait que string
args est une liste de chaînes. La ligne numéro six entre
dans l'index pour y accéder. Supposons donc que vous souhaitiez accéder
au premier élément de la chaîne. Utilisez-vous les crochets avec zéro parce que
les indices commencent à zéro ? Et cela renverra
le premier élément du
tableau, qui est bonjour. Ensuite, en entrant dans la propriété
length, vous verrez que si nous
appelons la longueur du point r, elle vaut zéro car il s'
agit d'un tableau vide. Et puis disons, d'accord, que nous voulons placer un élément un sur
un tableau de nombres. Vous vous souviendrez que push
placera un élément à la fin du tableau et renverra en fait la nouvelle
longueur du tableau. La nouvelle longueur en est donc une. Et après avoir poussé, vous
verrez que le nombre r est désormais une liste d'éléments avec un seul élément. À l'intérieur. Et si vous utilisez l'
opérateur de longueur en veut plus, vous verrez que la
longueur est désormais égale à un car vous avez ajouté un
membre au tableau. Donc, pour en revenir à la chaîne si vous deviez
appeler pop et vous vous
souviendrez que pop supprime le dernier élément du
tableau et le renvoie. Vous verrez que le dernier
élément de chaîne ici est world, car c'est
l'élément qui a été supprimé de la
fin du tableau. Et si vous redeviez enregistrer
la chaîne, vous verrez que le monde
a été supprimé. Il s'agit donc d'une
liste à élément unique avec hello à l'intérieur. Passons donc en revue
tout ce qui se trouve sur le terrain de jeu. Essayons de déclarer
un tableau booléen. Donc, une gamme complète. Maintenant, si je ne le donne pas à taper, vous verrez que si vous passez la
souris sur Bull Array, cela revient à taper n'importe lequel
ou une liste d'entre eux. Il s'agit d'une liste de n'importe laquelle. Et nous passerons en revue
tous les types plus tard. Mais ce n'est pas une bonne pratique si vous avez un tableau vide. Donc, comme nous savons que ce
sera une liste de booléens, définissons-la dès maintenant. Nous utilisons donc le premier
type de syntaxe. Vous verrez donc que nous pouvons
également utiliser les
impacts alternatifs de l'utilisation d'un tableau
avec les crochets angulaires. Maintenant, si je déclarais que les bools sont et que je
mettais des valeurs dedans. Vous verrez que le fait de
survoler TypeScript en
déduira que Bulara est
de type tableau booléen. Essayons maintenant de placer quelque
chose sur cette matrice. Donc en ajoutant un élément à la fin. Augmentons la valeur de false. Alors maintenant, si nous console.log, r
devrait être ce à quoi nous nous attendons. C'est tellement vrai, faux et faux. Et si nous enregistrons sa nouvelle longueur, quoi nous attendons-nous ? Nous avions donc deux membres
, puis nous en avons créé un autre. Donc, la longueur devrait être de
trois. Et c'est encore une fois
ce à quoi nous nous attendions. Essayons maintenant de trouver
le dernier membre. J'appelle donc pop, qui supprimera le
dernier membre du tableau. Allons-y et console.log
en est le résultat. Alors, que se passe-t-il lorsque
vous sortez du tableau ? Que revient la pop ? Et il renverra en fait le dernier élément qui a été
supprimé du tableau. Et enregistrons également le
tableau lui-même après pop, l'opération est terminée. Essayons donc ça. Regardons donc
les deux dernières lignes. Vous verrez que la
valeur de r point pop, qui supprime le dernier élément, sera fausse car c'
était le dernier élément ici. Il supprime donc la valeur False
, le renvoie et le déconnecte. Ensuite, si nous déconnectons le pool se trouve
à
la toute fin après l'opération pop, vous verrez qu'il
ne contient que du vrai et faux, car grâce à
l'appel de pop, nous avons supprimé la dernière
fausse valeur du matrice. Très bien, c'
était donc une démonstration rapide. Revenons aux diapositives, passons à quelques exercices. Définissez donc d'abord un tableau
vide
contenant à la fois des éléments de chaîne
et des éléments numériques. Un petit
indice ici, vous pouvez utiliser un type d'union pour définir une zone. Maintenant, essaie d'appuyer sur bonjour
et essaie de pousser aussi. Étant donné que r peut contenir à la fois des types de
chaîne et de nombre, cela devrait fonctionner
sans erreur. Et maintenant, essayez d'attribuer
la valeur d' une nouvelle constante Ae au
résultat de r point pop. Est-ce ce à quoi tu t'attends ? Et essayez de
survoler a pour voir ce que TypeScript déduit de a à
B en termes de saisie. Enfin, attribuez la
valeur d'une constante, notre longueur, aux résultats
de la longueur de notre point. C'est ce à quoi tu t'attends ? Ensuite, définissez un tableau booléen contenant les membres
suivants. Vrai, vrai, faux, faux. Troisièmement, que se passe-t-il
si vous essayez d'
accéder à un index de tableau
qui n'existe pas ? Donc, à partir de l'exemple donné ici, disons que vous avez
déclaré un tableau de r égal à un dans un tableau de nombres. Que se passe-t-il si
vous essayez d'accéder au troisième indice des deux éléments ? Essayez de le déconnecter et
voyez ce qu'il renvoie. Enfin, essayez de définir un
tableau de nombres de 123,4. Maintenant, cet exercice vous
demandera de
faire quelques recherches sur Google. Essayez donc de trouver de la documentation pour le type de
tableau JavaScript ou TypeScript parmi ces chiens trouvez un moyen de supprimer
l'élément 1. Il s'agit donc du premier
élément du tableau. Au lieu de cela, ça va durer. Vous ne pouvez pas utiliser pop ici. Maintenant, toujours
dans la documentation, trouvez un moyen de rajouter l'élément
un au début. Vous ne pouvez donc pas utiliser le push car le push va jusqu'à
la fin du tableau. Peux-tu essayer d'en mettre
un au début ? Faites-moi savoir si vous
avez des questions et je vous verrai
dans la prochaine.
8. Primitives - objets: Salut les gars, Dans cette leçon,
nous allons passer en revue des objets. Nous allons apprendre les
objets à travers un exemple. Et cet exemple consiste
à définir une voiture. Dans un premier temps,
utilisons ce que nous savons. Définissons la
propriété séparément. Nous pouvons donc définir la marque, modèle et l'année en les
préfixant par voiture. Et bien sûr, ce
sont des types que nous avons déjà vus. Karmic est donc de type chaîne comme son modèle de voiture et son
année de voiture sont de type numéro. Mais comme vous pouvez l'imaginer, si vous deviez transmettre cette
voiture dans votre code, cela pourrait devenir incontrôlable
assez rapidement car vous
devez remplir tous ces
champs individuellement. Voici donc l'objet. Chaque objet est un
groupe logique d'informations. Et un objet est simplement un
mappage entre une clé et une valeur. Et chaque correspondance entre
une clé et une valeur est appelée
propriété de l'objet. Redéfinissons donc la voiture. Chacune des lignes
ci-dessous définit donc une propriété. Nous aurions une clé de marque
avec la valeur de Honda, une clé de modèle avec
la valeur de la Civic et une clé d'année avec
la valeur de 2022. Alors, comment faisons-nous
cela dans TypeScript ? Les interfaces et les types définissent la forme d'un objet
dans TypeScript. La convention habituelle
est de mettre en majuscule les noms des propriétés,
autrement appelés clés. Nous avons donc deux
manières différentes de définir la voiture, et ces deux sont généralement
utilisées de manière interchangeable. La première consiste à utiliser l'interface de
mots-clés. Nous disons que l'interface
s'appelle voiture. Et nous disons, d'accord, make est une propriété de la
voiture avec une chaîne de caractères. Identique au modèle. Le modèle possède un type de chaîne. Et pour l'année, l'année
a un type de chiffre. Nous pouvons également
utiliser le type de mot clé. Mais notez que nous avons besoin d'un signe
égal après voiture pour définir un type, alors que vous n'
avez pas besoin du signe égal
pour une interface. Nous faisons exactement la même chose lorsque utilisons un type au lieu
d'une interface. Et dans ce contexte, ils veulent dire la même chose. Désormais, un type TypeScript définit
simplement la
forme d'un objet. Il ne crée pas d'objet. Essayons maintenant de créer
l'objet. Encore une fois. Vous verrez que nous
utilisons le mot clé const. Nous disons réutiliser ma voiture. Et cette fois, au lieu
que ma voiture soit un type de chaîne
booléenne ou numérique, nous disons qu'il s'agit d'un type de voiture, qui est une interface personnalisée ou un type que nous avons
défini précédemment. Maintenant, nous pouvons dire, d'accord,
pour cette voiture en particulier, mes constructeurs automobiles, les modèles Honda, Civic, et l'année est 2022. Vous verrez donc que nous
définissons par
const et non par élection, ce qui signifie que nous ne pouvons pas redéfinir
ma voiture en une autre. Cependant, nous pouvons modifier les
propriétés de mes cartes, afin de changer
la marque de ma voiture en Ford, disons. Et c'est totalement autorisé
s'il s'agit d'une constante. C'est donc une chose
à surveiller. Maintenant. Examinons les
objets en profondeur à l'aide d'exemples. La première est de savoir comment modifier une propriété et comment pouvons-nous
même accéder à une propriété ? Cela revient donc
à l'avertissement que nous avions reçu dans la diapositive précédente. Nous définissons à nouveau ma voiture. Mais vous ne pouvez pas la redéfinir car
c'est une constante si elle est
définie comme une variable. Donc, en utilisant la gauche, tu peux redéfinir ma voiture sur la ligne numéro
huit en autre chose. Cependant, il existe deux manières d' accéder
à une propriété
de l'objet. La première, la syntaxe des points
, c'est ce que vous
faites à la ligne 13. Nous disons donc la marque de ma voiture
et dans ce cas, nous
réattribuons la marque de ma
voiture à Conda pour nous permettre de payer. C'est ce que l'on appelle l'accès par points. La prochaine façon d'accéder à une propriété consiste à utiliser un accès de type
index. Cela revient donc à
accéder à quelque chose dans un tableau avec l'
index, d'où le nom. Mais au lieu d'un index numérique, nous lui donnons le
nom de la propriété ou la clé. Donc, sur la ligne numéro 14, vous verrez ma voiture, modèle entre
crochets, ce qui signifie que nous accédons à la propriété modèle de ma voiture et que nous la
changeons en Ranger. Donc, après la ligne 13.14, ma voiture sera de marque avant
et le modèle sera Ranger. Examinons maintenant un peu les
interfaces et les types. Vous pouvez réellement
imbriquer des interfaces et des types
pour définir les formes des objets imbriqués. Les propriétés peuvent également être
ce que l'on appelle nullables, c'
est-à-dire qu'elles peuvent être
nulles ou non définies. Alors
allons-y un peu. Sur la première ligne, vous
verrez que nous utilisons le mot clé interface pour
définir un type d'objet. La première propriété
est facultative en raison de ce point d'interrogation
devant les deux points. Cela signifie que la première propriété
peut être booléenne, donc vraie ou fausse, ou indéfinie. Deuxième propriété, la façon dont elle est définie est exactement la même chose. C'est juste une syntaxe alternative. Le point d'interrogation est essentiellement un raccourci pour dire que cela peut être booléen
ou non défini. Vous pouvez également l'indiquer
explicitement avec un type d'union, comme vous le voyez pour la deuxième propriété. À la ligne numéro six, nous avons défini un
autre type d'objet, et c'est là que nous
abordons les objets imbriqués. Nous disons donc qu'un objet
imbriqué est une clé sur autre type d'objet avec
le type d'un certain type d'objet. Cela signifie donc que si vous avez un objet d'un
autre type d'objet, il aura une propriété
nommée objet imbriqué. Et cette propriété
aura un objet avec une
propriété de première propriété. Nous y reviendrons un
peu plus avec des exemples. Mais c'est ainsi
que vous imbriquez des objets. Vous pouvez également le définir en ligne. Le deuxième objet imbriqué
est donc une autre façon de
définir un objet imbriqué. Dans ce cas, un autre type d'
objet possède un nom de champ : deuxième objet imbriqué avec
un nom de champ imbriqué, premier imbriqué, qui
est de type chaîne, ou le second imbriqué, qui est de
type numéro ou non. Essayons maintenant d'
utiliser ces types. Examinons d'abord les propriétés
nullables. Donc, pour en
revenir à un type d'objet, vous verrez que
la première propriété et la deuxième propriété
sont inconnues. Cela signifie que si nous ne
définissons pas une propriété
nulle, elle sera définie par défaut. Donc, en ligne numéro six, nous définissons OBJ
comme un type d'objet. Nous précisons que la
deuxième propriété est vraie, ce qui est valide
car,
comme vous pouvez le voir, la deuxième propriété est booléenne ou non définie. Cependant, nous ne définissons pas première
propriété et, comme elle est nulle, elle sera définie par défaut. Passons maintenant à un exemple
avec des objets imbriqués. Vous vous souviendrez donc qu' un autre type d'objet
possède deux champs imbriqués, un objet
imbriqué et un
deuxième objet imbriqué. Nous pouvons à
nouveau déclarer OBJ, des objets imbriqués. Nous pouvons lui donner un
objet vide car rappelons que certains types d'objets ont champ nul de première
propriété et de deuxième propriété. Et cela signifie
que si vous utilisez la propriété OBJ point d'objet imbriqué
point first, sa valeur par défaut est indéfinie. Vous allez maintenant voir que
nous déclarons OBJ pour les deuxièmes objets imbriqués. Nous déclarons ces
champs immédiatement. La première imbriquée est donc une chaîne car nous l'avons déclarée comme
étant une chaîne de type. Et deuxièmement imbriqué, nous
devons le déclarer nul. Passons maintenant au terrain de jeu
TypeScript et jouons un peu
avec les objets pour ce que
nous avons appris
dans les diapositives. Essayons de définir une interface
pour un concessionnaire automobile. Nous allons utiliser le mot clé
interface. Voyons maintenant quelles propriétés ont du sens
chez un concessionnaire ? Peut-être voulons-nous répertorier les voitures. Essayons d'abord de définir une interface
automobile. Un petit mot ici. La
convention pour définir le nom d'une interface ou d'un
type consiste à le mettre en majuscule. Donc, quelque chose comme voiture avec un C
majuscule ou concessionnaire avec un D majuscule. Si vous avez plusieurs mots
dans votre interface, vous devez mettre les premières lettres
du mot en majuscule. Donc, mon type, par exemple pour
retourner à la voiture
, utilisons ce que nous avions avant. Donc, marque du type chaîne, modèle du type chaîne et
année du numéro de type. Nous voulons donc dire que le
concessionnaire a des voitures à vendre. Définissons donc une voiture
clé à vendre. Et nous allons dire
qu'il s'agit d'une liste de voitures. Vous vous souviendrez donc
que la syntaxe des tableaux est déclarée de la manière
suivante. Ce faisant, nous
disons que les voitures
à vendre sont une gamme de voitures. Essayons maintenant de définir
un type en ligne, peut-être un emplacement
pour le concessionnaire. Je vais utiliser
les accolades
pour définir qu'il
s'agit d'un objet. Et un emplacement peut
avoir une latitude, qui est de type
numéro, et une longitude, qui est un numéro de type. Essayons maintenant également de définir la
propriété inconnue. Peut-être voulons-nous savoir si le
concessionnaire opère en ligne. Peut-être qu'il est en ligne. Et j'utilise le point
d'interrogation pour dire que c'est nul. Le booléen a du sens ici. Vous pouvez également définir explicitement « non défini » dans le type d'
union. Ou si vous préférez,
vous pouvez utiliser null. Je vais utiliser null pour le moment. Essayons de créer une voiture. Je vais donc dire
const, première voiture. Et je vais
lui donner une sorte de voiture. Vous verrez que si
je le laisse vide, nous ne définissons aucune
des propriétés requises. Donc, si vous
survolez la zone ici, TypeScript
vous indiquera qu'il vous manque
ces propriétés. Alors,
peuplons-les dès maintenant. Et essayons de
définir une autre voiture. Maintenant. Enfin, passons à la
définition d'un concessionnaire. Je vais donc
définir les voitures à vendre. Et vous vous souviendrez que pour définir un tableau, vous devez utiliser
les crochets. Et je vais dire que les
voitures à vendre
contiendront la première voiture
et la deuxième voiture. Emplacement, je vais également
définir en ligne. Et nous pouvons dire que la latitude est nulle et la longitude
est nulle pour le moment. Gardez à l'esprit que nous pouvons également faire quelque chose comme cet endroit. Cette syntaxe indique
essentiellement que le type de lieu est le même que le champ de localisation
sur le concessionnaire. Donc latitude et longitude. Si vous survolez la zone ici, vous verrez qu'il nous
manque les numéros de latitude
et de longitude. Nous pouvons donc aller de l'avant et
le peupler dès maintenant. Ensuite, nous pouvons le
faire passer ici en ligne. D'accord.
Pour en revenir au concessionnaire, je vais faire
la queue pour être bref. Et vous vous souviendrez qu'une fois que
nous les aurons définis, nous recevons toujours une
erreur même si elle est en ligne, c'est facultatif. En effet, si nous utilisons le raccourci « est en ligne »
avec un point d'interrogation, nous n'avons pas besoin de
déclarer cette propriété. Cependant, si nous utilisons
le type union, nous devons indiquer
explicitement si en ligne n'est pas défini, ou si c'est en ligne est
booléen ou nul, alors nous devons lui donner non. Enfin, vous pouvez créer
des objets console.log de la même manière que vous le
faites avec les types de base. Alors essayons ça maintenant. Si nous exécutons le code, vous
verrez que c'est ce à quoi nous nous attendons. concessionnaire est un objet
avec une clé de voitures à
vendre d'une
valeur variable.
Il s'agit de notre première voiture et de notre deuxième voiture. Il possède également un champ
de localisation de longitude zéro
et de latitude zéro. Et enfin, nous l'avons
en ligne pour le savoir. Cela met fin à notre
démo et je vous revois sur les diapositives. Très bien, donc les exercices pour les objets commencent par la documentation
en ligne, trouvez un moyen d'obtenir toutes les clés
de l'objet sous forme de tableau. Comme vous vous en souvenez, les clés étaient associées à des valeurs. Essayez de trouver un moyen d'
obtenir toutes les clés d' un objet et
jouez avec cet objet dans
le terrain de jeu TypeScript
pour vous assurer qu'il fonctionne. Ensuite, essayez de trouver une
interface pour un type de personne. La première question est donc de savoir quelles propriétés ont
du sens pour une personne. C'est un peu ouvert, mais cela vous apprend et vous fait réfléchir d'une manière
orientée objet. Maintenant, supposons qu'une personne possède les
propriétés du prénom, qui est de type String, LastName, également du type string, et que votre naissance, qui
est de type numéro, essaie de trouver cette interface et en
tant que type de script de type. Créons maintenant une
personne pour l'élément C. Ajoutons
maintenant une propriété
annulable du pays de naissance et faisons en sorte qu'elle soit de
type chaîne. Et en plus de la propriété
nullable, vous pouvez soit la définir
par défaut sur undefined, soit indiquer explicitement qu'
il s'agit d'une chaîne ou d'une valeur nulle. Maintenant, jouez avec la syntaxe du
style point et syntaxe du style d'
index pour modifier les propriétés
de votre objet personnel. Enfin, trouvez un moyen de réaffecter votre objet Person à un
tout nouvel objet personnel. Auparavant, nous déclarions personne que vous
créez comme une insulte, mais vous
devrez peut-être la modifier pour réattribuer votre objet personnel. Faites-moi savoir si vous
avez des questions et je vous verrai
dans la prochaine leçon.
9. Affectation variable: Salut les gars, c'est une petite
leçon sur l'affectation des variables. Si vous venez d'autres langages de
programmation, vous avez probablement entendu parler
des termes affectation par référence et
affectation par valeur. Dans cette leçon, nous
allons passer en revue une affectation de variable pour
JavaScript et TypeScript. Si vous n'avez aucune
expérience en programmation et que tout cela est
complètement nouveau pour vous. Ne t'inquiète pas trop à ce sujet. Je vais donner quelques exemples pour illustrer la différence. Il existe également de nombreuses ressources
en
ligne au
cas où vous souhaiteriez approfondir. D'accord, alors qu'entendons-nous par
affectation par valeur par rapport à
affectation par référence ? Essentiellement, nous voulons
répondre à la question suivante : que se passe-t-il lorsque vous attribuez
une variable à une autre ? Supposons donc que vous ayez
une constante nommée a et que vous souhaitiez attribuer à la
constante b la valeur a. Si vous attribuez par valeur, cela signifie que
nous copions la valeur de a dans la constante b. Ceci dans Le JavaScript dans TypeScript s'applique aux chaînes, aux
nombres et aux booléens. La valeur de a elle-même
est donc copiée dans b. D'autre part, par référence signifie que tout B fait référence à
celui-ci pointe vers a. Si vous voulez obtenir
la valeur de
B, B va dire : regardez a et prenez la
valeur de a telle qu'elle est actuellement. Nous ne copions pas
la valeur actuelle. Au lieu de cela, nous détenons simplement une référence à la valeur de a. En JavaScript
et TypeScript,
cela s'applique aux objets et aux tableaux. Ceci est mieux illustré
à l'aide d'un exemple. Dans le premier exemple
de la ligne numéro un, nous déclarons a
égal à deux, et nous déclarons B, qui est égal à a. Vous vous rappellerez
maintenant qu'un
nombre est attribué par valeur. Donc, ce que nous disons ici c'
est que nous devons copier
la valeur de a, donc deux, et la mettre dans b. Donc b est maintenant égal au chiffre trois
en ligne, nous incrémentons maintenant p de deux. Donc deux plus deux font quatre. Donc maintenant, à ce stade, B a une valeur de quatre. Mais a, parce que sa
valeur a été copiée, est complètement distinct de B. Donc a l'est toujours aussi parce que
vous n'incrémentez pas a, mais vous avez incrémenté B24. Maintenant, à la ligne numéro cinq, examinons un exemple d'
affectation par référence. Nous déclarons une constante
C, qui est un tableau. C'est un tableau de
nombres, donc 1,2. Attribuons maintenant une
nouvelle constante D à C. Les
tableaux sont attribués
par référence. Donc, ce que fait D en ce moment, c'est qu'il pointe
vers la valeur de C, mais D n'est pas une nouvelle valeur. Donc, la valeur de c, ce tableau n'a pas été copiée
dans d Si nous appelons pop on C. Nous sommes
donc en train de muter ou de
modifier le tableau existant. Nous supprimons
le deuxième élément. Et maintenant, nous nous attendons à ce que C n'ait qu'un seul élément,
qui en est un. Mais maintenant, si vous accédez à
D, D pointe pour voir, lorsque vous essayez
de trouver la valeur de D. D va simplement dire,
allez regarder la valeur actuelle de C. Mais maintenant, comme C
ne possède qu'un seul élément, d n'aura qu'un seul élément
lorsque vous l'imprimerez. Voici quelques exercices et si vous avez besoin de plus de
précisions à ce sujet, hésitez pas à poser des
questions nécessaire ou à
approfondir vos recherches en ligne. Premièrement, il y a une
chaîne qui suit l'affectation par valeur ou par référence. Il s'agit donc plutôt de
tester votre numéro de connaissance pour déclarer un tableau de
chaînes avec les éléments a, B et C. Maintenant, dans la
documentation en ligne, trouvez un moyen de copier la valeur de ce tableau dans
un autre variable matricielle. Vous vous souviendrez donc qu'il s'agit d'un rasoir
ou d'une assignation par référence, mais existe-t-il un autre moyen
de le faire copier
la valeur de ce tableau ? Très bien, donc pour tester cela, vous devriez être capable d'
appeler des éléments tels que push
, insérer le nouveau tableau sans
changer l'original. Journal, à la fois
original et nouveau. Les opérations que vous effectuez sur la nouvelle matrice ne doivent pas
affecter la matrice d'origine. Et un petit indice, essayez de rechercher l'
opérateur de propagation en JavaScript.
10. Typescript extras: Salut les gars, c'est
une petite leçon sur certaines
notes TypeScript qui ne
rentraient pas dans une section particulière. TypeScript propose donc deux types
uniques, le premier et le
second étant inconnus. Il existe également un type d'
opérateur fourni par JavaScript vous
donner le
type primitif de base pour n'importe quelle variable. Donc, en ce qui concerne les types
TypeScript, la première étant que cela signifie que cette
variable peut être n'importe quoi. Il peut s'agir d'un nombre, d'une chaîne, d'un
objet, d'un tableau. Nous ne savons pas ce que c'est,
mais cela peut être n'importe quoi. Unknown est très similaire. Cela indique toutefois que le type de cette
variable est inconnu. Il existe une
différence très subtile entre une inconnue et la
différence devient évidente lors de la production. Pour l'instant, tout ce que
vous devez vraiment savoir, c'est que les variables « any » et « unknown » sont généralement utilisées pour les
types dont vous
n'êtes pas sûr du
type de variable. Type est un opérateur
qui vous donne un nom de chaîne pour le
type actuel d'une variable donnée. Les détails concernant
leur fonctionnement, ainsi que le moment de leur utilisation, sont vraiment hors de portée de
ce cours d'introduction. Passons en revue quelques exemples. En ligne. Premièrement, nous déclarons une
variable a de type inconnu. Nous ne savons donc pas
quelle est cette valeur. Nous lui donnons d'abord une chaîne, mais vous pouvez voir que vous
pouvez l'attribuer à deux. Et c'est très valable car TypeScript dira essentiellement que nous ne savons pas quelle est
cette variable. Je vais donc autoriser
tout ce qui est en ligne. Troisièmement, nous
faisons la même chose. Déclarer B signifie
que b peut prendre n'importe quel type. Mais sur la ligne numéro cinq, vous pouvez voir que nous
pouvons également l'attribuer à un type numérique sur la ligne numéro car le type de b est une chaîne. Donc, le fait de donner cela
vous donnera le numéro de chaîne sur la ligne pour le type de variable B est une chaîne. C'est donc ce
qu'il va enregistrer. Mais une fois que vous l'avez réaffecté à un numéro et que vous avez enregistré le type, il
reviendra
encore une fois sous forme de numéro. L'utilisation de typeof est donc
un bon moyen de trouver le type d'une
variable donnée lors de l'exécution. Et pour
terminer cette leçon, nous allons en présenter un
peu plus sur les types de syndicats. Au fur et à mesure que votre base de code se développe, vous souhaiterez probablement extraire des
types et leur donner des noms. Et vous
pouvez attribuer des types à un type défini par l'utilisateur avec
votre nom unique. Donc, par exemple si vous voulez avoir
un type d'animal qui peut être le
chat à cordes ou le chien à cordes. Vous pouvez dire type animal. Et nous déclarons un type unique défini par l'utilisateur nommé animal. Et vous dites simplement que c'est
un chat ou un chien. Ou disons qu'un type d'identifiant peut être une
chaîne ou un booléen. Vous pouvez faire la même chose, en disant que l'identifiant de type est
une chaîne ou un booléen. Quelques exemples ici. Donc, pour en revenir à
ce type d'animal, vous verrez que nous pouvons
créer une constante animal, de type animal et l'
attribuer au chat. Cependant, si vous essayez d'attribuer une constante de type animal à, disons une voiture, qui
n'est ni un chat ni un chien. Tapez script, cela vous
donnera une erreur. Donc, pour faire quelques
exercices, essayez tout d'abord d'enregistrer
le type de NRA. Et le résultat peut être un peu confus et vous êtes
libre de vous y plonger. Mais encore une fois, ce cours d'introduction est hors de portée . Ensuite, déclarez un type de numéro
spécial. Donc, un type défini par l'utilisateur qui peut prendre trois
types de valeurs différents, 12.42. Maintenant, essayez de créer une constante, mon numéro spécial avec ce type et essayez de le
régler sur dix. Si vous le pouvez essayez d'inspecter la zone
qui en sort. Enfin, déclarez-le tableau vide
avec des éléments de tout type. Déclarez donc un type de tableau. Mais pour chaque élément, le type de cet élément est quelconque. Et maintenant, réfléchissez au type d' objets que vous pouvez ajouter
à ce tableau. Pourrais-tu appuyer sur une chaîne, un nombre, un booléen ? Essayez-le sur le terrain de jeu. Faites-moi savoir si vous
avez des questions et je vous verrai
dans la prochaine leçon.
11. Déclarations conditionnelles: Salut les gars, Dans cette
leçon, nous allons
passer en revue les
déclarations conditionnelles. Il s'agit du premier d'une longue série de chapitres
sur le contrôle des flux. L'
instruction conditionnelle de base dans JavaScript dans TypeScript est composée
de if, else-if et else. Une instruction conditionnelle
vous permet d'exécuter du code en
fonction d'une condition, qu'
elle soit évaluée comme vraie ou fausse. Une déclaration conditionnelle commence
toujours par un « si ». Vous pouvez avoir un else-if, nombre
quelconque de blocs
else-if supplémentaires. Et enfin, un autre bloc. Mais le bloc else
est également facultatif. L'instruction
conditionnelle très basique est donc une condition unique
sans autre IPS ou autre. Vous pouvez également ajouter un
autre si vous le souhaitez ou n'importe quel autre élément
entre les deux. Donc, en regardant ce
pseudocode ci-dessous, il
s'agit d'une syntaxe pour une déclaration
conditionnelle. Vous verrez que si nous mettons une certaine condition
entre crochets, cette condition est essentiellement
une expression évaluée comme
vraie ou fausse. Si c'est vrai, exécutez le bloc juste après
l'instruction if. Si vous avez
une déclaration contraire, cette nouvelle condition
sera évaluée. Et si cette condition est vraie, lancez le bloc juste
après cette autre condition. Si tout échoue, aucune condition du if ou de
toute autre condition if ne correspond, le code du
bloc else sera exécuté. Passons en revue un exemple. Supposons que vous définissiez un nombre et
que vous le rendiez égal à cinq. Nous définissons d'abord un
si et nous disons, d'accord, si un nombre est inférieur à dix, donc c'est cinq, moins de dix. Console.log, petit nombre. Sinon, si un nombre
est inférieur à 20, nous enregistrons le nombre moyen
; sinon , si un nombre est compris
entre 20 et 10, le grand nombre logarithmique. Donc, si notre nombre est cinq, alors nous verrons que
la condition if sera considérée comme vraie et
nous enregistrerons un petit nombre. Mais si un nombre est, disons 15, nous
enregistrerons un nombre moyen. Et si un nombre est 25, nous enregistrerons un grand nombre. Nous abordons ici un peu
les opérateurs booléens. Il y en a trois que
vous devez connaître, le premier étant
l'opérateur non. Donc le point d'exclamation
devant la variable elle-même. Cela signifie
inverser le booléen. Cela signifie donc que si vous avez un vrai et que vous placez un point d'
exclamation devant
celui-ci, il deviendra faux et
faux deviendra vrai. L'opérateur suivant, l'opérateur, implique que pour que cette
expression soit évaluée comme vraie, toutes les conditions que vous
associez aux deux
esperluettes doivent être vraies. Enfin, nous avons l'opérateur OR. Cela signifie simplement que pour que cette
expression soit évaluée comme vraie, l'
une des affirmations
que vous
associez aux doubles
lignes verticales doit être vraie. Donnez donc quelques exemples ici. Sur la première ligne, nous voyons que vrai
et vrai seront
bien sûr vrais parce que
les deux conditions sont vraies. Cependant, si nous avons le vrai, le vrai
et le faux, parce que l'un d'entre eux est faux, l'ensemble de
cette déclaration
sera considéré comme faux. À la troisième ligne, nous disons vrai ou faux, et comme l'un d'entre eux est vrai, le premier est vrai. Sur la ligne numéro quatre, il y a « faux » ou « faux » ou « vrai ». Maintenant, peu importe le
nombre de faux que nous avons, tant que l'un d'entre eux est vrai, toute
la déclaration
sera vraie. Et c'est ce qui
se passe ici. dernière fois que l'opérateur
not a utilisé le point d'exclamation devant faux, cela inversera le booléen, ce qui vous donnera true. L'instruction conditionnelle suivante est appelée opérateur ternaire. Et il s'agit essentiellement d'un raccourci pour une affectation
« si, sinon ». Affectation, ce qui signifie
que vous attribuez la valeur à une variable. L'opérateur ternaire
est donc essentiellement le point d'interrogation juste
après la condition. Et vous séparez la
vraie valeur de la fausse par deux points. Cela signifie donc
essentiellement que la valeur d' une variable prend
la valeur réelle. Si la condition est évaluée comme vraie. Sinon, si la
condition est fausse, donnez-lui la valeur fausse. Passons donc en revue un exemple. Disons qu'un chiffre est cinq. Nous voulons maintenant construire un
nombre qui soit définitivement
pair si notre nombre peut être tout ce que nous voulons ou
n'importe quel nombre que nous voulons qu'il soit. Nous disons ici un nombre modulo deux. Donc, si vous n'avez pas vu
l'opérateur modulo, il vous donne essentiellement le reste après avoir
divisé par deux. Si un nombre modulo deux est vrai, renvoyez un
nombre multiplié par deux. Sinon, si un nombre
modulo deux est faux, il ne renvoie qu'
un nombre lui-même. Alors réfléchissons-y. Si vous avez un nombre impair et que le reste
est divisé par deux, le reste est toujours un. Et la véracité de l'
une d'elles est vraie, non ? L'un d'eux a le chiffre en JavaScript
qui sera évalué comme vrai. Donc, si cette condition est vraie, alors nous avons un nombre impair. Comment rendre un nombre
impair pair ? Nous le multiplions par deux. Sinon, si un nombre
modulo deux est faux, il doit être égal à zéro. Et nous savons que
lorsqu'il est égal à zéro, le nombre doit être pair. C'est pourquoi nous avons simplement renvoyé un numéro car
il est déjà pair. Prochaine. Examinons l'opérateur Knowledge
Color Leçon. Il s'agit essentiellement d'un
raccourci pour donner une valeur par défaut à toute
variable nulle. Si vous vous en souvenez, nullable
signifie qu'il peut être nul ou non défini ou
prendre une valeur réelle. Donc, dans le pseudocode, nous avons
une constante, une variable. Nous disons que nous
avons d'abord une valeur nulle. Cette valeur peut donc être
nulle ou non définie. S'il est nul ou non défini,
attribuez la valeur par défaut à une variable. Sinon, si
une valeur nulle est définie, donnez-lui
simplement la valeur
qu'elle est définie. Pour donner un exemple, disons que nous avons une valeur
nulle qui
peut être une
chaîne ou une valeur non définie. Et nous ne le donnons
pas de définition au début. Que se passe-t-il si nous
enregistrons une valeur nulle ? Deuxièmement, les points d'interrogation et la valeur par défaut ? Comme
la valeur nulle n'est pas définie, nous donnerons la valeur par défaut, sorte que la valeur par défaut sera enregistrée. Cependant, si nous disons OK, la valeur du
roman est égale à bonjour, ce n'est plus indéfini. Maintenant, lorsque console.log utilise
cet opérateur de fusion, la valeur par défaut
ne sera pas utilisée car valeur
nulle est
déjà renseignée. Donc, bonjour sera faible. Donc, pour commencer quelques
exercices, commencez par
définir un nombre, puis
écrivez une instruction if else qui imprime même
si le nombre est pair et impair s'il
est impair. Cela nous ramène donc
à l'exemple que nous avons donné dans les diapositives précédentes sur
l'utilisation de l'opérateur modulo. Ensuite, vous avez accès
à des points mathématiques aléatoires, vous pouvez
donc le taper sur le terrain de jeu et
vous obtiendrez un nombre aléatoire de 0 à 1, n'est-ce pas ? Expression ternaire qui
attribue une contrainte constante. Vous créez donc une
nouvelle chaîne constante dont
la valeur est grande si cet appel aléatoire à points
mathématiques est supérieur à 0,5 et petite si elle n'est pas
supérieure à 0,5. Enfin, créez deux variables
booléennes, première condition et
la deuxième condition. Premièrement, écrivez une
instruction if qui affiche les deux valeurs vraies. Si les deux variables sont vraies. Le nombre pour écrire une instruction if qui en affiche au
moins un est vrai. Si l'une ou les deux
conditions sont remplies. Troisièmement, écrivez
une instruction if
qui indique qu'aucune n'est vraie. Si les deux variables sont fausses. Faites-moi savoir si vous
avez des questions et je vous verrai
dans la prochaine leçon.
12. Boucles: Salut les gars. Dans cette leçon, nous allons passer en
revue et faire des boucles. Les boucles sont un moyen d'
effectuer une itération. En d'autres termes,
c'est un moyen plus facile d'exécuter quelque chose
de nombreuses fois. Ils nous permettent d'itérer à nouveau, c'
est-à-dire de faire quelque chose
encore et encore. Quatre types de boucles seront abordés
dans cette leçon. Il existe de nombreuses autres façons de
parcourir quelque chose, mais ce sont les
plus populaires que je connaisse. Ces quatre boucles seront
la boucle while, la boucle for, la boucle for et la boucle for chaque boucle. Commençons par un certain temps. En pseudocode, il indique
While condition is true et les
parenthèses contiennent une
sorte de condition
TypeScript. Le bloc de code qui suit
l'instruction while est le code que vous exécutez
encore et encore. Donc, dans un exemple, définissons d'abord num
égal à zéro. Donc, si num est de type numéro, je dirais que le nombre
est inférieur à trois. Ainsi, chaque fois que nous
parcourons la boucle, si num est inférieur à trois, continuez à exécuter le code
et le bloc de code ci-dessous. Nous voyons que nous sommes
console.log num plus plus. Et si vous vous en souvenez, l'opérateur
postfix
incrémentera le nombre après
l'exécution de l'instruction. Donc, la première fois que la ligne numéro trois
est tête, num vaut zéro. Donc num est inférieur à trois, ce qui signifie que la
condition est vraie. Maintenant, exécutez le
bloc de code console.log num, qui vaut zéro, puis
incrément num n'en vaut pas un. Revenez maintenant au
début de la boucle. Donc, ligne numéro trois, num est égal à un et inférieur à trois. Alors continuez. Il en enregistrera un et
maintenant num vaut deux. La condition est à nouveau vraie. Lorsque num est égal à deux, il passe par la
même instruction de journal, mais maintenant il est numéro trois. Donc, lorsque vous revenez à la troisième ligne
et que le chiffre 33 n'est pas inférieur à
trois, c'est faux. Maintenant, la boucle va se rompre et nous allons donc poursuivre l'exécution
après la ligne numéro cinq. Et le journal de la console ne sera pas exécuté lorsque num est égal à trois. Entrez dans le For-Loop. Voici le pseudocode pour tout d'abord, vous avez une expression d'
initialisation terminée par un point-virgule. Ensuite, vous avez ce que l'on appelle
l'expression de test, terminée à nouveau par un point-virgule ,
puis une expression itératrice. Et bien sûr, comme
pour la boucle while, vous avez le bloc de code. Ensuite, examinons l'expression
de l'initialiseur. L'expression d'initialisation
est exécutée une fois au tout début lorsque la
boucle pour est visible en ligne.
Premièrement, l'initialiseur s'
exécutera une fois, mais si vous
parcourez cette boucle pour boucle, elle ne sera pas Courez à nouveau. L'expression de test vous
donnera un booléen. C'est donc très similaire
à ce que vous mettez à l'intérieur de la boucle while. L'expression doit
renvoyer une valeur vraie ou fausse selon que nous devons
continuer à exécuter cette boucle. L'expression itérateur est exécutée
à la fin de chaque boucle. Il est généralement utilisé pour
modifier un compteur afin que l'expression de test
se termine, c' est-à-dire qu'elle renvoie false
à un moment donné que vous avez prédéterminé via
le pseudocode en ligne. Premièrement, lorsque vous verrez la boucle pour la
première fois, vous exécuterez celle de l'initialiseur. Ensuite, vous allez exécuter l'expression de
test pour savoir si nous
devons exécuter ce bloc de code ? Et si oui, exécutez ce qui se trouve dans le bloc de code à
la fin de la boucle, exécutez l'expression itérateur, puis revenez au
début de la boucle. L'expression de test
sera alors utilisée pour dire :
OK, est-ce que nous l'exécutons à nouveau ? Si c'est vrai, nous l'exécutons à nouveau. Et puis à la fin de la boucle exécutez l'expression itératrice. Mais si c'est faux, nous
sortons
complètement de la boucle , puis nous
passons à l'exécution et au
reste du code. Maintenant, cela peut être un peu déroutant
avec un pseudocode pur. Passons donc à un exemple. Nous avons donc ici trois
déclarations dans la boucle pour. Soit num égal à zéro. Il s'agit donc de la première instruction, l'instruction d'initialisation. Cela se fait au
tout début. L'expression du test est similaire à celle que nous avions
dans la boucle while. Donc, zéro est inférieur à trois. Si num est inférieur à trois, exécutez ce qui se
trouve à l'intérieur de la boucle. Mais si ce n'est pas le cas,
sortez de la boucle. Enfin, l'
expression de l'itérateur est num plus plus plus, ce qui signifie que nous incrémentons
simplement num. relisant cela d'abord, En relisant cela d'abord, lorsque vous rencontrez la boucle, num est égal à zéro, et donc votre console enregistre zéro. Ensuite, à la fin de la boucle, num est incrémenté à un. Vous revenez au
début de la boucle et un fait toujours
moins de trois. Yule Log one, tu
vas l'incrémenter. Maintenant, num vaut deux. Bien sûr, c'est moins de
trois. Vous allez donc le
reconnecter et l'incrémenter. Et maintenant, Num est trois. Ainsi, lorsque num est égal à trois, nombre inférieur à trois
sera considéré comme faux, ce qui signifie que
vous sortirez de la boucle. La forme de la boucle vous permet de vous lier à un élément spécifique
dans un itérable. Iterable est généralement un tableau. Et bien sûr, pour chaque
élément de cet itérable, exécutez ce bloc de code, mais vous avez accès
à l'élément lui-même. C'est donc très utile pour
parcourir des tableaux d'éléments. Donc, en regardant l'exemple de
la ligne numéro un, vous déclarez un
tableau dont le numéro est 01.2. Ensuite, vous pouvez dire, d'accord, pour un nombre constant de nombres, et vous verrez que num est une nouvelle variable ou constante ici. Et dans le bloc de code qui suit, vous avez
accès à num. Num est chaque élément
du tableau, et nous allons
parcourir chaque élément
du tableau un par un . Donc, pour la première itération, num est égal à zéro. Vous allez donc consoler .logs zero. Mais lorsque vous revenez
au début de la boucle, num vaut désormais un car vous
parcourez le tableau. Vous allez donc en enregistrer un
, puis vous en enregistrerez deux. Et c'est la fin de la course. Vous sortirez donc automatiquement de la boucle
for. Franchir la boucle pour chaque boucle. C'est une bonne alternative aux quatre que vous pouvez utiliser
sur la baie elle-même. Donc, chacun prend en fait une fonction d'itérateur en
tant que paramètre, et nous aborderons plus en détail
les fonctions plus tard. Mais en regardant l'exemple, vous verrez à nouveau qu'
avec la forme de la boucle, nous avons un nombre égal à
un tableau de 01,2. Mais vous pouvez les appeler
directement
dessus et transmettre ce que l'on appelle
une fonction flèche. Alors ne t'inquiète pas trop pour
ça. Mais si vous avez un entre parenthèses
au sein de cette fonction, il s'agit essentiellement du nombre constant de nombres
que nous avions dans la boucle for. Et vous verrez que
nous serons en mesure d'accéder à cet élément numérique dans le tableau et de nous connecter. Donc, pour chacun, il suffit d'itérer
et de passer en revue
chaque élément du tableau. Salut les gars, faisons une
démo de l'itération. Dans cet exemple,
nous définissons donc une interface Car. Chaque voiture possède une marque de type chaîne ainsi qu'
un modèle de chaîne de caractères. Ensuite, nous créons une gamme de voitures. La première voiture est donc fabriquée avec une
Honda et un modèle de Civic, et la seconde a les
moyens et le modèle Focus. Essayons d'utiliser chacun de
ces types de boucles. Donc, pour la boucle entière, nous avons réellement besoin de quelque chose pour suivre où nous
en sommes dans la boucle elle-même. Disons que l'
index du tableau est égal à zéro. Cela permettra de suivre notre
position dans le tableau. Ainsi,
bien que l'indice du tableau soit
inférieur à la longueur des points de la voiture ,
nous allons d'abord enregistrer les points sur console sur l'objet de la voiture lui-même. Et vous vous souviendrez que vous pouvez accéder à cet
objet en particulier à l'aide d'un accès indexé. Nous pouvons donc utiliser notre indice. Et bien sûr, vous pouvez
parler de notre augmentation d'indice. Et nous allons suivre cette boucle. Cela signifie donc que
notre indice se situe au premier zéro. Notre indice est nul, il est
donc inférieur longueur
des points des voitures, qui est de deux. Nous allons donc enregistrer
l'indice zéro des voitures, qui est le premier élément. Ensuite, nous augmentons notre indice, qui est égal à un, ici même. Et maintenant, notre indice en est un. Lorsque notre indice est de un, il est toujours
inférieur à la longueur du tarse,
qui, comme vous vous en souvenez, est de deux. Nous enregistrons maintenant le
deuxième élément des voitures. Nous augmentons maintenant notre indice
et notre indice est désormais de deux, mais deux n'est pas inférieur à deux. Nous sortons donc de la boucle. Essayons de l'exécuter. C'est ce à quoi nous nous attendons. Nous enregistrons donc d'
abord le premier élément
du tableau, puis le
deuxième élément du tableau. Maintenant, vous pouvez réellement le raccourcir
en utilisant une boucle pour. Nous pouvons donc dire pour, nous pouvons dire pour, notre indice soit égal à zéro. Cela se fait donc
au tout début. Notre indice est donc le premier zéro. Désolé, notre indice est
inférieur à la longueur des points des voitures. Il s'agit donc de l'expression de test. Et puis l'incrément, notre expression itératrice,
est notre indice plus, plus. Et comme toujours, nous pouvons l'enregistrer
comme nous l'avons fait ici. Et essayons de l'exécuter. Encore une fois. Nous avons exactement la même chose. Maintenant, cela peut être encore
simplifié en utilisant la forme de loop, qui correspond à quatre
concept-cars. Alors maintenant, cela signifie simplement de parcourir chaque élément de la voiture
dans le réseau de voitures. Et nous pouvons console.log car. Et vous verrez qu'
il défile vers le bas. Nous avons exactement la même chose. Clariquons cela en fait. Maintenant, pour que ce soit encore plus clair. Et c'est peut-être l'
alternative que vous préférez. Vous pouvez en fait conduire des voitures
, puis appeler le foreach et lui transmettre ce que l'
on appelle une fonction, une voiture, et enregistrer cette
voiture immédiatement. Et encore une fois, nous avons exactement
la même chose. C'est la fin de
notre démo et je vous revois sur les diapositives. Très bien, des exercices. Essayez d'écrire un script
qui enregistre les nombres de 50 à 60, mais incluant 60, en utilisant les quatre
types de boucles différents. Ensuite, définissez un tableau de chaînes avec des éléments,
hello, world, array, et verrouillez chaque élément avec chacun des
quatre types de boucle. Petit indice,
la longueur du
tableau peut être très utile pendant un certain temps et pour les boucles lorsque
vous le faites. Très bien les gars, je suis
heureuse de répondre à toutes vos questions et à la prochaine leçon.
13. Déclarations de commutation: Salut les gars, Dans cette leçon, nous
allons passer en revue l'instruction switch, la dernière leçon
sur le contrôle du flux. Une instruction switch vous
permet d'évaluer plusieurs cas et d'exécuter
quelque chose lorsqu'un cas correspond. Par défaut, toutes les cases
seront cochées de haut en bas et vous utiliserez une pause pour quitter l'intégralité du relevé
si l'une des cases correspond. Nous allons passer en revue le pseudocode
ainsi qu'un exemple pour le rendre plus clair. Mais considérez une instruction
switch comme une bonne alternative pour répondre
à de nombreuses conditions. C'est donc une alternative à
l'utilisation de nombreux blocs if-else. La même chose peut être faite
avec de nombreux blocs, sinon. Jetons donc un coup d'
œil au pseudocode. Vous avez d'abord l'instruction
switch elle-même sur la ligne numéro un. Entre parenthèses, vous mettez une variable que
vous souhaitez comparer. Et puis vous avez le
bloc de code entre accolades. Ensuite, vous
verrez que chaque élément l'instruction
switch commence par majuscules. Après case, c'est
essentiellement ce à quoi vous voulez comparer une
variable à laquelle vous voulez comparer. Si la variable à comparer
est strictement égale au premier cas r1 qui fait quelque chose, vous verrez l'
utilisation de break there. Ainsi, lorsque nous disons pause, nous disons sortir complètement de l'instruction
switch. Si vous n'êtes pas obligé de faire une pause, vous parcourrez étape par étape tous
les exposés de cas. Et si quelque chose d'autre est
écrasé en dessous, ce bloc de code
sera également exécuté. Jetons donc un coup d'
œil à la septième ligne. Maintenant, examinons le deuxième cas. Si la variable à comparer
est égale au second cas, alors nous exécuterons
faire autre chose. Mais notez qu'il
n'y a pas d'instruction break, et c'est une
partie étrange de TypeScript. Et que si vous correspondez à une déclaration et qu'
il n'y a pas de pause, vous
continuerez à traiter toutes les affaires ci-dessous comme si elles correspondaient. Donc, si la variable à comparer
est égale au second cas, do something else sera exécuté dans ce second
cas, case statement. Mais le troisième cas correspondra
également, que
la variable à
comparer soit égale ou non au troisième cas. Donc, faire autre chose sera
en fait appelé deux fois. Maintenant, bien sûr, vous avez
la clause par défaut et elle est exécutée lorsque
rien ne correspond. Regardons un exemple. Cela provient directement de
la documentation de Mozilla. Déclarez donc d'abord un animal constant
égal à la girafe. Allumons maintenant cet animal. Donc si les animaux boivent, ce qui n'est pas courir, rien. Si l'animal est une girafe, ce qui est Console.log,
c'est une girafe. Mais notez qu'il
n'y a aucune déclaration de rupture. Vous continuerez donc à exécuter tous les segments de cas ci-dessous
comme s'ils correspondaient. L'affaire pour chien sera classée mais il n'y a rien.
Nous ne faisons donc rien. Mais les arguments en faveur de l'
éducation physique seront également présentés. Vous allez donc vous connecter. C'est une girafe et elle est sous-payée. Vous aimez aussi console.log. Cet animal n'a pas disparu. Et enfin, vous avez
la déclaration de rupture. Donc, rien après
Dinosaur n'est exécuté. Disons les animaux,
quelque chose d'autre qui ne correspond à
aucun des cas, alors par défaut, vous
enregistrerez que cet animal est éteint. Très bien, donc un exercice
pour cette leçon, écrivez une instruction switch
qui fonctionne sur un numéro appelé mon numéro et abordez
les cas suivants. Lorsque mon nombre est égal
à un journal, il est égal à un. Quand il fait cinq heures, il en fait cinq. Et quand mon numéro n'est ni
un ni cinq, pas 145. Comme toujours, faites-moi savoir
si vous
rencontrez des problèmes et je
vous verrai dans la prochaine leçon.
14. Fonctions: Salut les gars, j'espère que vous
allez bien. Et c'est moins que ce que nous
passons en revue les fonctions. C'est sans doute l'une des choses
les plus importantes de JavaScript ou de
la programmation en général. Le code complexe repose en fait
sur des fonctions de composition. Une fonction put prend simplement une ou plusieurs entrées appelées
paramètres ou variables, et renvoie un type de retour
facultatif. Vous pouvez donc considérer une
fonction comme une boîte noire. Vous entrez une entrée,
quelque chose se
passe à l'intérieur de la boîte noire. C'est donc ce que la fonction
est chargée de faire. Et puis vous obtenez un certain
nombre de sorties. Et je dis
type de retour facultatif ici parce que vous
n'avez pas vraiment besoin de renvoyer
quelque chose à partir d'une fonction. Souvent, les fonctions
renvoient une sorte de type de retour en fonction
de l'utilité de la fonction. Une fonction doit être
une unité de travail de base. Il doit faire une chose et
être nommé de manière appropriée. Ainsi, par exemple, vous pouvez préfixer
votre fonction avec get, calculate ou parse en
fonction de la raison d'être de la fonction. En général, c'est une
bonne idée d'avoir une fonction pour une
unité d'opération. Donc, si vous faites deux choses
dans la fonction, c'est un bon signe
que vous devez diviser cette fonction en
deux fonctions distinctes. Très bien, donc un peu sur les déclarations de
fonctions
dans TypeScript. Commençons par la première ligne. Nous déclarons une fonction avec
le mot clé function. Vos entrées ou paramètres
sont séparés par des virgules. Nous avons donc ici la première
entrée et nous avons deux points avec le
type de première entrée. Ensuite, nous avons une deuxième entrée
séparée par une virgule. La deuxième entrée est de type, deuxième type d'entrée indique le
type de retour de la fonction, vous commencez par le signe deux-points après la fin des paramètres de
la fonction, et vous spécifiez
tapez de retour juste après. Ensuite, bien sûr, vous avez
les accolades pour indiquer le bloc
de code de la fonction. Vous pouvez faire ce que vous
voulez dans le cadre de cette fonction. Et bien sûr, vous avez accès à la première entrée
ainsi qu'à la deuxième entrée. Et à la toute fin, vous voulez renvoyer une sorte de variable qui correspond
au type de retour. J'ai dit que le
type de retour est facultatif. Donc, en ligne, numéro huit, si vous omettez
le point-virgule final avec un type, cela signifie que TypeScript
déduira
le type de retour du nom de
ma fonction. Ainsi, quel que soit le type
de variable de type return, TypeScript annotera le nom de
ma fonction pour renvoyer ce type. Il existe également une syntaxe
alternative pour déclarer une fonction. Et il s'agit en fait
d'attribuer une fonction à une variable. À la ligne 14, vous verrez que nous disons «
const my arrow function ». C'est très similaire
à la déclaration d'une variable de type numéro
ou de type chaîne. Vous avez ensuite les parenthèses
pour déclarer vos entrées. Vous avez donc une entrée appelée
mon entrée de mon type d'entrée, puis avec
deux points, vous indiquez le type de retour. Et puis vous avez cette flèche triée en utilisant le signe
égal
ainsi que l'opérateur
supérieur à, avec une fonction entre crochets
juste après. Ainsi, comme le
nom de la variable l'indique, cette déclaration est
appelée fonction flèche. Vous avez donc une fonction normale déclarée en utilisant le mot clé
function. Et vous avez une fonction flèche déclarée à l'aide de la syntaxe flèche, et vous l'attribuez à une
constante ou à une variable. Alors, que pouvez-vous mettre
dans une fonction ? C'est en fait
tout ce que tu veux. Quel que soit le code valide
dans TypeScript, vous pouvez le mettre dans
une fonction. La fonction ne fait que résumer un
bout de logique ou un bout de code en blocs qui peuvent être réutilisés
dans tout votre code. Vous pouvez donc appeler votre fonction plusieurs fois
dans le code. Cela signifie que vous
n'avez pas à
copier-coller des blocs de code identiques autour de votre code. Donc, un peu sur les bons
noms de fonctions, en général, vous souhaitez les préfixer par un verbe en fonction de
ce que fait la fonction. Par exemple, ajoutez des nombres. Nous utilisons donc ici
la syntaxe des flèches. Nous disons que les nombres impairs sont une fonction qui prend
comme premier numéro de type et le second
numéro de type renvoie un nombre. Et vous verrez que
dans le corps de la fonction, nous ajoutons simplement le
premier et le second. Essayons maintenant de
déclarer une interface la ligne numéro cinq. C'est une interface assez simple
avec le nom et l'âge des champs. Ensuite, nous utilisons la syntaxe de
déclaration de fonction. Nous avons baptisé ce GetAge parce qu' il prend de l'âge
et le rend. Vous verrez que le
paramètre prend en compte une personne de type personne
et qu'il renvoie un nombre. En lisant simplement la déclaration de
fonction, il peut très bien déduire que le type de numéro renvoyé
est l'âge de la personne. Et bien sûr, dans
le corps fonctionnel, nous avons renvoyé à la personne le point h, qui est l'âge, est
signé pour être donné à la personne. Objet. Typescript autorise également les paramètres nullables
ainsi que les paramètres par défaut. Dans le premier exemple,
nous avons donc myfunction. Nous avons alors un argument ou un paramètre appelé argument
connaissable. Regardez ce point d'
interrogation avec deux points. Cela signifie que l'
argument nullable est facultatif. Et notez également que
nous ne renvoyons rien à l'intérieur
de cette fonction. Le script de type en déduira alors que le type de retour de
ma fonction est nul. Donc, chaque fois que tu vois un vide. C'est en fait juste
un autre nom pour rien dans le bloc
de code de ma fonction, le type d'argument connaissable, car nous avons spécifié qu'
il est nul ou facultatif, est nombre ou non défini. Donc, l'
argument connaissable console.log donnera une valeur non définie si vous appelez simplement ma fonction sans
transmettre d'arguments. Ou si vous transmettez par exemple le numéro deux,
il en enregistrera deux. Passons maintenant aux paramètres par défaut. Dans l'exemple que nous avons ici, valeur
par défaut est de type numéro et ce qui équivaut à
la syntaxe. Nous disons que
si aucun argument n'est fourni pour justifier notre défaut de croissance, définissez cette variable
par défaut sur deux. Ainsi, si nous appelons une autre
fonction avec l'argument quatre, argument par défaut est quatre. Et donc, bien entendu, dans
le corps de la fonction, vous vous connecterez. Cependant, si vous appelez une autre
fonction sans rien, valeur par défaut n'
est pas indiquée. La valeur par défaut sera deux. Vous verrez donc que cela sera
également enregistré. Salut les gars, Dans cet exemple, nous allons écrire
une fonction somme nombres
pairs qui fait la somme tous les nombres pairs d'un tableau de nombres et
retourne au soleil. Permettez-moi donc d'abord de
déclarer la fonction. Nous allons
lui donner des nombres pairs. Il va prendre
une série de numéros que je vais
appeler. Et il va
renvoyer un numéro. Voici donc le
nom de la fonction, quelques nombres pairs. Il prend en compte un paramètre, le type de tableau de nombres, et le paramètre
est appelé nombres. Ensuite, nous renvoyons un
numéro et vous verrez que nous avons une erreur
TypeScript ici. Cela signifie essentiellement
que nous
ne renvoyons pas de nombre
même si nous avons indiqué à TypeScript
que la fonction certains nombres pairs
devraient renvoyer un nombre. Par exemple, si nous disons simplement renvoyer zéro, cette erreur disparaît
car nous renvoyons un nombre ici, dans le corps de
cette fonction, nous pouvons écrire ce que nous voulons. Mais le rôle de la
fonction est de faire la somme tous les nombres pairs
dans le tableau de nombres. Écrivons également un test
rapide pour cela. Déclarez un tableau 12345. Et nous allons simplement
enregistrer le résultat de certains nombres pairs lorsque
nous transmettons ce tableau. Lancez-le donc rapidement
et vous verrez que nous n' obtenons aucun log parce que, bien sûr,
nous renvoyons zéro ici. Essayons maintenant d'implémenter
la fonction elle-même. Nous allons suivre
la somme grâce à la variable
vallée. Et ici, nous devons additionner tous les nombres
pairs en chiffres. Pour ce faire,
je vais utiliser pour chacun des numéros du tableau. Nous transmettons ici
une fonction de rappel. Et sa fonction de rappel est
une fonction déclarée
en utilisant la syntaxe des flèches. Pour chacune d'elles, un rappel
prend un paramètre num, qui correspond à chaque
élément du tableau. Num le sera. Dans le cas des nums, ce sera 1 234,5. Au fur et à mesure que nous parcourons
le tableau de nombres, nous nous intéressons à tous les nombres
pairs qu'il contient. Mais comment s'y prendre ? Rappelez l'opérateur modulo. Je vais donc
dire si num modulo deux est strictement égal à zéro, et modulo est le reste après division par ce nombre. S'il s'agit d'un nombre pair, lorsque vous divisez par deux, le reste est toujours égal à zéro. Nous savons donc que
NUM est même là. Lorsque nous savons que
le nombre est pair, nous voulons augmenter
la valeur de la valeur. Enfin, à la toute
fin, retournons la valeur. Essayons de l'exécuter. Nous verrons que le
résultat est de six. Et bien sûr, si
nous ne prenons ici que les nombres
pairs qui sont 2,4, la somme devrait être de six. Essayons de changer ce tableau. Alors disons 12. Maintenant, comme c'est égal, nous nous attendons à ce que
six soient ajoutés à 12, soit 18, et c'est ce
que nous obtenons. Essayons maintenant d'ajouter
un nombre impair, 101. C'est étrange, il ne faut donc pas inclure dans la valeur finale. Nous recommençons, nous constatons
que nous avons à nouveau 18 mois, ce qui signifie que nous pouvons être quelque peu sûrs
que notre fonction, certains chiffres pairs, a fonctionné. Très bien les gars,
c'est tout pour cet exemple et je vous
revois sur les diapositives. Très bien, donc pour certains
exercices, commencez écrire une fonction qui
enregistre les flux qui prend en argument une chaîne de caractères, comme l'argument,
et ne renvoie rien. Écrivez une fonction pour l'exponentiation numéro
deux qui prend deux nombres a et
b et renvoie un nombre, un double astérisque b. Et voici la notation pour amener a à la puissance
de b dans TypeScript. OK, numéro trois, jetez un
œil à la fonction de filtre du tableau, et vous verrez que
la fonction de filtre prend
en fait une autre
fonction comme paramètre. Ce paramètre est appelé
fonction de filtrage. La fonction que vous transmettez au
filtre doit donc renvoyer
vrai ou faux, indiquant si vous souhaitez que l'élément actuel soit
inclus dans le tableau final. Examinez donc un peu la fonction de filtrage
des chiens et vous
pourrez le voir avec les exemples
fournis dans la
documentation que j'ai liée. Maintenant, avec cet arrière-plan, écrivez un script qui crée
le tableau de 1 234,5. Et puis en créant
un nouveau tableau avec cette fonction de filtre avec uniquement les éléments pairs
du tableau d'origine. Petit indice, l'opérateur
modulo que nous avons déjà vu
peut être très utile. Faites-moi savoir si vous
avez des questions et je vous
verrai
dans la prochaine leçon.
15. Cours ES5: Salut les gars, j'espère que
vous allez bien. Dans cette dernière leçon, nous
allons passer en revue les cours. Nous n'allons pas passer
beaucoup de temps avec les cours car ils
réutilisent simplement ce que nous savons déjà. Une grande partie de la syntaxe peut être consultée dans
la documentation. De plus, les classes
ne sont généralement pas utilisées très souvent
dans TypeScript. Verra les fonctions
ainsi que les objets plus couramment. Et tout ce que la classe est vraiment, c'est des objets renforcés. Il encapsule
certaines fonctions et propriétés et imite une syntaxe
orientée objet. Même si JavaScript
ou TypeScript pas vraiment de la programmation
orientée objet, sont utilisés pour regrouper
les fonctionnalités associées. Au lieu d'avoir des fonctions
distinctes existe des propriétés distinctes
au sein d'un objet. Encore une fois, cela n'est pas
très couramment utilisé dans la production,
selon l'endroit où vous vous trouvez. Les objets de base semblent être
plus populaires, de même que les fonctions qui intègrent cet objet et effectuent des
opérations sur celui-ci. Examinons rapidement
la syntaxe d'une classe à l'
aide d'un exemple. Tout d'abord, en ligne, nous utilisons le mot clé class pour déclarer une classe appelée my class name. Vous avez alors bien sûr
un constructeur. Ainsi, en invoquant le constructeur, vous créez une instance
de mon nom de classe. Vous verrez que le
constructeur ressemble
beaucoup à une fonction
et il l'est vraiment. Il prend en compte le premier paramètre du type numéro et le deuxième
paramètre du type chaîne. Nous utilisons ensuite le, ce mot clé. Lorsque vous l'utilisez, vous faites référence à une propriété sur une instance de mon nom de classe. Donc, si vous venez d'un terrain de jeu axé sur les
objets, cela devrait être simple. Ensuite, vous le verrez
sur la ligne numéro sept ainsi que sur la ligne numéro 13. Vous pouvez utiliser le même
type de syntaxe pour déclarer des fonctions sur
l'instance elle-même. Numéro sept en ligne, nous
déclarons la fonction de classe. Vous pouvez ensuite
l'utiliser pour accéder aux autres membres de
la même instance. Donc, en utilisant ce point
other class function, nous appelons une autre fonction de
classe et invoquons dans la fonction de
classe. Ensuite, il y a le mot clé statique. Encore une fois, si vous venez d'une formation en
programmation orientée
objet, cela devrait être assez
simple. Vous utilisez donc le
mot clé statique et vous pouvez déclarer des propriétés ainsi que des
fonctions sur le nom de ma classe. Et ceux-ci, bien sûr,
sont liés à la classe et non à une instance
de la classe. À la ligne 17,
nous déclarons une
propriété statique de chaîne de HelloWorld. Et en ligne numéro 19, nous ne faisons que créer
une fonction statique. Et comme dans la plupart des langages
orientés objet, vous pouvez créer une
instance d'une classe en
utilisant le nouveau numéro en ligne 26. Nous parlons de l'instance de
ma classe de variable, et vous créez
une instance de mon nom de classe en utilisant know my class name et en transmettant
les paramètres du constructeur. Puis sur mon instance de classe. Vous pouvez appeler des éléments tels que
la fonction de
classe ou une autre fonction de classe car ils appartiennent à une instance
de la classe. C'est donc essentiellement
tout pour les cours. Encore une fois, il s'agit d'un aperçu
assez basique
et rapide syntaxe des classes, juste pour que
vous sachiez ce que cela signifie. Il y en a certainement beaucoup
plus dans la documentation. Cependant, parce
qu'ils ne sont pas utilisés très souvent et que les gens ont tendance à préférer les objets plutôt
que les fonctions pures. Nous ne passons pas beaucoup de
temps à suivre les cours. Voici quelques exercices. Commencez par créer un élément de liste
de tâches pour la classe. Ce numéro un porte le nom d'une propriété de chaîne créée par le constructeur. ajout d'une propriété
est également terminé, ce qui est faux lorsque vous créez une instance
d'un élément de liste de tâches. Vous pouvez donc attribuer à ce point est terminé la valeur false
dans le constructeur. Ajoutez également une fonction sur l'
instance appelée Mark done. Après avoir marqué comme terminé, la modification est
terminée sur l'instance Vous devez
donc utiliser ce
point si la valeur true est terminée, puis créer une fonction statique
appelée propriétés du journal. Rappelez-vous donc que vous devrez
utiliser le mot clé statique ici. J'ai pris un
élément de liste de tâches comme paramètre
et j' ai enregistré les propriétés
en utilisant ce nom de modèle. Ajoutez ensuite le nom
et c'est terminé, puis ajoutez si
c'est terminé. Numéro deux. Maintenant, avec votre nouvel élément de liste de tâches de
classe, créez une instance
des éléments que vous devez utiliser les mots-clés CONST ou
let créez une instance appelée todo item et donnez-lui le
nom de wash the dishes. Essayez ensuite d'utiliser la propriété
statique ou la fonction statique des propriétés du
journal des
tâches pour enregistrer cet élément et voir si
c'est ce que vous attendez, puis essayez d'appeler mark
terminé sur l'instance. Vous l'appelez
donc sur un élément de la liste des tâches à faire et
non sur un élément de la liste des
tâches de la classe. Utilisez ensuite les propriétés du journal, la fonction statique
pour enregistrer l'instance. Encore une fois, après que Mark ait terminé sa course. C'est tout pour celui-ci, les gars. Et c'est la fin
du cours. Une autre vidéo
passera en revue le
projet final. Alors je vous y verrai.
16. Examen de projet du cours: Salut les gars. Dans cette vidéo, nous allons passer en revue le projet final. Le projet consiste à créer des
listes de tâches dans TypeScript. Définissons-la donc d'abord pour
créer une tâche d'
interface afin de spécifier la
structure d'une tâche. Et j'ai donné quelques
détails ici pour
les différents champs
de l'élément à faire. La section suivante vous demande d'
ajouter quelques fonctions utilitaires. Créez donc un identifiant de tâche, qui génère l'
identifiant approprié de l'élément de la liste de tâches, ainsi que create to do, qui le reprendra, ainsi que
les paramètres inutiles , et
vous donnera un élément de tâche. On l'appelle donc
alternativement fonction d' usine ou fonction
constructeur. Ensuite, nous allons
créer un type de liste de tâches, qui est simplement un
tableau d'éléments de tâches. Nous allons définir
certaines fonctions qui fonctionnent sur cette
liste de tâches à faire
et à effectuer. Une fois
ces fonctions terminées, nous examinons un
scénario dans lequel
vous pouvez tester vos fonctions. Ils sont donc listés ici à
la fin du document. À la toute fin, je
vous demande d'essayer de créer une
nouvelle liste qui n'
inclue pas toutes les tâches que vous avez effectuées dans le
cadre de vos petits tests
tout au long de l'exercice. Essayez de vous déconnecter de la liste
après chaque opération
pour vous assurer que ce que vous pensez que votre code
fait bien ce qu'il fait. Essayez cet exercice. Dites-moi ce que vous
trouvez et je serai toujours heureuse de
répondre à vos questions. Dans la vidéo suivante,
nous allons passer en revue un exemple de solution pour
ce projet de conclusion. Je t'y verrai.
17. Solution de projet de cours: Salut les gars, Dans cette dernière vidéo, nous allons passer en revue un exemple de
solution pour le projet. Donc, par souci de brièveté, j'omets tous les journaux de
la console ainsi que le code de test. Et en passant en revue les
fonctions de base qu'il vous est
demandé de mettre en œuvre
dans le cadre du projet final. Nous allons donc d'abord créer une
interface appelée todo item. Le nom de l'identifiant de ces champs créé dans un champ de
description facultatif, ainsi que dans le champ
rempli. Nous lisons quelques fonctions utilitaires. Le premier est créé do id, et nous utilisons ici une
interpolation de chaîne en
insérant le nom
ainsi que le créé. À. Ensuite, nous créons une
fonction d'usine ou de constructeur appelée create. Pour ce faire, il suffit de
prendre un nom et description, car nous avons
créé par défaut ce point à ce jour, ce qui vous donnera essentiellement les millisecondes Unix
depuis le 1er janvier 1970. Il s'agit donc d'un chiffre
indiquant le nombre de millisecondes qui se sont écoulées
depuis cette période spéciale. Nous pouvons ensuite appeler notre autre fonction
util create todo id. Pour créer l'identifiant,
nous allons transmettre le nom et la description
directement à l'objet, ainsi que Created,
car nous avons déjà créé
cette constante ici. Bien sûr, c'est terminé, valeur par défaut
sera False lorsque
vous créerez une tâche pour la première fois. Ensuite, nous définissons un
type de liste de tâches, qui est simplement un
tableau d'éléments de tâches. Ensuite, nous avons nos trois fonctions qui fonctionnent sur une liste de tâches. La première est donc l'attitude, qui créera une nouvelle liste. Et ce que nous faisons, c'est utiliser
l'opérateur de propagation. Cela met essentiellement
tous les éléments de la liste de tâches existante, le nouveau tableau que
nous déclarons. Et puis nous ajoutons le
nouveau todo en haut. Ensuite, pour remove to do, nous utilisons la
fonction de filtre et nous passons ici une fonction de rappel, ou bien
une fonction flèche. Parce que le filtre inclura tous les éléments pour lesquels cette
fonction renvoie la valeur true. Nous voulons inclure tous les todos dont l'identifiant ne correspond
pas à cet identifiant. Ainsi, le seul cas où le filtre
supprimera un élément de la liste des tâches est lorsque l'identifiant de tâche correspond à l'
identifiant que nous voulons supprimer. filtre
nous donne en fait un nouveau tableau. Cela ne modifie pas la liste de tâches
existante. Nous disons donc qu'il
renvoie une nouvelle liste via l'annotation de
type TypeScript ainsi que le commentaire. Enfin, nous avons tout ce qu'il nous reste à faire. Nous utilisons la
fonction find sur le tableau. Et l'amende prend en charge
une autre fonction de rappel. Et ce rappel devrait renvoyer vrai » si c'est ce que
nous recherchons. Nous cherchons donc à utiliser un identifiant strictement égal à l'identifiant que
nous voulons trouver. Donc, si nous avons trouvé
cette tâche, souvenez-vous que si rien n'est trouvé, bien reviendra
indéfini, ce qui est faux. Donc, si ce n'est pas faux, donc ce n'est pas indéfini, alors nous avons fondé
pour faire et ensuite nous pouvons
passer à vrai. Enfin, à la fin
de l'exercice, je vous demande de
créer une nouvelle liste en supprimant toutes les
tâches terminées de la liste des tâches. En fait, j'ai écrit une fonction pour cela appelée remove
completed pour le faire encore une fois, nous utilisons une fonction de filtre ici. N'oubliez pas que la fonction transmise
dans le paramètre à filtrer doit renvoyer
true si nous voulons inclure l'élément dans
le tableau résultant. Et true renvoie false si nous
voulons exclure cet élément. Nous voulons donc exclure tous les éléments
déjà terminés. S'il est déjà terminé, nous voulons renvoyer faux et faux signifie que
nous voulons l'exclure. Donc, si nous voulons l'
inclure dans une tâche, c'est essentiellement l'inverse de savoir si la tâche est terminée. Donc, s'il n'est pas terminé, il est considéré comme faux. Nous l'inversons avec ce
point d'exclamation. Faux, l'inverse est vrai, et cela signifie que nous
voulons l'inclure. Si x2 est terminé, l'inverse
de vrai est faux. Cette
fonction de filtre donnera donc faux, ce qui signifie que l'élément ne
sera pas inclus dans la liste de tâches
résultante. Et c'est à peu près tout. Vous pouvez utiliser pratiquement toutes
ces fonctions dans
votre code de test. Et puis essayez d'enregistrer le
résultat de chaque opération. Et vous devriez être
en mesure de voir que le code s'exécute comme
prévu. Merci beaucoup les gars d'
avoir suivi le cours. J'espère que vous avez
beaucoup appris sur JavaScript, TypeScript et
la programmation en général. J'espère vous voir
lors d'un prochain cours. Prends soin de toi.