TypeScript Beginner: Using TypeScript

Name: TypeScript Beginner: Using TypeScript
Author: Mark Nair

Enhance your web development with TypeScript's strong typing, type inference, and powerful features

Preview the first lesson free — get full access to all 10 lessons.

Course: On-Demand

Hi, in these lessons, you'll learn about TypeScript variables and data types, Strings, Bullions, Numbers, the type we call any type inference, objects, and functions. Now, a variable is just a container for your data, and the information you hold in these containers can change depending on your needs. I'll make this screen a little bigger so we can see it. There are two ways we can set up a variable in TypeScript. We can use the var key like this. So here I've said var variable named current city is of type string, and it holds a value of the string, Austin. But the keyword var right here might cause some tricks if we're not ready for them. One in particular is that you can access var declarations anywhere within your function that contains them or module or namespace. People call this var scoping. Because of this, you're able to declare the same variable multiple times, and this might end up being quite confusing, especially if you don't know what you're looking for. For now, let's avoid that trickiness altogether and declare variables with the let keyword instead. Now let might cause you a little bit of heartache if you're used to using let in other languages like Swift, for example, and Swift let denotes a constant and var denotes a variable. In this case, though, we're not going to worry about it too much. We'll just say we'll use let for variables. Now one other note about the variable idea, we're talking about information that changes over time. That's why it is a variable. If you have information you don't want to change, we'll use the constant that I just mentioned. And the reason we use a constant or we have the preference of using a constant, if you know you're not going to change the information, is really out of memory allocation and consistency and speed in your code. Now to make a constant, we'll use the keyword constant. Now the variable here, we're saying current city will not change. If we try to change that current city, we can't do it and you'll see that the squiggly line here under current city tells us there's an error and if we do a rollover, I'll have can't assign current city because it is a constant and that makes perfect sense. We can't add a new value to it if we've already said that value will not change over time. Let's try that again just to double check. So here I have a constant of favorite pasta, which is of type string and that is equal to penny. If I try to change it, favorite pasta is not a klazidi, we can't do it. And over here in the error log, now this happens in the TypeScript playground, which is pretty handy. It just shows us this altogether in different IDEs, you'll have different errors pop up in different ways. But for here, we'll just use what we have in the playground to help us out. Error can't assign favorite pasta because it is a constant. Now TypeScript will also give us an error if I tried to change penny into a different type. I don't mean it will give an error because a penny doesn't have a preference on the pasta, but the value that I put into favorite pasta, let me try this out by saying get rid of this line here and I'll just say, yes, my favorite pasta is string pasta of type string, but it is true. I'll just say it's a Boolean value here. But we can't do it because here our error type Boolean is not assignable to type string. All that means is that we've said favorite pasta is of type string, but what I'm giving it is a Boolean value. Now, if I for some reason want this to be, say true as a string, I could do that. But just keep in mind that true or false are special keywords that we use for Boolean. Remember TypeScript is all about type safety. And even though the compiled JavaScript works perfectly fine with the errors, let me show you this. Even though this is an error here, if I come over here to my JavaScript, it works perfectly fine right here. Even though it does that in JavaScript, that is not what TypeScript is about. Thanks for watching. Stay tuned for the next lesson where I'll show you how to use strings in TypeScript.

Beginner Provider : Mark Nair 10 Lessons · 43m in Arabic, German, English, Spanish, French, Portuguese, Chinese

Course Description

In these lessons, we’ll look at the benefits of TypeScript, including strong typing and type inference, operators, objects, and functions. One of the primary advantages of TypeScript is its strong typing, which ensures better tooling and error catching. When working with TypeScript, developers must declare the types of their variables and data, which can include strings, Booleans, and numbers. The "any" type can also be used for cases where the type of the data is unknown or varies.

Type inference is another feature that helps to speed up development by automatically determining the type of a variable based on its value. This reduces the amount of code that needs to be written and ensures that the code is correctly typed.

Operators, including assignment and logical operators, can also be used in TypeScript, allowing developers to perform operations on their data. Objects are also a critical aspect of TypeScript, allowing developers to create complex data structures and classes.

Functions in TypeScript can be declared with types for their parameters and return values, ensuring that inputs and outputs are correctly typed. This feature helps to prevent errors and improve the maintainability of code.

Overall, TypeScript is a powerful language that enhances the efficiency and reliability of web development. Its support for strong typing, type inference, operators, objects, and functions make it a versatile language suitable for a wide range of applications.

What You'll Learn

Use TypeScript's strong typing and type inference features to catch errors and improve tooling
Declare and work with variables using types such as strings, Booleans, and numbers, plus the "any" type for unknown or varying data
Apply TypeScript operators, including assignment and logical operators, to perform operations on data
Create complex data structures and classes using objects
Declare functions with typed parameters and return values to ensure inputs and outputs are correctly typed

Key Takeaways

TypeScript's strong typing requires developers to declare the types of their variables and data, ensuring better tooling and error catching.
Type inference automatically determines a variable's type based on its value, reducing the amount of code written and ensuring correct typing.
The "any" type can be used for cases where the type of the data is unknown or varies.
Typing function parameters and return values helps prevent errors and improves the maintainability of code.
TypeScript's support for strong typing, type inference, operators, objects, and functions makes it a versatile language suitable for a wide range of applications.

Frequently Asked Questions

Who is this course for?

It is a TypeScript beginner course for developers who want to learn how to use TypeScript's strong typing, type inference, operators, objects, and functions in web development.

What topics does this course cover?

The lessons cover variables and data types, strings, Booleans, numbers, the "any" type, type inference, assignment operators, logical operations, objects, and functions.

What skills will I gain?

You will gain knowledge of typing, JavaScript, object-oriented JavaScript, and TypeScript, including how to declare and work with variables and how to use operators, objects, and functions.

How does type inference help when writing TypeScript?

Type inference speeds up development by automatically determining the type of a variable based on its value, which reduces the amount of code that needs to be written and ensures the code is correctly typed.

Why use typed functions in TypeScript?

Functions can be declared with types for their parameters and return values, ensuring inputs and outputs are correctly typed, which helps prevent errors and improve the maintainability of code.