web-dev-qa-db-fra.com

Javascript: différence entre un énoncé et une expression?

J'ai posé une question this plus tôt, et après avoir réfléchi un peu plus au sujet, j'ai commencé à me demander où se situe la frontière apparemment floue entre les significations des termes "déclaration" et "expression". Toutes les déclarations sont-elles également des expressions? D'où viennent les valeurs de retour dans une console REPL? Elles ne semblent pas toujours avoir un sens intuitif. Bien sûr, si vous tapez 1+1, Vous obtiendrez 2, Mais d'autres fois, la logique n'est pas aussi évidente.

Étant donné que tout ce qui est entré dans REPL produit une valeur , cela signifie-t-il qu'il peut être utilisé dans le code source JS comme à la fois une expression et une déclaration autonome?

une chaîne de code pouvant être utilisée pour _X_ dans l'extrait de code suivant peut-elle également être utilisée pour _Y_ et vice versa? if(_X_) _Y_

javascriptexpressionterminologysemantics
52
wwaawaw

Toutes les déclarations sont-elles également des expressions?

"Partout où JavaScript attend une déclaration, vous pouvez également écrire une expression. Une telle instruction est appelée instruction d'expression. L'inverse ne tient pas: vous ne pouvez pas écrire une instruction où JavaScript attend une expression. Par exemple, une instruction if ne peut pas devenir l'argument d'une fonction. "

Ceci provient d'un récent article d'Axel Rauschmayer sur ce sujet: Expressions versus instructions en JavaScript

J'espère que cela aide.

37
ZER0

Selon MDN :

Une expression est une unité de code valide qui se résout en une valeur.

En tant que tel, tout ce qui peut être utilisé comme valeur r est une expression.

Le critère est pas si des effets secondaires existent. Les expressions peuvent certainement avoir des effets secondaires. Par exemple. a=2 Est une expression car elle a une valeur (2) et affecte également une valeur à une variable. C'est pourquoi vous pouvez faire des choses comme:

let a;
let b = 1 + (a = 2); // a is now 2 and b is 3

Il est possible que le même bloc de code (textuel) soit considéré à la fois comme une expression et une instruction selon le contexte. Par exemple. l'extrait de texte function f(){} est une expression à la ligne 1 et une instruction à la ligne 2 dans le code ci-dessous:

let g = function f() {};
function f() {};

Donc, si quelque chose est une expression ou une déclaration ne peut pas (dans le cas général) être déterminé en regardant un morceau de code textuel hors contexte; c'est plutôt une propriété d'un nœud dans un arbre de syntaxe et ne peut être décidée qu'après que le code a été (mentalement ou réellement) analysé.

De plus, et peut-être plus important encore, les instructions de fonction (a.k.a déclarations de fonction) à l'intérieur d'une fonction f font partie du contexte d'exécution qui est créé lorsque la fonction f est invoquée. Cependant, les expressions de fonction ne font pas partie de ce contexte d'exécution.

Un effet souvent cité de cela est que les déclarations de fonctions sont "hissées" alors que les expressions de fonction ne le sont pas.

Un effet plus subtil peut également être observé expérimentalement dans les récursions profondes étant donné que les instructions de fonction prennent de la place dans le contexte d'exécution alors que les expressions de fonction ne le font pas. Par exemple. le code ci-dessous utilise la récursion infinie d'une fonction f. La fonction f dans le premier cas inclut une expression de fonction à l'intérieur, dans le second cas elle inclut la déclaration de fonction équivalente:

// Function Expression
{
    let i = 0;
    try {

        function f () {
            i++;
            (function g() {})(); // this is an expression
            f();
        }

        f();

    } catch (err) {
        console.log(`Function Expressions case: depth of ${i} reached. Error: ${err.name}`);
    }
}
// Function Declaration
{
    let i = 0;
    try {
        function f () {
            i++;
            function g() {}; // this is a statement
            g();
            f();
        }

        f();

    } catch (err) {
        console.log(`Functions Declarations case: depth of ${i} reached. Error: ${err.name}`);
    }
}

Sur ma machine, j'obtiens systématiquement les éléments suivants (dans node.js):

Function Expressions case: depth of 17687 reached. Error: RangeError
Functions Declarations case: depth of 15476 reached. Error: RangeError

… Ce qui est cohérent avec le fait que les déclarations de fonctions augmentent la quantité d'espace nécessaire pour contenir un contexte d'exécution et consomment ainsi un peu plus d'espace de pile et donc diminuent légèrement la profondeur de récursivité maximale.

33
Marcus Junius Brutus

L'expression produit ou évalue une valeur.

Exemples d'expressions: new Date() produit un nouvel objet Date sans aucun effet secondaire. [1,2,3] Produit un nouveau tableau sans aucun effet secondaire. 5+6 Produit une nouvelle valeur 11.Il produit juste une nouvelle valeur sans aucun effet secondaire.

