Solid.js vs Qwik Comparison

Reactivity

Reactivity is a core feature in both Solid.js and Qwik, allowing developers to build dynamic and responsive applications. Let’s explore how each framework handles state declaration, updates, and computed properties.

Declare state

Solid.js

Name.jsx

import { createSignal } from "solid-js";

export default function Name() {
  const [name] = createSignal("John");

  return <h1>Hello {name()}</h1>;
}

In Solid.js, state is managed using signals, which are functions that return the current state and can be called to update it.

Qwik

Name.tsx

import { component$, useSignal } from "@builder.io/qwik";

export const Name = component$(() => {
  const name = useSignal("John");

  return <h1>Hello {name.value}</h1>;
});

In Qwik, state is managed using signals as well, but it leverages the useSignal hook within components to manage state.

Update state

Solid.js

Name.jsx

import { createSignal } from "solid-js";

export default function Name() {
  const [name, setName] = createSignal("John");
  setName("Jane");

  return <h1>Hello {name()}</h1>;
}

State updates in Solid.js are performed by calling the setter function returned by createSignal.

Qwik

Name.tsx

import { component$, useTask$, useSignal } from "@builder.io/qwik";

export const Name = component$(() => {
  const name = useSignal("John");

  useTask$(() => {
    name.value = "Jane";
  });

  return <h1>Hello {name.value}</h1>;
});

In Qwik, state updates can be managed using the useTask$ hook, which allows for side effects and state updates.

Computed state

Solid.js

DoubleCount.jsx

import { createSignal } from "solid-js";

export default function DoubleCount() {
  const [count] = createSignal(10);
  const doubleCount = () => count() * 2;

  return <div>{doubleCount()}</div>;
}

Computed properties in Solid.js are functions that derive values from other state, recalculating when dependencies change.

Qwik

DoubleCount.tsx

import { component$, useSignal, useComputed$ } from "@builder.io/qwik";

export const DoubleCount = component$(() => {
  const count = useSignal(10);
  const doubleCount = useComputed$(() => count.value * 2);

  return <div>{doubleCount.value}</div>;
});

In Qwik, computed properties are managed using the useComputed$ hook, which allows for reactive computations based on state changes.

Templating

Templating in both frameworks allows for the creation of reusable and dynamic UI components.

Minimal template

Solid.js

HelloWorld.jsx

export default function HelloWorld() {
  return <h1>Hello World!</h1>;
}

Qwik

HelloWorld.tsx

export const HelloWorld = () => {
  return <div>Hello World</div>;
};

Styling

Styling in Solid.js and Qwik can be managed using CSS, with support for scoped styles and CSS modules.

Solid.js

CssStyle.jsx

import "./style.css";

export default function CssStyle() {
  return (
    <>
      <h1 class="title">I am red</h1>
      <button style={{ "font-size": "10rem" }}>I am a button</button>
    </>
  );
}

style.css

.title {
  color: red;
}

Qwik

CssStyle.tsx

import { component$, useStyles$ } from "@builder.io/qwik";

export const App = component$(() => {
  useStyles$(`
    .title {
      color: red;
    }
    `);

  return (
    <>
      <h1 class="title">I am red</h1>
      <button style={{ "font-size": "10rem" }}>I am a button</button>
    </>
  );
});

In Qwik, styles can be applied using the useStyles$ hook, which allows for scoped styling within components.

Loop

Loops in both frameworks allow for the iteration over collections to dynamically generate UI elements.

Solid.js

Colors.jsx

import { For } from "solid-js";

export default function Colors() {
  const colors = ["red", "green", "blue"];

  return (
    <ul>
      <For each={colors}>{(color) => <li>{color}</li>}</For>
    </ul>
  );
}

Qwik

Colors.tsx

import { component$ } from "@builder.io/qwik";

export const Colors = component$(() => {
  const colors = ["red", "green", "blue"];
  return (
    <ul>
      {colors.map((color) => (
        <li key={color}>{color}</li>
      ))}
    </ul>
  );
});

Event click

Event handling in Solid.js and Qwik is intuitive, allowing developers to respond to user interactions.

