DEV Community: Gabriel Rufino

Reverse switch?

Gabriel Rufino — Tue, 27 Apr 2021 02:19:23 +0000

I recently saw something that caught my attention and I called it Reverse Switch. Probably there's a better name.

A conditional switch where the expression takes boolean constants (true or false) and the switch cases take expressions.

Some like this:

switch (true) {
  case isEven(x):
    console.log('x is even!')
    break
  case isPrime(x):
    console.log('x is prime!')
    break
  case x > 10:
    console.log('x is greater than 10')
    break
  default:
    console.log('x is not even, is not prime and is not greater than 10')
}

My head exploded because I never thought about it.
I always did it as follows:

if (isEven(x)) {
  console.log('x is even!')
} else if (isPrime(x)) {
  console.log('x is prime!')
} else if (x > 10) {
  console.log('x is greater than 10')
} else {
  console.log('x is not even, is not prime and is not greater than 10')
}

And here comes my question:

Have you seen or done something like that?
Do you think it is good practice?
Which one is more readable?

Let's talk about it!

A creative way to have required arguments in JavaScript

Gabriel Rufino — Thu, 25 Mar 2021 01:01:45 +0000

Have you ever received an error because you forgot to pass an argument to the function? This is a common situation.

Unfortunately, JavaScript does not require passing parameters that have been declared in the function, and this results in a possible later error.

Let's see an example. Consider we've got a function that must receive a string and return if that string contains de letter "G".

file.js

function includesG(string) {
  return string.includes('G')
}

console.log(includesG('Gabriel Rufino')) // true

This works fine! But there's a problem: what happens if I call the function includesG without an argument?

file.js

function includesG(string) {
  return string.includes('G')
}

console.log(includesG())

Let's execute using Node:

$ node file.js
/home/gabrielrufino/Desktop/file.js:2
  return string.includes('G')
                ^

TypeError: Cannot read property 'includes' of undefined
    at includesG (/home/gabrielrufino/Desktop/lab/lab.js:2:17)
    at Object.<anonymous> (/home/gabrielrufino/Desktop/lab/lab.js:5:13)
    at Module._compile (internal/modules/cjs/loader.js:1063:30)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1092:10)
    at Module.load (internal/modules/cjs/loader.js:928:32)
    at Function.Module._load (internal/modules/cjs/loader.js:769:14)
    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:72:12)
    at internal/main/run_main_module.js:17:47

It seems to be a pretty violent error 😅

There's a much better way to report the absence of an argument to the developer: we can combine the power of the default params with the throw of a more descriptive error.

Let's do it step by step. First, we define the function responsible for throw the error. I'm gonna call it isRequired.

file.js

function isRequired(argument) {
  throw new Error(`The argument ${argument} is required`)
}

function includesG(string) {
  return string.includes('G')
}

console.log(includesG())

The function isRequired is nothing more than a function that throws a custom error based on the name of the argument.

Now that we have this function, we can use it as the default param of the required argument or arguments.

Wait for it...

file.js

function isRequired(argument) {
  throw new Error(`The argument ${argument} is required`)
}

function includesG(string = isRequired('string')) {
  return string.includes('G')
}

console.log(includesG())

Now, always we forget to pass the argument string, the default value will be assumed and the default value is the throw of an error.

Let's run the code:

$ node file.js
/home/gabrielrufino/Desktop/file.js:2
  throw new Error(`The argument ${argument} is required`)
  ^

Error: The argument string is required
    at isRequired (/home/gabrielrufino/Desktop/lab/lab.js:2:9)
    at includesG (/home/gabrielrufino/Desktop/lab/lab.js:5:29)
    at Object.<anonymous> (/home/gabrielrufino/Desktop/lab/lab.js:9:13)
    at Module._compile (internal/modules/cjs/loader.js:1063:30)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1092:10)
    at Module.load (internal/modules/cjs/loader.js:928:32)
    at Function.Module._load (internal/modules/cjs/loader.js:769:14)
    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:72:12)
    at internal/main/run_main_module.js:17:47

And now, we've got a more descriptive error saying that we forgot the parameter string.

"Ok, Gabriel! But don't we replace one error with another? How does it help me?"