L'instruction produit un comportement ou fait quelque chose et elle a également un effet secondaire. Sur la base de l'effet secondaire, les déclarations peuvent être catégorisées.

x=5; Est une déclaration et ici l'effet secondaire est l'affectation ou la modification de x.

setTimeout() - le démarrage de la minuterie est l'effet secondaire.

Les déclarations sont généralement séparées par un point-virgule.

L'expression est l'expression qui a un effet secondaire ou simplement une "expression avec effet secondaire".

Exemples de déclaration d'expression:

x+=6; Est l'expression complexe (groupe d'expressions primaires) qui effectue une affectation qui est un effet secondaire, ce qu'on appelle une instruction d'expression.

delete a[2];
21
Praveen

Dans ses termes les plus simples, expressions sont évaluées pour produire une valeur . D'autre part, instructions sont exécutées pour faire bouger les choses .

13
U-ways

Expression: une unité de code qui se résout en une valeur, par exemple, littéraux & opérateurs. Exemples d'expressions:

> 3
> 1 + 2
> "expression"
> fn()
> []
> {}


Statement: une unité de code représentant une instruction ou plus, commence généralement par un mot clé réservé dans la langue et se termine, explicitement ou implicitement , avec un terminateur d'instruction. Exemples de déclarations:

> 3;
> let x = 3;
> if () {}
> for () {}
> while () {}
10
Mo Ali

Tous les programmes en JavaScript sont constitués d'instructions et se terminent par des points-virgules, à l'exception des instructions de bloc qui sont utilisées pour regrouper zéro ou plusieurs instructions. Les instructions ne font que réaliser certaines actions mais ne produisent aucune valeur ni sortie alors que expressions retourne une valeur. Lorsque l'interpréteur voit une expression, il récupère sa valeur et remplace l'expression par une nouvelle valeur. Les instructions sont utilisées pour manipuler ces expressions. Vous pouvez vérifier s'il s'agit d'une expression ou d'une déclaration ici: Analyseur JavaScript

9
Eldiyar Talantbek

Je recommande fortement de lire le blog complet du Dr Axel Rauschmayer
Expressions versus instructions en JavaScript
comme mentionné dans la réponse acceptée de @ ZER0 ci-dessus.

Mais mon raccourci mémoire préféré est:

Expression:
e peut être défini Equal sur un Expression
.. ou Expressed en l'imprimant.
Déclaration:
..rien d'autre.

Ce qui suit est modifié de
Réponse d'Anders Kaseorg à Quora .

Une instruction est une ligne de code complète qui effectue une action.

Every Expression peut être utilisé comme une instruction
(dont l'effet est d'évaluer l'expression, et ignorer la valeur résultante).

Mais une Expression est n'importe quelle section du code que e évalue en une valeur e.

Les expressions peuvent être combinées "horizontalement" en expressions plus grandes à l'aide d'opérateurs.
E a un sommet horizontalement plat

La plupart des instructions ne peuvent pas être utilisées comme expressions.

Les instructions ne peuvent être combinées "verticalement" qu'en écrivant l'une après l'autre ou avec des constructions de blocs.
S s'exécute verticalement en comparaison.

De Quora Post par Ryan Lam:

Voici une règle générale: si vous pouvez l'imprimer ou l'assigner à une variable, c'est une expression. Si vous ne pouvez pas, c'est une déclaration.

Voici quelques exemples d'expressions:

2 + 2
3 * 7
1 + 2 + 3 * (8 ** 9) - sqrt(4.0)
min(2, 22)
max(3, 94)
round(81.5)
"foo"
"bar"
"foo" + "bar"
None
True
False
2
3
4.0

Tout ce qui précède peut être imprimé ou affecté à une variable.

Voici quelques exemples de déclarations:

if CONDITION:
Elif CONDITION:
else:
for VARIABLE in SEQUENCE:
while CONDITION:
try:
except EXCEPTION as e:
class MYCLASS:
def MYFUNCTION():
return SOMETHING
raise SOMETHING
with SOMETHING:

Aucune des constructions ci-dessus ne peut être affectée à une variable. Ce sont des éléments syntaxiques qui servent un but, mais n'ont pas eux-mêmes de "valeur" intrinsèque. En d'autres termes, ces constructions n'évaluent rien. Essayer de faire l'une des choses suivantes, par exemple, serait absurde et ne fonctionnerait tout simplement pas:

x = if CONDITION:
y = while CONDITION:
z = return 42
foo = for i in range(10):
3
SherylHohman

Nous avons les deux types d'expressions suivants:

1. L'expression booléenne est utilisée pour exécuter un bloc d'instructions . enter image description here

2. L'expression arithmétique est utilisée pour les affectations de variables, qui agit également comme instructions .

Par exemple: number = number + 1;

1
Premraj