/(^\s*)(\s*$)/g是啥意思啊？

Posted 2023-05-18

function fTrim(str)

str=str.replace(/(^\s*)|(\s*$)/g, "");
return str;

tring.prototype.Trim = function()return this.replace(/(^\s*)|(\s*$)/g, "");
正则表达式，JS里一组特殊的东东，上例是替换文本前与后的空格，就等于trim

表：正则表达式中的特殊字符：

字符\
意义：对于字符，通常表示按字面意义，指出接着的字符为特殊字符，\不作解释。
例如：/b/匹配字符'b',通过在b 前面加一个反斜杠\，也就是/\b/，则该字符变成特殊字符，表示
匹配一个单词的分界线。
或者：
对于几个字符，通常说明是特殊的，指出紧接着的字符不是特殊的，而应该按字面解释。
例如：*是一个特殊字符，匹配任意个字符(包括0个字符)；例如：/a*/意味匹配0个或多个a。
为了匹配字面上的*，在a前面加一个反斜杠；例如：/a\*/匹配'a*'。

字符^
意义：表示匹配的字符必须在最前边。
例如：/^A/不匹配"an A,"中的'A'，但匹配"An A."中最前面的'A'。

字符$
意义：与^类似，匹配最末的字符。
例如：/t$/不匹配"eater"中的't'，但匹配"eat"中的't'。

字符*
意义：匹配*前面的字符0次或n次。
例如:/bo*/匹配"A ghost booooed"中的'boooo'或"A bird warbled"中的'b'，但不匹配"A goat g
runted"中的任何字符。

字符+
意义：匹配+号前面的字符1次或n次。等价于1,。
例如：/a+/匹配"candy"中的'a'和"caaaaaaandy."中的所有'a'。

字符?
意义：匹配?前面的字符0次或1次。
例如：/e?le?/匹配"angel"中的'el'和"angle."中的'le'。

字符.
意义：(小数点)匹配除换行符外的所有单个的字符。
例如：/.n/匹配"nay, an apple is on the tree"中的'an'和'on'，但不匹配'nay'。

字符(x)
意义：匹配'x'并记录匹配的值。
例如：/(foo)/匹配和记录"foo bar."中的'foo'。匹配子串能被结果数组中的素[1], ..., [n] 返
回，或被RegExp对象的属性$1, ..., $9返回。

字符x|y
意义：匹配'x'或者'y'。
例如：/green|red/匹配"green apple"中的'green'和"red apple."中的'red'。

字符n
意义：这里的n是一个正整数。匹配前面的n个字符。
例如：/a2/不匹配"candy,"中的'a'，但匹配"caandy," 中的所有'a'和"caaandy."中前面的两个
'a'。

字符n,
意义：这里的n是一个正整数。匹配至少n个前面的字符。
例如：/a2,不匹配"candy"中的'a'，但匹配"caandy"中的所有'a'和"caaaaaaandy."中的所有'a'

字符n,m
意义：这里的n和m都是正整数。匹配至少n个最多m个前面的字符。
例如：/a1,3/不匹配"cndy"中的任何字符，但匹配 "candy,"中的'a'，"caandy," 中的前面两个
'a'和"caaaaaaandy"中前面的三个'a'，注意：即使"caaaaaaandy" 中有很多个'a'，但只匹配前面的三
个'a'即"aaa"。

字符[xyz]
意义：一字符列表，匹配列出中的任一字符。你可以通过连字符-指出一个字符范围。
例如：[abcd]跟[a-c]一样。它们匹配"brisket"中的'b'和"ache"中的'c'。

字符[^xyz]
意义：一字符补集，也就是说，它匹配除了列出的字符外的所有东西。 你可以使用连字符-指出一
字符范围。
例如：[^abc]和[^a-c]等价，它们最早匹配"brisket"中的'r'和"chop."中的'h'。

字符[\b]
意义：匹配一个空格(不要与\b混淆)

字符\b
意义：匹配一个单词的分界线，比如一个空格(不要与[\b]混淆)
例如：/\bn\w/匹配"noonday"中的'no'，/\wy\b/匹配"possibly yesterday."中的'ly'。

字符\B
意义：匹配一个单词的非分界线
例如：/\w\Bn/匹配"noonday"中的'on'，/y\B\w/匹配"possibly yesterday."中的'ye'。

字符\cX
意义：这里的X是一个控制字符。匹配一个字符串的控制字符。
例如：/\cM/匹配一个字符串中的control-M。

字符\d
意义：匹配一个数字，等价于[0-9]。
例如：/\d/或/[0-9]/匹配"B2 is the suite number."中的'2'。

