Obtention du premier caractère d'une chaîne avec $ str [0]

Je veux obtenir la première lettre d'une chaîne et j'ai remarqué que cela $str[0]fonctionne très bien. Je ne suis tout simplement pas sûr que ce soit une «bonne pratique», car cette notation est généralement utilisée avec les tableaux. Cette fonctionnalité ne semble pas être très bien documentée, donc je me tourne vers vous pour me dire si c'est correct - à tous égards - d'utiliser cette notation?

Ou devrais-je simplement m'en tenir au bon vieux substr($str, 0, 1)?

J'ai également noté que les accolades ( $str{0}) fonctionnent également. Qu'est-ce qui se passe avec ça?

Oui. Les chaînes peuvent être vues comme des tableaux de caractères, et la façon d'accéder à la position d'un tableau est d'utiliser l' []opérateur. Habituellement, il n'y a aucun problème à utiliser $str[0](et je suis sûr que c'est beaucoup plus rapide que la substr()méthode).

Il n'y a qu'une mise en garde avec les deux méthodes: elles obtiendront le premier octet , plutôt que le premier caractère . Ceci est important si vous utilisez des encodages multi-octets (tels que UTF-8). Si vous souhaitez soutenir cela, utilisez mb_substr(). On peut dire que vous devriez toujours supposer une entrée multi-octets de nos jours, c'est donc la meilleure option, mais ce sera légèrement plus lent.

La syntaxe {} est obsolète à partir de PHP 5.3.0. Les crochets sont recommandés.

Disons que vous voulez juste le premier caractère d'une partie de $ _POST, appelons-le 'type'. Et que $ _POST ['type'] est actuellement 'Control'. Si dans ce cas si vous utilisez $_POST['type'][0], ou substr($_POST['type'], 0, 1)vous Creviendrez.

Cependant, si le client devait modifier les données qu'il vous envoie, depuis type à type[]par exemple, puis envoyer «Control» et «Test» en tant que données pour ce tableau, $_POST['type'][0]retournera maintenant Controlplutôt Cquesubstr($_POST['type'], 0, 1) qu'il échouera simplement.

Alors oui, il peut y avoir un problème avec l'utilisation $str[0], mais cela dépend des circonstances environnantes.

Mon seul doute serait de savoir comment cette technique serait applicable sur des chaînes multi-octets, mais si ce n'est pas un facteur, je suppose que vous êtes couvert. (En cas de doute,mb_substr() semble un choix évidemment sûr.)

Cependant, d'un point de vue d'ensemble, je dois me demander à quelle fréquence vous devez accéder au caractère n 'dans une chaîne pour que cela soit une considération clé.

Cela variera en fonction des ressources, mais vous pouvez exécuter le script ci-dessous et voir par vous-même;)

<?php
$tests = 100000;

for ($i = 0; $i < $tests; $i++)
{
    $string = md5(rand());
    $position = rand(0, 31);

    $start1 = microtime(true);
    $char1 = $string[$position];
    $end1 = microtime(true);
    $time1[$i] = $end1 - $start1;

    $start2 = microtime(true);
    $char2 = substr($string, $position, 1);
    $end2 = microtime(true);
    $time2[$i] = $end2 - $start2;

    $start3 = microtime(true);
    $char3 = $string{$position};
    $end3 = microtime(true);
    $time3[$i] = $end3 - $start3;
}

$avg1 = array_sum($time1) / $tests;
echo 'the average float microtime using "array[]" is '. $avg1 . PHP_EOL;

$avg2 = array_sum($time2) / $tests;
echo 'the average float microtime using "substr()" is '. $avg2 . PHP_EOL;

$avg3 = array_sum($time3) / $tests;
echo 'the average float microtime using "array{}" is '. $avg3 . PHP_EOL;
?>

Quelques références (sur une ancienne machine CoreDuo)

$ php 1.php 
the average float microtime using "array[]" is 1.914701461792E-6
the average float microtime using "substr()" is 2.2536706924438E-6
the average float microtime using "array{}" is 1.821768283844E-6

$ php 1.php 
the average float microtime using "array[]" is 1.7251944541931E-6
the average float microtime using "substr()" is 2.0931363105774E-6
the average float microtime using "array{}" is 1.7225742340088E-6

$ php 1.php 
the average float microtime using "array[]" is 1.7293763160706E-6
the average float microtime using "substr()" is 2.1037721633911E-6
the average float microtime using "array{}" is 1.7249774932861E-6

Il semble que l'utilisation des opérateurs []ou {}soit plus ou moins la même chose.

Parlant comme un simple mortel, je resterais avec $str[0]. En ce qui me concerne, il est plus rapide de saisir le sens d' $str[0]un coup d'œil quesubstr($str, 0, 1) . Cela se résume probablement à une question de préférence.

En ce qui concerne les performances, eh bien, profil profil profil. :) Ou vous pouvez regarder le code source PHP ...

$str = 'abcdef';
echo $str[0];                 // a

Dans le cas de chaînes multi-octets (unicode), l'utilisation str[0]peut provoquer un problème. mb_substr()est une meilleure solution. Par exemple:

$first_char = mb_substr($title, 0, 1);

Quelques détails ici: Obtenez le premier caractère de la chaîne UTF-8

J'ai également utilisé cette notation auparavant, sans aucun effet secondaire et aucun malentendu. Cela a du sens - une chaîne n'est qu'un tableau de caractères, après tout.