Fatal编程技术网
  • javascript/
  • Javascript 如何使Array.indexOf（）不区分大小写？

Javascript 如何使Array.indexOf（）不区分大小写？

javascript

Javascript 如何使Array.indexOf（）不区分大小写？,javascript,Javascript,我正在为一个网站制作一段代码，该网站将有一个数组中的名称列表，并选择一个随机名称，我想添加一个功能，使用户可以从数组中添加或删除名称。我拥有所有这些功能，但在删除名称时，用户必须键入名称以匹配数组中的大小写。我试图使它不区分大小写，我做错了什么 <html> <!--Other code uneeded for this question--> <p id="canidates"></p> <body> <input type="

我正在为一个网站制作一段代码，该网站将有一个数组中的名称列表，并选择一个随机名称，我想添加一个功能，使用户可以从数组中添加或删除名称。我拥有所有这些功能，但在删除名称时，用户必须键入名称以匹配数组中的大小写。我试图使它不区分大小写，我做错了什么

<html>
<!--Other code uneeded for this question-->
<p id="canidates"></p>
<body>
<input type="text" id="delname" /><button onclick="delName()">Remove Name from List</button>
<script>

//Array of names

var names = [];

//Other code uneeded for this question

//List of Canidates
document.getElementById('canidates').innerHTML = 
"<strong>List of Canidates:</strong> " + names.join(" | ");

//Other code uneeded for this question

//Remove name from Array

function delName() {
    var dnameVal = document.getElementById('delname').value;
    var pos = names.indexOf(dnameVal);
    var namepos = names[pos]
    var posstr = namepos.toUpperCase();
    var dup = dnameVal.toUpperCase();
    if(dup != posstr) {
        alert("Not a valid name");
        }
    else {
        names.splice(pos, 1);
        document.getElementById('canidates').innerHTML = 
        "<strong>List of Canidates:</strong> " + names.join(" | ");
        }
    }   
</script>
</body>
</html>




从列表中删除名称
//名称数组
变量名称=[]；
//此问题不需要其他代码
//日期表
document.getElementById（'canidates'）。innerHTML=
“日期列表：”+名称。加入（“|”）；
//此问题不需要其他代码
//从数组中删除名称
函数名（）{
var dnameVal=document.getElementById（'delname'）。值；
var pos=名称.索引（dnameVal）；
var namepos=名称[pos]
var posstr=namepos.toUpperCase（）；
var dup=dnameVal.toUpperCase（）；
如果（dup！=posstr）{
警告（“无效名称”）；
}
否则{
接头名称（位置1）；
document.getElementById（'canidates'）。innerHTML=
“日期列表：”+名称。加入（“|”）；
}
}
简单的方法是使用一个临时数组，其中包含所有大写名称。然后您可以比较用户输入。因此，您的代码可能会变成这样：

function delName() {
    var dnameVal = document.getElementById('delname').value;
    var upperCaseNames = names.map(function(value) {
      return value.toUpperCase();
    });
    var pos = upperCaseNames.indexOf(dnameVal.toUpperCase());

    if(pos === -1) {
        alert("Not a valid name");
        }
    else {
        names.splice(pos, 1);
        document.getElementById('canidates').innerHTML = 
        "<strong>List of Canidates:</strong> " + names.join(" | ");
        }
    }

函数delName（）{
var dnameVal=document.getElementById（'delname'）。值；
var upperCaseNames=names.map（函数（值）{
返回值.toUpperCase（）；
});
var pos=upperCaseNames.indexOf（dnameVal.toUpperCase（））；
如果（位置==-1）{
警告（“无效名称”）；
}
否则{
接头名称（位置1）；
document.getElementById（'canidates'）。innerHTML=
“日期列表：”+名称。加入（“|”）；
}
}
希望这有助于解决您的问题。

最好创建您自己的自定义
indexOf
方法，如下所示