Errors were created to help us! They must tell us what specifically is wrong. The first error doesn't help us to find out what is the problem, it only says that the value undefined doesn't have the method includes. It's so much generic to find the problem. The error we've created says explicitly that we forgot the argument 😄

Thank you!

How I made my own file compressor using Node.js

Gabriel Rufino — Tue, 16 Mar 2021 10:41:32 +0000

You may know Node.js for its power to build highly scalable services, but don't know that it is possible to do much more than just that. Using Node.js we can build incredible tools: from on-demand data processing to building neural networks that are used in machine learning.

The main concepts covered here will be the building CLIs using NodeJS, the use of Node Streams for processing e manipulating files, the native module zlib for file compression and decompression, and transformation of functions that receive a callback in promise functions.

The final result will be a CLI called npacker having two simple commands: pack for compression and unpack for decompression.

Compression command

Terminal

$ ls -la testfile.txt
-rw-rw-r-- 1 gabrielrufino gabrielrufino 2147483648 mar 14 11:13 testfile.txt
$ npacker pack testfile.txt
$ ls -la testfile.txt testfile.txt.gz
-rw-rw-r-- 1 gabrielrufino gabrielrufino 2147483648 mar 14 11:13 testfile.txt
-rw-rw-r-- 1 gabrielrufino gabrielrufino    2087280 mar 14 11:15 testfile.txt.gz

You may notice a reduction in the size of the compressed file compared to the source file

Decompression command

Terminal

$ ls -la testfile.txt.gz
-rw-rw-r-- 1 gabrielrufino gabrielrufino 2087280 mar 14 11:15 testfile.txt.gz
$ npacker unpack testfile.txt.gz
$ ls -la testfile.txt.gz testfile.txt
-rw-rw-r-- 1 gabrielrufino gabrielrufino 2147483648 mar 14 11:38 testfile.txt
-rw-rw-r-- 1 gabrielrufino gabrielrufino    2087280 mar 14 11:15 testfile.txt.gz

Now you can see the original file generated by the compressed file.

Repository

If you don't want to see the explanation, you can see the final code and contribute to it.

gabrielrufino / npacker

🗜️ Compressor de arquivos feito em Node.js

1. Creating the CLI

The first step is to create the structure of the project and make a binary file visible in the whole system. Fortunately, npm gives us an easy way to do this.

Let's create a folder, initialize an npm project and create the file index.js

Terminal

$ mkdir npacker
$ cd npacker
$ npm init -y
$ touch index.js

These commands generate two important files for our project: the package.json and the index.js.

This is the initial state of the package.json:

package.json

