精华内容
下载资源
问答
  • C++中如何访问字符串中的单个字符

    千次阅读 2019-08-15 20:32:34
    访问字符串中的单个字符是像字符数组那样使用下标访问字符串中的某个元素。 #include <iostream> int main(int argc,const char* argv[]) { std::string str1 = "Hello World!"; //向访问字符数组那样,将...

    访问字符串中的单个字符

    访问字符串中的单个字符是像字符数组那样使用下标访问字符串中的某个元素。

    #include <iostream>
    
    int main(int argc,const char* argv[])
    {
    	std::string str1 = "Hello World!";
    
    	//向访问字符数组那样,将字符串中的第二个字符提取出来显示,如果下标越界,不会报告错误。
    	std::cout << str1[2] << std::endl;
    
    	//使用成员函数来获得字符串中的第6个字符并显示,如果参数越界,函数将抛出异常。
    	std::cout << str1.at(6) << std::endl;
    
    	return 0;
    }
    
    展开全文
  • 例如string s="abc"; s[0]是'a'这是可以的。 那如果在s没有被初始化之前就对单个字符赋值难道是不可以的吗? 比如:string s; s[0]='a'; 这样编译器会提示string下标越界?只能先初始化吗?
  • Python字符串元素访问与截取

    万次阅读 2018-11-23 20:55:41
    得到Python的各种序列后,接下里就要知晓如何访问或取出序列中的数据。看着很简单,但是随着所学的序列越来越多后,比如字符串、列表、元组、字典、一维数组、多维...访问单个元素 给出下标即可,第一个元素的下...

     得到Python的各种序列后,接下里就要知晓如何访问或取出序列中的数据。看着很简单,但是随着所学的序列越来越多后,比如字符串、列表、元组、字典、一维数组、多维数组、Series、DataFrame,渐渐的脑子就会混乱,所以打算梳理一下。先从最简单的字符串开始。其他序列可参看鄙人其他博文,如果我写了的话。

     

    字符串可以单个访问,也可以切片访问。

    访问单个元素

    给出下标即可,第一个元素的下标是0,最后一个的下标既可以是(长度-1)也可以是-1。

    索引可以分为正索引和负索引。

    假设有个字符串“01234567”,那么它对应的索引如下图所示:

    temp="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    print(temp[0])  #A   下标从0开始计数
    print(temp[-1])  #Z
    

    字符串的切片操作

    格式:<字符串>[<起始位置>:<终止位置>:<步长>]

    步长为1,每次走一步;步长为2,每次走两步,中间隔一位。得到从<起始位置>开始,间隔为<步长>,到<终止位置>前一个字符结束的字符串。也就是说是一个左闭右开区间。

    起始位置可以省略,表示起始位置为0,从第一个开始。<终止位置>可以省略,表示终止位置为末尾,到最后一个为止。步长也可以省略,表示步长为1。

    步长可以为负。

    字符串第一个元素的索引是0,字符串最后一个元素的所以是len(str)-1或者是-1。

    之后的可以以此类推。

    普通切片操作

    temp="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    #从索引为0的位置开始输出,直到输出索引为9的位置的数据(10不包括)
    #步长默认为1
    print(temp[0:10])  #ABCDEFGHIJ
    
    print(temp[0:10:2])
    #开始我以为会输出ADG……形式的数据,但结果是ACEGI
    #原来步长为2,中间只隔一个……
    

    输出从第一个到倒数第N个数

    同理也可推出第M个数到倒数第N个数。

    例如:输出不包含最后两个元素的字符串切片。

    temp="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    print(temp[0:-2])
    #ABCDEFGHIJKLMNOPQRSTUVWX
    #最末尾两个数没有输出,步长是1已经省略
    #亦可写成
    print(temp[:-2])  #ABCDEFGHIJKLMNOPQRSTUVWX
    #完整形式是print(temp[0:-2:1])
    

    输出末尾的N个数

    例如从倒数第2个数开始输出

    temp="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    print(temp[-2:])  #YZ
    #完整形式是print(temp[-2:27:1])
    

    全部逆序输出 

    temp="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    print(temp[::-1])
    #ZYXWVUTSRQPONMLKJIHGFEDCBA
    

    循环迭代输出

    字符串作为可迭代对象,自然可以迭代循环输出。

    str = "ABCDEFG"
    for s in str:
        print(s, end = " ")
    #A B C D E F G
    str = "ABCDEFG"
    for index, item in enumerate(str):
        print(item, end =" ")
    #A B C D E F G

    遇到新的用法会更新,另,如有错误,还请指出。

    展开全文
  • String用法详解

    万次阅读 多人点赞 2018-04-05 16:15:51
    string类声明string类本不是STL的容器,但是它与STL容器有着很多相似的操作,因此,把string放在这里一起进行介绍。 之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必担心...

    string类

    声明

    string类本不是STL的容器,但是它与STL容器有着很多相似的操作,因此,把string放在这里一起进行介绍。 
    之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下的需要。我们尽可以把它看成是C++的基本数据类型。 
    首先,为了在我们的程序中使用string类型,我们必须包含头文件。如下:

    #include  <string>  // 注意这里不是string.h,string.h是C字符串头文件

    1、声明一个C++字符串

    声明一个字符串变量很简单: string str; 
    这样我们就声明了一个字符串变量,但既然是一个类,就有构造函数和析构函数。上面的声明没有传入参数,所以就直接使用了string的默认的构造函数,这个函数所作的就是把str初始化为一个空字符串。string类的构造函数和析构函数如下:

    1)  string s;  // 生成一个空字符串s 
    2)  string s(str) ; // 拷贝构造函数生成str的复制品 
    3)  string s(str, stridx);  // 将字符串str内"始于位置stridx"的部分当作字符串的初值 
    4)  string s(str, stridx, strlen) ; // 将字符串str内"始于stridx且长度顶多strlen"的部分作为字符串的初值 
    5)  string s(cstr) ;  // 将C字符串(以NULL结束)作为s的初值 
    6)  string s(chars, chars_len) ;  // 将C字符串前chars_len个字符作为字符串s的初值。 
    7)  string s(num, ‘c’) ;  // 生成一个字符串,包含num个c字符 
    8)  string s(“value”);  string s=“value”;  // 将s初始化为一个字符串字面值副本
    9)  string s(begin, end);  // 以区间begin/end(不包含end)内的字符作为字符串s的初值 
    10) s.~string();  //销毁所有字符,释放内存 

    2、string与C字符数组的比较

    string串要取得其中某一个字符,和传统的C字符串一样,可以用s[i]的方式取得。比较不一样的是如果s有三个字符,传统C的字符串的s[3]是’\0’字符,但是C++的string则是只到s[2]这个字符而已。

    1、C风格字符串

    • 用”“括起来的字符串常量,C++中的字符串常量由编译器在末尾添加一个空字符;
    • 末尾添加了‘\0’的字符数组,C风格字符串的末尾必须有一个’\0’。

    2、C字符数组及其与string串的区别

    • char ch[ ]={‘C’, ‘+’, ‘+’}; //末尾无NULL
    • char ch[ ]={‘C’, ‘+’, ‘+’, ‘\0’}; //末尾显式添加NULL
    • char ch[ ]=”C++”; //末尾自动添加NULL字符 若[ ]内数字大于实际字符数,将实际字符存入数组,其余位置全部为’\0’。 
      这里写图片描述

    3、string对象的操作

    string s;
    1)  s.empty();  // s为空串 返回true
    2)  s.size();  // 返回s中字符个数 类型应为:string::size_type
    3)  s[n];  //0开始相当于下标访问
    4)  s1+s2;  // 把s1和s2连接成新串 返回新串 
    5)  s1=s2;  // 把s1替换为s2的副本
    6)  v1==v2;  // 比较,相等返回true
    7)  `!=, <, <=, >, >=`  惯有操作 任何一个大写字母都小于任意的小写字母

    当进行string对象和字符串字面值混合连接操作时,+操作符的左右操作数必须至少有一个是string类型的:

    string s1(“hello”);
    string s3=s1+”world”;  //合法操作
    string s4=”hello”+”world”;  //非法操作:两个字符串字面值相加

    4、字符串操作函数

    1、string类函数

    1) =, s.assign() // 赋以新值 
    2) swap() // 交换两个字符串的内容 
    3) +=, s.append(), s.push_back() // 在尾部添加字符 
    4) s.insert() // 插入字符 
    5) s.erase() // 删除字符 
    6) s.clear() // 删除全部字符 
    7) s.replace() // 替换字符 
    8) + // 串联字符串 
    9) ==,!=,<,<=,>,>=,compare() // 比较字符串 
    10) size(),length() // 返回字符数量 
    11) max_size() // 返回字符的可能最大个数 
    12) s.empty() // 判断字符串是否为空 
    13) s.capacity() // 返回重新分配之前的字符容量 
    14) reserve() // 保留一定量内存以容纳一定数量的字符 
    15) [ ], at() // 存取单一字符 
    16) >>,getline() // 从stream读取某值 
    17) << // 将谋值写入stream 
    18) copy() // 将某值赋值为一个C_string 
    19) c_str() // 返回一个指向正规C字符串(C_string)的指针 内容与本string串相同 有’\0’ 
    20) data() // 将内容以字符数组形式返回 无’\0’ 
    21) s.substr() // 返回某个子字符串 
    22) begin() end() // 提供类似STL的迭代器支持 
    23) rbegin() rend() // 逆向迭代器 
    24) get_allocator() // 返回配置器

    2、函数说明

    1、s.assign();

    s.assign(str); // 不说 
    s.assign(str,1,3); // 如果str是"iamangel" 就是把"ama"赋给字符串 
    s.assign(str,2,string::npos); // 把字符串str从索引值2开始到结尾赋给s 
    s.assign("gaint"); // 不说 
    s.assign("nico",5); // 把’n’ ‘I’ ‘c’ ‘o’ ‘\0’赋给字符串 
    s.assign(5,'x'); // 把五个x赋给字符串

    2、大小和容量函数

    一个C++字符串存在三种大小: 
    1) 现有的字符数,函数是s.size()和s.length(),他们等效。s.empty()用来检查字符串是否为空。 
    2) max_size(); 这个大小是指当前C++字符串最多能包含的字符数,很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。 
    3) capacity()重新分配内存之前string所能包含的最大字符数。 
    这里另一个需要指出的是reserve()函数,这个函数为string重新分配内存。重新分配的大小由其参数决定,默认参数为0,这时候会对string进行非强制性缩减。

    3、元素存取

    我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。但是应该注意的是操作符[]并不检查索引是否有效(有效索引0~str.length()),如果索引失效,会引起未定义的行为。而at()会检查,如果使用at()的时候索引无效,会抛出out_of_range异常。 
    有一个例外不得不说,const string a;的操作符[]对索引值是a.length()仍然有效,其返回值是’\0’。其他的各种情况,a.length()索引都是无效的。

    4、比较函数

    C ++字符串支持常见的比较操作符(>,>=,<,<=,==,!=),甚至支持string与C-string的比较(如 str<”hello”)。在使用>,>=,<,<=这些操作符的时候是根据”当前字符特性”将字符按字典顺序进行逐一的比较。字典排序靠前的字符小,比较的顺序是从前向后比较,遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。 
    另一个功能强大的比较函数是成员函数compare()。他支持多参数处理,支持用索引值和长度定位子串来进行比较。他返回一个整数来表示比较结果,返回值意义如下:0-相等 、>0-大于、<0-小于。

    5、插入字符

    也许你需要在string中间的某个位置插入字符串,这时候你可以用insert()函数,这个函数需要你指定一个安插位置的索引,被插入的字符串将放在这个索引的后面。 
    s.insert(0,”my name”); 
    s.insert(1,str); 
    这种形式的insert()函数不支持传入单个字符,这时的单个字符必须写成字符串形式。为了插入单个字符,insert()函数提供了两个对插入单个字符操作的重载函数: 
    insert(size_type index, size_type num, chart c)和insert(iterator pos, size_type num, chart c)。 
    其中size_type是无符号整数,iterator是char*,所以,你这么调用insert函数是不行的: 
    insert(0, 1, ‘j’);这时候第一个参数将转换成哪一个呢? 
    所以你必须这么写:insert((string::size_type)0, 1, ‘j’)! 
    第二种形式指出了使用迭代器安插字符的形式。

    6、提取子串s.substr()

    s.substr(); // 返回s的全部内容 
    s.substr(11); // 从索引11往后的子串 
    s.substr(5,6); // 从索引5开始6个字符

    5、字符串流stringstream操作

    Iostream标准库支持内存中的输入输出,只要将流与存储在程序内存中的string对象捆绑起来即可。此时,可使用iostream输入和输出操作符读写这个stream对象。使用stringstream,我们必须包含头文件#include。

    1、string s

    1)  >>操作符 // 用于从istream对象中读入输入
    2)  is >> s;  // 从输入流is中读取一个以空白字符分割的字符串,写入s
    3)  <<操作符 // 用于把输出写到ostream对象中
    4)  os << s; // 将s写到输出流os中
    5)  getline(is, s);  // 从输入流is中读取一行字符,写入s,直到遇到分行符或到了文件尾
    6)  istream // 输入流 提供输入操作
    7)  ostream // 输出流 提供输出操作

    2、stringstream特定的操作

    1)  stringstream strm; // 创建自由的stringstream对象
    2)  stringstream strm(s); // 创建存储s的副本的stringstream对象,s是stringstream类型
    3)  strm.str(); // 返回strm中存储的string类型对象
    4)  strm.str(s); // 将string类型的s复制给strm 返回void

    3、string到int的转换

    stringstream通常是用来做数据转换的,如果你打算在多次转换中使用同一个stringstream对象,记住在每次转换前要使用clear()方法。在多次转换中重复使用同一个stringstream(而不是每次都创建一个新的对象)对象最大的好处在于效率。stringstream对象的构造和析构函数通常是非常耗费CPU时间的。 
    string到int的转换(与其他类型间的转换一样大同小异):

    string result=”10000”;  
    int n=0;
    stream<<result;
    stream>>n;  // n等于10000

    6、C字符串、string串、stringstream之间的关系

    首先必须了解,string可以被看成是以字符为元素的一种容器。字符构成序列(字符串)。有时候在字符序列中进行遍历,标准的string类提供了STL容器接口。具有一些成员函数比如begin()、end(),迭代器可以根据他们进行定位。注意,与char*不同的是,string不一定以NULL(‘\0’)结束。string长度可以根据length()得到,string可以根据下标访问。所以,不能将string直接赋值给char*。

    1、string转换成const char *

    如果要将字面值string直接转换成const char *类型。string有2个函数可以运用:一个是.c_str(),一个是data成员函数。 
    c_str()函数返回一个指向正规C字符串的指针,内容与本string串相同。这是为了与C语言兼容,在C语言中没有string类型,故必须通过string类对象的成员函数c_str()把string 对象转换成C中的字符串样式。注意:一定要使用strcpy()函数等来操作方法c_str()返回的指针

    string str = "Hello World";
    const char *ch1 = str.c_str();
    const char *ch2 = str.data();

    此时,ch1与ch2的内容将都是”Hello World”。但是只能转换成const char*,如果去掉const编译不能通过。

    2、string转换成char *

    C++提供的由C++字符串得到对应的C_string的方法是使用data()、c_str()和copy(),其中 
    1) data()以字符数组的形式返回字符串内容,但并不添加’\0’。 
    2) c_str()返回一个以’\0’结尾的字符数组,返回值是const char*。 
    3) copy()则把字符串的内容复制或写入既有的c_string或字符数组内。 
    C++字符串并不以’\0’结尾。我的建议是在程序中能使用C++字符串就使用,除非万不得已不选用c_string。 
    如果要转换成char*,可以用string的一个成员函数strcpy实现。

    string str = "Hello World";
    int len = str.length();
    char *data = new char[len+1];  //这里+1还是不+1需要注意
    strcpy(data, str.c_str());  // const char *data = new char[len+1];  strcpy(data, str);

    此时,data中的内容为”Hello World”使用c_str()要么str赋给一个const指针,要么用strcpy()复制。

    3、char *转换成string

    string类型能够自动将C风格的字符串转换成string对象:

    string str; 
    const char *pc = "Hello World"; 
    str = pc;
    printf(“%s\n”, str);  //此处出现错误的输出
    cout<<str<<endl;

    不过这个是会出现问题的。有一种情况我要说明一下。当我们定义了一个string类型之后,用printf(“%s”,str);输出是会出问题的。这是因为“%s”要求后面的对象的首地址。但是string不是这样的一个类型。所以肯定出错。 
    用cout输出是没有问题的,若一定要printf输出。那么可以这样:

    printf("%s",str.c_str());

    4、char[ ] 转换成string

    这个与char*的情况相同,也可以直接赋值,但是也会出现上面的问题,需要同样的处理。 
    - 字符数组转化成string类型:

    char ch [] = "ABCDEFG";
    string str(ch); //也可string str = ch;

    或者

    char ch [] = "ABCDEFG";
    string str;
    str = ch; //在原有基础上添加可以用str += ch;

    5、string转换成char[ ]

    string对象转换成C风格的字符串:

    const char *str = s.c_str();

    这是因为为了防止字符数组被程序直接处理c_str()返回了一个指向常量数组的指针。 
    由于我们知道string的长度可以根据length()函数得到,又可以根据下标直接访问,所以用一个循环就可以赋值了,这样的转换不可以直接赋值。

    string str = "Hello World";
    int len=str.length();
    char ch[255]={};
    for( int i=0;i<str.length();i++)
    ch[i] = str[i];
    ch[len+1] = '\0';
    printf("%s\n", ch);
    cout<<ch<<endl;

    6、stringstream与string间的绑定

    stringstream strm;
    string s;
    strm<<s;  // 将s写入到strm
    strm>>s;  // 从strm读取串写入s
    strm.str(); // 返回strm中存储的string类型对象
    strm.str(s); // 将string类型的s复制给strm 返回void
    char* cstr;  // 将C字符数组转换成流
    string str(cstr);
    stringstream ss(str);
    展开全文
  • elasticsearch 基础 —— Query String

    万次阅读 2018-09-19 11:54:29
    使用查询解析器来解析其内容的查询。下面是一个例子: ...query_string" : { "default_field" : "content", "query" : "this AND that OR thus" } } } query

    使用查询解析器来解析其内容的查询。下面是一个例子:

    GET /_search
    {
        "query": {
            "query_string" : {
                "default_field" : "content",
                "query" : "this AND that OR thus"
            }
        }
    }

    query_string查询解析输入并在运算符周围分割文本。每个文本部分彼此独立地分析。例如以下查询:

    GET /_search
    {
        "query": {
            "query_string" : {
                "default_field" : "content",
                "query" : "(new york city) OR (big apple)"
            }
        }
    }

    将分成new york city 或 big apple,然后通过为该字段配置的分析器独立地分析每个部分。

    空格不被视为运算符,这意味着new york city将“按原样”传递给为该字段配置的分析器。如果该字段是关键字字段,则分析器将创建单个术语new york city,并且查询构建器将在查询中使用此术语。如果要分别查询每个术语,则需要在术语周围添加显式运算符(例如new AND york AND city)

    当提供多个字段时,也可以修改如何使用类型参数在每个文本部分内组合不同字段查询。这里描述了可能的模式,默认是Bestfield。query_string顶级参数包括: 

    参数 描述

    query

    要解析的实际查询。参见查询字符串语法

    default_field

    如果未指定前缀字段,则查询字词的默认字段。默认为index.query.default_field索引设置,而索引设置默认为*.*提取映射中符合术语查询条件的所有字段,并过滤元数据字段。然后组合所有提取的字段以在没有提供前缀字段时构建查询。

    default_operator

    如果未指定显式运算符,则使用默认运算符。例如,使用默认运算符OR,查询 capital of Hungary将转换为capital OR of OR Hungary,并且使用默认运算符AND,将相同的查询转换为capital AND of AND Hungary。默认值为OR

    analyzer

    用于分析查询字符串的分析器名称。

    quote_analyzer

    分析器的名称,用于分析查询字符串中的引用短语。对于这些部件,它将覆盖使用analyzer参数或 search_quote_analyzer设置设置的其他分析器。

    allow_leading_wildcard

    设置时,*?允许作为第一个字符。默认为true

    enable_position_increments

    设置为true在结果查询中启用位置增量。默认为true

    fuzzy_max_expansions

    控制模糊查询将扩展到的术语数。默认为50

    fuzziness

    设置模糊查询的模糊性。默认为AUTO。请参阅允许设置的模糊性编辑

    fuzzy_prefix_length

    设置模糊查询的前缀长度。默认是0

    fuzzy_transpositions

    设置为false禁用模糊转置(ab→ ba)。默认是true

    phrase_slop

    设置短语的默认斜率。如果为零,则需要精确的短语匹配。默认值是0

    boost

    设置查询的提升值。默认为1.0

    auto_generate_phrase_queries

    默认为false

    analyze_wildcard

    默认情况下,不分析查询字符串中的通配符。通过将此值设置为true,将尽最大努力分析这些值。

    max_determinized_states

    限制允许创建的regexp查询的自动机状态数。这可以防止太难(例如指数级硬)的regexp。默认为10000。

    minimum_should_match

    一个值,用于控制生成的布尔查询中应该匹配的“should”子句的数量。它可以是绝对值(2),百分比(30%)或两者的 组合

    lenient

    如果设置为true将导致基于格式的失败(如向数字字段提供文本)将被忽略。

    time_zone

    时区应用于与日期相关的任何范围查询。另见 JODA时区

    quote_field_suffix

    附加到查询字符串的引用部分的字段的后缀。这允许使用具有不同分析链的字段进行精确匹配。看看这里为一个完整的例子。

    auto_generate_synonyms_phrase_query

    是否应为多项同义词自动生成短语查询。默认为true

    all_fields

    6.0.0 ] 在6.0.0中已弃用。设置default_field*代替执行上可以查询映射检测到的所有字段的查询。_all禁用该字段时将默认使用,并且未default_field指定no (在索引设置或请求正文中)并且未fields指定no 。

    在生成多项查询时,可以使用rewrite 参数控制如何重写它 。

    Default Field

    如果未在查询字符串语法中明确指定要搜索的字段,index.query.default_field则将使用该字段来派生要搜索的字段。如果index.query.default_field未指定,query_string则将自动尝试确定索引映射中可查询的现有字段,并对这些字段执行搜索。请注意,这不包括嵌套文档,使用嵌套查询来搜索这些文档。

    Multi Field

    query_string查询还可以运行针对多个领域。可以通过"fields"参数提供字段(示例如下)。

    field1:query_term OR field2:query_term | ...

    query_string针对多个字段运行查询的想法是将每个查询字词扩展为OR子句,如下所示:

    例如,以下查询

    GET /_search
    {
        "query": {
            "query_string" : {
                "fields" : ["content", "name"],
                "query" : "this AND that"
            }
        }
    }

    匹配相同的单词

    GET /_search
    {
        "query": {
            "query_string": {
                "query": "(content:this OR name:this) AND (content:that OR name:that)"
            }
        }
    }

    由于从单个搜索项生成了多个查询,因此使用dis_max带有tie_breaker 的查询自动组合它们。例如(name使用^5符号表示增强5 ):

    GET /_search
    {
        "query": {
            "query_string" : {
                "fields" : ["content", "name^5"],
                "query" : "this AND that OR thus",
                "tie_breaker" : 0
            }
        }
    }

    简单通配符也可用于搜索文档的特定内部元素“内”。例如,如果我们有一个city包含多个字段(或带有字段的内部对象)的对象,我们可以自动搜索所有“城市”字段:

    GET /_search
    {
        "query": {
            "query_string" : {
                "fields" : ["city.*"],
                "query" : "this AND that OR thus"
            }
        }
    }

    另一种选择是在查询字符串本身中提供通配符字段搜索(正确转义*符号),例如 city.\*:something

    GET /_search
    {
        "query": {
            "query_string" : {
                "query" : "city.\\*:(this AND that OR thus)"
            }
        }
    }

    由于\(反斜杠)是json字符串中的特殊字符,因此需要对其进行转义,因此上面的两个反斜杠query_string

    query_string对多个字段运行查询时,允许使用以下附加参数:

    参数 描述

    type

    应如何组合字段以构建文本查询。有关完整示例,请参阅类型。默认为best_fields

    参数 描述

    tie_breaker

    用于多场的分离最大连接断路器。默认为0

     fields参数还可以包括基于通配符字段名称,允许自动扩展到相关字段(包括动态引入的字段)。例如:

    GET /_search
    {
        "query": {
            "query_string" : {
                "fields" : ["content", "name.*^5"],
                "query" : "this AND that OR thus"
            }
        }
    }

    Synonyms 同义词

    query_string查询支持使用synonym_graph标记过滤器进行多项同义词扩展。使用此过滤器时,解析器会为每个多项同义词创建一个短语查询。例如,以下同义词:"ny, new york" would produce:(ny OR ("new york"))也可以将多项同义词与连词相匹配:

    GET /_search
    {
       "query": {
           "query_string" : {
               "default_field": "title",
               "query" : "ny city",
               "auto_generate_synonyms_phrase_query" : false
           }
       }
    }

    上面的例子创建了一个布尔查询:

    (ny OR (new AND york)) city)

    将文档与术语ny或连词匹配new AND york。默认情况下,参数auto_generate_synonyms_phrase_query设置为true

    Query string syntax

    查询字符串“迷你语言”由 查询字符串查询API中的 q查询字符串参数search使用

    查询字符串被解析为一系列术语运算符。术语可以是单个单词 -  quickbrown - 或短语,由双引号括起来 -  "quick brown" 以相同的顺序搜索短语中的所有单词。

    操作员允许您自定义搜索 - 可用选项如下所述。

    Field names

    查询字符串查询中所述default_field,搜索搜索词,但可以在查询语法中指定其他字段:

    • 其中status字段包含active

      status:active
    • 其中title字段包含quickbrown。如果省略OR运算符,将使用默认运算符

      title:(quick OR brown)
      title:(quick brown)
    • 其中author字段包含精确短语"john smith"

      author:"John Smith"
      
    • 其中任何字段book.titlebook.contentbook.date包含 quickbrown(注意我们需要如何*使用反斜杠转义):

      book.\*:(quick brown)
      
    • 该字段title具有任何非null值:

      _exists_:title
      

    Wildcards 通配符

    通配符搜索可以在单个术语上运行,使用?替换单个字符,并*替换零个或多个字符:

    qu?ck bro *
    

    请注意,通配符查询可能使用大量的内存,并且执行得很糟糕,只要想想需要查询多少项来匹配查询字符串“a*b*c*”。

    纯通配符\*被重写为exists查询效率。因此,通配符"field:*"将匹配具有空值的文档,如下所示:````{“field”:“”}```... 如果字段丢失或使用显式空值设置则不匹配如下所示:```{`field“:null}```

    允许在单词的开头(例如"*ing")使用通配符特别重,因为需要检查索引中的所有术语,以防它们匹配。可以通过设置allow_leading_wildcard为禁用前导通配符 false

    Regular expressions 正则表达式

    正则表达式模式可以通过将它们包装在forward-slashes("/")中嵌入查询字符串中:

    name:/joh?n(ath[oa]n)/
    

    正则表达式语法中解释了受支持的正则表达式语法

    allow_leading_wildcard参数对正则表达式没有任何控制权。如下所示的查询字符串将强制Elasticsearch访问索引中的每个术语:/.*n/ 谨慎使用!

    Fuzziness 模糊

    我们可以使用“fuzzy”运算符搜索与我们的搜索字词类似但不完全相同的字词:

    quikc~ brwn~ foks~

    它使用 Damerau-Levenshtein distance 来查找最多有两个变化的所有术语,其中一个变化是插入、删除或替换单个字符,或替换两个相邻字符。

    默认编辑距离为2,但是编辑距离为1应该足以捕捉所有人类拼写错误的80%。它可以被指定为:

    quikc~1

    Proximity searches 邻近搜索

    虽然短语查询(例如"john smith")期望所有术语具有完全相同的顺序,但是邻近查询允许指定的单词更远或者以不同的顺序。与模糊查询可以为单词中的字符指定最大编辑距离的方式相同,邻近搜索允许我们指定短语中单词的最大编辑距离:

    "fox quick"~5

    字段中的文本越接近查询字符串中指定的原始顺序,该文档被认为越相关。与上面的示例查询相比,该短语"quick fox"将被视为更相关"quick brown fox"

    Ranges 范围

    可以为日期,数字或字符串字段指定范围。包含范围用方括号指定,[min TO max]排他范围用大括号指定{min TO max}

    • All days in 2012:

      date:[2012-01-01 TO 2012-12-31]
    • Numbers 1..5

      count:[1 TO 5]
    • Tags between alpha and omega, excluding alpha and omega:

      tag:{alpha TO omega}
    • Numbers from 10 upwards

      count:[10 TO *]
    • Dates before 2012

      date:{* TO 2012-01-01}

    可以组合使用大括号和方括号:

    • 数字从1到5但不包括5

    count:[1 TO 5}

    一边无范围的范围可以使用以下语法:

    age:>10
    age:>=10
    age:<10
    age:<=10

    要将上限和下限与简化语法结合使用,您需要将两个子句与AND运算符连接:

    age:(>=10 AND <20)
    age:(+>=10 +<20)

    查询字符串中的范围解析可能很复杂且容易出错。使用显式range查询更加可靠。

    Boosting 提升权重

    使用boost运算符^使一个术语比另一个术语更相关。例如,如果我们想要找到关于foxes的所有文档,但我们对quick foxes特别感兴趣:

    quick^2 fox

    默认boost值为1,但可以是任何正浮点数。0到1之间的提升会降低相关性。

    提升也可以应用于短语或群组:

    "john smith"^2   (foo bar)^4

    Boolean operators 布尔运算符

    默认情况下,只要一个术语匹配,所有术语都是可选的。搜索foo bar baz将查找包含一个或多个foobar或的任何文档 baz。我们已经讨论了default_operator 上面的内容,它允许你强制要求所有的术语,但也有一些布尔运算符可以在查询字符串本身中使用,以提供更多的控制。

    首选运算符+(此术语必须存在)和- (此术语不得出现)。所有其他条款都是可选的。例如,这个查询:

    quick brown +fox -news

    说明:

    • fox 必须存在
    • news 一定不能存在
    • quickbrown是可选的 - 它们的存在增加了相关性

    熟悉的布尔运算符ANDOR以及NOT(也写作&&|| 和!)也支持,但要小心,他们不遵守通常的优先级规则,所以每当多个运营商一起使用时,应使用括号。例如,以前的查询可以重写为:

    ((quick AND fox) OR (brown AND fox) OR fox) AND NOT news

    此表单现在可以正确复制原始查询中的逻辑,但相关性评分与原始查询几乎没有相似之处。

    相反,使用查询重写的相同match查询 将如下所示:

    {
        "bool": {
            "must":     { "match": "fox"         },
            "should":   { "match": "quick brown" },
            "must_not": { "match": "news"        }
        }
    }

    Grouping 分组

    可以将多个术语或子句与括号组合在一起,以形成子查询:

    (quick OR brown) AND fox

    组可用于定位特定字段,或用于提升子查询的结果:

    status:(active OR pending) title:(full text search)^2

    Reserved characters 保留字符

    如果你需要在查询本身中使用任何作为运算符的字符(而不是运算符),那么你应该使用前导反斜杠来转义它们。例如,要搜索(1+1)=2,您需要将查询编写为\(1\+1\)\=2

    保留的字符是: + - = && || > < ! ( ) { } [ ] ^ " ~ * ? : \ /

    无法正确转义这些特殊字符可能会导致语法错误,从而阻止您的查询运行。

    <and>根本无法转义。 阻止它们尝试创建范围查询的唯一方法是完全从查询字符串中删除它们。

    Empty Query 空查询

    如果查询字符串为空或仅包含空格,则查询将生成空结果集。

     

    展开全文
  • string详解

    千次阅读 2012-03-22 10:30:28
    之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。...
  • C++ STL string类相关

    千次阅读 2010-11-26 16:07:00
    之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必  担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下(甚至是...
  • 使用指针访问数组元素

    万次阅读 2007-08-02 16:16:00
    C++语言中,指针和数组密切相关.... //ip points to ia[0]如果希望使指针指向数组中的另一个元素,则可使用下标操作符给某个元素定位,然后用取地址操作符&获取该元素的存储地址:ip=&ia[4]; //ip points to l
  • Java String源码解析

    千次阅读 2016-05-30 10:14:31
    String类提供了操作字符序列中单个字符的方法,比如有比较字符串,搜索字符串等 Java语言提供了对字符串连接运算符的特别支持(+),该符号也可用于将其他类型转换成字符串。 字符串的连接实际上是通过StringBuffer...
  • c++ string头文件详解

    万次阅读 多人点赞 2018-11-15 12:44:02
    标准c++中string类函数介绍 注意不是CString 之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数...
  • Java基础>18>数组>>获取/访问数组元素

    千次阅读 2019-06-07 10:31:14
    仅供自己记录学习,无它用,欢迎指导! 获取数组元素 ... 访问数组元素的格式:数组名称[索引值] 索引值:就是一个int数字,代表数组当中元素的编号。 【注意】索引值从0开始,一直到"数组的长度-1...
  • 可以通过Element类提供的方法访问一个XML元素中含有的信息: Method Comment getQName() 元素的QName对象 getNam
  • 因为已经改变了集合的size,所以再去访问的时候就并发异常了 //使用普通for循环遍历,虽然不会并发异常,但是由于索引和size大小在移除的时候就会发生变化,所以容易数组越界 public void ...
  • C++ String

    千次阅读 2007-07-18 11:01:00
    之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。...
  • VC++ string用法

    千次阅读 2013-10-08 09:05:04
    推荐网站: http://www.cplusplus.com/reference/string/string/ ... 之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必担心内存是否足够、字符串长度等等,而且作
  • String 详解

    千次阅读 2006-12-09 13:32:00
    之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。...
  • C++ string 详解

    千次阅读 2012-03-27 13:35:44
    C++中针对C语言中处理字符串的难题,在标准库中设计了string类,因此现在编程中涉及到字符串的处理,就可以直接使用string类了。  之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较...
  • VC string 操作

    千次阅读 2012-08-30 10:11:11
    以下是详细: C++ String knowledge ...之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数
  • 获取单个元素是指获取数组中的一个元素,如第一个元素或最后一个元素。获取单个元素的方法非常简单,指定元素所在数组的下标即可。语法如下: array[index]; 其中,array 表示数组变量,index 表示下标,...
  • C++ string资料

    千次阅读 2012-09-06 09:04:19
    C++ string资料一 之所以抛弃char *的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下...
  • C++ string详解

    千次阅读 2014-08-15 21:21:59
    C++ string 详解 任何人对本文进行引用都要标明作者是Nicolai M.Josuttis /////////////////////////////////////////////////////////////////////////////////// C++ 语言是个十分优秀的语言,但优秀并不表示...
  • <string>头文件

    千次阅读 2012-07-21 13:38:52
    string构造函数 string s 生成一个空字符串s string s(str) 拷贝构造函数,生成str对象的复制品 string s(str,stridx) 将字符串str对象内"始于位置stridx"的部分当作字符串的初值 string s(str,stridx,strlen)...
  • C++的string学习总结

    千次阅读 2018-11-13 08:44:49
    2.string类常用接口总结a.string类对象的常见构造函数b.string类对象常用的容量操作c.string类对象的访问操作d.string类对象常见的修改操作 一.标准库的string类 1.string类是什么? string是表示字符串的字符...
  • STL,string

    千次阅读 2019-11-03 12:27:19
    在C语言中,一般使用字符数组char str[]来存放字符串,但是使用字符数组有时会显得操作麻烦,而且容易因经验不足而产生一些错误,为了使编程者可以更方便的对字符串进行操作,C++在STL中加入了string类型,对字符串...
  • C++string类常用函数 c++中的string常用函数用法总结

    万次阅读 多人点赞 2018-06-02 16:55:42
    string类的构造函数: string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 此外,string类还支持默认构造函数和复制构造函数,如string s1;string s2="hello";都是...
  • C++ string使用方法详细介绍

    万次阅读 2019-11-01 22:40:00
    C++ String类库介绍及常用示例 目录 介绍 string成员函数 成员函数用法示例 常用操作 为了防止学习的过程中,出现学后忘的情况,我将接触到的知识进行整理,作该笔记,由于本人水平有限,如果出现错误,还望赐正。...
  • C++中string详解

    千次阅读 2018-10-01 22:50:01
    之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必担心内存是否足够、字符串长度等等,而且作为一个泛型类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要...
  • c++ string 用法详解

    万次阅读 多人点赞 2018-11-13 08:50:27
    c++ string 用法详解
  • 基于JDK1.8的String详解

    千次阅读 2019-05-16 20:09:43
    String 类的定义 public final class String implements java.io.Serializable, Comparable<String>, CharSequence {} 这是一个用 final 声明的常量类,不能被任何类所继承,而且一旦一个String对象被创建, ...
  • C++STL标准模板库(一)——string

    千次阅读 2018-02-26 23:52:57
    String类 ...对字符串元素访问[],at() 插入字符 insert() 追加字符 append += 替换字符 replace() 提取字符串 substr() 删除字符串 erase() 比较函数 compare() 搜索函数 find() 搜索函数 rfind() 搜...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,218
精华内容 43,687
关键字:

访问string的单个元素