Searching for a specific sequence of characters within an array

Question

Searching for a specific sequence of characters within an array

I have been working on a versatile function that can perform various tasks related to finding a specific value in a list or array. Below is the code I have come up with:

function findInArray(needle, arr, exact, sensitive) {
  if (needle && arr) {
    var hayLength = arr.length
    for (var i = 0; i < hayLength; i++) {
      if (arr[0].length >= 0) {var haystack = arr[i][0];}
      else {haystack = arr[i];}
      if (exact && sensitive && (haystack === needle)) {return i;}
      else if (exact && !(sensitive) && (haystack == needle)) {return i;}
      else if (!(exact) && sensitive && (haystack.toLowerCase().search(needle.toLowerCase()))>-1) {return i;}
      else if (!(exact) && !(sensitive) && haystack.search(needle)>-1) {return i;}
    }
  }
  return -1;
}

Although I believe the code can be optimized further, I am facing an issue with the third condition when attempting to ignore case sensitivity to match a string in a list. For example:

var arr = ["Partner1", "Partner2"]
var needle = "partner1"
var n = findInArray(needle, arr, true, false);

It returns -1.

I aim for this function to be able to work with both 1D and multidimensional lists and to find substrings (e.g. match "Google" and "Googler").

Answered: Drawing inspiration from responses by @NoobishPro and @tehhowch, the following optimized code resolves the sensitivity parameter efficiently:

function findInArray(needle, arr, exact, sensitive) {
  exact = exact !== false;
  sensitive = sensitive !== false;

  //Accounting for sensitivity parameter to enhance performance
  if (!sensitive) {
    needle = needle.toLowerCase();
  }

  //Determining array length
  var hayLength = arr.length;
  for (var i = 0; i < hayLength; i++) {
    //Setting haystack
    var haystack = arr[i];
    //Checking for nested arrays and handling them recursively
    if (haystack.constructor == Array) {
      return findInArray(needle, haystack, exact, sensitive);
    }

    //Performing additional lowercasing if sensitivity is disabled
    if (!sensitive) {
      haystack = haystack.toLowerCase();
    }

    //Handling different scenarios based on exact and sensitivity settings
    if (exact && sensitive && (haystack == needle)) {
      return i;
    } else if (exact & (haystack == needle)) {
      return i;
    } else if (!exact & (haystack.search(needle)) > -1) {
      return i;
    }
  }
  return -1;
}

javascript arrays multidimensional-array google-apps-script

Answer 1

Answer №1

LINK TO FUNCTIONAL JSFIDDLE

The reason for the issue with your recursion attempt was due to some errors in the code structure. Despite that, most of your code was well-written. Additionally, you overlooked implementing the toLowerCase() method in one instance.

The corrected code is as follows;

var arr = ["Partner1", "Partner2"]
var needle = "partner1"
var n = findInArray(needle, arr, true, false);
console.log(n);

function findInArray(needle, arr, exact, sensitive) {
  //Check if these attributes were even provided
  if (typeof needle != 'undefined' && typeof arr != 'undefined') {
    if (arr.length < 1) {
      return -1;
    }
    if (typeof exact == 'undefined') {
      //Ensuring it's always set. Defaults to false.
      exact = false;
    }
    if (sensitive == 'undefined') {
      //Ensuring it's always set. Defaults to false.
      sensitive = false;
    }
    //determining array length
    var hayLength = arr.length;
    for (var i = 0; i < hayLength; i++) {
      //Set haystack
      var haystack = arr[i];
      //Check if it's another array. If so, recursively call this function to go 1 level deeper.
      if (haystack.constructor == Array) {
        return findInArray(needle, haystack, exact, sensitive);
      }

      //Correction made to implement toLowerCase method on the last comparison
      if (exact && sensitive && (haystack === needle)) {
        return i;
      } else if (exact && !(sensitive) && (haystack.toLowerCase() == needle.toLowerCase())) {
        return i;
      } else if (!(exact) && sensitive && (haystack.search(needle)) > -1) {
        return i;
      } else if (!(exact) && !(sensitive) && haystack.toLowerCase().search(needle.toLowerCase()) > -1) {
        return i;
      }
    }
  }
  return -1;
}

