The JavaScript(x, cgopts) calling sequence translates Maple code to JavaScript code.

- If the parameter x is an algebraic expression, then a JavaScript statement assigning the expression to a variable is generated.

- If x is a list, Maple Array, or rtable of algebraic expressions, then a sequence of JavaScript statements assigning the elements to a JavaScript array is produced.  Only the initialized elements of the rtable or Maple Array are translated.

- If x is a list of equations $\mathrm{nm}=\mathrm{expr}$ where $\mathrm{nm}$ is a name and $\mathrm{expr}$ is an algebraic expression, this is understood as a sequence of assignment statements.  In this case, the equivalent sequence of JavaScript assignment statements is generated.

- If x is a procedure, then a JavaScript class is generated containing a function equivalent to the procedure, along with any necessary import statements.

- If x is a module, then a JavaScript class is generated, as described on the JavaScriptDetails help page.

The parameter cgopts may include one or more CodeGeneration options, as described in CodeGenerationOptions.

For more information about how the CodeGeneration package translates Maple code to other languages, see Translation Details. For more information about translation to JavaScript in particular, see JavaScriptDetails.

$\mathrm{with}\left(\mathrm{CodeGeneration}\right)\:$

$\mathrm{JavaScript}\left(x+yz-2xz\,\mathrm{resultname}=''w''\right)$

w = -2 * x * z + y * z + x;

$\mathrm{JavaScript}\left(\left[\left[x\,2y\right]\,\left[5\,z\right]\right]\,\mathrm{resultname}=''w''\right)$

w = [[x, 2 * y], [5, z]];

$\mathrm{cs}≔\left[s=1.0+x\,t=\ln \left(s\right)\exp \left(-x\right)\,r=\exp \left(-x\right)+xt\right]\:$

$\mathrm{JavaScript}\left(\mathrm{cs}\,\mathrm{optimize}\right)$

s = 0.10e1 + x;
t1 = Math.log(s);
t2 = Math.exp(-x);
t = t2 * t1;
r = x * t + t2;

$s≔\mathrm{JavaScript}\left(x+y+1\,\mathrm{declare}=\left[x::\mathrm{float}\,y::\mathrm{integer}\right]\,\mathrm{output}=\mathrm{string}\right)$

$s≔''cg\; =\; x\; +\; y\; +\; 1;''$

f := proc(x, y, z) return x*y-y*z+x*z; end proc:

$\mathrm{JavaScript}\left(f\,\mathrm{defaulttype}=\mathrm{integer}\right)$

function f(x, y, z) {
  return(y * x - y * z + x * z);
}

f := proc(n)
  local x, i;
  x := 0.0;
  for i to n do
    x := x + i;
  end do;
end proc:

$\mathrm{JavaScript}\left(f\right)$

function f(n) {
  var x;
  var i;
  var cgret;
  x = 0.0e0;
  for (i in 1...n)
  {
    x = x + i;
    cgret = x;
  }
  return(cgret);
}

f := proc(x::Array(numeric, 5..7))
  return x[5]+x[6]+x[7];
end proc:

$\mathrm{JavaScript}\left(f\right)$

function f(x) {
  return(x[0] + x[1] + x[2]);
}

m := module() export p; local q;
    p := proc(x,y) if y>0 then trunc(x); else ceil(x); end if; end proc:
    q := proc(x) sin(x)^2; end proc:
end module:

$\mathrm{JavaScript}\left(m\,\mathrm{resultname}=\mathrm{t0}\right)$

var m = {
  "p": function(x, y) {
      if (0 < y)
      {
        return(trunc(x));
      }
      else
      {
        return(Math.ceil(x));
      }
  },
  "q": function(x) {
      return(Math.pow(Math.sin(x), 2));
  }
}

$\mathrm{JavaScript}\left(2\cosh \left(x\right)-7\tanh \left(x\right)\right)$

cg0 = 2 * (Math.exp(x) + Math.exp((-0.1e1) * x)) / 0.2e1 - 7 * (Math.exp(0.2e1 * x) - 0.1e1) / (Math.exp(0.2e1 * x) + 0.1e1);

f := proc(a::integer, p::integer)
  printf("The integer remainder of %d divided by %d is: %d\n", a, p, irem(a, p));
end proc:

$\mathrm{JavaScript}\left(f\right)$

function f(a, p) {
  printf("The integer remainder of %d divided by %d is: %d\n", a, p, a % p);
}

The CodeGeneration[JavaScript] command was introduced in Maple 2015.

For more information on Maple 2015 changes, see Updates in Maple 2015.