DEV Community: Osumgba Chiamaka

JavaScript Truthy and Falsy Values

Osumgba Chiamaka — Sat, 22 Aug 2020 17:44:55 +0000

Truthy and falsy values are misunderstood by lots of people to mean only values that have true or false as their values. In this article you would get to understand the difference between these two concepts.

Prerequisite

Basic Knowledge of JavaScript

True and False Variable Values

    let a = false
    let b = true

In Javascript you can assign true or false to a variable. The variables in the sample code above have true or false assigned to them. So wherever you call this variables, either true or false will be displayed unless the are re-assigned.
Follow me, let do some coding experiments.

e.g 1

    let a = false
    console.log(a)
    console.log(Boolean(a))

e.g 2

    let a = 'false'
    console.log(a)
    console.log(Boolean(a))

In e.g 1 you get

    false
    false

In e.g 2 you get

    false
    true

A value being truthy or falsy goes beyond having true or false as it's value. In this article true/false values means values that have either true/false values assigned to them. Then what does it mean for variables to be truthy or falsy.

Truthy and Falsy Values

Falsy Values

Falsy values are values that JavaScript's built-in type coercion converts to false or in a Boolean context are considered false. In simple terms we could say, variables that do not have values or do not exist but it’s more than that. Below are a list of all falsy values

false
0 Both positive and negative
0n BigInt, when used as a boolean, follows the same rule as a Number
''
null
undefined
NaN

    let a = false
    let b = 0
    let c = -0
    let d = 0n
    let e = ''
    let f = null
    let g = undefined
    let h = NaN
    console.log(Boolean (a))
    console.log(Boolean (b))
    console.log(Boolean (c))
    console.log(Boolean (d))
    console.log(Boolean (e))
    console.log(Boolean (f))
    console.log(Boolean (g))
    console.log(Boolean (h))

The above shows that all the above are falsy. In your JavaScript algorithm if you are checking and using truthy/falsy values, then make sure that you are not using any of the falsy values in your if algorithm.

e.g The sample code below is an algorithm to check if a variable is a number or not a number.

    // using the variables you have declared above => a, b, c, d, e, f, g, h
    const printType = (value) => {
        if (!value){
            return 'does not exist, it is falsy'
        }
        return Number.isInteger(value) ? `${value} is a number` : `${value} is a not a number`
    }
    console.log(printType(a))

The above code will always return does not exist, it is falsy as long as it evaluates the value to be falsy in this case it includes both 0 and '' which you might want to use in your algorithm. 0 is a number and should return 0 is a number, but because it's falsy and we are checking for falsy values in our code, it won't be evaluated that way, same goes for ''.

The block of code below checks if a value is falsy. It will return true if the value is falsy, so anything inside this block of code will be executed as long as the value is falsy.

    if (!value){
          ...
      }

If your code makes use of falsy/truthy values, it saves you the stress of having to check for undefined, null, NaN individually.

e.g
Instead of

    if (a == false) // ...
    // runs if a is false, 0, -0, 0n, '', or []
    // where [] should be truthy not falsy

Use

    if (!a) // ...
    // runs if a is false, 0, -0, 0n, '', NaN, null or undefined

Truthy Values

Anything asides what’s mentioned above is truthy. Simply any variable with a value is truthy.
Below are some truthy values

true
{} An object (whether empty or not)
[] An array (whether empty or not)
25 Numbers (whether positive or negative)
'true' Non empty strings
'false' Non empty strings
new Date() Date object
12n BigInt, when used as a boolean, follows the same rule as a Number
Infinity

Conclusion

Hope you enjoyed the article. Truthy or Falsy values can be confusing, hope this article makes it clearer.

You can find me on Twitter, let's connect.

Tenary Operators in JavaScript, Should I?

Osumgba Chiamaka — Thu, 20 Aug 2020 20:55:42 +0000

Tenary operators are said to replace the if-else statements. When and how should tenary operators be used? In this article we would learn what tenary operators are and how it can be used.

Prerequisite

Basic JavaScript understanding

Tenary operators

