VBA to JavaScript: The Complete Mapping Reference for Excel Macros Moving to the Web

TL;DR: VBA to JavaScript mapping is the construct-by-construct translation of an Excel macro into browser and server code. Every Dim, loop, Range call, Worksheet event, UserForm control and error handler has a defined web equivalent. In a typical module, roughly 80% of the lines map directly, 15% are reshaped (cells become named state, button clicks become input events), and 5% have no browser equivalent and move to the server. The tables below list the mappings we apply on every conversion, plus the four traps (rounding, empty cells, dates, silent errors) where a literal translation gives the wrong number.

This is the reference we wished existed when we started converting macro workbooks. Microsoft documents VBA and JavaScript separately, and most "VBA vs JavaScript" articles compare the languages without saying what a specific line becomes. This page does the specific part. It complements our five-step VBA conversion process and the worked macro on our VBA conversion page. Here the goal is coverage: if a construct is in your module, it should be in a table below.

How to Read the Mapping Tables

Each VBA construct falls into one of three mapping types, and the type matters more than the syntax:

• Direct: same idea, different spelling. A For loop is a for loop. Translate it and move on.
• Reshaped: the concept survives but the shape changes. Range("B2") does not exist in a browser, so the value it held becomes a named variable fed by a form field.
• Redesigned: the macro did something a browser cannot do, such as open Outlook, write to disk, or run at 6 am. The job survives, but as a server-side feature.

The Notes column names the mapping type where it is not obvious. Where JavaScript has no built-in that behaves identically, the table says so rather than pretending.

Data Types and Variables

VBA	JavaScript	Notes
Dim x As Long / As Integer	let x = 0;	JavaScript has one numeric type. Integer overflow that VBA raises as an error is silent in JavaScript, so range checks are written explicitly.
Dim x As Double	let x = 0;	Both are IEEE 754 doubles. Arithmetic results match bit for bit.
Dim s As String	let s = '';	Direct.
Dim b As Boolean	let b = false;	True is -1 in VBA arithmetic and 1 in JavaScript. Code that adds booleans must be rewritten.
Dim v As Variant	let v;	Avoid. Declare the type the macro actually stores.
Dim d As Date	new Date() or a date library	See the dates table below.
Const RATE As Double = 0.2	const RATE = 0.2;	Direct.
Dim arr(1 To 10) As Double	const arr = new Array(10).fill(0);	VBA arrays can start at 1 or any base. JavaScript arrays start at 0, so every index shifts.
ReDim Preserve arr(n)	arr.push(x) or arr.length = n	JavaScript arrays grow on demand.
Scripting.Dictionary	new Map()	Map preserves insertion order and accepts any key type.
Collection	Array, or Map when keyed	Reshaped.
Set obj = ...	const obj = ...;	No Set keyword. Object references are the default.
Nothing / Is Nothing	null / === null	Direct.
Empty / IsEmpty	undefined / === undefined	Direct.
Public x (module level)	Application state object	See the state table below.

Operators and Control Flow

VBA	JavaScript	Notes
If ... ElseIf ... Else ... End If	if () {} else if () {} else {}	Direct.
IIf(cond, a, b)	cond ? a : b	IIf evaluates both branches. The ternary evaluates one. Matters when a branch can error.
Select Case x	switch (x) { case ...: }	Select Case supports ranges (Case 1 To 5) and comparisons (Case Is > 10). Those become if/else chains.
For i = 1 To n	for (let i = 1; i <= n; i++)	Direct.
For i = n To 1 Step -1	for (let i = n; i >= 1; i--)	Direct.
For Each cell In rng	for (const item of items)	Reshaped: the range is an array by the time the loop runs.
Do While cond ... Loop	while (cond) {}	Direct.
Do ... Loop Until cond	do {} while (!cond)	Note the negation.
Exit For / Exit Do	break	Direct.
Exit Sub / Exit Function	return	Direct.
GoTo label	None	Restructure into functions.
With obj ... End With	None	Destructure the object or use a short local alias.
& (concatenation)	Template literal `${a}${b}`	+ also works but coerces numbers unpredictably when one side is a string.
= (comparison)	===	Never use == in translated code.
<>	!==	Direct.
And / Or / Not	&& / || / !	VBA And and Or evaluate both operands. JavaScript short-circuits. Code that relies on the second operand always running must be rewritten.
Mod	%	Both take the sign of the dividend. But VBA rounds both operands to integers first: 12.6 Mod 5 is 3, while 12.6 % 5 is 2.6. Use Math.round(a) % Math.round(b) for fractional inputs. Excel's MOD worksheet function takes the sign of the divisor, another difference again.
^	**	Direct.
\ (integer division)	Math.trunc(a / b)	VBA rounds both operands to integers before dividing. Check the inputs.
Like "a*"	Regular expression /^a/	Wildcards map to regex.

