Werfen wir einen Blick auf den JavaScript-GUI-Technologie-Stack von Hongmeng

<p>

<p>Verwandte Lernempfehlungen: Javascript-Video-Tutorial

<p>Wie wir alle wissen, verwendet die neue Open-Source-Version „Hongmeng 2.0“ JavaScript als Rahmensprache für die IoT-Anwendungsentwicklung. Dies zeigt, dass JavaScript nach dem Start von SpaceX erneut zu einem heißen Thema auf der Ebene der Nachrichtensendungen geworden ist. Es wäre schade, Yin Yang Qi nur für eine so gute Gelegenheit zu nutzen. Aus Gründen der Populärwissenschaft verwendet dieser Artikel keine Lupe, um die Fehler im Code herauszufinden, um Fehler zu finden, sondern hofft, in Laiensprache zu erklären, worum es bei der von ihm unterstützten GUI geht. Solange Sie über allgemeine Kenntnisse der Computer-Grundlagen verfügen, sollte der Lektüre dieses Artikels nichts im Wege stehen.

<p>Wir wissen bereits, dass Entwickler bei „Hongmeng 2.0“ lediglich JavaScript-Geschäftslogik in Form von Vue-Komponenten schreiben müssen, um sie in eine UI-Schnittstelle auf eingebetteter Hardware wie Smartwatches zu rendern. Welche Kernmodule müssen in diesen Prozess einbezogen werden? Welche dieser Module sind selbstentwickelt und welche nutzen vorgefertigte Open-Source-Projekte? Es ist von oben nach unten in drei abstrakte Ebenen unterteilt, um Folgendes vorzustellen:

• JS-Framework-Ebene, die als stark vereinfachtes JavaScript-Framework im Vue-Stil verstanden werden kann,
• JS-Engine und Laufzeitebene, die verstanden werden kann Es handelt sich um eine stark vereinfachte Laufzeit-Grafik-Rendering-Schicht im WebKit-Stil, die als stark vereinfachte Grafik-Zeichnungsbibliothek im Skia-Stil verstanden werden kann. Diese drei Abstraktionsschichten bilden insgesamt eine Reihe von GUI-Technologien für eingebetteter Hardware-Stack. Im Gegensatz zu vielen öffentlichen Meinungen, die „unergründlich/unergründlich“ rufen, denke ich persönlich, dass zumindest für den GUI-Teil jeder Front-Line-Entwickler in China, der mit den aktuellen Mainstream-Hybrid-Cross-End-Lösungen oder der JS-Laufzeitentwicklung in Berührung gekommen ist, problemlos damit beginnen kann aus dem Quellcode Machen Sie sich daran, es zu verstehen. Lassen Sie uns Schicht für Schicht etwas interpretieren und analysieren.
• JS Framework LayerWenn Sie aus der Perspektive der obersten Ebene „Hongmeng 2.0“ zum Rendern eines dynamischen Textes verwenden möchten, müssen Sie nur den folgenden HML-Formatcode (XML-ähnlich) schreiben:

<!-- hello.hml --><text onclick="boil">{{hello}}</text>复制代码

Dann in das gleiche Ebenenverzeichnis Schreiben Sie JavaScript wie folgt: <p>

// hello.jsexport default {  data: {    hello: 'PPT'
  },
  boil() {    this.hello = '核武器';
  }
}复制代码

Solange also auf den Text geklickt wird, wird die boil-Methode aufgerufen, wodurch PPT in einen nuclear umgewandelt wird Waffe.

Was ist dahinter passiert? Studierende, die mit Vue 2.0 vertraut sind, sollten sofort an folgende Dinge denken: <p>

<p> erfordert einen Vorverarbeitungsmechanismus für XML, um es in eine verschachtelte Funktionsstruktur in JS umzuwandeln. Auf diese Weise müssen Sie zur Laufzeit nur eine einfache Auswertung durchführen und können mit JS eine Benutzeroberfläche generieren, die der XML-Struktur entspricht.

