I need to search an array in JavaScript. The search would be for only part of the string to match as the string would have additional components. I would then need to return the successfully matched More on stackoverflow.com

Suppose my array is ["abcdefg", "hijklmnop"] and I am looking at if "mnop" is part of this array. How can I do this using a javascript method? I tried this and it does not work: var array= ["abcd... More on stackoverflow.com

Solved. In case you also need it, and you're using regexes: string = string.left(regex_match.get_start()) + (string.right(string.length() - regex_match.get_end())) This basically just adds the string that's to the left of the match to the string that's to the right of it, skipping over it. More on reddit.com

Some classes jump ahead way too quickly which is unfortunate, I remember when I first started taking the codecademy "learn JS" class, they immediately jumped into jQuery and React just a lesson after teaching what a function was which in hindsight is totally absurd. As a basic first step, whenever you have trouble try looking over the MDN page for the topic . I don't know why this is so weird to me, but it seems really weird to declare the const, and then pass it a function with another function inside of it. Sure, but this is probably because you've yet to work with any complex data, or need to make a lot of complex changes to data in sequence where you may not be in control of the input. It might help to demonstrate more about map itself: // A **very** simplified version of what Array.map would be, // though you shouldn't modify the prototype like this: Array.prototype.map = function (callback) { // ^ We're passing a function in as an argument named callback let resultArray = []; // But otherwise it's just syntactical sugar for a normal for loop: for ( let i = 0; i < this.length; // "this" equals the array here, like [1,2,3] i++ ) resultArray.push(callback(this[i], i, this)); // ^ read as (value, index, array) which we're passing into the callback function, // returning the result of that callback no matter what it may be return resultArray; }; // This allows us to easily modify any list and return a new array on the fly: const foo = [1, 2, 3]; const timesTwo = foo.map(function (value, index, array) { return value * 2; }); console.log(timesTwo); // [2, 4, 6] const shortAndSweet = foo.map((v) => v * 2); // [2, 4, 6] // v is arbitrary. It can be named whatever I want as long as it's the first argument, it corresponds to this[i]/value in the manual Map function above const longAndAnnoyingToWrite = []; for (var i = 0; i < foo.length; i++) longAndAnnoyingToWrite.push(foo[i] * 2) This may be overwhelming to look at, so let's boil it down to look more traditional: // Why not just make a custom function to do what we wanted to use map for in the first place? function multiplyArrayTimesTwo(array) { let resultArray = []; for (let i = 0; i < array.length; i++) resultArray.push(array[i] * 2); return resultArray; } // Or turn map into a normal looking function: function mapArray(array, callback) { // ^ Still containing the callback function as an argument though, why? let resultArray = []; for (let i = 0; i < array.length; i++) resultArray.push(callback(array[i], i, array)); return resultArray; } // We can produce the same results: const foo = [1, 2, 3]; const timesTwo = mapArray(foo, function (value, index, array) { return value * 2; }); const timesTwoAgain = multiplyArrayTimesTwo(foo) console.log(timesTwo, timesTwoAgain); // [2, 4, 6] , [2, 4, 6] const shortAndSweet = mapArray(foo, (v) => v * 2); // [2, 4, 6] Why not just do this? The answer is really only that we may want to modify this array in many ways besides multiplying by only two. We may need to multiply it by two once, but we may need to also change it in a variety of other ways, and we can more easily do that with callback functions than by writing out a custom function for every single change we'd want to make. const alphabet = "abcdefghijklmnopqrstuvwxyz"; const foo = [1, 2, 3]; const timesTwoAsLettersWithOtherStuff = foo .map((value) => value * 2) // Multiply it by two > [2, 4, 6] .map((value) => alphabet[value]) // Then change it to a letter > ["c", "e", "g"] .map((value) => value.padStart(4, "0")); // Add leading 0 until the total length is four > ["000c", "000e", "000g"] const short = foo.map(i => i * 2).map(i => alphabet[i]).map(i => i.padStart(5, "0")); If we had to write the above out with a custom function to do each step, we'd be looking at far more lines of code (repeating the for loop each one) instead of only 2 or 3 lines. And if we're not using arrow functions, we can again run into having what would otherwise be concise code as very vertical: const timesTwoAsLettersWithOtherStuff = foo .map(function (i) { return i * 2; // Multiply it by two > [2, 4, 6] }) .map(function (i) { return alphabet[i]; // Then change it to a letter > ["c", "e", "g"] }) .map(function (i) { return i.padStart(4, "0"); // Add leading 0 until the total length is four > ["000c", "000e", "000g"] }); This isn't the most practical example because you don't need 3 separate map functions to do the above. You could do it in a single one via map(i => alphabet[i * 2].padStart(4, "0")), but the principle is that you'll find yourself using several Array methods in a chain to do complex operations with map being only one of these: const someComplexModification = foo .map(/* ... */) .filter(/* ... */) .sort(/* ... */) .map(/* ... */) .forEach(/* ... */); // You wouldn't do this though, because forEach doesn't return values // Which if we built a custom function that needed us to supply the array as an argument would have to look like this: const complexAndOverlyComplicated = doForEach( doMap(doSort(doFilter(doMap(foo)))) // Ooof, gross ); // Or a chain like this: const mapped = doMap(foo); const filtered = doFilter(mapped); const sorted = doSort(filtered); const mappedAgain = doMap(sorted); for (let index = 0; index < mappedAgain.length; index++) { let value = mappedAgain[index]; // Now we finally do what we wanted, but have a ton of redundant variables declared and code above } Finally, the fact that the argument in the anonymous function, here: "j", seems so arbitrary and I don't understand why. Does it have anything to do with the fact that .map is already being called on the emojipedia array, and since "j" is an extremely local variable, it doesn't matter? It is arbitrary. It doesn't matter what it's named, it only matters what the argument position is. If it's the first argument, it's always the value because the parameters are (value, index, array). You can name it whatever you want but people tend to do one-letter characters so the code is the most concise, though it isn't always helpful to do this especially when showing it to others. I decided to in the above specifically to demonstrate to you that it was arbitrary. More on reddit.com