[PHP] '0123' hetzelfde als '123' ?

[Yohost!]

PHP:

<?
 $var_a = '123';
 $var_b = '0123';
 
 if ($var_a == $var_b) echo 'gelijk'; else echo 'ongelijk';
?>

Hier print hij dus gewoon 'gelijk' op het scherm.

Gebruik ik === ipv == dan krijg ik wel 'ongelijk'

Doet php bij een vergelijking een soort type conversion?

[SchizoDuckie]

PHP is loosely typed. Hij zal dus zelf een inschatting maken van wat jij in een variabele propt, of het nou een array, integer, double of string is.

Hij zal dit dus waarschijnlijk beschouwen als een integer, en het omzetten naar een 'nette' integer, waardoor er 123 komt uit je var_b (immers, type maar eens 0123 + 1 in op je rekenmachine).

met === wordt de strict check aangezet, waardoor hij gewoon gaat checken of de 2 strings ook qua type met elkaar overeen komen, en dan zal er dus geen conversieslag naar integer gebeuren.

in het kort is je antwoord dus ja

[ Voor 6% gewijzigd door SchizoDuckie op 20-12-2006 12:01 ]

[mcdronkz]

Wat ik overigens wel typisch vind is dat 'ie met de volgende code alsnog "gelijk" output:

PHP:

<?php
 $var_a = strval('123');
 $var_b = strval('0123');
 
 if ($var_a == $var_b) echo 'gelijk'; else echo 'ongelijk';
?>

Zo is 'ie wel ongelijk:

PHP:

<?php
 $var_a = strval('hoi 123');
 $var_b = strval('hoi 0123');
 
 if ($var_a == $var_b) echo 'gelijk'; else echo 'ongelijk';
?>

[ Voor 27% gewijzigd door mcdronkz op 20-12-2006 12:12 ]

[frickY]

Omdat je loose-typed evalueert, maakt het niet uit hoe de variabele is gedefiieerd.

In de if lijkt de variabele een integer te zijn, dus kan de voorlop nul weg, dus zijn ze gelijk.

[ Voor 37% gewijzigd door frickY op 20-12-2006 12:14 ]

[Jaap-Jan]

mcdronkz schreef op woensdag 20 december 2006 @ 12:08:

Zo typisch is dat niet hoor, PHP's gedrag bij de == vergelijking is gewoon gedocumenteerd: http://www.php.net/manual/en/types.comparisons.php

En dat hij in het tweede geval wel gelijk is omdat het dan twee strings zijn (de strings zijn niet te casten naar een integer)

[daft_dutch]

dus als je wilt dat het een string moet zijn moet je er letters of tekens (\n) in donderen

[hamsteg]

daft_dutch schreef op woensdag 20 december 2006 @ 12:22:
dus als je wilt dat het een string moet zijn moet je er letters of tekens (\n) in donderen

De voilgende constructies, hoe lelijk ook, zie je regelmatig als men moet wisselen tussen strings en getallen en zekerheid wil hebben over het type dat wordt gebruikt door PHP:

PHP:

$iGetal= 100;
$sString = "".$iGetal;
$sGetal= '100';
$sString = "".$sGetal;

[ Voor 6% gewijzigd door hamsteg op 20-12-2006 12:30 ]

[SchizoDuckie]

daft_dutch schreef op woensdag 20 december 2006 @ 12:22:
dus als je wilt dat het een string moet zijn moet je er letters of tekens (\n) in donderen

neej, je moet gewoon de juiste evaluators (===) gebruiken voor je checks of een check doen of iets echt een INT is

zo heb je ook dit trucje:

PHP:

$blaat = 0;
$mekker = false; 

echo ($blaat == $mekker) ? "blaat eq mekker" : "blaat neq mekker"; // false is eigenlijk stiekum 0
echo "<br>";
echo ($blaat === $mekker) ? "blaat eq mekker" : "blaat neq mekker"; // false != zelfde type als 0

[ Voor 31% gewijzigd door SchizoDuckie op 20-12-2006 12:40 ]

[.oisyn]

Deze is ook leuk

PHP:

$a = 0;
$b = "aap";

if ($a == $b)
    echo "PHP sucks";

[.oisyn]

SchizoDuckie schreef op woensdag 20 december 2006 @ 12:32:
zo heb je ook dit trucje:

Euh, false is 0 hoor

[SchizoDuckie]

.oisyn schreef op woensdag 20 december 2006 @ 12:36:
[...]

Euh, false is 0 hoor

heh wuh wah?
_{sorry niet echt wakker nog vandaag}

[Spockz]

.oisyn schreef op woensdag 20 december 2006 @ 12:36:
[...]

Euh, false is 0 hoor

True, maar sommige functies returnen -1 als ze false bedoelen.

[.oisyn]

Je bedoelt als ze een error bedoelen. False is niet per se een error natuurlijk

[Yohost!]

Nu heb ik dus het volgende case statement

PHP:

  switch ($veld) {
    case '123': $result = 'eentweedrie'; break;
    case '456': $result = 'viervijfzes'; break;
  }

Echter als $veld de waarde '0123' heeft krijgt $result de waarde 'eentweedrie'
Hoe kan ik dit nu het beste oplossen?

[Janoz]

Wat raar weer trouwens. '123' en '0123' zijn gelijk aan elkaar omdat php het wel even denkt te casten naar integers, maar 123 en 0123 zijn weer ongelijk (aangezien de tweede als octaal wordt geinterpreteerd)

