Comment vérifier si une chaîne commence par "GET" ou "POST" dans c?

Question

Portez attention à l'espace qu'il contient.

Quelle fonction puis-je utiliser?

Answer 1

Vous pouvez utiliser

if (!strncmp("GET ", str, 4) 
{ 
    ... 
} 
else if (!strncmp("POST ", str, 5)) 
{ 
    ... 
} 
else 
{ 
    ... 
} 

Answer 2

Utilisation strncmp avec des paramètres chaîne1, chaîne2, n où string1 et string2 sont les chaînes à comparer et n le nombre de caractères. strncmp renvoie 0 si les chaînes correspondent ou < 0 si string1 est lexicographiquement plus petit que string2 ou> 0 si string2 est plus petit que string1. Exemples:

#include <string.h> 
... 
strncmp(somestring, "GET ", 4) == 0 
strncmp(somestring, "POST ", 5) == 0 

Answer 3

#include <stdio.h> 
#include <string.h> 

typedef enum httpmethod 
{ 
    HTTP_ERR, 
    HTTP_GET, 
    HTTP_POST, 
    HTTP_METHOD_COUNT 

} httpmethod; 

const char* http_method_str[HTTP_METHOD_COUNT + 1] = 
{ 
    "UNKNOWN", 
    "GET ", 
    "POST ", 
    0 
}; 


httpmethod str_get_http_method(const char* str) 
{ 
    if (!str || strlen(str) < 4) 
     return HTTP_ERR; 

    const char* ptr[HTTP_METHOD_COUNT]; 
    int i; 
    int failcount = 0; 

    for (i = 1; i < HTTP_METHOD_COUNT; ++i) 
     ptr[i] = http_method_str[i]; 

    while (*str != '\0' && failcount < HTTP_METHOD_COUNT - 1) 
    { 
     for (i = 1; i < HTTP_METHOD_COUNT; ++i) 
     { 
      if (ptr[i] && *str != *ptr[i]++) 
      { 
       ptr[i] = 0; 
       ++failcount; 
      } 
     } 
     str++; 
    } 

    for (i = 1; i < HTTP_METHOD_COUNT; ++i) 
     if (ptr[i]) 
      return i; 

    return HTTP_ERR; 
} 


int main(int argc, char** argv) 
{ 
    const char* test[4] = { "GET ", "POST ", "GIT ", "PAST " }; 

    httpmethod result = HTTP_ERR; 

    int i; 

    for (i = 0; i < 4; ++i) 
    { 
     printf("checking str: %s\n", test[i]); 
     result = str_get_http_method(test[i]); 
     printf("result is type: %s\n", http_method_str[result]); 
    } 

    return 0; 
} 

Answer 4

Vous ne avez à utiliser strncmp() lorsque vous avez seulement besoin de faire la différence entre quelques cordes:

#include <stdio.h> 
#include <stdint.h> 
#include <string.h> 

static uint32_t method_hash(const char *key) 
{ 
     int len; 
     uint32_t hash; 
     int i; 

     len = strlen(key); 
     for (hash = 0, i = 0; i < len; i++) { 
       hash += (unsigned int) key[i]; 
       hash += (hash << 10); 
       hash ^= (hash >> 6); 
     } 
     hash += (hash << 3); 
     hash ^= (hash >> 11); 
     hash += (hash << 15); 
     return hash; 
} 

int main(int argc, char *argv[]) 
{ 
    if (argc < 2) { 
     printf("Usage: %s <method>\n", argv[0]); 
     return 0; 
    } 

    switch(method_hash(argv[1])) { 
    case 802187597: 
     printf("Its GET\n"); 
     break; 
    case 740659500: 
     printf("Its POST\n"); 
     break; 
    default: 
     printf("Its RUBBISH\n"); 
     return 1; 
    } 

    return 0; 
} 

noter juste, le hachage est pas une preuve de collision, mais convient de connaître la différence entre GET et POST. J'utilise très souvent ce petit bijou dans les dictionnaires, en appelant seulement strncmp() quand je pense J'ai une correspondance.

Je souhaite publier cette réponse à vous dire, il y a plusieurs façons de traiter avec des cordes, dans l'espoir que vous évitez le code qui ressemble à ceci que vous continuez à apprendre C:

if (! strncmp(string, "FOO ", 4)) { 
    do_this(); 
} else if (! strncmp(string, "BAR ", 4)) { 
    do_that(); 
} else if (! strncmp(string, "FOOBAR ", 7)) { 
    do_both(); 
/* ... madness ensues through 200 more lines and 100 more else if's ... */ 
} else { 
    return 0; 
} 

Mon exemple est pas exactement correct. Vous souhaitez que les valeurs de hachage soient déterminées au moment de l'exécution plutôt que de simplement insérer les valeurs connues si vous souhaitez que le code soit portable. C'est un exercice pour le lecteur (indice, les cas de commutation veulent des constantes).