Operators are used to assign, compare, evaluate one, two or more operands. We have different types of operators in JavaScript. These include comparison, arithmetic, logical, tenary, etc.
Tenary operators have 3 operands and are often used as a shorthand for if statement. Tenary operators are represented with ?:

Let’s retrace out steps back to our if-else statement.

    if (condition) {
      expressionIfTrue
    } else {
      expressionIfFalse
    }

The if-else statement takes a condition which will evaluate to be either truthy or falsy. The if-else statement above can be rewritten with tenary operators.

Syntax

    condition ? <expressionIfTrue> : <expressionIfFalse>

e.g

The first operand is the condition to be evaluated. it’s like asking a question - age > 18 ?.
If the condition evaluates to be truthy the second operand after ? is executed, if the condition evaluates to be falsy the third operand after : is executed. Some falsy values includes, false, null, NaN, 0, an empty string (""), and undefined.

Tenary operators present a very concise way to write your if-else statements, but should this replace your if-else statements in a codebase. Though they can be used interchangeable, tenary operators return a value while if-else do not because tenary operator is an expression while if-else is a statement.

Nested Tenary operators

Similar to the multiple if-else statement, we can chain our tenary operator to evaluate multiple conditions.

    let books
    if (booksTitles.includes(title)) {
        books = booksTitles
    }
    else if (!title) {
        books = {}
    }
    else {
        books = booksTitles.concat(title)
    }

    const books = booksTitles.includes(title) ? booksTitles
        : !title ? {}
        : booksTitles.concat(title)

Tenary operators when used in a codebase can look shorter.

Should Tenary replace if-else ?

Readable codes

Tenary operators are a good replacement for one line if-else statement. Chained or nested tenary on the other hand can get confusing as the condition continues to grow. If you must use nested tenary, formatting is very important.

    return age > 10 ? 'teenager' : age >= 18 ? 'adult' : 'child'

    return age > 10 ? 'teenager'
      : age >= 18 ? 'adult'
      : 'child'

Debugging

Nested or chained tenary operators are slightly difficult to read and debug because you can not add break points on each sub expression. The sample code below is easier for a debugger, to isolate each break point.

    if (age > 10) {
      return 'teenager'
    }
    else if (age >= 18) {
      return 'adult'
    }
    else {
      return 'child'
    }

Conclusion

The decision to use tenary operators is up to you and your team. Because tenary operators look shorter, this shouldn’t be the reason to replace your if-else statements entirely with tenary operators most especially nested if-else statement. While working in a team, do not write codes that will take your team members hours just to understand, thus making debugging harder.

I use tenary and I love it especially when it’s one line if-else statement. Always remember that "shorter codes does not equal cleaner codes"

I hope you enjoyed this post. You can find me on Twitter, let's connect.

Debug like a PRO (Debugger in VsCode) - Series 1

Osumgba Chiamaka — Fri, 14 Aug 2020 20:37:58 +0000

Debugging is an everyday task when it comes to software development. Whether you are working in a team, working alone or contributing to open source projects, we all encounter bugs. These bugs can be caused by syntax errors, wrong algorithm, unterminated loops, etc. To fix these bugs you need to find them first, and this entire process is called Debugging.

In this article you are going to learn how to debug your code directly in Visual Studio Code. We would be using a JavaScript application for our example.

Prerequisites

Visual Studio Code
Node.js
nodemon (optional but will be used in this tutorial)

Visual Studio Code

Visual Studio Code has an inbuilt tool to help you debug your application directly from your editor.

The debugger icon in Visual Studio Code enables you to launch or attach to your running apps and debug with break points, call stacks, and an interactive console.

Let’s get it up and running.

Configurations

Method 1 - Run and Debug

Image a)

If the opened tab on your Visual Studio Code is not a debuggable file, click on Open a file and select the file you want to debug.

Image b)

Opened tab is a debuggable file. I will be debugging a JavaScript file that removes campaigns with expired dates from a list of ongoing campaigns. You can find the code here, feel free to clone and follow along.

Add Break Points and click on Run and Debug as shown in the image above, this will pop up a window for you to select how you want to run your application.

The image below tries to explain how to debug your application. When you run the debugger, you can use break points to explore what is happening in your code. You also have the ability to hover over the variables in your application to see if the hold the intended value.