<p>Damit der entsprechende Callback ausgeführt werden kann, wenn das onclick-Ereignis ausgelöst wird, ist ein Ereignismechanismus erforderlich. boil 方法，让 PPT 变成 核武器。

<p>这背后发生了什么呢？熟悉 Vue 2.0 的同学应该会立刻联想到下面这几件事：

• 需要对 XML 的预处理机制，将其转换为 JS 中的嵌套函数结构。这样只需在运行时做一次简单 eval ，即可用 JS 生成符合 XML 结构的 UI。
• 需要事件机制，使得触发 onclick 事件时能执行相应回调。
• 需要数据劫持机制，使得对 this.hello 赋值时能执行相应回调。
• 需要能在回调中更新 UI 对象控件。

<p>这几件事分别是怎么实现的呢？简单说来是这样的：

• XML 预处理依赖现成的 NPM 开源包，从而把 XML 中的 onclick 属性转换为 JS 对象的属性字段。
• 事件的注册和触发都直接由 C++ 实现。如上一步所获得的 JS 对象 onclick 属性会在 C++ 中被检查和注册，相当于全部组件均为原生。
• 数据劫持机制用 JS 实现，是个基于 Object.defineProperty 的（几百行量级的）ViewModel。
• UI 控件的更新，会在 ViewModel 自动执行的 JS 回调中，调用 C++ 的原生方法实现。这部分完全隐式完成，并未开放 document.createElement 式的标准化 API。

<p>由于大量常见 JS 框架中的能力都直接做进了 C++，所以整套 GUI 技术栈里用纯 JavaScript 所实现的东西（主要见 ace_lite_jsfwk 仓库下的 core/index.js、observer.js 和 subject.js

Ein Daten-Hijacking-Mechanismus ist erforderlich, damit der entsprechende Rückruf ausgeführt werden kann, wenn this.hello ein Wert zugewiesen wird. <p>Es muss möglich sein, UI-Objektsteuerelemente in Rückrufen zu aktualisieren.

<p>Wie werden diese Dinge erreicht? Um es einfach auszudrücken: Die

<p>XML-Vorverarbeitung

basiert auf dem vorgefertigten NPM-Open-Source-Paket, um das onclick-Attribut in XML in das Attributfeld des JS-Objekts zu konvertieren. 🎜🎜🎜Ereignisregistrierung und -auslösung🎜 werden direkt in C++ implementiert. Das onclick-Attribut des im vorherigen Schritt erhaltenen JS-Objekts wird überprüft und in C++ registriert, was der nativen Funktionalität aller Komponenten entspricht. 🎜🎜🎜Daten-Hijacking-Mechanismus🎜 ist in JS implementiert und ist ein ViewModel (Hunderte von Zeilen groß), das auf Object.defineProperty basiert. 🎜🎜🎜UI-Steuerungsaktualisierungen🎜 werden durch den Aufruf nativer C++-Methoden im JS-Rückruf implementiert, der automatisch von ViewModel ausgeführt wird. Dieser Teil erfolgt vollständig implizit und stellt keine standardisierte API im document.createElement-Stil bereit. 🎜🎜🎜Da eine große Anzahl von Funktionen in gängigen JS-Frameworks direkt in C++ implementiert sind, ist der gesamte GUI-Technologie-Stack in reinem JavaScript implementiert (siehe hauptsächlich core/ unter dem Warehouse-Index <code>ace_lite_jsfwk). js, observer.js und subject.js), was gleichbedeutend damit ist, nur diese Funktion zu haben: 🎜🎜🎜Ein ViewModel, das beobachtet werden kann. 🎜🎜🎜Was die Implementierungskomplexität und -qualität des reinen JS-Framework-Teils betrifft, kann es objektiv gesehen als guter Bonus im Rekrutierungsgespräch für Schulen verwendet werden, wenn es sich um eine persönliche Amateurarbeit handelt. 🎜🎜JS-Engine und Laufzeitschicht🎜🎜Nachdem wir die JS-Framework-Schicht verstanden haben, können wir entweder denken, dass „Hongmeng 2.0“ sich für eine tiefgreifende Anpassung des stark vereinfachten Vue an C++ entscheidet, oder wir können denken, dass es sich stark um die stark vereinfachte (und Private) DOM implementiert das unterstützende Front-End-Framework. Wenn wir die Prinzipien dieser GUI weiter erforschen wollen, müssen wir daher ihren C++-Teil betreten und die Implementierung ihrer JS-Engine und Laufzeitschicht verstehen. 🎜<p>Was sind die Unterschiede und Zusammenhänge zwischen JS-Engine und Laufzeit? JS-Engines müssen im Allgemeinen nur der ECMA-262-Spezifikation entsprechen, die keine Plattform-APIs mit „Nebeneffekten“ definiert. Von setTimeout über document.getElementById über console.log bis fs.readFile können diese alle tatsächlichen E/A-Vorgänge ausführen Die Funktionalität muss von einer Laufzeit bereitgestellt werden, die „die Engine-API und die Plattform-API zusammenhält“. Das Prinzip der Laufzeit selbst ist nicht kompliziert. In meinem persönlichen Artikel „Von der JS-Engine zur JS-Runtime“ können Sie beispielsweise sehen, wie Sie mithilfe der vorgefertigten QuickJS-Engine eine Laufzeit selbst erstellen. setTimeout 到 document.getElementById 到 console.log 再到 fs.readFile，这些能执行实际 IO 操作的功能，都需要由「将引擎 API 和平台 API 胶合到一起」的运行时提供。运行时本身的原理并不复杂，譬如在个人的文章《从 JS 引擎到 JS 运行时》中，你就可以看到如何借助现成的 QuickJS 引擎，自己搭建一个运行时。

