javascript数组indexOf中使用的正则表达式_Javascript_Regex_Arrays

javascript数组indexOf中使用的正则表达式

javascript regex arrays

javascript数组indexOf中使用的正则表达式,javascript,regex,arrays,Javascript,Regex,Arrays,我需要在数组中找到单词的索引 var str="hello how are you r u fineOr not .Why u r not fine.Please tell wats makes u notfiness". var splitStr=str.split(" "); //in splitStr array fineOr is stored at da index of 6. //in splitStr array notfiness is stored at da index o

我需要在数组中找到单词的索引

var str="hello how are you r  u fineOr not .Why u r not fine.Please tell wats makes u notfiness".
var splitStr=str.split(" ");
//in splitStr array fineOr is stored at da index of 6.
//in splitStr array notfiness is stored at da index of 18.
var i=splitStr.indexOf("**fine**");
var k=splitStr.lastindexOf("**fine**");
console.log('value i-- '+i); it should log value 6
console.log('value k-- '+k); it should log value 18

我需要如何传递正则表达式来搜索数组函数indexOf的字符串“fine”？

在

之后。split（“”）

您将得到

splitStr

作为一个数组，因此您必须循环使用它

 var str="hello how are you r  u fineOr not .Why u r not fine.Please tell wats makes u notfiness";
 var splitStr = str.split(" ");
 var indexs = [];
 splitStr.forEach(function(val,i){

     if(val.indexOf('fine') !== -1) {  //or val.match(/fine/g)
        indexs.push(i);
     }
 });

console.log(indexs) // [7, 13, 18]

console.log('First index is ', indexs[0]) // 7
console.log('Last index is ', indexs[indexs.length-1]) // 18

您还可以对单词数组使用过滤器

如果源字符串可能很复杂，并且不容易被“”分割，那么您可能应该使用更健壮的方法。如果您不介意包含一个外部库，可以使用来标记源字符串。以下是一个例子：

<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Example 04 - Word Index</title>

  <!--<script src="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>-->
  <script src="../js/lib/jquery-1.9.0.min.js"></script>
  <!--<script src="//cdnjs.cloudflare.com/ajax/libs/qunit/1.12.0/qunit.min.js"></script>-->
  <script src="../js/lib/nat.js"></script>
</head>
<body>

<h1>Example 04 - Word Index</h1>

<p>
You can use nat-js to tokenize a text and build some logic over it.
</p>


<script>
$(document).ready(function(){
    var searchString = 'fine';
    var sourceString = 'hello how are you r  u fineOr not .Why u r not fine.Please tell wats makes u notfiness';
    var tkz = new nat.tokenizer();
    var tokens = tkz.execute(sourceString);

    var i = 0;
    var result = [];
    for(var t in tokens) {
        var tk = tokens[t];
        if ( tk.value.indexOf(searchString)>=0 ) {
            result.push({
                what: tk.value,
                where: i
            });
        }
        i++;
    }

    result.forEach(function(r) {
        console.log('found ' + r.what + ' in ' + r.where);
    });
});
</script>

</body>
</html>


示例04-单词索引
示例04-单词索引

您可以使用nat js标记文本并在其上构建一些逻辑。

$（文档）.ready（函数（）{
var searchString='fine'；
var sourceString='你好，你还好吗？为什么不好？请告诉wats让你不好'；
var tkz=新的nat.tokenizer（）；
var tokens=tkz.execute（sourceString）；
var i=0；
var结果=[]；
for（令牌中的var t）{
var tk=代币[t]；
if（tk.value.indexOf（searchString）>=0）{
结果：推({
什么：传统价值观，
地点：我
});
}
i++；
}
结果.forEach（函数（r）{
log（'在'+r.where'中找到'+r.what+'）；
});
});

如果您使用的是库，则可以使用u.findIndex（）方法

为了解决我觉得还没有完成的OP问题，这里有一个由正则表达式使用压缩迭代实现indexOf的方法：

var arr = ['foo','bar','this','that','another'];
var re = /^[Tt]hi[a-z]$/; // expected match is 'this'
var ind = arr.indexOf((function(){
    var i;
    for(i in arr)
        if(re.test(arr[i]))
            return arr[i];
    })());
// ind = 2 which is accurate

re = /i_dont_exist/; // expected not to match
ind = arr.indexOf((function(){
    var i;
    for(i in arr)
        if(re.test(arr[i]))
            return arr[i];
    })());
// ind = -1, also accurate

另一个尚未实现的替代方案是：

var str = "hello how are you r u fineOr not .Why u r not fine.Please 
tell wats makes u notfiness";
var splitStr = str.split(" ");

function findIndex(splitStr){
  return splitStr.findIndex(function (element) {
    return element.indexOf('fine') === 0;
  })
}
console.log(findIndex(splitStr)); // 6

说明：

findIndex方法迭代数组的每个元素，并在提供的匿名函数返回true时返回所需元素的索引

element.indexOf在本例中，将每个元素作为字符串进行计算，并在到达出现所需单词（即（'fine'）的元素时计算为0。计算为0并与0进行比较后，将返回true。这将使findIndex返回函数计算为true的元素的索引。

如果您不太关心性能，下面是一个解决方案

const str=“你好，你还好吗？为什么不好？请告诉我是什么让你不好”；
const splitStr=str.split（“”）；
设i=splitStr.findIndex（v=>/.*fine.*/.test（v））；
设k=splitStr.length-splitStr.reverse（）.findIndex（v=>/.*fine.*/.test（v））；
控制台日志（--i）；
控制台日志（--k）这里只有ES6答案继续使用正则表达式，但这不是必需的。如果regexp是您的性能问题，您可以避免它们：
const str = "hello how are you r  u fineOr not .Why u r not fine.Please tell wats makes u notfiness";
const splitStr = str.split(" ");
let i = splitStr.findIndex(str => str.includes("fine"));
let k = splitStr.length - splitStr.reverse().findIndex(str => str.includes("fine"));
console.log(`i = ${--i}\nk = ${--k}`);

下面是一个代码笔，演示了这一点：
可能有比.reverse（）
更有效的方法，如果您愿意声明一个函数而不是两个重复的箭头函数，则可以声明一个函数。但是这完全消除了regexp，应该可以很好地执行。您不能在那里传递正则表达式，因为indexOf不是这样工作的。@CBroe是的，也许值得一个功能请求？您应该使用reduce，而不是创建一个数组，使用forEach，然后推到数组上
var str = "hello how are you r u fineOr not .Why u r not fine.Please 
tell wats makes u notfiness";
var splitStr = str.split(" ");

function findIndex(splitStr){
  return splitStr.findIndex(function (element) {
    return element.indexOf('fine') === 0;
  })
}
console.log(findIndex(splitStr)); // 6

const str = "hello how are you r  u fineOr not .Why u r not fine.Please tell wats makes u notfiness";
const splitStr = str.split(" ");
let i = splitStr.findIndex(str => str.includes("fine"));
let k = splitStr.length - splitStr.reverse().findIndex(str => str.includes("fine"));
console.log(`i = ${--i}\nk = ${--k}`);