With this method, you will always need to click on Run and Debug to start debugging.

Method 2 - Configure a launch.json file

Follow along as I show you how to create a launch.json file and configure it to tell Visual Studio Code how to debug your application. The launch.json file is saved in a folder called .vscode. You can create this file yourself or auto-create it with the steps below.

Use any of the steps below

Click on create a launch.json file
Select Run from the menu bar and then select Add Configurations

Using any method above, a pop-up window will appear. Because you want to debug your application directly in Visual Studio Code without opening chrome, select Node.js.

Your launch.json file should look like the the image below. Click on Add Configuration.

Let’s add a nodemon configuration so we do not have to click on the debug icon whenever we make changes to our file.

or simply copy the code below into your launch.json file

    {
      "version": "0.2.0",
        "configurations": [
            {
                "console": "integratedTerminal",
                "internalConsoleOptions": "neverOpen",
                "name": "nodemon",
                "program": "${workspaceFolder}/index.js",
                "request": "launch",
                "restart": true,
                "runtimeExecutable": "nodemon",
                "skipFiles": [
                    "<node_internals>/**"
                ],
                "type": "pwa-node"
            },
            {
                "type": "node",
                "request": "launch",
                "name": "Launch Program",
                "skipFiles": [
                    "<node_internals>/**"
                ],
                "program": "${workspaceFolder}/index.js"
            }
        ]
    }

To start the debugger, click on the debugger icon, select how you want to start the debugger. We will select nodemon for this tutorial.

If your terminal looks like the image below, then voilà we have successfully started our debugger. Feel free to add break points, console.log, etc and start debugging. Notice that if you make changes to your code, it auto-restarts the debugger.

Sneak peek

you can see a log of what is happening in your application by simply typing node.index.js or nodemon index.js to enable auto-restart when changes are detected in the file debugged.

Note: This only logs changes to your terminal if you used console.log. You won’t have that full debugging capabilities, like break points, watch, etc.

Conclusion

Your debugger is up and running. In the next series we will explore other ways to debug your code with easy.

I hope you enjoyed this post. You can find me on Twitter, let's connect.

How to Build an API With Nodejs, Expressjs and Google Sheet - Series 2

Osumgba Chiamaka — Sat, 08 Aug 2020 10:33:59 +0000

How to Build an API With Nodejs, Expressjs and Google Sheet - Series 2

Welcome back to the second series of our article on building an API with Nodejs, Expressjs and Google Sheet. In the previous article we initialized our project, authorised our application to use the Google Sheet API, created our route and controllers, and read data directly from Google Sheet into our application.

If you’ve not read the previous article, do well to check it out here - How to Build an API With Nodejs, Expressjs and Google Sheet - Series 1

In this article, I’ll be working you through the process of writing to Google Sheet from a Nodejs application.

Prerequisites

Postman

While continuing this article because we want everyone to catchup with what we have already done, we would consider 2 types of applications

I want to write to and read from Google Sheet
I have no business retrieving from Google Sheet, I only want to write to Google Sheet

I want to write to and read from Google Sheet

Follow all the steps in Series 1 and the follow along as we create our post route/controller

I have no business retrieving from Google Sheet, I only want to write to Google Sheet

If your application only writes to Google Sheet, follow the steps below

Step 1)

In Series 1 follow all the steps under Enabling Google Sheet API to authorise your application to use the Google Sheet API only change your redirect URI to http://localhost:3000/v1/update/users

Step 2)

Our folder structure will look like this

Step 3)

Follow all steps in Series 1 to create and start your server. Server should be running on http://localhost:3000

Step 4) Follow the steps in Series 1 to create routes.

Here we will add a get route for authentication and after delete it as we will no longer need it.

    const express = require('express')
    const router = express.Router()
    const { saveUsers } = require('../controllers/saveToSheet')

    router.get('/v1/update/users', saveUsers)
    router.post('/v1/update/users', saveUsers)

    module.exports = router

Step 4) Create your controller

Authenticate application