<p>那么在「鸿蒙 2.0」中，JS 运行时是如何搭建出来的呢？有这么几条重点：

• JS 引擎选择了 JerryScript，这是一款由三星开发的嵌入式 JS 引擎。
• 每种形如 <text> 和 <p> 的 XML 标签组件，都对应一个绑定到 JerryScript 上的 C++ Component 类，如 TextComponent 和 pComponent 等。
• 除 UI 原生对象外，还有一系列在 JS 中以 @system 为前缀的 built-in 模块，它们提供了 JS 中可用的 Router / Audio / File 等平台能力（参见 ohos_module_config.h）。

<p>这里特别值得一提的是 Router。它和 vue-router 等常见 Web 平台路由的实现原理有很大区别，是专门在运行时内深度定制的（参见 router_module.cpp、js_router.cpp 和 js_page_state_machine.cpp）。简单说来这个「路由」是这样实现的：

• 在 JS 中调用切换页面的 router.replace 原生方法，走进 C++。
• C++ 中根据新页面 URI 路径（如 pages/detail
Wie ist also die JS-Laufzeit in „Hongmeng 2.0“ aufgebaut? Es gibt mehrere wichtige Punkte:
Die JS-Engine hat sich für JerryScript entschieden, eine eingebettete JS-Engine, die von Samsung entwickelt wurde.
• Jede XML-Tag-Komponente in der Form <text> und <p> entspricht einer an JerryScript gebundenen C++-Komponentenklasse, z. B. TextComponent und <code>pComponent usw.

<p>Zusätzlich zu nativen UI-Objekten gibt es auch eine Reihe integrierter Module mit dem Präfix @system in JS, die Plattformfunktionen wie Router/Audio/Datei in JS bereitstellen (siehe ohos_module_config.h).

<p>

Was hier besonders erwähnenswert ist, ist Router. Es unterscheidet sich stark von den Implementierungsprinzipien allgemeiner Webplattform-Routings wie vue-router. Es wird während der Laufzeit speziell tiefgreifend angepasst (siehe router_module.cpp, js_router.cpp und). js_page_state_machine.cpp). Einfach ausgedrückt wird dieses „Routing“ wie folgt implementiert: <p>

Rufen Sie die native Methode router.replace zum Seitenwechsel in JS auf und geben Sie C++ ein. <p>
Laden Sie in C++ das neue Seiten-JS entsprechend dem neuen Seiten-URI-Pfad (z. B. pages/detail), erstellen Sie eine neue Seitenzustandsmaschineninstanz und versetzen Sie sie in den Init-Status.

