首页 > 试题广场 >

智能提示

[编程题]智能提示
  • 热度指数:2991 时间限制:C/C++ 2秒,其他语言4秒 空间限制:C/C++ 256M,其他语言512M
  • 算法知识视频讲解
本题展示了一个简化版的搜索框智能提示功能,请按照如下要求完成suggest函数。
1、当输入框的值发生变化时,系统会调用suggest函数,用于显示/隐藏智能提示数据,参数items为一个字符串数组。
2、当items中的字符串和输入框的值匹配时,将匹配的数据依次渲染在ul下的li节点中,并显示.js-suggest节点,否则移除ul下的所有li节点,并隐藏.js-suggest节点
3、输入框的值需要移除两侧空白再进行匹配
4、输入框的值为空时,按照全部不匹配处理
5、字符串使用模糊匹配,比如"北大"能匹配"北大"和"北京大学",但不能匹配"大北京",即按照 /北.*?大.*?/ 这个正则进行匹配
6、通过在.js-suggest节点上添加/移除 hide 这个class来控制该节点的隐藏/显示
7、当前界面是执行 suggest(['不匹配数据', '根据输入框的值', '从给定字符串数组中筛选出匹配的数据,依次显示在li节点中', '如果没有匹配的数据,请移除所有li节点,并隐藏.js-suggest节点']) 后的结果
8、请不要手动修改html和css
9、不要使用第三方插件
10、请使用ES5语法
提交没通过,把代码复制到本地测了一下,就当是做练习了。
function suggest(items) {
    var input = document.querySelector('input');
    var ulDoc = document.querySelector('ul');
    ulDoc.childNodes.forEach(item => ulDoc.removeChild(item));
    if(input.value.trim() !== '') {
      var regExp = new RegExp((input.value.trim().split('').join('.*?')) + '.*?', 'i');
      document.querySelector('.js-suggest').hidden = false;
      items.forEach(item => {
        if(regExp.test(item)) {
            var node = document.createElement('li');
            var textNode = document.createTextNode(item);
            node.appendChild(textNode);
            ulDoc.appendChild(node);
        }
      })
    } else {
      document.querySelector('.js-suggest').hidden = true;
    }
}


编辑于 2020-09-03 10:24:11 回复(2)
function suggest(items) {
 var oinput = document.querySelector('.js-input')
    var osuggest = document.querySelector('.js-suggest')
    var oul = osuggest.querySelector('ul')
    for(var i =oul.children.length - 1;i>=0;i--){
        oul.removeChild(oul.children[i])
    }
    var val = oinput.value.trim()
    if(val == ""){
        osuggest.classList.add('hide')
        return
    }
    var str = val.split('').reduce((total,val)=>{
        if(/[\(\)\.\*\^\\\[\]\{\}\?]/.test(val)){
                val = '\\' + val
            }
            return total += val + '.*'
        },'')
    var reg = new RegExp(str,'')
    var resultstr = ""
    items.forEach(item =>{
        if(reg.test(item)){
            resultstr += `<li>${item}</li>`
        }
    })
    if(resultstr == ''){
        osuggest.classList.add('hide')
    }else {
        osuggest.classList.remove('hide')
        oul.innerHTML = resultstr
    }
}
发表于 2021-06-07 17:12:16 回复(2)
function suggest(items) {
    let jsSuggest = document.querySelector(".js-suggest"),
        jsInputVal = document.querySelector(".js-input").value.trim(), // 移除两侧空白后的输入框中的值
        liEl = "", // 渲染的结构
        reg = ""; // 正则字符串
    // 清空ul
    jsSuggest.children[0].innerHTML = ""
    if (!jsInputVal) return jsSuggest.classList.add("hide");
    // 循环添加模糊匹配正则
    for (let i = 0; i < jsInputVal.length; i++) {
        // 匹配转义字符,特殊的转义字符需要加\\,例如\\*在转译为正则时会转为\*而不是*,*在正则中有特殊的表达意思
        if(/[\$\^\(\)\+\[\]\|\?\\\/\*\.]/.test(jsInputVal[i])){
            reg += '\\' + jsInputVal[i] + ".*?";
        }else {
            reg += jsInputVal[i] + ".*?";
        }
    }
    // 循环判断当前字符串是否匹配正则
    for (let index = 0; index < items.length; index++) {
      if (RegExp(reg).test(items[index])) {
        liEl += "<li>" + items[index] + "</li>";
      }
    }
    if (!liEl) return jsSuggest.classList.add("hide");
    jsSuggest.classList.remove("hide");
    jsSuggest.children[0].innerHTML = liEl;
}

