Quels sont les éléments de base de la syntaxe javascript

Les éléments de base de la syntaxe JavaScript sont les valeurs, les opérateurs, les expressions, les mots-clés et les commentaires ; chaque instruction JavaScript se termine par un point-virgule. Si une instruction occupe une ligne, il n'est pas nécessaire d'écrire un point-virgule.

L'environnement d'exploitation de cet article : système Windows 7, javascript version 1.8.5, ordinateur DELL G3

Syntaxe JavaScript

Quels sont les éléments de base des instructions js À quoi devez-vous faire attention ? lorsque vous utilisez des valeurs et des opérateurs js ?

Qu'est-ce que la grammaire En fait, la grammaire est un ensemble de règles. Tout comme lorsque nous apprenons le chinois, nous apprenons le sujet, le prédicat, l'objet et le complément adverbial. JS possède également une syntaxe et son propre ensemble de règles.

Tout comme lorsque nous parlons, le contenu de notre discours est composé d'une série d'énoncés, et le programme JS est également composé d'une série d'énoncés.

Nous parlons phrase par phrase, et l'exécution du programme s'effectue également phrase par phrase.

Dans le front-end, le programme JS est exécuté par le navigateur.

Les instructions JS sont composées de valeurs, d'opérateurs, d'expressions, de mots-clés et de commentaires. C'est comme si chaque phrase que nous prononçons habituellement est composée de mots un par un.

Chaque instruction se termine par un point-virgule.

Si une instruction occupe une ligne, il n'est pas nécessaire d'écrire un point-virgule. Cependant, je vous suggère de prendre l’habitude d’écrire des points-virgules, ce qui vous évitera bien des ennuis inutiles.

JS ignorera plusieurs espaces. Afin d'améliorer la lisibilité, je vous suggère d'ajouter des espaces dans le code, comme les deux lignes de code suivantes :

var name = "刘小妞";var name="刘小妞";

Les deux phrases sont identiques, mais dans la première phrase, nous utilisons le signe égal L'ajout d'espaces sur les côtés gauche et droit le rendra beaucoup plus confortable.

Les instructions JS peuvent être placées entre accolades {}, et le code entre les accolades est appelé un bloc de code. Les blocs de code sont généralement utilisés dans les fonctions, dont nous parlerons plus tard.

Nous allons maintenant présenter les valeurs, les opérateurs, les expressions, les mots-clés et les commentaires dans les instructions JS.

- Commentaires

Il faut quand même ajouter des commentaires de manière appropriée dans le code. Cela améliore non seulement la lisibilité du code, mais facilite également le débogage du code.

Les commentaires sont principalement utilisés pour ajouter des explications au code et expliquer les fonctions du code actuel.

Le contenu des commentaires ne sera pas exécuté.

Les commentaires sont divisés en commentaires sur une seule ligne et commentaires sur plusieurs lignes.

Les commentaires sur une seule ligne commencent par // et le contenu après // ne sera pas exécuté. Par exemple :

//给变量a赋值1
var a = 1 ;
var b = 2 ; //给变量b赋值2
单行注释的位置，通常在代码上面单独一行或者代码后面。

多行注释以 /* 开头，以 */ 结尾。这个和CSS的注释一样。
多行注释也叫注释块。写个例子。

/*
下面代码是给变量a和b赋值
a的值是1，b的值是2。
*/
var a = 1 ;
var b = 2 ;

一般情况下，单行注释就足够了。

Lorsque nous débogueons du code, nous utilisons souvent des commentaires. Par exemple :

//var a = 1;
var a = 2;

Nous pouvons ajouter des commentaires au lieu de taper du code dans les deux sens.

- Valeurs JS

Les instructions JS définissent trois types de valeurs : les valeurs mixtes, les valeurs variables et les valeurs constantes.

Les valeurs mixtes sont appelées littéraux, les valeurs variables sont appelées variables et les valeurs constantes sont appelées constantes.

La quantité littérale est également appelée quantité directe, c'est-à-dire que tout ce que vous voyez est ce que vous voyez. Cela peut également être compris comme une valeur. Par exemple, 1 vaut 1, 2 vaut 2, ou il peut s'agir d'un nombre décimal, tel qu'une chaîne. Une chaîne est du texte, entouré de guillemets doubles ou simples, tels que : "Liu Xiaoniu", "Liu Xiaoniu". Il peut également s'agir d'un tableau ou d'un objet.

