시작하기
JS에서 Wasm 로드
WebAssembly(Wasm)는 브라우저에서 거의 네이티브 속도로 실행되는 바이너리 형식입니다. instantiateStreaming은 .wasm 파일을 로드하고 컴파일합니다. 익스포트는 JavaScript에서 호출 가능한 함수입니다.
// Load and instantiate a .wasm module
WebAssembly.instantiateStreaming(fetch('module.wasm'))
.then(result => {
const { instance } = result;
// call exported functions
console.log(instance.exports.add(2, 3)); // 5
});
// Alternative: from ArrayBuffer
const bytes = new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]);
WebAssembly.instantiate(bytes).then(result => {
console.log(result.instance.exports);
});WebAssembly 모듈과 인스턴스
WebAssembly.Module은 컴파일된 무상태 표현으로 여러 인스턴스에서 안전하게 재사용할 수 있습니다. WebAssembly.Instance는 런타임 상태(메모리, 전역)를 보유합니다. 한 번 컴파일하고 여러 번 인스턴스화하면 병렬 워커 생성에 효율적입니다.
// Two-step: compile then instantiate
const module = await WebAssembly.compile(bytes);
const instance = await WebAssembly.instantiate(module, importObject);
console.log(instance.exports.add(1, 2));
// Module is stateless & shareable across instances
const instance2 = await WebAssembly.instantiate(module, importObject);
// Each instance has its own memory and globals브라우저 지원과 기능 감지
WebAssembly 1.0은 모든 최신 브라우저에서 지원됩니다. 최신 제안(SIMD, 예외, 스레드, GC)은 기능 감지가 필요합니다. WebAssembly.validate는 컴파일 없이 바이트가 유효한 모듈을 이루는지 확인합니다.
// Check basic WebAssembly support
if (typeof WebAssembly !== 'undefined') {
console.log('WebAssembly is supported');
}
// Verify the engine can actually compile
WebAssembly.validate(new Uint8Array([
0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00
])); // true if valid module
// Feature-detect newer proposals
const hasSIMD = typeof WebAssembly.Module !== 'undefined';
const hasExceptions = 'exceptions' in WebAssembly;스트리밍 vs 비스트리밍
instantiateStreaming은 네트워크로 스트리밍되는 동안 모듈을 컴파일해 시작이 더 빠릅니다. 서버는 반드시 'Content-Type: application/wasm'을 보내야 합니다. 해당 헤더가 없는 CDN이나 정적 호스트를 쓰면 ArrayBuffer 경로로 폴백하세요.
// Streaming (preferred): compiles while downloading
WebAssembly.instantiateStreaming(fetch('m.wasm'), imports);
// Non-streaming: must download fully first
const res = await fetch('m.wasm');
const buf = await res.arrayBuffer();
WebAssembly.instantiate(buf, imports);
// Streaming requires correct MIME type:
// Content-Type: application/wasmWasm 매직 넘버와 헤더
Wasm 바이너리 매직 넘버는 ASCII 문자열 '\0asm' 뒤에 4바이트 리틀엔디언 버전이 붙습니다. 이 헤더로 컴파일 전에 파일이 Wasm인지 검증할 수 있습니다. 형식은 섹션(Type, Import, Function, Memory 등)으로 구성됩니다.
// Every .wasm file starts with this 8-byte header:
// 0x00 0x61 0x73 0x6d -> "\0asm"
// 0x01 0x00 0x00 0x00 -> version 1
const magic = [0x00, 0x61, 0x73, 0x6d];
const version = [0x01, 0x00, 0x00, 0x00];
// Quick validity check
function isWasm(bytes) {
return bytes[0] === 0x00 && bytes[1] === 0x61
&& bytes[2] === 0x73 && bytes[3] === 0x6d;
}Hello Wasm(최소 예제)
최소 Wasm 앱: 모듈이 JS에서 'log' 함수를 가져오고 이를 호출하는 'greet'를 익스포트합니다. WAT(WebAssembly Text) 형식은 사람이 읽을 수 있는 표현이며 wat2wasm으로 바이너리로 컴파일합니다. 브라우저는 바이너리 형식만 실행합니다.
<!-- index.html -->
<script>
WebAssembly.instantiateStreaming(fetch('hello.wasm'))
.then(({ instance }) => {
instance.exports.greet(); // logs "Hello, Wasm!"
});
</script>
;; hello.wat (compiled to hello.wasm via wat2wasm)
(module
(import "console" "log" (func $log (param i32)))
(func (export "greet")
i32.const 72 ;; 'H'
call $log
)
)WAT 텍스트 형식
모듈과 S-표현식
WAT(WebAssembly Text format)는 Wasm의 텍스트 표현입니다. 모든 것이 (module ...) s-표현식으로 감싸집니다. 명령은 스택 기반 순서로 작성합니다. 피연산자를 먼저 푸시하고 연산이 이를 소비합니다.
;; WAT uses s-expressions: (keyword args...)
(module
;; function definitions, exports, etc. go here
)
;; Nested expressions form the instruction sequence
(module
(func $add (param $a i32) (param $b i32) (result i32)
local.get $a
local.get $b
i32.add
)
(export "add" (func $add))
)WAT 주석
WAT는 두 가지 주석 스타일을 지원합니다. ';;'는 한 줄, '(; ... ;)'는 블록 주석입니다. 블록 주석은 중첩되고 여러 줄에 걸칠 수 있어 개발 중 코드 덩어리를 비활성화할 때 유용합니다.
;; Single-line comment (starts with ;;)
(func (export "f")
i32.const 1 ;; push 1
drop ;; discard
)
(; Block comment
can span
multiple lines ;)
(func (export "g")
nop
)함수 정의 문법
함수는 (func ...)로 선언합니다. 매개변수는 (param $name type), 결과는 (result type)을 씁니다. '$name'은 선택이며 없으면 함수/지역 변수를 숫자 인덱스로 참조합니다. 다중 값 반환에는 multi-value 제안이 필요합니다(널리 지원됨).
;; Named function with params and result
(func $name (param $p1 i32) (param $p2 f64) (result i32)
;; body
)
;; Anonymous function (referenced by index)
(func (param i32) (result i32)
local.get 0
)
;; Multiple results (multi-value proposal)
(func $swap (param i32 i32) (result i32 i32)
local.get 1
local.get 0
)인라인 export와 import
WAT는 함수, 메모리, 테이블, 전역에 인라인 (export "name")과 (import "module" "field") 주석을 지원합니다. 확장된 (export ...) / (import ...) 형식의 단축입니다. 둘 다 동일한 바이너리 출력으로 컴파일됩니다.
;; Inline export on a function
(func (export "add") (param i32 i32) (result i32)
local.get 0
local.get 1
i32.add
)
;; Inline import
(func $log (import "env" "log") (param i32))
;; Inline export on memory
(memory (export "mem") 1)
;; Expanded form (equivalent)
(func $add (param i32 i32) (result i32) ...)
(export "add" (func $add))데이터 세그먼트
데이터 세그먼트는 인스턴스화 시(활성) 또는 memory.init로 지연 초기화(수동)해 선형 메모리를 초기화합니다. 문자열에는 널 종료자용 \00, 줄바꿈용 \n 같은 이스케이 프 시퀀스가 포함됩니다. data.drop은 복사 후 세그먼트 저장소를 해제합니다.
;; Initialize memory with bytes at offset 0
(memory 1)
(data (i32.const 0) "Hello, Wasm!\00")
;; Named data segment (active)
(data $msg (i32.const 0) "Hello\00")
;; Passive data segment (used with memory.init)
(data $passive "lazy-loaded bytes")
;; Drop a data segment to free its memory
(data.drop $msg)wat2wasm과 wasm2wat 변환
WABT(WebAssembly Binary Toolkit)는 wat2wasm(텍스트→바이너리), wasm2wat(바이너리→텍스트), wasm-validate, wasm-objdump를 제공합니다. Wasm 모듈을 검사, 디버깅, 직접 작성하는 데 필수입니다. .wat 형식은 사람용이고 .wasm 형식은 브라우저가 실행하는 것입니다.
# Install the WebAssembly Binary Toolkit (WABT)
# macOS: brew install wabt
# Ubuntu: apt install wabt
# Convert text -> binary
wat2wasm hello.wat -o hello.wasm
# Convert binary -> text (disassemble)
wasm2wat hello.wasm -o hello.wat
# Validate a .wasm file
wasm-validate hello.wasm
# Print module structure
wasm-objdump -x hello.wasm값 타입
기본 값 타입(i32/i64/f32/f64)
Wasm에는 네 가지 기본 값 타입만 있습니다: i32, i64, f32, f64. 정수의 부호는 타입이 아니라 연산(예: i32.div_s vs i32.div_u)으로 결정됩니다. 타입 시스템을 최소하고 예측 가능하게 유지합니다.
;; Wasm has exactly four basic value types:
;; i32 - 32-bit integer
;; i64 - 64-bit integer
;; f32 - 32-bit float
;; f64 - 64-bit float
(func (param i32) (param i64) (param f32) (param f64)
(result f64)
local.get 2 ;; f32
f64.promote_f32
)
;; Integers are signed or unsigned PER OPERATION,
;; not per type. Use i32.add_s / i32.div_u etc.WAT의 숫자 리터럴
WAT의 숫자 리터럴은 10진, 16진(0x), 2진(0b) 형식을 지원합니다. 부동소수는 과학적 표기법, 무한대(inf), NaN을 지원합니다. WAT 리터럴은 기본적으로 부호가 없으며 음수 정수는 앞에 '-'를 붙여 인코딩합니다.
;; Integer literals
i32.const 42
i32.const -7
i32.const 0xff ;; hex
i32.const 0b1010 ;; binary
;; Float literals
f64.const 3.14
f64.const 1e10
f64.const -0.0
f64.const inf
f64.const nan
;; 64-bit
i64.const 9007199254740992 ;; 2^53타입 변환
변환은 일관된 명명 체계를 씁니다: extend(작은→큰), wrap(큰→작은), convert(정수↔부동소수), reinterpret(비트 수준 캐스트), demote/promote(부동소수 정밀도). 부호 있는 변형은 _s, 없는 변형은 _u를 씁니다.
;; Extend i32 to i64
i64.extend_i32_s ;; sign-extend
i64.extend_i32_u ;; zero-extend
;; Wrap i64 to i32
i32.wrap_i64
;; Integer <-> Float
f32.convert_i32_s
f64.convert_i64_u
i32.trunc_f32_s ;; truncate (toward zero)
i32.reinterpret_f32 ;; bit-level reinterpret
;; Demote / promote floats
f32.demote_f64
f64.promote_f32v128 SIMD 타입
v128 타입은 16바이트를 하나의 SIMD 레지스터에 패킹합니다. 레인은 i32x4(int32 4개), f32x4(float32 4개), i16x8, i8x16, f64x2로 주소 지정합니다. SIMD는 명령당 여러 값을 처리해 이미지/오디오/암호화 워크로드를 빠르게 합니다.
;; SIMD: 128-bit vector type (fixed-width SIMD proposal)
(module
(func (param v128) (result v128)
local.get 0
v128.not ;; bitwise NOT
)
(func (result v128)
v128.const i32x4 1 2 3 4
)
)
;; Vector operations: i32x4, i16x8, i8x16, f32x4, f64x2
v128.const f32x4 1.0 2.0 3.0 4.0
i32x4.add참조 타입(funcref/externref)
참조 타입 제안은 funcref(함수 포인터)와 externref(불투명 호스트 참조)를 추가합니다. externref는 복사나 직렬화 없이 Wasm이 JS 객체를 보유하게 하므로 강력합니다. 테이블과 결합하면 유연한 콜백 패턴을 가능하게 합니다.
;; Reference types proposal adds:
;; funcref - reference to a function (in a table)
;; externref - opaque reference to a host (JS) object
(module
(table 1 funcref)
(func (param externref) (result externref)
local.get 0 ;; pass through a JS object
)
)
;; In JS, externref lets you pass arbitrary objects
;; through Wasm without serialization:
instance.exports.store({ hello: 'world' });함수
함수 정의와 호출
함수는 코드의 기본 단위입니다. call은 이름/인덱스로 함수를 호출합니다. 인자는 호출 전 스택에 푸시되고 함수가 반환하면 결과가 스택에 남습니다. 스택은 (result ...) 선언과 일치해야 합니다.
(module
(func $add (param $a i32) (param $b i32) (result i32)
local.get $a
local.get $b
i32.add
)
(func $double (param $x i32) (result i32)
local.get $x
local.get $x
i32.add ;; or: i32.const 2 i32.mul
)
(func (export "use")
i32.const 5
i32.const 7
call $add ;; -> 12 on stack
drop
)
)매개변수와 지역 변수
매개변수는 0부터 인덱스되는 불변 지역 변수입니다. 선언된 지역 변수(local $name type)는 0으로 초기화되고 가변입니다. local.get, local.set, local.tee(설정 + 스택에 남김)를 사용하세요. 지역 변수는 메 모리/전역 밖에서 Wasm의 유일한 가변 저장소입니다.
(func $f (param $a i32) (param $b i32) (result i32)
(local $sum i32) ;; mutable local
(local $i i32)
local.get $a
local.get $b
i32.add
local.set $sum ;; store into local
i32.const 0
local.set $i
local.get $sum
)
;; tee: set and keep on stack
local.tee $sum ;; $sum = top; stays on stack다중 반환 값
multi-value 제안은 함수가 여러 값을 반환(그리고 0개도 허용)하게 합니다. 2020년부터 모든 주요 엔진이 지원합니다. 메모리를 통한 출력 매개변수가 필요 없어지고 swap/minmax 같은 관용구가 자연스러워집니다.
;; Multi-value: return two i32 values
(func $minmax (param $a i32) (param $b i32) (result i32 i32)
local.get $a
local.get $b
i32.lt_s
if (result i32 i32)
local.get $a
local.get $b
else
local.get $b
local.get $a
end
)
;; Caller receives both on the stack
(func (export "use")
i32.const 3
i32.const 8
call $minmax
;; stack: [min=3, max=8]
drop drop
)재귀
Wasm은 직접 재귀를 지원해 함수가 자신을 호출할 수 있습니다. MVP Wasm에는 꼬리 호출 최적화가 없습니다(tail-call 제안이 return_call을 추가). 깊은 재귀는 스택 오버플로 위험이 있으므로 운영 코드에는 반복 루프를 권장합니다.
(module
(func $fact (param $n i32) (result i32)
local.get $n
i32.const 1
i32.le_s
if (result i32)
i32.const 1
else
local.get $n
local.get $n
i32.const 1
i32.sub
call $fact ;; recursive call
i32.mul
end
)
(export "factorial" (func $fact))
)인라인 export와 이름 있는 호출
함수 정의의 인라인 (export "name")은 별도 (export ...) 선언의 단축입니다. call_ref(참조 타입 제안)는 funcref를 통해 직접 함수를 호출하므로 테이블 조회 없이 일급 함수 값을 쓸 수 있습니다.
(module
;; Inline export on definition
(func $add (export "add") (param i32 i32) (result i32)
local.get 0
local.get 1
i32.add
)
;; call_ref: call via funcref (reference types)
(func $caller (param $f funcref) (param i32) (result i32)
local.get 1
local.get 0
call_ref (param i32) (result i32)
)
)시작 함수
모듈은 인스턴스화 시 자동 실행되는 (start $func) 함수를 하나 선언할 수 있어 초기화에 유용합니다. 인자도 반환 값도 없습니다. 모듈당 시작 함수는 하나만 허용됩니다.
(module
(func $init
;; runs once at instantiation
i32.const 0
i32.const 42
i32.store
)
(start $init) ;; declare as start function
(memory (export "mem") 1)
)
;; The start function runs automatically after
;; instantiation, before instantiate() resolves.
;; It takes no params and returns nothing.메모리
선형 메모리 선언
선형 메모리는 64KiB 페이지 단위로 커지는 연속 ArrayBuffer 유사 영역입니다. (memory 1 10)은 초기=1, 최대=10을 선언합니다. 메모리는 Wasm과 JS 사이에 대량 데이터(문자열, 배열)를 전달하는 유일한 방법입니다. JS에서 접근하려면 익스포트하세요.
(module
;; 1 page = 64KiB. Declare 1 page, max 10.
(memory $mem 1 10)
(export "memory" (memory $mem))
;; JS-side: read/write the exported memory
;; const buf = new Uint8Array(instance.exports.memory.buffer);
)메모리 grow
memory.grow는 페이지를 추가하고 이전 크기(페이지)를 반환하며 실패 시 -1을 반환합니다. 중요: grow는 기반 ArrayBuffer를 분리(detach)해 기존의 모든 TypedArray 뷰가 사용 불가능해집니다. grow 호출 후에는 항상 뷰를 다시 만드세요.
(func $grow (result i32)
i32.const 1 ;; request 1 more page
memory.grow ;; returns previous size (or -1)
)
;; In JS, growing detaches the old buffer!
const prev = instance.exports.grow();
const buf = new Uint8Array(instance.exports.memory.buffer);
// OLD buf references are now detached — re-create views!로드와 저장 연산
로드/저장에는 크기(8/16/32/64비트)와 부호 확장(_s/_u) 변형이 있습니다. offset=N은 주소 피연산자에 상수를 더하고 align=은 힌트입니다(크기 이하여야 함). 모든 주소는 선형 메모리의 바이트 오프셋입니다.
;; Load: read from memory at address (top of stack)
i32.load offset=0 align=2 ;; 4-byte aligned load
i32.load8_u ;; 1 byte, zero-extended
i32.load16_s ;; 2 bytes, sign-extended
f64.load ;; 8-byte float load
;; Store: write value at address
i32.const 100 ;; address
i32.const 42 ;; value
i32.store ;; mem[100] = 42
i32.const 100
i32.const 0xFF
i32.store8 ;; write 1 byte메모리 크기와 정렬
Wasm의 정렬은 정확성 제약이 아니라 성능 힌트이므로 비정렬 접근도 항상 동작합니다. 'align' 값은 연산의 자연 크기를 넘을 수 없습니다. memory.size는 현재 페이지 수(각 64KiB)를 반환합니다.
;; Each load/store has a natural alignment:
;; i32.load -> 4 bytes
;; i64.load -> 8 bytes
;; f32.load -> 4 bytes
;; i32.load8 -> 1 byte
;; Explicit alignment hint (does not affect correctness)
i32.load align=2 ;; may be slower but still works
;; memory.size returns current pages
(func $pages (result i32)
memory.size
)공유 메모리와 원자 연산
공유 메모리(threads 제안)는 여러 Wasm 인스턴스/Worker가 하나의 메모리를 공유해 병렬성을 얻습니다. 원자 연산(i32.atomic.load/store/rmw.add/cmpxchg)이 동기화를 제공합니다. 브라우저에서는 교차 출처 격리(COOP/COEP 헤더)가 필요합니다.
(module
;; Shared memory (threads proposal)
(memory 1 1 shared)
(export "memory" (memory 0))
;; Atomic operations
(func (param i32 i32)
local.get 0 ;; address
local.get 1 ;; value
i32.atomic.store
)
(func (param i32) (result i32)
local.get 0
i32.atomic.load
)
(func (param i32) (result i32)
local.get 0
i32.const 1
i32.atomic.rmw.add ;; atomic read-modify-write
)
)메모리에서 문자열 읽기
Wasm에는 네이티브 문자열 타입이 없습니다. 문자열은 선형 메모리의 바이트 시퀀스이며 보통 (포인터, 길이) 쌍으로 전달됩니다. TextEncoder/TextDecoder가 UTF-8 변환을 처리합니다. 쓰기 전에 메모리 영역이 충분히 큰지 항상 확인하세요.
// Wasm has no string type — strings live in linear memory.
// Decode UTF-8 from a (ptr, len) pair returned by Wasm:
function readString(memory, ptr, len) {
const bytes = new Uint8Array(memory.buffer, ptr, len);
return new TextDecoder('utf-8').decode(bytes);
}
// Writing a string into Wasm memory:
function writeString(memory, str, ptr) {
const bytes = new TextEncoder().encode(str);
const view = new Uint8Array(memory.buffer, ptr, bytes.length);
view.set(bytes);
return bytes.length; // return length
}테이블
테이블 선언
테이블은 간접 호출과 동적 디스패치에 쓰이는 참조(보통 funcref) 배열입니다. 바이트를 담는 메모리와 달리 테이블은 Wasm이 위조할 수 없는 불투명 참조를 담습니다. (elem ...) 세그먼트가 인스턴스화 시 테이블 슬롯을 초기화합니다.
(module
;; A table of function references, initial size 1
(table 1 funcref)
(export "table" (table 0))
;; With max size
(table $t 4 16 funcref)
;; elem segment: initialize table slots
(elem (i32.const 0) $fn1 $fn2 $fn3)
(func $fn1)
(func $fn2)
(func $fn3)
)funcref 테이블과 call_indirect
call_indirect는 인덱스로 테이블 항목을 통해 호출을 디스패치합니다. (type ...) 선언이 필수이며 Wasm이 런타임에 함수 시그니처 일치를 검사합니다(불일치 시 트랩). Wasm의 vtable과 객체 지향 디스패치의 기반입니다.
(module
(type $bin (func (param i32 i32) (result i32)))
(table 3 funcref)
(func $add (param i32 i32) (result i32)
local.get 0 local.get 1 i32.add)
(func $sub (param i32 i32) (result i32)
local.get 0 local.get 1 i32.sub)
(func $mul (param i32 i32) (result i32)
local.get 0 local.get 1 i32.mul)
(elem (i32.const 0) $add $sub $mul)
(func (export "dispatch") (param i32 i32 i32) (result i32)
local.get 0 ;; arg a
local.get 1 ;; arg b
local.get 2 ;; table index
call_indirect (type $bin)
)
)테이블 grow, get, set
table.grow는 슬롯을 추가하고 이전 크기(또는 -1)를 반환합니다. table.get/table.set은 인덱스로 항목을 읽고 씁니다. 테이블을 늘리면 런타임 콜백 등록이 가능합니다. 초기 크기 + 최대값으로 성장을 제한해 폭주 할당을 막으세요.
(func $addSlot (param funcref) (result i32)
local.get 0
i32.const 1 ;; grow by 1
table.grow ;; returns old size, or -1
)
(func $read (param i32) (result funcref)
local.get 0
table.get
)
(func $write (param i32 funcref)
local.get 0 ;; index
local.get 1 ;; funcref
table.set
)호스트 객체용 externref 테이블
externref 테이블은 호스트(JS) 객체에 대한 불투명 참조를 저장합니다. Wasm은 이를 보유하고 전달할 수 있지만 내용을 검사할 수 없습니다. 콜백 등록, JS 핸들 테이블, 객체 지향 JS API를 Wasm으로 연결하는 데 이상적입니다.
(module
;; Table holding opaque JS objects
(table 8 externref)
(export "table" (table 0))
(func $store (param i32 externref)
local.get 0
local.get 1
table.set
)
(func $load (param i32) (result externref)
local.get 0
table.get
)
)
// JS: pass arbitrary objects
instance.exports.store(2, { callback: () => 42 });동적 디스패치 패턴
동적 디스패치 패턴: 연산을 테이블에 저장한 뒤 인덱스로 call_indirect합니다. 필수 타입 검사와 결합하면 안전한 vtable 스타일 다형성을 얻습니다. Rust 열거형, C++ 가상 함수, 인터프리터가 디스패치를 구현하는 방식입니다.
(module
(type $op (func (param i32 i32) (result i32)))
(table 4 funcref)
(elem (i32.const 0) $add $sub $mul $div)
(func $add (param i32 i32) (result i32)
local.get 0 local.get 1 i32.add)
(func $sub (param i32 i32) (result i32)
local.get 0 local.get 1 i32.sub)
(func $mul (param i32 i32) (result i32)
local.get 0 local.get 1 i32.mul)
(func $div (param i32 i32) (result i32)
local.get 0 local.get 1 i32.div_s)
(func (export "apply") (param $op i32) (param $a i32) (param $b i32)
(result i32)
local.get $a
local.get $b
local.get $op
call_indirect (type $op)
)
)전역
전역 선언
전역은 모듈 수준 단일 값이며 불변(기본) 또는 가변(mut)입니다. 함수 호출 간 유지되고 카운터, 설정 플래그, 상수에 유용합니다. 가변 전역은 메모리/테이블 밖에서 유일한 공유 가변 상태입니다.
(module
;; Immutable global (const)
(global $counter (mut i32) (i32.const 0))
;; Read-only global
(global $pi f64 (f64.const 3.14159265))
(func $increment
global.get $counter
i32.const 1
i32.add
global.set $counter
)
)가변 vs 불변 전역
'mut'이 없으면 전역은 불변이고 global.set은 컴파일 오류입니다. 초기화는 상수 표현식(예: i32.const, ref.null, 가져온 불변 전역의 global.get)이어야 합니다. 안전을 위해 기본적으로 불변을 선택하세요.
(module
;; (global $name type init) -> immutable
;; (global $name (mut type) init) -> mutable
(global $version i32 (i32.const 3))
;; global.set $version ;; ERROR: immutable
(global $state (mut i32) (i32.const 0))
(func (export "toggle")
global.get $state
i32.eqz
if
i32.const 1 global.set $state
else
i32.const 0 global.set $state
end
)
)전역 가져오기
가져온 전역은 호스트가 인스턴스화 시 설정 값(또는 WebAssembly.Global 객체)을 모듈에 주입하게 합니다. 불변 가져온 전역은 다른 전역을 초기화할 수 있습니다. WebAssembly.Global은 가변 공유 전역의 JS 가시 래퍼입니다.
(module
;; Import a global from JS
(global $env (import "env" "version") i32)
;; Mutable imported global
(global $flag (import "env" "flag") (mut i32))
(func (export "ver") (result i32)
global.get $env
)
)
// JS side
const imports = {
env: {
version: 3,
flag: new WebAssembly.Global({ value: 'i32', mutable: true }, 0)
}
};전역 익스포트와 공유
익스포트된 전역은 JS에서 .value 속성을 가진 WebAssembly.Global 객체로 접근할 수 있습니다(읽기 가능, 가변이면 설정 가능). Global 객체를 여러 모듈 인스턴스에 공유하면 메모리를 건드리지 않고 상태를 조율하는 깔끔한 방법입니다.
(module
(global $g (export "counter") (mut i32) (i32.const 0))
(func (export "inc")
global.get $g
i32.const 1
i32.add
global.set $g
)
)
// JS reads/writes the global directly
const g = instance.exports.counter;
g.value; // 0
instance.exports.inc();
g.value; // 1
g.value = 100; // write directly전역 사용 사례
전역은 세 패턴에 적합합니다: (1) 가져온 설정 상수, (2) 인스턴스 간 공유되는 지속 카운터/상태, (3) 캐시된 계산 결과. 단일 값에는 메모리보다 단순하고 JS로 공유하면 여러 인스턴스에서 보입니다.
(module
;; Configuration constants
(global $maxSize (import "config" "maxSize") i32)
(global $debug (import "config" "debug") i32)
;; Persistent counters
(global $calls (mut i32) (i32.const 0))
(func (export "handle") (result i32)
global.get $calls
i32.const 1
i32.add
global.set $calls
global.get $calls
)
)가져오기와 내보내기
함수 가져오기
가져오기는 Wasm이 호스트(JS) 함수를 호출하게 합니다. 각 가져오기는 두 수준 이름(module, field)으로 식별됩니다. instantiate에 넘기는 import 객체가 이 이름과 일치해야 합니다. 가져오기는 Wasm이 외부 세계(I/O, 로깅, 스케줄링)에 닿는 방법입니다.