Solid.js

Counter.jsx

import { createSignal } from "solid-js";

export default function Counter() {
  const [count, setCount] = createSignal(0);

  function incrementCount() {
    setCount(count() + 1);
  }

  return (
    <>
      <p>Counter: {count()}</p>
      <button onClick={incrementCount}>+1</button>
    </>
  );
}

Qwik

Counter.tsx

import { component$, useSignal, $ } from "@builder.io/qwik";

export const Counter = component$(() => {
  const count = useSignal(0);

  const incrementCount = $(() => {
    count.value++;
  });

  return (
    <>
      <p>Counter: {count.value}</p>
      <button onClick$={incrementCount}>Increment</button>
    </>
  );
});

Dom ref

DOM references in both frameworks allow for direct manipulation of DOM elements.

Solid.js

InputFocused.jsx

import { onMount } from "solid-js";

export default function InputFocused() {
  let inputElement;

  onMount(() => inputElement.focus());

  return <input ref={inputElement} type="text" />;
}

Qwik

InputFocused.tsx

import { component$, useVisibleTask$, useSignal } from "@builder.io/qwik";

export const InputFocused = component$(() => {
  const inputElement = useSignal<HTMLInputElement>();

  useVisibleTask$(({ track }) => {
    const el = track(inputElement);
    el?.focus();
  });

  return <input type="text" ref={inputElement} />;
});

Conditional

Conditional rendering in Solid.js and Qwik allows for dynamic UI updates based on application state.

Solid.js

TrafficLight.jsx

import { createSignal, Switch, Match } from "solid-js";

const TRAFFIC_LIGHTS = ["red", "orange", "green"];

export default function TrafficLight() {
  const [lightIndex, setLightIndex] = createSignal(0);

  const light = () => TRAFFIC_LIGHTS[lightIndex()];

  function nextLight() {
    setLightIndex((lightIndex() + 1) % TRAFFIC_LIGHTS.length);
  }

  return (
    <>
      <button onClick={nextLight}>Next light</button>
      <p>Light is: {light()}</p>
      <p>
        You must
        <Switch>
          <Match when={light() === "red"}>
            <span>STOP</span>
          </Match>
          <Match when={light() === "orange"}>
            <span>SLOW DOWN</span>
          </Match>
          <Match when={light() === "green"}>
            <span>GO</span>
          </Match>
        </Switch>
      </p>
    </>
  );
}

Qwik

TrafficLight.tsx

import { $, component$, useComputed$, useSignal } from "@builder.io/qwik";

export const TRAFFIC_LIGHTS = ["red", "orange", "green"];

export const TrafficLight = component$(() => {
  const lightIndex = useSignal(0);

  const light = useComputed$(() => TRAFFIC_LIGHTS[lightIndex.value]);

  const nextLight = $(() => {
    lightIndex.value = (lightIndex.value + 1) % TRAFFIC_LIGHTS.length;
  });

  return (
    <>
      <button onClick$={nextLight}>Next light</button>
      <p>Light is: {light.value}</p>
      <p>
        You must {light.value === "red" && <span>STOP</span>}
        {light.value === "orange" && <span>SLOW DOWN</span>}
        {light.value === "green" && <span>GO</span>}
      </p>
    </>
  );
});

Lifecycle

Lifecycle hooks in both frameworks provide a way to execute code at specific points in a component’s lifecycle.

On mount

Solid.js

PageTitle.jsx

import { createSignal, onMount } from "solid-js";

export default function PageTitle() {
  const [pageTitle, setPageTitle] = createSignal("");

  onMount(() => {
    setPageTitle(document.title);
  });

  return <p>Page title: {pageTitle()}</p>;
}

Qwik

PageTitle.tsx

import { component$, useVisibleTask$, useStore } from "@builder.io/qwik";

export const App = component$(() => {
  const store = useStore({
    pageTitle: "",
  });

  useVisibleTask$(() => {
    store.pageTitle = document.title;
  });

  return <p>Page title: {store.pageTitle}</p>;
});

On unmount

Solid.js

Time.jsx

import { createSignal, onCleanup } from "solid-js";

