Coming from JavaScript

The two languages look alike, so the differences are easy to miss. Braces, for, while, function, closures, class, try/catch, ?., ??, string interpolation and async/await have the same meaning. The differences are inside common expressions: there is no undefined, integers and floats are separate types, and reading a key that is not there is an error.

Values and bindings

JavaScript	Quirrel
`let x = 1`, rebindable	`local x = 1` - rebindable; `let x = 1` - binds once
`const x = 1`	`let x = 1`; `const MAX = 10 * 5`, folded at compile time
`var`	nothing
`null` and `undefined`	`null` alone
one number type	`integer` and `float`; `7 / 2` is `3`, `7 / 2.0` is `3.5`
`x === y`	`x == y`; there is no loose equality to avoid
a template literal, `${b}` inside	`$"a {b}"`
`(x) => x * 2`	`@(x) x * 2`
`function (x) { }`	the same
`typeof x`	`type(x)`, or `typeof x`, giving `"integer"`, `"table"`, `"instance"`, ...
`x ?? y`, `x?.y`, `a?.[i]`, `f?.()`	`x ?? y`, `x?.y`, `a?[i]`, `f?()`
`!x`, `&&`, `\|\|`	the same, and they keep the operand value
`x++`, `+=`, `<<`, `&`	the same
`NaN`, `Infinity`	neither one; `1 / 0` throws
`String(x)`, `Number(s)`	`x.tostring()`, `s.tointeger()`, `s.tofloat()`
`// comment`	the same

Objects and arrays

JavaScript	Quirrel
`{ a: 1 }`	`{ a = 1 }`, a table, with `=` inside; `{ [expr] = 1 }` for a computed key
`{ x, y }` shorthand	`{ x, y }`, the same
`o.miss` gives `undefined`	it throws; `o?.miss` gives `null`, and `??` fills in
`o.fresh = v`	`o.fresh <- v`; plain `=` writes a slot that is already there
`delete o.k`	`o.$rawdelete("k")`; the `delete` operator is off by default
`"k" in o`, `o.hasOwnProperty(k)`	`"k" in o`, `o.rawin(k)`
`Object.keys`, `values`, `entries`	`o.keys()`, `o.values()`, `o.topairs()`
`Object.assign({}, a, b)`	`{ ...a, ...b }`, or `a.__merge(b)`; `a.__update(b)` updates in place
`Object.freeze(o)`	`freeze(o)`, and it reaches the tables inside
`{ ...o }`, `[...a]`	the same, one level deep; a table also takes a class or an instance, and a `null` source adds nothing
`{ ...a, ...b }`, `[...a, ...b]`	the same, and a later key wins
`structuredClone(o)`	nothing; `clone o` copies one level
`const { a, b } = o`	`let { a, b } = o`, and a key that is not there throws unless it has a default
`const { a, ...rest } = o`	`let { a } = o`; there is no rest element
`a.length`	`a.len()`
`a.push(v)`, `a.pop()`	`a.append(v)`, `a.pop()`
`a.shift()`, `a.unshift(v)`	`a.remove(0)`, `a.insert(0, v)`
`a.indexOf(v)`	`a.indexof(v)`, and `null` rather than `-1`
`a.includes(v)`	`a.contains(v)`
`a.forEach(f)`	`a.each(f)`
`a.map`, `a.filter`, `a.reduce`	the same names, and the callback is `(value, index)`
`a.find`, `a.findIndex`	`a.findvalue`, `a.findindex`
`a.concat(b)`	`a.extend(b)`; `+` does not join two arrays
`a.join(",")`	`",".join(a)`, which is a string method
`a.slice(1, 3)`, `a.slice(-2)`	the same
`s.toUpperCase()`, `s.trim()`	`s.toupper()`, `s.strip()`
`s.startsWith(p)`, `s.includes(p)`	`s.startswith(p)`, `s.contains(p)`
`s.replace(a, b)`	`s.replace(a, b)`, and it replaces every match
`/re/` literal	`regexp("re")` from string
`JSON.parse`, `JSON.stringify`	not in the core library
`Map`, `Set`	a table

Control flow and functions

