Forem: Jitendra

A Guide to Converting ASCII to Characters in JavaScript

Jitendra — Wed, 03 Jan 2024 15:04:40 +0000

Introduction:

In the vast world of programming, understanding the fundamentals is crucial. One such fundamental concept is ASCII (American Standard Code for Information Interchange). ASCII codes, representing characters as numerical values, play a vital role in various applications. This post will teach us how to use JavaScript to convert ASCII codes to characters.

Understanding ASCII:

ASCII is a character encoding standard that assigns a unique numerical value to each character. For example, the ASCII code for the letter 'A' is 65, 'B' is 66, and so on. This encoding scheme allows computers to represent text characters in a standardized way.

The Journey Begins: Writing the Conversion Function:

In JavaScript, the process of converting ASCII codes to characters is straightforward. We can leverage the String.fromCharCode() method to achieve this transformation. Let's explore a simple function that encapsulates this process:

const ASCIIToChar = (asciiCode) => {
  return String.fromCharCode(asciiCode);
};

The String.fromCharCode() method takes one or more Unicode values and returns the corresponding characters. In this case, we provide it with a single ASCII code to obtain the character it represents.

Putting the Function to the Test:

Now that we have our conversion function, let's put it to the test with some examples:

console.log(ASCIIToChar(65)); // Output: 'A'
console.log(ASCIIToChar(97)); // Output: 'a'
console.log(ASCIIToChar(33)); // Output: '!'

You can use ASCII to text converter to verify your output or convert ASCII codes to text online.

Handling Arrays of ASCII Codes:

What if you have an array of ASCII codes that you want to convert to a string? Fear not; JavaScript has you covered. We can modify our function to handle arrays of ASCII codes:

const ASCIIToString = (asciiArray) => {
  return String.fromCharCode(...asciiArray);
};

Now, you can convert an array of ASCII codes into a string effortlessly:

const asciiArray = [72, 101, 108, 108, 111];
console.log(ASCIIToString(asciiArray)); // Output: 'Hello'

Real-World Applications:

Understanding how to convert ASCII codes to characters opens the door to various real-world applications. You might encounter scenarios where data is encoded using ASCII and decoding it into readable text becomes a necessity

Conclusion:

In this exploration of converting ASCII codes to characters in JavaScript, we've equipped ourselves with a fundamental skill. The ability to decode ASCII opens up numerous possibilities in programming. Whether you're working with textual data or diving into the intricacies of character encoding, mastering the conversion from ASCII codes to characters is a journey well worth taking. Happy coding!

Top 5 Programming Languages to Learn in 2024

Jitendra — Tue, 26 Sep 2023 14:13:18 +0000

The technological landscape always evolves and is everchanging.
Similarly, the trend of languages also changes.

Based on current trends and market predictions, the top five programming languages predicted to be in high demand in 2024 are:

1. Python: Known for its simplicity and versatility, Python continues to be a popular choice for data analysis, artificial intelligence, and machine learning.

2. JavaScript: With the rise of online applications and the dominance of front-end development, JavaScript continues to be an important language for creating interactive and dynamic web pages.

3. Go: Go's popularity for systems and network programming can be attributed to its efficiency, strong support for concurrent programming, well-designed standard library, portability, and backing from Google. Its simplicity and focus on readability also contribute to its appeal, making it an excellent choice for building scalable, high-performance, and concurrent software systems.

4. Rust: Rust's ownership system is a groundbreaking feature that ensures memory safety without the need for a garbage collector. It enforces strict rules at compile time, preventing common issues like null pointer dereferences, data races, and buffer overflows

5. Java: Java's design and architecture make it well-suited for building large and complex applications. It's object-oriented programming (OOP) features, modular structure, and strong typing allow developers to design scalable and maintainable codebases

In conclusion, the programming languages landscape is ever-evolving, and it's important for developers and aspiring programmers to stay updated with the latest trends.

Make properties optional in TypeScript

Jitendra — Thu, 21 Sep 2023 09:58:36 +0000

I just came into a situation where I needed to mark one or more keys optional in a TypeScript interface.

Let’s say that I have an interface of three keys name, age, and email.

interface User {
  name: string;
  age: number;
  email: string
}

// 👍 OK, name, age, and email are defined
const pawel: User = {
  name: "Pawel Grzybek",
  age: 34,
  email: "email@email.com"
};

In today's modern world, if you have a small or large JSON object and want to create an interface for it, don't waste your time doing it manually. You can use an online JSON to Typescript converter.

Make all properties optional except one in TypeScript

Now I have a case in which I want to assign only name and age without email.

interface User {
  name: string;
  age: number;
  email: string
}

// 👎 Uuups, Property 'email' is missing
const pawel: User = {
  name: "Pawel Grzybek",
  age: 34
};

To handle this situation, TypeScript provides a handy utility type Partial. Which converts all keys to optional.

interface User {
  name: string;
  age: number;
  email: string
}

