[js] 第2天 写一个方法去掉字符串中的空格

[haizhilin2013]

写一个方法去掉字符串中的空格，要求传入不同的类型分别能去掉前、后、前后、中间的空格

[haizhilin2013]

欢迎大家展开多种不同的方法

[yxkhaha]

        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)

[qq674785876]

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,""); //去除字符串内右侧的空格

[shulandmimi]

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;
        }

[linghucq1]

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| 

[qqdnnd]

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');

[tzjoke]

• Regex: string.replace(/\s/g, '')
• join: string.split(' ').join('')

[yangchunboy]

var str = ' 1 2 3445 6    ';
console.log(str.split(' ').join('')) // 输出"1234456"

这样不是很简单吗 @haizhilin2013

[Hxiaongrong]

function noSpace(str){ if (!str) return '' return str.split('').filter(item => item !== ' ').join('') }

[Zhou-Bill]

" 123 56 ".replace(/\s+/g, "")

[likeke1997]

function trim(str) {
    return str.split(' ').join('');
}
var result = trim(' hello world, I am keke. ');
console.log(result); // helloworld,Iamkeke. 

[myprelude]

 str.trim()

[wanghaooo]

const trim = (str) => str.split('').filter((item) => item !== ' ').join('');

[Damon99999]

str.replace(/[ ]/g, "");

[AricZhu]

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('类型错误!');
}

}

[persist-xyz]

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
    }

[Konata9]

正则不是很熟，感觉中间的空格也能用正则去掉

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"}));

[alowkeyguy]

不太明白为什么要分左中右，正着是贪婪的

function trim (str) {
	let reg = /\s+/g
	return str.replace(reg, '')
}

[DarthVaderrr]

var str = ' 1 2 3445 6    ';
console.log(str.split(' ').join('')) // 输出"1234456"

这样不是很简单吗 @haizhilin2013

这个如果遇到连续的空格呢

[boboyu]

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”

[haizhilin2013]

@boboyu 格式化下代码吧，用markdown的语法

[chenliwen123]

var str = ' 1 2 3445 6    ';
console.log(str.split(' ').join('')) // 输出"1234456"

这样不是很简单吗 @haizhilin2013

这个如果遇到连续的空格呢

连续的也没有问题啊

[Azathoth-H]

let str = '21 sdf asdf 123 ' str.replace(/ /g, '') str.split(' ').join('')

[shufangyi]

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
}

[goldEli]

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
  }
}

[ZhaoYu8]

// 我看大家基本上都用正则解决的，想了一下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'))

[IanSun]

注意审题啊，要求的是去掉空格，不是去掉空白字符

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 ) ) );

[Cillivian]

 str.trim()

这个是删去两端的空格，而不会删去字符中间的空格：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim

[LvyYoung]

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, ''));

[ab291478089]

let str = "as sas qs as A" str.split(" ").toString().replace(/,/g,"")

[babygirlhuan8]

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 "，不对啊

[qqdnnd]

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'将跳过

[pma934]

去掉中间空格

str.replace(/^(\s+)(.*?)(\s+)$/g,function($0,$1,$2,$3){
	return $1+$2.replace(/(\s+)/g,'')+$3
})

[funlee]

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));

[JJL-SH]

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")

[Yulingsong]

