Types et portée

Introduction

Les variables permettent de manipuler les données au sein d'un programme. Chaque variable est ainsi un emplacement mémoire utilisé pour stocker une valeur qui pourra subir différentes opérations. Au delà des opérations de base que vous connaissez, il est possible de réaliser des opérations plus complexes, comme le changement de type d'une variable. De plus une variable n'est pas forcément utilisable pendant la totalité de l'exécution du programme. Selon la manière d'écrire le code source, il sera possible de n'utiliser une variable que durant une partie du programme, et de libérer ensuite l'espace mémoire utilisé. Les variables nous réservent donc encore de nombreux secrets.

Types de données

Objectif

Découvrir les différents types de données.

Mise en situation

Pour manipuler et traiter des données, on associe un type à chacune d'entre elles. Un ordinateur ne traite que des informations binaires, toutes les données sont donc converties en suite de 0 et de 1. Comment dans ce cas différencier une lettre d'un nombre ou un booléen d'une suite de caractères ? Grâce aux types de données. Celui-ci va permettre de définir de quelle manière doivent être réalisées les opérations sur les données. En effet ajouter 2 nombres ne se fait pas de la même manière que la concaténation de 2 chaînes de caractères.

Définition : Type de donnée

Une donnée peut être un nombre, un caractère, une suite de caractères, etc.

Le type d'une donnée, c'est donc la catégorie que le programme va associer à celle-ci. Le type détermine la place occupée en mémoire par la donnée, les traitements possibles sur celle-ci ou le comportement d'un opérateur.

Définition : Les types principaux

En JavaScript les types principaux sont :

les nombres (entiers ou flottants) number,
les chaînes de caractères string
et les booléens bool.

En Python les types principaux sont :

