Understanding TypeScript
The course starts by introducing you to TypeScript - what it is and why it’s awesome.
You’ll learn about the advantages it offers over plain JavaScript and how to set it up.
This lays a solid foundation before diving into the core concepts.
From there, you’ll explore TypeScript basics like types for numbers, strings, booleans, and how type inference works.
You’ll work with objects, arrays, tuples, enums, and learn about union and literal types.
The course covers functions, including return types, callbacks, and the “unknown” and “never” types.
It provides a thorough understanding of TypeScript’s type system.
But it doesn’t stop at the basics.
You’ll learn about the TypeScript compiler and its extensive configuration options like setting compilation targets, core libs, source maps, and code quality checks.
This is vital for real-world projects.
The course teaches you modern JavaScript features that TypeScript supports, like let/const, arrow functions, spread operator, and destructuring.
You’ll see how your code gets compiled to leverage these in older browsers.
A major portion covers classes, inheritance, access modifiers, and interfaces - core object-oriented programming (OOP) concepts.
You’ll build a complete drag-and-drop project management app to practice what you’ve learned so far.
Advanced TypeScript features like intersection types, discriminated unions, index properties, and function overloads are covered next.
You’ll dive into generics, an interesting programming concept supported by TypeScript.
The course explores decorators - a meta-programming feature that lets you annotate classes, methods, and properties.
You’ll build useful decorators like autobind and validation decorators.
Working with modules, namespaces, and leveraging Webpack for bundling TypeScript code is also part of the curriculum.
You’ll integrate popular third-party libraries and use TypeScript with React for building front-end apps.
For the back-end, you’ll learn to use TypeScript with Node.js and Express, covering topics like middleware, controllers, and parsing request bodies.
The course even touches on using TypeScript with Google Maps API.
Typescript: The Complete Developer’s Guide
The course provides a comprehensive journey into TypeScript, guiding you from the fundamentals to building robust applications.
It begins by exploring TypeScript’s type system, covering basic types, type annotations, and type inference.
You’ll learn when to leverage type inference for cleaner code and when explicit annotations are necessary.
The course dives into object types, arrays, tuples, and interfaces, enabling you to define complex data structures.
You’ll grasp how interfaces promote code reuse by acting as contracts between classes.
Additionally, you’ll master classes, inheritance, and access modifiers like public, private, and protected.
Moving beyond syntax, the course emphasizes design patterns and best practices.
You’ll build applications from scratch, like a data analytics tool for sorting arrays, strings, and linked lists.
Through hands-on projects, you’ll learn to leverage abstract classes for code reuse and composition over inheritance for flexibility.
The course explores advanced TypeScript features like decorators and metadata, guiding you to enhance Express applications with custom route handlers.
You’ll integrate TypeScript with popular libraries like React and Redux, covering class and functional components, state management, and type-safe action creators.
Throughout the course, you’ll work on practical examples, such as a web framework for managing user data, complete with features like data fetching, rendering, event handling, and server persistence.
You’ll learn to create reusable modules, leverage generics for flexibility, and implement advanced patterns like dependency injection.
The instructor emphasizes best practices, such as separating concerns, adhering to SOLID principles, and writing maintainable code.
You’ll learn to use static methods for simplified instantiation and explore the nuances of inheritance versus composition.
React and Typescript: Build a Portfolio Project
This course covers a wide range of topics, from the fundamentals of TypeScript to advanced concepts like design patterns with Redux and TypeScript.
It starts by introducing you to TypeScript and its integration with React.
You’ll learn how to annotate props, state, events, and refs with TypeScript types.
This lays a solid foundation for working with TypeScript in React applications.
As you progress, you’ll dive into more complex topics like using TypeScript with Redux.
The course guides you through designing Redux stores, defining actions and reducers with TypeScript interfaces, and connecting React components to the Redux store.
Additionally, you’ll learn how to simplify state updates using the Immer library.
One unique aspect of this course is its focus on building a code editor within a React application.
You’ll learn techniques like in-browser code transpiling and bundling, safely executing untrusted code, and integrating a code editor like Monaco.
This hands-on project will give you practical experience with advanced TypeScript concepts.
The course also covers other essential topics, such as data persistence, publishing to NPM, and creating a local API.
You’ll learn how to fetch and save data using Redux, configure and publish your application as an NPM package, and build a local API for development purposes.
Throughout the course, you’ll work on a real-world project, allowing you to apply the concepts you learn in a practical setting.
The instructor provides clear explanations and walks you through each step, ensuring you understand the reasoning behind the code.
While the course covers a lot of ground, the instructor maintains a conversational tone and uses simple language, making it accessible to learners at all levels.
The syllabus is well-structured, with transitions between topics to ensure a smooth learning experience.
Mastering TypeScript - 2024 Edition
You’ll start by learning the fundamentals of TypeScript, including installation, setup, and type annotations.
The course then dives into functions, object types, array types, and union types, ensuring you have a solid understanding of these core concepts.
One of the highlights is the mini project section, where you’ll work with the DOM, type assertions, and events to build a todo list application.
This hands-on experience will solidify your understanding of TypeScript in a practical setting.
The course also covers essential topics like classes, generics, and type narrowing, equipping you with the skills to write more robust and maintainable code.
You’ll even learn how to work with type declarations and modules, making it easier to integrate TypeScript with third-party libraries and manage your codebase.
The syllabus also includes sections on Webpack and React, teaching you how to set up a development environment and use TypeScript with one of the most popular front-end frameworks.
Throughout the course, you’ll have access to a supportive community and comprehensive course materials, including slides and exercises.
Introduction to TypeScript Development
The course begins by explaining what TypeScript is and its benefits over regular JavaScript.
You’ll learn how to install and configure TypeScript on both Mac and Windows systems, including setting up popular text editors like Sublime Text and Visual Studio Code with the necessary plugins.
Once the setup is complete, you’ll dive into the core TypeScript syntax and language features.
This includes working with variables, types (like strings, numbers, booleans), type aliases, and union types.
You’ll also learn about string interpolation, arithmetic operators, conditionals, loops, and functions (including arrow functions).
The course covers important TypeScript concepts like closures, immediately invoked functions, and how to handle the ’this’ keyword.
It then moves on to object-oriented programming principles like classes, inheritance, interfaces, and namespaces.
A major section is dedicated to asynchronous development in TypeScript.
You’ll learn about callbacks, promises, and how to configure TypeScript to work with the ES6 runtime.
This is crucial for building modern web applications.
The syllabus also covers advanced TypeScript features like decorators and optional chaining, which can make your code more scalable and maintainable.
There are lectures on capitalizing strings and using the map function for iteration, which are common tasks in web development.
Towards the end, you’ll build a real-world React application using TypeScript.
This includes generating a new React project pre-configured with TypeScript, creating React components with interfaces, rendering lists of data, and implementing inline styles.
TypeScript for Professionals - by Basarat
You’ll start with the fundamentals, learning about primitive types, arrays, tuples, object types, functions, and classes.
The course then dives into intermediate topics like union types, literal types, type narrowing, discriminated unions, and interfaces.
As you progress, you’ll tackle advanced concepts such as function overloading, abstract classes, index signatures, and generic constraints.
The expert section is where things get really interesting.
You’ll explore powerful TypeScript features like the typeof type operator, lookup types, keyof type operator, conditional types, mapped types, and template literal types.
The course also covers essential utilities like Partial, Required, Readonly, and Record.
One of the standout aspects of this course is its coverage of TypeScript’s advanced type manipulation capabilities.
You’ll learn how to use the infer keyword, ReturnType, and mapped type modifiers to create complex and expressive types.
Additionally, the course delves into string manipulation utilities and using mapped types as clauses.
Throughout the syllabus, you’ll find lectures on practical topics like creating a frontend project, generating an NPM package, using ts-node, and dealing with temporal uncertainty.
The course also addresses important concepts like the strict compiler option, null versus undefined, and the non-null assertion operator.
What sets this course apart is its focus on helping you develop a deep understanding of TypeScript’s mental models.
You’ll learn how to think about unions versus intersections and why TypeScript enums are considered bad practice.
Using TypeScript with React
You’ll start by understanding TypeScript’s fundamentals, including types, interfaces, classes, and advanced features like generics, union types, and type aliases.
Once you’ve grasped the basics, you’ll dive into integrating TypeScript with React projects.
The course guides you through setting up a webpack-based development environment, configuring TypeScript loaders, and adding React components.
You’ll learn to create function and class components, handle events, use React hooks like useState and useReducer, and even build higher-order components and render props components.
The course also covers building a full-fledged React Redux application using TypeScript.
You’ll set up a fake server, configure Redux, create components to load, create, delete, and edit events, all while maintaining type safety.
Additionally, you’ll build a Tasks app using Next.js, a popular React framework for server-side rendering.
You’ll set up a GraphQL API route, connect to a local MySQL server, create resolvers for queries and mutations, and integrate Apollo Client on the front-end.
The app will allow you to create, update, delete, and filter tasks based on their status.
Throughout the course, you’ll gain hands-on experience using TypeScript with external packages, handling DOM events, creating custom hooks, and working with advanced TypeScript features like declaration merging, utility types, and mapped types.
The course provides cheatsheets for using TypeScript with React and Next.js, serving as handy references for your future projects.
TYPESCRIPT FOR BEGINNERS
The course begins with an overview of TypeScript, its benefits, and how to set up your development environment using Visual Studio Code.
You’ll learn about variables, data types like strings, booleans, and arrays, as well as how to use operators and control flow statements like if-else and while loops.
Moving on, you’ll delve into objects and arrays, including object literals, for-in loops, array functions, and destructuring.
The syllabus covers functions in-depth, teaching you about parameters, optional and default values, anonymous functions, and function overloading.
You’ll also learn about arrow functions, a concise syntax for writing functions, and how to use variable prefixes like let, const, and declare.
Interfaces, a crucial concept in TypeScript, are covered extensively, including object interfaces, function interfaces, extending interfaces, and array interfaces.
The course introduces classes, constructors, inheritance, access modifiers like public and private, encapsulation, and static properties and methods.
You’ll explore polymorphism, a powerful concept that allows objects to take on many forms.
Additionally, you’ll learn about type casting, modules (including function, class, and default exports), and advanced types like Map, Set, and regular expressions.
The syllabus even touches on decorators, a way to annotate or modify classes and class members at design time.
Throughout the course, you’ll have opportunities to practice with quizzes and coding exercises, solidifying your understanding of each concept.
Unit Testing for Typescript & NodeJs Developers with Jest
You’ll start by understanding the importance of testing and setting up the necessary tools like Jest and Visual Studio Code.
The course then dives into the basics of Jest, covering topics like assertions, matchers, test structure, and parametrized tests.
As you progress, you’ll explore intermediate concepts such as the F.I.R.S.T.
principles, Jest hooks, error testing, aliases, watch mode, debugging, and code coverage.
This section equips you with the skills to write maintainable and efficient tests.
The course then introduces Test-Driven Development (TDD) with Jest and TypeScript, guiding you through coding katas and iterative development of a password checker application.
This hands-on approach solidifies your understanding of TDD principles.
Next, you’ll delve into the world of test doubles, including stubs, fakes, mocks, and spies.
You’ll learn how to isolate and test individual components of your application, ensuring thorough coverage and maintainability.
Applying these concepts, the course walks you through a real-world project, covering testing arrays, mocking consumer classes, injecting mocks, and testing event-based and server applications.
You’ll gain experience with both high-mock and low-mock testing strategies.
Integration testing is also covered, teaching you how to set up and write tests that verify the interaction between different components of your application.
The course explores additional topics like environment variables, multiple test configurations, snapshot testing, custom matchers, and the Node.js test runner module.
You’ll also get a glimpse of other testing frameworks and their comparison with Jest.
React developers will benefit from the section dedicated to unit testing React TypeScript components, covering rendering, user interactions, and asynchronous updates using the React Testing Library.
Finally, the course touches on Continuous Integration and Continuous Deployment (CI/CD) with GitHub Actions and Docker, enabling you to set up automated testing pipelines and ensure consistent, reliable builds.
AWS & Typescript Masterclass - CDK, Serverless, React
You’ll start by learning the fundamentals of AWS CloudFormation and the AWS Cloud Development Kit (CDK), which allows you to define and provision cloud infrastructure using code.
The course dives deep into CDK, covering intermediate topics like handling multiple stacks, cross-stack references, and sharing resources.
You’ll then build a serverless project from scratch using CDK and TypeScript, creating AWS Lambda functions, API Gateways, and DynamoDB databases.
Moving on, you’ll explore the challenges of working with AWS Lambda, such as bundling, testing, and debugging.
The course covers techniques for optimizing Lambda functions and integrating them with DynamoDB using TypeScript for data validation.
Security is a crucial aspect, and the course teaches you how to secure your APIs using AWS Cognito for authentication and access control.
You’ll learn about user pools, identity pools, and generating temporary AWS credentials.
For the front-end, you’ll build a React application that integrates with the AWS services you’ve created.
This includes routing, authentication, creating spaces, uploading files to S3, and visualizing data from DynamoDB.
The course also covers monitoring with CloudWatch, setting up alarms, and using AWS SNS for notifications.
You’ll learn how to write tests for your CDK infrastructure and AWS Lambda functions using Jest, including techniques like mocking and snapshot testing.
Finally, you’ll dive into CI/CD (Continuous Integration/Continuous Deployment) with AWS CodePipeline, setting up automated builds, tests, and deployments directly from your GitHub repository.