{
  "name": "npacker",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

The task now is to make index.js a binary, give it an alias and make it visible in any folder on the system. Look at these necessary changes:

index.js

#!/usr/bin/env node

'use strict'

async function main() {
  console.log('Let\'s compress!')
}

main()

package.json

{
  "name": "npacker",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "bin": {
    "npacker": "index.js"
  },
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Notice that we need to put the line #!/usr/bin/env node on the top of the index.js. Moreover, we put the key bin on package.json giving the alias npacker to the index.js file. We also include the string use strict to activate the strict mode in the project and created the async function main to use await on it.

Finally, we run the command below to make the executable visible in any folder.

Terminal

$ npm link

Now you can execute the command npacker at any folder. Nice!

Terminal

$ cd ~
$ npacker
Let's compress!

2. Getting the arguments

There are two important arguments that we want to receive from the command line: the operation and the file. The operation can be pack or unpack and the file can be any file from any format.

For this, we can use the process.argv: an array containing all the command line arguments.

Let's see with code:

index.js

#!/usr/bin/env node

'use strict'

async function main() {
  console.log(process.argv)
}

main()

Terminal

$ npacker pack music.mp3
[
  '/home/gabrielrufino/.nvm/versions/node/v14.16.0/bin/node',
  '/home/gabrielrufino/.nvm/versions/node/v14.16.0/bin/npacker',
  'pack',
  'music.mp3'
]

The first argument is the executor that we've specified at the first line of index.js. The second argument is the generated link for the binary specified by us in package.json. These two first arguments don't matter to us.

The two last are the important arguments: the operation (pack or unpack) and the file.

We can extract them in an easy way using array destructuring assignment ignoring the two first arguments. Some like this:

index.js

#!/usr/bin/env node

'use strict'

async function main() {
  const [,, operation, file] = process.argv

  console.log(operation, file)
}

main()

Terminal

$ npacker pack documentation.docx
pack documentation.docx

3. Compressing files

To make the compression, we will need 4 native modules: fs, stream, zlib and util. Let's import these modules:

index.js

#!/usr/bin/env node

'use strict'

const fs = require('fs')
const stream = require('stream')
const zlib = require('zlib')
const { promisify } = require('util')

async function main() {
  const [,, operation, file] = process.argv

  console.log(operation, file)
}

main()

Now we can verify if the operation is pack: the compression operation.

index.js

#!/usr/bin/env node

'use strict'

const fs = require('fs')
const stream = require('stream')
const zlib = require('zlib')
const { promisify } = require('util')

async function main() {
  const [,, operation, file] = process.argv

  if (operation === 'pack') {

  }
}

main()

So far so good. Pay close attention to the next step because it is the most important one so far. We'll work with an important concept in Node.js: the Node Streams.

A stream is an abstract interface for working with streaming data in Node.js. The stream module provides an API for implementing the stream interface.

The definition above is from Node.js Documentation.

Streams are a way to process large data using a smart approach: divide all the data into small packages and process them one by one. The module fs provides us two methods to read and write data using streams: createReadStream and createWriteStream. The module zlib provides us a method to compress data in gz format: createGzip. Finally, the stream module provides us a method to create a logical sequence from reading to writing: pipeline.

index.js

#!/usr/bin/env node

'use strict'

const fs = require('fs')
const stream = require('stream')
const zlib = require('zlib')
const { promisify } = require('util')

async function main() {
  const [,, operation, file] = process.argv

  if (operation === 'pack') {
    const gzip = zlib.createGzip()
    const source = fs.createReadStream(file)
    const destination = fs.createWriteStream(`${file}.gz`)

    await promisify(stream.pipeline)(source, gzip, destination)
  }
}

main()

The intention of the util.promisify is to transform the function stream.pipeline in a function that returns Promise instead of a function that receives a callback.

And that's it! Simple as it looks and we can run the following command:

Terminal

$ npacker pack file.txt

4. Decompressing files

This part is the inverse of the last one. The only change is the use of zlib.createUnzip istead of zlib.createGzip. Let's see the result:

index.js

#!/usr/bin/env node

'use strict'

const fs = require('fs')
const stream = require('stream')
const zlib = require('zlib')
const { promisify } = require('util')

async function main() {
  const [,, operation, file] = process.argv

  if (operation === 'pack') {
    const gzip = zlib.createGzip()
    const source = fs.createReadStream(file)
    const destination = fs.createWriteStream(`${file}.gz`)

    await promisify(stream.pipeline)(source, gzip, destination)
  } else if (operation === 'unpack') {
    const unzip = zlib.createUnzip()
    const source = fs.createReadStream(file)
    const destination = fs.createWriteStream(file.replace('.gz', ''))

    await promisify(stream.pipeline)(source, unzip, destination)
  }
}

main()

Finally, we can run the command for decompression:

Terminal

$ npacker unpack file.txt.gz

Here we saw one of the wonderful things that Node.js can do other than just services. Thank you very much!

Convertendo Callbacks para Promises no Node.js

Gabriel Rufino — Fri, 21 Aug 2020 18:42:21 +0000

Um padrão muito usado no início do Node.js foi o padrão Callback. Esse padrão foi a primeira forma de resolver o assincronismo da single thread do JavaScript.

Veja um exemplo fake abaixo:

function getUserCallback(id, callback) {
  setTimeout(function () {
    callback(null, {
      id,
      name: 'Gabriel Rufino'
    })
  }, 2000)
}

getUserCallback(1234, function (error, user) {
  if (!error) {
    console.log(user)
  }
})

Felizmente, hoje nós temos Promises e a dupla amável async/await para tratar o fluxo assíncrono de forma mais elegante.

A mesma função getUser usando Promise:

function getUserPromise(id) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve({
        id,
        name: 'Gabriel Rufino'
      })
    }, 2000)
  })
}