[Janoz]

Yohost! schreef op woensdag 20 december 2006 @ 12:46:
Nu heb ik dus het volgende case statement

PHP:

  switch ($veld) {
    case '123': $result = 'eentweedrie'; break;
    case '456': $result = 'viervijfzes'; break;
  }

Echter als $veld de waarde '0123' heeft krijgt $result de waarde 'eentweedrie'
Hoe kan ik dit nu het beste oplossen?

Ikzelf zit te denken aan:

PHP:

  switch ('pauper php'.$veld) {
    case 'pauper php123': $result = 'eentweedrie'; break;
    case 'pauper php456': $result = 'viervijfzes'; break;
  }

[Wolfboy]

Bij php moet je gewoon === gebruiken als je zeker wilt zijn dat het goed vergeleken wordt, en hoe dat in een switch moet?.. tja.. niet?

[Anoniem: 27510]

Yohost! schreef op woensdag 20 december 2006 @ 12:46:
Nu heb ik dus het volgende case statement

PHP:

  switch ($veld) {
    case '123': $result = 'eentweedrie'; break;
    case '456': $result = 'viervijfzes'; break;
  }

Echter als $veld de waarde '0123' heeft krijgt $result de waarde 'eentweedrie'
Hoe kan ik dit nu het beste oplossen?

Misschien zoiets of bedoel je dat niet?

PHP:

switch(true)
{
case ($veld==="123"):
/*do iets*/
break;

case ($veld==="456"):
/*do iets*/
break;
}

[Patriot]

Dit werkt ook:

PHP:

<?php

$veld = '0123';

switch($veld) {
    
    case $veld === '123':
        echo "Pils";
        break;
        
    case $veld === '456':
        echo "Geen pils :/";
        break;
    
    default:
        echo "Wat dan?";
        break;
        
}

?>

EDIT: Grrrrrr

[ Voor 4% gewijzigd door Patriot op 20-12-2006 12:56 ]

[Yohost!]

Janoz schreef op woensdag 20 december 2006 @ 12:49:
[...]


Ikzelf zit te denken aan:

PHP:

  switch ('pauper php'.$veld) {
    case 'pauper php123': $result = 'eentweedrie'; break;
    case 'pauper php456': $result = 'viervijfzes'; break;
  }

Daar zat ik stiekem ook aan te denken maar daar wil ik eigenlijk niet aan denken omdat het wel heel idioot is

[Anoniem: 27510]

Huh das wel heel lelijk..waarom niet 3 = jes?

[SchizoDuckie]

hmm dit is best wel enigzins ruk ja.. de oplossing is inderdaad waarschijnlijk om een string te padden voor de string die je wil switchen. Zelfs casten met (string) of setType($val, "string") werkt niet namelijk (php 5.1.4)

PHP:

<?php
$veld = (string)'0123';
settype(&$veld, 'string'); // just for testcase

switch ($veld) 
{
    case '123': $result = 'eentweedrie'; break;
    case '456': $result = 'viervijfzes'; break;
    default: $result = "blaat"; break;
}

echo $result; // eentweedrie


switch (' '.$veld) 
{
    case ' 123': $result = 'eentweedrie'; break;
    case ' 456': $result = 'viervijfzes'; break;
    default: $result = "blaat"; break;
}

echo $result; // eentweedrie


switch ((string)$veld) 
{
    case (string)'123': $result = 'eentweedrie'; break;
    case (string)'456': $result = 'viervijfzes'; break;
    default: $result = "blaat"; break;
}

echo $result; // eentweedrie

switch ('_'.$veld) 
{
    case '_123': $result = 'eentweedrie'; break;
    case '_456': $result = 'viervijfzes'; break;
    default: $result = "blaat"; break;
}


 echo $result;  // blaat

?>

[ Voor 10% gewijzigd door SchizoDuckie op 20-12-2006 13:04 ]

[Patriot]

En toch is de oplossing van mij en Vorlox nog het netst

[SchizoDuckie]

Patriot schreef op woensdag 20 december 2006 @ 13:01:
En toch is de oplossing van mij en Vorlox nog het netst

Als je een if/else constructie wil gebruiken ja, ik vind switch statements eerlijk gezegd wel prettig werken als je meer dan 2 mogelijke waardes hebt...

Is dit iets om te submitten naar de PHP bugtracker?

[ Voor 5% gewijzigd door SchizoDuckie op 20-12-2006 13:03 ]

[Yohost!]

Patriot schreef op woensdag 20 december 2006 @ 13:01:
En toch is de oplossing van mij en Vorlox nog het netst

Inderdaad!
Dat gaat hem worden

* Yohost! gaat vanaf nu wel meer === gebruiken!!

[ Voor 48% gewijzigd door Yohost! op 20-12-2006 13:06 ]

[hamsteg]

De vraag is eerst of het een bug is ... het type is gewoon loosly coupled. Gebruik gewoon de juiste checks '==='. String compare zou dit toch ook goed moeten doen ?

[Patriot]

SchizoDuckie, dat van ons is gewoon een switch hoor, en je kunt gewoon zelf nieuwe waardes toevoegen.

[SchizoDuckie]

Patriot schreef op woensdag 20 december 2006 @ 13:06:
SchizoDuckie, dat van ons is gewoon een switch hoor, en je kunt gewoon zelf nieuwe waardes toevoegen.