Minor optimizations

I have also incorporated a few refinements to enhance the efficiency of the code. LINK TO OPTIMIZED JSFIDDLE

var arr = ["Partner1", "Partner2"]
var needle = "partner2"
var n = findInArray(needle, arr, true, false);
console.log(n);

function findInArray(needle, arr, exact, sensitive) {
  //Check if these attributes were even provided
  if (typeof needle != 'undefined' && typeof arr != 'undefined') {
    if (arr.length < 1) {
      return -1;
    }
    if (typeof exact == 'undefined') {
      //Ensuring it's always set. Defaults to false.
      exact = false;
    }
    if (sensitive == 'undefined') {
      //Ensuring it's always set. Defaults to false.
      sensitive = false;
    }

    //Handle sensitivity parameter for improved performance
    if (!sensitive) {
      needle = needle.toLowerCase();
    }

    //determine array length
    var hayLength = arr.length;
    for (var i = 0; i < hayLength; i++) {
      //Set haystack
      var haystack = arr[i];
      //Check if it's another array. If so, recursively call this function to go 1 level deeper.
      if (haystack.constructor == Array) {
        return findInArray(needle, haystack, exact, sensitive);
      }

      //Implementing a lowercase operation here to save on lowercase condition checks
      if (!sensitive) {
        haystack = haystack.toLowerCase();
      }

      //Simplified conditionals
      if (exact && sensitive && (haystack == needle)) {
        return i;
      } else if (exact & (haystack == needle)) {
        return i;
      } else if (!exact & (haystack.search(needle)) > -1) {
        return i;
      }
    }
  }
  return -1;
}

Answer 2

LINK TO FUNCTIONAL JSFIDDLE

The reason for the issue with your recursion attempt was due to some errors in the code structure. Despite that, most of your code was well-written. Additionally, you overlooked implementing the toLowerCase() method in one instance.

The corrected code is as follows;

var arr = ["Partner1", "Partner2"]
var needle = "partner1"
var n = findInArray(needle, arr, true, false);
console.log(n);

function findInArray(needle, arr, exact, sensitive) {
  //Check if these attributes were even provided
  if (typeof needle != 'undefined' && typeof arr != 'undefined') {
    if (arr.length < 1) {
      return -1;
    }
    if (typeof exact == 'undefined') {
      //Ensuring it's always set. Defaults to false.
      exact = false;
    }
    if (sensitive == 'undefined') {
      //Ensuring it's always set. Defaults to false.
      sensitive = false;
    }
    //determining array length
    var hayLength = arr.length;
    for (var i = 0; i < hayLength; i++) {
      //Set haystack
      var haystack = arr[i];
      //Check if it's another array. If so, recursively call this function to go 1 level deeper.
      if (haystack.constructor == Array) {
        return findInArray(needle, haystack, exact, sensitive);
      }

      //Correction made to implement toLowerCase method on the last comparison
      if (exact && sensitive && (haystack === needle)) {
        return i;
      } else if (exact && !(sensitive) && (haystack.toLowerCase() == needle.toLowerCase())) {
        return i;
      } else if (!(exact) && sensitive && (haystack.search(needle)) > -1) {
        return i;
      } else if (!(exact) && !(sensitive) && haystack.toLowerCase().search(needle.toLowerCase()) > -1) {
        return i;
      }
    }
  }
  return -1;
}

Minor optimizations

I have also incorporated a few refinements to enhance the efficiency of the code. LINK TO OPTIMIZED JSFIDDLE

var arr = ["Partner1", "Partner2"]
var needle = "partner2"
var n = findInArray(needle, arr, true, false);
console.log(n);

