Arrays are list-like objects whose prototype has methods to perform traversal and mutation operations. Neither the length of a JavaScript array nor the types of its elements are fixed. Since an array’s length can change at any time, and data can be stored at non-contiguous locations in the array, JavaScript arrays are not guaranteed to be dense; this depends on how the programmer chooses to use them.

Following are the important JavaScript Array Functions

1. Array.prototype.map()

The map() method creates a new array populated with the results of calling a provided function on every element in the calling array.

const array1 = [1, 4, 9, 16];

// pass a function to map
const map1 = array1.map(x => x * 2);

console.log(map1);
// expected output: Array [2, 8, 18, 32]

2. Array.prototype.find()

The find() method returns the value of the first element in the provided array that satisfies the provided testing function.

const array1 = [5, 12, 8, 130, 44];

const found = array1.find(element => element > 10);

console.log(found);
// expected output: 12

3. Array.prototype.findIndex()

The findIndex() method returns the index of the first element in the array that satisfies the provided testing function. Otherwise, it returns -1, indicating that no element passed the test.

const array1 = [5, 12, 8, 130, 44];

const isLargeNumber = (element) => element > 13;

console.log(array1.findIndex(isLargeNumber));
// expected output: 3

4. Array.prototype.filter()

The filter() method creates a new array with all elements that pass the test implemented by the provided function.

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

5. Array.prototype.reduce()

The reduce() method executes a reducer function (that you provide) on each element of the array, resulting in single output value.

const array1 = [1, 2, 3, 4];
const reducer = (accumulator, currentValue) => accumulator + currentValue;

// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));
// expected output: 10

// 5 + 1 + 2 + 3 + 4
console.log(array1.reduce(reducer, 5));
// expected output: 15

The reducer function takes four arguments:

1. Accumulator (acc)
2. Current Value (cur)
3. Current Index (idx)
4. Source Array (src)

Your reducer function’s returned value is assigned to the accumulator, whose value is remembered across each iteration throughout the array, and ultimately becomes the final, single resulting value.

6. Array.prototype.concat()

The concat() method is used to merge two or more arrays. This method does not change the existing arrays, but instead returns a new array.

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);

console.log(array3);
// expected output: Array ["a", "b", "c", "d", "e", "f"]

7. Array.prototype.slice()

The slice() method returns a shallow copy of a portion of an array into a new array object selected from start to end (end not included) where start and end represent the index of items in that array. The original array will not be modified.

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

8. Array.prototype.splice()

The splice() method changes the contents of an array by removing or replacing existing elements and/or adding new elements in place.

const months = ['Jan', 'March', 'April', 'June'];

months.splice(1, 0, 'Feb');
// inserts at index 1

console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "June"]

months.splice(4, 1, 'May');
// replaces 1 element at index 4

console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "May"]

Syntax

let arrDeletedItems = array.splice(start[, deleteCount[, item1[, item2[, ...]]]])

Parameters

startThe index at which to start changing the array.

deleteCount | Optional — An integer indicating the number of elements in the array to remove from start. If deleteCount is 0 or negative, no elements are removed. In this case, you should specify at least one new element

item1, item2, ...| Optional — The elements to add to the array, beginning from start. If you do not specify any elements, splice() will only remove elements from the array.

Return value

An array containing the deleted elements. If only one element is removed, an array of one element is returned. If no elements are removed, an empty array is returned.

Note — If the specified number of elements to insert differs from the number of elements being removed, the array’s length will be changed.

Let’s deep dive to understand splice() method better —

1. Remove 0 (zero) elements before index 2, and insert “drum”

let myFish = ['angel', 'clown', 'mandarin', 'sturgeon']
let removed = myFish.splice(2, 0, 'drum')

// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"] 
// removed is [], no elements removed

2. Remove 0 (zero) elements before index 2, and insert “drum” and “guitar”

let myFish = ['angel', 'clown', 'mandarin', 'sturgeon']
let removed = myFish.splice(2, 0, 'drum', 'guitar')

// myFish is ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"] 
// removed is [], no elements removed

3. Remove 1 element at index 3

let myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon']
let removed = myFish.splice(3, 1)

// myFish is ["angel", "clown", "drum", "sturgeon"]
// removed is ["mandarin"]

4. Remove 1 element at index 2, and insert “trumpet”

let myFish = ['angel', 'clown', 'drum', 'sturgeon']
let removed = myFish.splice(2, 1, 'trumpet')

// myFish is ["angel", "clown", "trumpet", "sturgeon"]
// removed is ["drum"]

5. Remove 2 elements from index 0, and insert “parrot”, “anemone” and “blue”

let myFish = ['angel', 'clown', 'trumpet', 'sturgeon']
let removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue')

// myFish is ["parrot", "anemone", "blue", "trumpet", "sturgeon"] 
// removed is ["angel", "clown"]

6. Remove 2 elements from index 2

let myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon']
let removed = myFish.splice(2, 2)

// myFish is ["parrot", "anemone", "sturgeon"] 
// removed is ["blue", "trumpet"]

7. Remove 1 element from index -2