les nombres entiers int,
les nombres flottants (c'est à dire les nombres à virgule) float,
les chaînes de caractères str
et les booléens bool.

Méthode : Connaître le type

En JavaScript la fonction typeof() permet de connaître le type d'une variable.

En Python il s'agit de la fonction type().

Exemple :

/** Javascript */
let word = 'Hello'
let value = 42
console.log(typeof(word))
console.log(typeof(value))

Ce programme affiche :

string
number

Exemple : Comportement de l'opérateur + selon le type de données

L'opérateur + peut être utilisé avec des nombres ou avec des chaînes de caractères, son comportement dépend justement du type de données manipulées.

/** JavaScript */
const number1 = 1
const number2 = 4
const letter1 = '1'
const letter2 = '4'
console.log(number1 + number2)
console.log(letter1 + letter2)

"""Python."""
number1 = 1
number2 = 4
letter1 = '1'
letter2 = '4'
print(number1 + number2)
print(letter1 + letter2)

Ces deux programmes retournent :

5
14

Les variables number1 et number2 ont été additionnées avec l'opérateur + alors que les variables letter1 et letter2 ont été concaténées avec le même opérateur, parce que les données number1 et number2 ne sont pas de même type que les données letter1 et letter2 (type number et type string en JavaScript).

Avec des données de type booléen, l'opérateur + correspond à l'opération logique ou.

Complément : typeof

/** Javascript */
let word = 'Hello'
console.log(typeof(word))
console.log(typeof word)

Complément : D'autres types de données

Il existe d'autres type de données comme les tableaux ou les objets.

Un tableau est une collection de variables type quelconque, rangées les unes à la suite des autres dans la mémoire.

Les tableaux sont en général utilisés pour stocker et traiter des données de même nature.

Dans l'exemple suivant le tableau temp contient des températures, les températures sont séparées par des virgules.

"""Python."""
temp = [21, 24, 18, 19]

/** JavaScript */
const temp = [21, 24, 18, 19]

À retenir

Le type d'une donnée correspond à la catégorie de cette donnée (nombre, chaîne de caractères, etc.), ce type indique au programme comment il doit manipuler et traiter celle-ci.

Appliquer la notion

Afficher le résultat de l'opération + entre une variable nbStrawberries de type number (valeur 4) et une variable type de type string (valeur gariguettes).

/** JavaScript */
const nbStrawberries = 4
const type = ' gariguettes'
const sentence = nbStrawberries + type
console.log(sentence)

Le programme affiche « 4 gariguettes ». Ne pouvant additionner un nombre avec une chaîne, il les a concaténé avec l'opérateur +.

Afficher le résultat de l'opération + entre une variable boolean de type bool (valeur true) une variable nb de type number (valeur 16).

/** JavaScript */
const boolean = true
const nb = 16
console.log(boolean + nb)

Le programme affiche « 17 », ce qui correspond à l'addition du nombre 1, associé à un booléen true, contenu dans boolean et du nombre 16 contenu dans nb.

Afficher le résultat de l'opération + entre une variable boolean de type bool (valeur true) une variable word de type string (valeur magic).

/** JavaScript */
const boolean = true
const word = ' magic'
console.log(boolean + word)

Le programme affiche « true magic », ce qui correspond à la concaténation de boolean et de word.

Conversion de type (cast)

Objectif

Apprendre à convertir des données d'un type vers un autre.

Mise en situation

Comment changer le type d'une donnée ?

Chaque donnée a un type qui détermine quels traitements sont possibles et comment un même opérateur agit sur sur cette donnée. Cependant on peut avoir besoin de changer le type d'une donnée, par exemple si l'on veut effectuer des traitements incompatibles avec le type initial. Imaginons que nous avons un nombre que l'on souhaite ajouter dans une chaîne de caractères, pour l'intégrer à une phrase. Il n'est pas possible d'additionner un nombre avec du texte, mais en convertissant ce nombre en une chaîne de caractères, il devient possible de concaténer nos 2 chaînes de caractères.

Définition : Conversion en chaîne de caractères

En JavaScript la méthode String() permet de convertir des nombres ou des booléens en chaînes de caractères.

En Python il s'agit de la méthode str().

Exemple :

"""Python."""
number = 25
number = str(number)

/** JavaScript */
let number = 25
number = String(number)

Définition : Conversion en nombre

En JavaScript la méthode Number() permet de convertir des chaînes de caractères ou des booléens en nombres.

En Python il s'agit de la méthode int() si on veut faire une conversion vers un nombre entier et float() si on veut faire une conversion vers un nombre flottant.

Exemple :

"""Python."""
word_1 = '3.26'
word_1 = float(word_1)
word_2 = '426'
word_2 = int(word_2)

/** JavaScript */
let word = '3.26'
word = Number(word)

Remarque :

Les méthodes de conversion de type fonctionnent de la même manière avec des booléens.

La conversion d'un booléen true vers un nombre renvoie 1, celle d'un booléen false vers un nombre renvoie 0.

Appliquer la notion

Déclarer une variable nbBirds initialisée à 325 et utiliser la conversion de type pour afficher le nombre des centaines de la variable (c'est à dire 3).

Il faut convertir la variable en chaîne de caractères.

Le numéro de centaine est le premier caractère de 325. On peut accéder à un caractère d'une chaîne avec la syntaxe variable[indice], les indices commençant à 0.

/** JavaScript */
let nbBirds = 325
nbBirds = String(nbBirds)
console.log(nbBirds[0])

On convertit la variable de type number en type string pour pouvoir accéder à chaque caractère.

La programme suivant n'affiche pas la somme du nombre d'oranges et du nombre de bananes.

Modifiez-le afin que ce soit bien le cas, sans changer les variables nbOranges et nbBananas.

/** JavaScript */
const nbOranges = '47'
const nbBananas = '31'
const nbFruits = nbOranges + nbBananas
console.log(nbFruits)

/** JavaScript */
const nbOranges = '47'
const nbBananas = '31'
const nbFruits = (Number(nbOranges) + Number(nbBananas))
console.log(nbFruits)

On convertit le nombre d'oranges et le nombre de bananes puis on les additionne, nbOranges et nbBananas ne sont pas modifiées.

Déclaration préalable des variables

Objectifs

Savoir déclarer une variable avec ou sans affectation ;
Savoir à quoi correspond la valeur undefined.

Mise en situation

Lors du développement d'un programme, le développeur est en charge de définir les variables à utiliser, les déclarer ainsi que leurs types, et leur affecter des valeurs. L'étape de déclaration d'une variable est primordiale : il n'est pas possible d'utiliser une variable si elle n'a pas été déclarée au préalable. En effet, puisque une variable permet de réserver de l'espace mémoire pour la valeur à stocker, l'ordinateur ne pourra rien stocker si la variable n'a pas été déclarée. De plus dans certains langages, c'est lors de la déclaration que le type de la variable est déterminée.

Définition : Déclarer une variable

Déclarer une variable c'est indiquer au compilateur ou à l’interpréteur qu'il doit réserver un emplacement mémoire pour que le programmeur puisse y stocker une donnée.

En Python il est obligatoire d'initialiser une variable lors de sa déclaration. Mais d'autres langages comme le JavaScript permettent de déclarer une variable sans l'initialiser.

Cependant il est préférable d'initialiser une variable lors de sa déclaration afin de s'assurer de la valeur que contient la variable.

Exemple :

"""Python."""
apples = 10

/** JavaScript */
let apples
apples = 10

Attention :

On ne peut pas utiliser une variable qui n'a pas été préalablement déclarée.

De plus, une constante doit être initialisée lors de sa déclaration.

Remarque :

JavaScript associe un type à une variable en fonction de la valeur associée, en l'absence de valeur associée (ce qui est le cas lors d'une déclaration sans initialisation), la variable ne peut prendre que le type undefined. Ici, dans le programme en JavaScript, lorsqu'on déclare la variable apples sans l'initialiser elle prend automatiquement le type undefined.

À retenir

Pour pouvoir utiliser une variable, il faut la déclarer au préalable.

Lors de sa déclaration, il est parfois indispensable de l'initialiser (en Python par exemple) mais même si ce n'est pas obligatoire c'est fortement recommandé car beaucoup plus sûr.

Appliquer la notion

Déclarer une variable potatoes sans l'initialiser, afficher sa valeur et afficher son type.

/** JavaScript */
let potatoes
console.log(potatoes)
console.log(typeof(potatoes))

La valeur de potatoes est undefined et le type de potatoes est « undefined ».

Déclarer une variable potatoes sans l'initialiser, afficher sa valeur et afficher son type, affecter la valeur 15 à potatoes, afficher sa valeur et son type.

Il faut compléter le programme précédent.

/** JavaScript */
let potatoes
console.log(potatoes)
console.log(typeof(potatoes))
potatoes = 15
console.log(potatoes)
console.log(typeof(potatoes))

Avec l'affectation, potatoes prend le type number et peut être utilisée sans risque d'incohérence de type.

Portée des variables

Objectif

Comprendre la notion de portée locale et de bloc de définition.

Mise en situation

Un programme est séparé en blocs afin d'être plus lisible. Par exemple si on veut écrire un programme qui affiche une suite de nombres puis qui calcule leur somme, on peut séparer le programme en deux parties : deux blocs, qui ont chacun leurs variables. En effet chaque variable ne sera utilisable que dans le bloc de code où elle a été définie. On appelle portée d'une variable la zone de code dans laquelle une variable sera définie et utilisable.

Définition : Portée d'une variable

Lorsqu'on définit une variable elle est associée au bloc où elle se trouve et n'est visible que dans celui-ci. On parle de portée locale.

Cela signifie qu'il est impossible d'afficher ou d'utiliser cette variable dans un autre bloc : elle n'existe tout simplement pas.

Si une variable est déclarée dans le bloc principal (c'est à dire en dehors de toute boucle ou fonction) elle est visible dans toute la partie du programme située après sa déclaration.

Exemple :

Dans le programme suivant la variable numberApple est visible dans tout le programme y compris dans le bloc if.

En revanche la variable enoughApple est déclarée dans le bloc if, donc visible uniquement dans celui-ci.

La dernière instruction génère donc une erreur.

/** JavaScript */
const numberApple = 30
console.log(numberApple)
if(numberApple === 30) {
  let enoughApple = true
  console.log(enoughApple)
}
console.log(enoughApple)

Remarque :

La portée des variables fonctionne de la même manière avec d'autres boucles ou dans des fonctions.

Une variable définie dans une fonction n'est visible que dans celle-ci.

À retenir

En fonction du bloc où sont déclarées les variables, elles n'ont pas la même portée et ne sont donc pas visibles et utilisables dans la même partie du programme.

Appliquer la notion

Programme exemple

/** JavaScript */
const numberApple = 30
console.log(numberApple)
if(numberApple === 30) {
  let enoughApple = true
  console.log(enoughApple)
}
console.log(enoughApple)

Réécrire le programme exemple afin qu'il ne génère pas d'erreur.

Il faut modifier la portée de la variable enoughApple.

/** JavaScript */
const numberApple = 30
let enoughApple = false
console.log(numberApple)
if(numberApple === 30) {
  enoughApple = true
  console.log(enoughApple)
}
console.log(enoughApple)

On déclare la variable enoughApple avant la boucle if, de façon à ce qu'elle soit visible pour celle-ci.

Voici une modification du programme précédent. Qu'affiche le programme ? Pourquoi ?

/** JavaScript */
const numberApple = 30
let enoughApple = false
console.log(numberApple)
if(numberApple === 30) {
  let enoughApple = true
  console.log(enoughApple)
}
console.log(enoughApple)

Le programme affiche « true » puis « false » car il affiche d'abord la variable enoughApple qui est déclarée dans la boucle if, puis celle qui est déclarée au début du programme, qui sont deux variables différentes avec deux portées différentes.

Cet exemple illustre que deux variables avec le même nom peuvent référencer deux valeurs différentes, si leur portée est différente.

Variables globales

Objectifs

Savoir ce que sont et à quoi servent les variables globales ;
Adopter les bonnes pratiques.

Mise en situation

Les variables ont généralement une portée locale, c'est à dire qu'elles ne sont accessibles que dans le bloc de code où elles ont été définies. C'est la plupart du temps largement suffisant, mais il peut arriver d'avoir besoin d'une variable soit accessible dans la totalité du programme. Par exemple une variable qui contiendrait une information de configuration régulièrement utilisé à des endroits très différents du code. Pour cela, il est possible d'utiliser une variable de portée globale, qui ne sera donc pas limitée de la même manière qu'une variable locale.

Définition : Variable globale en JavaScript

En JavaScript, on définit habituellement une variable avec let nameV = value.

En remplaçant le mot-clé let par le mot-clé var on change la portée de la variable.

La variable aura une portée globale et sera donc visible dans toute la partie du programme située après sa définition.

En Python le mot-clé global, suivi du nom de la variable indique que la variable à utiliser a été préalablement définie dans un autre bloc du programme et que c'est cette variable qu'il faut modifier.

Exemple :

/** JavaScript : programme erroné */
const numberApple = 30
console.log(numberApple)
if(numberApple === 30)
{
  let enoughApple = true
  console.log(enoughApple)
}
console.log(enoughApple)

L’exécution de ce programme renvoie une erreur car la dernière instruction fait référence à une variable qui n'existe pas : enoughApple est locale au bloc if.

/** JavaScript  : programme corrigé */
const numberApple = 30
console.log(numberApple)
if(numberApple === 30)
{
  var enoughApple = true
  console.log(enoughApple)
}
console.log(enoughApple)

Si on remplace let par var dans la définition de enoughApple, il n'y a plus d'erreur car la variable est visible hors de la boucle if.

Ce code fonctionne, mais c'est une mauvaise pratique !

Attention : À consommer avec modération

Les variables globales sont source de nombreux problèmes.

En effet, une variable déclarée globale pourra être modifiée dans n'importe quelle autre partie du programme, ce qui peut provoquer des erreurs difficiles à détecter, comme l'écrasement inattendu de la valeur d'origine (on appelle cela un effet de bord).

Il est recommandé de ne jamais utiliser de variables globales par défaut, et de les utiliser avec parcimonie uniquement dans des cas bien identifiés.

Complément :

Si on veut inverser la valeur de deux variables avec une fonction, on peut utiliser des variables globales (mais ce n'est pas une bonne façon de faire).

"""Python."""
fruit_1 = ' pear '
fruit_2 = ' pineapple '
def inversion():
    global fruit_1
    global fruit_2
    temp = fruit_2
    fruit_2 = fruit_1
    fruit_1 = temp
print(fruit_1 + fruit_2)
inversion()
print(fruit_1 + fruit_2)

Le programme affiche « pear pineapple » puis « pineapple pear ».

À retenir

Il est possible de créer des variables dont la portée s’étend au delà de leur bloc de définition, avec le mot-clé var en JavaScript et le mot-clé global en Python, il s'agit des variables globales. Cependant il est recommandé de les utiliser avec prudence car cela peut provoquer des résultats inattendus.

Appliquer la notion

Que se passe-t-il si on définit dans une boucle if une variable locale portant le même nom qu'une variable globale déjà déclarée préalablement ?

Expliquez à partir de l'exécution du code suivant :

/** JavaScript */
var numberApple = 30
var enoughApple = false
console.log(numberApple)
if(numberApple === 30)
{
  let enoughApple = true
  console.log('A-t-on assez pommes ? (dans le "if")', enoughApple)
}
console.log('A-t-on assez pommes ? (en dehors du if)', enoughApple)

Une variable enoughApple est d'abord définie comme globale et initialisée avec false.
Ensuite une autre variable enoughApple est définie localement au bloc if : elle porte le même nom, mais c'est une autre case mémoire qui est utilisée. Elle est initialisée avec valeur true, dans ce bloc la première variable n'est pas accessible, donc la valeur affichée est bien true.
Le second affichage de enoughApple est demandé en dehors du bloc if, la variable enoughApple locale n'existe plus et c'est bien la variable globale, qui vaut toujours false, qui est retournée.

Faut-il obligatoirement initialiser une variable globale (comme pour les constantes), ou est-il possible de les déclarer sans les initialiser (comme pour les déclarations utilisant let) ? Essayez.

Il est possible de déclarer une variable globale sans l'initialiser (mais ce n'est pas recommandé) qui prendra la valeur undefined jusqu'à ce qu'elle soit affectée.

/** JavaScript */
var numberApple = 30
var enoughApple
console.log(numberApple)
if(numberApple === 30)
{
  let enoughApple = true
  console.log('A-t-on assez pommes ? (dans le "if")', enoughApple)
}
console.log('A-t-on assez pommes ? (en dehors du if)', enoughApple)

Qu'affiche le programme suivant ?

/** JavaScript */
console.log(flowers)
var flowers = 25

Le programme va afficher undefined, car la variable flowers a une portée globale mais seulement à partir de la ligne où elle est définie. En attendant, elle est bien indéfinie.

Quiz

Quiz - Culture

Qu'affiche le programme suivant ?

/** JavaScript */
const number = 3.14
const conversion = String(number)
console.log(conversion[2])

undefined

Quelle est la portée d'une variable déclarée dans une boucle ?

locale

globale

L'usage de variables globales... :

permet d'avoir accès à la variable dans tous les blocs du programme

peut provoquer des effets de bord

est déconseillé en général

Quiz - Méthode

Quelle est la meilleure façon de déclarer une variable nbDogs et de lui affecter la valeur 3 ?

var nbDogs = 3

var nbDogs

nbDogs = 3

let nbDogs =3

let nbDogs

nbDogs = 3

Quelle instruction permet de déclarer une variable contenant la caractère 1 ?

let letter = 1

let character = 1

let num = '1'

Quiz - Code

Comment convertir nbBananas, une chaîne de caractères valant '3415', en un nombre, en JavaScript ?

nbBananas = Number(nbBananas)

nbBananas.Number()

int(nbBananas)

nbBananas.int()

Soit le programme :

/** JavaScript */
let f = false
console.log('Boolean : ', f)
console.log('String : ', String(f))
console.log('Number : ', Number(f))

Compléter le résultat de son exécution :

Boolean : false

String : 'false'

Number : 0

Qu'affiche le programme suivant ?

/** JavaScript */
const numberApple = 30
let enoughApple = false
if(numberApple === 30)
{
  let enoughApple = true
}
console.log(enoughApple)

true

false

Qu'affiche le programme suivant ?

/** JavaScript */
const bool1 = false
const bool2 = false
const res = bool1 + bool2
console.log(res)

falsefalse

Qu'affiche le programme suivant ?

/** JavaScript */
const word = 'bonjour'
const number = 126458
console.log(word[2])
console.log(number[2])

undefined

Quiz - Culture

undefined

La fonction de conversion String permet de convertir le nombre 3.14 en chaîne puis de retourner un des caractères de la chaîne. Ici le caractère numéro 2, donc le troisième (le premier indice est l'indice 0).

Quelle est la portée d'une variable déclarée dans une boucle ?

locale

globale

La variable ne sera visible que dans la boucle, elle est donc de portée locale.

L'usage de variables globales... :

permet d'avoir accès à la variable dans tous les blocs du programme

peut provoquer des effets de bord

est déconseillé en général

Quiz - Méthode

Quelle est la meilleure façon de déclarer une variable nbDogs et de lui affecter la valeur 3 ?

var nbDogs = 3

var nbDogs

nbDogs = 3

let nbDogs =3

let nbDogs

nbDogs = 3

Il est préférable de ne pas utiliser var et d'initialiser une variable lors de sa déclaration.

Remarque : si nbDogs n'a pas besoin d'être modifié dans la suite du programme il vaut mieux le déclarer en tant que constante const nbDogs = 3.

Quelle instruction permet de déclarer une variable contenant la caractère 1 ?

let letter = 1

let character = 1

let num = '1'

Ce sont les apostrophes (simple quotes) qui indique que la variable est un caractère et non un nombre.

Le nom de la variable n'influence pas le type, il améliore la lisibilité et la compréhension du programme.

Ici letter et character sont de type number, alors que num est de type string.

Quiz - Code

Comment convertir nbBananas, une chaîne de caractères valant '3415', en un nombre, en JavaScript ?

nbBananas = Number(nbBananas)

nbBananas.Number()

int(nbBananas)

nbBananas.int()

En JavaScript on utilise la méthode Number(), qui prend comme argument la variable à convertir.

Boolean : false

String : 'false'

Number : 0

La fonction String renvoie une chaîne de caractères.
La fonction Number renvoie un entier, et c'est 0 qui correspond à false.

true

false

Dans la boucle if on a défini une variable enoughApple qui vaut true, mais il existait déjà une variable enoughApple qui vaut false, définie en dehors de la boucle.

C'est donc celle ci qui est affichée.

falsefalse

bool1 et bool2 sont de type booléen, l'opérateur + va donc faire une opération logique (l'opération OU).

L’opération OU renvoie un booléen true (1) si au moins 1 des booléens est vrai sinon elle renvoie un booléen false (0).

Ici bool1 et bool2 sont false, le résultat est donc false et le programme affiche 0.

undefined

Il est possible d'accéder au i-ème d'une chaîne grâce à strName[i].

En revanche il n'est pas possible de faire la même chose avec une donnée de type number, ce qui produit une valeur undefined.

Les indices commencent à 0, word[2] correspond donc au 3^e caractère de word, donc à la lettre n.

Défi

Julie est fleuriste. Elle reçoit chaque jour plusieurs milliers de fleurs.

Elle a besoin de les trier et de savoir quel genre de bouquets elle pourra faire.

Julie a reçu 1 478 roses, elle peut les transformer en gros bouquets (100 roses), en bouquets moyens (30 roses), en petits bouquets (10 roses) ou vendre les roses à l'unité.

Julie voudrait faire le maximum de bouquets et les plus gros possibles. Calculer le nombre de gros bouquets réalisables.

Le nombre de gros bouquets correspond au nombre de centaines de roses reçues. Ce nombre correspond aux deux premiers caractères du nombre de roses. Une conversion serait utile...

Il est possible de récupérer la sous-chaîne contenant les deux premiers caractères d'une chaîne str avec la syntaxe str.substring(0, 2). Les indices commencent à 0.

Comme le numéro des centaines se trouve toujours au troisième caractère en partant de la fin, il est plus pertinent d'utiliser la syntaxe str.substring(0, str.length - 2), qui s'adaptera à plusieurs dizaines de milliers de roses.

On convertit le nombre de roses en chaîne pour pouvoir accéder à chacun de ses chiffres, puis on calcule le nombre de centaines, donc le nombre de gros bouquets, et on le convertit en nombre.

let nbRoses = 1478
nbRoses = String(nbRoses) 
let nbHundreds = nbRoses.substring(0, nbRoses.length - 2) 
nbHundreds = Number(nbHundreds)

Julie voudrait ensuite savoir combien de dizaines de bouquets il lui reste. Calculer ce nombre.

Il faut récupérer le nombre de dizaines restantes, les centaines ayant déjà été prises en compte. Le nombre de dizaines se situe toujours à l'avant dernière caractère. On peut y accéder avec la syntaxe [].

Le dernier caractère d'une chaîne str se situe à l'indice str.length - 1. Donc pour l'avant dernier caractère.

On calcule le nombre de dizaines qui permettra de calculer le nombre de petits et de moyens bouquets, et on le convertit en nombre.

let nbTens = nbRoses[nbRoses.length - 2] 
nbTens = Number(nbTens)

À partir du nombre de dizaines de roses, calculer le nombre de bouquets moyens et le nombre de petits bouquets que Julie peut réaliser.

Les bouquets moyens sont composés de 30 roses, et sont prioritaires par rapport aux petits bouquets.

La fonction Math.floor(nombre) permet d'arrondir le résultat d'une division.

On calcule le nombre de bouquets moyens en retirant le maximum de groupes de 30 fleurs, puis on calcule le nombre de petits bouquets.

let nbMedium = (nbTens * 10) / 30
nbMedium = Math.floor(nbMedium) 
const nbSmall = nbTens - nbMedium * 3

Il est possible qu'à ce stade, il reste des roses ne pouvant pas être incluses dans un bouquet. Récupérer le nombre de roses restantes.

Comme un bouquet est composé d'au moins 10 roses, le nombre de roses restant est celui des unités, à savoir le dernier chiffre du nombre.

On récupère le dernier chiffre du nombre de roses total, donc le nombre de roses restantes, et on le convertit en nombre.

let nbUnities = nbRoses[nbRoses.length - 1] 
nbUnities = Number(nbUnities)

Afficher le nombre de bouquets de chaque catégorie ainsi que le nombre de roses restant. Quels résultats obtient-on ?

console.log('Nombre de gros bouquets: ' + nbHundreds)
console.log('Nombre de gros bouquets moyens : ' + nbMedium)
console.log('Nombre de petits bouquets: ' + nbSmall)
console.log("Nombre de roses vendues à l'unité: " + nbUnities)

Julie pourra concevoir :

14 gros bouquets
2 bouquets moyens
1 petit bouquet
8 roses vendues à l'unité

Types et portée des variables

Introduction

Types de données

Objectif

Mise en situation

Définition : Type de donnée

Définition : Les types principaux

Méthode : Connaître le type

Exemple :

Exemple : Comportement de l'opérateur + selon le type de données

Complément : typeof

Complément : D'autres types de données

À retenir

Appliquer la notion

Conversion de type (cast)

Objectif

Mise en situation

Définition : Conversion en chaîne de caractères

Exemple :

Définition : Conversion en nombre

Exemple :

Remarque :

Appliquer la notion

Déclaration préalable des variables

Objectifs

Mise en situation

Définition : Déclarer une variable

Exemple :

Attention :

Remarque :

À retenir

Appliquer la notion

Portée des variables

Objectif

Mise en situation

Définition : Portée d'une variable

Exemple :

Remarque :

À retenir

Appliquer la notion

Programme exemple

Variables globales

Objectifs

Mise en situation

Définition : Variable globale en JavaScript

Exemple :

Attention : À consommer avec modération

Complément :

À retenir

Appliquer la notion

Quiz

Quiz - Culture

Quiz - Méthode

Quiz - Code

Quiz - Culture

Quiz - Méthode

Quiz - Code

Défi