Built-in Functions

String functions

Most string functions are direct, with one systematic difference: VBA positions start at 1 and JavaScript positions start at 0. Every Mid, InStr and index calculation shifts by one.

VBA	JavaScript	Notes
Len(s)	s.length	Direct.
Left(s, n)	s.slice(0, n)	Direct.
Right(s, n)	s.slice(-n)	Right(s, 0) returns an empty string, but s.slice(-0) returns the whole string. Guard n = 0.
Mid(s, start, n)	s.slice(start - 1, start - 1 + n)	VBA positions are 1-based.
InStr(s, find)	s.indexOf(find) + 1	InStr returns 0 for not found and 1-based positions. indexOf returns -1 and 0-based.
InStrRev(s, find)	s.lastIndexOf(find) + 1	Same offset rule.
Replace(s, a, b)	s.replaceAll(a, b)	replace() only replaces the first match.
UCase / LCase	toUpperCase() / toLowerCase()	Direct.
Trim(s)	s.trim()	VBA Trim strips spaces only. JavaScript trim strips all whitespace, including tabs and newlines.
Split(s, ",")	s === '' ? [] : s.split(',')	Split("", ",") returns an empty array. ''.split(',') returns one empty string, which runs a loop body once.
Join(arr, ",")	arr.join(',')	Direct.
StrComp(a, b, vbTextCompare)	a.localeCompare(b, undefined, { sensitivity: 'accent' })	Case-insensitive compare.
Format(n, "#,##0.00")	new Intl.NumberFormat('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 }).format(n)	Formatting moves to render time. Stored values stay raw numbers.
Format(d, "dd/mm/yyyy")	Intl.DateTimeFormat or a date library	Locale is explicit in JavaScript.
vbCrLf / Chr(10)	'\r\n' / '\n'	Line breaks only matter in generated files. On screen they become HTML elements.
Val("12abc")	parseFloat('12abc')	Both return 12. But Val("") is 0 and parseFloat('') is NaN. Every parse gets an explicit default.
CStr(n)	String(n)	Direct.
IsNumeric(s)	s.trim() !== '' && Number.isFinite(Number(s))	isNaN alone treats an empty string as numeric.

Number functions and rounding

Rounding is where converted financial tools most often disagree with the original workbook. VBA, Excel and JavaScript each round half values differently, and a workbook usually mixes at least two of them without anyone noticing. Microsoft documents the VBA behaviour in its Round function reference, and MDN documents the JavaScript behaviour for Math.round. Neither matches Excel's ROUND.

VBA	JavaScript	Notes
Round(x, 2)	Custom roundHalfEven(x, 2)	VBA Round is banker's rounding: 2.5 becomes 2, 3.5 becomes 4.
WorksheetFunction.Round(x, 2)	Custom roundHalfAwayFromZero(x, 2)	Excel's ROUND rounds half away from zero: 2.5 becomes 3, -2.5 becomes -3. Math.round matches neither: Math.round(-2.5) is -2.
Int(x)	Math.floor(x)	Int(-2.5) is -3.
Fix(x)	Math.trunc(x)	Fix(-2.5) is -2.
CInt(x) / CLng(x)	Custom roundHalfEven(x, 0)	Also banker's rounding, not truncation. A frequent surprise.
Abs / Sqr	Math.abs / Math.sqrt	Direct.
Rnd	Math.random()	VBA Rnd repeats the same sequence every run unless Randomize is called. Math.random() cannot be seeded, so a macro that relies on repeatable output needs a seeded generator instead.
WorksheetFunction.Sum(rng)	arr.reduce((a, b) => a + b, 0)	Reshaped.
WorksheetFunction.Max / Min	arr.length ? Math.max(...arr) : 0	Reshaped.
WorksheetFunction.VLookup(v, rng, 3, False)	rows.find(r => r.key.toLowerCase() === v.toLowerCase())?.field	See the formula conversion guide for lookups in depth.
WorksheetFunction.Match / Index	arr.findIndex() / arr[i]	Match is 1-based. findIndex is 0-based.
WorksheetFunction.SumIf / CountIf	arr.filter(pred).reduce(...) / arr.filter(pred).length	Reshaped.

Date functions

Excel stores dates as serial day numbers counted from 30 December 1899. JavaScript stores them as milliseconds from 1 January 1970 UTC, with a timezone attached. Every conversion between the two is explicit, and every workbook date is tested against the same dates the workbook was built on.

VBA	JavaScript	Notes
Now / Date	new Date()	Date-only values need the time zeroed. Timezone handling is explicit in JavaScript and implicit in VBA.
DateSerial(y, m, d)	new Date(y, m - 1, d)	JavaScript months are 0-based.
DateAdd("m", 1, d)	Date library add	Native JavaScript has no safe month arithmetic. January 31 plus one month needs a rule.
DateDiff("d", a, b)	Math.round((b - a) / 86400000)	Only after both dates are normalised to midnight.
Year / Month / Day	getFullYear() / getMonth() + 1 / getDate()	Note the +1 on month.
Weekday(d)	d.getDay() + 1	Sunday is 1 in both with default settings.
CDate("2026-09-21")	new Date('2026-09-21T00:00:00')	Without the time part, JavaScript parses the string as UTC and can shift the date by a day.
Excel serial date (e.g. 45930)	new Date(Date.UTC(1899, 11, 30) + serial * 86400000)	Excel's epoch is 30 December 1899 because of the 1900 leap year bug it inherited from Lotus 1-2-3.
WorksheetFunction.NetworkDays	Explicit loop or library	No native equivalent. Holidays become a configurable list.

The Excel Object Model: Where Range and Cells Go

This is the reshaped category, and it is the part no automatic converter handles. A browser has no worksheet, so every reference to the grid becomes a reference to a value the app holds explicitly. The rule is mechanical once accepted: a cell the macro reads is an input, a cell it writes is an output, and a cell it both reads and writes is application state. Naming those cells is the first day of any VBA conversion.

VBA	JavaScript	Notes
Range("B2").Value (read)	A named input: qtyInput.valueAsNumber or state.qty	Reshaped. The cell address disappears. The value gets a name.
Range("B5").Value = x (write)	An output binding: totalOutput.textContent = money.format(x)	Reshaped.
Cells(r, c).Value	rows[r - 1][c - 1] over an array of rows	0-based in both dimensions.
Range("A2:D100")	An array of row objects: [{ item, qty, price, total }, ...]	Reshaped. Column letters become property names.
UsedRange / CurrentRegion	The whole array	Direct once the array exists.
Cells(Rows.Count, 1).End(xlUp).Row	rows.length	The "find the last row" idiom disappears entirely.
rng.Offset(1, 0)	rows[i + 1]	Direct.
Range("Table1[Price]")	rows.map(r => r.price)	Structured references map cleanly to object properties.
Names("TaxRate").RefersToRange.Value	A config constant, or a settings record in the database	Redesigned. Admin-editable rates live in a table an admin can edit from the app.
ActiveSheet / ActiveCell / Selection	None	A web app has no cursor. Anything that depended on the selection becomes an explicit parameter.
Worksheets("Rates") (lookup sheet)	A JSON constant for small static data, a database table for anything edited	Redesigned.
Workbooks.Open("other.xlsx")	An API call or an import endpoint	Redesigned.
rng.Find(x)	rows.find(r => r.field.toLowerCase().includes(x.toLowerCase()))	Find is case-insensitive and partial by default, and its LookAt setting persists between calls. Check what the macro actually relied on.
rng.AutoFilter / rng.Sort	rows.filter() / rows.sort()	Direct. Sort needs an explicit comparator.
rng.Interior.Color / Font.Bold	CSS classes toggled by state	Presentation leaves the data layer.
rng.NumberFormat = "0.00%"	Intl.NumberFormat at render time	Values stay raw.
Application.Calculate	A single recompute() function called after every input change	Reshaped. The dependency order is written out once.
Application.ScreenUpdating = False	Not needed	The browser batches DOM updates.
Application.EnableEvents = False	Not needed	The dependency order is explicit, so there are no event chains to suppress.
Application.Volatile	Not needed	Every recompute is explicit.

Events: What Replaces Worksheet_Change?

Excel macros are event driven, but the events belong to the grid. In a web app the events belong to the form fields, and the recalculation order is written out once instead of emerging from a chain of change handlers.

VBA	JavaScript	Notes
Worksheet_Change(Target)	field.addEventListener('input', recompute)	Change fires for every cell and the handler inspects Target. The web version attaches to exactly the fields that matter.
Worksheet_Calculate	The recompute() function itself	No separate after-calculation hook is needed.
Worksheet_SelectionChange	focus / blur events	Rarely needed.
Workbook_Open / Auto_Open	App initialisation on page load	DOMContentLoaded, or the framework's mount hook.
Workbook_BeforeSave	Form submit handler with validation	Reshaped.
Workbook_BeforeClose	beforeunload	Only for unsaved-changes warnings.
CommandButton1_Click / Button.OnAction	button.addEventListener('click', ...)	Direct.
Application.OnTime	setTimeout for UI delays; a scheduled server job for anything that must run when nobody has the page open	Redesigned.
DoEvents	Not needed	The browser event loop is asynchronous by design. A long synchronous loop still freezes the tab, so heavy work moves to the server or a Web Worker.
Application.Wait	await new Promise(r => setTimeout(r, ms))	Almost always a sign the original macro was working around Excel, not solving a business need.

UserForms and Controls

Every UserForm control has a native HTML equivalent. The web versions are responsive, keyboard accessible, and work on phones, none of which a UserForm can claim. Our VBA conversion page covers the multi-user redesign of UserForm workflows in more depth.

VBA UserForm	HTML	Notes
UserForm	An HTML form, a page section, or a modal	Reshaped.
UserForm.Show (modal)	<dialog> with showModal()	Native, accessible, no library required.
Frame	<fieldset> with <legend>	Direct.
Label	<label for="...">	Also gives screen readers something to announce.
TextBox	<input type="text"> or type="number"	Number inputs give valueAsNumber and a numeric keyboard on phones.
ComboBox	<input list> with <datalist>, or <select>	The default DropDownCombo style accepts typed values not in the list, which maps to datalist. DropDownList style maps to a select. A searchable select component when the list is long.
ListBox (single)	<select>	Direct.
ListBox (MultiSelect)	<select multiple> or a checkbox group	Checkbox groups are easier on mobile.
CheckBox	<input type="checkbox">	Direct.
OptionButton group	<input type="radio" name="group">	Direct.
SpinButton / ScrollBar	<input type="number" step="1"> or type="range"	Direct.
MultiPage	Tabbed sections	Reshaped.
CommandButton	<button type="button">	type="submit" for the one that submits.
Image	<img>	Direct.
MsgBox "Saved"	Inline status message or toast	Reshaped.
MsgBox(..., vbYesNo)	A confirm dialog that returns a promise	Reshaped.
InputBox	A field on the form	Almost never needs a separate prompt.
TextBox_Change / TextBox_Exit	input / blur events	Direct.
control.Enabled = False	input.disabled = true	Direct.
control.Visible = False	hidden attribute or a CSS class	Direct.
Cell data validation dropdown	<select>, or <input list> with <datalist>	Datalist allows free text with suggestions, the same as a ComboBox in its default style.

Error Handling and State

VBA	JavaScript	Notes
On Error GoTo Handler	try { } catch (err) { }	Direct.
On Error Resume Next	None by design	Each risky line gets an explicit check. This is the single most common source of hidden bugs in converted macros.
Resume Next / Resume	Restructure	Catch inside the loop and continue.
Err.Number / Err.Description	err.name / err.message	Custom Error subclasses for domain errors.
Err.Raise	throw new Error('...')	Direct.
Debug.Print	console.log	Removed or routed to a logger before release.
Debug.Assert	Unit tests	Redesigned.
Public / Global variables	An application state object	Per-user state lives in the server session, so two users can never overwrite each other.
Static variable in a Sub	Closure or module-level variable	Direct.
Hidden "scratch" sheet	State object, or a database table if it must persist	Redesigned.
Values saved in the workbook between sessions	Database	In-memory state is lost on refresh. Browser storage can keep per-device drafts, but anything shared between users or treated as authoritative belongs in the database.

Files, Data and the Outside World

This is the redesigned category. Nothing here runs in a browser, and none of it should: file access, email and external connections belong on the server, where credentials stay private and the work happens whether or not anyone has the page open.

VBA	JavaScript	Notes
ADODB.Connection / QueryTables	fetch() to an API backed by a database	Redesigned. Credentials never reach the browser.
Open "file.csv" For Output / Print #	Server generates the file; browser triggers a download	Redesigned.
SaveAs / ExportAsFixedFormat (PDF)	Server-side PDF or Excel generation	Redesigned.
Application.FileDialog	<input type="file">, parsed on the server	Reshaped.
FileSystemObject	Not available in the browser	Server job.
Outlook.Application / SendMail	Transactional email API from the server	Redesigned, and far more reliable.
Shell("...")	Not available	Server job or integration.
SendKeys	None	Redesign the interaction.
Clipboard (DataObject)	navigator.clipboard.writeText()	Direct.
Environ("USERNAME")	The authenticated user from the login session	Finally reliable.
PrintOut	window.print() with a print stylesheet, or a generated PDF	Reshaped.
ThisWorkbook.Path	Not applicable	Assets are served by URL.

A Second Worked Example: Loop, Dictionary, Select Case, Format

Our VBA conversion page walks through a single-line-item pricing macro. Here is the next most common shape: a macro that walks a table, buckets rows by category, and builds a summary. It touches almost every table above.

VBA:

Sub SummariseByTier()
    Dim tiers As Object, r As Long, tier As String, lastRow As Long
    Set tiers = CreateObject("Scripting.Dictionary")
    lastRow = Cells(Rows.Count, 1).End(xlUp).Row
    For r = 2 To lastRow
        Select Case Cells(r, 3).Value
            Case Is >= 10000: tier = "Enterprise"
            Case 1000 To 9999: tier = "Business"
            Case Else: tier = "Starter"
        End Select
        If Not tiers.Exists(tier) Then tiers.Add tier, 0
        tiers(tier) = tiers(tier) + Cells(r, 3).Value
    Next r
    Dim key As Variant, msg As String
    For Each key In tiers.Keys
        msg = msg & key & ": " & Format(tiers(key), "#,##0.00") & vbCrLf
    Next key
    MsgBox msg
End Sub

JavaScript:

const money = new Intl.NumberFormat('en-US', {
  minimumFractionDigits: 2, maximumFractionDigits: 2
});

function tierFor(amount) {
  if (amount >= 10000) return 'Enterprise';
  if (amount >= 1000) return 'Business';
  return 'Starter';
}

function summariseByTier(rows) {
  // rows were parsed once at the input boundary: amount is already a Number
  const tiers = new Map();
  for (const row of rows) {
    const tier = tierFor(row.amount);
    tiers.set(tier, (tiers.get(tier) ?? 0) + row.amount);
  }
  return [...tiers].map(([tier, total]) => `${tier}: ${money.format(total)}`);
}

summaryList.replaceChildren(
  ...summariseByTier(rows).map(line =>
    Object.assign(document.createElement('li'), { textContent: line })
  )
);

Five mappings happened. The last-row idiom vanished because rows is already an array. The Dictionary became a Map, and the Exists pre-check collapsed into ?? 0. The Select Case became a small function, which is now testable on its own. Format became Intl.NumberFormat, defined once. And the MsgBox became a list rendered into the page.

One thing also surfaced. The VBA had Case 1000 To 9999 against a decimal column, so an amount of 9999.50 fell through to Starter. The JavaScript version uses >= 1000 and closes the gap. Conversion is where these latent bugs come to light, and whether to preserve or fix each one is a question we put to the client rather than decide silently. That is what the side-by-side test matrix in our conversion process is for.

Four Traps Where a Literal Translation Is Wrong

1. Rounding. Round, WorksheetFunction.Round, CInt and Math.round give three different answers on half values, and a workbook rarely uses only one of them. The converted app uses a named rounding function per behaviour and the test matrix checks totals to the cent.
2. Empty cells. An empty cell reads as 0 in VBA arithmetic and as "" in string operations. An empty form field is always an empty string in JavaScript, and adding it to a number produces text. Every input gets an explicit parse with a defined default.
3. Dates. Serial numbers, the 1899 epoch, 0-based months and timezone shifts on parsing. Dates are converted through one function, never inline.
4. Silent failure and eager evaluation. On Error Resume Next hides errors the original author never saw, so the web version validates at the boundary and reports which row or field is the problem. In the other direction, VBA And evaluates both operands, so a guard like Not rng Is Nothing And rng.Value > 0 errors in VBA but silently short-circuits in JavaScript. Each guard is checked for what the macro actually relied on.

What Has No JavaScript Equivalent at All

A short list, and every item on it is a desktop capability rather than a calculation: Shell, SendKeys, ActiveX controls, COM automation of Outlook or Word, direct file system access, and anything scheduled with Application.OnTime that must run while the workbook is closed. None of these run in a browser and none of them should. Each becomes a server-side feature, usually a better one: a scheduled job instead of a workbook someone has to leave open, an email API instead of a fragile Outlook link. Our running list of what VBA still cannot do online covers the Excel side of the same boundary.

Using This Reference to Scope a Conversion

Run each construct in your module through the tables and mark it direct, reshaped, or redesigned. The count in the third column is what drives the estimate. A macro with 400 lines of direct mappings is a smaller project than one with 80 lines and three redesigned integrations. Our VBA conversion page gives cost and timeline ranges by that shape, and the complete Excel to web application guide covers everything around the macros: formulas, data, hosting and handover.

Or skip the counting. Send us the workbook and within 24 hours you'll get a free Conversion Blueprint that lists every construct in your macros against these mappings, with a fixed price and timeline for the conversion.

Frequently Asked Questions

Can VBA be converted to JavaScript automatically?

Not reliably. Syntax converters can handle the direct category in the tables above (loops, conditionals, string functions), but they have no answer for the Excel object model, worksheet events, UserForms, or file and email automation, which is where most of a real macro lives. Those parts have to be reshaped or redesigned by a developer, then verified against the original workbook with real inputs.

What is the JavaScript equivalent of Range("A1")?

There is none, because a browser has no worksheet. The value the macro read from A1 becomes a named input (a form field or a state variable), and the value it wrote to a cell becomes an output binding. A block like Range("A2:D100") becomes an array of row objects. Naming every cell the macro touches is the first step of any VBA to JavaScript conversion.

Does VBA Round work the same as JavaScript Math.round?

No. VBA's Round uses banker's rounding, so Round(2.5) is 2. Excel's ROUND worksheet function rounds half away from zero, so ROUND(2.5, 0) is 3. JavaScript's Math.round rounds half toward positive infinity, so Math.round(-2.5) is -2. A converted app has to use a purpose-built rounding function that matches whichever behaviour the workbook actually relied on.

What replaces MsgBox and InputBox in a web app?

MsgBox becomes an inline status message, a toast notification, or a modal dialog built with the HTML dialog element. A vbYesNo prompt becomes a confirm dialog that returns a promise. InputBox almost always becomes an ordinary field on the form. The browser does have alert() and prompt(), but they block the page and cannot be styled, so production apps do not use them.

Is Office Scripts the same as converting VBA to JavaScript?

No. Office Scripts is TypeScript that runs inside Excel, on the web and on desktop, through the Excel JavaScript API. It can replace some macros for users who stay in Excel, but it cannot create a standalone web app, cannot serve customers who have no Excel licence, and has no UserForm equivalent. Converting VBA to JavaScript for a web app moves the logic out of Excel entirely.

Is JavaScript harder to maintain than VBA?

Usually the opposite once the conversion is done. The translated logic is typically shorter because the cell bookkeeping disappears, the code lives in version control instead of inside a binary workbook, and it can be unit tested. JavaScript does add concepts VBA lacks, such as asynchronous calls and block scope, which is why the mapping is done by a developer rather than by search and replace.