发表于 2022-07-13 15:19:37 回复(0)
根据用例调试了几遍终于提交成功了!!!
因为用例也考虑了,输入中各种不能被识别的正则表达式的特殊字符,对特殊字符需要进行转义处理!!!
function suggest(items) {
    var input = document.querySelector('.js-input');
    var div = document.querySelector('.js-suggest');
    var ul = document.querySelector('.js-suggest ul');
    var inputValue = input.value.trim(); //移除两侧空白
    
    ul.innerHTML = '';
    // 输入框的值为空时,按照全部不匹配处理
    if(!inputValue){
        div.classList.add('hide');
    }else{
        //字符串和输入框的值匹配
        var str = ''; // 正则表达式
        var istrue = false;
        if(/(\(|\)|\||\.|\?|\*|\+|\\|\[|\])/.test(inputValue.toString())){
            Array.from(inputValue.toString()).forEach(el=>{ 
                str += '\\'+ el+'.*?';
            })
        }else{
            Array.from(inputValue.toString()).forEach(el=>{ 
                str += el+'.*?';
            })
        }
        items.forEach(item=>{
            console.log(item.search(str))
            if(item.search(str)!=-1){
                istrue=true;
                ul.innerHTML += `<li>${item}</li>`;
            }
        })
        
        if(istrue){
            console.log('suggest');
            div.className='js-suggest';
        }else{
            console.log('hide');
            div.classList.add('hide');
        }
    }
}


发表于 2022-02-17 18:22:50 回复(0)
 input = document.getElementsByTagName('input')[0]
        div = document.getElementsByClassName('js-suggest')[0]
        function suggest(items) {
            let ipt = document.querySelector('.js-input').value.trim();
            var htmlLi = "";
            const regKey = ['(', ')', '.', '?', '^', '/', '\\', '*', '[', ']', '|', '+', '{', '}', '$'];
            console.log(regKey.length);
            var value = "";
            for (i of ipt) {
                if (regKey.includes(i)) {
                    i = '\\' + i;
                }
                value += i + ".*?";
            }
            console.log("123123",value)
            // value = value.replace(/(.)/g, "$1.*?");
            var reg = new RegExp(value)
            items.forEach(element => {
                if (reg.test(element)) {
                    htmlLi +="<li>" + element + "</li>"
                }
            });
            var ul = document.getElementsByTagName("ul")[0]
            ul.innerHTML = htmlLi;
            if (ul.childNodes.length == 0||value=="") {
                div.classList.add('hide')
                ul.innerHTML = ""

            } else {
                div.classList.remove('hide')
            }
           
        }
发表于 2023-11-04 17:32:50 回复(0)
<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8">
    <style>
       .search{
    position: relative;
}
.js-input{
    width: 450px;
    height: 22px;
    line-height: 22px;
    font-size: 16px;
    padding: 8px;
    border: 1px solid #cccccc;
    outline: none;
}
.js-suggest{
    width: 466px;
    font-size: 14px;
    border: 1px solid #cccccc;
    background: #ffffff;
    position: absolute;
    left: 0;
    top: 39px;
}
.js-suggest.hide{
    display: none;
}
.js-suggest ul{
    display: block;
    list-style: none;
    padding: 0;
    margin: 0;
}
.js-suggest ul li{
    color: #000;
    font: 14px arial;
    line-height: 25px;
    padding: 0 8px;
    position: relative;
    cursor: default;
}
.js-suggest ul li:hover{
    background: #f0f0f0;
}
    </style>
