盘点 Solid.js 源码中的那些迷惑行为

Solid.js详解:新一代前端框架的崛起 (命令式 → 组件化 → 编译时优化 → 细粒度响应式)// 原生信号实现示例// 依赖收集逻辑// 完整生命周期示例}, 1000);});}); 阅读详情

前言

我研究 Solid.js 源码已经有一段时间了,在钻研的过程中我发现了其中的一些迷惑行为,在搞懂之后终于恍然大悟,忍不住想要分享给大家。不过这么说其实也不太准确,因为在严格意义上来讲 Solid.js 其实是被划分为了两个部分的。我只认真钻研了其中一个部分,所以也不能说钻研 Solid.js 源码,因为另外一个部分压根就不叫 Solid。

有些同学看到这可能就会感到疑惑了,哪两个部分?Solid、.js?其实是这样:大家应该都听说过 Solid.js 是一个重编译、轻运行的框架吧,所以它可以被分为编译器和运行时两个部分。那有人可能会问:你要是这么说的话那岂不是 Vue 也可以被分为两部分,毕竟 Vue 也有编译器和运行时,为什么从来没有人说过 Vue 是两部分组成的呢?是这样,Vue 的编译器和运行时全都放在了同一仓库内的 Monorepo 中:

你可以说 Vue2 和 Vue3 是两个部分,因为它俩被放在了两个不同的仓库中:

虽然它俩已经是两个不同的仓库了,但好歹也都是 vuejs 名下的吧:

而 Solid.js 的两部分不仅不在同一个仓库内,甚至连组织名都不一样:

一个是 solidjs/solid:

而另一个则是 ryansolid/dom-expressions:

ryan 是 Solid.js 作者的名字,所以 ryan + solid = ryansolid(有点迷,为啥不放在 solidjs 旗下非要单独开一个 ryansolid)

这个 dom-expressions 就是 Solid.js 的编译器,那为啥不像 Vue 编译器似的都放在同一个仓库内呢?因为 Vue 的编译器就是专门为 Vue 设计的,你啥时候看非 Vue 项目中使用 xxx.vue 这样的写法过?.vue 这种单文件组件就只有 Vue 使用,虽说其他框架也有单文件组件的概念并且有着类似的写法(如:xxx.svelte)但人家 Svelte 也不会去用 Vue 的编译器去编译人家的 Svelte 组件。不过 Solid 不一样,Solid 没自创一个 xxx.solid,而是明智的选择了 xxx.jsx。

单文件组件和 jsx 各有利弊,不能说哪一方就一定比另一方更好。但对于一个声明式框架作者而言,选择单文件组件的好处是可以自定义各种语法,并且还可以牺牲一定的灵活性来换取更优的编译策略。缺点就是成本太高了,单单语法高亮和 TS 支持度这一方面就得写一个非常复杂的插件才能填平。好在 Vue 的单文件组件插件 Volar 已经可以支持自定义自己的单文件组件插件了,这有效的降低了框架作者的开发成本。但 Solid 刚开始的时候还没有 Volar 呢(可以去看看 Volar 的源码有多复杂 这还仅仅只是一个插件就需要花费那么多时间和精力),甚至直到现在 Volar 也没个文档,就只有 Vue 那帮人在用 Volar(毕竟是他们自己研究的):

并且人家选择 jsx 也有可能并非是为了降低开发成本,而是单纯的钟意于 jsx 语法而已。那么为什么选择 jsx 会降低开发成本呢?首先就是不用自己写 parser、generator 等一堆编译相关的东西了,一个 babel 插件就能识别 jsx 语法。语法高亮、TS 支持度这方面更是不用操心,甚至用户都不需要为编辑器安装任何插件(何时听过 jsx 插件)。并且由于 React 是全球占有率最高的框架,jsx 已被广泛接受(甚至连 Vue 都支持 jsx)但如果选择单文件组件的话又会产生有人喜欢这种写法有人喜欢那种写法的问题,比方说同样使用 sfc 的 Vue 和 Svelte,if-else 写法分别是这样:

<!-- Vue -->
<template>
  <h1 v-if="xxx" />
  <div v-else />