interface OptionalExceptEmail extends Partial<User>  {
  email?: string
}

// 👍 OK, all looks good
const pawel: OptionalExceptEmail = {
  name: "Pawel Grzybek",
  age: 34
};

Make a single or multiple properties optional in Typescript

To solve using best practices in Typescript. I will create another type to make it work.

interface Dev {
  language: string;
  age: number;
  experience: number;
}

type MakeOptional<Type, Key extends keyof Type> = Omit<Type, Key> &
  Partial<Pick<Type, Key>>;

// 👍 mark experience as optional
type T1 = MakeOptional<Dev, 'experience'>;

const dev1: T1 = {
  age: 30,
  language: 'ts',
};

// 👍 mark experience and age as optional
type T2 = MakeOptional<Dev, 'experience' | 'age'>;

const dev2: T2 = {
  language: 'ts',
};

Make all properties optional in TypeScript

To make all properties optional. Again I will use an amazing utility called Partial.

interface Person {
  personId: number;
  fullName: string;
  annualIncome: number;
}

// 👍 mark all keys as optional
const emp: Partial<Person> = {};

emp.fullName = 'Bobby Hadz';

Everything about JSON Stringify Method - JavaScript

Jitendra — Wed, 13 Sep 2023 16:27:59 +0000

Overview

JavaScript provides a static method JSON.stringify(). Which is useful to convert valid JavaScript object to JSON string.

Apart from it this method comes with lot of flexibility to create JSON string using using its replacer and space arguments.

In this article, we will explore how use to them.

To stringify JSON data online you can use a popular online tool JSON to String.

Syntax

JSON.stringify(value, replacer, space)

Parameters of JSON.stringify

Value (mandatory)
Replacer (optional)
Space (optional)

1. Value Parameter

Value is required to be passed as a parameter when calling the function.

const user = {
  "name": "Jimmy",
  "age": 67,
  "city": "New York"
};

const user_string = JSON.stringify(user);

Output

`{"name":"Jimmy","age":67,"city":"New York"}`

2. Replacer Parameter

Replacer is a optional parameter. It can be either an array or a function to alter the JavaScript object before converting it JSON string.

Assume you have your personal information in the form of a JavaScript object and now you want to convert it to JSON string. The issue is that you don't want to include all of the keys in the JSON string. Here replacer parameter comes into picture to apply that filter.

As an array, It will contain a list of allowed keys which you want to include in the result of JSON stringify.

const user = {
    "username": "johndoe",
    "firstName": "John",
    "lastName": "Doe",
    "email": "johndoe@dev.to",
    "age": 30,
    "registrationDate": "2023-09-12T12:00:00Z"
}

const replacer = ['username', 'firstName', 'lastName'];

const userData_string = JSON.stringify(user, replacer);

console.log(userData_string);

Output

`{"username":"johndoe","firstName":"John","lastName":"Doe"}`

As a function, It takes two parameters (Key, Value).

function replacer_function (key, value) {    
    // code
}

