[js] 第2天 写一个方法去掉字符串中的空格
haizhilin2013 opened this issue · 168 comments
写一个方法去掉字符串中的空格,要求传入不同的类型分别能去掉前、后、前后、中间的空格
欢迎大家展开多种不同的方法
var str = ' abc d e f g ';
function trim(str) {
var reg = /\s+/g;
if (typeof str === 'string') {
var trimStr = str.replace(reg,'');
}
console.log(trimStr)
}
trim(str)
var trim = function(str){
return str.replace(/\s*/g,"");
}
str.replace(/\s*/g,""); //去除字符串内所有的空格
str.replace(/^\s*|\s*$/g,""); //去除字符串内两头的空格
str.replace(/^\s*/,""); //去除字符串内左侧的空格
str.replace(/(\s*$)/g,""); //去除字符串内右侧的空格
function deleSpac(str,direction) { // 1 串的模板 2 清除哪边空格
let Reg = '';
switch(direction) {
case 'left' : // 去除左边
Reg = /^[\s]+/g;
break;
case 'right' : // 去除右边
Reg = /([\s]*)$/g;
break;
case 'both' : // 去除两边
Reg = /(^\s*)|(\s*$)/g
break;
default : // 没传默认全部,且为下去除中间空格做铺垫
Reg = /[\s]+/g;
break;
}
let newStr = str.replace(Reg,'');
if ( direction == 'middle' ){
let RegLeft = str.match(/(^\s*)/g)[0]; // 保存右边空格
let RegRight = str.match(/(\s*$)/g)[0]; // 保存左边空格
newStr = RegLeft + newStr + RegRight; // 将空格加给清完全部空格后的字符串
}
return newStr;
}
const str = ' s t r '
const POSITION = Object.freeze({
left: Symbol(),
right: Symbol(),
both: Symbol(),
center: Symbol(),
all: Symbol(),
})
function trim(str, position = POSITION.both) {
if (!!POSITION[position]) throw new Error('unexpected position value')
switch(position) {
case(POSITION.left):
str = str.replace(/^\s+/, '')
break;
case(POSITION.right):
str = str.replace(/\s+$/, '')
break;
case(POSITION.both):
str = str.replace(/^\s+/, '').replace(/\s+$/, '')
break;
case(POSITION.center):
while (str.match(/\w\s+\w/)) {
str = str.replace(/(\w)(\s+)(\w)/, `$1$3`)
}
break;
case(POSITION.all):
str = str.replace(/\s/g, '')
break;
default:
}
return str
}
const result = trim(str)
console.log(`|${result}|`) // |s t r|
function trimStr(str, type) { const regObj = { left: /^\s+/, middle: /(^\s+)(\S)|\s+(\S)/g, right: /\s+$/, both: /(^\s+)|(\s+$)/g, all: /\s+/g }; const reg = type && regObj[type] ? regObj[type] : regObj.both; const replaceStr = type === 'middle' ? (m, $1, $2, $3) => $1 ? m : $3 : ''; return str.replace(reg, replaceStr); } trimStr(' aa bb cc d d ee ','middle');
- Regex:
string.replace(/\s/g, '')
- join:
string.split(' ').join('')
var str = ' 1 2 3445 6 ';
console.log(str.split(' ').join('')) // 输出"1234456"
这样不是很简单吗 @haizhilin2013
function noSpace(str){
if (!str) return ''
return str.split('').filter(item => item !== ' ').join('')
}
" 123 56 ".replace(/\s+/g, "")
function trim(str) {
return str.split(' ').join('');
}
var result = trim(' hello world, I am keke. ');
console.log(result); // helloworld,Iamkeke.
str.trim()
const trim = (str) => str.split('').filter((item) => item !== ' ').join('');
str.replace(/[ ]/g, "");
function removeSpace (str, type) {
if (type === 'before') {
// 递归去除字符串前面的空格
return (str && str[0] === ' ')? removeSpace(str.substring(1), type): str;
} else if (type === 'after') {
// 递归去除字符串后面的空格
return (str && str[0] && str[str.length - 1] === ' ')? removeSpace(str.substring(0, str.length-1), type): str;
} else if (type === 'before-after') {
// 递归去除字符串前后的空格
return (str = removeSpace(str, 'before')) && (str = removeSpace(str, 'after'));
} else if (type === 'between') {
// 递归去除字符串中间的空格
// 首先找到 'x y'类型的字符位置
let x = y = 0;
outer:
for (let i = 0; i < str.length - 1; i ++) {
if (str[i] !== ' ' && str[i+1] === ' ') {
x = i;
let j = i + 2;
while(j < str.length && str[j] === ' ') {
j++;
}
if (j < str.length) {
y = j;
}
break outer;
}
}
return y !== 0? removeSpace(str.substring(0, x + 1) + str.substring(y), type): str;
} else {
throw new Error('类型错误!');
}
}
myTrim: (str) => {
// 1 去除所有空格
str = str.replace(/\s*/g, '')
// 2去除所有空格
str = str.split(' ').join('')
// 1 去除开头空格
str = str.replace(' ', '')
// 2 去除开头空格
str = str.replace(/^\s*/, '')
// 1 去除结尾空格
str = str.replace(/\s*$/, '')
// 1 去除中间空格
while(str.match(/\w\s+\w/)) {
str = str.replace(/^\s*|\s*$/, '')
}
return str
}
正则不是很熟,感觉中间的空格也能用正则去掉
const trimString = ({str = "", position = "both"}) => {
if (!str) {
return str;
}
const removePos = {
left: () => str.replace(/^\s+/, ""),
right: () => str.replace(/\s+$/, ""),
both: () => str.replace(/(^\s+)|(\s+$)/g, ""),
// 这个方法在字符串中间有多个空格时会有问题
// middle: () =>
// str
// .split(" ")
// .map((item) => (item ? item : " "))
// .join(""),
// 下面这种正则更优雅
// middle: () => {
// let result = str;
// while (/\w+\s+\w+/.test(result)) {
// result = result.replace(/(\w+)\s+(\w+)/, '$1$2');
// }
// return result;
// },
// 一行正则
// middle: () => str.replace(/\b\s*\b/g,''),
// 普通方法
middle: () => {
const leftSpace = str.match(/^\s+/)[0];
const rightSpace = str.match(/\s+$/)[0];
return leftSpace + str.split(" ").join("") + rightSpace;
},
all: () => str.split(" ").join("")
};
return removePos[position]();
};
const a = " 12a b cde fff ";
console.log("trim left:", trimString({str: a, position: "left"}));
console.log("trim right:", trimString({str: a, position: "right"}));
console.log("trim middle", trimString({str: a, position: "middle"}));
console.log("trim both:", trimString({str: a}));
console.log("trim all:", trimString({str: a, position: "all"}));
不太明白为什么要分左中右,正着是贪婪的
function trim (str) {
let reg = /\s+/g
return str.replace(reg, '')
}
var str = ' 1 2 3445 6 '; console.log(str.split(' ').join('')) // 输出"1234456"这样不是很简单吗 @haizhilin2013
这个如果遇到连续的空格呢
String.prototype.myTrim = function(option){
var _this = this;
var fn = {
front:function(){
return _this.replace(/^\s+/,'')
// return _this.trimLeft()//或_this.trimStart() ie不支持
},
end:function(){
return _this.replace(/\s+$/,'')
// return _this.trimRight()//或 _this.trimEnd() ie不支持
},
frontEnd:function(){
return _this.replace(/^\s+|\s+$/g,'');
// return _this.trim()//--包括所有的空格字符 (space, tab, no-break space 等)以及所有的行结束符(如 LF,CR)
// return _this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
/* 某些软件,在保存一个以UTF-8编码的文件时,会在文件开始的地方插入三个不可见的字符(0xEF 0xBB 0xBF,即BOM),
转码后是“\uFEFF”,因此我们在读取时需要自己去掉这些字符。
“\xA0”其实就是HTML中常见的“ ” */
},
content:function(){
var mStr = this.all();
var lStr = _this.match(/^\s+/)[0];
var rStr = _this.match(/\s+$/)[0]
return lStr + mStr + rStr
},
all:function(){
return _this.replace(/\s+/g,'')
}
}
return fn[option]();
}
var str = ' s t r ';
var _str = {}
_str.front = str.myTrim('front')
_str.end = str.myTrim('end')
_str.frontEnd = str.myTrim('frontEnd')
_str.content = str.myTrim('content')
_str.all = str.myTrim('all')
console.log(_str)
全角空格还需要匹配“\u3000”
@boboyu 格式化下代码吧,用markdown的语法
var str = ' 1 2 3445 6 '; console.log(str.split(' ').join('')) // 输出"1234456"这样不是很简单吗 @haizhilin2013
这个如果遇到连续的空格呢
连续的也没有问题啊
let str = '21 sdf asdf 123 '
str.replace(/ /g, '')
str.split(' ').join('')
function trim(str, types = ['start', 'end', 'middle']) {
types.forEach(type => {
switch (type) {
case 'start':
str = str.replace(/^\s*/, '')
break
case 'end':
str = str.replace(/\s*$/, '')
break
case 'middle':
while (str.match(/(\S)\s+(\S)/)) {
str = str.replace(/(\S)\s+(\S)/g, '$1$2')
}
break
default:
break
}
})
return str
}
var removeSpace1 = (str, type) => {
if (!str) return
switch(type){
case 'ALL':
return str.replace(/\s/g, '')
case 'TRIM_HEAD_AND_TAIL':
return str.replace(/^\s*|\s*$/g, '')
case 'TRIM_HEAD':
return str.replace(/^\s*/g, '')
case 'TRIM_TAIL':
return str.replace(/\s*$/g, '')
default:
return str
}
}
// 我看大家基本上都用正则解决的,想了一下js提供的字符串方法也能解决。简洁程度比不上正则。
let str = ' a b c ';
let delBlank = (str, type) => {
let count = 0,_str = str.split(''), arr = [];
_str.map((r, i) => {
if (r !== " ") { // 主要是为了取第一个,最后一个不是" "的下标
!count ? (arr[0] = i,count++) : arr[1] = i + 1
}
})
switch (type) {
case 'all':
return str.split(' ').join('')
break
case 'left':
return str.slice(arr[0])
break
case 'right':
return str.slice(0, arr[1])
break
case 'centre':
// 字符串拼接:左边的空格 + 去除前后空格后的字符串,然后再删除所有的空格 + 尾部的空格
return str.slice(0, arr[0]) + str.slice(arr[0], arr[1]).split(' ').join('') + str.slice(arr[1], _str.length)
break
default:
return str;
break
}
}
console.log(delBlank(str, 'centre'))
注意审题啊,要求的是去掉空格,不是去掉空白字符
const trim = ( () => {
const ALL = Symbol( `ALL` );
const END = Symbol( `END` );
const INSET = Symbol( `INSET` );
const START = Symbol( `START` );
const SURROUND = Symbol( `SURROUND` );
const WHITESPACE = `\u0020`;
const REGEXP = {
[ ALL ] : new RegExp( `${ WHITESPACE }+`, `gu` ),
[ END ] : new RegExp( `${ WHITESPACE }+$`, `u` ),
[ INSET ] : new RegExp( `(?<!^|${ WHITESPACE })${ WHITESPACE }+(?!$|${ WHITESPACE })`, `gu` ),
[ START ] : new RegExp( `^${ WHITESPACE }+`, `u` ),
[ SURROUND ] : new RegExp( `^${ WHITESPACE }+|${ WHITESPACE }+$`, `gu` ),
};
function trim ( string = ``, type ) {
return REGEXP[ type ] ?
string.replace( REGEXP[ type ], `` ) :
string;
}
trim.ALL = ALL;
trim.END = END;
trim.INSET = INSET;
trim.START = START;
trim.SURROUND = SURROUND;
return trim;
} )();
const string = ' abc d e f g ';
console.log( JSON.stringify( trim( string, trim.ALL ) ) );
console.log( JSON.stringify( trim( string, trim.END ) ) );
console.log( JSON.stringify( trim( string, trim.INSET ) ) );
console.log( JSON.stringify( trim( string, trim.START ) ) );
console.log( JSON.stringify( trim( string, trim.SURROUND ) ) );
str.trim()
这个是删去两端的空格,而不会删去字符中间的空格:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim
let str = ' abcde fgh ijk ';
console.log(" 原字符串:" + str);
console.log(" 去掉左空格:" + str.replace(/^\s*/g, ''));
console.log(" 去掉右空格:" + str.replace(/\s*$/g, ''));
console.log("去掉左右空格:" + str.replace((/^\s*/g|/\s*$/g), ''));
console.log("去掉所有空格:" + str.replace(/\s*/g, ''));
let str = "as sas qs as A"
str.split(" ").toString().replace(/,/g,"")
function trimStr(str,type){
const regObj={
left: /^\s+/,
middle: /(\S)\s+(\S)/g,
right:/\s+$/,
both: /(^\s+)|(\s+$)/g,
all: /\s+/g
};
const reg =type && regObj[type] ? regObj[type] :regObj.both;
const replaceStr = type === 'middle' ? '$1$2' : '';
return str.replace(reg,replaceStr);
}
trimStr(' aa bb cc dd ee ','middle');
如果str = 'aa bb c dd ee',运行结果是" aabbc ddee ",不对啊
function trimStr(str,type){
const regObj={
left: /^\s+/,
middle: /(\S)\s+(\S)/g,
right:/\s+$/,
both: /(^\s+)|(\s+$)/g,
all: /\s+/g
};
const reg =type && regObj[type] ? regObj[type] :regObj.both;
const replaceStr = type === 'middle' ? '$1$2' : '';
return str.replace(reg,replaceStr);
}
trimStr(' aa bb cc dd ee ','middle');如果str = 'aa bb c dd ee',运行结果是" aabbc ddee ",不对啊
已修改了,具体产生的原因是正则有问题,原匹配的是‘x x’,但碰到‘x x x’只会取前面的'x x',后面的' x'将跳过
去掉中间空格
str.replace(/^(\s+)(.*?)(\s+)$/g,function($0,$1,$2,$3){
return $1+$2.replace(/(\s+)/g,'')+$3
})
function deleteSpace(str) {
return str.split("").filter(d => d !== " ").join("");
}
var str1 = "abc def tfd";
var str2 = " abc def tfd";
var str3 = "abc def tfd ";
var str4 = " abc def tfd ";
console.log(deleteSpace(str1));
console.log(deleteSpace(str2));
console.log(deleteSpace(str3));
console.log(deleteSpace(str4));
function trimString(str, type) {
let allRegex = {
left: /^\s+/,
right: /\s+$/,
both: /(^\s+)|(\s+$)/g,
all: /\s+/g
};
if (type === "middle") {
let cacheLeft = str.match(allRegex.left)[0];
let cacheRight = str.match(allRegex.right)[0];
return cacheLeft + str.replace(allRegex.all, "") + cacheRight;
}
return str.replace(allRegex[type], "");
}
trimString(" asdasd asd asd ", "both")
/**
* 移除字符串中特定位置的空格
* @param {*} str 目标字符串
* @param {*} direction 目标位置
* 1,字符串左侧空格
* 2,字符串右侧空格
* 3,字符串左右侧空格
* 4,字符串内部空格
* 5,字符串内全部空格
*/
function removeSpace(str,direction) {
if(!str)return ;
switch (direction) {
case 1:
return str.replace(/^\s*/,"");
case 2:
return str.replace(/(\s*$)/g,"");
case 3:
return str.replace(/^\s*|\s*$/g,"");
case 4:
var prefix = str.substr(0,str.match(/^\s*/)[0].length);
var suffix = str.substr(str.length-str.match(/(\s*$)/g)[0].length,str.length);
var content = str.replace(/^\s*|\s*$/g,"").replace(/\s*/g,"");
return prefix+content+suffix;
default:
return str.replace(/\s*/g,"");
}
}
var str = ' adasd asd dc ';
console.log(removeSpace(str,1));
console.log(removeSpace(str,2));
console.log(removeSpace(str,3));
console.log(removeSpace(str,4));
console.log(removeSpace(str,5));
console.log(removeSpace(str));
function fn(str) { return str.split(' ').join(''); }
const str = ' s t r '
const _POSITION = Object.freeze({
left: Symbol(),
right: Symbol(),
both: Symbol(),
all: Symbol(),
center: Symbol()
})
function trim (str, position = 'all') {
if(!_POSITION.hasOwnProperty(position)) throw new Error('unexpected position value in [left, right, both, all, center]')
switch(position){
case ('left'):
return str.replace(/^\s+/g, '')
case ('right'):
return str.replace(/\s+$/g, '')
case ('all'):
return str.replace(/\s+/g, '')
case ('both'):
return str.replace(/^\s+|\s+$/g, '')
case ('center'):
let leftSpace = str.match(/^\s+/g)[0]
let rightSpace = str.match(/\s+$/g)[0]
return leftSpace + str.replace(/\s+/g, '') + rightSpace
}
}
console.log(trim(str,'left'))
console.log(trim(str,'right'))
console.log(trim(str,'all'))
console.log(trim(str,'both'))
console.log(trim(str,'center'))
var str = ' abc d e f g ';
function trim(str) {
if (typeof str === "string") {
// 方案1:正则
var string1 = str.replace(/\s*/g, ""); //去所有空格
var string2 = str.replace(/^\s*/g, ""); //去前空格
var string3 = str.replace(/\s*$/g, ""); //去后空格
var string4 = str.replace(/^\s*|\s*$/g, ""); //去前后空格
var leftSpace = str.match(/^\s*/g);
console.log(str.match(/\s*$/g))
var rightSpace = str.match(/\s*$/g[0]);
var string5 = leftSpace + str.replace(/\s*/g, "") + rightSpace; //去中间空格
// 方案2:split, join
var string = str.split(" ").join(""); //去所有空格
}
console.log(string1);
console.log(string2);
console.log(string3);
console.log(string4);
console.log(string5);
console.log(string);
}
trim(str)
function delSpace (str, pos) {
let reg = /\s+/g
switch (pos) {
case 'l':
reg = /^\s+/g
break
case 'r':
reg = /\s+$/g
break
case 'c':
reg = /(?<=\w)\s+(?=\w)/g
break
case 'lr':
reg = /(^\s+)|(\s+$)/g
break
case 'a':
reg = /\s+/g
break
}
return str.replace(reg, '')
}
function trim(str, pos) {
let ret = str
switch(pos) {
case 'l':
ret = str.trimStart()
break
case 'r':
ret = str.trimEnd()
break
case 'lr':
ret = str.trimStart().trimEnd()
break
case 'm':
ret = str.replace(/(?<=[^\s])\s*(?=[^\s])/g, '')
break
}
return ret
}
答案亲测,连续空格可以用(比较简便)
var str = ' A B CDDD D D ';
console.log(str.split(' ').join('')) // 输出"ABCDDDDD"
function trim(str, position = 'both') {
if (position === 'left') return str.replace(/^\s*/g, '')
if (position === 'right') return str.replace(/\s*$/g, '')
if (position === 'all') return str.replace(/\s*/g, '')
if (position === 'both') return str.replace(/^\s*|\s*$/g, '')
return str
}
console.log('|' + trim(' sss ggg ', 'both') + '|')
function trimStr(str) {
return str.split('').filter(item => {
return item !== ' ';
}).join('');
}
/**
* @param {string} str
* @param {string} type
*/
function trim(str, type = "all") {
var regexMap = {
left: /^\s+/,
right: /\s+$/,
center: /(?<=\S)\s(?=\S)/g,
both: /(^\s+)|(\s+$)/,
all: /\s/g
};
var reg = regexMap[type];
if (!reg) {
throw new TypeError("type is invalid");
}
return str.replace(regexMap[type], "");
}
function deleSpac(str, type) {
let regObj = {
left: /^\s*/,
right: /\s*$/,
both: /^(\s*)|(\s*$)/g,
middle: /\b\s*\b/g,
all: /\s+/g
}
return str.replace(regObj[type], '');
}
let res = deleSpac(' 00abc\t aa 00 ', 'middle');
function trim (str){
return typeof str === 'string' && (str.replace(/\s+/g,''))
}
trim(' a b c d e f g ')
"abcdefg"
function removeSpache(str, types) {
let _str = str;
let _reg = [
/^[\s]+/g,
/([\s]*)$/g,
/\b\s*\b/g
]
let _type = parseInt(types, 2);
let i = 0;
while(_type) {
if (_type !== _type >> 1 << 1) {
// 执行指定方法
_str = _str.replace(_reg[i], '')
}
i++
_type = _type >> 1;
}
return _str;
}
// 1 去掉开头空格
// 10 去掉结尾空格
// 100 去掉中间空格
// 110 去掉中间和结尾空格
// 111 去掉所有空格
console.log(removeSpache(' asdas asda sd ', 101))
String.prototype.removeSpace = function() { return this.split(' ').join('') }
function removeSpace(str){
return str.replace(/\s+/g,'');
}
var mytrim = function(str){
var reg = /\s+/g
var res = str.replace(reg,'')
return res
}
console.log(mytrim(' Abba bs e s '))
function trim(str, {
start = true,
middle = false,
end = true,
}) {
if (!start && !middle && !end) return str;
if (middle) {
const SPACE = ' ';
const len = str.length;
let i = 0;
let j = len - 1;
while(str[i] === SPACE) i++;
while(str[j] === SPACE) j--;
// 全空
if (j < i) return start || end ? '' : str;
str = str.replace(/\s+/g, '');
const prefix = start ? '' : SPACE.repeat(i + 1);
const postfix = end ? '' : SPACE.repeat(len - 1 - j);
return `${prefix}${str}${postfix}`;
}
if (start) str = str.replace(/^\s+/, '');
if (end) str = str.replace(/\s+$/, '');
return str;
}
str.split(' ').join('')
const str = ' s t r ' const POSITION = Object.freeze({ left: Symbol(), right: Symbol(), both: Symbol(), center: Symbol(), all: Symbol(), }) function trim(str, position = POSITION.both) { if (!!POSITION[position]) throw new Error('unexpected position value') switch(position) { case(POSITION.left): str = str.replace(/^\s+/, '') break; case(POSITION.right): str = str.replace(/\s+$/, '') break; case(POSITION.both): str = str.replace(/^\s+/, '').replace(/\s+$/, '') break; case(POSITION.center): while (str.match(/\w\s+\w/)) { str = str.replace(/(\w)(\s+)(\w)/, `$1$3`) } break; case(POSITION.all): str = str.replace(/\s/g, '') break; default: } return str } const result = trim(str) console.log(`|${result}|`) // |s t r|
抛出错误那一行,多了一个!
function myTrim(str, type = 'all') {
switch (type) {
case "all":
return str.replace(/\s*/g, '')
break;
case "left":
return str.replace(/^\s*/, '')
break;
case "right":
return str.replace(/\s*$/, '')
break;
case "double":
return str.replace(/^\s*|\s*g/g, '')
break;
default:
break;
}
}
function removeSpace(str) {
let arr =str.split(' ');
str =arr.join('');
return str;
}
let str =' abc sdef dwffr defr';
console.log(removeSpace(str));
function trim(str, type) {
var t = type || "all";
var map = {
all: /\s+/g, // 去除字符串所有空格 \s空白字符串 g 修饰符 表示 执行全局匹配(查找所有匹配而非在找到第一个匹配后停止)
before: /^\s*/, // 去除字符串前面的空格 \s空白字符串 ^\s表示 以 空白字符串开头 *表示 匹配任何包含零个或多个 n 的字符串。
after: /\s*$/,//去除字符串 后面的空格 \s空白字符串 \s$表示以空白字符串结尾 *表示 匹配任何包含零个或多个 n 的字符串。
beforeAndAfter: /^\s*|\s*$/g,// 去除字符串 前后的空格 |表示 或的意思
};
if (map[t]) {
return str.replace(map[t], '');
} else {
throw "传入的类型错误";
}
}
这样可以不用 switch if 之类的
function myTrim (str){
return str.replace(/\s+/g, "")
}
function trim(str) {
return str.split(" ").join("");
}
function trim(str) {
return str.replace(/\s/g, "");
}
var str = " 123 31 12 412 4 ";
console.log(trim(str));
//Dindex = 去掉哪个位置的空格 -1=所有 0=前边 1=后边 2=当间
function DNfun(str, Dindex) {
let newStr = '' //新搞个变量存着
let newArr = str.split(' ') //啥也不管先分割成数组
if (Dindex == 1) { //后边特殊搞一下子
Dindex = newArr.length - 2 // 数组最大-1就是最后一个空格出现的地方
}
if (Dindex == 2) { //当间特殊搞一下子
Dindex = Math.floor((newArr.length - 1) / 2) //数组最大除2就是中间 舍去小数点
}
//开整
newArr.forEach((item, index) => {
if (index == Dindex) {
newStr += item + ' '
} else {
newStr += item
}
})
return newStr
}
console.log(DNfun('野 狼 D i s c o !', -1), '-1 全场动作必须跟我整齐划一')
console.log(DNfun('野 狼 D i s c o !', 0), '0 来左边跟我一起划个龙')
console.log(DNfun('野 狼 D i s c o !', 1), '1 右边画一道彩虹')
console.log(DNfun('野 狼 D i s c o !', 2), '2 中间再比划一个郭富城')
function trim (str){
return str.replace(/\s+/g,"");
}
方法一:正则str = str.replace(/\s*/g,"");
方法二:字符串方法str=str.split(' ').join('')
方法三:str.trim()方法str= str.trim()
function filterSpace(str) {
let c = [];
str.split(' ').map(v => {
v !== '' ? c.push(v) : '';
});
return c.join('')
}
var a = ' ncjkdsa f,j832 1j f234f3 ';
console.log(filterSpace(a))
好多回答的函数我见都没见过。。。
var str = 'sdfs sdf sd sd ';
var func = function(str){
var strList = str.split(' ');
return strList.join();
}
func(str);//sdfssdfsdsd
var trim = function(str){
return str.replace(/\s*/g,"");
}
str.replace(/\s*/g,""); //去除字符串内所有的空格
str.replace(/^\s*|\s*$/g,""); //去除字符串内两头的空格
str.replace(/^\s*/,""); //去除字符串内左侧的空格
str.replace(/(\s*$)/g,""); //去除字符串内右侧的空格
' sadfa adf asdfasd asdfa '.replace(/(?<=\S)\s*(?=\S)/g,'');加一个这完美,只去中间的
str.replace(/(\u00A0|\u0020|\u3000)+/g,"")
不间断空格:\u00A0
半角空格:\u0020
全角空格:\u3000
// 写一个方法去掉字符串中的空格,要求传入不同的类型分别能去掉前、后、前后、中间的空格
var str = " hah hha "
// 这里简化参数:前=>1 后=>2 前后=>3 中间=>4
function strTrim(val, place) {
if (place == 3) str = val.trim()
if (place == 1) str = val.trimStart()
if (place == 2) str = val.trimEnd()
if (place == 4) {
var start = "",
end = ""
for (const n of str) {
if (n != " ") break
start += " "
}
for (const n of str.split("").reverse().join("")) {
if (n != " ") break
end += " "
}
var center = str.split(" ").join("")
str = start + center + end
}
return str
}
strTrim(str, 4)
str.replace(' ','')
str.replace(/\s+/,'')
var str = ' a b c d e f g ';
function removeSpace(value, type) {
var headPattern = /^\s+/g;
var tailPattern = /\s+$/g;
var headAndTailPattern = /^\s+|\s+$/g;
var middlePattern = /(\S)\s+(\S)/g;
var pattern = /\s+/g;
if (type === 'head') {
return value.replace(headPattern, '');
} else if (type === 'tail') {
return value.replace(tailPattern, '');
} else if (type === 'head_and_tail') {
return value.replace(headAndTailPattern, '');
} else if (type === 'middle') {
while (middlePattern.exec(value)) {
value = value.replace(middlePattern, '$1$2');
}
return value;
} else {
return value.replace(pattern, '');
}
}
str.replace(/\s/g, '')
var str = ' 1 2 3445 6 '; console.log(str.split(' ').join('')) // 输出"1234456"这样不是很简单吗 @haizhilin2013
这个如果遇到连续的空格呢
var str = ' 12 33'
var newstr = "";
var strs = str.split(" ")
for(i = 0;i < strs.length; i++){
if(strs[i]) {newstr += strs[i];console.log(strs[i])}
}
`function foo(str) {
return str.split(" ").join("")
}
function lee(str){
return str.replace(/ /g,"")
}`
- 去全部 str.split(" ").join('')
- 去头尾 str.trim()
- 去头 str.replace(/^\s+/, '')
- 去尾 str.replace(/(\s+$)/, '')
function fn(n) {
return n.replace(/\s*/g, '')
}
var str = ' |ac| bcd |'
console.log(str.replace(/\s*/g, ""))
console.log(str.split(' ').join(''))
let str = ' what are you nong sha lie ';
let arr = str.split('');
let noSpaceArr = arr.filter(function(item){
return item != ' ';
})
str = noSpaceArr.join('');
console.log(noSpaceArr);
const str = ' go od ';
function fun(str, position) {
let newStr;
const len = str.length;
switch (position) {
case 'left':
newStr = str.slice(1);
break;
case 'right':
newStr = str.slice(0, len);
break;
case 'both':
newStr = str.slice(1, len);
break;
case 'middle':
newStr = str.split(' ').join('');
break;
}
return newStr;
}
console.log(fun(str, 'left'));
console.log(fun(str, 'right'));
console.log(fun(str, 'both'));
console.log(fun(str, 'middle'));
function deleteSpace(str1){
var str3='';
var j=0;
for(var i=0;i<str1.length;i++)
{
if(str1[i]==" ")
{
continue;
}
str3+=str1[i];
}
return str3;
}
var str4=deleteSpace("ab cd");
console.log(str4);
var str=' a b c ' ;
var arr=Array.from(new Set(str.split(""))).filter(item=>item&&item.trim());
str=arr.join("")
此题需要限定“空格”具体指代。\s
正则(以及 trim()
),指代的“空白字符”,包含制表符、回车、换行等等。
方法
/**
* 去除空格。只支持 `' '`、`'\u0020'` 空格去除。
* @param {string} str 需要去除空格的字符串
* @param {('start'|'middle'|'end'|'all')} position 去除空格的位置
*/
function removeSpace (str, position = 'all') {
const reg = ({
start: /^\u0020/gu,
end: /\u0020$/gu,
middle: '不会,欢迎补充',
all: /\u0020/gu
})[position];
return (reg && str && typeof str === 'string') ? str.replace(reg, '') : str;
}
另,用正则未必是性能最好的,见《JavaScript 忍者秘籍》165 页。
示例
var str = " Remove Space \f\n\v\t\ufeff\u00a0Remove\u0020Space\u2002\u2003\u0009\u000b\u000c ";
console.log(`input length: ${str.length}`);
console.log(`input: ${str}`);
console.log(`input.replace(/\\s/g, ''): ${str.replace(/\s/g, '')}\n\n`);
console.log(`input.split(' ').join(''): ${str.split(' ').join('')}\n\n`);
['all', 'start', 'end', 'unknown']
.forEach(position => {
const output = removeSpace(str, position);
console.log(`remove ${position}:`);
console.log(`output length: ${output.length}`);
console.log(`output: ${output}\n\n`);
});
参考
function removeStrEndSpace (str) {
// 去掉末尾的空字符串
return str.replace(/\s$/g, '');
// 去掉行首的空字符串
return str.replace(/^\s*/g, '');
// 去掉所有字符串
return str.replace(/\s/g, '');
}
const ENUM_TYPE = {
left: Symbol(),
right: Symbol(),
mid: Symbol(),
both: Symbol()
}
const trim = (str, position = ENUM_TYPE.both) => {
switch (position) {
case (ENUM_TYPE.left):
str = str.replace(/^\s+/, '')
break
case (ENUM_TYPE.right):
str = str.replace(/\s+$/, '')
break
case (ENUM_TYPE.mid):
while (str.match(/\w\s+\w/)) {
str = str.replace(/(\w)(\s+)(\w)/, `$1$3`)
}
break
case (ENUM_TYPE.both):
str = str.replace(/^\s+/, '').replace(/\s+$/, '')
break
}
return str
}
const str = ' hfdh kfjdsh '
const res = trim(str)
console.log(res)
function stringTrim(str) {
return str.split("").filter(item => {
if(item !== " " && item !== "") {
return item;
}
}
function trimer (str, position) {
switch (position) {
case 'start': return str.trimStart()
case 'end': return str.trimEnd()
case 'center': return str.replace(/(?<=\S)\s+(?=\S)/g, '')
case 'all': return str.replace(/\s/g, '')
case 'normal':
default:
return str.trim()
}
}
let str = ' jjs jsjsj jsj s '
// str=str.trim() //去掉两边
str = str.replace(/\s/g, '') //去掉全部
const str = ' s t r ';
const POSITION = {
left: 'left',
right: 'right',
both: 'both',
center: 'center',
all: 'all'
};
function trim (str, position) {
// 判断position的值,默认为both
let pos = position && POSITION[position] ? position : 'both';
switch(pos) {
case(POSITION.left):
str = str.replace(/^\s+/, '');
break;
case(POSITION.right):
str = str.replace(/\s+$/, '');
break;
case(POSITION.both):
str = str.replace(/^\s+|\s+$/g, '');
break;
case(POSITION.center):
while (str.match(/\w\s+\w/)) {
str = str.replace(/(\w)(\s+)(\w)/, `$1$3`);
}
break;
case(POSITION.all):
str = str.replace(/\s/g, '');
break;
default:
}
return str;
}
const result = trim(str);
console.log(`|${result}|`);
export enum TrimType {
LEADING,
TRAILING,
MIDDLE,
ALL,
}
export function trim(str: string, type: TrimType) {
switch (type) {
case TrimType.LEADING:
return str.replace(/^\s+/, "");
case TrimType.TRAILING:
return str.replace(/\s+$/, "");
case TrimType.MIDDLE:
while (str.match(/\w+\s+\w+/)) {
str = str.replace(/(\w+)\s+(\w+)/, "$1$2");
}
return str;
case TrimType.ALL:
return str.replace(/\s+/g, "");
}
}
// test
const str = " hello wor ld ";
console.log(trim(str, TrimType.ALL));
console.log(trim(str, TrimType.LEADING));
console.log(trim(str, TrimType.TRAILING));
console.log(trim(str, TrimType.MIDDLE));
/**
helloworld
hello wor ld
hello wor ld
helloworld
*/
借鉴了大佬们的写法 ^ _ ^
function Trim (str) {
this.str = str
}
Trim.prototype = {
left () {
return this.str.replace(/^\s*/, '')
},
right () {
return this.str.replace(/\s*$/, '')
},
all () {
return this.str.replace(/\s/g, '')
},
interval () {
return this.str.replace(/(?<=\w)\s(?=\w)/g, '')
}
}
const str = ' fs fs sa '
const trim = new Trim(str)
console.log('l->' + trim.left() + '<-r');
console.log('l->' + trim.right() + '<-r');
console.log('l->' + trim.all() + '<-r');
console.log('l->' + trim.interval() + '<-r');
function trim(str, position = 'both') {
if (typeof position !== 'string') {
throw new Error('expected position is string type')
}
switch (position) {
case 'left':
str = str.replace(/^\s+/, '');
break;
case 'right':
str = str.replace(/\s+$/, '');
break;
case 'both':
str = str.replace(/^\s+/, '').replace(/\s+$/, '');
break;
case 'center':
while (str.match(/(\w)(\s+)(\w)/g, `$1$3`)) {
str = str.replace(/(\w)(\s+)(\w)/g, `$1$3`);
}
case 'all':
str = str.split(' ').join('');
break;
}
return str;
}
console.log(trim(' 1 2 3 ', 'all'));
感觉没什么正确答案啊,好多人没看懂题。。。
function rmEmpty(str, dir) {
const regObj = {
left: /^\s+/,
middle: /(?<=\S)\s+(?=\S)/g,
right: /\s+$/,
both: /^\s+|\s+$/g
};
return str.replace(regObj[dir], '');
}
Regex: string.replace(/\s/g, '')
join: string.split(' ').join(' ')
str.split(' ').join('')
let str = ' 12 12 ';
function rmSpace(str) {
return str.replace(/\s/g, '')
}
var str = ' 123 123 ';
function replaceSpace(str) {
// 由于正则默认使用贪婪模式,会在每次匹配中匹配所有连续的空格
return str.replace(/\s/g, '')
// 紧跟在任何量词 *、 +、? 或 {} 的后面再添加一个 ? ,将会使量词变为非贪婪(匹配尽量少的字符)
// return str.replace(/\s*?/g, '')
}
let str = ' 1x dsa2 d sd sda '
str.split(' ').join('') //"1xdsa2dsdsda"
去除中间空格
' a v c '.replace(/\b(\S+)\s+\b/g,"$1");
var str = '1 2 3 4 5 6 '
console.log( str.split( ' ' ).join( ' ' ) )
let str = 'a aa a a '
str.split(' ').join('')
str.replace(/\s*/g,'')