Javascript a-t-il une fonction principale ?

Il n'y a pas de fonction principale en javascript. La fonction principale est souvent utilisée dans les langages Java et C. Elle est également appelée fonction principale et doit avoir une valeur de retour. Le retour de 0 signifie que le programme est exécuté avec succès normalement, et le retour d'une valeur non 0 signifie que le programme. se termine anormalement mais cette fonction n'existe pas en JavaScript.

L'environnement d'exploitation de ce tutoriel : système Windows 10, JavaScript version 1.8.5, ordinateur Dell G3.

Javascript a-t-il une fonction principale ?

Javascript n'a pas de fonction principale

Introduction

La fonction principale, également connue sous le nom de fonction principale, est le seul point d'entrée pour la plupart des programmes C et nécessite un valeur de retour. La valeur de retour renvoyée à (comme le système d'exploitation) pour indiquer l'état d'exécution du programme. Renvoyer 0 signifie que le programme est exécuté normalement avec succès, et renvoyer une valeur non-0 signifie que le programme se termine anormalement. Par conséquent, la valeur de retour doit être un entier, il y a donc la spécification de int main().

Si vous utilisez void main(), ce qui signifie que la fonction principale n'a pas de valeur de retour, bien que le programme puisse être compilé et exécuté avec succès, cela ne permet pas à l'activateur du programme de juger de son statut. les projets composés de nombreux programmes C sont fatals.

Surtout à partir du standard C99 (la deuxième édition du standard officiel du langage C formulé en 1999), int main() doit être utilisé Si le langage return 0; c'est une bonne habitude de l'écrire soi-même). Si seul main() est déclaré, le système utilise par défaut int main(). void main() ne doit jamais être utilisé car la fonction main doit avoir une valeur de retour pour indiquer l'état d'exécution du programme (c'est une bonne habitude de ne pas utiliser void main() dans votre code).

Définition

Dans la dernière norme C99, seules les deux définitions suivantes sont correctes :

int main(void)
int main(int argc, char *argv[]) // char *argv[]可以写成char **argv

Paramètres

void : n'accepte aucun paramètre

argc : représente l'environnement dans lequel le programme est exécuté ; passé au programme Nombre de paramètres ;

argv : Pointeur vers le premier élément du tableau de pointeurs argc+1. Le dernier élément du tableau est un pointeur nul, et s'il y a des éléments précédents, ils pointent vers des chaînes représentant les paramètres transmis au programme depuis l'environnement hôte. Si argv[0] n'est pas un pointeur nul (ou argc>0), il pointe vers une chaîne représentant le nom du programme. Cette chaîne est vide si le nom du programme n'est pas disponible depuis l'environnement hôte.

Valeur de retour

La valeur de retour sera utilisée comme paramètre pour l'appel implicite à exit(). Les valeurs de 0 et EXIT_SUCCESS indiquent une terminaison réussie, et les valeurs autres que 0 et EXIT_FAILURE indiquent une terminaison infructueuse.

L'exemple est le suivant : Créez une fonction principale en JavaScript

En C et Java, il existe une fonction ou une méthode d'entrée pour le programme, c'est-à-dire la fonction principale ou la méthode principale. En JavaScript, le programme s'exécute à partir de l'en-tête du fichier source JS. Mais dans un sens, nous pouvons toujours constituer une fonction principale comme point de départ du programme, de cette façon, non seulement il peut être unifié avec d'autres langages, mais peut-être que vous aurez une compréhension plus approfondie de JS.

1. Entrée réelle

Lorsqu'un fichier JavaScript est transmis au moteur JS pour exécution, le moteur JS exécute chaque instruction une par une de haut en bas jusqu'à ce que tout le code soit exécuté.

2. Chaîne de portée, portée globale et objet global

Nous savons que chaque fonction de JS générera une nouvelle portée une fois exécutée. Plus précisément, une nouvelle portée sera créée lorsque le flux d'exécution entre dans la fonction, et cette portée sera détruite lorsque l'exécution de la fonction se terminera et se terminera. Les paramètres formels et les variables locales de la fonction seront liés à cette portée lorsque l'appel de fonction terminera la destruction de la portée, ils seront détruits en conséquence. Bien entendu, dans des cas particuliers, si certaines variables de la portée sont encore référencées au retour de la fonction, la portée et ces variables référencées ne seront pas détruites, formant ce qu'on appelle une fermeture.

D'un autre côté, nous savons que les fonctions peuvent être imbriquées, donc les portées peuvent également être imbriquées. Lorsqu'une fonction est définie, le moteur JS définira un attribut intégré appelé [[scope]] pour chaque fonction, qui pointe vers la portée lexicale de la fonction externe. De cette manière, plusieurs portées forment une structure de chaîne appelée chaîne de portées. Normalement, il n'y a qu'une seule chaîne de portées à la fois, c'est-à-dire qu'elle part de la portée de la fonction en cours d'exécution et remonte couche par couche jusqu'à la portée globale la plus externe.

[Note] : Les fonctions sur la chaîne de portée sont des fonctions imbriquées couche par couche dans le code source JS. Elles n'ont rien à voir avec l'ordre dans lequel les fonctions sont exécutées ou la pile d'appels de fonction. portée lexicale du nom.

La portée globale est une portée spéciale. Ce n'est pas une portée de fonction, mais c'est la portée externe de toutes les portées de fonction et le point final de toutes les chaînes de portée. Par conséquent, tant que le programme ne se termine pas, la portée globale existe toujours et les variables de la portée globale sont toujours valides.

[Portée de la fonction 3]-->[Portée de la fonction 2]-->[Portée de la fonction 3]-->[Portée globale]

De plus, correspondant à la portée globale, Il existe également un objet global. Dans le navigateur, l'objet global est l'objet window. L'objet global est un objet spécial :

Les variables définies dans la portée globale seront liées à l'objet global.

在任意作用域中定义的变量，如果定义时没有用 var 关键字，都会绑定到全局对象。

在全局作用域中， this 指向全局对象。

从上面列举的这些特性可以看出，如果把全局作用域当成一个对象的话，那么实际上它就是全局对象。另外，这也解释了在全局作用域中，下面的四条语句为什么是等价的：

var a = 1;
a = 1;
window.a = 1;
this.a = 1;

3. 虚构的main函数

既然都是作用域，为什么要有一个特殊的全局作用域呢？我们总是喜欢简单化、一致性，而尽量避免复杂化、特殊性。所以很自然地，我们会想能否让全局作用域看起来跟函数作用域没什么区别？答案是肯定的。我们可以做这样的构想：

 我们想象，在JS引擎执行源文件时，会将文件中的代码包装到一个叫做main的函数中。然后把这个main函数作为程序的入口。

也就是说，假设一个JS文件中有这样的代码：

var a = 1;
var b = 2;
 
function add(x, y) {
  var z = x + y;
  return z;
}
console.log(add(a, b));

JS引擎在程序开始执行前会把它包装成一个main函数：

// 虚构的main函数
function main() {
  var a = 1;
  var b = 2;
 
  function add(x, y) {
    var z = x + y;
    return z;
  }
 
  console.log(add(a, b));
}

然后，调用这个main函数：

main._current_scope_ = window; // 将全局作用域(对象)设为window
main.call(window) // 将this指向window

4. 意义何在？

(1) JS也有了入口函数main，跟其他语言一致了。

(2) 省去了全局作用域的概念，或者说全局作用域也成了函数作用域。

(3) 通过上面对main函数的调用过程，可以明白全局作用域中的那些特殊性质的由来。

(4) 最后一点，将所有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!