Rufen Sie im Init-Prozess der neuen Zustandsmaschine die JS-Engine auf, um den JS-Code der neuen Seite auszuwerten und das ViewModel der neuen Seite abzurufen.

Routenparameter an das ViewModel anhängen und die alte Zustandsmaschine und ihre JS-Objekte zerstören.

<p>
Wir können also feststellen, dass die sogenannte „Switch-Route“ hier tatsächlich näher an der „Aktualisierungsseite“ des Webbrowsers liegt. Können wir also davon ausgehen, dass die Fähigkeiten dieser JS-Laufzeit bereits den Browser-Kernel auf WebKit-Ebene messen können? <p>
Natürlich ist es noch ein langer Weg. Im Vergleich zu WebKit unterstützt es weder das Parsen von HTML und CSS (beide werden während der Entwicklungsphase mit demselben Ausführungseffekt analysiert und in JS konvertiert), noch besteht die Herausforderung, Ressourcen kontinuierlich dynamisch zu laden, zu analysieren und auszuführen der Browser (klein Das Programm ist nichts weiter als ein paar lokale statische JS-Dateien). Was den Satz, das Layout und die Darstellung betrifft, gibt es natürlich eine große Lücke, die im letzten Abschnitt erwähnt wird. 🎜🎜Darüber hinaus glaube ich, dass viele Studenten neugierig auf die JerryScript-Engine sein werden. Dieser Abschnitt schließt mit der Weitergabe einiger persönlicher Informationen zu diesem Thema. 🎜🎜Die JerryScript-Engine ist ein speziell für eingebettete Hardware implementierter JS-Interpreter und unterstützt nur den ES5.1-Standard. Im QuickJS Benchmark können Sie die Ergebnisse des Leistungsvergleichs einsehen: 🎜🎜🎜🎜🎜🎜🎜Sie können sehen, dass JerryScript in Bezug auf die Leistung in JIT-freien Engines deutlich schwächer ist als QuickJS und Hermes. Im Vergleich zum V8 mit eingeschaltetem JIT ist er sogar zwei Größenordnungen langsamer. Daher ist dies eine sehr spezifische Engine für Low-End-Geräte. Wenn Sie grundlegende Bibliotheken unterstützen müssen, die in mittleren und großen Front-End-Projekten wie React und Vue (oder sogar den entsprechenden Familien-Buckets) Standard sind, benötigen Sie möglicherweise noch einen stärkeren Motor zu verwenden. 🎜🎜 Was die Verwendung von JerryScript betrifft, ist RT-Thread-Gründer @midnightbear zweifellos derjenige mit großer Anwendungserfahrung in diesem Szenario. Die Smartwatch, die sie in Zusammenarbeit mit einem inländischen First-Tier-Hersteller entwickelt haben, verwendete JerryScript, um die aktuelle Benutzeroberfläche zu implementieren Das Produkt wird bald auf den Markt kommen. Einige Rückmeldungen ihres Teams zur Verwendung von JerryScript stimmen ebenfalls mit der obigen Bewertung überein. Zusammenfassend lautet es wie folgt: 🎜
• JerryScript 在体积和内存占用上，相比 QuickJS 有更好的表现。
• JerryScript 的稳定性弱于 QuickJS，有一些难以绕过的问题。
• JerryScript 面对稍大（1M 以上）的 JS 代码库，就有些力不从心了。
<p>那么师出名门的 QuickJS 和 Facebook 的 Hermes，是否就是无 JIT 式 JS 引擎的下一代标杆了吗？倒也未必如此。这方面可以参考个人的知乎回答：随着 TypeScript 继续普及，会不会出现直接跑 TypeScript 的运行时？这里提到的微软为教育项目 MakeCode 研发的 Static TypeScript，就相当有潜力成为下一代的高性能 JS 系语言环境。通过限定 TypeScript 的静态强类型子集并为其搭建工具链，STS 可以做到无需 JIT 也能接近 V8 的性能水平，同时内存占用比 V8 少两个数量级。这使得 STS 不光能用于开发普通 app 这类 IO 密集的应用，还能顺利在嵌入式硬件上开发小游戏这类更偏计算密集（需逐帧更新渲染）的应用，在工程能力上是一项很大的突破。
<p>所以说，当「鸿蒙 2.0」还需要熟练开发者勉强搭建出环境跑通 Hello World 时，微软已经让上百万小朋友都能用 TypeScript 在网页里给教学用的掌上游戏机写小游戏入门编程了。这里没什么唱反调的意思，只希望提醒一下我们在为国产「里程碑」欢呼时，也要清醒地看到业界前沿的动向，仅此而已。

