如何使用DataTables jQuery插件和正则表达式过滤短语？(How to phrase filter using DataTables jQuery plugin and regex?)

 您的代码存在许多问题。 
 
char* s1 = "Bob";
 
 字符串文字创建一个只读的char数组; 这个数组是静态的，意味着它在程序的整个生命周期中都存在。 由于历史原因，它不是const ，因此如果您尝试修改它，编译器不一定会警告您，但您应该小心避免这样做。 
 
 s1指向该数组的第一个字符。 您不能修改*s1 。 为安全起见，您应该将指针声明为const ： 
 
const char *s1 = "Bob";
 
 如果你想要一个可修改的字符数组，你可以像这样创建它： 
 
char s1[] = "Bob";
 
 现在让我们看看剩下的代码： 
 
if (*s1 >= 97 && *s1 <= 122)
     *s1 -= 32;
}
 
 97和122是'a'和'z'的数字ASCII码。 32是小写字母和相应的大写字母之间的差异 - 再次，用ASCII表示。 
 
 C语言不保证字符以ASCII或与其兼容的任何字符集表示。 例如，在IBM大型机上，字符以EBCDIC表示，其中字母的代码不连续（有间隙），相应的小写字母和大写字母之间的差异为64，而不是32。 
 
 EBCDIC系统现在很少见，但即便如此，便携式代码往往比非可移植代码更清晰 ，即使代码是否适用于所有系统的任何实际问题也是如此。 
 
 我相信你知道，最好的方法是使用tolower函数： 
 
*s1 = tolower((unsigned char)*s1);
 
 注意转换为unsigned char 。 由于历史原因，在<ctype.h>中声明的to*()和is*()函数表现得很奇怪。 它们不适用于char参数; 相反，它们处理在unsigned char范围内的int参数。 （他们也接受EOF ，通常为-1 ）。 如果对plain char进行了签名，则传递恰好为负的char值会导致未定义的行为。 是的，这很烦人。 
 
 但是你说你不想使用tolower 。 （这很好;学会自己做这样的事情是一个很好的练习。） 
 
 如果你愿意假设大写字母是连续的，并且小写字母是连续的，那么你可以这样做： 
 
if (*s1 >= 'a' && *s1 <= 'z') {
    *s1 -= 'a' - 'A';
}
 
 这仍然不能移植到非ASCII系统，但如果您没有记住ASCII表，它会更容易阅读。 
 
 这也让你的逻辑向后变得更加明显。 你说你想转换成小写，但你的代码从小写转换为大写。 
 
 或者您可以使用将小写字母映射到大写字母的查找表： 
 
char to_lower[CHAR_MAX] = { 0 }; /* sets all elements to 0 */
to_lower['A'] = 'a';
to_lower['B'] = 'b';
/* ... */
to_lower['Z'] = 'z';
 
 或者，如果您的编译器支持复合文字： 
 
const char to_lower[CHAR_MAX] = {
    ['A'] = 'a',
    ['B'] = 'b',
    /* ... */
};
 
 我会留给你填写剩下的代码来使用它。 
 
 现在你可以看到为什么tolower和toupper函数存在 - 所以你不必处理所有这些东西（除了你需要的奇怪的unsigned char cast）。 
 
 更新： 
 
 回答您问题的新部分： 
 
char* temp = malloc(100);   
temp = s1;
 
 那个赋值temp = s1; 不复制分配的字符串; 它只是复制指针 。 temp指向100个字节的已分配空间，但是您将temp指向（只读）字符串文字，并且您丢失了对分配空间的任何引用，从而产生内存泄漏。 
 
 您无法在C中分配字符串或数组。要复制字符串，请使用strcpy()函数： 
 
char *temp = malloc(100);
if (temp == NULL) {     /* Don't assume the allocation was successful! */
    fprintf(stderr, "malloc failed\n");
    exit(EXIT_FAILURE);
}
strcpy(temp, s1);
 
 
 
 另外，为什么我需要为已经在内存中的字符串分配内存？ 
 
 
 它在内存中，但它是你不允许修改的内存。 如果要修改它，则需要将其复制到可修改的位置。 或者，正如我上面建议的那样，你可以把它放在读/写内存中： 
 