oh sorry ik had er even omheen gelezen excuus.

Eigenlijk vind ik dat geen switch, maar meer een soort vern***te if/else constructie die de logica van je code niet echt ten goede komt.

hamsteg schreef op woensdag 20 december 2006 @ 13:06:
De vraag is eerst of het een bug is ... het type is gewoon loosly coupled. Gebruik gewoon de juiste checks '==='. String compare zou dit toch ook goed moeten doen ?

De gein is dat casten met (string) dit ook zou moeten kunnen voorkomen imo...

[ Voor 30% gewijzigd door SchizoDuckie op 20-12-2006 13:09 ]

[hamsteg]

edit:
dacht dat de vorig post verdwenen was maar er waren zoveel posts

[ Voor 66% gewijzigd door hamsteg op 20-12-2006 13:12 ]

[mcdronkz]

hamsteg schreef op woensdag 20 december 2006 @ 13:08:
String compare zou dit alles toch goed moeten doen? Maar goed het is een loosely type dus '===' is zo-wie-zo beter.

Dat zei je net ook al .

[hamsteg]

SchizoDuckie schreef op woensdag 20 december 2006 @ 13:08:
Eigenlijk vind ik dat geen switch, maar meer een soort vern***te if/else constructie die de logica van je code niet echt ten goede komt.

Bij compileer programmeertalen is een switch vaak een beter oplossing omdat men dan in arrays dingen kan verwerken en vaak deze verwerking kwa processing efficienter is. PHP is echter een script taal en daar weet ik niet van of de if/else of switch beter is.

[Patriot]

SchizoDuckie schreef op woensdag 20 december 2006 @ 13:08:
[...]


oh sorry ik had er even omheen gelezen excuus.

Eigenlijk vind ik dat geen switch, maar meer een soort vern***te if/else constructie die de logica van je code niet echt ten goede komt.
[...]

De gein is dat casten met (string) dit ook zou moeten kunnen voorkomen imo...

Een switch is in feite zelf niets meer dan een 'verneukte' if/else constructie.

Casten met (string) gaat niet werken, omdat PHP het verschil niet ziet tussen een int gecast met (string) en een string met alleen cijfers.

[SchizoDuckie]

hamsteg schreef op woensdag 20 december 2006 @ 13:10:
[...]

Bij compileer programmeertalen is een switch vaak een beter oplossing omdat men dan in arrays dingen kan verwerken en vaak deze verwerking kwa processing efficienter is. PHP is echter een script taal en daar weet ik niet van of de if/else of switch beter is.

Het verschil tussen een switch en een if/else was volgens mij ook dat je met een switch al meerdere voorgedefineeerde uitkomsten matched, en met een if/else een statement uitvoert en a.d.h.v. de uitkomst daarvan iets doet. Deze 'hack' met switch (true) en case ($blaat === '0123') verbouwt dus volgens mij je switch naar 1 grote if/else constructie, maar da's een verhaal wat eigenlijk even buiten dit topic hoort.

[Jaap-Jan]

SchizoDuckie schreef op woensdag 20 december 2006 @ 13:08:
[...]


oh sorry ik had er even omheen gelezen excuus.

Eigenlijk vind ik dat geen switch, maar meer een soort vern***te if/else constructie die de logica van je code niet echt ten goede komt.

Bovendien doe je dan twee checks, in de switch wordt namelijk $veld == '123' gedaan en zelf doe je nog eens de check $veld === '123'.

Oftewel, je doet iets als dit: ($veld == '123' & $veld === '123').

IMHO kun je dan beter kiezen voor een reeks if- else.

[ Voor 5% gewijzigd door Jaap-Jan op 20-12-2006 13:19 ]

[mcdronkz]

Dit geeft overigens wel "ongelijk":

PHP:

<?php
 $var_a = 123;
 $var_b = 0123;
 
 if ($var_a == $var_b) echo 'gelijk'; else echo 'ongelijk';
?>

Want IMHO horen getallen niet tussen haakjes ?

[Voutloos]

Janoz schreef op woensdag 20 december 2006 @ 12:47:
Wat raar weer trouwens. '123' en '0123' zijn gelijk aan elkaar omdat php het wel even denkt te casten naar integers, maar 123 en 0123 zijn weer ongelijk (aangezien de tweede als octaal wordt geinterpreteerd)

De feature is dat je zo een getal octaal in je code kan opschrijven. De feature is niet dat PHP alles dat met een 0 begint maar octaal moet vergelijken. Het resultaat van $a = 0123; is gewoon een int en het talstelsel dat gebruikt is voor de assignment is later niet meer belangrijk.

mcdronkz schreef op woensdag 20 december 2006 @ 13:16:
Dit geeft overigens wel "ongelijk":

8< decimale vs octale definitie van vars 8<

Want IMHO horen getallen niet tussen haakjes ?

Je hebt gelijk, maar soms heb je nou eenmaal wel gewoon de strings '123' en '0123'.
en je bedoelt quotes ipv haakjes.

[ Voor 23% gewijzigd door Voutloos op 20-12-2006 13:23 ]

[Yohost!]

Dan zou ik dit het netst kunnen oplossen met een if....elseif contrctie zodat ik ook geen 'vreemde' switch statements krijg.

[ID-College]

Een switch is leuk maar vaak omslachtig.
Heb je bij PHP niet zoiets als bij java?:

code:

string1.equals(string2);

In java doe je bij strings ook geen string1 == string2

