[js] 第3天 去除字符串中最后一个指定的字符
haizhilin2013 opened this issue · comments
[js] 第3天 去除字符串中最后一个指定的字符
function delLast (str,del) {
if (tpeof str !== 'string') {
alert('请确认要删除的对象为字符串！');
retrun false;
} else {
let index = str.lastIndexOf(del);
str.substring(0,index ) + str.substring(index+1,str.length);
}
}
用的是张震的方法
function trim(str) { if(typeof str === 'string'){ var trimStr = str.substring(0,str.length-1) } return trimStr; }
🐶
function delLast(str, target) {
return str.split('').reverse().join('').replace(target, '').split('').reverse().join('');
}
const str = delLast('asdfghhj', 'h')
console.log(str) // asdfghj 
String.prototype.reverse = function () {
return this.split('').reverse().join('')
}
String.prototype.removeFirstChar = function (m) {
return this.replace(m, '')
}
const string = 'emamam, your string'
const removedChar = 'm'
string.reverse().removeFirstChar(removedChar).reverse()
function delLast(str,target) {
let reg =new RegExp(`${target}(?=([^${target}]*)$)`)
return str.replace(reg,'')
}
怎么开始全是正则？？？？@haizhilin2013
function delLastStr(str, delStr) {
for (let i = str.length - 1; i >= 0; i --) {
if (delStr === str[i]) {
return str.substring(0, i) + str.substring(i+1);
}
}
return str;
}
function delLast(str, target) { return str.split('').reverse().join('').replace(target, '').split('').reverse().join(''); } const str = delLast('asdfghhj', 'h') console.log(str) // asdfghj
1：性能问题
2：太长了
个人见解
var str = "array"
str.substr(0, str .length-1);
str.substring(0, str .length-1);
function del(str, n) {
str = [...str]
const idx = str.lastIndexOf(n);
return str.splice(idx, 1).join('');
}
function delLast (str,del) {
if (tpeof str !== 'string') {
alert('请确认要删除的对象为字符串！');
retrun false;
} else {
let index = str.lastIndexOf(del);
str.substring(0,index ) + str.substring(index+1,str.length);
}
}
用的是张震的方法
---楼主typeof打错啦，还有str.substring(0,index ) + str.substring(index+1,str.length);这行应该也要return一下吧，不然成功删除了以后没有返回值
const removeRight = (str, target) => {
if (!str || !target) {
return str;
}
const idx = str.lastIndexOf(target);
if (idx > -1) {
return str.slice(0, idx) + str.slice(idx + 1);
} else {
return str;
}
};
const str = "aaa1 bc de a 2";
console.log(removeRight(str, "e"));
console.log(removeRight(str, "a"));
console.log(removeRight(str, "c"));
思路：循环，从字符串尾部开始移动，直到匹配到的第一个目标字符，将它删除，退出循环，循环结束或退出后，返回字符串。
var filterLast = function(str, del) {
const index = str.lastIndexOf(del);
if(index > -1) {
str = [...str];
str.splice(index, 1);
return str.join('');
}
return str;
}
@undefinedYu 借用了一下你的方法稍作修改,让它能输出
var str = "123456789"
function strdelete (str, del) {
if (typeof str !== 'string') {
return false
} else {
var index = str.lastIndexOf(del)
return str.substring(0,index ) + str.substring(index+1,str.length);
}
}
strdelete(str, "9")
function delString(str, delChar) {
if (!str || typeof str !== 'string' || !delChar || typeof delChar !== 'string') return false;
let arr = str.split('');
let idx = arr.lastIndexOf(delChar);
arr.splice(idx, 1);
return arr.join('');
}
前面有朋友通过[...str]来实现，没考虑到如果不是单一字符的情况吧
我也来添加一个
function removeLastStr(str, dstr) {
var arr = str.split(dstr);
var len = arr.length;
var nArr = [].concat(arr.slice(0, len-2))
nArr.push(arr[len-2]+arr[len-1])
return nArr.join(dstr)
}
lastIndexOf看看最后字的索引，截取即可
function subStrIn(str, value) {
if (typeof str !== "string" || typeof value !== "string") {
throw new Error("非字符串!");
}
let length = str.length;
let lastIndex = str.lastIndexOf(value);
// 截取
return str.substr(0, lastIndex) + str.substr(lastIndex + 1, length);
}
console.log(subStrIn("1234345", "3"));
/**
*
* @param string '字符串'
* @param delItem '删除的字符'
*/
function delLastItem(string,delItem){
let arr = string.split('')
arr.map((item,index)=>{
if(delItem === item){
arr.splice(index,1)
}
})
console.log(136,arr.join(''))
}
delLastItem('12323sdaas2','a') //输出 '12323sdas2'
function deleteSpecifiedLastCharacter(str, char) {
if (!char || typeof str !== 'string' || typeof char !== 'string') return str
return str.replace(new RegExp(`${char}(?=([^${char}]*)$)`), '')
}
var a = (str,s)=>{
var a = str.lastIndexOf(s)
// console.log(a)
// console.log(str.substring(0,a))
// console.log(str.substring(a+1,str.lenth))
console.log(str.substring(0,a)+(str.substring(a+1,str.lenth)))
}
a('abcdefghgh','g')
function delLast(str,target) { let reg =new RegExp(`${target}(?=([^${target}]*)$)`) return str.replace(reg,'') }
delLast('emamam, your string', 'ur') // =>emamam, your string
function delLastStr(str, delStr) {
const reg = new RegExp(`^(.*)(${delStr})(.*)$`)
return str.replace(reg, '$1$3')
}
delLastStr('emamam, your string', 'ur')
// 字符串自带查找字符串最后出现的位置：lastIndexOf
let str = '1 ab c c c ca asdab aaa'
console.log((function (str, keyword) {
let index = str.lastIndexOf(keyword)
return index === -1 ? str : str.slice(0, index) + str.slice(index + keyword.length)
})(str, 'ab'))
function removeLastAppearedChar ( string = ``, char = `` ) {
return string.replace( new RegExp( `${ char }(?=[^${ char }]*$)`, `u` ), `` );
}
function removeLastAppearedChar ( string = ``, char = `` ) {
const index = string.lastIndexOf( char );
return -1 < index ?
string.slice( 0, index ) + string.slice( index + 1 ) :
string;
}
function removeLast(str,k){
return str.slice(0,str.lastIndexOf(k)) + str.slice(str.lastIndexOf(k)+1)
}
const removeLastStr = (str, target) => {
if (!str || !target) {
return str;
}
if(typeof str !== 'string'){
alert('输入的对象不是字符串!');
return false;
}
const idx = str.lastIndexOf(target);
if (idx > -1) {
return str.slice(0, idx) + str.slice(idx + 1);
} else {
return str;
}
};
String.prototype.splitStringLastChar = function(s) {
let len = this.length - 1;
for(; len >= 0; len--) {
if(this[len] === s) {
return this.slice(0,len) + this.slice(len+1,this.length)
}
}
return this.toString();
}
let arr = 'you are my uu'
arr.split('').reverse().join('').replace('u','').split('').reverse().join('')
两种正则的方式：
function deleteLastWord (str, word) {
const reg = new RegExp(`${word}(?!.*${word}.*)`) // 先行否定断言
return str.replace(reg, '')
}
function deleteLastWord(str, word) {
const reg = new RegExp(word, 'g');
let info, index = str.length
while (info = reg.exec(str)) { // 直到exec匹配结束
index = info.index
}
return str.substring(0, index) + str.substring(index + word.length)
}
不过在去除多个字符时(虽然题目没这样要求)，当两处匹配的结果重叠时都会出现问题：
deleteLastWord('ABCABCABC', 'CABC')
// 结果是 "ABABC"（匹配到第3位的C） 预期为 "ABCAB"（匹配到第6位的C）
'ABCABCABC'.lastIndexOf('CABC')
// 结果是 5（匹配到第6位的C)
function remove(str,word){
for (let index = s.length; index >0; index--) {
if (s[index]===k) {
let t =s.substr(0,index)+s.substr(index+1,s.length);
return t;
}
}
}
function trimEnd(str, del) {
let cacheIndex = str.lastIndexOf(del);
if (!!~cacheIndex) {
return str.slice(0, cacheIndex) + str.slice(cacheIndex + 1);
}
return str;
}
trimEnd("abcabcabc", "c");
function removeLastWord(str,word){
const lastIndex = str.lastIndexOf(word);
const strArr = str.split('');
strArr[lastIndex] = '';
return strArr.join('')
}
removeLastWord('mymother','m')
/**
* 删除匹配到的字符串（根据第三个参数 决定删除第一个还是最后一个）
* @param {String} str 原字符串
* @param {String} deleteStr 你想删除的字符串(长度可以超过1)
* @param {String} where ['last' || 'first']
*/
function deleteSubString(str, deleteStr, where = "last") {
if (typeof str !== "string" || typeof deleteStr !== "string")
throw new Error("params only accept String");
let index =
where === "last" ? str.lastIndexOf(deleteStr) : str.indexOf(deleteStr);
if (index === -1) return str;
let deleteLength = deleteStr.length;
return str.substring(0, index) + str.substring(index + deleteLength);
}
console.log(deleteSubString("1as2as3", "as")); // '1as23'
console.log(deleteSubString("1as2as3", "as", 'first')); // '12as3'
function rmLastC(str , c) {
const temp = str.split('').reverse()
const index = temp.indexOf(c)
temp.splice(index, 1)
return temp.reverse().join('')
}
可以删除多个字符
function deleteChars(str, target) {
let index = str.lastIndexOf(target)
if (index === -1) return str
let arr = [...str]
arr.splice(index, target.length)
return arr.join('')
}
console.log(deleteChars('abscdsg', 'ds'))
// abscg
/**
* @param {string} str
* @param {string} char
* @return {string}
*/
function delLastChar(str, char) {
var arr = str.split("");
return (arr.splice(str.lastIndexOf(char), 1), arr).join("");
}
function del(str, n) { str = [...str] const idx = str.lastIndexOf(n); return str.splice(idx, 1).join(''); }
Wrong Anwser
splice(idx, 1)返回的是修改的字符串，而不是原串
str.splice(idx, 1);
return str.join('');const removeLastChar = (str, char) => {
let index = str.lastIndexOf(char)
let arr = Array.from(str)
arr.splice(index, 1)
return arr.join('')
}
console.log(removeLastChar('123a456', 'a'))
function del(str, char) {
if (str && char && typeof char === 'string' && typeof str === 'string') {
let arr = str.split('');
let index = arr.lastIndexOf(char);
if(index !== -1) {
arr.splice(index, 1)
}
return arr.join('');
}
return str;
}
const deleteStringForLastFlag = (str, flag) => {
const string = str.toString()
const lastIndex = string.lastIndexOf(flag)
const head = string.substr(0, lastIndex)
const foot = string.substr(lastIndex + 1, string.length)
return head + foot
}
// 去除字符串中最后一个指定的字符
let removeLastChar = (str, char) => {
let strArr = str.split('');
for (let i = strArr.length - 1; i >= 0; i--) {
if (strArr[i] === char) {
// str = str.slice(0, i) + str.slice(i + 1, str.length);
strArr.splice(i, 1);
break;
}
}
// return str;
return strArr.join('');
}
console.log(removeLastChar('aqsbwasfesd', 's'))
function delLast(str = 'asdasdasd', target = 's') {
let index = str.lastIndexOf(target)
return str.substring(0, index) + str.substring(index + 1, str.length)
}
function deleteLastStr(origin, str) {
if (typeof origin === "string" && typeof str === 'string') {
var arr = origin.split('')
arr.splice(origin.lastIndexOf(str), 1);
return arr.join('');
} else {
throw "数据类型错误";
}
}
console.log(deleteLastStr('origin', 'n'));// origi
function delLast(str, current) {
if(typeof str == "string") {
let index = str.lastIndexOf(current);
if(index != -1) {
let arr = str.split('');
arr.splice(index,1);
return arr.join('');
} else {
return str;
}
return str.substr(0, str.length -1);
} else {
throw "请输入有效字符串！";
}
}疑问： 直接使用 return str.split('').splice(index,1).join(''); 时结果有误，是什么问题导致的的呢？求解答
function delLast(str, del) {
if (typeof str !== "string") {
return console.log("输入字符串，匝总");
}
var index = str.lastIndexOf(del);
return str.substring(0, index) + str.substring(index + 1);
}
var str = "hello, world";
console.log(delLast(str, "l"));
function delLast(str, current) { if(typeof str == "string") { let index = str.lastIndexOf(current); if(index != -1) { let arr = str.split(''); arr.splice(index,1); return arr.join(''); } else { return str; } return str.substr(0, str.length -1); } else { throw "请输入有效字符串！"; } }疑问：
直接使用 return str.split('').splice(index,1).join(''); 时结果有误，是什么问题导致的的呢？求解答
因为Array.prototype.splice()的返回值是被修改的内容，详情查看API文档 @zlqGitHub
11
function deleteLastChat(str,chat){
let index = str.lastIndexOf(chat);
let arr = str.split('');
arr.splice(index,1)
return arr.join('')
}
deleteLastChat('abababass','a')
var str = '12345678901234567890123456789asdsadavvv'
str = str.substring(0, str.lastIndexOf('8')) + str.substring(str.lastIndexOf('8') + 1, str.length)
console.log(str)
function remove(str,target){
const index=str.lastIndexOf(target);
return str.slice(0,index)+str.slice(index+1)
}
function removeStr(str) {
let strlist = str.split('')
let result = strlist.slice(0,-1).join()
return result;
}
let strs = 'abcdef'
console.log(removeStr(strs))
function removeLastTxt(txt, target) {
const len = txt.length
const txts = txt.split('')
let output = ''
let isMatch = false
for (let i = len - 1; i >= 0; i--) {
if (txts[i] === target) {
if (isMatch) {
output = txts[i] + output
} else {
isMatch = true
}
} else {
output = txts[i] + output
}
}
return output
}
function delLast(str, del) {
if (typeof str !== "string") throw new Error(`${str} It's not a string`);
var lastIndex = str.lastIndexOf(del);
if (lastIndex < 0) return str;
return str.substring(0, lastIndex) + str.substring(lastIndex, str.length - 1);
}
(str, del) => str.replace(RegExp(del+'$'), '')
var str = 'sdfasdgsdfg';
var func = function(str, target){
var index = str.indexOf(target);
return str.substring(0, index) + str.substring(index+1);
}
func(str, 'f');//sdfasdgsdg
function del(str, n) { str = [...str] const idx = str.lastIndexOf(n); return str.splice(idx, 1).join(''); }
return splice的话只会return第一个哦
function removeStr(str,del){
str=[...str] //转为数组
str.splice(str.lastIndexOf(del),1) //去除数组中最后一个指定字符
return str.join("") //转为字符串
}
console.log(removeStr("abakjsdh","a")) //abkjsdh
提供一个反转思路
'vvvvvvvvasdfvvvvvvasdfvvvvv'.split('').reverse().join('').replace(/fdsa/, '').split('').reverse().join('');
function delLast(str, target) { return str.split('').reverse().join('').replace(target, '').split('').reverse().join(''); } const str = delLast('asdfghhj', 'h') console.log(str) // asdfghj1：性能问题
2：太长了个人见解
这个方法只适合一个删掉一个字符
delLast('wo shi ni shi sha', 'shi')
'wo shi ni shi sha'.split('').reverse().join('') // 'ahs ihs in ihs ow'
'ahs ihs in ihs ow'.replace('shi', '') // 找不到
function delLast(str, del) { if (typeof str !== "string") throw new Error(`${str} It's not a string`); var lastIndex = str.lastIndexOf(del); if (lastIndex < 0) return str; return str.substring(0, lastIndex) + str.substring(lastIndex, str.length - 1); }
console.log(delLast('abcabcab','cab')) // 'abcabca'
function removeLast(str, code) {
var index = str.lastIndexOf(code);
return ~index ? str.substring(0, index) + str.substring(index + code.length) : str;
}
function delLast(str, delVal) {
let arr = str.split('')
arr.splice(str.lastIndexOf(delVal), 1)
return arr.join('')
}
let str = '12345678'
console.log(delLast(str, '7')) // output: 1234568
/**
- 移除字符串最后一个指定的目标字符串
- 使用字符串方法
- **/
function delLastString(str, target) {
let index = str.lastIndexOf(target);
if(index > -1){
return str.slice(0,index) + str.slice(index + 1);
}
return str;
}
function deleteLastThisChar(str, char){
let temp = str.split('')
temp.splice(str.lastIndexOf(char, str.length - 1), 1)
return temp.join('')
}
deleteLastThisChar('1x1x1x1x1x', 'x')
cosnt delLastChar = (str='', target='') => {
const idx = str.lastIndexOf(target);
if(idx===-1)return str;
const charList = str.split('');
charList.splice(idx,1);
return charList.join('');
}
function fn(str, target) {
let reg = new RegExp(`${target}(?=([^${target}]*)$)`)
return str.replace(reg, '')
}function delLastChar(str,char) {
let formatterStr='';
let lastIndex = str.lastIndexOf(char);
let arr = str.split('');
if(lastIndex === -1){
return str;
}else{
arr.splice(lastIndex,1);
return arr.join('')
}
}
let str = ' what are you nong sha lie ?? ';
function delLastCh(st, ch) {
let index = st.lastIndexOf(ch);
return st.substring(0, index) + st.substring(index + 1);
}
str = delLastCh(str, 'a');
console.log(str);
function fun(str, del) {
let index = str.lastIndexOf(del);
let newStr = str.replace(str[index], '');
return newStr;
}
let str = 'goodmorning';
let del = 'i';
fun(str, del);
function delLast(str, target){
var map = str.split(target);
var newstr = '';
console.log(map);
for(var i = 0;i < map.length;i++){
if(i === map.length - 1 || i === map.length - 2){
newstr = newstr + map[i];
}else{
newstr = newstr + map[i] + target;
}
}
return newstr;
}
delLast('abcc abcdabceabc','abc');
var str = "aabbccddqwetaasdaszc";
rp_f(str, "a");
function rp_f(str, item) {
var arr = str.split("");
var num = arr.lastIndexOf(item);
arr.splice(num, 1);
var str_new = arr.join(",");
str_new.replace(",", "");
str_new = str_new.replace(/,/g, "");
}
[js] 第3天 去除字符串中最后一个指定的字符
let str = "abdhdgshajdgsadshadjjj”;
function delateStr (str, del) {
if(typeof str === 'string') {
return str.split('').reverse().join('').replace(del,'').split('').reverse().join('');
} else {
console.log('请输入字符串');
}
}
console.log(delateStr(str,'d'))
var str = 'asdagghalk'
function _del(str, delStr){
let reg = new RegExp(delStr, 'g')
let matchLen = str.match(reg) ? str.match(reg).length : -1
let count = 0
return str.replace(reg, function(){
return matchLen === ++count ? '' : arguments[0]
})
}
_del(str, 'a')
let str = "abdhdgshajdgsadshadjjj";
function del(str, params) {
let index = str.lastIndexOf(params);
return str.substring(0, index) + str.substring(index + 1);
}
console.log(del(str, "m"));
function removeLastTarge(str, target) {
const index = str.lastIndexOf(target);
return str.substr(0,index ) + str.substr(index).replace(target, '')
}
removeLastTarge('abcadbcadbcdaaa', 'd') //abcadbcadbcaaa
removeLastTarge('abcadbcadbcdaaa', 'bc') //abcadbcaddaaa
function findLast(str,target) {
let loc = 0;
let j = 0;
for (i of str) {
// console.log(i,target,j);
j++;
if (i == target) {
loc = j;
}
}
return loc;
}
function myDel(str,target) {
let loc = findLast(str,target);
// console.log(loc);
let res = "";
let j = 0;
for (i of str) {
if (j == loc-1) {
j++;
continue;
}
res += i;
j++;
}
return res;
}
let str = "sadasdadasdasd";
let target = "s";
let res = myDel(str,target);
console.log(str);
console.log(res);
const str1 = '1112223331112';
function RemoveLastX(str, x){
let num=str.length-1-str.split('').reverse().indexOf(x);
return str.substring(0,num)+str.substring(num+1,str.length);
}
console.log(RemoveLastX(str1, '1'));
function deleteLastMatchedChar(str, target) {
let idx = -1;
for (let i = str.length - 1; i >= 0; i--) {
if (target === str[i]) {
idx = i;
break;
}
}
const strArr = Array.from(str)
strArr.splice(idx, 1)
return strArr.join('')
}
如有错误求戳 (:」∠)_
function removeChar (str, char) {
if (str.length <= 1) {
return str === char ? '' : str
}
const center = Math.floor(str.length / 2)
const left = str.slice(0, center)
const right = str.slice(center)
if (right.indexOf(char) > -1) {
return left + removeChar(right, char)
} else if (left.indexOf(char) > -1) {
return removeChar(left, char) + right
} else {
return str
}
}
function rmChar(str, char) {
const index = str.lastIndexOf(char);
return str.slice(0, index) + str.slice(index + 1);
}转数组的方法有点麻烦没必要
function strRemove(str, remove) {
const index = str.lastIndexOf(remove)
if(index !== -1) {
const str = str.splice(index, 1)
return str.join()
} else {
alert('没有该字符')
}
}
function delLastStr(str, target) { let returnStr = str let index = str.indexOf(target) if(index !== -1) { returnStr = str.slice(0, index) + str.slice(index + 1) } return returnStr }
//去除字符串中最后一个指定的字符
let myString = 'adsad3123 1asd';
function deleteLastWord(string, word) {
const index = string.lastIndexOf(word);
return string.slice(0,index) + string.slice(index+1);
console.log(string);
// string.replace(word);
}
myString = deleteLastWord(myString,'s');
console.log(myString);
let str = 'qfqfrqqqqqqqqqqqqqqqqq#s#qqqqqqqqqqqqqq'
function trimChar(str, delChar) {
if (typeof str !== 'string') return
return str.substring(0, str.lastIndexOf(delChar)) + str.substr(str.lastIndexOf('s') + 1)
}
console.log(trimChar(str, 's'))
function delStr(str,del){
for(i=str.length;i>0;i--){
let s = str.substring(i-1,i)
if(s == del){
str = str.substring(0,i-1)+str.substring(i,str.length)
break
}
}
return str
}
const str = "abcdefg";
function sliceStr(str) {
// return str.substr(0, str.length - 1);
// return str.substring(0, str.length - 1);
return str.slice(0, str.length - 1);
}
console.log(sliceStr(str));
function removeLastStr(str,target){
let arr = str.split('');
for(let i=arr.length-1;i>=0;i--){
if(arr[i]===target){
arr.splice(i,1);
return arr.join('');
}
}
console.log("字符串中不存在目标字符！");
}
function fn(str, char) {
for (let i = str.length - 1; i >= 0; i --) {
if (char === str[i]) {
return str.substring(0, i) + str.substring(i+1);
}
}
return str;
}
function clear(str,character){
let num = str.lastIndexOf(character);
let arr = str.split('');
if(num != -1){
arr.splice(num,1);
}
return arr.join('');
}
function delLastStr (src, target) {
const reg = new RegExp(target)
let str = src.split('').reverse().join('')
str = str.replace(reg, '')
return str.split('').reverse().join('')
}
function delLast(str, del) {
const arr = str.split('')
const lastIndex = arr.lastIndexOf(del)
arr.splice(lastIndex, 1)
return arr.join('')
}
let str='556412121312024'
console.log(getString(str,'0'));
function getString (str,subString) {
let idx=str.lastIndexOf(subString)
return str.substring(0,idx)+''+str.substring(idx+1,str.length)
}
let s="Hello, wold";
String.prototype.reverse= function () {
return this.split('').reverse().join('');
}
String.prototype.removeFirst=function (c){
return this.replace(c,'');
}
s=s.reverse();
s=s.removeFirst('l');
s=s.reverse();
console.log(s)
//"Hello, wod"
let s="Hello, wolld";
function removeLast(str, c){
const arr=s.split(c);
const newString=arr.reduce((a, v, i, r)=>{
if( i === (r.length-1)){
return a+v;
}
if( i === (r.length-2)){
return a+v;
}
return a+v+c;
},'')
return newString;
}
console.log(removeLast(s, 'l'));
let s="Hello, wolld";
function removeLast(str, c){
let arr=s.split('');
let lastIndex, newArr, newStr;
for(let i=0; i<arr.length;i++){
let tmp=arr[i];
if(tmp===c){
lastIndex=i;
}
}
if(lastIndex){
arr.splice(lastIndex, 1);
newStr=arr.join('');
}
return newStr;
}
console.log(removeLast(s, 'l'))
// 使用正则和substring方法
let strList = [];
function del(str, n) {
let reg = eval(`/${n}/g`)
// 使用matchAll方法或者exec方法进行全局匹配
for (const i of str.matchAll(reg)) {
strList.push(i)
}
// while(res=reg.exec(str)) strList.push(res)
let idx = strList[strList.length-1].index
return str.substring(0,idx)+str.substring(idx+1,str.length);
}
console.log(del("dad123dadadwssx", 'd'));
// 第二种
let newstr = []
function del(str, n) {
str = [...str]
const idx = str.lastIndexOf(n);
// str.splice(idx, 1); // 删除指定位置的
// return str.join('')
str.forEach((v,i) =>(i!==idx)?newstr.push(v):false);
return newstr.join('')
}
console.log(del("dad123dadadwssx",'d'));
// 第三种
let str = 'dad123dadadwssx'
function del(str, n) {
str = [...str]
const idx = str.lastIndexOf(n);
str.splice(idx, 1); // 删除指定位置的
return str.join('')
}
console.log(del(str,'d'));
// 第四种
function del(str, target) {
return [...str].reverse().join().replace(target,'').split(',').reverse().join('')
// return str.split('').reverse().join('')
// .replace(target, '').split('')
// .reverse().join(''); // 先分隔 分隔后在倒叙在连接 替换后在分隔倒序后在合并
}
const str = del('asdfghhj', 'h')
console.log(str) // asdfghj 
function delS(s,delString){
var index=s.lastIndexOf(delString);
if(index>=0) //判断是否存在要删除的字符串
{
//通过拼接字符串
var s1=s.substring(0,index)+s.substring(index+delString.length,s.length)
console.log(s1)
}else {
console.log("没有要删除的字符串")
}
}
const deleteLastChar = (str, c) => {
let res = str.split('');
res.splice(str.lastIndexOf(c), 1);
return res.join('');
}
deleteLastChar('111a11111a11', 'a')