Add the code below to your saveToSheet.js file

    const authentication = require('../google/index')
      const { google } = require('googleapis')

      exports.saveUsers = (req, res) => {
      authentication.authenticated()
        .then((auth) => {
          res.status(200)
          .json('Working')
        })
        .catch(err => {
          res.status(401)
          .json(`you know wetin happen, ${err}`)
        })
    }

Go back to Series 1 and complete the steps needed to authenticate and download your token.json file.
If your browser shows Working, hurray we are have successfully authorised our application to use Google Sheet API.

Delete router.get('/v1/update/users', saveUsers) we do not need it again.

Create our POST controller

Let’s create a function to save our data to Google Sheet in saveToSheet.js. saveToSheet.js should look like this

    const authentication = require('../google/index')
    const { google } = require('googleapis')
    const sheets = google.sheets('v4')
    const saveToSheet = async (auth, data) => {
        const request = {
          spreadsheetId: '1_c4TS8WO0VqX336OauvYaVlxRzuEkaZ50hJf6yQxZok',
          range: 'new users!A1:B',
          valueInputOption: 'USER_ENTERED',
          insertDataOption: 'INSERT_ROWS',
          resource: {
            values: data // data to save to sheet
          },
          auth: auth
        }
        try {
          const response = (await sheets.spreadsheets.values.append(request)).data
          // response return an object with the spreadsheetId, tableRange and all columns updated
          // you can use this response in your application however you so desire
          return 'Success - Google Sheet Updated'
        } catch (err) {
          return `${err}` //returns only the error object
        }
    }

    exports.saveUsers = (req, res) => {
      const data = [['amaka', 'obinna'], ['uche']] // data to save to Google Sheet
        authentication.authenticated()
        .then((auth) => {
            saveToSheet(auth, data)
            .then(resp => {
                res.status(200).
                json({
                message: resp
                })
            })
            .catch(err=> {
                res.status(404).
                json({
                error: `i no gree save data to sheet, ${err}`
                })
            })
        })
        .catch(err => {
            res.status(401)
            .json(`you know wetin happen, ${err}`)
        })
    }

In the code snippet above, notice we didn’t create a new promise as did in Series 1 but we used async and await to enable asynchronous, promise-based behaviour.

Google Sheet API accepts data in form of arrays.

    const data = [['amaka', '2 lokoja'], ['uche']]

This data we are saving to Google Sheet can be retrieved from the UI, but here we created it ourselves.
Open Postman, let test our post route

The image above shows what the response from Google Sheet API looks like after successfully updating the Sheet. You can use this data however you so desire in your application.

You can also enter the data to save to Sheet directly here in Postman, as shown in the image below. In your application, use req to retrieve data entered in Postman and then you’ll destructure to retrieve the data to save to Google Sheet.

Each time you save to Google Sheet, a new row is added below.

Congratulations

We have completed our REST API built with Nodejs, Expressjs and Google Sheet API, to read from Sheet and write to Sheet.
Thanks and see you next time.

Follow me on twitter let's connect
View full application on Github. Feel free to fork and star for later consumption

How to Build an API With Nodejs, Expressjs and Google Sheet - Series 1

Osumgba Chiamaka — Tue, 04 Aug 2020 23:11:59 +0000

Got a bunch of work done with spreadsheets and you are wondering how to integrate that data into your Nodejs application without moving it to a relational or NoSql database?

That’s possible and you’ll learn how to get it done in this article.

Google sheet remains an important tool for small businesses today. I know a couple of startups that started all from a Google Sheet until they found a need to scale before they created an app and migrated to a real database.

Though there has been a lot of reasons given as to why an actual backend database should be used instead of Google Sheet, reasons ranging from accidentally deleting data or sheet, lack of static identifiers on records, etc.

However, this article is not to deliberate the advantages of sheet over an actual backend database or vice versa, some projects require you to read data from sheet and sync into your application/database or write to sheet for managerial use.

Most small projects might not necessarily require a regular database and can be managed with Google Sheet.

In this article, I will be walking you through the process of reading from Google Sheet using Nodejs.

Prerequisites

For this tutorial we are going to create a rest API that reads and writes to Google Sheet.
Before you begin this tutorial you'll need the following:

N odejs and NPM installed
A web browser
A google account to enable authentication