字符\D
意义：匹配任何的非数字，等价于[^0-9]。
例如：/\D/或/[^0-9]/匹配"B2 is the suite number."中的'B'。

字符\f
意义：匹配一个表单符

字符\n
意义：匹配一个换行符

字符\r
意义：匹配一个回车符

字符\s
意义：匹配一个单个white空格符，包括空格，tab，form feed，换行符，等价于[ \f\n\r\t\v]。
例如：/\s\w*/匹配"foo bar."中的' bar'。

字符\S
意义：匹配除white空格符以外的一个单个的字符，等价于[^ \f\n\r\t\v]。
例如：/\S/\w*匹配"foo bar."中的'foo'。

字符\t
意义：匹配一个制表符

字符\v
意义：匹配一个顶头制表符

字符\w
意义：匹配所有的数字和字母以及下划线，等价于[A-Za-z0-9_]。
例如：/\w/匹配"apple,"中的'a'，"$5.28,"中的'5'和"3D."中的'3'。

字符\W
意义：匹配除数字、字母外及下划线外的其它字符，等价于[^A-Za-z0-9_]。
例如：/\W/或者/[^$A-Za-z0-9_]/匹配"50%."中的'%'。

字符\n
意义：这里的n是一个正整数。匹配一个正则表达式的最后一个子串的n的值(计数左圆括号)。

例如：/apple(,)\sorange\1/匹配"apple, orange, cherry, peach."中的'apple, orange'，下面
有一个更加完整的例子。
注意：如果左圆括号中的数字比\n指定的数字还小，则\n取下一行的八进制escape作为描述。

字符\ooctal和\xhex
意义：这里的\ooctal是一个八进制的escape值，而\xhex是一个十六进制的escape值，允许在一个
正则表达式中嵌入ASCII码。 参考技术A

这是个正则表达式，表示行首或行尾的空字符。

空字符包括空格、制表符、垂直制表符、换页符、换行符、回车符。

该方法的作用是给字符串去掉首尾的空字符。

拓展资料

正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。

正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。

参考资料：百度百科—正则表达式

参考技术B stringObj.replace(rgExp, replaceText)
将stringObj中满足rgExp这个表达式的内容，使用replaceText进行替换，返回替换结果。

rgExp要求是一个正则表达式。
有关正则表达式的语法，参见http://www.yesky.com/imagesnew/software/vbscript/html/jsgrpRegExpSyntax.htm

str.replace(/(^\s*)|(\s*$)/g, "");
就是把str首尾的空格去掉。本回答被提问者采纳 参考技术C /(^\s*)|(\s*$)/g 这是一段正则表达式
匹配把所有以可见字条开头或结尾的字符串 参考技术D 好像是去掉字符串前后空格。

相当于trim()的功能。

+-r, +-s 的所有排列

【中文标题】+-r, +-s 的所有排列

【英文标题】：all permutations of +-r, +-s

【发布时间】：2017-07-26 08:48:43

【问题描述】：

给定两个数字r 和s，我想获得n +-r 和m +-s 的所有排列列表。例如（使用r=3.14 和s=2.71），

n = 1
m = 1
out = [
    (+r, +s), (+r, -s), (-r, +s), (-r, -s), 
    (+s, +r), (+s, -r), (-s, +r), (-s, -r)
    ]

n = 1
m = 2
out = [
    (+r, +s, +s), (+r, -s, +s), (-r, +s, +s), (-r, -s, +s), ...
    (+s, +r, +s), (-s, +r, +s), (+s, -r, +s), (-s, -r, +s), ...
    ...
    ]

使用itertools.product([+r, -r], repeat=n)，我可以分别获得rs 和ss 的列表，我只需要将它们交织在一起，但我不确定这是否是正确的做法。

效率并不过分重要，所以我不介意产生许多重复结果的解决方案，只是为了使它们在之后变得独一无二。

【参考方案1】：

更新：添加了通用解决方案。

这里有一个解决方案，代码稍微复杂一些，但不会产生重复元素，可以懒惰地求值：

from itertools import combinations, product, chain

r = 3.14
s = 2.71
n = 1
m = 2
idx = combinations(range(n + m), n)
vs = ((r if j in i else s for j in range(n + m)) for i in idx)
res = chain.from_iterable(product(*((+vij, -vij) for vij in vi)) for vi in vs)
print("\n".join(map(str, res)))

输出：

