在第一个空格出现时拆分字符串

var arr = [];             //new storage
str = str.split(' ');     //split by spaces
arr.push(str.shift());    //add the number
arr.push(str.join(' '));  //and the rest of the string


//arr is now:
["72","tocirah sneab"];

但我还是觉得有更快的方法。

如果您只关心空格字符(而不是制表符或其他空格字符) ，并且只关心第一个空格之前的所有内容和第一个空格之后的所有内容，那么您可以不使用如下正则表达式:

str.substring(0, str.indexOf(' ')); // "72"
str.substring(str.indexOf(' ') + 1); // "tocirah sneab"

注意，如果根本没有空格，那么第一行将返回一个空字符串，第二行将返回整个字符串。确保这是你在那种情况下想要的行为(或者那种情况不会发生)。

Javascript 不支持后视，所以 split是不可能的:

str.match(/^(\S+)\s(.*)/).slice(1)

另一个小把戏:

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

这个怎么样:

[str.replace(/\s.*/, ''), str.replace(/\S+\s/, '')]

为什么不呢

reverse = function (s) { return s.split('').reverse().join('') }
reverse(str).split(/\s(?=\S+$)/).reverse().map(reverse)

也许吧

re = /^\S+\s|.*/g;
[].concat.call(re.exec(str), re.exec(str))

2019年更新 : 自 ES2018年起，支持后视功能:

str = "72 tocirah sneab"
s = str.split(/(?<=^\S+)\s/)
console.log(s)

您还可以使用. change 仅替换第一个出现的,

​str = str.replace(' ','<br />');

省略了/g。

演示

每当我需要从一个类列表或者类名或者 id 的一部分中获取一个类时，我总是使用 split () ，然后通过数组索引来获取它，或者，在我的例子中，通常使用 pop ()来获取最后一个元素或者 shift ()来获取第一个元素。

此示例获取 div 的类“ Gallery _ 148 ui-sortable” 并返回画廊 ID 148。

var galleryClass = $(this).parent().prop("class"); // = gallery_148 ui-sortable
var galleryID = galleryClass.split(" ").shift(); // = gallery_148
galleryID = galleryID.split("_").pop(); // = 148
//or
galleryID = galleryID.substring(8); // = 148 also, but less versatile

我确信它可以被压缩成更少的行，但是为了便于阅读，我把它扩展了。

我需要一个稍微不同的结果。

我想要第一个词，以及它后面的词——即使它是空白的。

str.substr(0, text.indexOf(' ') == -1 ? text.length : text.indexOf(' '));
str.substr(text.indexOf(' ') == -1 ? text.length : text.indexOf(' ') + 1);

因此，如果输入是 oneword，就会得到 oneword和 ''。

如果输入为 one word and some more，则得到 one和 word and some more。

在 ES6你也可以

let [first, ...second] = str.split(" ")
second = second.join(" ")

只需将字符串拆分成一个数组，并将所需的部分粘合在一起即可。这种方法非常灵活，在许多情况下都可以工作，而且很容易推理。另外，您只需要一个函数调用。

arr = str.split(' ');             // ["72", "tocirah", "sneab"]
strA = arr[0];                    // "72"
strB = arr[1] + ' ' + arr[2];     // "tocirah sneab"

或者，如果你想从字符串中挑选你需要的东西，你可以这样做:

strA = str.split(' ')[0];                    // "72";
strB = str.slice(strA.length + 1);           // "tocirah sneab"

或者像这样:

strA = str.split(' ')[0];                    // "72";
strB = str.split(' ').splice(1).join(' ');   // "tocirah sneab"

不过我建议用第一个例子。

工作演示: Jsbin

Georg 的解决方案很好，但是如果字符串不包含任何空格就会中断。如果您的字符串有可能不包含空格，那么使用它会更安全。像这样分散和捕捉群体:

str_1 = str.split(/\s(.+)/)[0];  //everything before the first space
str_2 = str.split(/\s(.+)/)[1];  //everything after the first space

比赛后期，我知道，但似乎有一个非常简单的方法来做到这一点:

const str = "72 tocirah sneab";
const arr = str.split(/ (.*)/);
console.log(arr);

这将使 arr[0]带有 "72"，arr[1]带有 "tocirah sneab"。注意，arr [2]将为空，但您可以忽略它。

参考资料:

Https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/string/split#capturing_parentheses

下面的函数将 一直都是把句子分成两个元素。第一个元素将只包含第一个单词，第二个元素将包含所有其他单词(或者它将是一个空字符串)。

var arr1 = split_on_first_word("72 tocirah sneab");       // Result: ["72", "tocirah sneab"]
var arr2 = split_on_first_word("  72  tocirah sneab  ");  // Result: ["72", "tocirah sneab"]
var arr3 = split_on_first_word("72");                     // Result: ["72", ""]
var arr4 = split_on_first_word("");                       // Result: ["", ""]


function split_on_first_word(str)
{
str = str.trim();  // Clean string by removing beginning and ending spaces.


var arr = [];
var pos = str.indexOf(' ');  // Find position of first space


if ( pos === -1 ) {
// No space found
arr.push(str);                // First word (or empty)
arr.push('');                 // Empty (no next words)
} else {
// Split on first space
arr.push(str.substr(0,pos));         // First word
arr.push(str.substr(pos+1).trim());  // Next words
}


return arr;
}

我不知道为什么所有其他的答案都这么复杂，当你可以在一行中做到这一点，同时处理空间不足的问题。

作为一个示例，让我们获取名称的第一个组件和“ rest”组件:

const [first, rest] = 'John Von Doe'.split(/\s+(.*)/);
console.log({ first, rest });


// As array
const components = 'Surma'.split(/\s+(.*)/);
console.log(components);

上面的大多数答案是按空格搜索，而不是按空格搜索。@georg 的答案很好。我有一个稍微不同的版本。

s.trim().split(/\s(.*)/).splice(0,2)

我不确定如何判断哪个是最有效的，因为我的 regexp 要简单得多，但它有额外的位置。

(@georg 的参考是 s.split(/(?<=^\S+)\s/))

这个问题没有指定如何处理没有空格或所有空格、空格前导或后导或空字符串，在这些情况下，我们的结果略有不同。

我为一个需要使用下一个单词的解析器编写这个代码，所以我更喜欢我的定义，尽管@georg 可能更适合其他用例。

input.        mine              @georg
'aaa bbb'     ['aaa','bbb']     ['aaa','bbb']
'aaa bbb ccc' ['aaa','bbb ccc'] ['aaa','bbb ccc']
'aaa '        [ 'aaa' ]         [ 'aaa', '' ]
' '           [ '' ]            [ ' ' ]
''            ['']              ['']
' aaa'        ['aaa']           [' aaa']

我已经使用 .split(" ")[0]得到所有的字符之前的空间。

productName.split(" ")[0]

另一个简单的方法:

str = 'text1 text2 text3';
strFirstWord = str.split(' ')[0];
strOtherWords = str.replace(strFirstWord + ' ', '');

结果:

strFirstWord = 'text1';
strOtherWords = 'text2 text3';

"72 tocirah sneab".split(/ (.*)/,2)

产生指定的结果

[ '72', 'tocirah sneab' ]