图形绘制层

<p>理解 JS 运行时之后，还剩最后一个问题，即 JS 运行时中的各种 Component 对象，是如何被绘制为手表等设备上的像素的呢？
<p>这就涉及「鸿蒙 2.0」中的另一个 graphic_lite 仓库了。可以认为，这里才是真正执行实际绘制的 GUI。像之前的 TextComponent 等原生组件，都会对应到这里的某种图形库 View。它以一种相当经典的方式，在 C++ 层实现并提供了「Canvas 风格的立即模式 GUI」和「DOM 风格的保留模式 GUI」两套 API 体系（对于立即模式和保留模式 GUI 的区别与联系，可参见个人这篇 IMGUI 科普回答）。概括说来，这个图形子系统的要点大致如下：
• 图形库提供了 UIView 这个 C++ 控件基类，其中有一系列形如 OnClick / OnLongPress / OnDrag 的虚函数。基本每种 JS 中可用的原生 Component 类，都对应于一种 UIView 的子类。
• 除了各种定制化 View 之外，它还开放了一系列形如 DrawLine / DrawCurve / DrawText 等命令式的绘制方法。
• 这个图形库具备名为 GFX 的 GPU 加速模块，但它目前似乎只有象征性的 FillArea 矩形单色填充能力。
<p>在基础 UI 控件方面，不难找到一些值得一提的自研模块特性：
• 支持了简易的 RecycleView 长列表。
• 支持了简易的 Flex 布局。
• 支持了内部的 Invalidate 脏标记更新机制。
<p>至于 2D UI 渲染中的几项关键能力，则基本可分为路径、位图和文字三类。这个图形库在这几个方面都有涉及，最后简单介绍一下。
<p>首先对于位图，这个图形库依赖了 libpng 和 libjpeg 做图像解码，然后即可使用内存中的 bitmap 图像做绘制。
<p>然后对于路径，这个图形库自己实现了各种 CPU 中的像素绘制方法，典型的例子就是这个贝塞尔曲线的绘制源码：

void DrawCurve::DrawCubicBezier(const Point& start, const Point& control1, const Point& control2, const Point& end,    const Rect& mask, int16_t width, const ColorType& color, OpacityType opacity)
{    if (width == 0 || opacity == OPA_TRANSPARENT) {        return;
    }

    Point prePoint = start;    for (int16_t t = 1; t <= INTERPOLATION_RANGE; t++) {
        Point point;
        point.x = Interpolation::GetBezierInterpolation(t, start.x, control1.x, control2.x, end.x);
        point.y = Interpolation::GetBezierInterpolation(t, start.y, control1.y, control2.y, end.y);        if (prePoint.x == point.x && prePoint.y == point.y) {            continue;
        }

        DrawLine::Draw(prePoint, point, mask, width, color, opacity);
        prePoint = point;
    }
}复制代码

<p>基于高中的数学知识，我们不难明白这种曲线是如何绘制出来的：取足够多的点（也就是那个默认 1000 的 INTERPOLATION_RANGE）作为插值输入，逐点计算出曲线表达式的 XY 坐标，然后直接修改像素位置所在的 framebuffer 内存即可。这种教科书式的实现是最经典的，不过如果要拿它对标 Skia 里的黑魔法，还是不要勉为其难了吧。