(3.14, 2.71, 2.71)
(3.14, 2.71, -2.71)
(3.14, -2.71, 2.71)
(3.14, -2.71, -2.71)
(-3.14, 2.71, 2.71)
(-3.14, 2.71, -2.71)
(-3.14, -2.71, 2.71)
(-3.14, -2.71, -2.71)
(2.71, 3.14, 2.71)
(2.71, 3.14, -2.71)
(2.71, -3.14, 2.71)
(2.71, -3.14, -2.71)
(-2.71, 3.14, 2.71)
(-2.71, 3.14, -2.71)
(-2.71, -3.14, 2.71)
(-2.71, -3.14, -2.71)
(2.71, 2.71, 3.14)
(2.71, 2.71, -3.14)
(2.71, -2.71, 3.14)
(2.71, -2.71, -3.14)
(-2.71, 2.71, 3.14)
(-2.71, 2.71, -3.14)
(-2.71, -2.71, 3.14)
(-2.71, -2.71, -3.14)

说明

我们可以将输出视为包含 n +/- r 元素和 m +/- s 元素的排列，或者换句话说，n + m 元素的元组其中n 是 +/- r，其余的是 +/- s。 idx 包含具有 +/- r 元素的所有可能位置的元组；例如，第一个结果是(0,)。

然后，对于这些元组i 中的每一个，我们在vs 中创建“模板”元组，它们只是大小为n + m 的元组，其中i 中的索引是r，其余的是s。因此，对于idx 中的元组(0,)，您将得到(r, s, s)。如果n + m 非常大，您可以考虑上一步idx = map(set, idx) 以更快地进行in 操作，但我不确定在哪一点值得这样做。

最后，对于v 中的每个vi 模板，我需要考虑对其每个元素使用正值和负值的所有可能性。所以它是(+vi[0], -vi[0]), (+vi[1], -vi[1]), ... 的笛卡尔积。最后，您只需链接每个产品的每个生成器即可获得最终结果。

一般解决方案

要为任意数量的不同元素构建问题的通用解决方案，您需要考虑索引集的分区。例如，对于n = 3 和m = 5，您可以使用所有可能的方式将0, 1, 2, 3, 4, 5, 6, 7 分成大小为3 和5 的两部分。下面是一个实现：

from itertools import chain, repeat, permutations, product


def partitions(*sizes):
    if not sizes or all(s <= 0 for s in sizes):
        yield ()
    for i_size, size in enumerate(sizes):
        if size <= 0:
            continue
        next_sizes = sizes[:i_size] + (sizes[i_size] - 1,) + sizes[i_size + 1:]
        for p in partitions(*next_sizes):
            yield (i_size,) + p


def signed_permutations(*elems):
    values, sizes = zip(*elems)
    templates = partitions(*sizes)
    return chain.from_iterable(
        product(*((+values[ti], -values[ti]) for ti in t)) for t in templates)


r = 3.14
s = 2.71
n = 1
m = 2
res = signed_permutations((r, n), (s, m))
print("\n".join(map(str, res)))

这个想法是一样的，你构建“模板”（这次它们包含值的索引而不是值本身），然后是它们的笛卡尔积。

【讨论】：

这似乎不起作用：list(itertools.product(*([[+r, -r]] * 1 + [[+s, -s]] * 1))) 给了[(3.14, 2.71), (3.14, -2.71), (-3.14, 2.71), (-3.14, -2.71)] -- 3.14 永远不会排在第二位。

一两句解释肯定有助于理解代码。

@NicoSchlömer 对，我已经添加了一些解释，如果不清楚，请告诉我。

@NicoSchlömer 又一次更新，为任意数量的不同元素提供了通用解决方案。

可以使用 Knuth 的“算法 L”，而不是您自己的 partitions，例如在 ***.com/questions/4250125/… 实现。

【参考方案2】：

您还可以将r 和s 的permutations 与+1 和-1 和zip 的product 结合起来。这样，整个结构就更易读了，恕我直言：

>>> n, m = 1, 2
>>> r, s = 3.14, 2.71
>>> [[x*i for x,i in zip(perm, prod)] for perm in permutations([r]*n + [s]*m) 
...                                   for prod in product((+1, -1), repeat=n+m)]
[[3.14, 2.71, 2.71],
 [3.14, 2.71, -2.71],
 ...
 [-2.71, -2.71, 3.14],
 [-2.71, -2.71, -3.14]]

【参考方案3】：

首先使用product，然后在每个元素上使用permutations。然后连接所有结果并将它们传递给set() 以删除重复项：

arr = set(itertools.chain.from_iterable([
    itertools.permutations(x)
    for x in itertools.product(*([[+r, -r]] * n + [[+s, -s]] * m))
    ]))
print(arr)