Quelles sont les différences entre c et javascript ?

Les différences sont : 1. Le langage C est compilé en langage machine, tandis que JS est interprété et exécuté comme un script par l'interpréteur ; 2. Le langage C nécessite que les programmeurs gèrent manuellement la mémoire, tandis que la mémoire de JS est traitée par l'interpréteur Gérer ; 3. Le langage C implémente le multithread en appelant l'API système, tandis que JS est monothread.

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

1. Le langage C est principalement compilé en langage machine, tandis que JavaScript est principalement interprété et exécuté comme un script par l'interpréteur

2. à l'application et à la version Heap Memory), tandis que la mémoire JavaScript est gérée par l'interpréteur ;

3. JavaScript est un langage typé dynamiquement, et le type de données des variables peut toujours changer pendant l'exécution ; > 4. Fonctions dans les fermetures de formulaires JavaScript avec des variables accessibles lorsqu'elles sont définies ;

5. Prise en charge des fonctionnalités orientées objet telles que "l'héritage de classe et le polymorphisme", et JavaScript peut utiliser des chaînes prototypes et des fermetures, etc. implémentent l'héritage orienté objet, le polymorphisme et l'encapsulation, et JavaScript qui implémente ECMAScript 2015 et supérieur prend en charge la définition des classes au niveau grammatical

6. Le langage C peut implémenter plusieurs fonctions en appelant les API système. améliorer l'utilisation du processeur lors des opérations de blocage (principalement IO) grâce au multi-threading, alors que JavaScript est principalement monothread. Les opérations de blocage possibles en JavaScript sont complétées par l'API asynchrone fournie par le runtime JavaScript

Pour les étudiants ayant un Fondation C, l'apprentissage de js est assez simple et la syntaxe est similaire. Ici, nous énumérons principalement les similitudes et les différences entre les deux. Fondamentalement, après avoir mémorisé ces similitudes et différences, vous pouvez commencer à utiliser js. En quelques jours ou même une journée d'étude, vous pouvez utiliser js pour appeler des cartes Baidu, dessiner des modèles tridimensionnels et d'autres fonctions amusantes dans QT.

Dans le processus de développement QT, qss, qml et js sont souvent utilisés, qui sont très similaires à l'ensemble frontal en trois parties (CSS/HTML/JS). Voici un enregistrement du commun). syntaxe de JS.

Le concept de pointeurs de fonction en langage C est également applicable en JS. Cependant, les pointeurs de fonction en JS ne sont pas au niveau de la compilation, mais au niveau de l'interprétation. L'implémentation sous-jacente est différente, mais l'utilisation est. le même.

0. [Déclaration de variable] Les variables en langage C doivent d'abord être déclarées puis utilisées ; tandis que JS permet une utilisation directe sans déclaration. Bien sûr, il prend également en charge la déclaration d'abord, puis l'utilisation, et l'utilisation d'abord, puis la déclaration. .