getUserPromise(1234)
  .then(function (user) {
    console.log(user)
  })
  .catch(function (error) {
    console.error(error)
  })

Mas nem tudo são flores. Ainda existem diversas funções ou pacotes npm que funcionam apenas com callbacks. Com sorte, o Node.js tem por padrão uma função que nos ajuda a transformar funções que recebem um callback como um argumento para uma função que retorna uma Promise.

É o helper util.promisify:

const util = require('util')

const functionPromise = util.promisify(/* Função aqui */)

Veja um exemplo de conversão:

const { promisify } = require('util')
const getUserCallback = require('./getUserCallback')

getUserCallback(1234, function (error, user) {
  if (!error) {
    console.log(user)
  }
})

const getUserPromise = promisify(getUserCallback)

getUserPromise(1234)
  .then(function (user) {
    console.log(user)
  })
  .catch(function (error) {
    console.log(error)
  })

Importante: A função deve seguir o padrão callback

O callback deve ser o ultimo argumento
O primeiro argumento do callback deve ser o possível erro

Era isso! Obrigado :D

Converting Callbacks to Promise approach on Node.js

Gabriel Rufino — Thu, 20 Aug 2020 22:33:38 +0000

A pattern very used at the beginning of Node.js was the Callback pattern. This pattern was the first way to resolve the asynchronism of the javascript single thread.

Look at a fake example below:

function getUserCallback(id, callback) {
  setTimeout(function () {
    callback(null, {
      id,
      name: 'Gabriel Rufino'
    })
  }, 2000)
}

getUserCallback(1234, function (error, user) {
  if (!error) {
    console.log(user)
  }
})

Fortunately, today we have Promises and the lovely duo async/await to treat the asynchronous flow more elegantly.

The same function getUser using Promise:

function getUserPromise(id) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve({
        id,
        name: 'Gabriel Rufino'
      })
    }, 2000)
  })
}

getUserPromise(1234)
  .then(function (user) {
    console.log(user)
  })
  .catch(function (error) {
    console.error(error)
  })

But not everything is perfect. There's a lot of functions or npm packages that work only with the callback approach. Hopefully, the Node.js has built-in util that helps us to transform functions that receive a callback as an argument to a function that returns a Promise.

It's the util.promisify helper:

const util = require('util')

const functionPromise = util.promisify(/* Function here */)

Look at an example of transforming:

const { promisify } = require('util')
const getUserCallback = require('./getUserCallback')

getUserCallback(1234, function (error, user) {
  if (!error) {
    console.log(user)
  }
})

const getUserPromise = promisify(getUserCallback)

getUserPromise(1234)
  .then(function (user) {
    console.log(user)
  })
  .catch(function (error) {
    console.log(error)
  })

Important: The function must follow the callback pattern

The callback must be the last argument
The first argument of the callback must be the possible error

That's it! Thank you :D

Commander.js no meu YouTube

Gabriel Rufino — Wed, 12 Aug 2020 13:02:14 +0000

Essa semana lancei uma playlist sobre Commander.js no meu canal do YouTube.

Com essa biblioteca, a gente consegue construir CLIs muito poderosas e publicar no NPM pra todo mundo usar.

Te espero lá: Link da playlist

Share files on React Native

Gabriel Rufino — Wed, 12 Aug 2020 12:33:59 +0000

File sharing is a very common feature in many apps. For this purpose on React Native, we can use the lib React Native Share.

Install React Native Share

$ npm install react-native-share --save

One more step for iOS

$ npx pod-install
# or
$ cd ios && pod install

Share a file

import React, {useCallback} from 'react';
import {View, Button} from 'react-native';
import Share from 'react-native-share';

export default function ShareAudio () {
  const onShareAudio = useCallback(function () {
    Share.open({
      url: `file:///data/data/com.yourapp/files/audio.mp3`,
      type: 'audio/mp3',
    });
  }, []);

  return (
    <View>
      <Button
        title="Share audio"
        onPress={onShareAudio}
      />
    </View>
  );
};

Simple snippet to shuffle array

Gabriel Rufino — Sat, 25 Jul 2020 00:29:32 +0000