[Jaap-Jan]

ID-College schreef op woensdag 20 december 2006 @ 13:26:
Een switch is leuk maar vaak omslachtig.
Heb je bij PHP niet zoiets als bij java?:

code:

string1.equals(string2);

In java doe je bij strings ook geen string1 == string2

Nee, maar dat komt omdat in java de '==' operator adressen vergelijkt als het objecten zijn. Op primitieven checkt het de value.

Equals gebruikt onder water ook '==', want als de adressen gelijk zijn, zijn de waardes dat ook. Daarna zal equals (nadat gecheckt is of het opgegeven Object wel een String is) waarschijnlijk elk karakter van beide strings nalopen om te kijken of ze gelijk zijn. Aangezien dat tijdrovender is dan het vergelijken van een tweetal adressen wordt dat eerst gedaan.

In PHP wordt met de '==' operator altijd de waarde vergeleken en is het in feite een soort equals.

[ Voor 9% gewijzigd door Jaap-Jan op 20-12-2006 13:39 ]

[Grijze Vos]

In de meeste talen kun je uberhaupt niet een switch/case statement gebruiken op strings.

Maargoed, waarom niet gewoon strcmp gebruiken? Ben je van al dat gezeik af.

[ Voor 44% gewijzigd door Grijze Vos op 20-12-2006 13:45 ]

[SchizoDuckie]

Grijze Vos schreef op woensdag 20 december 2006 @ 13:43:
In de meeste talen kun je uberhaupt niet een switch/case statement gebruiken op strings.

Maargoed, waarom niet gewoon strcmp gebruiken? Ben je van al dat gezeik af.

Daar gaat het niet om in deze discussie

[hamsteg]

SchizoDuckie schreef op woensdag 20 december 2006 @ 13:52:
Daar gaat het niet om in deze discussie

Jawel, daar gaat het wel om. PHP is een loosely type taal. Als je dan iets strict wilt gebruiken zul je gebruik moeten maken van strict functionaliteiten. De '===' en de 'strcmp' zijn beiden strict oplossingen.
[edit]Als programmeur moet je wel je taal, zijn kracht en zijn beperkingen kennen. Netjes programmeren is een vak.

[ Voor 13% gewijzigd door hamsteg op 20-12-2006 13:59 ]

[SchizoDuckie]

Nou vooruit, het gaat er wel én niet om.

Zoals je gezien hebt in mijn voorbeeld staat er ook een stukje met explicite casts naar (string). Dat daarna deze explicite cast vervolgens genegeerd wordt is imo een bug.

[NMe]

SchizoDuckie schreef op woensdag 20 december 2006 @ 13:52:
[...]

Daar gaat het niet om in deze discussie

Het is wel de meest duidelijke workaround.

Ik zou graag zien dat PHP ooit nog eens van die loose types afstapt. Of voor mijn part blijven ze ze ondersteunen in een non-strict omgeving. Ik heb het idee dat er teveel mensen met PHP bezig gaan zonder te weten wat ze doen, puur en alleen omdat het zo makkelijk is om met variabelen te goochelen. Om vervolgens tegen dit soort problemen aan te lopen.

[.oisyn]

Voutloos schreef op woensdag 20 december 2006 @ 13:16:
en het talstelsel dat gebruikt is voor de assignment is later niet meer belangrijk.

Een talstelsel wordt niet gebruikt voor de assignment. Het gaat om de representatie van een bepaald getal, waarbij je met een 0 aangeeft dat het octaal is. De lexical analyser zet dit om naar echt getal (de CPU werkt met binaire representaties, dus in feite wordt het altijd omgezet naar een binaire representatie), en de assignment werkt vervolgens op dat getal, niet op de representatie van dat getal

Als PHP dezelfde representaties toepast in strings als in de taal zelf dan leg je de eindgebruiker vage regels op, wat natuurlijk niet echt gewenst is

[SchizoDuckie]

-NMe- schreef op woensdag 20 december 2006 @ 13:59:
[...]

Het is wel de meest duidelijke workaround.

Ik zou graag zien dat PHP ooit nog eens van die loose types afstapt. Of voor mijn part blijven ze ze ondersteunen in een non-strict omgeving. Ik heb het idee dat er teveel mensen met PHP bezig gaan zonder te weten wat ze doen, puur en alleen omdat het zo makkelijk is om met variabelen te goochelen. Om vervolgens tegen dit soort problemen aan te lopen.

Volgens mij zijn ze er vanaf als ze gewoon het expliciet casten naar een bepaald type *netjes* gaan implementen.

Ik ben ff een testcase aan het samenstellen om te submitten naar de bugtracker, want voor de toekomst van PHP is dit wel iets waar gewoon duidelijkheid over moet zijn.

[hamsteg]

-NMe- schreef op woensdag 20 december 2006 @ 13:59:
[...]
Ik zou graag zien dat PHP ooit nog eens van die loose types afstapt. Of voor mijn part blijven ze ze ondersteunen in een non-strict omgeving.

100% mee eens, maar het succes van PHP is deels te wijten aan het feit dat men als beginnend PHP programmeur niet druk hoeft te maken om strict dingen en daardoor een relatief lage instap heeft. Een optie om PHP strict te maken (dus niet default) krijgt mijn support!

[aex351]

