การแลกเปลี่ยนข้อมูลพื้นฐาน ชนิดข้อมูลดั้งเดิม

Welcome! In this lesson, we'll learn how to pass simple data types, known as primitives, between your JavaScript code and your WebAssembly (WASM) module compiled from C/C++.

Primitives include numbers like integers (int) and floating-point numbers (float, double). This is fundamental for enabling communication and interaction between your web application and high-performance WASM logic.

Passing an integer from JavaScript to a C/C++ WASM function is quite direct. You define your C/C++ function with integer parameters, and Emscripten handles the necessary type mapping.

For example, a C function to add two integers would look like this:

Let's look at a complete C program that defines a function to add two integers and exposes it to JavaScript using EMSCRIPTEN_KEEPALIVE.

Try running this code and see how it compiles:

After compiling the C code above, Emscripten generates a JavaScript glue code file (e.g., your_module.js) that provides access to your C functions.

You can then call the exported C function from your JavaScript code like this:

Returning an integer from a WASM function back to JavaScript is just as straightforward. C/C++ functions naturally return primitive types, and Emscripten ensures these return values are directly accessible in JavaScript.

Consider a C function that simply returns a fixed integer:

Here's a C example that returns a specific integer. Notice the use of EMSCRIPTEN_KEEPALIVE to make it available to JavaScript.

Run this to see the simple C structure:

Passing floating-point numbers (float and double) between JavaScript and WASM works very similarly to integers. You define your C/C++ functions with float or double parameters and return types.

JavaScript's Number type is generally a 64-bit float (double-precision), which Emscripten automatically converts when passing to C/C++ float (32-bit) or double (64-bit) types.

Let's create a C function that takes two floats and returns their product, and another for doubles. This demonstrates both input and output of floating-point numbers.

Run this code to see how floats are handled:

While Emscripten handles much of the type conversion automatically, it's good practice to be aware of the underlying types:

• JavaScript Number: This is typically a 64-bit floating-point number.
• C/C++ int: Often 32-bit integer.
• C/C++ float: 32-bit floating-point number.
• C/C++ double: 64-bit floating-point number.

When passing a JS Number to a C float, there might be a slight loss of precision, as the 64-bit JS number is truncated to a 32-bit float.

You've learned how simple data types are exchanged. Let's test your understanding.

Great job! You've mastered the basics of primitive data exchange between JavaScript and WebAssembly modules compiled from C/C++.

• Simple data types like int, float, and double are straightforward to pass.
• C/C++ functions can take them as parameters and return them as results.
• Emscripten acts as the bridge, automatically converting between JavaScript's Number type and C/C++'s primitive types.
• Be mindful of potential precision differences when converting between 64-bit (JS Number, C double) and 32-bit (C float, C int) types.

This fundamental understanding paves the way for exchanging more complex data structures later on!