
The smallest complete JavaScript program prints a message to the console - proving the runtime is wired up and your code runs.

<ExamplePair>
  <ExampleProse>

  `console.log` prints its argument to stdout. Every JavaScript runtime - Node.js, browser devtools, Deno, and Bun - honors it.

  </ExampleProse>

  <ExampleCode>

  ```js
  console.log("Hello, World!");
  ```

  </ExampleCode>

</ExamplePair>


<ExamplePair>
  <ExampleProse>

Running this prints:

  </ExampleProse>

  <ExampleCode>

  ```shell
  Hello, World!
  ```
  </ExampleCode>

</ExamplePair>



<InProduction>
`console.log` is fine for scripts and CLI tools. In services, replace it with a structured logger like [pino](https://getpino.io) or [winston](https://github.com/winstonjs/winston) that writes JSON - plain text logs are difficult to query in Datadog or Grafana Loki, and `console.log` bypasses log levels and request-ID serialization entirely.
</InProduction>


The simplest JavaScript program - print a message to the console.

Hello, World


JavaScript has eight value types: seven primitives (`string`, `number`, `bigint`, `boolean`, `undefined`, `symbol`, and `null`) and `object`. The `typeof` operator reveals a value's type - with one infamous exception.

<ExamplePair>
<ExampleProse>

Numbers, strings, and booleans are the most common primitives. `typeof` returns their type as a lowercase string.

</ExampleProse>
<ExampleCode>

```js
typeof 42;         // "number"
typeof "hello";    // "string"
typeof true;       // "boolean"
typeof undefined;  // "undefined"
typeof Symbol();   // "symbol"
typeof 9007199254740993n; // "bigint"
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`null` is technically a primitive, but `typeof null` returns `"object"` - a legacy bug in the language that [can never be fixed without breaking existing code](https://www.wirfs-brock.com/allen/jshopl.pdf). Check for null explicitly.

</ExampleProse>
<ExampleCode>

```js
typeof null;        // "object" - legacy quirk, not a real object
null === null;      // true  - use this instead
null !== undefined; // true  - null and undefined are distinct
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Always use strict equality (`===`) for comparisons. The loose equality operator (`==`) coerces types before comparing, producing results that are rarely what you want.

</ExampleProse>
<ExampleCode>

```js
0 == false;         // true  (type coercion)
0 === false;        // false (strict - different types)

"" == false;        // true  (coercion)
"" === false;       // false

null == undefined;  // true  (special case)
null === undefined; // false
```

</ExampleCode>
</ExamplePair>

<InProduction>
The `typeof null === "object"` quirk bites null checks written as `if (typeof x === "object")` - that check passes for `null`. Always combine it with an explicit `x !== null` guard, or just check `x === null` directly. Prefer strict equality (`===`) everywhere; the loose `==` operator has over a dozen coercion rules that produce surprises in feature-flag defaults, counter comparisons, and conditional rendering.
</InProduction>


JavaScript has seven primitive types plus the object type - and one infamous typeof quirk.