export default function Time() {
  const [time, setTime] = createSignal(new Date().toLocaleTimeString());

  const timer = setInterval(() => {
    setTime(new Date().toLocaleTimeString());
  }, 1000);

  onCleanup(() => clearInterval(timer));

  return <p>Current time: {time()}</p>;
}

Qwik

Time.tsx

import { component$, useVisibleTask$, useStore } from "@builder.io/qwik";

export const App = component$(() => {
  const store = useStore({
    time: new Date().toLocaleTimeString(),
  });

  useVisibleTask$(({ cleanup }) => {
    const timer = setInterval(() => {
      store.time = new Date().toLocaleTimeString();
    }, 1000);

    cleanup(() => clearInterval(timer));
  });

  return <p>Current time: {store.time}</p>;
});

Component composition

Component composition in Solid.js and Qwik allows for the creation of complex UIs from smaller, reusable components.

Props

Solid.js

App.jsx

import UserProfile from "./UserProfile.jsx";

export default function App() {
  return (
    <UserProfile
      name="John"
      age={20}
      favouriteColors={["green", "blue", "red"]}
      isAvailable
    />
  );
}

Qwik

App.tsx

import { component$ } from "@builder.io/qwik";
import UserProfile from "./UserProfile";

const App = component$(() => {
  return (
    <UserProfile
      name="John"
      age={20}
      favouriteColors={["green", "blue", "red"]}
      isAvailable
    />
  );
});

export default App;

Emit to parent

Solid.js

App.jsx

import { createSignal } from "solid-js";
import AnswerButton from "./AnswerButton.jsx";

export default function App() {
  const [isHappy, setIsHappy] = createSignal(true);

  function onAnswerNo() {
    setIsHappy(false);
  }

  function onAnswerYes() {
    setIsHappy(true);
  }

  return (
    <>
      <p>Are you happy?</p>
      <AnswerButton onYes={onAnswerYes} onNo={onAnswerNo} />
      <p style={{ "font-size": "50px" }}>{isHappy() ? "😀" : "😥"}</p>
    </>
  );
}

Qwik

App.tsx

import { $, component$, useStore } from "@builder.io/qwik";
import AnswerButton from "./AnswerButton";

const App = component$(() => {
  const store = useStore({
    isHappy: true,
  });

  const onAnswerNo = $(() => {
    store.isHappy = false;
  });

  const onAnswerYes = $(() => {
    store.isHappy = true;
  });

  return (
    <>
      <p>Are you happy?</p>
      <AnswerButton onYes$={onAnswerYes} onNo$={onAnswerNo} />
      <p style={{ fontSize: 50 }}>{store.isHappy ? "ðŸ˜€" : "ðŸ˜¥"}</p>
    </>
  );
});

export default App;

Slot

Solid.js

App.jsx

import FunnyButton from "./FunnyButton.jsx";

export default function App() {
  return <FunnyButton>Click me!</FunnyButton>;
}

Qwik

App.tsx

import FunnyButton from "./FunnyButton";

export default function App() {
  return <FunnyButton>Click me!</FunnyButton>;
}

Slot fallback

Solid.js

App.jsx

import FunnyButton from "./FunnyButton.jsx";

export default function App() {
  return (
    <>
      <FunnyButton />
      <FunnyButton>I got content!</FunnyButton>
    </>
  );
}

Qwik

App.tsx

import FunnyButton from "./FunnyButton";

export default function App() {
  return (
    <>
      <FunnyButton />
      <FunnyButton>Click me!</FunnyButton>
    </>
  );
}

Context

Context management in Solid.js and Qwik allows for the sharing of data and functionality across components.

Solid.js

App.jsx

import { createSignal } from "solid-js";

import { UserContext } from "./UserContext";
import UserProfile from "./UserProfile";

export default function App() {
  const [user, setUser] = createSignal({
    id: 1,
    username: "unicorn42",
    email: "unicorn42@example.com",
  });

  function updateUsername(newUsername) {
    setUser({ ...user(), username: newUsername });
  }

  return (
    <>
      <h1>Welcome back, {user().username}</h1>
      <UserContext.Provider value={[user, updateUsername]}>
        <UserProfile />
      </UserContext.Provider>
    </>
  );
}