</head>

<body>
    <div class="search">
    <div><input type="text" class="js-input" value="的"></div>
    <div class="js-suggest">
        <ul>
            <li>根据输入框的值</li>
            <li>从给定字符串数组中筛选出匹配的数据,依次显示在li节点中</li>
            <li>如果没有匹配的数据,请移除所有li节点,并隐藏.js-suggest节点</li>
        </ul>
    </div>
</div>
    <script type="text/javascript">
        function suggest(items) {
            var input = document.querySelector('.js-input');
            var suggest = document.querySelector('.js-suggest');
            var hide = document.querySelector('.hide');
            var value = input.value.trim();
            if (value) {
                suggest.classList.remove('hide');
                var reg = new RegExp('^' + value);
                var result = items.filter(function(item) {
                    return reg.test(item);
                });
                console.log(result);
                if (result.length) {
                    var ul = suggest.querySelector('ul');
                    ul.innerHTML = result.map(function(item) {
                        return '<li>' + item + '</li>';
                    }).join('');
                } else {
                    suggest.classList.add('hide');
                }
            } else {
                suggest.classList.add('hide');
}

}
var input = document.querySelector('.js-input');
input.addEventListener('input', function() {
  suggest(['不匹配数据', '根据输入框的值', '从给定字符串数组中筛选出匹配的数据,依次显示在li节点中', '如果没有匹配的数据,请移除所有li节点,并隐藏.js-suggest节点', '如果输入框的值为空,请隐藏.js-suggest节点'])
}, false);
    </script>
</body>

</html>
发表于 2023-09-07 19:55:50 回复(0)
终于有一题我直接通过了,前面的几题都是本地好用,测试不通过,害我找了半天问题。但这题直接拿下!
function suggest(items) {
   let ul = document.getElementsByTagName('ul')[0];
        let jsSuggest = document.getElementsByClassName('js-suggest')[0];
        let jsInput = document.getElementsByClassName('js-input')[0];

        console.log(jsInput);

        let reg = '';
        let keyWord = jsInput.value.trim();
        
        //一共有12个特殊字符
        let special = ['(',')','.','[','{','|','\\','?','+','*','^','$'];
        keyWord.split('').forEach((s) => {
            if(special.includes(s)) {
                s = '\\' + s;
            }
          reg += `${s}.*?`;
        });
        reg = `^.*?${reg}$`;

        items = items.filter((item) => {
            console.log('拼接的正则',reg)
            console.log('匹配的内容',item)
            console.log('',new RegExp(reg).test(item))
          return keyWord.length != 0 && new RegExp(reg).test(item);
        });

        if (items.length != 0) {
          jsSuggest.classList.remove('hide');
          ul.innerHTML = '';
            console.log(jsInput.value,'进入')
          for (let i = 0; i < items.length; i++) {
                let liNew = document.createElement('li');
                console.log(liNew,'新节点')
                liNew.innerHTML = items[i];
                ul.appendChild(liNew);
          }
        } else {
          ul.innerHTML = '';
          jsSuggest.classList.add('hide');
        }
    
}

