Corrispondenza di uno degli elementi di una matrice in una stringa utilizzando javascript

Question

Sto tentando di creare una funzione che restituisce true se almeno uno degli elementi di una serie di stringhe si trova all'interno di un'altra stringa.

function findInString(str) { 
    var fruits = ["orange", "banana", "grape"]; 

    for(var i = 0; i < fruits.length; i++) { 
     if (str.indexOf(fruits[i]) > -1) { 
      return true; 
     } 
    } 

    return false; 
} 

var a = findInString("I love orange juice."); //=> returns true 
var b = findInString("I don't like peach."); //=> returns false 

Questa funzione fa il trucco, ma sono sicuro che ci potrebbe qualche metodo array o stringa che fa la stessa cosa, senza dover scorrere l'array. Qualche idea?

Grazie.

Answer 1

Concettualmente non riesco a pensare a un modo migliore (o addirittura diverso) di farlo. Non so di una funzione incorporata che svolge questo compito, ma anche se ce ne fosse una, l'implementazione sarebbe comunque questa.

Answer 2

È possibile utilizzare some che si avvicina molto a questo. Ecco come mi piacerebbe scrivere che:

function find (str, arr) { 
    return arr.some((s) => s.indexOf(str) > -1); 
} 

Si potrebbe fare questo pure se vuoi, ma non mi sento bene su di esso.

function find (str, arr) { 
    return arr.join(',').indexOf(str) > -1 
} 

Answer 3

Mi piace il tuo modo di farlo. Ci sono un po 'di attenzione, qui ci sono diversi modi in cui puoi pensare:

Alcuni di questi sono veramente vicini, ma quell'ultimo periodo potrebbe richiedere un parsing di stringhe per gestire ogni caso. Si noti l'ultimo, in quanto utilizza RegExp, solito richiedono facendo nulla per la stringa:

JsBin Example

function findInString(str) { 
    var fruits = ["orange", "banana", "grape"]; 

    return str.split(' ').filter(function(el) { 
    return fruits.indexOf(el) > -1; 
    }).length > 0; 
} 

function finderWithReduce(str) { 
    var fruits = ["orange", "banana", "grape"]; 
    var result = false; 
    str.split(' ').reduce(function(a, b) { 
    if (a.indexOf(b) > -1) { 
     result = true; 
    } 
    return a; 
    }, fruits); 
    return result; 
} 

function finderWithForEach(str){ 
    var fruits = ["orange", "banana", "grape"]; 
    var result = false; 
    fruits.forEach(function(fruit) { 
    if (str.indexOf(fruit) > -1) { 
     result = true; 
    } 
    }); 
    return result; 
} 

function finderWithRegex(str) { 
    var fruits = ["orange", "banana", "grape"]; 
    for (var i = 0; i < fruits.length; i++) { 
    var re = new RegExp(fruits[i], 'gi'); 
    if (str.match(re) !== null) { 
     return true; 
    } 
    } 
    return false; 
} 

Answer 4

È possibile utilizzare la funzione some.

function findInString(str, arr) { 
    return arr.some(function(el) { 
     return str.indexOf(el) > -1; 
    }); 
} 

var fruits = ["orange", "banana", "grape"]; 

var a = findInString("I love orange juice.", fruits); //=> returns true 
var b = findInString("I don't like peach.", fruits); //=> returns false 

Answer 5

Penso che si debba elaborare l'array. Vorrei fare due cambiamenti.

Prima passavo nell'array e anche nella stringa, creando una funzione generica, quindi lo rielaboravo in modo che, una volta trovato, si smetta di farlo ed esca dal ciclo; concetto simile al ritorno vero ma solo un modo diverso di farlo - la mia personale preferenza per avere solo una funzione di uscita.

function findInString(arr, str) { 
    var hasString = false; 
    for (var i = 0; i < fruits.length; i++) { 
    if (str.indexOf(fruits[i]) > -1) { 
     hasString = true; 
     break; 
    } 
    } 
    return hasString; 
} 

var fruits = ["orange", "banana", "grape"]; 

var a = findInString(fruits, "I love orange juice."); //=> returns true 
var b = findInString(fruits, "I don't like peach."); //=> returns false 

Answer 6

Ecco un metodo ES6 funzionale. presentIn è una funzione di ordine superiore che accetta una stringa e restituisce una funzione che funge da callback some.

const presentIn = (str) => (el) => str.includes(el); 

fruits.some(presentIn('I love orange juice.')); // true 
fruits.some(presentIn('I don\'t like peach.')); // false 

Mi piace molto questo approccio perché si opera direttamente sugli elementi dell'array, e se il nome del tuo funzione bene analizza brillantemente: "sono alcuni elementi della matrice presenti nella stringa".

DEMO

La versione leggermente più prolisso ES5 per il confronto:

function presentIn(str) { 
    return function (el) { 
    return str.indexOf(el) > -1; 
    } 
}