If you need to shuffle the elements of an array, you can use this simple function:

function shuffle(array) {
  const copy = [...array]

  return copy.sort(() => Math.random() - 0.5)
}

The algorithm

Creates a copy of the parameter to not modify the original array
Uses the function Array.prototype.sort of the copy to randomly sort the array with a callback that always returns Math.random() - 0.5 (The random factor).

Example

const example = [1, 2, 3]

const shuffled = shuffle(example)

/*
  shuffled is one of these:
  - [1, 2, 3]
  - [1, 3, 2]
  - [2, 1, 3]
  - [2, 3, 1]
  - [3, 1, 2]
  - [3, 2, 1]
*/

How to make your express API more secure with helmet

Gabriel Rufino — Thu, 23 Jul 2020 00:46:24 +0000

Security is a serious matter! Are you concerned about the security of your APIs?

When it comes to APIs built with Express.js, one simple step can help you increase the level of security on your system: the Helmet library.

What is the Helmet?

Helmet is a library for Express.js that aggregates 12 simple middleware, responsible for setting some headers in HTTP responses.

Let's do a simple example below:

Simple example

$ mkdir my-api
$ cd my-api
$ npm init -y
$ npm install express --save

Create a file index.js:

const express = require('express')

const app = express()

app.get('/', (request, response) => {
  return response.json({
    api: 'live'
  })
})

app.listen(3000)

Start the server:

$ node index.js

Notice the headers returned by the request without using the helmet:

We will include the helmet in our API. First, install the package:

$ npm install helmet --save

Import and include in the express app as follows:

const express = require('express')
const helmet = require('helmet')

const app = express()

app.use(helmet())

app.get('/', (request, response) => {
  return response.json({
    api: 'live'
  })
})

app.listen(3000)

Restart the server:

$ node index.js

Discover the new headers defined by the helmet:

These headers add the extra level of security to your API. For example, Strict-Transport-Security, which allows a website to inform browsers that it should be accessed only over HTTPS, instead of using HTTP.

Some middlewares are enabled by default, others are not. Learn more at https://helmetjs.github.io/

See you soon

Removing repetitions from Array using the class Set

Gabriel Rufino — Mon, 20 Jul 2020 23:58:15 +0000

I was watching a course on Udemy and I figure out a very cool way of removing eventual repetitions of elements of an array.

It is the combination of the class Set with the Spread Operator.

Set

Allows storage of unique values of any type.

Example of a set:

const set = new Set([1, 2, 3, 3, 4, 5, 5])
console.log(set) // Set {1, 2, 3, 4, 5}

Click here to know more about the class Set.

Spread operator

It will serve to spread the elements of the resulting Set.

Example of how the spread operator works:

const a = [1, 2, 3]
const b = [4, 5, 6]

const c = [...a, ...b]
console.log(c) // [1, 2, 3, 4, 5, 6]

Click here to learn more about the Spread operator.

Combining both

Now, we can combine both and remove the repetitions:

const initial = [1, 2, 2, 3, 4, 4, 8, 8]
const set = new Set(initial)
const final = [...set]

console.log(final) // [1, 2, 3, 4, 8]

Your first Firebase Function

Gabriel Rufino — Thu, 16 Jul 2020 22:35:17 +0000

With Firebase Cloud Functions, you don't have to worry about server management. All the boring tasks are made by the Firebase, and you worry about the main thing: the business rule of your application.

Cloud Functions for Firebase is a serverless framework that lets you automatically run backend code in response to events triggered by Firebase features and HTTPS requests. Your JavaScript or TypeScript code is stored in Google's cloud and runs in a managed environment. There's no need to manage and scale your own servers.

Above, you read the definition of Firebase Cloud Functions according to the documentation.

The purpose here is to implement your first function triggered by an HTTP call.

Create a project

Obviously, you gonna need a firebase project to deploy your first function. It's pretty easy and I explain how to do it in my post Deploy a website using Firebase Hosting.

This is a post in English written by a Brazilian. I decided to try to write a series of articles in a new language with more reach than Portuguese using a translator eventually because I'm not fluent yet. So, I ask you for feedback and corrections if you find any errors. Thanks!