JavaScript	Quirrel
`for (const v of a)`	`foreach (v in a)`
`for (const k in o)`	`foreach (k, v in o)`, which gives both
`for (let i = 0; ...)`	`for (local i = 0; ...)`; `let` is not allowed in a `for` header
`switch`	`if (a) ... else if (b) ...`; `switch` is deprecated and off by default, see control flow
`try / catch / finally`	`try { } catch (e) { }`; no exception classes, and no `finally`
`throw new Error(m)`	`throw m`; any value can be thrown, and `catch` takes them all
`async` and `await`	the same words; see async and await
`function* g()` with `yield`	any function that contains `yield`
`f(...args)`	`f.acall([this, a, b])`
`f.call(o, x)`, `f.apply(o, args)`	`f.call(o, x)`, `f.acall([o, x])`
`f.bind(o)`	`f.bindenv(o)`
`arguments`	`vargv`, in a `function f(...)`
a default parameter	`function f(a, b = 1) { }`, the same

Classes

JavaScript	Quirrel
`class A extends B`	`class A(B) { }`, with one base class only
`constructor()`	`constructor()`
`super.m()`, `super()`	`base.m()`, `base.constructor()`
a field assigned in the constructor	declare it in the class body; an instance takes no new slots later
`static x = 1`	`static x = 1`
`get x()`, `set x(v)`	the `_get` and `_set` metamethods
`toString()`	`_tostring`
`new A()`	`A()`; there is no `new`
`a instanceof A`	the same
a prototype patched at run time	a class is locked as soon as it is used

Modules

JavaScript	Quirrel
`import { x } from "m"`	`from "m" import x`
`import * as m from "m"`	`import "m" as m`
`require("m")`	`require("m")`, at run time; `import "m"` at compile time
`export default v`	`return v` at the end of the file
`export const a, b`	`return freeze({ a, b })`

Traps

There is no undefined. Reading a slot that is not there throws, and so does reading a member of null. o?.x gives null, and ?? fills it in.
A missing slot named like a type method is not null. When t has no filter slot, t?.filter finds Table.filter. Test with "filter" in t, or write t.$filter when you want the type method.
7 / 2 is 3. Two integers divide as integers. Make one side a float.
1 / 0 throws instead of giving Infinity, and 0.0 / 0.0 throws instead of giving NaN.
"", [] and {} are true. 0 and 0.0 are false, as in JavaScript, but an empty string or container is not. Test s.len() == 0.
for gives every closure the same variable, the way var did. foreach gives each pass its own. The sample below shows both.
== on two tables compares identity, like === on two objects. There is no deep comparison in the language.
+ joins when one side is a string and throws for other mixed pairs, so 1 + true throws. Use $"...". The analyzer flags + on a string as w264.
A container in a class body is one object for every instance. A JavaScript class field is built per instance; this one is not. Declare the slot as null and fill it in the constructor.
clone is an operator, not a function. clone(a).append(9) parses as clone (a.append(9)), which appends to a. Write (clone a).append(9).

examples/pages/coming-from/javascript.nut

let squad = { name = "alpha" }

// a slot that is not there is an error, not undefined
try {
  println(squad.hp)
} catch (e) {
  println(e)
}
println(squad?.hp ?? 100)

// two integers divide as integers, and a division by zero throws
println(7 / 2)
local zero = 0    // local: a let would fold to 0 and the analyzer would flag the division
try {
  println(1 / zero)
} catch (e) {
  println(e)
}

// for gives every closure the same variable, foreach gives each one its own
let fromFor = []
for (local i = 0; i < 3; i++)
  fromFor.append(@() i)

let fromForeach = []
foreach (v in [0, 1, 2])
  fromForeach.append(@() v)

println($"for:     {fromFor[0]()}{fromFor[1]()}{fromFor[2]()}")
println($"foreach: {fromForeach[0]()}{fromForeach[1]()}{fromForeach[2]()}")

Output:

the index 'hp' (type='string') does not exist
100
3
integer division by zero
for:     333
foreach: 012

What is not there

undefined, NaN, Infinity, finally, new, labelled statements
prototypes, Symbol, Proxy, Map, Set, JSON, Promise (the runtime has Future instead)
spread in a call, a rest element in destructuring, tagged templates, a regular expression literal
truthiness for an empty string or container
automatic number growth: an integer is 64 bits and it wraps