DEV Community: Pedro Henrique da Costa Rossi

Mastering Typing: A Deep Dive into TypeScript's Diverse Type System

Pedro Henrique da Costa Rossi — Thu, 30 Nov 2023 17:46:04 +0000

In TypeScript, types are a fundamental feature that allows developers to explicitly define the shape and structure of data within their code. By assigning types to variables, functions, and other entities, TypeScript enables static type checking, catching potential errors during development rather than at runtime. This proactive approach enhances code reliability, makes it more maintainable, and improves collaboration within a development team.

1.Introduction to Primitive Types
In TypeScript, types are a system for explicitly defining the data structure of variables, functions, and other entities in your code. They enable static type checking, catching errors during development. For instance, you can specify that a variable should be a string, a number, or even a custom object. Here's a simple example:

// Variable with explicit type
let age: number = 25;

// Function with parameter types and return type
function greet(name: string): string {
    return `Hello, ${name}!`;
}

// Custom object type
type Person = {
    name: string;
    age: number;
};

// Usage of the custom type
let person: Person = { name: "John", age: 30 };

2.Basically the main methods are:
number: Represents numeric values, including integers and floating-point numbers. Example: let count: number = 42;

string: Represents textual data, such as words or characters. Example: let message: string = "Hello, TypeScript!";

boolean: Represents a logical value, either true or false. Example: let isLogged: boolean = true;

array: Represents a sequential collection of elements of the same type using square brackets. Example: let numbers: number[] = [1, 2, 3];

object: Represents any non-primitive type and is a generic term for instances of classes or custom structures. Example: let person: { name: string, age: number } = { name: "Alice", age: 30 };

3.Explicit typing:
Explicit typing refers to the practice of clearly specifying the data type of a variable, function parameter, or return value in a programming language. This is commonly associated with statically-typed languages, where the data type of a variable is explicitly declared by the programmer, as opposed to dynamically-typed languages where types are inferred at runtime.

In languages like TypeScript, explicit typing involves explicitly stating the type of a variable using a colon (:) followed by the type. For example:

let age: number = 25;

Here, age is explicitly declared as a variable of type number. This means that age can only hold numeric values, and any attempt to assign a value of a different type will result in a compilation error.

4.Implicit typing:
Implicit typing, often associated with dynamically-typed languages, is a programming language feature where the type of a variable is determined automatically by the interpreter or compiler based on the value assigned to it. This means that developers do not explicitly specify the data type of a variable; instead, the type is inferred from the context or the assigned value.

In languages like JavaScript, which is dynamically typed, implicit typing is common:

let age = 25; // Here, the type of 'age' is implicitly inferred as a number.
let name = "John"; // The type of 'name' is implicitly inferred as a string.

5.Conclusion
In a nutshell, TypeScript types are a game-changer for developers. From explicit precision to implicit flexibility, they elevate code quality. We delved into union types, type aliases, and intersections, unleashing a potent coding arsenal. With these tools, developers forge resilient, expressive code, minimizing errors. TypeScript isn't just a language; it's a powerhouse ally for rock-solid software development.

Unleashing the Power of Generator Functions in JavaScript: A Comprehensive Guide

Pedro Henrique da Costa Rossi — Mon, 27 Nov 2023 16:57:04 +0000

A generator function is a special type of function in JavaScript that has the unique ability to pause its execution and resume it later. While normal functions run from start to finish and return a value, generator functions can be interrupted in the middle, allowing you to control the flow of execution more flexibly.

To create a generator function, you use the function keyword followed by an asterisk (*). Inside the generator function, instead of using return to send a value, you use the yield keyword. This yield acts like a pause, where the function stops and returns a value, but remembers exactly where it left off.

function* generator(i){
    yield i + 1;
    yield i + 2;
    yield i + 3;
}


var gen = generator(10);

console.log(gen.next())
console.log(gen.next())
console.log(gen.next())

Now that we grasp the fundamental concept of generator functions, let's delve deeper into navigating this fascinating universe. In the previous example, we created a simple generator that produced sequential values from a starting point. Let's broaden our horizons by exploring additional features and advanced strategies.

1. Understanding the next() Method
When using the next() method on a generator, we can advance its execution to the next pause point (yield). Each invocation of next() returns an object with two properties: value containing the generated value and done indicating whether the generator function has completed its execution.

console.log(gen.next()); // { value: 11, done: false }
console.log(gen.next()); // { value: 12, done: false }
console.log(gen.next()); // { value: 13, done: false }
console.log(gen.next()); // { value: undefined, done: true }

2. Sending Values from Outside to Inside the Generator

Generator functions can receive values from the outside using the next(value) method. This value is captured by the yield expression as if it were the result of the previous pause.

function* generator(i) {
    const receivedValue = yield i + 1;
    yield i + receivedValue;
}

const gen = generator(5);
console.log(gen.next());   // { value: 6, done: false }
console.log(gen.next(10)); // { value: 15, done: false }

3. Coordination Between Multiple Generators

In some cases, coordinating the execution of multiple generators can be beneficial. You can achieve this by delegating control from one generator to another using the yield* keyword. This is known as "generator delegation." Here's a simple example:

function* generatorA() {
    yield 'A1';
    yield 'A2';
}

function* generatorB() {
    yield 'B1';
    yield 'B2';
}

function* mainGenerator() {
    yield 'Start';

    yield* generatorA();

    yield 'Middle';

    yield* generatorB();

    yield 'End';
}

const gen = mainGenerator();