function findInArray(needle, arr, exact, sensitive) {
  //Check if these attributes were even provided
  if (typeof needle != 'undefined' && typeof arr != 'undefined') {
    if (arr.length < 1) {
      return -1;
    }
    if (typeof exact == 'undefined') {
      //Ensuring it's always set. Defaults to false.
      exact = false;
    }
    if (sensitive == 'undefined') {
      //Ensuring it's always set. Defaults to false.
      sensitive = false;
    }

    //Handle sensitivity parameter for improved performance
    if (!sensitive) {
      needle = needle.toLowerCase();
    }

    //determine array length
    var hayLength = arr.length;
    for (var i = 0; i < hayLength; i++) {
      //Set haystack
      var haystack = arr[i];
      //Check if it's another array. If so, recursively call this function to go 1 level deeper.
      if (haystack.constructor == Array) {
        return findInArray(needle, haystack, exact, sensitive);
      }

      //Implementing a lowercase operation here to save on lowercase condition checks
      if (!sensitive) {
        haystack = haystack.toLowerCase();
      }

      //Simplified conditionals
      if (exact && sensitive && (haystack == needle)) {
        return i;
      } else if (exact & (haystack == needle)) {
        return i;
      } else if (!exact & (haystack.search(needle)) > -1) {
        return i;
      }
    }
  }
  return -1;
}

Answer 3

Answer №2

You have the option of utilizing the built-in Array.prototype.find or Array.prototype.indexOf

var arr = ["Partner1", "Partner2"];
var needle = "partner1";
var n = findInArray(needle, arr, true, false);
console.log(n);
function findInArray (input, array, exact, caseSenstive) {
   if (caseSenstive) {
      input = input.toLowerCase();
   }
   if (!exact){
      return array.find(i => i.toLowerCase().indexOf(input)) || -1;
   }
   if (caseSenstive) {
      return array.find(i => i === input) || -1;
   }
   return array.find(i => i.toLowerCase() === input) || -1;
}

Answer 4

You have the option of utilizing the built-in Array.prototype.find or Array.prototype.indexOf

var arr = ["Partner1", "Partner2"];
var needle = "partner1";
var n = findInArray(needle, arr, true, false);
console.log(n);
function findInArray (input, array, exact, caseSenstive) {
   if (caseSenstive) {
      input = input.toLowerCase();
   }
   if (!exact){
      return array.find(i => i.toLowerCase().indexOf(input)) || -1;
   }
   if (caseSenstive) {
      return array.find(i => i === input) || -1;
   }
   return array.find(i => i.toLowerCase() === input) || -1;
}

Searching for a specific sequence of characters within an array

Answer №1

Minor optimizations

Answer №2

Similar questions

Using jQuery to display items from GitHub API in a custom unordered list format

What is the best practice for naming variables in JavaScript?

I encounter difficulties using my static resources in the root route of my Express.js application

Oops! Looks like there was an error. The text strings need to be displayed within a <Text> component in the BottomTabBar. This occurred at line 132 in the

The Null object within localStorage is identified as a String data type

VueJS method for making an HTTP GET request

Display a div based on user selection using Ajax and Laravel

How can I transform area, city, state, and country into latitude and longitude using Google Maps API v3?

Error encountered: Mocha - The property '$scope' cannot be read as it is undefined

Is there a way to trigger an Ajax function after individually selecting each checkbox in a list in MVC 4 using Razor syntax?

Encountering issues with webpack module federation and single-spa-vue integration, specifically with Vue version 2.16.12

Converting a JavaScript variable into an xls or csv file

Combine TypeScript files in a specific sequence following compilation

Creating a new object store in IndexedDB on Windows 8

establishing the dimensions of table data cells

Angular: Defining variables using let and var

Issue with reflect metadata in Next.js edge runtime causing functional problems

Angular 2 partial static routing parameters with customizable features

Javascript code not running as expected

Toggling javascript functionality based on media queries