1. [Affectation et affectation de référence] Lors de l'attribution de valeurs à des variables dans js, à l'exception du type de base qui est l'affectation de copie, les "autres" sont toutes des références d'affectation (les soi-disant "autres" sont en fait des variables d'objet dans JS). L'affectation en langage C est une affectation de copie, sauf si vous spécifiez explicitement d'attribuer une référence.

2. [Callback] Les deux ont le concept de fonction de rappel, et le nom de la fonction est le nom de la variable de rappel. Cela est vrai pour C et JS.

3. [Auto-appel]. JS peut l'appeler immédiatement lors de la définition d'une fonction. La syntaxe est la suivante :

无参函数示例
(function fooA (){
            //这里是函数体
        })();
有参函数示例：
(function fooB(var a){
            //这里是函数体
        })(5);

consiste à définir la fonction entière, à la mettre entre parenthèses A (cela équivaut à obtenir le pointeur de fonction de la fonction), puis à ajouter une parenthèse B (cela équivaut à exécuter ceci fonction), les parenthèses B suivantes peuvent être utilisées pour renseigner les paramètres. Et le nom de la fonction ici peut être omis.

4. [Définition de fonctions au sein des fonctions] JS permet de définir des fonctions à l'intérieur des fonctions.

5. [Fermeture]

Ce concept est relativement nouveau et je ne l'ai jamais vu en C/C++ En lisant le tutoriel JS, j'ai trouvé que cette chose est très simple, mais la. le nom est trop bluffant, pour faire simple, cette technique de programmation permet à une fonction d'avoir des variables statiques locales.

De manière générale, la portée des variables en JS est cohérente avec celle du C. Les variables d'une fonction ne sont pas accessibles en dehors de la fonction, sauf si vous utilisez les paramètres formels ou la valeur de retour de la fonction pour modifier la variable locale Le pointeur est déplacé vers l'extérieur, de sorte que le code en dehors de la fonction puisse faire fonctionner les variables statiques locales à l'intérieur d'une certaine fonction via le pointeur. De même, cette technique existe également en JS, et son nom est Closure. La différence est que C renvoie un pointeur vers une variable statique locale à partir de la fonction, tandis que JS renvoie un pointeur vers une fonction qui peut faire fonctionner cette variable locale.

À titre de comparaison, voici une version en langage C de "closure" :

uint8_t *getBuf(void)
{
    static uint8_t buf[1024];
    return buf;
}

void sendCmd()
{
    uint8_t *cmdBuf = getBuf(void);
    cmdBuf[0] = 0xA5;
    cmdBuf[1] = 0xFF;
    ....
    send(cmdBuf, 10);
}

Il existe un tableau statique local buf dans la fonction getBuf, auquel les autres codes du programme d'origine ne peuvent pas accéder . Mais nous utilisons la valeur de retour de la fonction pour envoyer la première adresse, réalisant ainsi l'accès du code externe au tableau. Par exemple, la fonction sendCmd utilise ce tableau.

Ce qui suit est la version JS :

Scénario (1) : La variable a et la fonction B sont définies dans la fonction A. Évidemment, B peut accéder à a. Comment pouvons-nous laisser le code en dehors de A accéder. ça ? Et un ? Il existe deux façons de penser, l’une consiste à renvoyer une référence à a et l’autre à fermer. Je ne parlerai pas du retour d'une référence, car la mémoire de a sera libérée après l'exécution de A, et la référence de retour de a ne pourra pas accéder à a.

var aRef = (function A(){
            var a = 2;
            return function B(){
                return a++;
            }
            })();

alert(aRef());
alert(aRef());

L'effet du code ci-dessus est qu'une boîte d'invite apparaît avec le numéro 2 comme contenu, puis la boîte d'invite réapparaît avec le numéro 3 comme contenu. Le nom de la fonction A et le nom de la fonction B n'ont pas besoin d'être écrits.

我们来分析一下上述代码，首先函数A是个自调用函数（也可以不自调用，后面有例子），所以A里面变量a立即被赋值为2，函数A的返回值为函数B的函数指针，所以变量aRef就是个函数指针，以后调用aRef( )，就相当于调用了函数B( )。而B( )的返回值为a++。按照JS的设计机制，这种情形下的变量a将会常驻内存，这就是实现了让函数A拥有局部静态变量，而这个局部静态变量，只能被A返回的函数指针（也即函数B）修改。

基于上述分析，我们可以把上述代码改成这样，更容易阅读：

var aRef = (function A(){
            var a = 2;            
            function B(){
                return a++;
            }
            return B;
            })();

也可以改成这样：
function A(){
    var a = 2;            
    function B(){
        return a++;
    }
    return B;
}
var aRef = A();//A没有进行自调用，只能在这里调一次，才能获取到B的函数指针

情形2：经典的JS定时器闭包。题目：使用for循环，每秒打印出for当前的值。

错误写法：

for(var i = 1; i <= 5; i++)
{
    setTimeout(function(){
        alert(i);
    }, 1000);
}

执行的效果是，连续弹出5次数字5，而不是预想的依次弹出12345。原因是，第一次执行定时器的回调函数前，i的值就已经变成5了，后续4次定时回调，i的值也是5.

正确写法：

for(var i = 1; i <= 5; i++)
{
    (function(a){
        setTimeout(function(){alert(a);}, 1000);
    })(i);
}

这里使用了一个匿名的自调用函数（为了叙述方便，我下面称之为out函数），在函数内部又声明了匿名的定时器回调函数（为了叙述方便，我下面称之为in函数），因此使得in函数成了闭包函数，从而使得out函数的局部变量a常驻内存了。

为了更清楚de看明白它的原理，我们再把这段代码改成这样，增强可读性：

function outFunc(a){
    function inFunc(){
        alert(a);
    }
    setTimeout(inFunc, 1000);
}

for(i = 0; i < 4; i++)
{
    outFunc(i);
}

这段代码看起来清晰了，可以一目了然地看出其中的闭包语法。

总结一下闭包就是：一旦执行了闭包函数所在的外部函数，那么这个外部函数所维护的局部变量，将会常驻内存。

最后来一个实例应用，看看闭包在实际场景中是如何应用的。题目：有如下C语言函数，请把它改成js版。

uint32_t readVol(void)
{
    static uint8_t callCnt = 0;
    callCnt++;
    return callCnt;
}

这个C函数的功能很简单，就是每次调用时，会返回该函数被调的次数，也即readVol这个函数拥有自己的局部静态变量。用js实现如下：

    var readVol = (function ()
	{
		var callCnt = 0;
		return function()
		{
			callCnt++;
			return callCnt;
		}		
	})();

这个readVol函数与C语言的readVol函数功能完全一致。

【推荐学习：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!