/**
 * 移除字符串中特定位置的空格
 * @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));

[Daniel-Fang]

function fn(str) { return str.split(' ').join(''); }

[tianfeng65]

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'))

[censek]

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)

[zepang]

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, '')
}

[mopig]

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
}

[RQSA]

答案亲测，连续空格可以用（比较简便） var str = ' A B CDDD D D '; console.log(str.split(' ').join('')) // 输出"ABCDDDDD"

[diandianzd]

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') + '|')

[zhoucumt]

function trimStr(str) { return str.split('').filter(item => { return item !== ' '; }).join(''); }

[0x3c]

/**
 * @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], "");
}

[qqlxxlxx]

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');

[ADengrc]

function trim (str){ return typeof str === 'string' && (str.replace(/\s+/g,'')) } trim(' a b c d e f g ') "abcdefg"

[a1444942531]

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))

[007304wz]

String.prototype.removeSpace = function() { return this.split(' ').join('') }

[mosesyoung]

function removeSpace(str){ return str.replace(/\s+/g,''); }

[Lanbasara]

var mytrim  = function(str){
    var reg = /\s+/g
    var res = str.replace(reg,'')
    return res
}

console.log(mytrim(' Abba bs e s  '))

[huanguolin]

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;
}

[cxyxiaoyuyu]

str.split(' ').join('')

[nikolausliu]

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| 

抛出错误那一行，多了一个!

[13714273163]

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; } }

[l5769389]

function removeSpace(str) {

  let arr =str.split(' ');
  str =arr.join('');
  return str;
}
let str ='    abc    sdef dwffr defr';
console.log(removeSpace(str));

[crazyming9528]

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 之类的

[yyz841875845]

function myTrim (str){ return str.replace(/\s+/g, "") }

[YeChang]

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));

[qq814927478]

//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 中间再比划一个郭富城')

[chengazhen]

function trim (str){
return str.replace(/\s+/g,"");
}

[wxawxa]

方法一：正则str = str.replace(/\s*/g,""); 方法二：字符串方法str=str.split(' ').join('') 方法三：str.trim()方法str= str.trim()

[zzfc]

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))

好多回答的函数我见都没见过。。。

[wowsunny]

var str = 'sdfs sdf sd sd ';
var func = function(str){
  var strList = str.split(' ');
  return strList.join();
}
func(str);//sdfssdfsdsd

[loveWebloveLive]

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,'');加一个这完美，只去中间的

[PanPanZhangCode]

str.replace(/(\u00A0|\u0020|\u3000)+/g,"")

不间断空格：\u00A0 半角空格：\u0020 全角空格：\u3000

[rennzhang]

// 写一个方法去掉字符串中的空格，要求传入不同的类型分别能去掉前、后、前后、中间的空格
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)

[Jvid]

str.replace(' ','')


str.replace(/\s+/,'')

[xiaoyucoding]

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, '');
    }
}

[makejun168]

str.replace(/\s/g, '')

[WindSoftdzw]

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])}
}

[houxinyu-neu]

`function foo(str) { return str.split(" ").join("") }

function lee(str){ return str.replace(/ /g,"") }`

[xuzhouchen1104]

1. 去全部 str.split(" ").join('')
2. 去头尾 str.trim()
3. 去头 str.replace(/^\s+/, '')
4. 去尾 str.replace(/(\s+$)/, '')

[giggleCYT]

function fn(n) {
    return n.replace(/\s*/g, '')
}

[v1kt0r820]

var str = ' |ac| bcd |'
console.log(str.replace(/\s*/g, ""))
console.log(str.split(' ').join(''))

[Sang-Sang33]

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);

[ooceann]

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'));

[Pvtwen]

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);

[code521]

var str=' a b c ' ; var arr=Array.from(new Set(str.split(""))).filter(item=>item&&item.trim()); str=arr.join("")

[HereChen]