Let’s get started…

Enabling Google Sheet API

Google sheet API is google's API that enable developers programatically read, write and format google sheet from their applications.

Step 1). Download your credentials.json
Follow this link and click on the “Enable the Google Sheets API” button to download your credentials.json file

You’ll be required to enter the name of your project as shown below:

Select web server **** as the type of application you are integrating with and click on *API Console* to configure your redirect URI

Select credentials from your console and edit your OAuth client

Authorise redirect URI and save. (This URI is where you will be redirected to after authenticating with Google. This should be an absolute path)

and finally, download your credentials

Note: This tutorial will assume the name of your downloaded credential as *credentials.json*, you can rename yours to whatever name you desire to use and make sure you replace credentials.json file to your desired file name as used in the article.

Step2). Install the Required NodeJS Packages

npm install googleapis@39 express http --save
npm install nodemon --save-dev

Creating our API

Folder structure

Our folder structure will look like this

The server.js file contains the code to start and run our server
Add the code below to your server.js file.



    const PORT = process.env.PORT || 3000;
    const http = require('http');
    const app = require('./routes/app')
    const server = http.createServer(app);
    server.listen(PORT)

Inside your routes folder, create app.js and add the code below



    const express = require('express');
    const indexRoute = require('../routes/index')
    const app = express();
    app.use((req, res, next) => {
      res.setHeader('Access-Control-Allow-Origin', '*');
      res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content, Accept, Content-Type, Authorization');
      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
      next();
    });
    app.use('/', indexRoute);
    module.exports = app;

Start your server by typing nodemon in your terminal, this is same as typing node server.js. The difference is you’ll have to always stop and restart your server whenever you make changes to your code if you use node server.js. But with Nodemon, it automatically restarts your application when a file changes in the directory. Nodemon knows to start server.js because it was specified in my package.json file "main": "server.js". Your server should be running on http://localhost:3000

Copy *credentials.json* into the google folder.
Below is the code that creates a class module to authenticate and authorise our application to use the sheet api.



    const fs = require('fs')
    const readline = require('readline')
    const {google} = require('googleapis')
    // If modifying these scopes, delete token.json.
    // SCOPE gives additional rules to the sheet, you can restrict rule to readonly or give full access
    const SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
    // The file token.json stores the user's access and refresh tokens, and is
    // created automatically when the authorization flow completes for the first
    // time.
    // The path were your token.json file is saved, depends totally on you.
    const TOKEN_PATH = './google/token.json'
    class Authentication {
      authenticated(){
        return new Promise((success, failed) => {
          // Load client secrets from a local file.
            let credentials = this.getClientSecret()
            let authorized = this.authorize(credentials)
            authorized.then(success, failed)
          })

      }
      getClientSecret(){
        return require('./credentials.json')
      }

      /**
       * Create an OAuth2 client with the given credentials, and then execute the
       * given callback function.
       * @param {Object} credentials The authorization client credentials.
       * @param {function} callback The callback to call with the authorized client.
       */
      authorize(credentials) {
        const {client_secret, client_id, redirect_uris} = credentials.web
        const oAuth2Client = new google.auth.OAuth2(
            client_id, client_secret, redirect_uris[0])

            return new Promise((success, failed) => {
              // Check if we have previously stored a token.
              fs.readFile(TOKEN_PATH, (err, token) => {
                if (err) {
                  this.getNewToken(oAuth2Client)
                  .then((oAuth2ClientNew) => {
                    success(oAuth2ClientNew)
                  }, (err) => {
                    failed(err)
                  })
                } else {
                  oAuth2Client.setCredentials(JSON.parse(token))
                  success(oAuth2Client)
                }    
              })
            })
        }

      /**
       * Get and store new token after prompting for user authorization, and then
       * execute the given callback with the authorized OAuth2 client.
       * @param {google.auth.OAuth2} oAuth2Client The OAuth2 client to get token for.
       * @param {getEventsCallback} callback The callback for the authorized client.
       */
      getNewToken(oAuth2Client, callback) {
        return new Promise((success, failed) => {
          const authUrl = oAuth2Client.generateAuthUrl({
            access_type: 'offline',
            scope: SCOPES,
          })
          console.log('Authorize this app by visiting this url:', authUrl)
          const rl = readline.createInterface({
            input: process.stdin,
            output: process.stdout,
          })
          rl.question('Enter the code from that page here: ', (code) => {
            rl.close()
            oAuth2Client.getToken(code, (err, token) => {
              if (err) {
                failed('Error while trying to retrieve access token', err)
              } 
              oAuth2Client.setCredentials(token)
              // Save the token for later program executions
              fs.writeFile(TOKEN_PATH, JSON.stringify(token), (err) => {
                if (err) return console.error(err)
                console.log('Token stored to', TOKEN_PATH)
              })
              success(oAuth2Client)
            })
          })
        })
      }
    }

    module.exports = new Authentication