char s[] = "Bob";
 
 该初始化将字符串复制到数组s 。 

There are a number of problems with your code.
 
char* s1 = "Bob";
 
A string literal creates a read-only array of char; this array is static meaning that it exists for the entire lifetime of your program. For historical reasons, it's not const, so the compiler won't necessarily warn you if you attempt to modify it, but you should carefully avoid doing so.
 
s1 points to the first character of that array. You may not modify *s1. For safety, you should declare the pointer as const:
 
const char *s1 = "Bob";
 
If you want a modifiable character array, you can create it like this:
 
char s1[] = "Bob";
 
Now let's look at the remaining code:
 
if (*s1 >= 97 && *s1 <= 122)
     *s1 -= 32;
}
 
97 and 122 are the numeric ASCII codes for 'a' and 'z'. 32 is the difference between a lower case letter and the corresponding upper case letter -- again, in ASCII.
 
The C language doesn't guarantee that characters are represented in ASCII, or in any of the character sets that are compatible with it. On an IBM mainframe, for example, characters are represented in EBCDIC, in which the codes for the letters are not contiguous (there are gaps), and the difference between corresponding lower case and upper case letters is 64, not 32.
 
EBCDIC systems are rare these days, but even so, portable code tends to be clearer than non-portable code, even aside from any practical issues of whether the code will work on all systems.
 
As I'm sure you know, the best way to do this is to use the tolower function:
 
*s1 = tolower((unsigned char)*s1);
 
Note the cast to unsigned char. The to*() and is*() functions declared in <ctype.h> are oddly behaved, for historical reasons. They don't work on char arguments; rather, they work on int arguments that are within the range of unsigned char. (They also accept EOF, which is typically -1). If plain char is signed, then passing a char value that happens to be negative causes undefined behavior. Yes, it's annoying.
 
But you say you don't want to use tolower. (Which is fine; learning to do things like this yourself is a good exercise.)
 
If you're willing to assume that upper case letters are contiguous, and that lower case letters are contiguous, then you can do something like this:
 
if (*s1 >= 'a' && *s1 <= 'z') {
    *s1 -= 'a' - 'A';
}
 
That's still not portable to non-ASCII systems, but it's a lot easier to read if you don't happen to have the ASCII table memorized.
 
It also makes it a little more obvious that you've got the logic backwards. You say you want to convert to lower case, but your code converts from lower case to upper case.
 
Or you can use a lookup table that maps lower case letters to upper case letters:
 
char to_lower[CHAR_MAX] = { 0 }; /* sets all elements to 0 */
to_lower['A'] = 'a';
to_lower['B'] = 'b';
/* ... */
to_lower['Z'] = 'z';
 
Or, if your compiler supports compound literals:
 
const char to_lower[CHAR_MAX] = {
    ['A'] = 'a',
    ['B'] = 'b',
    /* ... */
};
 
I'll leave it to you to fill in the rest write the code to use it.
 
And now you can see why the tolower and toupper functions exist -- so you don't have to deal with all this stuff (apart from the odd unsigned char casts you'll need). 
 
UPDATE :
 
In response to the new parts of your question:
 
char* temp = malloc(100);   
temp = s1;
 
That assignment temp = s1; doesn't copy the allocated string; it just copies the pointer. temp points to 100 bytes of allocated space, but then you make temp point to the (read-only) string literal, and you've lost any references to the allocated space, creating a memory leak.
 
You can't assign strings or arrays in C. To copy a string, use the strcpy() function:
 
char *temp = malloc(100);
if (temp == NULL) {     /* Don't assume the allocation was successful! */
    fprintf(stderr, "malloc failed\n");
    exit(EXIT_FAILURE);
}
strcpy(temp, s1);
 
 
 
Also, why do I need to allocate memory for a string that already is in memory?
 
 
It's in memory, but it's memory that you're not allowed to modify. If you want to modify it, you need to copy it to a modifiable location. Or, as I suggested above, you can put it in read/write memory in the first place:
 
char s[] = "Bob";
 
That initialization copies the string into the array s.