console.log(gen.next().value); // 'Start'
console.log(gen.next().value); // 'A1'
console.log(gen.next().value); // 'A2'
console.log(gen.next().value); // 'Middle'
console.log(gen.next().value); // 'B1'
console.log(gen.next().value); // 'B2'
console.log(gen.next().value); // 'End'
console.log(gen.next().value); // undefined

Conclusion: Unraveling Generator Functions in JavaScript

In summary, generator functions emerge as a powerful tool in JavaScript development, simplifying flow control, especially in asynchronous operations. Their unique ability to pause and resume execution fosters code that is more readable and linear, departing from traditional nested callbacks.

By offering efficient iterations, lazy evaluation, and automatic maintenance of internal states, generator functions elevate the expressiveness and efficiency of code. This article highlights how this intuitive approach transforms how we perceive and structure our programs, encouraging developers to explore and apply these concepts in their projects. In an increasingly complex programming landscape, generator functions stand out as a beacon of simplicity and effectiveness, enriching the journey of software development in JavaScript.

Binary Search

Pedro Henrique da Costa Rossi — Mon, 06 Nov 2023 19:05:34 +0000

Searching refers to iterating over the data structure's elements to retrieve some data. When searching in an array, there are two main techniques depending on whether the array is sorted.
With regards to Linear and Binary searching, Linear searches are especially flexible because they can be used with both sorted and unsorted data while Binary searches are specifically used with sorted data.

Linear Search
A linear search works by going through each element of the array one index after another sequentially. The following code example is an implementation of a linear search that iterates through the entire array of numbers to find out whether an item exists within the array.

function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i; 
    }
  }
  return -1; 
}

// Example usage:
const numbers = [4, 2, 7, 1, 9, 3];
const target = 7;
const result = linearSearch(numbers, target)

Binary Tree
Generally, when beginners in programming attempt to perform a loop to find something in an array, they resort to linear search, an algorithm with little efficiency that analyzes each index of the array in search of the desired element. To put it simply, it's like reading an entire dictionary in search of just a small word.

Unlike linear search, binary search has the "spirit" of divide and conquer. It repeatedly divides a data collection in two, which allows vast data portions not to be analyzed.

function pesquisaBinariaPrimos(array, targe) {
  let left = 0;
  let right = array.length - 1;

  while (left <= right) {
    const half = Math.floor((letf + right) / 2);

    if (array[half] === targe) {
      return half; 
    } else if (array[half] < targe) {
      left = half + 1;
    } else {
      right = half - 1;
    }
  }

  return -1; 
}

Those with a basic knowledge of algorithms and JavaScript can already understand the steps and processes of the code.

With a sorted dataset, we can take advantage of the order to make a search more efficient than going element by element.

Let's say you're looking for the word "Telescope" in the dictionary. You don't leaf through the words "A" and "B," page by page until you get to the desired page because you know that "T" is near the end of the alphabet.

You can open it near the end and see the words "R." Maybe then you jump ahead and reach the words with "V." You then backtrack a bit to find the words "T."

At each point, you could look forward or backward based on the order of the alphabet. We can use this intuition for an algorithm called binary search.

Binary search requires a sorted dataset. We then follow the following steps:

Check the middle value of the dataset.
If this value matches our target, we can return the index.
If the middle value is less than our target, start at step 1 using the right half of the list.
If the middle value is greater than our target, start at step 1 using the left half of the list.
Finally, we either run out of values in the list or find the target value.

Asymptotic Analysis: Understanding Infinite Limits

Pedro Henrique da Costa Rossi — Fri, 27 Oct 2023 18:31:12 +0000

introduction
If you've ever studied software development and software analysis, you've undoubtedly come across the question, "Is my code good? Is it efficient?" To answer this question, we need to master asymptotic analysis.

Asymptotic Notation
Starting with the fundamentals of Asymptotic Notation, we need to master "Big O." The "Big O" notation is defined as O(f(n)), where "f(n)" is a function that describes the upper bound of the growth of another function. This allows us to compare the performance of algorithms as their inputs grow indefinitely.

Exist five main functions in the "Big O", in which will be explain how to indentify them:

O(1) : this denotes a constant time of execution, this means that the function does not depends on the size of the input.

O(log n) : indicates logarithmic growth

O(n) : represents linear growth, when the time of execution is directly proportional to the size of the input

O(n log n) : Common in efficient sorting algorithms.

O(n²) : Indicates quadratic growth, common in inefficient algorithms, such as some forms of selection sort.

To explain how to use it in practice, I will use the following example.

function buscaLinear(array, alvo) {
  for (let i = 0; i < array.length; i++) {
    if (array[i] === alvo) {
      return i; // Elemento encontrado
    }
  }
  return -1; // Elemento não encontrado
}

First step:
Considering the provided code, the first step is to identify which functions exist and create a notation that describes how many steps are required to execute the algorithm.

In this simple case, we can identify that there is a loop that will iterate through a specific array, making it a linear growth notation T(n) because the increase in steps is directly proportional to the number of objects in the array.

Second step:
The second step to perform asymptotic analysis is the simplification of the equation we created in the previous step. Simplification involves removing all elements from the notation except the largest variable. Therefore, the complexity of T(n) is O(n).

Conclusion:
In summary, mastering asymptotic analysis, especially the "Big O" notation, is essential for software development professionals. This skill enables a thorough evaluation of algorithm performance and guides decisions regarding algorithm selection and optimization. Understanding algorithm growth rates is fundamental for creating efficient and scalable software systems. Asymptotic analysis is a valuable tool that empowers developers to write better and more efficient code.