此题需要限定“空格”具体指代。\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`);
});

参考

1. String.prototype.trim()
2. https://keycode.info/
3. JS: Whitespace Characters
4. JavaScript: Unicode space character

[code521]

学习了 感谢指导！

------------------ 原始邮件 ------------------ 发件人: "陈磊"<[email protected]>; 发送时间: 2020年7月2日(星期四) 下午3:54 收件人: "haizlin/fe-interview"<[email protected]>; 抄送: "北葵向暖"<[email protected]>; "Comment"<[email protected]>; 主题: Re: [haizlin/fe-interview] [js] 第2天 写一个方法去掉字符串中的空格 (#6)

此题需要限定“空格”具体指代。\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); });

参考

String.prototype.trim()

https://keycode.info/

JS: Whitespace Characters

JavaScript: Unicode space character

— You are receiving this because you commented. Reply to this email directly, view it on GitHub, or unsubscribe.

[Alex-Li2018]

function removeStrEndSpace (str) { // 去掉末尾的空字符串 return str.replace(/\s$/g, ''); // 去掉行首的空字符串 return str.replace(/^\s*/g, ''); // 去掉所有字符串 return str.replace(/\s/g, ''); }

[m7yue]

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)

[yangyi1987]

function stringTrim(str) { return str.split("").filter(item => { if(item !== " " && item !== "") { return item; } }

[babycannotsay]

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()
  }
}

[iceCream0311]

let str = ' jjs jsjsj jsj s ' // str=str.trim() //去掉两边 str = str.replace(/\s/g, '') //去掉全部

[davidandnick]

    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}|`);

[zebratt]

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  
 */

[luneShaoGM]

借鉴了大佬们的写法 ^ _ ^

    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');

[zhengbiaofeng]

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'));

[ShaneQin]

感觉没什么正确答案啊，好多人没看懂题。。。

function rmEmpty(str, dir) {
    const regObj = {
        left: /^\s+/,
        middle: /(?<=\S)\s+(?=\S)/g,
        right: /\s+$/,
        both: /^\s+|\s+$/g
    };
    return str.replace(regObj[dir], '');
}

[Cillivian]

建议配置项做成数组列表 输入一个列表来控制要消除的位置更好发自我的iPhone------------------ 原始邮件 ------------------发件人: ShaneQin [email protected]发送时间: 2021年1月16日 13:43收件人: haizlin/fe-interview [email protected]抄送: 林水泉 [email protected], Comment [email protected]主题: 回复：[haizlin/fe-interview] [js] 第2天 写一个方法去掉字符串中的空格 (#6) 感觉没什么正确答案啊，好多人没看懂题。。。 function rmEmpty(str, dir) { const regObj = { left: /^\s+/, middle: /(?<=\S)\s+(?=\S)/g, right: /\s+$/, both: /^\s+|\s+$/g }; return str.replace(regObj[dir], ''); }

—You are receiving this because you commented.Reply to this email directly, view it on GitHub, or unsubscribe. [ { "@context": "http://schema.org", "@type": "EmailMessage", "potentialAction": { "@type": "ViewAction", "target": "https://github.com/haizlin/fe-interview/issues/6#issuecomment-761464454", "url": "https://github.com/haizlin/fe-interview/issues/6#issuecomment-761464454", "name": "View Issue" }, "description": "View this Issue on GitHub", "publisher": { "@type": "Organization", "name": "GitHub", "url": "https://github.com" } } ]

[crush2020]

Regex: string.replace(/\s/g, '') join: string.split(' ').join(' ')

[Aizener]

str.split(' ').join('')

[fanerge]

let str = ' 12 12 ';
function rmSpace(str) {
   return str.replace(/\s/g, '')
}

[fanerge]

var str = '   123  123   ';
function replaceSpace(str) {
    // 由于正则默认使用贪婪模式，会在每次匹配中匹配所有连续的空格
    return str.replace(/\s/g, '')
    // 紧跟在任何量词 *、 +、? 或 {} 的后面再添加一个 ? ，将会使量词变为非贪婪（匹配尽量少的字符）
    // return str.replace(/\s*?/g, '')
}

[zfing]

let str = ' 1x dsa2 d sd sda ' str.split(' ').join('') //"1xdsa2dsdsda"

[si19891002]

去除中间空格 ' a v c '.replace(/\b(\S+)\s+\b/g,"$1");

[Gun-yx]

var str = '1 2 3 4 5 6 ' console.log( str.split( ' ' ).join( ' ' ) )

[lwt09]

let str = 'a aa a a ' str.split(' ').join('') str.replace(/\s*/g,'')