“严格使用”；
var customIndexOf=函数（arrayLike，searchElement）{
var object=对象（类似阵列）；
var length=object.length>>>0；
var fromIndex=arguments.length>2？参数[2]>>0:0；
if（长度<1 | |搜索元素的类型！='string'| | fromIndex>=长度）{
返回-1；
}
如果（从索引<0）{
fromIndex=Math.max（长度-Math.abs（fromIndex），0）；
}
var search=searchElement.toLowerCase（）；
对于（var index=fromIndex；indexlog（customIndexOf（name，'aNnE'））在ECMA-262第5版中，您可以使用它


var array = [ 'I', 'hAve', 'theSe', 'ITEMs' ];
var query = 'these'.toLowerCase();
var index = -1;
array.some(function(element, i) {
    if (query === element.toLowerCase()) {
        index = i;
        return true;
    }
});
// Result: index = 2



你不能区分大小写。我将使用一个对象来保存一组名称：


function Names() {
    this.names = {};

    this.getKey = function(name) {
        return name.toLowerCase();
    }

    this.add = function(name) {
        this.names[this.getKey(name)] = name;
    }

    this.remove = function(name) {
        var key = this.getKey(name);

        if (key in this.names) {
            delete this.names[key];
        } else {
            throw Error('Name does not exist');
        }
    }

    this.toString = function() {
        var names = [];

        for (var key in this.names) {
            names.push(this.names[key]);
        }

        return names.join(' | ');
    }
}

var names = new Names();

function update() {
    document.getElementById('canidates').innerHTML = '<strong>List of Canidates:</strong> ' + names;
}

function deleteName() {
    var name = document.getElementById('delname').value;

    try {
        names.remove(name);
        update();
    } catch {
        alert('Not a valid name');
    }
}

update();



函数名（）{
this.names={}；
this.getKey=函数（名称）{
返回name.toLowerCase（）；
}
this.add=函数（名称）{
this.names[this.getKey（name）]=name；
}
this.remove=函数（名称）{
var key=this.getKey（名称）；
如果（输入此.names）{
删除此项。名称[键]；
}否则{
抛出错误（'名称不存在'）；
}
}
this.toString=函数（）{
变量名称=[]；
for（此.names中的var键）{
names.push（this.names[key]）；
}
返回名称。联接（“|”）；
}
}
变量名称=新名称（）；
函数更新（）{
document.getElementById（'canidates'）。innerHTML='canidates列表：'+名称；
}
函数deleteName（）{
var name=document.getElementById（'delname'）。值；
试一试{
姓名。删除（姓名）；
更新（）；
}抓住{
警报（“不是有效名称”）；
}
}
更新（）；

最优雅的解决方案是首先将数组转换为字符串，然后进行不区分大小写的比较。例如：


var needle = "PearS"
var haystack = ["Apple", "banNnas", "pEArs"];
var stricmp = haystack.toString().toLowerCase(); // returns 
                                   // "apple,bananas,pears"
if (stricmp.indexOf(needle.toLowerCase()) > -1) {
    // the search term was found in the array
} else {
    // the search term was not found in the array
}


ES2015：


var数组=['I'，'hAve'，'this'，'ITEMs']，
indexOf=（arr，q）=>arr.findIndex（item=>q.toLowerCase（）==item.toLowerCase（））；
log（indexOf（数组，'i'））//0
log（indexOf（数组，'this'））//2

log（indexOf（数组，'items'）//3
可以使用by-map方法。例如，请参见下面的代码


var _name = ['prasho','abraham','sam','anna']
var _list = [{name:'prasho'},{name:'Gorge'}];

for(var i=0;i<_list.length;i++)
{
   if(_name.map(function (c) {
     return c.toLowerCase();
   }).indexOf(_list[i].name.toLowerCase()) != -1) { 
  //do what ever
   }else{
     //do what ever
   }
}



var\u name=['prasho'，'abraham'，'sam'，'anna']
var_list=[{name:'prasho'}，{name:'Gorge'}]；

对于（var i=0；i将数组转换为由分隔符分隔的字符串，将该字符串转换为小写，然后使用相同的分隔符将该字符串拆分回数组：



函数findIt（arr、find、del）{
如果（！del）{del='.//.'}
arr=arr.join（del）.toLowerCase（）.split（del）；
返回arr.indexOf（find.toLowerCase（））；
}
var arr=[“汤姆·里德尔”、“罗恩·韦斯莱”、“哈利·波特”、“赫敏·格兰杰”]；
var find=‘哈利波特’；
var指数=findIt（arr，find）；
如果（~索引）{
警报（'Found'+arr[index]+'！：D'）；
}否则{
警报（'未找到它。D:'）；

}
这是最短的


haystack.join(' ').toLowerCase().split(' ').indexOf(needle.toLowerCase())



我需要类似的东西，我需要使用
includes
比较两个字符串，并且需要能够支持大小写和不区分大小写的搜索，所以我编写了以下小函数


function compare(l1: string, l2: string, ignoreCase = true): boolean {
  return (ignoreCase ? l1.toLowerCase() : l1).includes((ignoreCase ? l2.toLowerCase() : l2));
}


同样的原则也适用于
indexOf
，如下所示


function indexOf(l1: string, l2: string, ignoreCase = true): number {
  return (ignoreCase ? l1.toLowerCase() : l1).indexOf((ignoreCase ? l2.toLowerCase() : l2));
}


我知道这不是特别的
Array.indexOf
，但希望这能帮助那些在旅行中遇到这篇文章的人

不过，为了回答ops问题，您可以将其类似地应用于与this from组合的数组（对它的细微更改是在任何数组值包含空格的情况下使用tilda字符作为分隔符）

再次希望这有帮助。
您可以使用
例如：


myArray = ['An', 'aRRay', 'oF', 'StringS'];
searchString = 'array';
found = myArray.find(key => key.toUpperCase() === searchString.toUpperCase()) != undefined;
if (found ) {
    // The array contains the search string
}
else {
    // Search string not found
}


注意：数组不能将
未定义的
作为值。
不能将
设为.ind

// unique only, removes latter occurrences    
array.filter((v, i, a) => a.findIndex(j => v.toLowerCase() === j.toLowerCase()) === i);



myArray = ['An', 'aRRay', 'oF', 'StringS'];
searchString = 'array';
found = myArray.find(key => key.toUpperCase() === searchString.toUpperCase()) != undefined;
if (found ) {
    // The array contains the search string
}
else {
    // Search string not found
}



// unique only, removes latter occurrences    
array.filter((v, i, a) => a.findIndex(j => v.toLowerCase() === j.toLowerCase()) === i);