een stom php type dingetje

Overzicht Reageren

Sponsored by: Vacatures door Monsterboard

Rudie dirkx

rudie dirkx

18/12/2010 01:14:28
Quote Anchor link
Steek je hand op als je het volgende ook stom vindt:

'50' == '50.00' is TRUE

Test:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
<?php
var_dump('50' == '50.00'); // bool(true)
?>


Ik weet en snap (en love) dat PHP type ongevoelig en ontzettend vrij is, maar als beide delen strings zijn wordt toch zeker wel op de waarde gecontroleerd??? Nu worden ze als float ofzo vergeleken? Dat is raar!

Ik heb altijd gedacht dat het enige verschil tussen == en === was dat de eerste niet en de tweede wel op type controleert. Blijkbaar is dat niet!! Want beide zijn string en toch is het met == true en met === false!

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
<?php
var_dump('50' === '50.00'); // bool(false)
?>


De string wordt intern even snel geconverteerd naar float of int om het te laten matchen??

Wie vindt dit nog meer raar (en misschien zelfs een bug)?? Ik heb PHP 5.3.0.
 
PHP hulp

PHP hulp

12/04/2024 21:53:44
 
- SanThe -

- SanThe -

18/12/2010 04:03:52
Quote Anchor link
Nee, ik vind dit niet raar. Met == maakt php daar blijkbaar toch getallen van (op zich wel raar) en die worden vergeleken. En die zijn gelijk. Met === wordt ook het type vergeleken en dan moet php het wel als zijnde een string behandelen en nee, die zijn dus niet gelijk.
 
Rudie dirkx

rudie dirkx

18/12/2010 06:44:52
Quote Anchor link
Maar dan is het toch juist raar? Het verschil tussen == en === is dat de typen bij de tweede hetzelfde moeten zijn. De typen ZIJN al hetzelfde, dus zouden == en === toch hetzelfde moeten doen??
Ik vind het heel erg raar. Ik ga voortaan in ieder geval overal === en !== gebruiken.
 
Victor Php

Victor Php

18/12/2010 10:04:55
Quote Anchor link
That's the way they made it.
Kunnen wij hier niks aan doen =)
 
Jelmer -

Jelmer -

18/12/2010 10:25:38
Quote Anchor link
Rudie dirkx op 18/12/2010 06:44:52:
Maar dan is het toch juist raar? Het verschil tussen == en === is dat de typen bij de tweede hetzelfde moeten zijn. De typen ZIJN al hetzelfde, dus zouden == en === toch hetzelfde moeten doen??
Ik vind het heel erg raar. Ik ga voortaan in ieder geval overal === en !== gebruiken.


== vergelijkt en converteert eventueel het type tijdens het vergelijken om te kijken of ze dan wel gelijk zijn. === converteert het type niet, dus als ze niet van hetzelfde type zijn, zijn ze automatisch al niet gelijk. En zijn ze wel van hetzelfde type, dan wordt er gecontroleerd op inhoud. Zo vreemd is dat toch niet?
 
Yea Rupie

Yea Rupie

18/12/2010 13:20:23
Quote Anchor link
Wat is hier raar aan?
50 is hetzelfde als 50.00? (==)
en 50 is niet identiek aan 50.00 (===)
 

18/12/2010 15:16:13
Quote Anchor link
Rudie dirkx op 18/12/2010 01:14:28:
(…)
Ik heb altijd gedacht dat het enige verschil tussen == en === was dat de eerste niet en de tweede wel op type controleert. Blijkbaar is dat niet!! Want beide zijn string en toch is het met == true en met === false!
(…)