Les littéraux apparaissent généralement sur le côté droit de l'opérateur d'affectation, qui sera présenté séparément ci-dessous. Par exemple :

var a = "刘小妞"; //a是变量，等号右边的字符串刘小妞是字面量。

Les variables et constantes sont utilisées pour stocker les valeurs des données, ce sont des conteneurs.

Les variables sont déclarées avec le mot-clé var et les constantes sont déclarées avec const.

La différence entre les variables et les constantes est que les variables stockent les valeurs des variables et peuvent être attribuées plusieurs fois ; les constantes stockent des valeurs immuables et ne peuvent pas être attribuées plusieurs fois.

Les constantes doivent avoir une valeur initiale lorsqu'elles sont déclarées, mais ce n'est pas obligatoire pour les variables. Généralement, les constantes sont écrites en lettres majuscules.

Trois types de valeurs en JS sont généralement utilisés dans les affectations.

- Opérateurs JS

Les opérateurs devraient nous être familiers, nous les avons appris en mathématiques à l'école primaire. Par exemple, les opérateurs arithmétiques sont : l'addition, la soustraction, la multiplication et la division, et les opérateurs de comparaison sont : supérieur à, égal à et inférieur à. Les opérateurs en JS sont similaires à ceux en mathématiques, sauf qu'il y a plus d'opérateurs qu'en mathématiques à l'école primaire, et il y a une légère différence. Présentons-les un par un.

Les opérateurs couramment utilisés dans JS sont les suivants :

Opérateur d'affectation
Opérateur arithmétique
Opérateur de comparaison
Opérateur logique
Opérateur de type

Opérateur d'affectation : (=)

L'opérateur d'affectation est un signe égal à l'école primaire. En mathématiques, le signe égal est utilisé à des fins de comparaison. Mais dans JS, un signe égal est utilisé pour l'affectation. Lorsque nous avons introduit les valeurs ci-dessus, nous avons dit que les trois types de valeurs dans JS sont généralement utilisés dans l'affectation et que l'affectation est réalisée via le signe égal. Par exemple :

var a = 1; //等号左边a是变量，等号右边1是字面量，等号是赋值运算符，通过赋值运算符把1赋值给了变量a。

Un signe égal est l'opérateur d'affectation le plus basique, et il existe des opérateurs d'affectation plus avancés. Ce ne sont pas seulement des affectations, mais ont également des fonctions de calcul logiques. Nous avons présenté plusieurs autres opérateurs plus tard. Présentons-le à nouveau.

-JS的 算数运算符

加法运算符：（+）

加法运算符有点特殊，因为在JS里，加号（+）也表示连接。所以，需要看加号两边值的类型。

1、加号两边都是数字，结果是两个数字相加的结果。比如：

var a = 1 + 1 ; //a的值是2

2、加号两边都是字符串，结果是两个字符串拼接。比如：

var a = '我是刘小妞'  + '栖息地' ; //a的结果是：“我是刘小妞栖息地”

3、加号两边一个数字一个字符串，结果是数字和字符串拼接成的字符串。比如：

var a = 1 + '刘小妞' ; //a的结果是：“1刘小妞”var a = '刘小妞' + 10 ; //a的结果是：“刘小妞10”

减法运算符：（-）
乘法运算符：（*）
除法运算符：（/）

减、乘、除，这三个和我们数学运算符的作用是一样的，只不过，符号不太一样。乘法用星号，除法用斜杠。

系数运算符：（%）它是返回余数。比如：

var a = 8 % 3; //a的值是2

递增运算符：（++）对数值进行递增，比如：

var a = 1;a++;var b = a;  //b的值是2

递增就是在原来的基础上加1。

递减运算符：（–）对数值进行递减

var a = 10;a--;var b = a;  //b的值是9

递减就是在原来的基础上减1。

说一下a++和++a的区别吧。在赋值的时候，它们两个的执行顺序是不一样的。比如：

var a = 1;var b = a++; //b的值1。