发表于 2023-03-08 17:27:00 回复(0)
function suggest(items) {
    var inputValue = document.querySelector('.js-input').value.trim(); // 获取input值
    var testUl = document.querySelector('ul');
    var testUlDiv = document.querySelector('.js-suggest');
    var allLi = Array.from(testUl.querySelectorAll('li')); // 获取展示列表
    // 特殊字符数组
    const regKey = ['(', ')', '.', '?', '^', '/', '\\', '*', '[', ']', '|', '+', '{', '}', '$'];
    for(let i=allLi.length-1;i>=0;i--){ // 处理前先清除所有子节点,注意从后往前删,否则有残留
        testUl.removeChild(allLi[i]);
    }
    if(inputValue === ''){ // 输入空不匹配
        testUlDiv.classList.add('hide');
    } else {
        var tempStr = inputValue.split('');
        var reg = '';        
        for(let i=0;i<tempStr.length;i++){
            if(regKey.indexOf(tempStr[i])>-1){ // 如果是特殊字符需要转义
                tempStr[i] = '\\' + tempStr[i];
            }
        }
        reg = new RegExp(tempStr.join('.*?')+'.*?'); // 按要求拼接
        for(let i=0;i<items.length;i++){
            if(reg.test(items[i])){ // 匹配一个添加一个
                var tempLi = document.createElement('li');
                tempLi.innerHTML = items[i];
                testUl.appendChild(tempLi);
            }
        }
        if(testUl.querySelectorAll('li').length==0){ // 所有都没有匹配上也不展示
            testUlDiv.classList.add('hide');
        }
    }
}
发表于 2022-02-23 11:30:38 回复(0)
function suggest(items) {
    let ipt = document.querySelector('.js-input').value;
    let dv = document.querySelector('.js-suggest');
    let ul = document.querySelector('ul');
    let len = ul.children.length;
    // console.log('len', len);

    // 清空ul
    for (let i = 0; i < len; i++) {
        let li = document.querySelector('li');
        ul.removeChild(li);
    }
    // console.log(ul.children.length);

    ipt = ipt.trim();
    // 输入为空
    if (!ipt) {
        dv.classList.add('hide');
        return;
    }

    // 构造reg的时候,ipt如果是特殊字符,要转义
    let reg = '';
    const regKey = ['(', ')', '.', '?', '^', '/', '\\', '*', '[', ']', '|', '+', '{', '}', '$'];
    console.log(regKey.length);
    for (i of ipt) {
        if (regKey.includes(i)) {
            i = '\\' + i;
        }
        reg += i +'.*?';
    }
    // console.log(reg);
    reg = new RegExp(reg);

    // 匹配
    for (i of items) {
        if (reg.test(i)) {
            let tip = document.createElement('li');
            tip.innerHTML = i;
            ul.appendChild(tip);
        }
    }
    dv.appendChild(ul);

    // 要考虑ipt不为空但是没有匹配到
    if (ul.children.length){
        dv.classList.remove('hide');
    } else {
        dv.classList.add('hide');
    }
}
发表于 2022-02-12 15:09:14 回复(0)
function suggest(items) {
    var inputEl = document.getElementsByClassName('input')[0];
    var inputVal = inputEl.value.trim();
    var suggestEl = document.getElementsByClassName('js-suggest')[0];
    var isHide = false;
    input.addEventListener('change', inputChange);
    var inputChange = function(e){
        inputVal = e.target.value.trim();
        var regStr = '';
        for(let i=0, arr=inputVal.split('');i<arr.length;i++){
            regStr += `${arr[i]}.*?`;
        }
        let reg = new RegExp(regStr, gi);
        var resItems = items.filter(item => reg.test(item));
        isHide = inputVal === '' || resItems.length === 0;
        if(isHide){
            let liEls = suggestEl.getElementsByTagName('li');
            for(let i=0;i<liEls.length-1;i++){
                suggestEl.children[0].removeChild(liEls[0]);
            }
            suggestEl.classList.add('hide');
        }else{
            suggestEl.classList.remove('hide');
            for(let i=0;i<resItems.length-1;i++){
                let li = document.createElement('li');
                li.innerText = resItems[i];
                suggestEl.children[0].appendChild(li);
            }
        }
    }
}
没跑通过,但是感觉应该没问题?
发表于 2021-12-05 14:39:56 回复(0)
在这儿测太不方便了,要求都写的很清楚,自己写一个实现了这个功能就行了
下面是我自己实现的,测试用的items是
items = ['abc', 'acb', 'aaabc', 'baa'];

发表于 2021-05-27 11:30:00 回复(0)