Tipos primitivos: string, number, boolean, null, undefined de Typescript

TypeScript programming offers a robust and secure experience for developers looking to avoid common JavaScript errors. This programming language, which extends JavaScript with static typing, allows you to create more maintainable and scalable applications. Let's explore the basics to get started programming with TypeScript.

How to create your first "Hello world" program in TypeScript?

To start programming in TypeScript, the first thing we need to do is to create our classic "Hello World". This exercise will allow us to understand the basic process of compiling and executing TypeScript code.

First, we create a new file with extension .ts:

console.log("Hello world");

Once we have written our code, we need to compile it to convert it to JavaScript, since TypeScript does not run directly in browsers or in Node.js:

1. Open the terminal
2. Navigate to the folder where your file is
3. Run the tsc command followed by the name of your file:

tsc main.ts

This command will generate an equivalent JavaScript file(main.js). To run it, we simply use Node.js:

node main.js

And we will see in the terminal our "Hello world" message. This compilation process is fundamental in TypeScript, as it transforms our code with types to pure JavaScript that can be interpreted by any environment.

What are typed variables in TypeScript?

The main feature of TypeScript is the type system. Unlike JavaScript, where variables can change type during execution, TypeScript allows us to explicitly define what type of data each variable will contain.

Let's look at some basic examples:

// String variablelet name: string = "min";
// Number variablelet age: number = 39;
// Boolean variablelet developer: boolean = true;
// Variable that can be undefined or stringlet month: undefined | string;
console.log(`Hello ${name}`);console.log(month); // Result: undefined
month = "january";console.log("updated month:", month); // Result: january

In the above example, we can see how we declare variables with different types:

• name can only contain text
• age can only contain numbers
• developer can only be true or false
• month can be a text string or be undefined

How to work with strings in TypeScript?

TypeScript offers different ways to work with text strings, similar to JavaScript. We can concatenate variables using the + operator or use template literals (string templates) with backticks (``).

let name: string = "min";
// Option 1: Traditional concatenationconsole.log("Hello " + name);
// Option 2: Template literals (recommended)console.log(`Hello ${name}`);

Both options produce the same result, but template literals are more readable when we work with long strings or need to insert multiple variables.

How do data types work in TypeScript?

TypeScript includes several basic data types that help us to clearly define the structure of our code:

• string: For text
• number: For numbers (integers and decimals)
• boolean: For true/false values
• undefined: For variables with no assigned value
• null: For explicit null values

We can also create union types by combining several types with the | operator:

// This variable can be undefined or stringlet month: undefined | string;
console.log("initial month", month); // undefined
month = "January";console.log("updated month", month); // January.

In this example, month can contain text or be undefined. This is useful when a variable can have different types of values depending on the context.

How to experiment with TypeScript?

The best way to learn TypeScript is to experiment with different types of variables and observe how they behave. We recommend:

1. Create variables with different types
2. Try assigning incorrect values to see compilation errors.
3. Using console.log() to visualize the values
4. Compiling and executing the code to see the results

The TypeScript development process always includes these steps: write typed code, compile to JavaScript and execute the result. This cycle will help you become familiar with the language and its features.

Constant practice with these basic concepts will give you a solid foundation to move on to more complex TypeScript features. We encourage you to experiment with the examples shown and create your own variations to consolidate your learning. What other data types would you like to explore in TypeScript? Share your experiences in the comments!