<p>最后对于文字的绘制，会涉及一些字体解析、定位、RTL和折行等方面的处理。这部分实际上也是组合使用了一些业界通用的开源基础库来实现的。比如对于「牢」这个字，就可以找到图形库的这么几个开源依赖，它们各自扮演不同的角色：

• harfbuzz - 用来告诉调用者，应该把「牢」的 glyph 字形放在哪里。
• freetype - 从宋体、黑体等字体文件中解码出「牢」的 glyph 字形，将其光栅化为像素。
• icu - 处理 Unicode 中许多奇葩的特殊情况，这块个人不了解，略过。

<p>到这里，我们就可以理出一个非常概括性的渲染流程了：

Führen Sie Code wie

in
• this.hello = 'PPT'JS aus, um die Abhängigkeitsverfolgung auszulösen.
• JS-Abhängigkeitsverfolgungsrückruf löst native Funktionen aus, um den Komponentenstatus der C++-Komponente zu aktualisieren.
• Component aktualisiert den Status seiner gebundenen UIView-Unterklasse und löst so Aktualisierungen der Grafikbibliothek aus.
• Die Grafikbibliothek aktualisiert den Pixelstatus im Speicher, um die Zeichnung abzuschließen.

<p>Dies ist meine persönliche Interpretation des GUI-Technologie-Stacks von „Hongmeng 2.0“. Aus Zeitgründen habe ich mich nicht weiter damit beschäftigt und (zivilisierte) Kritik und Korrekturen sind willkommen.

Zusammenfassung

<p>Besonderer Hinweis: Diese subjektive Rezension bezieht sich nur auf das aktuelle GUI-Framework von „Hongmeng 2.0“, bitte interpretieren Sie sie nicht nach Belieben falsch.

<p>Was die Highlights von „Hongmeng 2.0“ im GUI-Teil betrifft, fallen mir persönlich folgende ein:

• Es hat zwar pragmatischen (aber völlig anderen als die damalige PPT-Einführung) Code.
• Es handelt sich nicht um eine WebView-Shell, das Layout und die Zeichnung werden von Ihnen selbst erstellt.
• Sie benötigen keine über das Grundniveau hinausgehenden Computerkenntnisse, um reibungslos lesen und verstehen zu können.

<p>Was die offensichtlichen (nicht nur einige hässliche Codezeilen) Mängel oder Probleme betrifft, so scheint es derzeit Folgendes zu geben:

• JS-Framework-Schicht
  • verfügt nicht über eine grundlegende Kommunikation zwischen Komponenten (z. B Requisiten / Emittieren usw.) Funktionen
  • Keine grundlegenden Funktionen für benutzerdefinierte Komponenten
  • Keine Statusverwaltungsfunktionen außer der grundlegenden Abhängigkeitsverfolgung
• JS-Engine und Laufzeitebene
  • Die Standardunterstützung ist zu gering, um Vue 3.0 und die auszuführen wie Das Front-End-Framework der nächsten Generation, das Proxy erfordert
  • hat eine schwache Leistung und ist schwierig, mittlere und große JS-Anwendungen zu unterstützen
  • Es gibt keine offene Objektmodell-API im DOM-Stil, was der Glättung der Unterschiede nicht förderlich ist in der oberen Ebene
• Die Grafik-Rendering-Ebene
  • hat keine Substanz. Verfügbare GPU-Beschleunigung
  • Keine erweiterten Rendering-Funktionen wie SVG und Rich Text
  • Canvas hat eine geringe Fertigstellung, es fehlen Statusstapel und viele APIs

<p>Es scheint viele Mängel zu haben, aber würden Sie dem Auto die Schuld geben, dass es kein Düsentriebwerk hat? Für Szenarien unterschiedlicher Komplexität gibt es natürlich unterschiedliche optimale Architekturdesigns. Derzeit scheint dieses Design tatsächlich sehr gut für eingebettete Hardware und einfache Szenarien mit „kleinen Programmen“ geeignet zu sein. Wenn wir es jedoch nach den sogenannten „verteilten, plattformübergreifenden Vollszenario-Anforderungen“ betrachten, ist die Komplexität dieser Architektur völlig unvergleichbar mit modernen Webbrowsern oder iOS- und Android-GUIs. Wenn Sie es auf einem Mobiltelefon implementieren möchten, müssen Sie mit ziemlicher Sicherheit eine große Anzahl komplexer Module hinzufügen und sich einer erheblichen architektonischen Weiterentwicklung und Neugestaltung unterziehen.

