Visual Basic.CodeCompared.To/JavaScript

No module, no entry point, no imports, and — the part that matters most — no build step. This line runs in any browser's console, in a <script> tag, or through node file.js, exactly as written. There is nothing between the source and the running program, which is the single biggest practical difference from .NET and the reason so much of the web is written in it.

console.log prints the structure of whatever you give it — [ 1, 2, 3 ], not System.Collections.Generic.List`1 — and takes any number of arguments. The rest of the family exists because the browser's console is a real tool rather than a text stream: console.table renders an array of objects as a grid, console.time/timeEnd replaces Stopwatch, console.warn and console.error are separately filterable, and console.dir shows an object's properties.

There are no parameter types, no return type and no check of any kind. discount("80", 25) happens to work, because "80" * 75 coerces to a number. discount("eighty", 25) produces NaN — not an error, not an exception, just a number that is not a number, which then flows silently into whatever you do next. This is the whole story of the page: everything Option Strict On was doing for you is now your responsibility, and the next two rows are about how the ecosystem actually copes.

A JSDoc comment carries the types the language does not. With // @ts-check at the top of the file, or checkJs in a jsconfig.json, the TypeScript compiler reads these annotations and reports errors — in your editor, at author time — while the file remains ordinary JavaScript with no build step. This is the middle path between untyped JavaScript and adopting TypeScript outright, and for a codebase that must ship source as written it is the realistic answer.

TypeOf x Is T becomes typeof x === "...", which knows only seven answers: "number", "string", "boolean", "undefined", "object", "function", "symbol". There is one integer type, so Integer versus Double is Number.isInteger. Two traps: typeof null is "object", a bug from 1995 that can never be fixed, and an array is also "object" — hence Array.isArray. For a class instance, instanceof.

const for a name you will not reassign — which is most of them — and let for one you will; both are block-scoped like Dim. Const becomes const, though it prevents rebinding rather than mutation, so a const array can still be pushed to. var is the pre-2015 form: function-scoped rather than block-scoped, and hoisted, so it exists (as undefined) from the top of the function regardless of where you wrote it. Every style guide bans it.

Every End becomes a brace, Then disappears, ElseIf becomes two words, and ' becomes //. Semicolons terminate statements, and although automatic semicolon insertion supplies most of the missing ones, it also means the opening brace must stay on the same line: a return alone on its line gets a semicolon inserted after it and returns undefined. Write the semicolons, keep the brace where it is, and let a formatter settle the rest.

There is one numeric type, a 64-bit float, and nothing else — no Integer, no Long, no Decimal. Integers are exact only to 2⁵³ (Number.MAX_SAFE_INTEGER), which is why a database id or an account number arriving as a JSON number can arrive wrong. The two answers are bigint (the n suffix, integers only, cannot be mixed with number) or keeping such values as strings. \ becomes Math.trunc(a / b), and money must not live in a number.

Operators convert their operands to make the operation work, using rules almost nobody has memorized: "5" - 2 is 3 because - only means subtraction, while "5" + 2 is "52" because + also means concatenation. == converts before comparing, which is how 1 == "1" is true. Use === and !== always; the single exception worth allowing is x == null, which catches both null and undefined. Ban == in your linter and this whole family of surprises goes away.

Exactly six values are falsy: false, 0, NaN, "", null, undefined. Everything else is truthy — including an empty array and an empty object. So if (items) tells you nothing about an array, and the emptiness test is items.length === 0. This is the opposite of Python and half the opposite of Ruby, so it is worth fixing in memory before writing much code.

undefined means "never given a value" — an uninitialized variable, a missing object property, a function with no return. null means "deliberately empty" and only appears because someone wrote it. Both are falsy and null == undefined is true, so they are usually handled together. ?? falls back only on those two, unlike ||, which also fires on 0 and "". ?. short-circuits a whole chain instead of throwing, which is the tidiest thing JavaScript has that Visual Basic does not.

Add→push, Count→length, and indexing uses square brackets. The LINQ names change: Where→filter, Select→map, Any→some, All→every, FirstOrDefault→find, Aggregate→reduce. Two differences worth knowing: these are eager, each building a whole new array, where LINQ is lazy; and at(-1) reaches the last element without length - 1.

An object literal is { key: value }, and it is simultaneously what you would use a class for, what you would use a Dictionary(Of String, Object) for, and what JSON parses into. Members are reached with a dot or with brackets, added by assigning, and walked with Object.keys, Object.values or Object.entries. Destructuring — const { name, ...rest } = person — pulls parts out by name, and appears on nearly every line of modern JavaScript.

Map is the real Dictionary(Of K, V): any key type, insertion order guaranteed, a size property, and set/get/has/delete. Set is HashSet(Of T). A plain object works as a string-keyed lookup and is what JSON gives you, but it inherits members from Object.prototype, so a key called toString or constructor appears to exist when it does not. Use a Map for data with arbitrary keys; use an object for a fixed known shape.

Writing a function's name without parentheses gives you the function; adding them calls it. So a table of behaviours is just an object, and passing a function to map needs nothing around it. { twice, triple } is shorthand for { twice: twice, triple: triple }. The arrow form, (value) => value * 3, is what you write for callbacks; the function form is hoisted, so it may be called from a line above its definition.

The inner function captures total, and that captured variable lives as long as the function does. Nothing outside can reach it: this is genuine privacy, achieved with no Private keyword and no class. Each call to makeCounter creates a fresh total, which is why other() starts again at 1. Closures are how callbacks remember their context, how module state was done before modules existed, and the mechanism behind most JavaScript patterns that look surprising at first.

Optional x As String = "Hello" becomes greeting = "Hello", and ParamArray becomes ...values. What has no counterpart at all is arity checking: calling greet() with no arguments is legal, and name is undefined, so the result is "Hello, undefined". Passing too many is legal too. Named arguments do not exist either; the idiom is a single options object destructured in the parameter list.

Sub New becomes constructor, Inherits becomes extends, MyBase becomes super, and Me becomes this — required for every member access. Overridable and Overrides have no equivalent: every method can be overridden and redefining it is all it takes. A field starting with # is genuinely private, enforced at runtime. Engineer needs no constructor — omitting it inherits the parent's.

JavaScript has no classes underneath. An object has a hidden link to another object — its prototype — and a property not found on the object is looked up there, and so on up the chain. class is syntax for building that chain. That is why adding to Greeter.prototype gives every existing instance a new method, which no .NET type can do. You will rarely write prototypes directly, but understanding them explains inheritance, this, and why old JavaScript looks the way it does.

this is set by how the function was called, not where it was written. counter.increment() sets it; pulling the method into a variable and calling that does not. AddressOf in Visual Basic binds the instance at the moment the delegate is created, so this cannot happen there. Three fixes: .bind(counter), wrapping in an arrow (() => counter.increment()), or declaring the member as an arrow property, which captures this once. Arrow functions have no this of their own — that is precisely why they are the default for callbacks.

JavaScript runs on one thread with an event loop. Nothing you write interleaves with anything else — a function runs to completion before the next queued work starts, so there are no locks, no race conditions between two lines of your own code, and no Thread to start. In exchange, a long synchronous loop freezes everything, including the whole browser tab. setTimeout(..., 0) does not run immediately; it queues work for after the current stack empties, and promise callbacks (microtasks) jump ahead of it.

Task(Of String) becomes Promise, and ContinueWith becomes .then(). A promise is always already running: creating one starts the work, so there is no cold task and no Start(). There is no cancellation token either — AbortController is the nearest thing and only works where the callee supports it. Because there is one thread, a promise is not a thread handle; it is a subscription to something the event loop will deliver.

Async Function ... As Task(Of T) becomes async function, Await becomes await, Task.WhenAll becomes Promise.all, Task.WhenAny becomes Promise.race. await is only allowed inside an async function or at the top level of an ES module — so a plain script wraps it in an immediately-invoked async function, as above. There is no ConfigureAwait and no deadlock from blocking on a task, because there is nothing to block: the thread returns to the event loop.

JSON is JavaScript object notation, so JSON.stringify and JSON.parse need no configuration and no target type. The third argument to stringify is the indent. Two things to watch: parse gives you a plain object with no class, no methods and no validation — you asserted nothing, so check what arrived; and a JSON number larger than 2⁵³ is silently rounded on the way in, which is why ids should travel as strings.

Date months are zero-based — January is 0, August is 7 — while days of the month are one-based. DateTime has none of that. There is no formatting vocabulary: ToString("yyyy-MM-dd") becomes toISOString().slice(0, 10) or Intl.DateTimeFormat. AddDays has no counterpart, so you read, add and set. Most real codebases reach for a library, and a standard replacement called Temporal is on its way; check whether it has landed before building on Date.

There is no designer and no control class. A page is a tree of elements — the DOM — and JavaScript creates, finds and changes nodes in it. Label1.Text becomes element.textContent, Button1.Enabled = False becomes button.disabled = true, and querySelector finds elements with the same selectors CSS uses. Layout is CSS, not anchors and docking. Learning HTML and CSS is most of the real work of this move, and it is worth budgeting for honestly.

Public Event Finished has no declaration equivalent — an event is identified by a string name, which means a typo in addEventListener("finihsed", ...) silently subscribes to nothing. AddHandler becomes addEventListener, RemoveHandler becomes removeEventListener, and RaiseEvent becomes dispatchEvent. Extra data travels in event.detail rather than in a custom EventArgs subclass. In the browser every element is an EventTarget, so a click handler is the same mechanism.

fetch is built into browsers and Node — nothing to construct, nothing to dispose. The trap: a 404 or a 500 does not reject the promise. fetch only rejects on a network failure, so await fetch(...) succeeds for an error response and you must check response.ok yourself. The body arrives separately and asynchronously — await response.json() or .text() — because the headers land before the body does.

Anything exported is visible elsewhere; everything else is private to the file. There is no namespace declaration and no project-level import. The complication with no .NET parallel is that two module systems coexist: ESM (import/export, the standard, what browsers use) and CommonJS (require, Node's original). Which one a file gets is decided by its extension and by "type" in package.json, and interop between them is the most tedious part of Node work.

package.json is the .vbproj, npm is nuget.org, npm install is dotnet restore, and package-lock.json pins exact versions. package.json also holds scripts, which is where build, test and start commands live — there is no MSBuild. The difference in scale: npm packages are small and numerous, dependencies nest, and a modest project routinely pulls in hundreds. That is normal, and it is also why npm audit and lockfile review matter more here than they do with NuGet.

There is one catch and it takes no type, so several typed Catch clauses become a chain of instanceof tests. There is no exception filter, so When becomes an if plus a rethrow. And anything at all may be thrown — a string, a number, an object — so a defensive handler checks error instanceof Error before reading .message. The catch binding may be omitted entirely (catch { }) when you do not need it.

Inherits Exception becomes extends Error, MyBase.New(message) becomes super(message). The line with no .NET counterpart is this.name = "...": without it the error prints as a plain Error in every log and stack trace, because name is an ordinary property rather than something derived from the class. Convention ends the class name in Error, not Exception.

Number("oops") is NaN — a number that is not a number — and every arithmetic operation involving it produces NaN, silently, all the way to whatever the user finally sees. There is no exception and no TryParse. Worse, NaN !== NaN, so the only test is Number.isNaN(x). Check at the point of conversion, every time; that is the discipline replacing Option Strict On, and nothing in the language will remind you.

sort() with no comparator converts every element to a string and sorts lexicographically, so 9 lands after 100. Always pass one: (a, b) => a - b for numbers, (a, b) => a.localeCompare(b) for text. The second problem is that it sorts in place and returns the same array, unlike LINQ's OrderBy — which is why the copies above use [...numbers]. toSorted() is the newer non-mutating version.

=== on objects and arrays compares identity, never contents. There is no Structure, no record, and no Equals to override that === would consult. Comparing by value means writing it out field by field, using a library's deep-equal, or comparing a canonical string — and the JSON.stringify trick works only when key order matches and the values are JSON-safe, so treat it as a debugging aid rather than a technique.

const prevents rebinding, not mutation: original = [] is an error, original.push(4) is not. Assignment shares the object, so aliased is the same array under another name; copying is [...original] or original.slice(), both shallow. Object.freeze makes an object genuinely immutable, but only one level deep and — in non-strict code — it fails silently rather than throwing, as the last line shows.

IsNumeric becomes Number() plus Number.isNaN; Now becomes new Date(). My.Computer and My.Computer.FileSystem exist only in Node (node:os, node:fs) and simply are not there in a browser, where document and window are instead. Code meant for both must avoid assuming either. MsgBox and InputBox have no real counterpart — the browser's alert and prompt exist but block the whole page and no production application uses them.