Init a folder

If you don't have the CLI of firebase, e execute this command:

$ npm install -g firebase-tools

So, now you create a folder and init a firebase project. Some like this:

$ mkdir firebase-lab-functions
$ cd firebase-lab-functions
$ firebase init

And follow the init steps:

Select the option Functions: Configure and deploy Cloud Functions
Select Use an existing project if you already create the project.
Choose the project.
Choose between JavaScript or TypeScript as the language of the functions.
Ask if you want to use ESLint style
Input Y to install the dependencies.

Look at my init inputs:

Create a function

Let's create our function. Note that the init create a folder called functions with a file called index.js with this content:

const functions = require('firebase-functions');

// // Create and Deploy Your First Cloud Functions
// // https://firebase.google.com/docs/functions/write-firebase-functions
//
// exports.helloWorld = functions.https.onRequest((request, response) => {
//   functions.logger.info("Hello logs!", {structuredData: true});
//   response.send("Hello from Firebase!");
// });

We can remove the comments of the function helloWorld:

const functions = require('firebase-functions');

// // Create and Deploy Your First Cloud Functions
// // https://firebase.google.com/docs/functions/write-firebase-functions
//
exports.helloWorld = functions.https.onRequest((request, response) => {
  functions.logger.info("Hello logs!", {structuredData: true});
  response.send("Hello from Firebase!");
});

Note that you need to export the function specifying the trigger. In this case, we export the function by exports.helloWorld using the trigger functions.https for HTTP calls! And then, we say to execute our controller as the callback of the event listener onRequest.

I would like to change the response:

const functions = require('firebase-functions');

// // Create and Deploy Your First Cloud Functions
// // https://firebase.google.com/docs/functions/write-firebase-functions
//
exports.helloWorld = functions.https.onRequest((request, response) => {
  functions.logger.info("Hello logs!", {structuredData: true});
  response.send("Hello from Gabriel Rufino!");
});

Deploy

The last task is to deploy the function with a simple command at the folder you created:

$ firebase deploy

This problem occurred to me: https://stackoverflow.com/questions/62852071/cloud-functions-deployment-requires-the-pay-as-you-go-blaze-billing-plan

The deploy will give you the endpoint of your function!

Thanks!

DEV Community: Gabriel Rufino

Reverse switch?

A creative way to have required arguments in JavaScript

How I made my own file compressor using Node.js

Compression command

Decompression command

Repository

gabrielrufino / npacker

🗜️ Compressor de arquivos feito em Node.js

1. Creating the CLI

2. Getting the arguments

3. Compressing files

4. Decompressing files

Convertendo Callbacks para Promises no Node.js

Converting Callbacks to Promise approach on Node.js

Commander.js no meu YouTube

Share files on React Native

Install React Native Share

One more step for iOS

Share a file

Simple snippet to shuffle array

The algorithm

Example

How to make your express API more secure with helmet

What is the Helmet?

Simple example

Removing repetitions from Array using the class Set

Set

Spread operator

Combining both

More readable conditional with Array.includes()

Using `or` operator

Using `Array.includes()`

Works with `NaN`

Your first Firebase Function

Create a project

Init a folder

Create a function

Deploy

DEV Community: Gabriel Rufino

Reverse switch?

A creative way to have required arguments in JavaScript

How I made my own file compressor using Node.js

Compression command

Decompression command

Repository

gabrielrufino / npacker

🗜️ Compressor de arquivos feito em Node.js

1. Creating the CLI

2. Getting the arguments

3. Compressing files

4. Decompressing files

Convertendo Callbacks para Promises no Node.js

Converting Callbacks to Promise approach on Node.js

Commander.js no meu YouTube

Share files on React Native

Install React Native Share

One more step for iOS

Share a file

Simple snippet to shuffle array

The algorithm

Example

How to make your express API more secure with helmet

What is the Helmet?

Simple example

Removing repetitions from Array using the class Set

Set

Spread operator

Combining both

More readable conditional with Array.includes()

Using or operator

Using Array.includes()

Works with NaN

Your first Firebase Function

Create a project

Init a folder

Create a function

Deploy

Using `or` operator

Using `Array.includes()`

Works with `NaN`