Go: syscall/js Index | Examples | Files

package js

import "syscall/js"

Package js gives access to the WebAssembly host environment when using the js/wasm architecture. Its API is based on JavaScript semantics.

This package is EXPERIMENTAL. Its current scope is only to allow tests to run, but not yet to provide a comprehensive API for users. It is exempt from the Go compatibility promise.

Index

Examples

Package Files

func.go js.go

func CopyBytesToGo Uses

func CopyBytesToGo(dst []byte, src Value) int

CopyBytesToGo copies bytes from src to dst. It panics if src is not an Uint8Array or Uint8ClampedArray. It returns the number of bytes copied, which will be the minimum of the lengths of src and dst.

func CopyBytesToJS Uses

func CopyBytesToJS(dst Value, src []byte) int

CopyBytesToJS copies bytes from src to dst. It panics if dst is not an Uint8Array or Uint8ClampedArray. It returns the number of bytes copied, which will be the minimum of the lengths of src and dst.

type Error Uses

type Error struct {
    // Value is the underlying JavaScript error value.
    Value
}

Error wraps a JavaScript error.

func (Error) Error Uses

func (e Error) Error() string

Error implements the error interface.

type Func Uses

type Func struct {
    Value // the JavaScript function that invokes the Go function
    // contains filtered or unexported fields
}

Func is a wrapped Go function to be called by JavaScript.

func FuncOf Uses

func FuncOf(fn func(this Value, args []Value) interface{}) Func

FuncOf returns a function to be used by JavaScript.

The Go function fn is called with the value of JavaScript's "this" keyword and the arguments of the invocation. The return value of the invocation is the result of the Go function mapped back to JavaScript according to ValueOf.

Invoking the wrapped Go function from JavaScript will pause the event loop and spawn a new goroutine. Other wrapped functions which are triggered during a call from Go to JavaScript get executed on the same goroutine.

As a consequence, if one wrapped function blocks, JavaScript's event loop is blocked until that function returns. Hence, calling any async JavaScript API, which requires the event loop, like fetch (http.Client), will cause an immediate deadlock. Therefore a blocking function should explicitly start a new goroutine.

Func.Release must be called to free up resources when the function will not be invoked any more.

Code:play 

// +build js,wasm

// To run these tests:
//
// - Install Node
// - Add /path/to/go/misc/wasm to your $PATH (so that "go test" can find
//   "go_js_wasm_exec").
// - GOOS=js GOARCH=wasm go test
//
// See -exec in "go help test", and "go help run" for details.

package main

import (
    "fmt"
    "math"
    "runtime"
    "syscall/js"
    "testing"
)

var dummys = js.Global().Call("eval", `({
	someBool: true,
	someString: "abc\u1234",
	someInt: 42,
	someFloat: 42.123,
	someArray: [41, 42, 43],
	someDate: new Date(),
	add: function(a, b) {
		return a + b;
	},
	zero: 0,
	stringZero: "0",
	NaN: NaN,
	emptyObj: {},
	emptyArray: [],
	Infinity: Infinity,
	NegInfinity: -Infinity,
	objNumber0: new Number(0),
	objBooleanFalse: new Boolean(false),
})`)