Consider a case where you want to add some logic to altering JSON data (Ex - You want to stringify an object's keys that does not contain string values).

const user = {
  "name": "John Doe",
  "age": 30,
  "email": "johndoe@example.com",
  "isSubscribed": true
}

function replacer(key, value){
    if(typeof value === 'string'){
        return undefined;
    }
    return value;
}

const user_string = JSON.stringify(user, replacer);

Output

`{"age":30,"isSubscribed":true}`

When replacer returns a object, string, number, boolean, or null, That returned value is treated as the value of the property, and the method converts it to a JSON string.
When it returns function, undefined or symbol, method will skip that key and will not include in output.

3. Space Parameter

We can use space parameter to control spacing in final result.
When we do not use last parameter, By default stringify method returns very crowded and dense output.

Space as a Number

When we use space as a number, the output's key-value pairs are separated by the specified number of spaces.

If we discuss the Space Parameter restriction. Only 0 to 10 spacing is allowed.

const colors = {
    primary: ['red','blue','green'],
    secondary: ['cyan', 'magenta', 'yellow'],
    tertiary: ['yellow-orange', 'red-orange', 'red-purple']
}

const colors_string = JSON.stringify(colors, null, 3);
console.log(colors_string);

Output

`{
   "primary": [
      "red",
      "blue",
      "green"
   ],
   "secondary": [
      "cyan",
      "magenta",
      "yellow"
   ],
   "tertiary": [
      "yellow-orange",
      "red-orange",
      "red-purple"
   ]
}`

Space as a String

If string is used as a space parameter. JSON stringify method will indent the result by the provided string.

const data = {
  name: "Central Park",
  city: "New York",
  country: "United States",
  amenities: ["Playgrounds", "Walking Trails", "Pond"],
};
const data_string = JSON.stringify(data, null, "fire");
console.log(data_string)

Output

`{
fire"name": "Central Park",
fire"city": "New York",
fire"country": "United States",
fire"amenities": [
firefire"Playgrounds",
firefire"Walking Trails",
firefire"Pond"
fire]
}`

I hope this was helpful to understand how JSON stringify works in JavaScript.

Top 2 Strategies for Handling JSON Parse Errors

Jitendra — Fri, 08 Sep 2023 07:32:45 +0000

JSON is quite popular and widely used data format for client and server communication.

Why do we get a JSON parsing error and How to Resolve Them?

If you have minor issues with JSON data. You can use any online tool such as JSON formatter. Which provides a feature to repair broken JSON.

Parsing JSON is a common task for a developer. JavaScript comes with a built-in method called JSON.parse(). Which is useful for parsing JSON string data.

If JSON is valid then JSON.parse() returns a JSON object otherwise, it throws a SyntaxError.

Handle JSON Parse Error in JavaScript

In JavaScript, There are many ways to deal with JSON parse errors, and we are going to explore two of the best here.

1. Handle Using try-catch block

To deal with JSON parse errors, the try-catch block method is most commonly used in JavaScript.

try {
  const json = '{"name": "Jimmy", "age":28}';
  const obj = JSON.parse(json);
  console.log(obj.name);
  // expected output: "Jimmy"
  console.log(obj.age);
  // expected output: 28
} catch (e) {
  console.log(e);
  // expected output: SyntaxError: Unexpected token o in JSON at position 1
}

2. Handle Using if-else block

Another useful method for handling JSON parse errors is to use an if-else block.
The use of this approach helps when you are doing other tasks in try-catch (for example, API requests and other processing) and then parsing JSON. Using this approach, you may find errors caused by SyntaxError.

try {
    // API calls
    // other handling
    const json = '{"name":"Jimmy", "age:42}';
    const obj = JSON.parse(json);
} catch (error) {
    if (error instanceof SyntaxError) {
        console.log(error);
        // expected output: SyntaxError: Unexpected token o in JSON at position 1
    }
}

What makes Go's compiler so FAST?

Jitendra — Thu, 07 Sep 2023 14:26:05 +0000

One of the best features of Go is its extremely quick compiler.
However, what exactly did the Go team do to achieve this?
Why is the Go compiler so fast?
Here are the reasons.

Go is simple

Go only has 20-something keywords in the language.
Compared to Java in the 60s and close to 100 for C++, for example.
This helps with shortening the compilation time.

No unused components

You can't compile with unused components like variables or imports.
Your IDE or code editor will also constantly complain during your development.
This helps reduce unnecessary instructions to compile at the end.

No symbol table when parsing

A symbol table is a data structure for storing entities like variable/function names.
Parsing in languages like C/C++ requires the symbol table.
Note that the symbol table is still used for full compilation, just not during parsing in Go, which reduces part of compilation time. No header files.
C/C++ uses header files to connect the different components together.
These header files take extra time to load, parse then compile.
Go, on the other hand, doesn't use header files.

Prioritisation

Fast compilation speed has been the priority since the birth of Go.
As a result, other features of Go have to be designed with fast compilation in mind.
Such prioritisation makes a difference, especially over time.

Hope this helps you get some ideas on this subject!

Encode URL in Javascript

Jitendra — Tue, 05 Sep 2023 11:26:33 +0000

Did you know that each website and online resource has a unique URL for its address? Uniform Resource Locators, or URLs, can appear straightforward but contain numerous components and special characters, making them truly fairly complex.

Built-in JavaScript Encoding Functions

When It comes to encoding in JavaScript. It Gives to two functions to perform encoding encodeURIComponent() and encodeURI().

How to use encodeURI in JavaScript

This function is used for encoding the complete URI (Uniform Resource Identifier). A limitation of we can say feature of encodeURI is that it does not encode characters ~!@#$&*()=:/,;?+' .

Syntax:

const originalURI = "https://www.dev.to/search?q=Hello dev";
const encodedURI = encodeURI(originalURI);
console.log(encodedURI);
VM249:3 https://www.dev.to/search?q=Hello%20dev

How to use encodeURIComponent in JavaScript

This function is used to encode complete URL (Uniform Resource Locator) instead of URI.

Syntax:

const originalURI = "https://www.dev.to/search?q=Hello dev";
const encodedURI = encodeURIComponent(originalURI);
console.log(encodedURI);
VM261:3 https%3A%2F%2Fwww.dev.to%2Fsearch%3Fq%3DHello%20dev

You can use any online JavaScript code executor, browser console, or online URL encoder tool to verify your encoding output.

Encoding vs Encryption

People frequently get confused between encoding and encryption. Although both are used to transform data but to serve different purposes and requirements.

Encoding: Encoding is used to transform data into specific format without maintaining security. It is easily reversible using appropriate method.

Encryption:: Encryption is used to protect data using complex algorithms. It ensures data confidentiality and security. Encrypted data is also reversible but only with the correct decryption key.