第 151 题：用最简洁代码实现 indexOf 方法？
报告指定字符在此实例中的第一个匹配项的索引。搜索从指定字符位置开始，并检查指定数量的字符位置。
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
报告指定字符在此实例中的第一个匹配项的索引。搜索从指定字符位置开始，并检查指定数量的字符位置。
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
接受 或继续使用网站，即表示您同意使用 Cookies 和您的相关数据。
发布评论
评论（56）
function _indexOf(string, target) { if (typeof string !== 'string') { throw new Error('string only'); } let mt = string.match(new RegExp(target)) return mt ? mt.index : -1; }使用正则 indexOf('/:>-|+?','/:>-|+?') 这个测试用例应该通不过
indexOf 字符串，数组也能用吧，
function indexOfTest(arrOrString, target, index = 0) { if(Array.isArray(arrOrString)) { for(let i = index; i < arrOrString.length; i++) { if(arrOrString[i] == target) { return i } } return -1; } // 字符串 const newArr = arrOrString.split(target); if(newArr.length == 1) { return -1 } let res = 0; for(let j = 0; j < newArr.length; j++) { if(newArr[j] == "" && index == 0) { return 0 } if(res > index) { return res; } res += newArr[j].length || 1; } return res; }function formatIndexof(str, target, index) { let begin = index || 0; let end = str.length || 0; const tLen = target.length if (begin > end) { return -1; } if (tLen == 1 || Object.prototype.toString.call(str) === '[object Array]') { for (let i = begin; i < end; i++) { if (str[i] === target) { return i } } } else if (tLen > 1) { for (let i = begin; i < end; i++) { const temp = str.slice(i, tLen + i); if (target === temp) { return i } } } return -1; }@Zhou-Bill
formatIndexof("test", "tes")这样不是不行吗好像没说是数组还是字符的indexOf
function arrayIndexOf (array = [], item) { for (let i = 0; i < array.length; i++) { if (array[i] === item) { return i; } } return -1; } function stringIndexOf (str = '', subStr) { if (!subStr) return -1; for (let i = 0; i < str.length; i++) { if (str.substr(i, subStr.length) === subStr) { return i; } } return -1; }for循环 这题好像没什么考的意义哦
let str = 'hello wrod'
str.indexOf(str,'ll')
直接凉 兄弟
你赢了
indexOf有两种：返回从
fromIndex处开始搜索第一次出现的指定值的索引，如果未找到，返回-1返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回
-1解答
String.prototype.indexOf()
解题思路：正则，字符串匹配
function sIndexOf(str, searchStr, fromIndex = 0){ var regex = new RegExp(`${searchStr}`, 'ig') regex.lastIndex = fromIndex var result = regex.exec(str) return result ? result.index : -1 } // 测试 var paragraph = 'The quick brown fox jumps over the lazy dog. If the dog barked, was it really lazy?' var searchTerm = 'dog' // 测试一：不设置 fromIndex console.log(sIndexOf(paragraph, searchTerm)) // 40 console.log(paragraph.indexOf(searchTerm)); // 40 // 测试二：设置 fromIndex console.log(sIndexOf(paragraph, searchTerm, 41)) // 52 console.log(paragraph.indexOf(searchTerm, 41)); // 52测试成功
Array.prototype.indexOf()
解题思路：遍历匹配
function aIndexOf(arr, elem, fromIndex = 0){ if(!elem) return -1 for(let i = fromIndex; i < arr.length; i++) { if(arr[i] === elem) return i } return -1 } // 测试 var beasts = ['ant', 'bison', 'camel', 'duck', 'bison'] // 测试一：不设置 fromIndex console.log(aIndexOf(beasts, 'bison')) // 1 console.log(beasts.indexOf('bison')) // 1 // 测试二：设置 fromIndex console.log(aIndexOf(beasts, 'bison', 2)) // 4 console.log(beasts.indexOf('bison', 2)) // 4测试成功
总结一下
function indexOf(items, item, fromIndex = 0) { let isArray = Array.isArray(items); let isString = Object.prototype.toString.call(items) == '[object String]'; if (!isArray && !isString) throw new SyntaxError(); if(isArray) return sIndexOf(items, item, fromIndex) else return aIndexOf(items, item, fromIndex) }你也可以尝试使用遍历匹配法解决
sIndexOf问题（正则更简洁），这里不做介绍（和aIndexOf差不多的套路，不同的是，String类型可以一次匹配多个字符）更过编程算法题可见 JavaScript-Algorithms
只是单字符的
Array.prototype.myIndexOf = function (value, fromIndex) {
const len = this.length
let index = -1
fromIndex = fromIndex === undefined ? 0 : fromIndex
if (fromIndex < 0) {
fromIndex = len + fromIndex;
fromIndex = fromIndex < 0 ? 0 : fromIndex;
}
for (let i = fromIndex; i < len; i++) {
if (this[i] === value) {
index = i;
break;
}
}
return index
}
赞，不过 感觉 SyntaxError 换成 TypeError 是不是更好一点
function mockIndexOf(eles, target, startIndex = 0) { const dataType = Object.prototype.toString.call(eles); if (dataType === '[object Array]') { const len = eles.length; const _startIndex = startIndex >= 0 ? startIndex : startIndex + len; return eles.findIndex((v, index) => { return _startIndex <= index && v === target; }); } if (dataType === '[object String]') { const len = eles.length; const _startIndex = startIndex >= 0 ? (startIndex < len ? startIndex : len) : 0; const result = eles.substr(_startIndex).match(target); console.log(result, eles.substr(startIndex), target); return result ? result.index + _startIndex : -1; } throw new Error('第一个参数请传入数组或者字符串'); } mockIndexOf('dsafsa', 'sa')' // 1 mockIndexOf('dsafsa', 'sf')' // -1兼容实现字符串和数组的 indexOf，针对字符串处理方式不一样：
/** * 字符串 * @param str * @param target * @param start * @returns {number|*} */ function strIndexOf(str, target, start = 0){ if (start > str.length) { return -1; } if (start < 0) { start = 0; } for (let i = start; i < str.length; i++) { let current = str.substring(i, i + target.length); if (current === target) { return i; } } return -1; }function indexOf(a, b){ var index = a.split(b)[0].length; return index === a.length ? -1 : index; } var a = 'abcbbcddc'; var b = 'bb'; indexOf(a, b); // 3 indexOf(a, '1'); // -1// 使用startsWith function indexOf(src: string, slice: string): number { const _indexOf = (src: string, slice: string, index: number): number => { if (slice.length === 0 || src.length < slice.length) return -1 return src.startsWith(slice) ? index : _indexOf(src.slice(1), slice, index + 1) } return _indexOf(src, slice, 0) } // 循环版本 function indexOf2(src: string, slice: string): number { for (let i = 0; i < src.length && (src.length - i) >= slice.length; ++i) { if (src.startsWith(slice, i)) return i } return -1; } const a = 'abcdefghijkl' const b = 'ghi' const c = '123' console.log(indexOf(a, b)) // 6 console.log(indexOf(a, c)) // -1'123'.search(x)
先说下思路吧，比较笨，哈哈
abc与cccabcaaa这种比较，就是从第一个开始，每三个长度为一段进行比较abc比较ccc,abc比较cca,abc比较cab... 比较笨吧， 可能性能比较差，但是好理解。。function findIndex(key, obj) { console.log(`查找的对象${obj}`, `----查找的键值${key}`) let arr = [] let index = -1 //最后返回查找到的索引 /**********************如果是数组***********************/ if (obj instanceof Array) { arr = obj arr.some((i, indexA) => { if (i == key) { index = indexA return true } }) } /**********************如果是字符串***********************/ else if (typeof (obj) === 'string') { arr = obj.split('') let keyLen = key.length for(let i=0;i<=arr.length-keyLen;i++){ if(key === obj.substring(i, i+keyLen)){ index = i } } } else { return '不符合数据格式' } return index } console.log(31, findIndex('g', 'abcdefg')) console.log(32, findIndex(22, [22,33,444]))实现
/** * * @param {string} p */ function buildNext(p) { const m = p.length const N = [] let t = N[0] = -1 let j = 0 while (j < m -1) { if (0 > t || p[j] === p[t]) { j++ t++ // 根据已知信息如果p[j] !== t[i] 如果p[j] === p[t]则p[t]必然失配t[i]所以这次比较可以优化 N[j] = p[j] !== p[t] ? t : N[t] } else { t = N[t] } } return N } /** * kmp字符串模式匹配 * @param {string} t * @param {string} p */ function match(t, p) { let N = buildNext(p) let i = 0 let j = 0 const n = t.length const m = p.length while(j < m && i < n) { if (0 > j || t[i] === p[j]) { i++ j++ } else { j = N[j] } } return j === m ? i - j : -1 } export function indexOf(s, fromIndex = 0) { fromIndex = 0 > fromIndex ? this.length + fromIndex > 0 ? this.length + fromIndex : 0 : fromIndex console.log(fromIndex) const i = match(this.slice(fromIndex), s) return i > 0 ? fromIndex + i : i }测试
import { indexOf} from '@/dayily-interview/kmp' describe('kmp.js', () => { it('match success',() => { expect(indexOf.call('test success', 'c')).toBe(7) }) it('match fail',() => { expect(indexOf.call('test success', 'z')).toBe(-1) }) it('match success with from index', () => { expect(indexOf.call('test success', 's', 3)).toBe(5) }) it('match fail with from index', () => { expect(indexOf.call('test success', 't', 4)).toBe(-1) }) it('match success with complex', () => { expect(indexOf.call('test success', 'ucce', 3)).toBe(6) }) it('match with negative from index', () => { expect(indexOf.call('test success', 'ucce', -16)).toBe(6) }) it('match with negative from index', () => { expect(indexOf.call('test success', 'ss', -1)).toBe(-1) }) it('match with negative from index', () => { expect(indexOf.call('test success', 'ss', -2)).toBe(10) }) it('match with zero from index', () => { expect(indexOf.call('test success', 'ss', 0)).toBe(10) }) })思路一: 利用正则比对当前字符串找出位置
function indexOf1(str,val){
const reg = new RegExp(
${val},'gi');const result = reg.exec(str);
return result?result.index:-1;
}
思路二: 利用字符串截取循环找到符合截取值的位置
function indexOf2(str,val){
const sl = str.length;
const vl = val.length;
for(var i=0;i<=sl-vl;i++){
if(str.slice(i,vl+i)===val){
return i;
}
}
return -1;
}
class myString extends String { myIndexOf(str: string) { const O = Object(this); const reg = new RegExp(str, 'g'); const res = reg.exec(O); if (res) { return res.index; } return -1; } } const stringTest = new myString('abcdefg'); console.log(stringTest.myIndexOf('23')); console.log(stringTest.myIndexOf('cde')); export {};不通过
'CDEFGAB'.sIndexOf('EF') // log -1//js 实现indexof Array.prototype._indexOf=function(res,fromIndex){ let len = this.length; if(len === 0) return []; if(fromIndex > len){ fromIndex = len; } if(fromIndex <= 0){ fromIndex = 0 } for(let i = fromIndex; i < len; i++){ if(this[i] === res){ return i; } } return -1; }看了下评论区发现，此题说用最简单代码实现，故意误导了大家往简单的想...
其实还应考虑以下几点：
1.String.prototype.indexOf 和 Array.prototype.indexOf
2.indexOf第二个可选参数 fromIndex
3.字符串indexOf可以是连续的一段，例如'astring'.indexOf('ing')，实现时无法像处理数组一样 直接拆成一个个字符比较，而应该拆成多段（有多种组合）比较。
/** * @param {*} item * @param {Number} fromIndex */ function indexOf(item, fromIndex = 0) { if (fromIndex < 0) fromIndex = 0 if (fromIndex >= this.length) return -1 for (let i = fromIndex; i < this.length; i += 1) { if (Array.isArray(this)) { if (this[i] === item) return i } else if (typeof this === 'string') { for (let j = i; j < this.length; j += 1) { const sub = this.substring(i, j + 1) if (sub === item) return i } } } return -1 } // eslint-disable-next-line no-extend-native Array.prototype.myIndexOf = indexOf // eslint-disable-next-line no-extend-native String.prototype.myIndexOf = indexOf /** * test */ const arrRes = ['q', 'w', 'e', 'r'].myIndexOf('e', 1) console.log('arrRes: ', arrRes) const strRes = 'abcdefgkdeg'.myIndexOf('deg') console.log('strRes: ', strRes)String.prototype.indexOf = function (search, fromIndex = 0) { if (fromIndex < 0) fromIndex = 0; if (fromIndex >= this.length) return -1; let str = this; let reg = RegExp(`(?<=.{${fromIndex}})(${search})`); let result = reg.exec(str); return result ? result.index : -1; };数组，感觉这题是考indexOf的定义，fromIndex的各种取值对结果的影响
Array.prototype.indexOf = function (search, fromIndex = 0) { const arrLen = this.length; if (fromIndex >= arrLen) return -1; if (fromIndex < 0) { fromIndex = arrLen + fromIndex; } for (let i = fromIndex; i < arrLen; i++) { if (i < 0) { i = 0; continue; } if (search == this[i]) { return i; } } return -1; };function myIndexOf(source, target, start = 0) { if (Array.isArray(source)) { let res = -1; for (let i = start; i < source.length; i++) { if (source[i] === target) return res = i; } } if (typeof source === 'string') { const reg = new RegExp(target, 'g'); reg.lastIndex = start; const result = reg.exec(source); return result ? result.index : -1; } }Array.prototype._indexOf = function (val, start) { if (typeof start !== "number") start = 0; //start 非数字 if (start < 0) start = start + this.length //start 小于零 const index = this.slice(start).findIndex((item) => item === val); return index > -1 ? index + start : -1 } String.prototype._indexOf = function (val, start) { if (typeof start !== "number") start = 0; start = Math.min(Math.max(0, start), this.length) // start大于等于0小于字符串的长度 if (val === '') return start; // val为空字符串返回开始的位置 const reg = new RegExp(val); const res = this.slice(start).match(reg); return res ? res.index + start : -1 }String.prototype._indexOf = function (val, start) { if (typeof start !== "number") start = 0; // start非数字 start = Math.min(Math.max(0, start), this.length) // start大于等于0小于字符串的长度 if (val === '') return start; // val为空字符串返回开始的位置 const arr = this.slice(start).split(val); return arr.length >= 2 ? arr[0].length + start : -1 // 分割后的数组大于2就说存在，并且第一个值的长度加开始位置就是val的index }indexof如果像楼上们那样写的话，速度太慢了，最简单的就是直接用indexof，如果是要实现他，当然是用kmp算法，速度最快。
https://github.com/chengruixin/rax-search/blob/main/src/exactMatch/patternFinder.ts
const NOT_INCLUDE = -1;
String.prototype.indexOf = function(string, start = 0) {
if(typeof this !== 'string') throw new SyntaxError('SyntaxError, needs a string');
const reg = new RegExp(
${string}, 'ig');reg.lastIndex = start;
const result = reg.exec(this);
return result?.index ?? NOT_INCLUDE;
}
Array.prototype.indexOf = function(item, start = 0) {
if(!item) return NOT_INCLUDE;
if(Array.isArray(this)) throw new SyntaxError('syntax error， needs an array!');
for (let i = start; i < this.length; i++)
}
"hello world".indexOf('he')有的写得只能匹配单个字符@ghost2113 substr应该换成substring吧
// 暴力匹配 function ViolentMatch(s, p) { var i = 0, j = 0, pLen = p.length, sLen = s.length; while (i < sLen && j < pLen) { if (s[i++] != p[j++]) { i = i - (j - 2) - 1; j = 0; } } return j == pLen ? i - j : -1; }因为大家都不咋用这个参数，想不起来了呗
Array.prototype.myIndexOf = function(item, start = 0) {
const length = this.length;
const startPos = start >= 0 ? start : length + start;
if (start >= length) return -1;
for (let i = startPos; i < length; i++) {
if (this[i] === item) return i;
}
return -1;
};
function indexOf(str, serchStr, index) {
if(index){
return str.substr(index,).match(serchStr)?str.substr(index,).match(serchStr).index + index :-1
}else{
return str.match(serchStr)?str.match(serchStr).index:-1
}
}
function indexOf(arr,target,start=0){ if(start<0) start+=arr.length; if(start>=arr.length) return -1; for(let i=start;i<arr.length;++i){ if(arr[i]===target) return i; } return -1; }看了一圈怎么没人考虑indexOf的第二个起始参数呢？
function _indexOf(str, reg, fromIndex = 0) { let index = fromIndex; const { length } = str; if (index <= 0) index = 0; if (index >= length) return -1; const arr = str.slice(fromIndex).split(reg); return arr.length > 1 ? arr[0].length + fromIndex : -1 }这题考点在哪啊，没盖特到 ，难道是有什么特别6的写法吗
能使用其它数组api？
能的话，嘿嘿嘿：
const indexOf = (arr, val) => { return arr.findIndex(item => item === val); }Object.prototype.sIndexOf = function (char) { const len = this.length for (let i = 0; i < len; i++) { if (this[i] === char) { return i } } return -1 }字符串变为数组，用数组方法findIndex去查找。