Ja, de eerste (==) checkt niet op type. Intern zal denk ik de eerste variabele naar integer worden omgezet. Dat betekend dus ook dat de tweede variabele omgezet moet worden. Makkelijk is om deze ook naar integer om te zetten. Dus dan krijg je twee keer 50 en dat is gelijk aan elkaar. Dat is dus precies een voorbeeld van weak typing.
Je moet dus inderdaad goed opletten wat je precies checkt met php. Ook moet je goed opletten met floats in php.
Zie ook de volgende php.net pagina’s:
types.comparisons
language.types.type-juggling
language.types.string#language.types.string.conversion
language.operators.comparison
Verder is dit misschien ook wel een interessant verhaal.

Als je een strong typing taal pakt zoals Java heb je ook wat rare dingetjes:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
<?php // LET OP! Dit is GEEN php. Dit is alleen voor de kleurtjes
/**
 * Deze klasse is voor het testen van types in java.
 * Java is een strong typing language en gaat dus anders om met zijn variabelen.
 * Elke methode en veld is static want dan kunnen we ze zo benaderen.
 * In java doe je concatten niet met een . maar met +.
 * @author Karl
 * @version 18-12-2010
 * @see http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
 * @see http://download.oracle.com/javase/tutorial/java/data/index.html
 *
 */

public class type_testing_java {
    // Aanmaken van een aantal velden
    public static int a = 5;
    public static int b = 9;
    public static int c = 100;
    public static double d = 1.5; // Wordt standaard 0.0d zie docs
    public static double e = 2.0;
    public static String f = "test"; // Object type
    public static double g = 100.0;
        
    /**
     * Main method. Deze wordt altijd uitgevoerd.
     * Hier roepen we dus al onze test methodes aan.
     * @param args
     */

    public static void main(String[] args) {
        // Onderstaande regels leveren output (zie codeblokje hieronder).
        System.out.println(levertTweeIntsEenDouble());
        System.out.println(levertTweeDoublesEenDouble());
        System.out.println(levertTweeIntsEnEenDoubleEenDouble());
        System.out.println(levertEenIntEnEenDoubleEenDouble());
        System.out.println(levertEenDoubleEenIntEenDoubleEenDouble());
        System.out.println(kunnenWeDrieIntsEenDoubleLatenLeveren());
        System.out.println(weWillenEenStringTerugMetTweeIntsAlsEenIntEnMetEenString());
        System.out.println(weWillenEenStringTerugMetEenStringEnTweeIntsAlsEenInt());
        System.out.println(weZeidenDatWeEenStringTerugMetEenStringEnTweeIntsAlsEenIntWouden());
        System.out.println(weZeidenDatWeEenStringTerugMetTweeIntsEnMetEenStringWouden());
    }

    
    /*
     * Nog even een methode uitleg:
     * public static double levertTweeIntsEenDouble()
     * Dat betekend dat deze methode door iedereen benaderd mag worden -> public
     * Er hoeft geen object van deze klasse te zijn -> static
     * Het type wat de methode teruggeeft -> double
     * De naam van de methode en geen parameters -> levertTweeIntsEenDouble()
     *
     * Deze is iets anders:
     * public static String weWillenEenStringTerugMetEenStringEnTweeIntsAlsEenInt()
     * Het enige verschil is de String. String is een object type (zie hierboven de links).
     * Dat betekend dus dat er van String een klasse is. En dat er een object zal bestaan
     * van het type String als je deze gebruikt.
     * In java is het zo dat je alleen primitieve datatypes hebt (int, double, char, etc.)
     * Als je wat anders wilt, zoals String, dan zit je bij een object datatype.
     * String is dus een klasse die intern een string bijhoud als iets.
     * Hoe hoef je niet te weten.
     */
    /**
     * Deze methode is om te kijken of twee ints een double levert.
     * De uitkomst zou 0.55555556 moeten zijn (breuk)
     * @return De uitkomts van de breuk a/b
     */

    public static double levertTweeIntsEenDouble()
    {

        return a/b;
    }

    
    /**
     * Deze methode is om te kijken of twee doubles een double levert.
     * De uitkomst zou 0.75 moeten zijn
     * @return De uitkomst van de breuk d/e
     */