a++是先赋值，再递增。

var a = 10;var b = ++a; //b的值是11。

++a是先递增，再赋值。

a–和--a也是类似的。a–先赋值再递减，–a先递减再赋值。

这个也好记，就是值和运算符谁在前面，就先执行谁。

运算符的优先级和小学数学里的一样，计算顺序是从左到右，先乘除后加减，有括号的，先算括号里的。

-JS的比较运算符

大于运算符：（>）
小于运算符：（>）
大于或等于运算符：（>=）
小于或等于运算符：（<br><code>等于运算符：（==）
等值等型运算符：（===）
不相等运算符：（!=）
不等值或不等型运算符：（!==）
三元运算符：（?）

大于、小于、大于等于、小于等于这四种和数学里的一样，我就不解释了。我重点讲下面的5种运算符。

等于运算符：（==），它的作用和数学里的一个等号是一样的，因为JS里一个等号被用做赋值了，所以，等于运算符用了两个等号。

等值等型运算符：（===），等值等型运算符是三个等号，它比两个等号严格一些，不仅两个数值要相等，两个值的类型也需要相等。

JS里有很多数据类型，有字符串，有数值等等，数据类型以后如果写的话再单独写，今天简单提一下。举个例子：

var a = '123' ;var b = 123 ;

a和b，a是字符串，b是数值。

a和b用两个等号比较，是相等的；用三个等号比较是不相等的。因为它们两个的数据类型不一样。

不相等运算符：（!=）
不等值或不等型运算符：（!==）

这两个和上面的等于运算符：（==）、等值等型运算符：（===）类似。只不过，它俩比较的是不相等。

在讲三元运算符之前，我先介绍一个数据类型：布尔值。

它有两个值：true和false。true是真，false是假。在写条件判断的时候，我们经常会用到这两个值。true就是条件成立，false就是条件不成立。

三元运算符：（?），也叫条件运算符，它这个稍微复杂一点。它一般是用在条件赋值里。格式如下：

var a = (condition) ? value1 :value2;

括号里是条件，如果condition的值是true，也就是条件成立，a的值就是value1，否则，a的值是value2。

写个小例子：

var a = 1 ;var b = (a>0) ? 2 : 3 ;  //b的值是2

三元运算符，我们在后面讲条件语句的时候，还会提到。

- JS的逻辑运算符

逻辑与运算符：（&&）
逻辑或运算符：（||）
逻辑非运算符：（!）

逻辑运算符总共三个，与、或、非。它们一般是用在条件语句里的判断。

与和或一般是连接多个判断条件，判断条件通常是用比较运算符连接。

逻辑与连接的多个运算结果都为真，它的结果才会是真，否则为假。
逻辑或连接的多个运算结果，有一个为真，它就为真。

举个例子：

var a = 1 ;var b = 5 ;var c = (a>0 && b<p>逻辑非是取反。如果当前是真（true），取反就是假，当前是假，取反就是真。</p><p>写个例子：</p><pre class="brush:php;toolbar:false">var a = 1 ;var b = 5 ;var c = (a==b); //c的值是falsevar d = !c ; //d的值是true

逻辑运算符从字面意思也能理解。
与就是并且的意思；或就是或者的意思；非就是相反的意思。

说一下前面说的高级一点的赋值运算符吧。其实，高级一点的运算符就是把上面说的运算符综合运用了一下。列几个常用的吧。

赋值运算符：（+=），比如：a += b 等价于 a = a + b
赋值运算符：（-=），比如：a -= b 等价于 a = a - b
赋值运算符：（*=），比如：a *= b 等价于 a = a * b
赋值运算符：（/=），比如：a /= b 等价于 a = a / b
赋值运算符：（%=），比如：a %= b 等价于 a = a % b

- JS的表达式

表达式是值和运算符的组合，计算结果是值。

我们前面介绍值和运算符的时候，其实一直在写表达式。比如：

1 + 1a + 1"刘小妞" + "栖息地"

- JS的关键词

关键词是JS自己保留的单词，这些单词都是有特定功能的，我们在定义变量的时候，不能用关键词。下表是常用的关键词。

推荐学习：《javascript基础教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!