Was sind die Unterschiede zwischen C und Javascript?

Die Unterschiede sind: 1. Die C-Sprache wird in Maschinensprache kompiliert, während JS vom Interpreter als Skript interpretiert und ausgeführt wird. 2. Die C-Sprache erfordert, dass Programmierer den Speicher manuell verwalten, während der JS-Speicher vom Interpreter verwaltet wird Die C-Sprache implementiert Multithreading durch Aufrufen der System-API, während JS Single-Threading ist.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, JavaScript-Version 1.8.5, Dell G3-Computer.

1. Die C-Sprache wird hauptsächlich in Maschinensprache kompiliert, während JavaScript hauptsächlich vom Interpreter als Skript interpretiert wird.

2. Die C-Sprache erfordert eine manuelle Speicherverwaltung (hauptsächlich in Bezug auf die Anwendung und Freigabe des Heap-Speichers). ), während der Speicher von JavaScript vom Interpreter verwaltet wird

3 und die Datentypen von Variablen können sich während der Laufzeit ändern

4

5 Unterstützung für objektorientierte Funktionen wie „Klassenvererbung und Polymorphismus“, während JavaScript objektorientierte Vererbung, Polymorphismus und Kapselung durch Prototypketten und -verschlüsse erreichen und ECMAScript 2015 und höher implementieren kann .JavaScript unterstützt die Definition von Klassen auf grammatikalischer Ebene.

6 Die Sprache C kann Multithreading durch Aufrufen der System-API implementieren und die CPU-Auslastung bei Blockierungsvorgängen (hauptsächlich IO) verbessern Hauptsächlich ist es Single-Threaded und die möglichen Blockierungsvorgänge von JavaScript werden durch die von der JavaScript-Laufzeit bereitgestellte asynchrone API vervollständigt. Für Schüler mit einer C-Grundlage ist das Erlernen von js recht einfach, und die Syntax ist hier hauptsächlich ähnlich Ähnlichkeiten und Unterschiede zwischen den beiden. Denken Sie grundsätzlich an diese Ähnlichkeiten und Unterschiede. Sie können mit der Verwendung von js beginnen. In nur wenigen Tagen oder sogar einem Lerntag können Sie mit js Baidu-Karten aufrufen, dreidimensionale Modelle zeichnen und andere unterhaltsame Funktionen in QT nutzen.

Im QT-Entwicklungsprozess werden häufig qss, qml und js verwendet, die dem dreiteiligen Front-End-Set (CSS/HTML/JS) sehr ähnlich sind. Hier ist eine Aufzeichnung der allgemeinen Syntax von JS.

Das Konzept der Funktionszeiger in der Sprache C ist auch in JS anwendbar. Allerdings befinden sich die Funktionszeiger in JS nicht auf der Kompilierungsebene, sondern auf der Interpretationsebene. Die zugrunde liegende Implementierung ist unterschiedlich, die Verwendung ist jedoch dieselbe.

0. Variablen in der C-Sprache müssen zuerst deklariert und dann verwendet werden, während JS natürlich auch die erste Deklaration und dann die Verwendung und dann die Deklaration unterstützt.

1. [Zuweisung und Referenzzuweisung] Bei der Zuweisung von Werten zu Variablen in JS sind „andere“ alle Zuweisungen von Referenzen (die sogenannten „anderen“ sind tatsächlich Objektvariablen in JS). Bei der Zuweisung in der Sprache C handelt es sich um eine Kopierzuweisung, es sei denn, Sie geben ausdrücklich an, eine Referenz zuzuweisen.

2. [Callback] Beide haben das Konzept einer Callback-Funktion, und der Funktionsname ist der Callback-Variablenname. Dies gilt sowohl für C als auch für JS.

3. [Selbstanrufung]. JS kann es sofort aufrufen, wenn eine Funktion definiert wird. Die Syntax lautet:

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

definiert die gesamte Funktion, schließt sie in Klammern A ein (dies entspricht dem Abrufen des Funktionszeigers der Funktion) und fügt dann eine Klammer B hinzu (dies entspricht dem Ausführen dieser Funktion) und dann Die Klammern B können Parameter ausfüllen. Und der Funktionsname kann hier weggelassen werden.

4. [Funktionen innerhalb von Funktionen definieren] JS ermöglicht die Definition von Funktionen innerhalb von Funktionen.

5. [Abschluss]

Dieses Konzept ist relativ neu und ich habe es noch nie in C/C++ gesehen. Ich habe festgestellt, dass dieses Ding sehr einfach ist, aber der Name ist zu bluffend Einfach ausgedrückt ist dies eine Programmiertechnik, die es einer Funktion ermöglicht, lokale statische Variablen zu haben.

Im Allgemeinen stimmt der Umfang von Variablen in JS mit dem von C überein. Auf Variablen innerhalb einer Funktion kann nicht außerhalb der Funktion zugegriffen werden, es sei denn, Sie verwenden die formalen Parameter oder den Rückgabewert der Funktion, um den Zeiger der lokalen Variablen zu ändern außerhalb, sodass Code außerhalb der Funktion lokale statische Variablen innerhalb einer Funktion über Zeiger bedienen kann. In ähnlicher Weise gibt es diese Technik auch in JS und sie heißt „Closure“. Der Unterschied besteht darin, dass C von der Funktion einen Zeiger auf eine lokale statische Variable wirft, während JS einen Zeiger auf eine Funktion wirft, die diese lokale Variable bedienen kann.

Zum Vergleich ist hier eine C-Sprachversion von „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);
}

Es gibt einen lokalen statischen Array-Buf in der getBuf-Funktion. Ursprünglich können andere Codes im Programm nicht darauf zugreifen, aber wir verwenden den Rückgabewert davon Durch das Senden der ersten Adresse kann externer Code auf das Array zugreifen. Beispielsweise verwendet die Funktion sendCmd dieses Array.

Das Folgende ist die JS-Version:

Szenario (1): Variable a und Funktion B sind in Funktion A definiert. Offensichtlich kann B auf a zugreifen. Wie können wir den Code außerhalb von A auf a zugreifen lassen? Es gibt zwei Denkweisen: Die eine besteht darin, einen Verweis auf a zurückzugeben, die andere darin, einen Abschluss zu finden. Ich werde nicht über die Rückgabe einer Referenz sprechen, da der Speicher von a nach der Ausführung von A freigegeben wird und die Referenz, die a zurückgibt, nicht auf a zugreifen kann.

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

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

Der obige Code bewirkt, dass ein Eingabeaufforderungsfeld mit der Nummer 2 als Inhalt und dann erneut das Eingabeaufforderungsfeld mit der Nummer 3 als Inhalt angezeigt wird. Sowohl Funktionsname A als auch Funktionsname B müssen nicht geschrieben werden.

我们来分析一下上述代码，首先函数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高级教程】

Das obige ist der detaillierte Inhalt vonWas sind die Unterschiede zwischen C und Javascript?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!