javascript 0.1.13

A JavaScript engine implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

function assert(condition, message) {
    if (!condition) {
        throw new Error(message);
    }
}

{
  console.log("=== Map Example ===");

  const sayings = new Map();
  sayings.set("dog", "woof");
  sayings.set("cat", "meow");
  sayings.set("elephant", "toot");
  assert(sayings.size === 3, "Map size should be 3"); // sayings.size; // 3

  console.log("sayings dog =", sayings.get("dog")); // woof
  console.log("sayings fox =", sayings.get("fox")); // undefined
  console.log("sayings has bird =", sayings.has("bird")); // false

  sayings.delete("dog");
  console.log("sayings has dog =", sayings.has("dog")); // false

  for (const [key, value] of sayings) {
    console.log(`${key} goes ${value}`);
  }
  // "cat goes meow"
  // "elephant goes toot"

  sayings.clear();
  assert(sayings.size === 0, "Map size should be 0");
}

{
  console.log("=== WeakMap Example ===");
  const privates = new WeakMap();

  function Public() {
    const me = {
      // Private data goes here
      registered: [],
    };
    privates.set(this, me);
  }

  Public.prototype.method = function () {
    const me = privates.get(this);
    if (me) {
      console.log("Private data accessed:", me);
      me.registered.push("test");
      console.log("Updated private data:", me.registered);
    } else {
      throw new Error("Private data not found!");
    }
  };

  const instance = new Public();
  instance.method();
}

{
  console.log("=== Set Example ===");
  const mySet = new Set();
  mySet.add(1);
  mySet.add("some text");
  mySet.add("foo");

  console.log("mySet has 1:", mySet.has(1)); // true
  assert(mySet.has(1) === true, "Set should have 1");

  mySet.delete("foo");
  console.log("mySet size after delete:", mySet.size); // 2
  assert(mySet.size === 2, "Set size should be 2");

  console.log("Iterating over Set:");
  for (const item of mySet) {
    console.log(item);
  }
  // 1
  // "some text"
}

{
  console.log("=== Array <-> Set Conversion Example ===");

  // 1. Create Set from Array
  const mySet = new Set([1, 2, 3, 4]);
  console.log("Set created from [1, 2, 3, 4], size:", mySet.size);
  assert(mySet.size === 4, "Set size should be 4");

  // 2. Convert Set to Array using Array.from
  const arr1 = Array.from(mySet);
  console.log("Array.from(mySet):", arr1);
  assert(arr1.length === 4, "arr1 length should be 4");
  assert(arr1[0] === 1, "arr1[0] should be 1");

  // 3. Convert Set to Array using spread syntax
  const arr2 = [...mySet];
  console.log("[...mySet]:", arr2);
  assert(arr2.length === 4, "arr2 length should be 4");
  assert(arr2[3] === 4, "arr2[3] should be 4");
}

{
  console.log("=== Array.from Map Example ===");
  const map = new Map();
  map.set("k1", "v1");
  map.set("k2", "v2");
  
  const arr = Array.from(map);
  console.log("Array.from(map):", arr);
  // Expected: [["k1", "v1"], ["k2", "v2"]]
  assert(arr.length === 2, "Array from map should have length 2");
  assert(Array.isArray(arr[0]), "First element should be an array");
  assert(arr[0][0] === "k1", "First key should be k1");
  assert(arr[0][1] === "v1", "First value should be v1");
}