So i'm trying to build a function that can simplify expressions but I can't seem to find a way to seperate the terms into 2 different arrays (numbers and letters). The result of the code below is "32xy" instead of just "32".
Also it would be great to know if there is a better way to check for a number or selection of characters in javascript.
var newArr;
var numArr = [];
var letArr = [];
function splitTerm (term) {
for (var i=0; i<term.length; i++){
newArr = term.split('');
}
for (var item of newArr){
if (item === '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9') {
numArr.push(item);
} else {
letArr.push(item);
}
}
$('#num').html(numArr.join(''));
}
splitTerm("32xy");
if (item === '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9')
This should be
if (['0','1','2','3','4','5','6','7','8','9'].includes(item)) {
Also, you do'nt need to do that loop at the top of the function.
newArr = term.split(''); is fine to just run once.
Your code can be improved in many ways:
newArr, numArr, and letArr are only used inside the function, so you should declare them inside the function.
The for loop iterating from 0 to term.length does nothing except repeatedly assign the same thing to newArr, so it doesn't need to be there.
You can use a regex to test if something is a number.
function splitTerm(term) {
var newArr = term.split("");
for (var item of newArr) {
if (/\d/.test(item)) {
newArr.push(item);
} else {
letArr.push(item);
}
}
$("#num").html(numArr.join(""));
}
Another option - use regex
const splitTerm = (str) => {
// Use regexp to extract characters and digits
return {
dig: str.match(/\d+/g).join(''),
char: str.match(/[^\d]+/g).join(''),
};
};
// Run
const res = splitTerm("32xy");
// Log
console.log(res);
Here is the edited version
var newArr;
var numArr = [];
var letArr = [];
function splitTerm (term) {
numArr = Array.from(term).filter((elem) => /^[0-9]$/i.test(elem));
console.log(numArr.join(''));
}
splitTerm("322xy");
but you can actually use the value directly without function call;
$('#num').html(Array.from('32xy').filter((elem) => /^[0-9]$/i.test(elem)).join(''));
You can use .replace() with regular expression in your function.
console.log("32xy".replace(/[^0-9]/g, '')); // 32
console.log("aaa32xy".replace(/[^0-9]/g, '')); // 32
console.log("aaa3bb2xy".replace(/[^0-9]/g, '')); // 32
I have been trying to figure out a fast way of creating an array based on repeating an element a given number of times. For my purposes, generally the element I'd be repeating is another array, and I'd be making a long repeated (2-dimensional) array out of it, so I'd prefer it to be fast. Note that in each example, c=[element] since that's how it naturally occurs in my code.
There are a few options here that I've found. At most basic is option 1:
function repeatSimple(c, n) {
var arr = [];
for (var i=0; i<n; i++) {
arr = arr.concat(c);
};
return arr;
};
Then from this question (Concatenate array to itself in order to duplicate it), gdbdmdb has another option:
function repeatApply(c, n) {
return [].concat.apply([], Array.apply(0, Array(n)).map(function() { return c }));
};
My thinking was (a) I don't really understand the second option well enough to know whether it's a good solution, and (b) it seems silly to have to call concat a whopping n times as in the first option. So I came up with one more:
function repeatBinary(c, n) {
var arr = [];
var r = 0;
while (n>0) {
r = n%2;
if (r>0) {
arr = arr.concat(c);
};
n = (n-r)/2;
if (n>0) {
c = c.concat(c);
};
};
return arr
};
This way, I only have to call concat at most 2log_2(n) times.
So, my question is, what is the fastest way to do this? Is it one of the options I'm looking at here or is there something else that blows them out of the water? Or will all of these options work at such similar speeds that it really doesn't make a difference?
I think the fastest way to do this witout even using the concat function :
function repeatSimple(element, times)
{
var result = [];
for(var i=0;i<times;i++)
result.push(element);
return result;
}
And if you don't want to use the push function , you can assign the value directly to the item on the array like this
function repeatSimple(element, times)
{
var result = Array(times);
for(var i=0;i<times;i++)
result[i] = element;
return result;
}
Another clever way to do this is to join an array and split it like this
function repeatSimple(element, times)
{
(result = Array(times).join("," + element).split(',')).shift()
return result;
}
But this last function returns an array of strings, you have to convert every element to the type you need, but anyway, these functions may help you
I would like to split a string into fixed-length (N, for example) pieces. Of course, last piece could be shorter, if original string's length is not multiple of N.
I need the fastest method to do it, but also the simplest to write. The way I have been doing it until now is the following:
var a = 'aaaabbbbccccee';
var b = [];
for(var i = 4; i < a.length; i += 4){ // length 4, for example
b.push(a.slice(i-4, i));
}
b.push(a.slice(a.length - (4 - a.length % 4))); // last fragment
I think there must be a better way to do what I want. But I don't want extra modules or libraries, just simple JavaScript if it's possible.
Before ask, I have seen some solutions to resolve this problem using other languages, but they are not designed with JavaScript in mind.
You can try this:
var a = 'aaaabbbbccccee';
var b = a.match(/(.{1,4})/g);
See this related question: https://stackoverflow.com/a/10456644/711085 and https://stackoverflow.com/a/8495740/711085 (See performance test in comments if performance is an issue.)
First (slower) link:
[].concat.apply([],
a.split('').map(function(x,i){ return i%4 ? [] : a.slice(i,i+4) })
)
As a string prototype:
String.prototype.chunk = function(size) {
return [].concat.apply([],
this.split('').map(function(x,i){ return i%size ? [] : this.slice(i,i+size) }, this)
)
}
Demo:
> '123412341234123412'.chunk(4)
["1234", "1234", "1234", "1234", "12"]
function stringToChanks(string, chunkSize) {
const chunks = [];
while (string.length > 0) {
chunks.push(string.substring(0, chunkSize));
string = string.substring(chunkSize, string.length);
}
return chunks
}
Pretty straight forward. In javascript, I need to check if a string contains any substrings held in an array.
There's nothing built-in that will do that for you, you'll have to write a function for it, although it can be just a callback to the some array method.
Two approaches for you:
Array some method
Regular expression
Array some
The array some method (added in ES5) makes this quite straightforward:
if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
// There's at least one
}
Even better with an arrow function and the newish includes method (both ES2015+):
if (substrings.some(v => str.includes(v))) {
// There's at least one
}
Live Example:
const substrings = ["one", "two", "three"];
let str;
// Setup
console.log(`Substrings: ${substrings}`);
// Try it where we expect a match
str = "this has one";
if (substrings.some(v => str.includes(v))) {
console.log(`Match using "${str}"`);
} else {
console.log(`No match using "${str}"`);
}
// Try it where we DON'T expect a match
str = "this doesn't have any";
if (substrings.some(v => str.includes(v))) {
console.log(`Match using "${str}"`);
} else {
console.log(`No match using "${str}"`);
}
Regular expression
If you know the strings don't contain any of the characters that are special in regular expressions, then you can cheat a bit, like this:
if (new RegExp(substrings.join("|")).test(string)) {
// At least one match
}
...which creates a regular expression that's a series of alternations for the substrings you're looking for (e.g., one|two) and tests to see if there are matches for any of them, but if any of the substrings contains any characters that are special in regexes (*, [, etc.), you'd have to escape them first and you're better off just doing the boring loop instead. For info about escaping them, see this question's answers.
Live Example:
const substrings = ["one", "two", "three"];
let str;
// Setup
console.log(`Substrings: ${substrings}`);
// Try it where we expect a match
str = "this has one";
if (new RegExp(substrings.join("|")).test(str)) {
console.log(`Match using "${str}"`);
} else {
console.log(`No match using "${str}"`);
}
// Try it where we DON'T expect a match
str = "this doesn't have any";
if (new RegExp(substrings.join("|")).test(str)) {
console.log(`Match using "${str}"`);
} else {
console.log(`No match using "${str}"`);
}
One line solution
substringsArray.some(substring=>yourBigString.includes(substring))
Returns true\false if substring exists\does'nt exist
Needs ES6 support
var yourstring = 'tasty food'; // the string to check against
var substrings = ['foo','bar'],
length = substrings.length;
while(length--) {
if (yourstring.indexOf(substrings[length])!=-1) {
// one of the substrings is in yourstring
}
}
function containsAny(str, substrings) {
for (var i = 0; i != substrings.length; i++) {
var substring = substrings[i];
if (str.indexOf(substring) != - 1) {
return substring;
}
}
return null;
}
var result = containsAny("defg", ["ab", "cd", "ef"]);
console.log("String was found in substring " + result);
For people Googling,
The solid answer should be.
const substrings = ['connect', 'ready'];
const str = 'disconnect';
if (substrings.some(v => str === v)) {
// Will only return when the `str` is included in the `substrings`
}
Here's what is (IMO) by far the best solution. It's a modern (ES6) solution that:
is efficient (one line!)
avoids for loops
unlike the some() function that's used in the other answers, this one doesn't just return a boolean (true/false)
instead, it either returns the substring (if it was found in the array), or returns undefined
goes a step further and allows you to choose whether or not you need partial substring matches (examples below)
Enjoy!
const arrayOfStrings = ['abc', 'def', 'xyz'];
const str = 'abc';
const found = arrayOfStrings.find(v => (str === v));
Here, found would be set to 'abc' in this case. This will work for exact string matches.
If instead you use:
const found = arrayOfStrings.find(v => str.includes(v));
Once again, found would be set to 'abc' in this case. This doesn't allow for partial matches, so if str was set to 'ab', found would be undefined.
And, if you want partial matches to work, simply flip it so you're doing:
const found = arrayOfStrings.find(v => v.includes(str));
instead. So if str was set to 'ab', found would be set to 'abc'.
Easy peasy!
var str = "texttexttext";
var arr = ["asd", "ghj", "xtte"];
for (var i = 0, len = arr.length; i < len; ++i) {
if (str.indexOf(arr[i]) != -1) {
// str contains arr[i]
}
}
edit:
If the order of the tests doesn't matter, you could use this (with only one loop variable):
var str = "texttexttext";
var arr = ["asd", "ghj", "xtte"];
for (var i = arr.length - 1; i >= 0; --i) {
if (str.indexOf(arr[i]) != -1) {
// str contains arr[i]
}
}
substringsArray.every(substring=>yourBigString.indexOf(substring) === -1)
For full support ;)
For full support (additionally to #ricca 's verions).
wordsArray = ['hello', 'to', 'nice', 'day']
yourString = 'Hello. Today is a nice day'.toLowerCase()
result = wordsArray.every(w => yourString.includes(w))
console.log('result:', result)
If the array is not large, you could just loop and check the string against each substring individually using indexOf(). Alternatively you could construct a regular expression with substrings as alternatives, which may or may not be more efficient.
Javascript function to search an array of tags or keywords using a search string or an array of search strings. (Uses ES5 some array method and ES6 arrow functions)
// returns true for 1 or more matches, where 'a' is an array and 'b' is a search string or an array of multiple search strings
function contains(a, b) {
// array matches
if (Array.isArray(b)) {
return b.some(x => a.indexOf(x) > -1);
}
// string match
return a.indexOf(b) > -1;
}
Example usage:
var a = ["a","b","c","d","e"];
var b = ["a","b"];
if ( contains(a, b) ) {
// 1 or more matches found
}
This is super late, but I just ran into this problem. In my own project I used the following to check if a string was in an array:
["a","b"].includes('a') // true
["a","b"].includes('b') // true
["a","b"].includes('c') // false
This way you can take a predefined array and check if it contains a string:
var parameters = ['a','b']
parameters.includes('a') // true
Best answer is here:
This is case insensitive as well
var specsFilter = [.....];
var yourString = "......";
//if found a match
if (specsFilter.some((element) => { return new RegExp(element, "ig").test(yourString) })) {
// do something
}
const str = 'Does this string have one or more strings from the array below?';
const arr = ['one', 'two', 'three'];
const contains = arr.some(element => {
if (str.includes(element)) {
return true;
}
return false;
});
console.log(contains); // true
Not that I'm suggesting that you go and extend/modify String's prototype, but this is what I've done:
String.prototype.includes()
String.prototype.includes = function (includes) {
console.warn("String.prototype.includes() has been modified.");
return function (searchString, position) {
if (searchString instanceof Array) {
for (var i = 0; i < searchString.length; i++) {
if (includes.call(this, searchString[i], position)) {
return true;
}
}
return false;
} else {
return includes.call(this, searchString, position);
}
}
}(String.prototype.includes);
console.log('"Hello, World!".includes("foo");', "Hello, World!".includes("foo") ); // false
console.log('"Hello, World!".includes(",");', "Hello, World!".includes(",") ); // true
console.log('"Hello, World!".includes(["foo", ","])', "Hello, World!".includes(["foo", ","]) ); // true
console.log('"Hello, World!".includes(["foo", ","], 6)', "Hello, World!".includes(["foo", ","], 6) ); // false
building on T.J Crowder's answer
using escaped RegExp to test for "at least once" occurrence, of at least one of the substrings.
function buildSearch(substrings) {
return new RegExp(
substrings
.map(function (s) {return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');})
.join('{1,}|') + '{1,}'
);
}
var pattern = buildSearch(['hello','world']);
console.log(pattern.test('hello there'));
console.log(pattern.test('what a wonderful world'));
console.log(pattern.test('my name is ...'));
Drawing from T.J. Crowder's solution, I created a prototype to deal with this problem:
Array.prototype.check = function (s) {
return this.some((v) => {
return s.indexOf(v) >= 0;
});
};
Using underscore.js or lodash.js, you can do the following on an array of strings:
var contacts = ['Billy Bob', 'John', 'Bill', 'Sarah'];
var filters = ['Bill', 'Sarah'];
contacts = _.filter(contacts, function(contact) {
return _.every(filters, function(filter) { return (contact.indexOf(filter) === -1); });
});
// ['John']
And on a single string:
var contact = 'Billy';
var filters = ['Bill', 'Sarah'];
_.every(filters, function(filter) { return (contact.indexOf(filter) >= 0); });
// true
If you're working with a long list of substrings consisting of full "words" separated by spaces or any other common character, you can be a little clever in your search.
First divide your string into groups of X, then X+1, then X+2, ..., up to Y. X and Y should be the number of words in your substring with the fewest and most words respectively. For example if X is 1 and Y is 4, "Alpha Beta Gamma Delta" becomes:
"Alpha" "Beta" "Gamma" "Delta"
"Alpha Beta" "Beta Gamma" "Gamma Delta"
"Alpha Beta Gamma" "Beta Gamma Delta"
"Alpha Beta Gamma Delta"
If X would be 2 and Y be 3, then you'd omit the first and last row.
Now you can search on this list quickly if you insert it into a Set (or a Map), much faster than by string comparison.
The downside is that you can't search for substrings like "ta Gamm". Of course you could allow for that by splitting by character instead of by word, but then you'd often need to build a massive Set and the time/memory spent doing so outweighs the benefits.
convert_to_array = function (sentence) {
return sentence.trim().split(" ");
};
let ages = convert_to_array ("I'm a programmer in javascript writing script");
function confirmEnding(string) {
let target = "ipt";
return (string.substr(-target.length) === target) ? true : false;
}
function mySearchResult() {
return ages.filter(confirmEnding);
}
mySearchResult();
you could check like this and return an array of the matched words using filter
I had a problem like this. I had a URL, I wanted to check if the link ends in an image format or other file format, having an array of images format. Here is what I did:
const imagesFormat = ['.jpg','.png','.svg']
const link = "https://res.cloudinary.com/***/content/file_padnar.pdf"
const isIncludes = imagesFormat.some(format => link.includes(format))
// false
You can check like this:
<!DOCTYPE html>
<html>
<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
<script>
$(document).ready(function(){
var list = ["bad", "words", "include"]
var sentence = $("#comments_text").val()
$.each(list, function( index, value ) {
if (sentence.indexOf(value) > -1) {
console.log(value)
}
});
});
</script>
</head>
<body>
<input id="comments_text" value="This is a bad, with include test">
</body>
</html>
let obj = [{name : 'amit'},{name : 'arti'},{name : 'sumit'}];
let input = 'it';
Use filter :
obj.filter((n)=> n.name.trim().toLowerCase().includes(input.trim().toLowerCase()))
var str = "A for apple"
var subString = ["apple"]
console.log(str.includes(subString))