Janoz schreef op woensdag 20 december 2006 @ 12:47:
Wat raar weer trouwens. '123' en '0123' zijn gelijk aan elkaar omdat php het wel even denkt te casten naar integers, maar 123 en 0123 zijn weer ongelijk (aangezien de tweede als octaal wordt geinterpreteerd)

PHP heeft volgens mij geen aparte type octaal. Wel integer en dus valt een octaal daar ook onder.

[Janoz]

Het eerste dat ze bij php moeten doen is juist dat soort optie geneuzel eruit werken. Hoogst irritant is het dat je een applicatie kunt schrijven die voor de werking compleet afhankelijk is van de instellingen van de server. Met dingen als safe_mode valt dat nog wel mee, dan werken sommige dingen gewoon niet. Dat is nog een redelijk valide optie, maar register globals of magic quotes zorgt gewoon dat je script anders werkt.

Nee, voordat ze strict typing toe gaan passen kunnen ze beter naar andere items kijken. Fatsoenlijke OO (Waarom wordt de constructor van de superclass niet aangeroepen), wat meer en vooral fatsoenlijke (niet lekkende) scopes, maar vooral nieuwe dingen eerst eens goed overdenken en uitzoeken en dan pas implementeren ipv iets erin hacken om vervolgens 3 versies nodig te hebben om alle rariteiten eruit te moeten halen (Of te laten zitten onder het mom 'by design')

[Janoz]

aex351 schreef op woensdag 20 december 2006 @ 14:15:
[...]

PHP heeft volgens mij geen aparte type octaal. Wel integer en dus valt een octaal daar ook onder.

Octaal, decimaal of hexadecimaal heeft helemaal niks met het type te maken, maar meer met de representatie tijdens opslag inlezen en afdrukken. Integers worden gewoon binair opgeslagen.

[SchizoDuckie]

Ik heb het even gesubmit als bug. Nu hopen dat het doordringt tot de stubborn-zend/php programmeurs...

edit:

goed... dit is dus expected behavior volgens degene die het gelijk naar bogus veranderd heeft :x

[ Voor 28% gewijzigd door SchizoDuckie op 20-12-2006 14:23 ]

[Jaap-Jan]

aex351 schreef op woensdag 20 december 2006 @ 14:15:
[...]

PHP heeft volgens mij geen aparte type octaal. Wel integer en dus valt een octaal daar ook onder.

Je hebt ook geen aparte types voor een getalweergave Een getal kan weergegeven worden als binair, octaal, decimaal, hexadecimaal, een character en noem maar op.

Al die dingen worden in de computer toch gerepresenteerd als een binair getal. Shorts, chars, ints en longs geven alleen maar de hoeveelheid bits voor het opslaan van een getal.

SchizoDuckie schreef op woensdag 20 december 2006 @ 14:20:
Ik heb het even gesubmit als bug. Nu hopen dat het doordringt tot de stubborn-zend/php programmeurs...

Nee dus, het is 'expected behavior' .

[ Voor 21% gewijzigd door Jaap-Jan op 20-12-2006 14:23 ]

[hamsteg]

SchizoDuckie schreef op woensdag 20 december 2006 @ 14:20:
Ik heb het even gesubmit als bug. Nu hopen dat het doordringt tot de stubborn-zend/php programmeurs...

Commentaar is reeds aanwezig:

switch() construct uses "==" semantics to compare values, which compares
numeric strings as numbers:
var_dump("0123"=="123"); => true

If you want to compare numeric strings as strings, use "===":
var_dump("0123"==="123"); => false.

This is expected behaviour.

[Janoz]

Ah, dus toch 'by design'....

En nog steeds mensen die het vreemd vinden dat die persoon verantwoordelijk voor security weggelopen is....

[SchizoDuckie]

Ik heb weer even gereageerd... Ik ben nog steeds van mening dat een explicite cast de switch naar === mode zou moeten schoppen

[ACM]

Nog even hierover:

SchizoDuckie schreef op woensdag 20 december 2006 @ 12:01:
PHP is loosely typed. Hij zal dus zelf een inschatting maken van wat jij in een variabele propt, of het nou een array, integer, double of string is.

Zolang er geen sprake is van verschillende typen aan weerszijden van een operator is het niet relevant dat je waarde lijkt op een waarde van een ander type. Er hoeft geen conversie van typen plaats te vinden (en het mag imho ook niet) omdat je gewoon werkt met strings en dus moet er ook gewoon een string-comparison plaatsvinden, geen cast naar ints en die vergelijken...
Ik zou het dus een bug noemen, niet 'logisch want het is loose typed'. Het zijn tenslotte dezelfde typen en dan hoort de vergelijking op basis van de standaard comparator binnen die typen te gebeuren, imho dan... === voegt alleen toe dat je eerst checked dat je dezelfde typen hebt en dan daarbinnen dezelfde waarden.

Dus 1 == '1' = true maar 1 === '1' = false

"a" = "0a" is false, om welke reden zou dan precies de string '123' gelijk moeten zijn aan de string '0123' ? En waarom geldt dat dan weer niet voor '123 bar' vs '0123 bar' ? En waarom is '000000000123' gelijk aan '123' ?

Magoed, blijkbaar zijn ze het bij php niet eens dat het een bug is. Imho zou iemand die bovenstaand gedrag per se wil hebben gewoon ltrim($var, '0') moeten doen... maarja.

[SchizoDuckie]

ACM schreef op woensdag 20 december 2006 @ 14:30:
Nog even hierover:

[duidelijk verhaal]