Qwik

App.tsx

import {
  component$,
  useStore,
  useContextProvider,
  createContext,
  $,
} from "@builder.io/qwik";
import UserProfile from "./UserProfile";

export const UserContext = createContext("user-context");

const App = component$(() => {
  const user = useStore({
    id: 1,
    username: "unicorn42",
    email: "unicorn42@example.com",
  });

  const updateUsername = $((newUsername) => {
    user.username = newUsername;
  });

  useContextProvider(UserContext, { user, updateUsername });

  return (
    <>
      <h1>Welcome back, {user.username}</h1>
      <UserProfile />
    </>
  );
});

export default App;

Form input

Form inputs in both frameworks support two-way data binding, making it easy to manage form state.

Input text

Solid.js

InputHello.jsx

import { createSignal } from "solid-js";

export default function InputHello() {
  const [text, setText] = createSignal("Hello world");

  function handleChange(event) {
    setText(event.target.value);
  }

  return (
    <>
      <p>{text()}</p>
      <input value={text()} onInput={handleChange} />
    </>
  );
}

Qwik

InputHello.tsx

import { component$, useSignal } from "@builder.io/qwik";

const InputHello = component$(() => {
  const text = useSignal("");

  return (
    <>
      <p>{text.value}</p>
      <input bind:value={text} />
    </>
  );
});

export default InputHello;

Checkbox

Solid.js

IsAvailable.jsx

import { createSignal } from "solid-js";

export default function IsAvailable() {
  const [isAvailable, setIsAvailable] = createSignal(false);

  function handleChange() {
    setIsAvailable((previousValue) => !previousValue);
  }

  return (
    <>
      <input
        id="is-available"
        type="checkbox"
        checked={isAvailable()}
        onChange={handleChange}
      />
      <label for="is-available">Is available</label>
    </>
  );
}

Qwik

IsAvailable.tsx

import { component$, useSignal } from "@builder.io/qwik";

const IsAvailable = component$(() => {
  const isAvailable = useSignal(false);

  return (
    <>
      <input id="is-available" type="checkbox" bind:checked={isAvailable} />
      <label for="is-available">Is available</label>
    </>
  );
});

export default IsAvailable;

Radio

Solid.js

PickPill.jsx

import { createSignal } from "solid-js";

export default function PickPill() {
  const [picked, setPicked] = createSignal("red");

  function handleChange(event) {
    setPicked(event.target.value);
  }

  return (
    <>
      <div>Picked: {picked()}</div>
      <input
        id="blue-pill"
        checked={picked() === "blue"}
        type="radio"
        value="blue"
        onChange={handleChange}
      />
      <label for="blue-pill">Blue pill</label>

      <input
        id="red-pill"
        checked={picked() === "red"}
        type="radio"
        value="red"
        onChange={handleChange}
      />
      <label for="red-pill">Red pill</label>
    </>
  );
}

Qwik

PickPill.tsx

import { component$, useSignal } from "@builder.io/qwik";

const PickPill = component$(() => {
  const pickedColor = useSignal("red");

  return (
    <>
      <div>Picked: {pickedColor.value}</div>
      <input
        id="blue-pill"
        type="radio"
        bind:value={pickedColor}
        checked={pickedColor.value === "blue"}
        value="blue"
      />
      <label for="blue-pill">Blue pill</label>

      <input
        id="red-pill"
        type="radio"
        checked={pickedColor.value === "red"}
        bind:value={pickedColor}
        value="red"
      />
      <label for="red-pill">Red pill</label>
    </>
  );
});

export default PickPill;

Select

Solid.js

ColorSelect.jsx

import { createSignal, For } from "solid-js";

const colors = [
  { id: 1, text: "red" },
  { id: 2, text: "blue" },
  { id: 3, text: "green" },
  { id: 4, text: "gray", isDisabled: true },
];