let myFish = ['angel', 'clown', 'mandarin', 'sturgeon']
let removed = myFish.splice(-2, 1)
// -ve index means start indexing from end of the array

// myFish is ["angel", "clown", "sturgeon"] 
// removed is ["mandarin"]

8. Remove all elements from index 2

let myFish = ['angel', 'clown', 'mandarin', 'sturgeon']
let removed = myFish.splice(2)

// myFish is ["angel", "clown"]
// removed is ["mandarin", "sturgeon"]

Hope these methods will be helpful for you to improve your code.

8 Important Array Functions Every JavaScript Developer Must Know was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

JavaScript can send network requests to the server and load new information whenever it’s needed. For example, we can use a network request to submit an order, load user information, receive the latest updates from the server, etc. …And all of that without reloading the page!

The Fetch API provides a fetch() method defined on the window object that provides an easy, logical way to fetch resources asynchronously across the network. It provides a JavaScript interface for accessing and manipulating parts of the HTTP pipeline (requests and responses).

A basic fetch request is really simple to set up. Have a look at the following code:

fetch(’http://example.com/task.json’)
  .then(response => response.json())
  .then(data => console.log(data))

The simplest use of fetch() takes one argument — the path to the resource you want to fetch — and returns a promise that resolves to the response to that request (successful or not). This is just an HTTP response, not the actual JSON. If you use fetch() there is a two-step process when handing JSON data. The first is to make the actual request and then the second is to call the json() method on the response. You can optionally pass an init options object as second argument (used to configure req headers for other types of HTTP requests such as PUT, POST, DELETE)

Difference between fetch() Vs jQuery.ajax()

Fetch is similar to XMLHttpRequest, but the new API provides a more powerful and flexible feature set. The fetch specification differs from jQuery.ajax() in these ways:

• The Promise returned from fetch() won’t reject HTTP error status even if the response is an HTTP 404 or 500. Instead, it will resolve normally (with ok status set to false), and it will only reject on network failure or if anything prevented the request from completing.
• fetch won’t send cookies, unless you set the credentials init option.

Axios is a Javascript library used to make HTTP requests from node.js or XMLHttpRequests from the browser and it supports the Promise API that is native to JS ES6. It can be used to intercept HTTP requests and responses and enables client-side protection against XSRF. It also has the ability to cancel requests.

Installation

You need to install axios using:

$ npm install axios

Or a content delivery network

<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

An axios request is simple to set up. Have a look at the following code:

axios.get('https://api.tasks.com/v1/artists/0OdUWJ0sBjDrqHygGUX')
  .then(function(response) {
       console.log(response)
  })
  .catch(function(error) {
       console.log(error)
  })

So by using axios you can cut out the middle step of passing the results of the http request to the .json() method. Axios just returns the data object you would expect.

Difference between fetch() Vs axios

• Fetch API is built into the window object, and therefore doesn’t need to be installed as a dependency or imported in client-side code.
• Axios needs to be installed as a dependency. However, it automatically transforms JSON data for you, thereby avoiding the two-step process of making a .fetch() request and then a second call to the .json() method on the response.
• With Axios, any kind of error you get with the http request will be handled and the .catch() block is executed.
• Axios allows cancelling request and request timeout while fetch does not.
• Axios has wide browser support, where as Fetch only supports Chrome 42+, Firefox 39+, Edge 14+, and Safari 10.1+ (This is known as Backward Compatibilty).

The fetch() method is modern and versatile for getting http requests native in ES6, but by using third party libraries like Axios certain scenarios can be better handled.

I hope you now have better idea about basic usage of fetch() Vs axios Vs jQuery.ajax(). If you still have any confusions, let me know in comments.

Using Fetch Vs Axios.Js for Making HTTP Requests was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you’re getting started with Tableau — right after connecting your workbook to the data source, you should be able to figure out and understand whether you would need a Tableau Extract or a Live connection (at times both though !). In this post, I’ll be giving you insights about Extracts Vs Live — Which one you should use and why, and what are the pros and cons of both.

So, Let’s get started!

What are Extracts?

Extracts are one of the most powerful but overlooked tools in Tableau’s arsenal. Tableau Data Extracts (TDEs) are compressed snapshots of data optimized for aggregation and loaded into system memory to be quickly recalled for visualization, accordingly. So, the database isn’t required to build your viz.

A TDE is a columnar store which means it stores values together within a column rather than a row. By only reading in the relevant data (columns) necessary to answer the question, the input and output necessary to query and aggregate data is largely decreased. Therefore, extracts are often faster (but not always!). To understand more about how TDE’s design makes it ideal for supporting analytics and data discovery, you can go through the below blog to know it’s architecture: https://www.tableau.com/about/blog/2014/7/understanding-tableau-data-extracts-part1

There are two options to refresh the data in the extract:

Full Extracts: A full extract rewrites the existing data extract in Tableau data Engine with a new file from the Tableau data source

Incremental Refresh: It will help to add new records that have been added since the last extract has been created. This can be particularly useful if your data extract is to be refreshed daily. You can do so by selecting the checkbox Incremental Refresh in the Extract Data Dialog box

What is a LIVE connection ?

The data source that contains a direct connection to underlying data, relies on a database for all queries and undergoes real-time updates is a live connection.

How to identify if you have created a TDE or LIVE connection ?

Below are the symbols that are used to represent TDE and LIVE connection:

After you have selected your data source, and chosen one of the options from LIVE and Extract in your Data Source tab, you can find the data source name with a symbol of TDE or LIVE connection in the upper left corner of Data pane in your Tableau sheet. This symbol denotes the TDE and LIVE connection. I have also attached the snapshots to know where you can check for these symbols.

When to use Extract and LIVE ?

In addition to choosing the data source in Tableau, you need to decide whether you want to use live or static data. In other words, do you want your analysis and visualizations to be based on the most current data that’s available, or do you want to use an extract that provides a snapshot of the results based on criteria that you select?

Here I have listed — Pros and Cons of both TDE and LIVE which will help you decide the connection based upon your business requirements:

Pros and Cons of TDE

Pros:

1. Speeds up the workbook through optimization — Because extracts are embedded within the workbook, they’re faster when you have complex visualizations with large data sets, filters, calculations. Also, where Custom SQL slows down performance, TDE can speed up the performance.
2. Offline — Your data source can be utilized when you’re offline and unable to connect to the data source. Eg: When you’re on a plane or in an area having a poor network connection, you can simply create an extract of your data and work on it if you don’t have a connection to your live data source.
3. Privacy — By hiding certain fields within your data source and then creating an extract, you can hide the fields that aren’t used, thereby ensuring data can only be viewed by the people intended.
4. Portability — A TDE can be bundled with Tableau visualizations in a packaged workbook for easy sharing and collaboration.
5. Reduce Load — Replacing a live connection to an OLTP database, or any database with a TDE reduces the load on the database that can result from heavy Tableau user traffic.
6. Filters — As you extract data into a Tableau Data Extract, you can begin the process of preparing your data for analysis. In the Extract options under Data > Extract, you’ll be prompted to add Filters to your data extract. While the data source may be very large, you may not need the entire dataset to complete the analysis required. Filters can help pare down a very large data source into only the essential records, thus creating a streamlined data sub-set. Smaller data extracts require less computing power.

Cons:

1. Snapshot: Because data is extracted from the data source, the data will remain the same unless it is refreshed.
2. Size/Structure: Extracts can become slow to refresh and query depending on the data structure. E.g: many columns and structures

Pros and Cons of Live Connection

Pros:

1. Real-time updates — As your viz is directly connected to the underlying data, this ensures data freshness.
2. When you need up-to-the-minute data — If things are changing so fast that you need to see them in real-time, you need a live connection to your data. All your operational dashboards can be hooked up directly to live data so you know when your plant is facing overutilization or when you’re experiencing peak demand.

Cons:

1. Databases are not always optimized for fast performance (unlike extracts) — As data queries go through the database, they can only as fast as the database itself. Accordingly, working with a live connection may be slow.
2. Other factors can affect speed — e.g. Poor network speed and network traffic can slow down your workbook.
3. Stress — Live connections, especially within complex workbooks, can stress some traditional databases.

Below I have summarized some of the points that would help you to compare both :

So, now the question is :

Which of the two is best and which one to choose?

And, the answer is BOTH!

Even better is when you don’t have to choose between in-memory and a live connection. Instead of looking for a solution that supports one or the other, look for one that supports choice. You should be able to switch back and forth between in-memory and live connections as needed.

• You want to use a sample of a massive data set to find trends and build your analysis. You bring a 5% sample of the data in-memory, explore it, and create a set of views you want to share. Then you switch to a live connection so your reports are working directly against all the data. Publish your views, and now your colleagues can interact with your analysis and drill down to the part of the data most relevant to their work.
• You’re flying to New York and want to do some analysis on the plane. You bring your entire data set, several million rows, into your local PC memory, and work with it offline. When you get to New York, you reconnect to the live data again. You’ve done your analysis offline and in-memory, but you are able to switch back to a live connection with a few clicks.

Because Tableau can now do analytics so swiftly and gives people the choice to connect directly to fast databases or use Tableau’s in-memory data engine, it has become much more powerful in respect of data exploration and data discovery. This leads to analytical insights that would most likely have been missed before.

— ROBIN BLOOR, Ph.D., FOUNDER OF THE BLOOR GROUP

Conclusion

With that I’ll say that it will majorly depend upon your business requirements for which kind of connection you’ll require after you develop your dashboard. With Tableau, you receive more options for deployment, data connections, and collaboration. Hence, you can always switch between your data connections to work according to the conditions prevailing around you which makes Tableau, the market leader in modern BI platforms, offering the greatest analytical breadth, depth, and flexibility.

I usually procrastinate a lot, but I promise I’ll post more stuff — tips, and tricks about Tableau in my upcoming Medium blogs. Till then keep reading! 😄

If you have any questions, you can ping me on my LinkedIn: https://www.linkedin.com/in/sonal-gupta-85169989/

I’ll be very much happy to answer any questions :)