Ottenere il primo carattere di una stringa con $ str [0]

Voglio ottenere la prima lettera di una stringa e ho notato che $str[0]funziona alla grande. Non sono sicuro che si tratti di una "buona pratica", poiché tale notazione viene generalmente utilizzata con le matrici. Questa funzione non sembra essere ben documentata, quindi mi rivolgo a voi ragazzi per dirmi se va bene, sotto tutti gli aspetti, usare questa notazione?

O dovrei semplicemente attenermi al buon vecchio substr($str, 0, 1)?

Inoltre, ho notato che anche le parentesi graffe ( $str{0}) funzionano. Cosa succede con quello?

Sì. Le stringhe possono essere viste come array di caratteri e il modo per accedere a una posizione di un array è utilizzare l' []operatore. Di solito non c'è alcun problema nell'uso $str[0](e sono abbastanza sicuro che sia molto più veloce del substr()metodo).

C'è solo un avvertimento con entrambi i metodi: otterranno il primo byte , anziché il primo carattere . Ciò è importante se si utilizzano codifiche multibyte (come UTF-8). Se vuoi supportarlo, usa mb_substr(). Probabilmente, dovresti sempre assumere input multibyte in questi giorni, quindi questa è l' opzione migliore , ma sarà leggermente più lenta.

La sintassi {} è obsoleta a partire da PHP 5.3.0. Si raccomandano parentesi quadre.

Diciamo che vuoi solo il primo carattere da una parte di $ _POST, chiamiamolo 'tipo'. E che $ _POST ['type'] è attualmente 'Control'. Se in questo caso, se si utilizza $_POST['type'][0], o substr($_POST['type'], 0, 1)si otterrà Cindietro.

Tuttavia, se il lato client dovesse modificare i dati che viene inviato, da typea type[]per esempio, e quindi inviare 'Control' e 'Test', come i dati relativi a questa matrice, $_POST['type'][0]sarà ora tornare Controlpiuttosto che Cmentre substr($_POST['type'], 0, 1)si limiterà semplicemente fallire.

Quindi sì, potrebbe esserci un problema con l'utilizzo $str[0], ma ciò dipende dalle circostanze circostanti.

Il mio unico dubbio sarebbe quanto applicabile sarebbe questa tecnica su stringhe multi-byte, ma se questa non è una considerazione, allora sospetto che tu sia coperto. (In caso di dubbio, mb_substr()sembra una scelta ovviamente sicura.)

Tuttavia, dal punto di vista generale, devo chiedermi quanto spesso è necessario accedere all'ennesimo carattere in una stringa perché questa sia una considerazione chiave.

Varia in base alle risorse, ma potresti eseguire lo script sotto e vedere di persona;)

<?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;
?>

Alcuni numeri di riferimento (su una vecchia macchina 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

Sembra che l'uso degli operatori []o {}sia più o meno lo stesso.

Parlando come un semplice mortale, mi atterrei $str[0]. Per quanto mi riguarda, è più veloce cogliere il significato $str[0]a colpo d'occhio che substr($str, 0, 1). Questo probabilmente si riduce a una questione di preferenza.

Per quanto riguarda le prestazioni, beh, profilo profilo profilo. :) Oppure potresti scrutare il codice sorgente di PHP ...

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

In caso di stringhe multibyte (unicode) l'uso str[0]può causare problemi. mb_substr()è una soluzione migliore. Per esempio:

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

Alcuni dettagli qui: ottieni il primo carattere della stringa UTF-8

Ho usato anche quella notazione prima, senza effetti collaterali negativi e incomprensioni. Ha senso: una stringa è solo una matrice di caratteri, dopo tutto.