- 
                
塑料小白
                
                
                0星
             
            - 
                
一指青铜
                
                
                100星
             
            - 
                
二指白银
                
                
                200星
             
            - 
                
十指黄金
                
                
                300星
             
            - 
                
流云蓝珀
                
                
                400星
             
            - 
                
幻影钻石
                
                
                500星
             
            - 
                
键影星耀
                
                
                800星
             
            - 
                
神速大师
                
                
                1000星
             
            - 
                
键舞王者
                
                
                200CPM
             
            - 
                
星河宗师
                
                
                400CPM
             
        
     
    
  
    
    
        闯关失败!💔
        你打错了太多字,再接再厉吧!
        
            
        
     
   
        
                
                
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        " 
                    
                                        
                        " 
                    
                                        
                        m 
                    
                                        
                        u 
                    
                                        
                        l 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                          
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        e 
                    
                                        
                        " 
                    
                                        
                        " 
                    
                                        
                        " 
                    
                                     
                
                
                多行字符串,用三引号创建跨多行字符串
             
                     
                
            
                        
                
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                     
                
                
                字符串拼接,用 + 连接两个字符串
             
                     
                
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        0 
                    
                                        
                        ] 
                    
                                     
                
                
                字符串正向索引,获取索引 0 的字符
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        - 
                    
                                        
                        2 
                    
                                        
                        ] 
                    
                                     
                
                
                字符串负向索引,获取倒数第 2 个字符
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        1 
                    
                                        
                        : 
                    
                                        
                        5 
                    
                                        
                        ] 
                    
                                     
                
                
                字符串切片,获取索引 1 到 4 的子串
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        : 
                    
                                        
                        3 
                    
                                        
                        ] 
                    
                                     
                
                
                字符串切片,从开头取到索引 2 的子串
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        3 
                    
                                        
                        : 
                    
                                        
                        ] 
                    
                                     
                
                
                字符串切片,从索引 3 取到结尾的子串
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        : 
                    
                                        
                        : 
                    
                                        
                        2 
                    
                                        
                        ] 
                    
                                     
                
                
                带步长切片,间隔 1 个字符取子串
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        : 
                    
                                        
                        : 
                    
                                        
                        - 
                    
                                        
                        1 
                    
                                        
                        ] 
                    
                                     
                
                
                反转字符串,用步长 - 1 切片反转
             
                     
                
            
                        
                
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        g 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                计算字符串长度,返回字符数量
             
                     
                
                
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        u 
                    
                                        
                        p 
                    
                                        
                        p 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                转大写,将字符串转换为全大写
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        w 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                转小写,将字符串转换为全小写
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                          
                    
                                        
                        w 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        l 
                    
                                        
                        d 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                标题化,每个单词首字母大写
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        z 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                首字母大写,仅第一个字符大写
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        s 
                    
                                        
                        w 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                大小写互换,大写转小写小写转大写
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        p 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                去除两端空白,删除字符串前后空格
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        p 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                去除左侧空白,删除字符串前空格
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        r 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        p 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                去除右侧空白,删除字符串后空格
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                        b 
                    
                                        
                        , 
                    
                                        
                        c 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        s 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                按分隔符分割,将字符串拆分为列表
             
                     
                
            
                        
                
                                        
                        " 
                    
                                        
                        - 
                    
                                        
                        " 
                    
                                        
                        . 
                    
                                        
                        j 
                    
                                        
                        o 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        " 
                    
                                        
                        x 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        y 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        z 
                    
                                        
                        " 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                连接列表元素,用字符串连接列表项
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        b 
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        a 
                    
                                        
                        c 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                字符串替换,替换指定子串
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        f 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                查找子串位置,返回首次出现的索引
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        b 
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        c 
                    
                                        
                        o 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                统计子串次数,计算子串出现次数
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        t 
                    
                                        
                        s 
                    
                                        
                        w 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                检查前缀,判断是否以子串开头
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        s 
                    
                                        
                        w 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                检查后缀,判断是否以子串结尾
             
                     
                
                
            
                        
                
                                        
                        " 
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        e 
                    
                                        
                        1 
                    
                                        
                        \ 
                    
                                        
                        n 
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        e 
                    
                                        
                        2 
                    
                                        
                        " 
                    
                                     
                
                
                包含换行符,\n 表示换行的字符串
             
                     
                
                
            
                        
                
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        c 
                    
                                        
                        e 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                          
                    
                                        
                        { 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        } 
                    
                                        
                        " 
                    
                                     
                
                
                f-string 格式化,插入变量值
             
                     
                
            
                        
                
                                        
                        " 
                    
                                        
                        { 
                    
                                        
                        } 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        { 
                    
                                        
                        } 
                    
                                        
                        " 
                    
                                        
                        . 
                    
                                        
                        f 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        m 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        d 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                format 方法,格式化字符串
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        1 
                    
                                        
                        2 
                    
                                        
                        3 
                    
                                        
                        4 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                        d 
                    
                                        
                        i 
                    
                                        
                        g 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                检查数字,判断是否全为数字字符
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        p 
                    
                                        
                        h 
                    
                                        
                        a 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                检查字母,判断是否全为字母字符
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        p 
                    
                                        
                        p 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                检查全大写,判断是否所有字符大写
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        w 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                检查全小写,判断是否所有字符小写
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                          
                    
                                        
                        w 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        l 
                    
                                        
                        d 
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                检查标题格式,判断是否标题化
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        . 
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                        s 
                    
                                        
                        p 
                    
                                        
                        a 
                    
                                        
                        c 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                检查空白,判断是否全为空白字符
             
                     
                
                
                
                
                
                
            
                        
                
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        . 
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        z 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                首字母大写函数,仅首字符大写
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        . 
                    
                                        
                        s 
                    
                                        
                        w 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                大小写互换函数,交换字符串大小写
             
                     
                
                
                
                
                
                
            
                        
                
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        . 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        a 
                    
                                        
                        c 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                替换函数,替换字符串中的子串
             
                     
                
                
                
                
            
                        
                
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        . 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        t 
                    
                                        
                        s 
                    
                                        
                        w 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                前缀检查函数,判断是否以子串开头
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        . 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        s 
                    
                                        
                        w 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                后缀检查函数,判断是否以子串结尾