    public static double levertTweeDoublesEenDouble()
    {

        return d / e;
    }

    
    /**
     * Deze methode is om te kijken of de volgorde van types wat uitmaakt.
     * De uitkomst zou dus 55.55555555556 moeten zijn
     * @see type_testing_java#levertEenDoubleEenIntEenDoubleEenDouble()
     * @return De uitkomst van de formule (a/b)*g.
     */

    public static double levertTweeIntsEnEenDoubleEenDouble()
    {

        return a/b * g;
    }

    
    /**
     * Deze methode is om te kijken of een int en een double wel een double oplevert.
     * De uitkomst zou dus 500.0 moeten zijn
     * @return De uitkomst van het product van a*g
     */

    public static double levertEenIntEnEenDoubleEenDouble()
    {

        return a*g;
    }

    
    /**
     * Deze methode is om te kijken of de volgorde van types wat uitmaakt.
     * De uitkomst zou dus 55.55555555 moeten zijn.
     * @see type_testing_java#levertTweeIntsEnEenDoubleEenDouble()
     * @return De uitkomst van de formule (a*g)/b
     */

    public static double levertEenDoubleEenIntEenDoubleEenDouble()
    {

        return a*g/b;
    }

    
    /**
     * Nu we bovenstaande methodes hebben uitgevoerd zullen we dit ons afvragen
     * De uitkomst zou dus 55.555555556 moeten zijn.
     * @see type_testing_java#levertTweeIntsEnEenDoubleEenDouble()
     * @see type_testing_java#levertTweeIntsEenDouble()
     * @return
     */

    public static double kunnenWeDrieIntsEenDoubleLatenLeveren()
    {

        return (double)a/b * c;
    }

    
    /**
     * Met strings is er ook wat aan de hand.
     * @return (a+b) + f
     */

    public static String weWillenEenStringTerugMetTweeIntsAlsEenIntEnMetEenString()
    {

        return a + b + f;
    }

    
    /**
     * Nu we de functie {@link type_testing_java#weWillenEenStringTerugMetTweeIntsAlsEenIntEnMetEenString()}
     * hebben gezien, willen we dus de integer op het eind van onze string
     * @return f+(a+b) (of niet?)
     */

    public static String weWillenEenStringTerugMetEenStringEnTweeIntsAlsEenInt()
    {

        return f + a + b;
    }

    
    /**
     * Blijkbaar werkt het niet zo in java @link {@link type_testing_java#weWillenEenStringTerugMetEenStringEnTweeIntsAlsEenInt()}
     * gaf ons een ander resultaat dan we wouden
     * @return f+(a+b)
     */

    public static String weZeidenDatWeEenStringTerugMetEenStringEnTweeIntsAlsEenIntWouden()
    {

        return f + (a+b);
    }

    
    /**
     * Blijkbaar werkte @link {@link type_testing_java#weWillenEenStringTerugMetTweeIntsAlsEenIntEnMetEenString()} wat we wouden.
     * Nu willen we dat we twee ints aan het begin moet. Hoe moet dat dan?
     * @return a+b+f
     */

    public static String weZeidenDatWeEenStringTerugMetTweeIntsEnMetEenStringWouden()
    {

        return "" + a + b + f;
    }
}

// Om gezeur van bbcode parser te vermijden:
?>

Dit levert:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php // Wederom, kleurtjes:
/*
0.0
0.75
0.0
500.0
55.55555555555556
55.55555555555556
14test
test59
test14
59test
*/

?>
Gewijzigd op 18/12/2010 15:25:59 door
 



Overzicht Reageren

 
 

Om de gebruiksvriendelijkheid van onze website en diensten te optimaliseren maken wij gebruik van cookies. Deze cookies gebruiken wij voor functionaliteiten, analytische gegevens en marketing doeleinden. U vindt meer informatie in onze privacy statement.