export default function ColorSelect() {
  const [selectedColorId, setSelectedColorId] = createSignal(2);

  function handleChange(event) {
    setSelectedColorId(event.target.value);
  }

  return (
    <select value={selectedColorId()} onChange={handleChange}>
      <For each={colors}>
        {(color) => (
          <option value={color.id} disabled={color.isDisabled}>
            {color.text}
          </option>
        )}
      </For>
    </select>
  );
}

Qwik

ColorSelect.tsx

import { component$, useSignal } from "@builder.io/qwik";

export const colors = [
  { id: 1, text: "red" },
  { id: 2, text: "blue" },
  { id: 3, text: "green" },
  { id: 4, text: "gray", isDisabled: true },
];

const ColorSelect = component$(() => {
  const selectedColorId = useSignal("2");

  return (
    <select bind:value={selectedColorId}>
      {colors.map((color) => (
        <option
          key={color.id}
          value={color.id}
          disabled={color.isDisabled}
          selected={`${color.id}` === selectedColorId.value}
        >
          {color.text}
        </option>
      ))}
    </select>
  );
});

export default ColorSelect;

Webapp features

Webapp features in both frameworks include data fetching and rendering, with support for asynchronous operations.

Render app

Solid.js

index.html

<!DOCTYPE html>
<html>
  <body>
    <div id="app"></div>
    <script type="module" src="./main.jsx"></script>
  </body>
</html>

main.jsx

App.jsx

Qwik

index.html

<!DOCTYPE html>
<html>
  <body>
    <div id="app"></div>
    <script type="module" src="./main.tsx"></script>
  </body>
</html>

main.tsx

app.tsx

Fetch data

Solid.js

App.jsx

import { createResource, For, Switch, Match } from "solid-js";

async function fetchUsers() {
  return (await fetch("https://randomuser.me/api/?results=3")).json();
}

export default function App() {
  const [data] = createResource(fetchUsers);
  const users = () => data()?.results;

  return (
    <Switch>
      <Match when={data.loading}>
        <p>Fetching users...</p>
      </Match>
      <Match when={data.error}>
        <p>An error occurred while fetching users</p>
      </Match>
      <Match when={users()}>
        <ul>
          <For each={users()}>
            {(user) => (
              <li>
                <img src={user.picture.thumbnail} alt="user" />
                <p>
                  {user.name.first} {user.name.last}
                </p>
              </li>
            )}
          </For>
        </ul>
      </Match>
    </Switch>
  );
}

Qwik

App.tsx

import { component$, useResource$, Resource } from "@builder.io/qwik";

type UsersResponse = {
  results: {
    picture: {
      thumbnail: string;
    };
    name: {
      first: string;
      last: string;
    };
  }[];
};

export async function fetchUsers() {
  return (await fetch("https://randomuser.me/api/?results=3")).json();
}

export const App = component$(() => {
  const data = useResource$<UsersResponse>(fetchUsers);

  return (
    <Resource
      value={data}
      onPending={() => <p>Fetching users...</p>}
      onRejected={() => <p>An error occurred while fetching users</p>}
      onResolved={({ results: users }) => (
        <ul>
          {users.map((user) => (
            <li>
              <img src={user.picture.thumbnail} alt="user" />
              <p>
                {user.name.first} {user.name.last}
              </p>
            </li>
          ))}
        </ul>
      )}
    />
  );
});

Decouvrez plus d’Offres de la plateform ItGalaxy.io :

Découvrez notre gamme complète de services et formations pour accélérer votre carrière.

1. Nous contactez

Description: Besoin de Formation et des Solutions cloud complètes pour vos applications
Links:
- Nous contactez

2. Infra as a Service

Description: Infrastructure cloud évolutive et sécurisée
Links:
- Demandez un devis

3. Projets Développeurs

Description: Découvrez des opportunités passionnantes pour les développeurs
Links:

4. Développeurs

Description: Rejoignez notre communauté de développeurs
Links:
- DevOps
- Web
- Backend
- SEO
- Design
- Mobile
- Wordpress
- Shopify

5. Formations Complètes

Description: Accédez à des formations professionnelles de haute qualité
Links:

6. Marketplace

Description: Découvrez notre place de marché de services
Links:

7. Blogs

Description: Découvrez nos blogs
Links: