Visual Basic.CodeCompared.To/TypeScript

There is no module, no entry point and no imports. A TypeScript file runs its statements top to bottom, like a script. console.log is the counterpart of Console.WriteLine, and it is available everywhere without importing anything. The name is a reminder of where the language came from: this is the browser's developer console, and the same function is what Node.js prints with.

A template literal is delimited by backticks rather than quotes, and each hole is ${...} rather than {...}. Any expression may go inside. There are no format specifiers: {score:D5} has no template-literal equivalent, and formatting is done with methods instead — score.toString().padStart(5, "0"), ratio.toFixed(2), or Intl.NumberFormat for anything locale-aware.

Passing several arguments prints them separated by spaces. Passing an object or array prints its structure — [ 1, 2, 3 ] — which is far more useful for debugging than .NET's default System.Collections.Generic.List`1. There is no Console.Write; writing without a newline means process.stdout.write in Node. console.error writes to standard error, matching Console.Error.

The shape is the C family's: parentheses around the condition, braces around the block, no Then, and else if as two words. Formatting convention puts the opening brace on the same line — this is not arbitrary in JavaScript, and the gotchas section explains why putting it on the next line can silently change what a return does.

Because the semicolon is the terminator, an expression can be broken across as many lines as you like with nothing to mark it. The complication is automatic semicolon insertion: the parser will supply a missing semicolon at a line break, which makes semicolons look optional and mostly lets you omit them. Mostly. A line starting with ( or [ is joined to the previous one instead, which is why many style guides — and the default formatter — put them in. Write them.

' becomes //, and TypeScript gains a real block comment, /* ... */. The documentation form is JSDoc, /** ... */, and it plays the role '''<summary> plays: editors show it on hover and documentation generators read it. Its tags are @param, @returns, @deprecated — the same ideas as the XML tags, written without angle brackets.

Identifiers are case-sensitive, so customerName and CustomerName are two names. The conventions differ from .NET's in one important way: methods and properties are camelCase, not PascalCase. PascalCase is reserved for classes, interfaces and type names. So person.Describe() becomes person.describe(), and getting this wrong is the fastest way to make TypeScript code look like it was written by someone visiting from another platform.

let declares a variable you intend to reassign; const declares one you do not, and the compiler enforces it. TypeScript convention is const by default and let only where you must — the opposite emphasis from Dim, which has no such distinction. Note that const prevents rebinding, not mutation: a const array can still have items pushed into it. There is a third keyword, var, with older and stranger scoping rules; do not use it.

value As Integer becomes value: number and a function's return type goes after the parameter list, ): number. TypeScript infers aggressively, so annotating a variable initialized on the same line is redundant and unidiomatic; annotate function parameters and return types, and let everything else infer. Unlike Python's hints, these are checked: the compiler rejects the program if they do not hold. Unlike .NET's, they vanish at runtime, which the gotchas section returns to.

number is a 64-bit float and there is nothing else — no Integer, no Long, and no Decimal. Integers are exact only up to 2⁵³, which is why big prints a different value than it was given. 0.1 + 0.2 misbehaves exactly as Double does, and there is no decimal type to switch to — so money must not be stored in a number. The two answers are bigint (the n suffix, integers only, no mixing with number) or storing whole cents. Integer division has no operator: Math.trunc(a / b), or Math.floor if you want Python's rounding.

null means "deliberately empty" and undefined means "never given a value" — a variable declared and not initialized, a missing object property, a function with no return. Both exist and both are falsy. With strictNullChecks on (the default, and non-negotiable) neither can be assigned to a string: you must widen the type to string | null, which is TypeScript's equivalent of Integer? and covers reference types too. The practical convention is to pick undefined for your own code and let null arrive from JSON and older libraries.

CInt/CDbl become Number(), CStr becomes String(), CBool becomes Boolean(). There is no TryParse: a failed conversion produces NaN, a number that is not a number, and it propagates silently through arithmetic — so test with Number.isNaN() at the point of conversion. Two traps: Number("") is 0, not NaN; and parseInt("12x") returns 12, stopping at the first bad character, which is almost never what you want.

Falsy values are false, 0, NaN, "", null and undefined — and that is the whole list. An empty array is truthy. An empty object is truthy. So if (items) is always true for an array and tells you nothing; the emptiness test is items.length === 0. This is the opposite of Python, where an empty collection is falsy, and it is the most common bug when moving between the two.

=== compares value and type and is the one to use, always. == converts its operands first, using rules nobody remembers, which is how 0 == "" and [] == false come out true. Inequality is !== and !=, the same split. TypeScript protects you where it can — comparing a number to a string with == is a compile error, which is why the examples above have to launder the types through unknown — but any value typed any slips past. Configure your linter to ban == outright, with the one exception x == null, which usefully catches both null and undefined.

AndAlso becomes &&, OrElse becomes ||, Not becomes !. The twist is that they do not return booleans: || returns its first truthy operand and && its last, which is why 0 || "fallback" is the string. That makes || a fallback operator, and a buggy one — it replaces 0 and "" as well as null. Use ?? instead when only null and undefined should trigger the fallback. Plain And and Or have no equivalent; & and | are bitwise and, worse, truncate to 32 bits.

/ is always floating-point, as in Visual Basic — there is no integer division operator, so \ becomes Math.trunc(a / b). Mod becomes %, and like Visual Basic (and unlike Python) it takes the sign of the left operand. ^ becomes **; writing ^ gives you bitwise exclusive-or, so 7 ^ 2 silently evaluates to 5. TypeScript also has ++ and --, which Visual Basic never had.

Two-argument If(value, fallback) becomes ??, which falls back only on null and undefined — unlike ||, it leaves 0 and "" alone. Three-argument If(condition, a, b) becomes condition ? a : b. The new one is optional chaining, ?.: if the thing to its left is null or undefined the whole expression short-circuits to undefined instead of throwing, which replaces the nested null checks that dominate this kind of code in .NET. It works on calls and indexes too — list?.[0], callback?.().

+ means both addition and concatenation, resolved left to right by the types it meets. 1 + 2 + " items" adds first and gives "3 items"; "items: " + 1 + 2 concatenates first and gives "items: 12". This is precisely the ambiguity & exists to avoid, and it is why a template literal is the better habit for anything with more than two parts. TypeScript will not let you add a number to an object, but string-plus-number is legal and does what you see.

Trim→trim, ToUpper→toUpperCase, Contains→includes, StartsWith→startsWith. Length becomes length — a property, no parentheses, unlike Python's len(). The trap is replace: given a string it replaces only the first occurrence, unlike .NET's Replace. replaceAll is what you actually want, and it is what the anchor column's Replace means.

slice(start, end) takes an end index where Substring(start, length) takes a length — so Substring(0, 6) and slice(0, 6) agree here by coincidence, and stop agreeing the moment the start is not zero. Negative numbers count from the end, so slice(-5) is Right(text, 5). There is an older substring method with subtly different behavior for negative arguments; prefer slice. Indexing uses square brackets and yields a one-character string — there is no character type.

Single and double quotes mean the same thing, so the easy way to include a quote is to wrap in the other kind. The backslash escapes, as in C#, so a Windows path needs each one doubled — and there is no verbatim-string prefix: TypeScript has no @"..." and no r"...". A template literal preserves newlines, which is what replaces the & Environment.NewLine & chain, and it interpolates too.

Split becomes split and takes a string (or a regular expression). String.Join(separator, parts) becomes parts.join(separator) — the array does the joining, which is the reverse of .NET and the same shape Python uses, only with the roles the other way round again. Note that join with no argument uses a comma, not an empty string.

List(Of String) becomes string[] (or Array<string> — the same type, two spellings). It grows and shrinks freely, so there is no fixed-size array to choose. Add becomes push, Insert(0, x) becomes unshift, RemoveAt becomes splice(index, 1), and Count becomes length. Note that const does not prevent any of these: it forbids reassigning fruits, not changing what is in it.

Where→filter, Select→map, Any→some, All→every, FirstOrDefault→find, Count→length, Contains→includes, Aggregate→reduce. There is no Sum, Min or Max on arrays: sum is a reduce, and min and max are Math.min(...numbers). The behavioral difference is laziness — LINQ builds a query and runs it when enumerated, while every array method here builds a whole new array immediately, so a long chain over a large array allocates at each step.

An object literal is { key: value }, and its type is inferred as { name: string; age: number }. This is the workhorse of TypeScript: most data is passed around as object literals rather than class instances, and a class is reserved for something with behavior. Members are reached with a dot or with brackets, and Object.keys, Object.values and Object.entries let you walk them — an object doubles as a string-keyed dictionary, which the next row builds on.

Map is the real Dictionary(Of K, V): any key type, insertion order preserved, set/get/has/delete, and a size property. Record<string, number> is a plain object used as a lookup — convenient, and what JSON gives you, but its keys can only be strings, and it inherits members from Object.prototype, so a key called "constructor" or "toString" will surprise you. ContainsKey→has, TryGetValue→get plus ??. Iterating a Map yields [key, value] pairs, destructured in the loop header.

Destructuring pulls parts out of an array or object into named variables in one statement — const [low, high] = ... for arrays by position, const { name } = ... for objects by key. Spread, ..., does the reverse: it expands an array into arguments (Math.min(...values)) or copies elements and properties into a new array or object. ...rest on the left collects whatever was not named. The return type [number, number] is a tuple type, TypeScript's fixed-length array; unlike Visual Basic's tuples, the elements can also be named for readability — [low: number, high: number].

Each branch needs an explicit break, and unlike C#, TypeScript does not make you write one — omitting it falls through into the next branch and runs it too. That is occasionally useful and far more often a bug, so turn on the compiler's noFallthroughCasesInSwitch option and let it catch them. Stacking bare case labels, as with 2 and 3 above, is the deliberate kind of fall-through and is always allowed. There is no Case Is > and no Case 4 To 6; ranges become an if chain or switch (true).

TypeOf value Is Integer becomes typeof value === "number", and inside that branch the compiler narrows value from number | string to number — so value * 2 type-checks with no cast, and in the else branch value.length does too. This is control-flow analysis, and it is TypeScript's best feature: if (x === null) return; narrows away the null for the rest of the function. For class instances the test is instanceof; typeof only knows the primitive kinds.

A union of literal types lists the permitted values, and the compiler knows the switch covers all of them — which is why the function type-checks with no fallback branch and no return after the switch. Add a fourth status and every unhandled switch becomes a compile error. A Visual Basic Enum cannot do this: it is an Integer underneath, any number can be cast into it, and so Case Else is always required.

The clauses are "initializer; condition; step". You state the ending condition rather than an ending value, so the inclusive To 5 becomes <= 5 — the classic off-by-one. Use let, not const, for the loop variable, since it is reassigned each pass. Step -2 becomes the step clause. Note the examples build a string rather than calling Console.Write: there is no partial-line print in a portable form, so accumulating and logging once is the idiom.

For Each x In items becomes for (const x of items). Getting the index too is items.entries(), which yields [index, value] pairs, or the forEach method, whose callback receives both. 🚨 for ... in is not this loop. It iterates an object's keys, and over an array it gives you the indices as strings — "0", "1" — plus anything else attached to the object. Using it on an array is almost always a bug.

While ... End While becomes while (...) { }, and the Do ... Loop family becomes do { } while (...). There is no Until, so Loop Until attempt >= 2 has to be flipped to while (attempt < 2). Note the semicolon after the closing while of a do loop — it is the one place a brace is followed by one.

Exit For becomes break and Continue For becomes continue, both acting on the innermost loop by default. TypeScript adds labels: naming a loop lets break outer or continue outer act on an enclosing one, which is what you need to leave a nested pair in one step. Visual Basic has no equivalent and neither does C#, where the answer is goto or extracting a method. Exit Sub and Exit Function both become return.

Sub becomes function ... : void and Function ... As Integer becomes function ... : number. The return type is usually inferred, so writing it is optional — but writing it on exported functions is good practice, because it makes the compiler check the body against your intent rather than inferring whatever the body happens to produce. Unlike Python, a function declared with function is hoisted: it can be called on a line above its definition.

Function(value) value * 2 becomes (value) => value * 2; a body in braces needs an explicit return. There is no Func(Of ...) or Action(Of ...) to name — a function's type is written as a signature, (value: number) => number, and is usually inferred anyway. Arrow functions are what you pass to map, filter and every callback, and they have one behavioral difference from function that matters enormously: how they treat this, covered in the gotchas.

A default value makes a parameter optional, and Optional disappears; a parameter that may be omitted with no default is marked name?: string and arrives as undefined. What TypeScript has no equivalent for is punctuation:= — to skip a middle argument you must pass undefined positionally. The idiomatic answer is to take a single options object and destructure it in the parameter list, which gives you named arguments, defaults and any order, and is what almost every TypeScript library does.

ParamArray values() As Integer becomes ...values: number[], must be last, and collects the extra arguments into a real array. Passing a ready-made array is sumAll(...[4, 5]) — the spread operator again, this time unpacking rather than collecting. Note reduce's second argument, 0: it is the starting value, and omitting it on an empty array throws.

There is no ByRef, no ref and no out. Assigning to a parameter changes only the local name. But arrays and objects are references, so calling a mutating method on one changes what the caller holds — the same "rebinding versus mutating" rule Python has. The idiomatic answer is to return a new value rather than modify an argument, and TypeScript can help you enforce it: annotate the parameter readonly number[] and the compiler rejects the push.

Nothing declares that formal implements Greeter. It has a greet method with the right signature, so it is a Greeter — this is structural typing, and it is why TypeScript can describe data that already exists, including JSON off the wire, without owning the types. Extra members are fine, as casual shows. A class may still write implements Greeter, and it is worth doing for the error message, but it changes nothing about assignability. Note also that interface names do not take an I prefix in TypeScript convention.

number | string is a union type: a value that is one or the other, with the compiler forcing you to narrow before using either. "pending" | "active" | "closed" is a union of literal types, which does the job of a Visual Basic Enum but is genuinely closed — no cast can smuggle another value in. type X = ... gives a name to any type, not just object shapes. The anchor column shows the nearest Visual Basic equivalent, and the difference in safety is the point: Object accepts everything and checks nothing.

Function Name(Of T)(...) becomes function name<T>(...), and List(Of T) becomes T[] or Array<T>. Type arguments are usually inferred from the call, as the first line shows. Constraints exist too: Where T As IComparable becomes <T extends Comparable>. The deep difference is erasure — a .NET generic is reified, so List(Of Integer) really stores integers and can be inspected at runtime, while a TypeScript generic is gone after compilation and exists only to check your code.

readonly on a property forbids assignment after construction, exactly as ReadOnly does. readonly string[] goes further than .NET: it removes the mutating methods from the type, so push and splice become compile errors. as const takes a literal and makes everything in it readonly and narrows each value to its literal type — so STATUSES has type readonly ["pending", "active"] rather than string[], which is how a list of allowed values and the union type describing them stay in step. All of this is compile-time only; nothing is frozen at runtime.

any switches type checking off for that value — every property access, call and assignment is permitted and nothing is checked, which is how a strongly-typed codebase quietly stops being one. unknown is the honest version: it accepts any value but permits nothing until you narrow it, which is what Object plus Option Strict On effectively gives you. Use unknown for data off the wire, and turn on noImplicitAny so the compiler tells you where any crept in by omission.

Public Sub New becomes constructor, and Me becomes this — which, unlike Me, is required for every field access. The shorthand shown is a TypeScript-only feature called parameter properties: an access modifier on a constructor parameter declares the field and assigns it, replacing the two declarations and two assignments the anchor column needs. New Person(...) becomes new Person(...), lower case.

Property ... Get/Set becomes separate get and set accessors sharing a name; a get with no set is ReadOnly Property. The #celsius field is a true private field, enforced at runtime and invisible from outside. TypeScript's own private keyword is checked only at compile time and is plain and visible in the emitted JavaScript, so # is the stronger choice when the object crosses a boundary. As in C#, the value parameter of the setter is written out explicitly.

Inherits becomes extends, MustInherit and MustOverride both become abstract, and MyBase becomes super. Overridable has no equivalent: every method can be overridden. Overrides becomes override, which is optional unless you turn on noImplicitOverride — and you should, because without it a misspelled method name silently adds a new method rather than replacing one. There is no NotInheritable/sealed for classes.

Shared becomes static, with the same meaning. What has no counterpart is the Module, whose members can be called without naming it. A class of static members works, but the idiomatic TypeScript answer to "a bag of related functions" is not a class at all — it is a module: a file of exported functions, imported by name. That is the next section, and it is the right home for most of what lives in a Module today.

Anything marked export is visible to other files; everything else is private to the file, which replaces both Public/Private at namespace level and the Namespace block itself. Imports Geometry becomes import { rectangle } from "./area.js", naming exactly what you want, or import * as area for the whole module. There are no project-level imports: every file states what it needs. Note the .js extension in the path even though the file is .ts — that is the ESM rule, and it catches everyone once.

Task(Of String) becomes Promise<string> and Task becomes Promise<void>. .then(callback) is what ContinueWith was. The behavioral difference: a Promise is always already running — creating one starts the work, and there is no cold task and no Start(). There is also no cancellation token; the closest equivalent is AbortController, and it must be supported by whatever you are calling.

Async Function ... As Task(Of T) becomes async function ... : Promise<T>, and Await becomes await. Task.WhenAll becomes Promise.all; Task.WhenAny becomes Promise.race. await works at the top level of a module, so no GetAwaiter().GetResult() bridge is needed. The single biggest difference underneath: JavaScript is single-threaded. await yields to the event loop rather than to another thread, so there is no thread pool, no deadlock from blocking on a task, and nothing like ConfigureAwait — but also no parallelism without spawning a worker.

An async function that throws returns a rejected promise, and await is what turns that back into a thrown exception your try can see. Call it without await and the surrounding try catches nothing, exactly as an un-awaited Task swallows its exception in .NET — except that here it becomes an unhandled rejection that can take the process down. Note also the cast in the catch: TypeScript types the caught value as unknown, because JavaScript permits throwing anything at all.

There is one catch block and it takes no type — so several typed Catch clauses become a chain of instanceof tests inside a single handler. There is no exception filter, so When becomes an if and a rethrow. Two further differences: the caught value is typed unknown, because any value may be thrown, not just an Error; and reading an array past its end returns undefined rather than throwing, which is why this example has to reach for JSON.parse to produce an error at all.

Inherits Exception becomes extends Error, Throw New becomes throw new, and 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 logs and stack traces, because name is a normal property rather than something derived from the class. Convention ends the class name in Error, not Exception.

There is no Using and no IDisposable. Deterministic cleanup is written as try { ... } finally { ... }, and the common pattern is to wrap that in a helper that takes a callback, as above — the caller cannot forget the cleanup because the helper owns it. Most Node APIs are async and handle their own cleanup, so this comes up less than you would expect. A newer language feature, using declarations with Symbol.dispose, brings the real construct back, but runtime support is still uneven.

TypeScript is a compile-time-only type system. Every annotation, interface and generic is erased, and what runs is plain JavaScript that checks nothing. So a type assertion (as Person) is a promise to the compiler, not a conversion — nothing verifies it, and bad data walks straight in. There is no reflection, no GetType(), no way to ask an object what interface it satisfies. The consequence for real code is that every value entering your program from outside must be validated at runtime, with hand-written checks or a library such as Zod or Valibot. Trusting as at the boundary is the single most common source of production bugs in TypeScript.

Array.prototype.sort converts every element to a string and sorts lexicographically unless given a comparator — so 9 sorts after 100. Always pass one: (a, b) => a - b for numbers ascending, (a, b) => a.localeCompare(b) for text. The second trap in the same method is that it sorts in place and returns the same array, unlike LINQ's OrderBy — hence the [...numbers] copies above. toSorted() is the newer non-mutating version.

this is decided by how a function is called, not where it was defined. counter.increment() sets it; const loose = counter.increment; loose() does not, and in a class body (which is strict mode) this is then undefined. This bites constantly when passing a method as a callback. Three fixes: .bind(counter), wrapping in an arrow (() => counter.increment()), or declaring the member as an arrow-function property, which captures this once at construction. Arrow functions have no this of their own — that is the whole reason they are preferred for callbacks.

Every number is a binary float, so 0.1 + 0.2 is not 0.3 — and unlike .NET there is no Decimal to switch to. The two workable answers are storing amounts as integer minor units (whole cents) and dividing only for display, or using a library such as decimal.js or dinero.js. toFixed(2) formats but does not fix the arithmetic. Anywhere a Visual Basic codebase uses Decimal, the port needs a deliberate decision rather than a straight translation.

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

My.Computer.Name is os.hostname(), My.Computer.FileSystem is node:fs, IsNumeric is a Number() plus Number.isNaN, Now is new Date(). The deeper adjustment is that TypeScript runs in two different worlds: Node.js on a server, where node:fs and node:os exist, and the browser, where they do not and document does. MsgBox and InputBox have no counterpart in either — a browser has alert and prompt, which real applications never use. A WinForms screen becomes HTML and CSS, which is the actual work of the port and the part no cheatsheet can shorten.