Create index.js file inside the google folder and paste the code above(its commented to explain the codebase.

Create our routes

Inside our routes folder, create index.js file and add the code below. This should contain all the routes for this application.



    const express = require('express')
    const router = express.Router()
    const { retrieveUsers } = require('../controllers/retrieveFromSheet')
    const { saveUsers } = require('../controllers/saveToSheet')

    router.get('/v1/users', retrieveUsers)
    router.post('/v1/update/users', saveUsers)

    module.exports = router

Create our controllers

Inside our controllers folder, create *retrieveFromSheet.js* and saveToSheet.js

Authenticate application

Let's give our application access to Sheet and afterwards download token.json.

Add this code to retrieveFromSheet.js



    const authentication = require('../google/index')
    const { google } = require('googleapis')

    exports.retrieveUsers = (req, res) => {
    authentication.authenticated()
      .then((auth) => {
        res.status(200)
        .json('Working')
      })
      .catch(err => {
        res.status(401)
        .json(`you know wetin happen, ${err}`)
      })
    }

open *localhost:3000/v1/users* on your browser, then go back to your terminal

Open the url in your terminal. Look at the link critically, you'll see that it appends the redirect_uri you configured in your google developer console.

Give all needed access to the application and continue, it should redirect you to your redirect_uri with a code appended to the path.

copy and paste the code into your terminal and hit enter. Open the google folder you should see *token.json, navigate back to *http://localhost:3000/v1/users** and if all goes well you should see

Let's add a function to retrieve data from our sheet



    const getFromSheet =  (auth) => {
      return new Promise((success, failed) => {
        const sheets = google.sheets({version: 'v4', auth})
        sheets.spreadsheets.values.get({
          spreadsheetId: '1_c4TS8WO0VqX336OauvYaVlxRzuEkaZ50hJf6yQxZok',
          range: 'approved!A:D',
        }, (err, res) => {
          if (err){
            return failed(err) 
          }
          const rows = res.data.values
          success(rows)
        })
      })
    }

Call getFromSheet inside retrieveUsers



    getFromSheet(auth).then((response) => {
      res.status(200).
      json(response)
    })
    .catch(err => {
      console.log(`i no gree fetch data from sheet, ${err}`)
    })

res returns data from the sheet including status code, headers, url, method type, etc but our concern is in res.data.values.

Refresh *localhost:3000/v1/users* and our retrieved users should be an array of arrays.

Now let's format our retrieved users to look more pretty.

*retrieveFromSheet.js* should look like this



    const authentication = require('../google/index')
    const { google } = require('googleapis')
    const getFromSheet =  (auth) => {
      return new Promise((success, failed) => {
        const sheets = google.sheets({version: 'v4', auth})
        sheets.spreadsheets.values.get({
          spreadsheetId: '1_c4TS8WO0VqX336OauvYaVlxRzuEkaZ50hJf6yQxZok',
          range: 'approved!A:D',
        }, (err, res) => {
          if (err){
            return failed(err) 
          }
          const rows = res.data.values

          // format retrieved data
          if (rows.length) {
              var rowHead = rows.shift()
              const formatedUsers = rows.map((row) => {
                  return rowHead.reduce( (obj, key, i) => {
                    obj[key] = row[i]
                    return obj
                  }, {})
              })
              success(formatedUsers)   
          } else {
            failed('No data found.')
          }
        })
      })
    }
    exports.retrieveUsers = (req, res) => {
      authentication.authenticated()
      .then((auth) => {
        getFromSheet(auth).then((response) => {
          res.status(200)
          .json({
            message: response
          })
        })
        .catch(err => {
          res.status(404)
          .json({
            error: `i no gree fetch data from sheet, ${err}`
          })
        })
      })
      .catch(err => {
        res.status(401)
        .json({
          error: `you know wetin happen, ${err}`
        })
      })
    }

users should look like this

Let’s go over the code base again in bits and pieces, to have a better understanding.



<span class="nx">sheets</span><span class="p">.</span><span class="nx">spreadsheets</span><span class="p">.</span><span class="nx">values</span><span class="p">.</span><span class="kd">get</span><span class="p">({</span>
      <span class="na">spreadsheetId</span><span class="p">:</span> <span class="dl">'</span><span class="s1">1_c4TS8WO0VqX336OauvYaVlxRzuEkaZ50hJf6yQxZok</span><span class="dl">'</span><span class="p">,</span>
      <span class="na">range</span><span class="p">:</span> <span class="dl">'</span><span class="s1">approved!A:D</span><span class="dl">'</span><span class="p">,</span>
    <span class="p">}</span>

Range

A range can be a single cell in a sheet or a group of adjacent cells in a sheet. For e.g in our code above we specified a range - approved!A:D. *approved* is pointing to the name of the sheet as shown in the image below.

The entire sheet is called a workbook

!A:D means starting from column A to column D.
!B2:D3 means start from column B row 2 to column D row 3.

values.get is used to retrieve values from a single range as shown in the example above.
values.batchGet is used to retrieve from multiple ranges at same time.

To use batchGet, change your range to ranges: ['approved!B2:D3', 'approved!A1:C2'], it takes an array of different ranges. using batchGet, returned data is destructed from res.data.valueRanges.

spreadsheetId: '1_c4TS8WO0VqX336OauvYaVlxRzuEkaZ50hJf6yQxZok', spreadsheetId refers to the id of your workbook

Promises

Promises simply refers to the completion (or failure) of an asynchronous operation. A promise can only succeed or fail once.

Here we created a promise to return either a success or failed object



<span class="kd">const</span> <span class="nx">getFromSheet</span> <span class="o">=</span>  <span class="p">(</span><span class="nx">auth</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="p">{</span>
  <span class="k">return</span> <span class="k">new</span> <span class="nc">Promise</span><span class="p">((</span><span class="nx">success</span><span class="p">,</span> <span class="nx">failed</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="p">{</span>

Conclusion

The data we just retrieved from sheet can be served to our front end, used for analysis in our application or even saved to a real backend database if any. In my next article we would take a look at how to save to Google Sheet and more.

Follow me on twitter let's connect

DEV Community: Osumgba Chiamaka

JavaScript Truthy and Falsy Values

Prerequisite

True and False Variable Values

Truthy and Falsy Values

Falsy Values

Truthy Values

Conclusion

Tenary Operators in JavaScript, Should I?

Prerequisite

Tenary operators

Nested Tenary operators

Should Tenary replace if-else ?

Readable codes

Debugging

Conclusion

Debug like a PRO (Debugger in VsCode) - Series 1

Prerequisites

Visual Studio Code

Configurations

Method 1 - Run and Debug

Image a)

Image b)

Method 2 - Configure a launch.json file

Sneak peek

Conclusion

How to Build an API With Nodejs, Expressjs and Google Sheet - Series 2

How to Build an API With Nodejs, Expressjs and Google Sheet - Series 2

Prerequisites

I want to write to and read from Google Sheet

I have no business retrieving from Google Sheet, I only want to write to Google Sheet

Step 1)

Step 2)

Step 3)

Step 4) Follow the steps in Series 1 to create routes.

Step 4) Create your controller

Authenticate application

Create our POST controller

Congratulations

Further Reading

How to Build an API With Nodejs, Expressjs and Google Sheet - Series 1

Prerequisites

Enabling Google Sheet API

Creating our API

Folder structure

Create our routes

Create our controllers

Authenticate application

Range

Promises

Conclusion