function foo(x: unknown) {
  // ... codice misterioso ...
}

const mioValore: any = {};
//
// TYPE CHECKING
// -------------
// mioValore è equivalente a
// ciò che foo si aspetta di ricevere?
foo(mioValore);

// il valore contenuto in y è equivalente a ciò che x permette?
x = y;

function bar(): string[] {
  if (Math.random() > 0.5) return [];
  // TYPE CHECKING
  // -------------
  // ["a"] è equivalente a
  // ciò che bar dichiara di restituire?
  return ["a"];
}

public class Auto {
  String marca;
  String modello;
  int anno;
}

public class ControlloreAuto {
  // accetta un argomento di tipo Auto, restituisce una String
  public static String controllaAuto(Auto auto) {  }
}

Auto miaAuto = new Auto();
// TYPE CHECKING
// -------------
// miaAuto è equivalente a
// ciò che controllaAuto si aspetta come argomento?
ControlloreAuto.controllaAuto(miaAuto);

class class AutoAuto {
  Auto.marca: stringmarca: string = "";
  Auto.modello: stringmodello: string = "";
  Auto.anno: numberanno: number = 0;
  Auto.isElettrica: booleanisElettrica: boolean = false;
}

class class CamionCamion {
  Camion.marca: stringmarca: string = "";
  Camion.modello: stringmodello: string = "";
  Camion.anno: numberanno: number = 0;
  Camion.capacitaTraino: numbercapacitaTraino: number = 0;
}

const 
const veicolo: {
    marca: string;
    modello: string;
    anno: number;
}veicolo = {
  marca: stringmarca: "Honda",
  modello: stringmodello: "Accord",
  anno: numberanno: 2017,
};

function 
function stampaAuto(auto: {
    marca: string;
    modello: string;
    anno: number;
}): voidstampaAuto(
auto: {
    marca: string;
    modello: string;
    anno: number;
}auto: {
  marca: stringmarca: string;
  modello: stringmodello: string;
  anno: numberanno: number;
}) {
  var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v22.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log(`${
auto: {
    marca: string;
    modello: string;
    anno: number;
}auto.marca: stringmarca} ${
auto: {
    marca: string;
    modello: string;
    anno: number;
}auto.modello: stringmodello} (${
auto: {
    marca: string;
    modello: string;
    anno: number;
}auto.anno: numberanno})`);
}

// Nessuno di questi tre è un errore, nonostante Auto, Camion e "veicolo"
// non abbiano nulla in comune se non la forma richiesta da stampaAuto.
function stampaAuto(auto: {
    marca: string;
    modello: string;
    anno: number;
}): voidstampaAuto(new constructor Auto(): AutoAuto());
function stampaAuto(auto: {
    marca: string;
    modello: string;
    anno: number;
}): voidstampaAuto(new constructor Camion(): CamionCamion());
function stampaAuto(auto: {
    marca: string;
    modello: string;
    anno: number;
}): voidstampaAuto(
const veicolo: {
    marca: string;
    modello: string;
    anno: number;
}veicolo);

{ tutti i valori che contengono una...
      proprietà marca    che è una string
  e una proprietà modello che è una string
  e una proprietà anno    che è un number
}