<p>Natürlich werden Autohersteller nicht sagen, dass sie Flugzeuge bauen, oder?

<p>Kurz gesagt, das ist zwar ein Teller mit hausgemachtem Mapo-Tofu, aber es ist nicht das Mandschu-Han-Bankett, wie manche Leute sagen.

<p>Abschließend noch ein persönlicher subjektiver Kommentar:

<p>Zuallererst hat dieser GUI-Technologie-Stack das Mainstream-Niveau erreicht, das durch Zusammenstellen und Ausleihen von Open-Source-Produkten erreicht werden kann. In Bezug auf Leistung und Ausdruckskraft besteht jedoch immer noch eine Generationslücke um eine Größenordnung zwischen seinen Kernmodulen und branchenführenden Branchen-, Universitäts- und Forschungslösungen wie Microsoft MakeCode.

<p>Zweitens: Betrachten Sie es nicht als Raketenwissenschaft, die Präzisionsberechnungen einer großen Anzahl von Experten erfordert – das soll nicht die unabhängige Forschung und Entwicklung herabsetzen, aber ich hoffe aufrichtig, dass jeder verstehen kann: „Das kann ich auch tatsächlich.“ Beteiligen Sie sich an dieser Angelegenheit! " Betriebssystem und Die GUI ist nicht so mysteriös. Es gibt viele inländische ausgereifte Open-Source-Produkte zum Lernen, Verwenden und Mitmachen (übrigens empfehle ich RT-Thread, das sehr einfach zu erleben ist und auch in China hergestellt, als Early Adopter). Denn nur wenn man wirklich versteht, wie ein Produkt technisch beschaffen ist, ist es doch weniger wahrscheinlich, dass es von Menschen mit Hintergedanken manipuliert wird, oder?

<p>Abschließend für alle Frontend-Entwickler, die mit JavaScript vertraut sind: Warum lachen Sie immer noch auf seltsame Weise über Hongmeng? Hongmeng ist der Reichtumscode von JavaScript in China! JavaScript wird von einer „nationalen Waffe“ wie Hongmeng übernommen, was das Straßenvertrauen, das theoretische Vertrauen, das kulturelle Vertrauen und das Vertrauen in den Technologie-Stack des Front-Ends erheblich verbessern kann. Solange wir Spleißen und Selbstforschung auf diese Weise kombinieren, können wir auf einen Schlag im ganzen Land hohes Ansehen erlangen. Dieser Weg ist wirklich faszinierend (flüstern)

<p>Wir müssen uns zusammenschließen und JavaScript energisch fördern und fördern, um mit den Majors zu konkurrieren Streben Sie danach, das Niveau der nuklearen Abschreckung in China zu erreichen, und streben Sie danach, das Niveau zu erreichen, auf dem Sie jeder respektieren wird, solange Sie sagen, dass Sie JavaScript schreiben können – solange Sie ein Front-End-Programmierer sind, können Sie springen Beim Ticketkauf in der Schlange stehen, bei einer Fahrt den Sitzplatz aufgeben und umsonst Sex haben... …Gute Zeiten stehen vor der Tür!

<p>Möchten Sie eine Säule des Landes werden? Lass uns JavaScript schreiben!

<p>Keine Worte mehr, ich werde hart daran arbeiten, das Land zu verjüngen!

<p>Wenn Sie mehr über das Erlernen des Programmierens erfahren möchten, achten Sie bitte auf die Spalte „PHP-Schulung“!

Das obige ist der detaillierte Inhalt vonWerfen wir einen Blick auf den JavaScript-GUI-Technologie-Stack von Hongmeng. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!