Zoals jij het daar beschrijft: 100% mee eens. Maar het punt blijft dat veel PHP ontwikkelaars al 'gewend' zijn aan deze manier van werken en dat is op zich geen probleem, zolang je maar met een expliciete cast het gedrag dat jij hierboven beschrijft (en wat ik dus ook verderop bedoel in mijn switch-verhaal en in m'n bugreport) het verwachte resultaat krijgt en niet alsnog het 'php-zoekt-zelf-wel-even-uit-wat-jij-bedoelt-resultaat'. Dan is iedereen blij
Vandaar dat ik ook zo blij was met het casten met data types omdat dat dit soort problemen voorkomt, maar als dit in de rest van de taal gewoon genegeerd wordt kan je het net zo goed er weer uit slopen

[ Voor 42% gewijzigd door SchizoDuckie op 20-12-2006 14:42 ]

[SchizoDuckie]

ID: 39901
Updated by: [e-mail]
Reported By: schizoduckie at gmail dot com
-Status: Open
+Status: Bogus
Bug Type: Variables related
Operating System: Win32/XP
PHP Version: 5CVS-2006-12-20 (snap)
New Comment:

It does not matter whether you cast the variables or not, switch()
always uses semantics similar to "==".
Again, there is nothing wrong and we're not going to change it.


Previous Comments:
------------------------------------------------------------------------

[2006-12-20 13:34:25] schizoduckie at gmail dot com

I disagree with this bug being bogus.

Once you start giving people the power of casting, this type of
programming should be either consistently be possible to use throughout
the PHP or be completely removed to avoid any misunderstandings.

[aex351]

PHP is gewoon loose typed en switch gebruikt "==" . Ik zie niet wat hier nou zo fout aan is.

[mcdronkz]

laatmaar, verkeerd gezien.

[ Voor 84% gewijzigd door mcdronkz op 20-12-2006 14:52 ]

[SchizoDuckie]

aex351 schreef op woensdag 20 december 2006 @ 14:48:
PHP is gewoon loose typed en switch gebruikt "==" . Ik zie niet wat hier nou zo fout aan is.

Dat ze aan het toewerken zijn naar een hybride taal van loose typed en strictly typed (maar toch ook weer stiekem niet) door mensen variabelen te kunnen laten casten naar een bepaald type.

[aex351]

SchizoDuckie schreef op woensdag 20 december 2006 @ 14:52:
[...]


Dat ze aan het toewerken zijn naar een hybride taal van loose typed en strictly typed (maar toch ook weer stiekem niet) door mensen variabelen te kunnen laten casten naar een bepaald type.

Casten kan nuttig zijn. Alleen met een switch dus niet.

[ID-College]

Nja vind het ook een beetje vreemd.
Niet dat switch() zo'n super functie is, je kan er altijd omheen werken. Dan maar een if/else constructie.
Overigens kun je altijd === gebruiken dus het maakt mij niet zoveel uit of ze nou == of === in switch gebruiken. Switch() wordt volgens mij zoiezo weinig gebruikt

[SchizoDuckie]

aex351 schreef op woensdag 20 december 2006 @ 14:56:
[...]

Casten kan nuttig zijn. Alleen met een switch dus niet.

Je ziet het even verkeerd (opdezelfde manier als de php-developers volgens mij)

Casten ís nuttig en het zou nóg nuttiger zijn als de compiler ook snapt dat als jij iets expliciet cast, hij === ipv == moet gebruiken.

[Janoz]

aex351 schreef op woensdag 20 december 2006 @ 14:48:
PHP is gewoon loose typed en switch gebruikt "==" . Ik zie niet wat hier nou zo fout aan is.

Wat hier fout aan is is dat je bijvoorbeeld geen telefoonnummers goed kunt vergelijken. De essentie van een loosetyped taal is niet dat er helemaal geen types bestaan, maar dat ze on the fly worden bepaald. Lees het stuk van ACM nog even goed door.

[Yohost!]

Patriot schreef op woensdag 20 december 2006 @ 12:55:
Dit werkt ook:

PHP:

<?php

$veld = '0123';

switch($veld) {
    
    case $veld === '123':
        echo "Pils";
        break;
        
    case $veld === '456':
        echo "Geen pils :/";
        break;
    
    default:
        echo "Wat dan?";
        break;
        
}

?>

Goed, doe nu eens: $veld = '';
Rara wat krijg ik nu op mijn scherm?

[NMe]

Hmm, ik mag blijkbaar geen comments submitten op bugs die zij als "bogus" bestempelen. Stel je voor dat ze kritiek krijgen. Dan maar hier posten.

Quite frankly, your excuse is kind of weak. Yes, switch uses the same semantics as the == operator. Yes, this means possible unwanted conversions (which, for the life of me, I don't understand - "0123" is a string; which, compared to "123" is _not_ the same. If I'd wanted it to be the same, I'd have defined it as 0123 and 123 respectively). But if you actually explicitly cast the variable to a string, I think it should do a strict comparison.

PHP invites you to use strange code, very strange code indeed. For instance, the following returns true:

PHP:

$a = 0;
$b = "foo";

if ($a == $b)
    echo "PHP sucks";

Idiotic inconsistencies like this one and the workarounds experienced programmers have to write just to make the language easy to work with for beginners really damage your reputation and the PHP language in general.

Do with this comment as you please, but I really think you should provide experienced programmers with more means of keeping their code tidy and clean, without dumb workarounds.

[ACM]

SchizoDuckie schreef op woensdag 20 december 2006 @ 14:44:

Je zou ze er nog op kunnen wijzen dat je strings vergelijkt die toevallig uit getallen bestaan en dus ook van == zou verwachten dat een en ander ongelijk is... Er zijn tenslotte geen type-casts nodig, ook al doen ze die blijkbaar wel. Ook jouw expliciete casts hebben geen resultaat, want het zijn al strings die je er in stopt, daar op hameren zal weinig zin hebben.

Bovendien, 123 != 0123, waar je ze dan ook nog op zou kunnen wijzen

ID-College schreef op woensdag 20 december 2006 @ 14:57:
Nja vind het ook een beetje vreemd.
Niet dat switch() zo'n super functie is, je kan er altijd omheen werken. Dan maar een if/else constructie.
Overigens kun je altijd === gebruiken dus het maakt mij niet zoveel uit of ze nou == of === in switch gebruiken. Switch() wordt volgens mij zoiezo weinig gebruikt

Switch is geen functie. Het is een taal-constructie die je kan gebruiken om snel te kiezen tussen bepaalde stukken code. Sneller dan if/else bij grotere statements.

Yohost! schreef op woensdag 20 december 2006 @ 16:09:
Goed, doe nu eens: $veld = '';
Rara wat krijg ik nu op mijn scherm?

Jij misbruikt (blijkbaar onbewust) het feit dat php dynamische constructies toelaat in de switch. Want je $veld === ... wordt eerst geevalueerd tot false en $veld = '' wordt ook geevalueerd tot false en in de switch is dat dus gelijk

[NMe]

ACM schreef op woensdag 20 december 2006 @ 16:27:
Jij misbruikt (blijkbaar onbewust) het feit dat php dynamische constructies toelaat in de switch. Want je $veld === ... wordt eerst geevalueerd tot false en $veld = '' wordt ook geevalueerd tot false en in de switch is dat dus gelijk

...waaraan toe te voegen is dat de code verder wel werkt als je hem onveranderd laat, afgezien van het switchen op true in plaats van op $veld. Maak er maar eens switch (true) van en kijk wat er gebeurt.

[Yohost!]

Blijkbaar is het dus niet mogelijk om in mijn situatie gebruik te maken van een switch() en ben ik verplicht hier om met if en === te werken.

Edit:

-NMe- schreef op woensdag 20 december 2006 @ 16:34:
Maak er maar eens [font=mono]switch (true)[/font] van en kijk wat er gebeurt.

Ja zo werkt ie wel weer pima inderdaad!
Een behoorlijk verbouwde switch is het nu geworden

[ Voor 54% gewijzigd door Yohost! op 20-12-2006 16:42 ]

[SchizoDuckie]

-NMe- schreef op woensdag 20 december 2006 @ 16:24:
Hmm, ik mag blijkbaar geen comments submitten op bugs die zij als "bogus" bestempelen. Stel je voor dat ze kritiek krijgen. Dan maar hier posten.

[...]

Ik heb je post er nog even bijgezet.

ACM schreef op woensdag 20 december 2006 @ 16:27:
[...]

Je zou ze er nog op kunnen wijzen dat je strings vergelijkt die toevallig uit getallen bestaan en dus ook van == zou verwachten dat een en ander ongelijk is... Er zijn tenslotte geen type-casts nodig, ook al doen ze die blijkbaar wel. Ook jouw expliciete casts hebben geen resultaat, want het zijn al strings die je er in stopt, daar op hameren zal weinig zin hebben.

Bovendien, 123 != 0123, waar je ze dan ook nog op zou kunnen wijzen

Da's dus nu juist mijn punt van wél expliciet casten naar strings, op die manier zou de 'standaard' typecast naar INT gewoon *niet* mogen gebeuren. De compiler/interpreter zou dat gewoon moeten snappen en dan eventuele typecasts overslaan. Dat zou de huidige manier van werken niet aanpassen, de switch() hoeft gelijk niet eens === te gebruiken maar kan netjes met == blijven werken, en voor degenen die niet geconfronteerd willen worden met dit soort wazigheden de standaard oplossing kunnen zijn

[ Voor 3% gewijzigd door SchizoDuckie op 20-12-2006 17:25 ]

[ACM]

SchizoDuckie schreef op woensdag 20 december 2006 @ 17:24:
Da's dus nu juist mijn punt van wél expliciet casten naar strings, op die manier zou de 'standaard' typecast naar INT gewoon *niet* mogen gebeuren. De compiler/interpreter zou dat gewoon moeten snappen en dan eventuele typecasts overslaan.

Op het moment dat je variabele de switch in gaat is het totaal niet bekend meer dat ie getypecast was, maar het type van het ding is wel bekend.

Want wat moet er in jouw geval dan met zoiets gebeuren?

PHP:

$bla = 1;
switch((string)$bla)
{
  case 1 : ...; break;
  default : ...; break;
}

Persoonlijk heb ik er niet zoveel moeite mee dat er standaard de '==' gedaan wordt in de diverse vergelijkingen. Waar ik wel moeite mee heb is dat als er twee variabelen hetzelfde type (string) hebben, dat ze behandeld worden als andere soorten types... Maar ook weer niet helemaal, want als de quotes er niet om heen hadden gestaan werden ze weer anders geinterpreteerd.
Ik snap dan ook niet waarom het "expected behavior" is dat een 0 vooraan een getalstring weggeknipt wordt als je die vergelijkt met een andere getalstring, maar niet als er andere soorten karakters in zitten. Blijkbaar vinden ze dus dat er ipv twee (int en string) er drie typen bestaan hier (int, number string, string), oid.

[SchizoDuckie]

ACM schreef op woensdag 20 december 2006 @ 18:59:
[...]

PHP:

$bla = 1;
switch((string)$bla)
{
  case 1 : ...; break; // nuh-uh da's een int, geen string!
  default : ...; break; // er wordt hierheen gesprongen
}

Zo is het logisch toch? Als je nog een case "1" toe zou voegen zou dat weer wel matchen want de expliciete cast naar string zegt dat je alleen daarop wilt matchen.

[ Voor 9% gewijzigd door SchizoDuckie op 20-12-2006 19:12 ]

[Anoniem: 183031]

De redenering die ACM geeft is, mijn inziens, correct en dat ( "123" == "0123" ) mag dan ook als een bug worden beschouwd.

De volgende code

PHP:

$bla = 1;
switch((string)$bla)
{
  case 1 : ...; break;
  default : ...; break;
}

wordt eigenlijk als volgt uitgevoerd (is semantisch gelijk aan)

PHP:

$bla = 1;
$bla = (string)$bla;
switch($bla)
{
  case 1 : ...; break;
  default : ...; break;
}

Dus wanneer de switch wordt ingegaan heeft deze switch geen kennis van het feit dat deze variabele zojuist expliciet gecast is (en dat wil een switch ook niet weten).

Binnen het switch-statement wordt de '=='-operator gebruikt en wordt dus niet expliciet gekeken naar het type. Dat lijkt mij ook correct want PHP is loosly typed. Anders moet er onderscheid gemaakt kunnen worden tussen de twee verschillende switches die jij wilt hebben (één switch die rekening houdt met het type van een variabele en één die dat niet doet)? Dit lijkt mij (zo op het eerste gezicht) niet wenselijk en het bevordert de helderheid van de semantiek van het switch-statement niet bepaald.

[NMe]

SchizoDuckie schreef op woensdag 20 december 2006 @ 17:24:
[...]

Ik heb je post er nog even bijgezet.

Danku.

[crisp]

Javascript is ook loosely typed, maar daar wordt pas een impliciete converie naar int gedaan als 1 van de operands een integer is:

JavaScript:

alert('123' == '0123'); // false
alert(123 == '0123'); // true

[ Voor 24% gewijzigd door crisp op 20-12-2006 22:27 ]

[Anoniem: 26306]

PHP is ook zo lekker consequent:

PHP:

error_reporting ( E_ALL & ~E_NOTICE );

$a1 = '0123';  $a2 = '123';
$b1 = '0234';  $b2 = 234;
$c1 = '345';   $c2 = 345;
$d1 = '456';   $d2 = '0456';
$e1 = 567;     $e2 = '0567';
$f1 = 678;     $f2 = '678';

$arr = array (
    $a1 => $a2,
    $b1 => $b2,
    $c1 => $c2,
    $d1 => $d2,
   $e1 => $e2,
   $f1 => $f2
);

function hasEqual ( $value ) {
   global $a1, $b1, $c1, $d1, $e1, $f1;
   $equal = false;
   switch ( $value ) {
      case $a1: return true;
      case $b1: return true;
      case $c1: return true;
      case $d1: return true;
      case $e1: return true;
      case $f1: return true;
   }
   return false;
}

var_dump ( $a1 == $a2 );
var_dump ( $b1 == $b2 );
var_dump ( $c1 == $c2 );
var_dump ( $d1 == $d2 );
var_dump ( $e1 == $e2 );
var_dump ( $f1 == $f2 );
echo '<hr>';
var_dump ( $a1 === $a2 );
var_dump ( $b1 === $b2 );
var_dump ( $c1 === $c2 );
var_dump ( $d1 === $d2 );
var_dump ( $e1 === $e2 );
var_dump ( $f1 === $f2 );
echo '<hr>';
var_dump ( hasEqual ( $a2 ) );
var_dump ( hasEqual ( $b2 ) );
var_dump ( hasEqual ( $c2 ) );
var_dump ( hasEqual ( $d2 ) );
var_dump ( hasEqual ( $e2 ) );
var_dump ( hasEqual ( $f2 ) );
echo '<hr>';
var_dump ( in_array ( $a1, $arr ) );
var_dump ( in_array ( $b1, $arr ) );
var_dump ( in_array ( $c1, $arr ) );
var_dump ( in_array ( $d1, $arr ) );
var_dump ( in_array ( $e1, $arr ) );
var_dump ( in_array ( $f1, $arr ) );
echo '<hr>';
var_dump ( array_key_exists ( $a2, $arr ) );
var_dump ( array_key_exists ( $b2, $arr ) );
var_dump ( array_key_exists ( $c2, $arr ) );
var_dump ( array_key_exists ( $d2, $arr ) );
var_dump ( array_key_exists ( $e2, $arr ) );
var_dump ( array_key_exists ( $f2, $arr ) );
echo '<hr>';

bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
--------------------
bool(false)
bool(false)
bool(false)
bool(false)
bool(false)
bool(false)
--------------------
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
--------------------
bool(false)
bool(false)
bool(true)
bool(false)
bool(false)
bool(true)
--------------------
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)

Wat is nou precies gelijkheid?