</template>
<!-- Svelte -->
{#if xxx}
  <h1 />
{:else}
  <div />
{/if}

有人喜欢上面那种写法就有人喜欢下面那种写法,众口难调,无论选择哪种写法可能都会导致另一部分的用户失望。而 jsx 就灵活的多了,if-else 想写成什么样都可以根据自己的喜好来:

if (xxx) {
  return <h1 />
} else {
  return <div />
}
// 或者
return xxx ? <h1 /> : <div />
// 亦或
let Title = 'h1'
if (xxx) Title = 'div'
return <Title />

jsx 最大程度的融合了 js,正是因为它对 js 良好的兼容性才导致它的适用范围更广,而不是像 Vue、Svelte 那样只适用于自己的框架。毕竟每种模板语言的 if-else、循环等功能写法都不太一样,当然 jsx 里的 if-else 也可以有各种千奇百怪的写法,但毕竟还是 js 写法,而不是自创的 ng-if、v-else、{:else if} {% for i in xxx %}等各种不互通的写法。

正是由于 jsx 的这个优势导致了很多非 React 框架(如:Preact、Stancil、Solid 等)用 jsx 也照样用的飞起,那么既然 jsx 可以不跟 React 绑定,那 Ryan 自创的 jsx 编译策略也同样可以不跟 Solid 绑定啊对不对?这是一款可以和 Solid.js 搭配使用的 babel 插件,也同样是一款可以和 MobX、和 Knockout、和 S.js、甚至和 Rx.js 搭配使用的插件,只要你有一款响应式系统,那么 dom-expressions 就可以为你提供 jsx 服务。

所以这才是 Ryan 没把 dom-expressions 放在 solidjs/solid 里的重要原因之一,但 Solid.js 又是一个注重编译的框架,没了 dom-expressions 还不行,所以只能说 Solid.js 是由两部分组成的。

DOM Expressions

DOM Expressions 翻译过来就是 DOM 表达式的意思,有人可能会问那你标题为啥不写成《盘点 DOM Expressions 源码中的那些迷惑行为》?拜托!谁知道 DOM Expressions 到底是个什么鬼!如果不是我苦口婆心的说了这么多,有几个能知道这玩意就是 Solid.js 的编译器,甭说国内了,就连国外都没几个知道 DOM Expressions 的。你要说 Solid.js 那别人可能会竖起大拇指说声 Excellent,但你要说 DOM Expressions 那别人说的很可能就是 What the fuck is that? 了。不信你看它俩的🌟对比:

再来看看 Ryan 在油管上亲自直播 DOM Expressions时的惨淡数据:

这都没我在掘金随便写篇文章的点赞量高,信不信如果我把标题中的 Solid.js 换成了 DOM Expression 的话点赞量都不会有 Ryan 直播的数据好?好歹人家还是 Solid 的作者,都只能获得如此惨淡的数据,那更别提我了。

言归正传,为了防止大家不知道 Solid.js 编译后的产物与 React 编译后的产物有何不同,我们先来写一段简单的 jsx:

import c from 'c'
import xxx from 'xxx'

export function Component () {
  return (
    <div a="1" b={2} c={c} onClick={() => {}}>
      { 1 + 2 }
      { xxx }
    </div>
  )
}

React 编译产物:

import c from 'c';
import xxx from 'xxx';
import { jsxs as _jsxs } from "react/jsx-runtime";
export function Component() {
  return /*#__PURE__*/_jsxs("div", {
    a: "1",
    b: 2,
    c: c,
    onClick: () => {},
    children: [1 + 2, xxx]
  });
}

Solid 编译产物:

import { template as _$template } from "solid-js/web";
import { delegateEvents as _$delegateEvents } from "solid-js/web";
import { insert as _$insert } from "solid-js/web";
import { setAttribute as _$setAttribute } from "solid-js/web";
const _tmpl$ = /*#__PURE__*/_$template(`<div a="1" b="2">3`);
import c from 'c';
import xxx from 'xxx';
export function Component() {
  return (() => {
    const _el$ = _tmpl$(),
      _el$2 = _el$.firstChild;
    _el$.$$click = () => {};
    _$setAttribute(_el$, "c", c);
    _$insert(_el$, xxx, null);
    return _el$;
  })();
}
_$delegateEvents(["click"]);

Solid 编译后的产物乍一看有点不太易读,我来给大家写一段伪代码,用来帮助大家快速理解 Solid 到底把那段 jsx 编译成了啥:

import c from 'c';
import xxx from 'xxx';

const template = doucment.createElement('template')
template.innerHTML = '<div a="1" b="2">3</div>'
const el = template.content.firstChild.cloneNode(true) // 大家可以简单的理解为 el 就是 <div a="1" b="2">3</div>

export function Component() {
  return (() => {
    el.onclick = () => {};
    el.setAttribute("c", c);
    el.insertBefore(xxx);
    return el;
  })();
}

这样看上去就清晰多了吧?直接编译成了真实的 DOM 操作,这也是它性能为何能够如此强悍的原因之一,没有中间商(虚拟DOM)赚差价。但大家有没有感觉有个地方看起来好像有点多此一举,就是那个自执行函数:

export function Component() {
  return (() => {
    el.onclick = () => {};
    el.setAttribute("c", c);
    el.insertBefore(xxx);
    return el;
  })();
}

为何不直接编译成这样:

export function Component() {
  el.onclick = () => {};
  el.setAttribute("c", c);
  el.insertBefore(xxx);
  return el;
}

效果其实都是一样的,不信你试着运行下面这段代码:

let num = 1
console.log(num) // 1

num = (() => {
  return 1
})()
console.log(num) // 还是 1 但感觉多了一个脱裤子放屁的步骤

看了源码才知道,原来看似多此一举的举动实则是有苦衷的。因为我们这是典型的站在上帝视角来审视编译后的代码,源码的做法是只对 jsx 进行遍历,在刚刚那种情况下所编译出来的代码确实不是最优解,但它能保证在各种的场景下都能正常运行。我们来写一段比较罕见的代码大家就能明白过来怎么回事了:

if (<div a={value} onClick={() => {}} />) {
  // do something…
}

当然这么写没有任何的意义,这是为了帮助大家理解为何 Solid 要把它的 jsx 编译成一段自执行函数才会写成这样的。我们来写一段伪代码,实际上 Solid 编译出来的并不是这样的代码,但相信大家能够明白其中的含义:

<div a={value} onClick={() => {}} />
// 将会被编译成
const el = document.createElement('div')
el.setAttribute('a', value)
el.onclick = () => {}

发现问题所在了么?原本 jsx 只有一行代码,但编译过后却变成三行了。所以如果不加一个自执行函数的话将会变成:

if (const el = document.createElement('div'); el.setAttribute('a', value); el.onclick = () => {}) {
  // do something…
}

这很明显是错误的语法,if 括号里根本不能写成这样,会报错的!但如果把 if 括号里的代码放在自执行函数中那就没问题了:

if ((() => {
  const el = document.createElement('div')
  el.setAttribute('a', value)
  el.onclick = () => {}
  return el
})()) {
  // do something…
}

我知道肯定有人会说把那三行代码提出去不就得了么:

const el = document.createElement('div')
el.setAttribute('a', value)
el.onclick = () => {}
if (el) {
  // do something…
}

还记得我之前说过的那句:我们是站在上帝视角来审判 Solid 编译后代码的么?理论上来说这么做确实可以,但编译成本无疑会高上许多,因为还要判断 jsx 到底写在了哪里,根据上下文的不同来生成不同的代码,但这样肯定没有只编译 jsx 而不管 jsx 到底是被写在了哪里来的方便。而且我们上述的那种方式也不是百分百没问题的,照样还是会有一些意想不到的场景:

for (let i = 0, j; j = <div a={i} />, i < 3; i++) {
  console.log(j)
}

但假如按照我们那种策略来编译代码的话:

const el = document.createElement('div')
el.setAttribute('a', i)
for (let i = 0, j; j = el, i < 3; i++) {
  console.log(j)
}

此时就会出现问题,因为 el 用到了变量 i,而 el 又被提到外面去了所以访问不到 i 变量,所以 el 这几行代码必须要在 jsx 的原位置上才行,只有自执行函数能够做到这一点。由于 js 是一门极其灵活的语言,各种骚操作数不胜数,所以把编译后的代码全都加上一段自执行函数才是性价比最高并且最省事的选择之一。

谜之叹号

有次在用 playground.solidjs.com 编译 jsx 时惊奇的发现:

不知大家看到这段 <h1>Hello, <!>!</h1> 时是什么感受,反正我的第一感觉就是出 bug 了,把我的叹号 ! 给编译成 <!> 了。但令人摸不着头脑的是,这段代码完全可以正常运行,没有出现任何的 bug。随着测试的深入,发现其实并不是把我的叹号 ! 给编译成 <!> 了,只是恰巧在那个位置上我写了个叹号,就算不写叹号也照样会有这个 <!> 的:

image.png

发现没?<!> 出现的位置恰巧就是 {xxx} 的位置,我们在调试的时候发现最终生成的代码其实是这样:

<h1>1<!---->2</h1>

也就是说当我们 .innerHTML = '<!>' 的时候其实就相当于 .innerHTML = '<!---->' 了,很多人看到这个空注释节点以后肯定会联想到 Vue,当我们在 Vue 中使用 v-if="false" 时,按理说这个节点就已经不复存在了。但每当我们打开控制台时就会看到原本 v-if 的那个位置变成了这样:

尤雨溪为何要留下一个看似没有任何意义的空注释节点呢?广大强迫症小伙伴们忍不了了,赶忙去 GitHub 里开个 issue 问尤雨溪:

尤雨溪给出的答案是这样:

那 Solid 加一个这玩意也是和 Vue 一样的原由么?随着对源码的深入,我发现它跟 Vue 的 <!----> 原由并不一样,我们再来用一段伪代码来帮助大家理解 Solid 为什么需要一段空注释节点:

<h1>1{xxx}2</h1>
// 将会被编译成:
const el = template('<h1>1<!---->2</h1>')
const el1 = el.firstChild  // 1
const el2 = el1.nextSibling  // <!---->
const el3 = el2.nextSibling  // 2

// 在空节点之前插入 xxx 而空节点恰好就在 1 2 之间 所以就相当于在 1 2 之间插入了 xxx
el.insertBefore(xxx, el2)

看懂了么,Solid 需要在 1 和 2 之间插入 xxx,如果不加这个空节点的话那就找不到该往哪插了:

<h1>1{xxx}2</h1>
// 假如编译成没有空节点的样子:
const el = template('<h1>12</h1>')
const el1 = el1.firstChild  // 12
const el2 = el2.nextSibling  // 没有兄弟节点了 只有一个子节点:12

el.insertBefore(xxx, 特么的往哪插?)

所以当大家在 playground.solidjs.com 中发现有 <!> 这种奇怪符号时,请不要觉得这是个 bug,这是为了留个占位符,方便 Solid 找到插入点。只不过大多数人都想不到,把这个 <!> 赋值给 innerHTML 后会在页面上生成一个 <!---->。

迷之 ref

无论是 Vue 还是 React 都是用 ref 来获取 DOM 的,Solid 的整体 API 设计的与 React 较为相似,ref 自然也不例外:

但它也有自己的小创新,就是 ref 既可以传函数也可以传普通变量。如果是函数的话就把 DOM 传进去,如果是普通变量的话就直接赋值:

// 伪代码
<h1 ref={title} />
// 将会编译成:
const el = document.createElement('h1')
typeof title === 'function'
  ? title(el)
  : title = el

但在查看源码时发现了一个未被覆盖到的情况:

// 简化后的源码
transformAttributes () {
  if (key === "ref") {
    let binding,
        isFunction =
      t.isIdentifier(value.expression) &&
      (binding = path.scope.getBinding(value.expression.name)) &&
      binding.kind === "const";

    if (!isFunction && t.isLVal(value.expression)) {
      ...
    } else if (isFunction || t.isFunction(value.expression)) {
      ...
    } else if (t.isCallExpression(value.expression)) {
      ...
    }
  }
}

稍微给大家解释一下,这个 transformAttributes 是用来编译 jsx 上的属性的:

当 key 等于 ref 时需要进行一些特殊处理,非常迷的一个命名就是这个 isFunction,看名字大家肯定会认为这个变量代表的是属性值是否为函数。我来用人话给大家翻译一下这个变量赋的值代表什么含义:t.isIdentifier(value.expression) 的意思是这个 value 是否为变量名:

比方说 ref={a} 中的 a 就是个变量名,但如果是 ref={1}、ref={() => {}} 那就不是变量名,剩下那俩条件是判断这个变量名是否是 const 声明的。也就是说:

const isFunction = value 是个变量名 && 是用 const 声明的

这特么就能代表 value 是个 function 了?

在我眼里看来这个变量叫 isConst 还差不多,我们再来梳理一下这段逻辑:

// 简化后的源码
transformAttributes () {
  if (key === "ref") {
    const isConst = value is 常量

    if (!isConst && t.isLVal(value.expression)) {
      ...
    } else if (isConst || t.isFunction(value.expression)) {
      ...
    } else if (t.isCallExpression(value.expression)) {
      ...
    }
  }
}

接下来就是 if-else 条件判断里的条件了,再来翻译下,t.isLVal 代表的是:value 是否可以放在等号左侧,这是什么意思呢?一个例子就能让大家明白:

// 此时 key = 'ref'、value = () => {}
<h1 ref={() => {}} />

// 现在我们需要写一个等号 看看 value 能不能放在等号的左侧:
() => {} = xxx // 很明显这是错误的语法 所以 t.isLVal(value.expression) 是 false

// 但假如写成这样:
<h1 ref={a.b.c} />

a.b.c = xxx // 这是正确的语法 所以 t.isLVal(value.expression) 现在为 true

明白了 t.isLVal 接下来就是 t.isFunction 了,这个从命名上就能看出来是判断是否为函数的。然后就是 t.isCallExpression,这是用来判断是否为函数调用的:

// 这就是 callExpression
xxx()

翻译完了,接下来咱们就来分析一遍:

  • 当 value 不是常量并且不能放在等号左侧时(这种情况有处理)
  • 当 value 是常量或者是一个函数字面量时(这种情况有处理)
  • 当 value 是一个正在调用的函数时(这种情况有处理)

不知大家看完这仨判断后有什么感悟,反正当我捋完这段逻辑的时候感觉有点迷,因为好像压根儿就没覆盖掉全部情况啊!咱们先这么分一下:value 肯定是变量名、字面量以及常量中的其中一种对吧?是常量的情况下有覆盖,不是常量时就有漏洞了,因为它用了个并且符号 &&,也就是说当 value 不是常量时必须还要同时满足不能放在等号左侧这种情况才会进入到这个判断中去,那假如我们写一个三元表达式或者二元表达式那岂不就哪个判断也没进么?不信我们来试一下:

可以看到编译后的 abc 三个变量直接变暗了,哪都没有用到这仨变量,也就是说相当于吞掉了这段逻辑(毕竟哪个分支都没进就相当于没处理)不过有人可能会感到疑惑,三元表达式明明能放到等号左侧啊:

实际上并不是你想的那样,等号和三元表达式放在一起时有优先级关系,调整一下格式你就明白是怎样运行的了:

const _tmpl$ = /*#__PURE__*/_$template(`<h1>Hello`)
a ? b : c = 1
// 实际上相当于
a
  ? b
  : (c = 1)
// 相当于
if (a) {
  b
} else {
  c = 1
}

如果我们用括号来把优先级放在三元这边就会直接报错了:

二元表达式也是同理:

我想在 ref 里写成这样没毛病吧:

<h1 ref={a || b} />

虽然这种写法比较少见,但这也不是你漏掉判断的理由呀!毕竟好多用 Solid.js 的人都是用过 React 的,他们会把在 React 那养成的习惯不自觉的带到 Solid.js 里来,而且这不也是 Solid.js 把 API 设计的尽可能与 React 有一定相似性的重要原因之一吗?但人家在 React 没问题的写法到了你这就出问题了的话,是会非常影响你这框架的口碑的!而且在文档里还没有提到任何关于 ref 不能写表达式的说明:

后来我仔细想了一下,发现还真不是他们不小心漏掉的,而是有意为之。至于为什么会有意为之那就要看它编译后的产物了:

// 伪代码
<div ref={a} />
// 将会被编译为:
const el = template(`<div>`)
typeof a === 'function' ? a(el) : a = el

其中咱们重点看 a = el 这段代码,a 就是我们写在 ref 里的,但假如我们给它换成一个二元表达式就会变成:

// 伪代码
<div ref={a || b} />
// 将会被编译为:
const el = template(`<div>`)
a || b = el

a || b 不能放在等号左侧,所以源码中的 isLVal 就是为了过滤这种情况的。那为什么不能编译成:

(a = el) || (b = el)

这么编译是错的,因为假如 a 为 false,a 就不应该被赋值,但实际上 a 会被赋值为 el:

所以要把二元编译成三元:

如果是并且符号就要编译成取反:

// 伪代码
<div ref={a && b} />
// 将会被编译为:
const el = template(`<div>`)
!a ? a = el : b = el

然后三元表达式以及嵌套三元表达式:

<div
  ref={
    Math.random() > 0.5
      ? refFactory() && refArr[0] && (refTarget1 = refTarget2) && (refTarget1 > refTarget2)
      : refTarget1
        ? refTarget2
        : refTarget3
  }
/>

当然可能并不会有人这么写,Solid 那帮人也是这么想的,所以就算了,太麻烦了,如果真要是有复杂的条件的话可以用函数:

<div
  ref={
    el => Math.random() > 0.5
        ? refTarget1 = el
        : refTarget2 = el
  }
/>

就先不管 isLVal 为 false 的情况了,不过我还是觉得至少要在官网上提一嘴,不然真有人写成这样的时候又搜不到答案的话那多影响口碑啊!

总结

看过源码之后感觉有的地方设计的很巧妙,但有些地方又不是很严谨。也怪 jsx 太灵活了,不可能做判断把所有情况都做到面面俱到,当你要写一些在 React 里能运行的骚操作可能在 Solid 里就哑火了。所以说模版语法和 jsx 各有千秋,同为无虚拟 DOM 框架的 Svelte 就依靠着灵活性受限的模版语法才能编译成命令式 DOM 操作,而 Solid 的 jsx 也已经不再是那个异常灵活的 jsx 了,而是有一定的限制以及在某些情况下有 bug 的阉割版。不过你要是问我喜欢哪个,我还是更喜欢 jsx,但如果是阉割版 jsx 的话… 我可能就更喜欢模版语法了,因为我在 jsx 里还是有挺多骚操作的,不想骚着骚着发现不好使结果又搜不到答案只能去看源码,所以莫不如用只有固定几个用法的模板语法。

那有人可能会讲:你就老老实实的不写太骚的 jsx 不就得了?

怎么说呢,就像是你买了一个新键盘,你难免会把以前在键盘上的那些习惯带到这个新键盘上来吧?结果这个新键盘是阉割版的,某几个不常用的键有 bug,但说明书上还没写,出了 bug 你还纳闷呢!所以在这种情况下莫不如买一个缺了键的键盘,哪怕说不能按,但也比按了出 bug 强吧!毕竟你以前的打字习惯还在呢,缺的键会限制你的打字习惯,你自然而然的就会想出一些替代方案,而不限制你打字习惯的带 bug 键盘必然坑你坑的更惨。

其实也没有说哪个功能 jsx 能实现但模版就实现不了的,顶多就是稍微麻烦点。

往期精彩文章

SolidJS 深度解析:高性能响应式前端框架 它结合了 React 的声明式 UI 和 Svelte 的编译时优化,同时采用。SolidJS 正在成为 React 和 Svelte 之外的。,避免了虚拟 DOM(Virtual DOM)的开销。:避免不必要的节点创建/销毁,性能更高。,特别适合对性能有极高要求的项目。SolidJS 是一个新兴的。SolidJS 提供。 阅读详情

相关推荐

Python实战:用Py2neo轻松玩转Neo4j图数据库(附完整CRUD示例)

本文通过构建武侠知识图谱的实战案例,详细介绍了如何使用Python的Py2neo库对Neo4j图数据库进行CRUD操作。内容涵盖环境搭建、节点与关系创建、Cypher查询、数据更新删除及事务管理,帮助开发者直观高效地处理复杂关联数据,实现从入门到进阶的完整交互流程。

weixin_29034963的博客 185

SolidJS——前端新秀框架,性能直逼原生JS

SolidJS 是什么?SolidJS是一个声明式、高效且灵活用于构建用户界面的 JavaScript 库。 Solid 号称拥有 JSX 语法,类似于 React hook 的语法,你可以用现代化的开发方式,获得性能最快的代码。 一、性能比较 原生 JS 是 1, Solid 是 1.05, 比 Svelte 也快,React 跑到了 1.93 。如图: 二、SolidJS 特点 直接使用浏览器的 DOM, 没有 虚拟DOM, DOM diff 一整套算法 ,可以发现它编译出来的代码,他的 DOM

天问博客-专注于大前端技术 1万+

AIGC大模型应用教学平台

该平台采用最新的AI推理加速芯片,提供30Tops算力和32GB存储,能够运行常见的大语言模型如ChatGLM2、Llama2、Baicuan、Mistral等,也可以运行文生图扩散模型Stable Diffusion,提供大模型微调、量化、转换和加速推理服务。在此基础上,平台还提供常见的生成式AI应用,包括AIGC知识抽取增强(RAG)、AIGC绘画、AIGC会话聊天、数字虚拟人等应用,以便学生能够掌握最新的生成式AI模型微调、提示工程和智能体应用技能。

中智讯的博客 1209

十分钟掌握使用 SolidJS 构建全栈 CRUD 应用程序

我们可以开始讨论SolidJS,说它比React更好,但没有必要做这种比较。SolidJS只是众多前端框架之一,旨在在Web上快速创建数据驱动。那么,我们为什么要突出这个新孩子呢?

Z__7Gk的博客 1768

基于LORA的双机通信的智能农业系统

通过LoRa模块与主机进行通信,监测环境中的温度、湿度、土壤湿度和光照强度等参数,并根据预设的自动控制逻辑或者手动指令控制继电器开关,从而调节风扇、加热器、水泵、喷雾器和灯光等设备,为植物提供适宜的生长环境。使用的Lora是大夏龙雀的感觉这个是我使用过的Lora里面最好用的,因为不用设置频道就可以直接透明传输,使用起来得心应手。就像两个单片机直接串口通信一样,缺点是异步串行,不能同时进行接收和发送。继电器灯亮模拟打开对应的风扇、水泵、灯、喷雾、加热。1.使用温度传感器测当前环境的温湿度。

ssjsjss的博客 1742

Windows下ArduPilot SITL仿真环境搭建与QGC地面站联调全攻略

软件在环仿真(SITL)是无人机开发中的关键一环,它通过将飞控固件运行在PC上,用数学模型模拟传感器数据,实现无硬件依赖的飞行逻辑验证。这项技术不仅降低了试错成本,更为地面站开发、自动化测试和任务规划提供了安全可控的试验场。在工程实践中,MAVLink协议作为飞控与地面站之间的通信桥梁,贯穿仿真、遥测与指令控制全程。结合QGroundControl(QGC)这一主流地面站,开发者可以直观地观察飞行状态、规划航点并记录日志。本文以Windows原生环境为例,详细介绍ArduPilot SITL的搭建流程、MA

weixin_31858171的博客 319

高性能前端UI库 SolidJS | 超棒 NPM 库

SolidJS是一个声明式的、高效的、编译时优化的JavaScript库,用于构建用户界面。它的核心特点是让你能够编写的代码既接近原生JavaScript,又能够享受到现代响应式框架提供的便利。SolidJS的设计哲学强调了性能与简洁性。它不使用虚拟DOM(Virtual DOM),而是通过编译时的静态分析生成高效的真实DOM更新指令。这种方法使得SolidJS在性能方面非常出色,尤其是在渲染和更新视图方面。SolidJS的响应式系统基于细粒度的响应式原语。

王乐平 技术博客 2784

Jetson Nano(1)——笔记本电脑控制

笔记本电脑控制Jetson Nano没有显示屏如何控制Jetson Nano一、使用ssh客户端连接到Jetson Nano的命令端1.将电脑的网线口和jetson nano的网线口通过网线连接2.在控制面版中打开“更改配适器设置”3.查找jetson nano的ip地址4.利用putty链接二、远程桌面配置 没有显示屏如何控制Jetson Nano Jetson Nano相当于一个微型电脑,能快...

weixin_43619070的博客 1万+

工作中使用到的单词(软件开发)

1.エイリアス   alias 别名 powershell使用 get-help 命令时,会得到与此命令 相关(别名)的命令 2.プロキシ proxy 代 理 3.プロモート   promote 促进,提升   开发的系统新功能上线发布,有时会使用到这个词,比如 STプロモート 还有使用リリース这个词的。比如STリリース。个人认为两者含义相同。 4.見逃し み................................................................

sun0322 6万+

博途WinCC多语言项目配置指南

在博途(TIA Portal)中为WinCC项目配置多语言功能,需通过系统化步骤实现界面文本的动态切换。

dhaimo的博客 2478

Java中使用工厂模式和策略模式优雅消除if-else语句(UML类图+案例分析)

在最近的后端开发中,多多少少会发现有很多if-else语句,如果条件过多则会造成整体代码看起来非常臃肿。本篇博客汇总了我对工厂模式和策略模式的理解,以及我是如何把它们巧妙运用在实际项目当中的一些技巧进行了分享,如有问题,欢迎评论区讨论!

黄团团的个人博客 2615

Solidjs 简介

Solid-js的定义 一个声明式、高效且灵活用于构建用户界面的 JavaScript 库(官方文档) 为什么选择Solidjs 高性能 - 始终在公认的 UI 速度和内存利用率基准测试中名列前茅 强大 - 可组合的反应式原语与 JSX 的灵活性相结合 务实 - 合理且量身定制的 API 使开发变得有趣而简单 生产力 - 人体工程学和熟悉程度使构建简单或复杂的东西变得轻而易举 优势 高性能 - 接近原生的性能,在 js-framework-benchmark 排名中名列前茅 极小的打包..

weixin_42287342的博客 3480

IEC 104电力规约详细解读(五) - 遥控

主站下发遥控选择命令,子站进行遥控选择返校,若成功则回答遥控选择成功报文,若失败则回答失败报文。主站下发取消遥控命令或者遥控执行命令行。子站皆以报文的镜像确认。遥控命令用来实现对一个可操作设备状态的改变。在配电自动化中,包括单点命令和双点命令。通常,单点命令用于控制单点信息对象;双点命令用于控制双点信息对象。

张二狗的博客 7354

探索前端的未来:深度使用 SolidJS 构建高性能用户界面

return (<div></div>SolidJS 凭借其极致的性能、直观的 API 和现代化设计,已经成为前端开发领域中的重要选择。无论是构建高性能应用还是快速原型开发,SolidJS 都能提供卓越的开发体验。希望通过本文的基础与进阶内容,你能对 SolidJS 有更全面的理解。不妨亲自体验一下,感受其出色的性能与便利的开发体验。

桂月二二博客 1732

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

关于Solid.js的理解

相反,Solid.js 通过依赖追踪机制来直接更新真实 DOM,避免了多次的虚拟DOM与实际DOM之间的比较过程,从而实现了更高效的更新。换句话说,Solid.js 避免了中间虚拟DOM层的冗余操作,直接对 DOM 进行操作,这就避免了大量的内存占用和额外的计算。,这意味着即使你有一个复杂的应用,依赖的状态非常多,Solid.js 也能确保高效的性能,而不会产生性能瓶颈或冗余的重渲染。在传统的框架中(例如 React),状态变化时,整个组件会重新渲染,而在 Solid.js 中,更新机制是基于。

qq_60535125的博客 1117

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

聊一聊 Solid 和 Vue 框架有啥差异性?

Solid.js和Vue.js都是JavaScript框架,在开发者社区中引起了相当大的关注和采用。每个框架都满足了不同的需求和偏好,具有独特的方法论、理念和特性。本文旨在对它们进行评估,探讨它们的基本理念、架构、可用性、性能等方面。让我们从两个简短的描述开始:Solid.js依赖于一种创新的、细粒度的响应式系统,确保高效的依赖跟踪和实时UI更新。这个“响应式优先”的JavaScript框架优先考...

前端达人 1155

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Solid.js,我遇到的问题以及相关测试

Solid.js组件中的this Solid.js流程控制 Solid.js组件状态重置 Solid.js,props解构 Solid.js,监视属性(watch) Solid.js,插槽(slot) Solid.js,持久路由(keep-alive)

weixin_45051415的博客 848

SolidJS是什么?SolidJS框架简介

最近刚刚整明白点Svelte感觉整个世界都清净了,但是昨天,有人给我介绍了SolidJS当时我心想:这又是啥玩意啊!经过一番深入交流才知道,居然又是个前端框架。“还有完没完了,一个接一个的框架啥时候是个头啊!不过本着给大家踩坑避雷的精神,我又秉烛夜读,通宵达旦研究了一番。

萌萌哒草头将军 1394

初识SolidJs

介绍SolidJs 一个用于构建用户界面,简单高效、性能卓越的JavaScript库。性能-始终在UI速度和内存利用率基准测试中名列前茅强大-可组合的响应式原语与 JSX 的灵活性相结合。实用-合理且量身定制的 API 使开发变得有趣而简单。生产力-人体工程化设计和熟悉程度使得构建简单或复杂的东西变得轻而易举。专注于性能性能仅次于原生js一个简单的例子import{render}from...

大转转FE 1113

Solid JS基础

Solid-js 用于构建用户界面的声明式、高效且灵活的 JavaScript 库 您可以在 官方教程 中尝试下面提到的部分例子,本文引用并简化了官方教程中的部分例子 本文讲述部分 solid 主要内容,更多详细内容,移步 Solid API 文档 Solid 使用了和 React 相似的语法和类似 Svelte 的预编译 Solid 使用上类似于 React,使用 JSX 语法,但不同于 React, 组件只会初始化一次,并不是 state 改变就重新运行渲染整个组件,这类似于 Vue3

qq_31275709的博客 832

SolidJS:重新定义UI开发的革命性JavaScript库

- 使用示例:[packages/solid-element/sample.jsx](https://link.gitcode.com/i/77f5813f4cb280a871906263c1df01c2) 2. **solid-ssr**:服务端渲染解决方案 - 项目地址:[packages/solid-ssr/](https://link.gitcode.com/i/8cab0d104...

gitblog_00022的博客 585

探索 SolidJS:一款高速的前端框架

SolidJS 是一个基于响应式模型构建的前端框架,由 Ryan Carniato 开发。它强调性能和简洁性,旨在为开发者提供最小的开销和最佳的用户体验。SolidJS 使用编译期优化,将声明式的 JSX 模板转化为纯粹的 JavaScript DOM 操作。这使其在运行时表现上具备显著的性能优势。响应式核心:基于信号(Signals)和计算(Computations)的反应式系统。编译优化:没有虚拟 DOM,直接操作真实 DOM。简单直观的 API:借鉴 React 的 API 风格,降低学习成本。

桂月二二博客 1274

探索 SolidJS,一起体验开源项目(solidjs-use)的乐趣

前言如果你是 React 技术栈,就会发现其对新手其实是不太友好的,会导致新人写出很多重复渲染的组件和 BUG,而且排查难度高(当然 React 依然是最优秀的框架,很多理念的提出者和先行者)。当我看到 SolidJS[1] 后,我感觉这才是真的 react(响应式),它既包含了 React 的语法和天生的 TS 支持,又拥有比 Vue 还彻底的响应式设计,让你不用为 Deps 烦恼。import...

我本可以容忍阳光,如果我不曾见过太阳,然而阳光已使我荒凉,成为更新的荒凉。 1346

性能爆表的SolidJS

使用预编译、无虚拟DOM、究极融合怪、性能爆表、React的异父异母亲兄弟——SolidJS

小帅の技术博客 1051
上一篇: React 官方纪录片:我们亲手将 JSX 推向神坛!
下一篇: 这个组件开发神器你一定要知道:用它开发出来的组件能够横跨各种端
「已注销」
博客等级 码龄5年 0粉丝 5原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值