func TestBool(t *testing.T) {
    want := true
    o := dummys.Get("someBool")
    if got := o.Bool(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    dummys.Set("otherBool", want)
    if got := dummys.Get("otherBool").Bool(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if !dummys.Get("someBool").Equal(dummys.Get("someBool")) {
        t.Errorf("same value not equal")
    }
}

func TestString(t *testing.T) {
    want := "abc\u1234"
    o := dummys.Get("someString")
    if got := o.String(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    dummys.Set("otherString", want)
    if got := dummys.Get("otherString").String(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if !dummys.Get("someString").Equal(dummys.Get("someString")) {
        t.Errorf("same value not equal")
    }

    if got, want := js.Undefined().String(), "<undefined>"; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got, want := js.Null().String(), "<null>"; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got, want := js.ValueOf(true).String(), "<boolean: true>"; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got, want := js.ValueOf(42.5).String(), "<number: 42.5>"; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got, want := js.Global().Call("Symbol").String(), "<symbol>"; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got, want := js.Global().String(), "<object>"; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got, want := js.Global().Get("setTimeout").String(), "<function>"; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
}

func TestInt(t *testing.T) {
    want := 42
    o := dummys.Get("someInt")
    if got := o.Int(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    dummys.Set("otherInt", want)
    if got := dummys.Get("otherInt").Int(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if !dummys.Get("someInt").Equal(dummys.Get("someInt")) {
        t.Errorf("same value not equal")
    }
    if got := dummys.Get("zero").Int(); got != 0 {
        t.Errorf("got %#v, want %#v", got, 0)
    }
}

func TestIntConversion(t *testing.T) {
    testIntConversion(t, 0)
    testIntConversion(t, 1)
    testIntConversion(t, -1)
    testIntConversion(t, 1<<20)
    testIntConversion(t, -1<<20)
    testIntConversion(t, 1<<40)
    testIntConversion(t, -1<<40)
    testIntConversion(t, 1<<60)
    testIntConversion(t, -1<<60)
}

func testIntConversion(t *testing.T, want int) {
    if got := js.ValueOf(want).Int(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
}

func TestFloat(t *testing.T) {
    want := 42.123
    o := dummys.Get("someFloat")
    if got := o.Float(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    dummys.Set("otherFloat", want)
    if got := dummys.Get("otherFloat").Float(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if !dummys.Get("someFloat").Equal(dummys.Get("someFloat")) {
        t.Errorf("same value not equal")
    }
}

func TestObject(t *testing.T) {
    if !dummys.Get("someArray").Equal(dummys.Get("someArray")) {
        t.Errorf("same value not equal")
    }

    // An object and its prototype should not be equal.
    proto := js.Global().Get("Object").Get("prototype")
    o := js.Global().Call("eval", "new Object()")
    if proto.Equal(o) {
        t.Errorf("object equals to its prototype")
    }
}

func TestFrozenObject(t *testing.T) {
    o := js.Global().Call("eval", "(function () { let o = new Object(); o.field = 5; Object.freeze(o); return o; })()")
    want := 5
    if got := o.Get("field").Int(); want != got {
        t.Errorf("got %#v, want %#v", got, want)
    }
}

func TestEqual(t *testing.T) {
    if !dummys.Get("someFloat").Equal(dummys.Get("someFloat")) {
        t.Errorf("same float is not equal")
    }
    if !dummys.Get("emptyObj").Equal(dummys.Get("emptyObj")) {
        t.Errorf("same object is not equal")
    }
    if dummys.Get("someFloat").Equal(dummys.Get("someInt")) {
        t.Errorf("different values are not unequal")
    }
}

func TestNaN(t *testing.T) {
    if !dummys.Get("NaN").IsNaN() {
        t.Errorf("JS NaN is not NaN")
    }
    if !js.ValueOf(math.NaN()).IsNaN() {
        t.Errorf("Go NaN is not NaN")
    }
    if dummys.Get("NaN").Equal(dummys.Get("NaN")) {
        t.Errorf("NaN is equal to NaN")
    }
}

func TestUndefined(t *testing.T) {
    if !js.Undefined().IsUndefined() {
        t.Errorf("undefined is not undefined")
    }
    if !js.Undefined().Equal(js.Undefined()) {
        t.Errorf("undefined is not equal to undefined")
    }
    if dummys.IsUndefined() {
        t.Errorf("object is undefined")
    }
    if js.Undefined().IsNull() {
        t.Errorf("undefined is null")
    }
    if dummys.Set("test", js.Undefined()); !dummys.Get("test").IsUndefined() {
        t.Errorf("could not set undefined")
    }
}

func TestNull(t *testing.T) {
    if !js.Null().IsNull() {
        t.Errorf("null is not null")
    }
    if !js.Null().Equal(js.Null()) {
        t.Errorf("null is not equal to null")
    }
    if dummys.IsNull() {
        t.Errorf("object is null")
    }
    if js.Null().IsUndefined() {
        t.Errorf("null is undefined")
    }
    if dummys.Set("test", js.Null()); !dummys.Get("test").IsNull() {
        t.Errorf("could not set null")
    }
    if dummys.Set("test", nil); !dummys.Get("test").IsNull() {
        t.Errorf("could not set nil")
    }
}

func TestLength(t *testing.T) {
    if got := dummys.Get("someArray").Length(); got != 3 {
        t.Errorf("got %#v, want %#v", got, 3)
    }
}

func TestGet(t *testing.T) {
    // positive cases get tested per type

    expectValueError(t, func() {
        dummys.Get("zero").Get("badField")
    })
}

func TestSet(t *testing.T) {
    // positive cases get tested per type

    expectValueError(t, func() {
        dummys.Get("zero").Set("badField", 42)
    })
}

func TestDelete(t *testing.T) {
    dummys.Set("test", 42)
    dummys.Delete("test")
    if dummys.Call("hasOwnProperty", "test").Bool() {
        t.Errorf("property still exists")
    }

    expectValueError(t, func() {
        dummys.Get("zero").Delete("badField")
    })
}

func TestIndex(t *testing.T) {
    if got := dummys.Get("someArray").Index(1).Int(); got != 42 {
        t.Errorf("got %#v, want %#v", got, 42)
    }

    expectValueError(t, func() {
        dummys.Get("zero").Index(1)
    })
}

func TestSetIndex(t *testing.T) {
    dummys.Get("someArray").SetIndex(2, 99)
    if got := dummys.Get("someArray").Index(2).Int(); got != 99 {
        t.Errorf("got %#v, want %#v", got, 99)
    }

    expectValueError(t, func() {
        dummys.Get("zero").SetIndex(2, 99)
    })
}

func TestCall(t *testing.T) {
    var i int64 = 40
    if got := dummys.Call("add", i, 2).Int(); got != 42 {
        t.Errorf("got %#v, want %#v", got, 42)
    }
    if got := dummys.Call("add", js.Global().Call("eval", "40"), 2).Int(); got != 42 {
        t.Errorf("got %#v, want %#v", got, 42)
    }

    expectPanic(t, func() {
        dummys.Call("zero")
    })
    expectValueError(t, func() {
        dummys.Get("zero").Call("badMethod")
    })
}

func TestInvoke(t *testing.T) {
    var i int64 = 40
    if got := dummys.Get("add").Invoke(i, 2).Int(); got != 42 {
        t.Errorf("got %#v, want %#v", got, 42)
    }

    expectValueError(t, func() {
        dummys.Get("zero").Invoke()
    })
}

func TestNew(t *testing.T) {
    if got := js.Global().Get("Array").New(42).Length(); got != 42 {
        t.Errorf("got %#v, want %#v", got, 42)
    }

    expectValueError(t, func() {
        dummys.Get("zero").New()
    })
}

func TestInstanceOf(t *testing.T) {
    someArray := js.Global().Get("Array").New()
    if got, want := someArray.InstanceOf(js.Global().Get("Array")), true; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got, want := someArray.InstanceOf(js.Global().Get("Function")), false; got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
}

func TestType(t *testing.T) {
    if got, want := js.Undefined().Type(), js.TypeUndefined; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
    if got, want := js.Null().Type(), js.TypeNull; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
    if got, want := js.ValueOf(true).Type(), js.TypeBoolean; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
    if got, want := js.ValueOf(0).Type(), js.TypeNumber; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
    if got, want := js.ValueOf(42).Type(), js.TypeNumber; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
    if got, want := js.ValueOf("test").Type(), js.TypeString; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
    if got, want := js.Global().Get("Symbol").Invoke("test").Type(), js.TypeSymbol; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
    if got, want := js.Global().Get("Array").New().Type(), js.TypeObject; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
    if got, want := js.Global().Get("Array").Type(), js.TypeFunction; got != want {
        t.Errorf("got %s, want %s", got, want)
    }
}

type object = map[string]interface{}
type array = []interface{}

func TestValueOf(t *testing.T) {
    a := js.ValueOf(array{0, array{0, 42, 0}, 0})
    if got := a.Index(1).Index(1).Int(); got != 42 {
        t.Errorf("got %v, want %v", got, 42)
    }

    o := js.ValueOf(object{"x": object{"y": 42}})
    if got := o.Get("x").Get("y").Int(); got != 42 {
        t.Errorf("got %v, want %v", got, 42)
    }
}

func TestZeroValue(t *testing.T) {
    var v js.Value
    if !v.IsUndefined() {
        t.Error("zero js.Value is not js.Undefined()")
    }
}

func TestFuncOf(t *testing.T) {
    c := make(chan struct{})
    cb := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
        if got := args[0].Int(); got != 42 {
            t.Errorf("got %#v, want %#v", got, 42)
        }
        c <- struct{}{}
        return nil
    })
    defer cb.Release()
    js.Global().Call("setTimeout", cb, 0, 42)
    <-c
}

func TestInvokeFunction(t *testing.T) {
    called := false
    cb := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
        cb2 := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
            called = true
            return 42
        })
        defer cb2.Release()
        return cb2.Invoke()
    })
    defer cb.Release()
    if got := cb.Invoke().Int(); got != 42 {
        t.Errorf("got %#v, want %#v", got, 42)
    }
    if !called {
        t.Error("function not called")
    }
}

func TestInterleavedFunctions(t *testing.T) {
    c1 := make(chan struct{})
    c2 := make(chan struct{})

    js.Global().Get("setTimeout").Invoke(js.FuncOf(func(this js.Value, args []js.Value) interface{} {
        c1 <- struct{}{}
        <-c2
        return nil
    }), 0)

    <-c1
    c2 <- struct{}{}
    // this goroutine is running, but the callback of setTimeout did not return yet, invoke another function now
    f := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
        return nil
    })
    f.Invoke()
}

func main() {
    var cb js.Func
    cb = js.FuncOf(func(this js.Value, args []js.Value) interface{} {
        fmt.Println("button clicked")
        cb.Release() // release the function if the button will not be clicked again
        return nil
    })
    js.Global().Get("document").Call("getElementById", "myButton").Call("addEventListener", "click", cb)
}

// See
// - https://developer.mozilla.org/en-US/docs/Glossary/Truthy
// - https://stackoverflow.com/questions/19839952/all-falsey-values-in-javascript/19839953#19839953
// - http://www.ecma-international.org/ecma-262/5.1/#sec-9.2
func TestTruthy(t *testing.T) {
    want := true
    for _, key := range []string{
        "someBool", "someString", "someInt", "someFloat", "someArray", "someDate",
        "stringZero", // "0" is truthy
        "add",        // functions are truthy
        "emptyObj", "emptyArray", "Infinity", "NegInfinity",
        // All objects are truthy, even if they're Number(0) or Boolean(false).
        "objNumber0", "objBooleanFalse",
    } {
        if got := dummys.Get(key).Truthy(); got != want {
            t.Errorf("%s: got %#v, want %#v", key, got, want)
        }
    }

    want = false
    if got := dummys.Get("zero").Truthy(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got := dummys.Get("NaN").Truthy(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got := js.ValueOf("").Truthy(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got := js.Null().Truthy(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
    if got := js.Undefined().Truthy(); got != want {
        t.Errorf("got %#v, want %#v", got, want)
    }
}

func expectValueError(t *testing.T, fn func()) {
    defer func() {
        err := recover()
        if _, ok := err.(*js.ValueError); !ok {
            t.Errorf("expected *js.ValueError, got %T", err)
        }
    }()
    fn()
}

func expectPanic(t *testing.T, fn func()) {
    defer func() {
        err := recover()
        if err == nil {
            t.Errorf("expected panic")
        }
    }()
    fn()
}

var copyTests = []struct {
    srcLen  int
    dstLen  int
    copyLen int
}{
    {5, 3, 3},
    {3, 5, 3},
    {0, 0, 0},
}

func TestCopyBytesToGo(t *testing.T) {
    for _, tt := range copyTests {
        t.Run(fmt.Sprintf("%d-to-%d", tt.srcLen, tt.dstLen), func(t *testing.T) {
            src := js.Global().Get("Uint8Array").New(tt.srcLen)
            if tt.srcLen >= 2 {
                src.SetIndex(1, 42)
            }
            dst := make([]byte, tt.dstLen)

            if got, want := js.CopyBytesToGo(dst, src), tt.copyLen; got != want {
                t.Errorf("copied %d, want %d", got, want)
            }
            if tt.dstLen >= 2 {
                if got, want := int(dst[1]), 42; got != want {
                    t.Errorf("got %d, want %d", got, want)
                }
            }
        })
    }
}

func TestCopyBytesToJS(t *testing.T) {
    for _, tt := range copyTests {
        t.Run(fmt.Sprintf("%d-to-%d", tt.srcLen, tt.dstLen), func(t *testing.T) {
            src := make([]byte, tt.srcLen)
            if tt.srcLen >= 2 {
                src[1] = 42
            }
            dst := js.Global().Get("Uint8Array").New(tt.dstLen)

            if got, want := js.CopyBytesToJS(dst, src), tt.copyLen; got != want {
                t.Errorf("copied %d, want %d", got, want)
            }
            if tt.dstLen >= 2 {
                if got, want := dst.Index(1).Int(), 42; got != want {
                    t.Errorf("got %d, want %d", got, want)
                }
            }
        })
    }
}

func TestGarbageCollection(t *testing.T) {
    before := js.JSGo.Get("_values").Length()
    for i := 0; i < 1000; i++ {
        _ = js.Global().Get("Object").New().Call("toString").String()
        runtime.GC()
    }
    after := js.JSGo.Get("_values").Length()
    if after-before > 500 {
        t.Errorf("garbage collection ineffective")
    }
}

// BenchmarkDOM is a simple benchmark which emulates a webapp making DOM operations.
// It creates a div, and sets its id. Then searches by that id and sets some data.
// Finally it removes that div.
func BenchmarkDOM(b *testing.B) {
    document := js.Global().Get("document")
    if document.IsUndefined() {
        b.Skip("Not a browser environment. Skipping.")
    }
    const data = "someString"
    for i := 0; i < b.N; i++ {
        div := document.Call("createElement", "div")
        div.Call("setAttribute", "id", "myDiv")
        document.Get("body").Call("appendChild", div)
        myDiv := document.Call("getElementById", "myDiv")
        myDiv.Set("innerHTML", data)

        if got, want := myDiv.Get("innerHTML").String(), data; got != want {
            b.Errorf("got %s, want %s", got, want)
        }
        document.Get("body").Call("removeChild", div)
    }
}

func TestGlobal(t *testing.T) {
    ident := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
        return args[0]
    })
    defer ident.Release()

    if got := ident.Invoke(js.Global()); !got.Equal(js.Global()) {
        t.Errorf("got %#v, want %#v", got, js.Global())
    }
}

func (Func) Release Uses

func (c Func) Release()

Release frees up resources allocated for the function. The function must not be invoked after calling Release. It is allowed to call Release while the function is still running.

type Type Uses

type Type int

Type represents the JavaScript type of a Value.

const (
    TypeUndefined Type = iota
    TypeNull
    TypeBoolean
    TypeNumber
    TypeString
    TypeSymbol
    TypeObject
    TypeFunction
)

func (Type) String Uses

func (t Type) String() string

type Value Uses

type Value struct {
    // contains filtered or unexported fields
}

Value represents a JavaScript value. The zero value is the JavaScript value "undefined". Values can be checked for equality with the Equal method.

func Global Uses

func Global() Value

Global returns the JavaScript global object, usually "window" or "global".

func Null Uses

func Null() Value

Null returns the JavaScript value "null".

func Undefined Uses

func Undefined() Value

Undefined returns the JavaScript value "undefined".

func ValueOf Uses

func ValueOf(x interface{}) Value

ValueOf returns x as a JavaScript value:

| Go                     | JavaScript             |
| ---------------------- | ---------------------- |
| js.Value               | [its value]            |
| js.Func                | function               |
| nil                    | null                   |
| bool                   | boolean                |
| integers and floats    | number                 |
| string                 | string                 |
| []interface{}          | new array              |
| map[string]interface{} | new object             |

Panics if x is not one of the expected types.

func (Value) Bool Uses

func (v Value) Bool() bool

Bool returns the value v as a bool. It panics if v is not a JavaScript boolean.

func (Value) Call Uses

func (v Value) Call(m string, args ...interface{}) Value

Call does a JavaScript call to the method m of value v with the given arguments. It panics if v has no method m. The arguments get mapped to JavaScript values according to the ValueOf function.

func (Value) Delete Uses

func (v Value) Delete(p string)

Delete deletes the JavaScript property p of value v. It panics if v is not a JavaScript object.

func (Value) Equal Uses

func (v Value) Equal(w Value) bool

Equal reports whether v and w are equal according to JavaScript's === operator.

func (Value) Float Uses

func (v Value) Float() float64

Float returns the value v as a float64. It panics if v is not a JavaScript number.

func (Value) Get Uses

func (v Value) Get(p string) Value

Get returns the JavaScript property p of value v. It panics if v is not a JavaScript object.

func (Value) Index Uses

func (v Value) Index(i int) Value

Index returns JavaScript index i of value v. It panics if v is not a JavaScript object.

func (Value) InstanceOf Uses

func (v Value) InstanceOf(t Value) bool

InstanceOf reports whether v is an instance of type t according to JavaScript's instanceof operator.

func (Value) Int Uses

func (v Value) Int() int

Int returns the value v truncated to an int. It panics if v is not a JavaScript number.

func (Value) Invoke Uses

func (v Value) Invoke(args ...interface{}) Value

Invoke does a JavaScript call of the value v with the given arguments. It panics if v is not a JavaScript function. The arguments get mapped to JavaScript values according to the ValueOf function.

func (Value) IsNaN Uses

func (v Value) IsNaN() bool

IsNaN reports whether v is the JavaScript value "NaN".

func (Value) IsNull Uses

func (v Value) IsNull() bool

IsNull reports whether v is the JavaScript value "null".

func (Value) IsUndefined Uses

func (v Value) IsUndefined() bool

IsUndefined reports whether v is the JavaScript value "undefined".

func (Value) JSValue Uses

func (v Value) JSValue() Value

JSValue implements Wrapper interface.

func (Value) Length Uses

func (v Value) Length() int

Length returns the JavaScript property "length" of v. It panics if v is not a JavaScript object.

func (Value) New Uses

func (v Value) New(args ...interface{}) Value

New uses JavaScript's "new" operator with value v as constructor and the given arguments. It panics if v is not a JavaScript function. The arguments get mapped to JavaScript values according to the ValueOf function.

func (Value) Set Uses

func (v Value) Set(p string, x interface{})

Set sets the JavaScript property p of value v to ValueOf(x). It panics if v is not a JavaScript object.

func (Value) SetIndex Uses

func (v Value) SetIndex(i int, x interface{})

SetIndex sets the JavaScript index i of value v to ValueOf(x). It panics if v is not a JavaScript object.

func (Value) String Uses

func (v Value) String() string

String returns the value v as a string. String is a special case because of Go's String method convention. Unlike the other getters, it does not panic if v's Type is not TypeString. Instead, it returns a string of the form "<T>" or "<T: V>" where T is v's type and V is a string representation of v's value.

func (Value) Truthy Uses

func (v Value) Truthy() bool

Truthy returns the JavaScript "truthiness" of the value v. In JavaScript, false, 0, "", null, undefined, and NaN are "falsy", and everything else is "truthy". See https://developer.mozilla.org/en-US/docs/Glossary/Truthy.

func (Value) Type Uses

func (v Value) Type() Type

Type returns the JavaScript type of the value v. It is similar to JavaScript's typeof operator, except that it returns TypeNull instead of TypeObject for null.

type ValueError Uses

type ValueError struct {
    Method string
    Type   Type
}

A ValueError occurs when a Value method is invoked on a Value that does not support it. Such cases are documented in the description of each method.

func (*ValueError) Error Uses

func (e *ValueError) Error() string

type Wrapper Uses

type Wrapper interface {
    // JSValue returns a JavaScript value associated with an object.
    JSValue() Value
}

Wrapper is implemented by types that are backed by a JavaScript value.

Package js imports 3 packages (graph) and is imported by 218 packages. Updated 2020-09-10. Refresh now. Tools for package owners.