operators.xml

<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.63 $ -->
 <chapter id="language.operators">
  <title>Operatorer</title>
  <simpara>
   En operator är någonting som du matar med ett eller flera värden 
   (eller uttryck på programmeringsjargon) vilket i sin tur resulterar
   i ett annat värde (så att konstruktionen själv blir ett uttryck). Du 
   kan tänka på funktioner eller konstruktioner som returnerar ett värde 
   (te x print) som operatorer och de som inte returnerar något (te x echo) 
   som andra saker.
  </simpara>
  <para>
   <!-- unary, termed, ternary ??? nu översatt med en- två- och trevariabels.. -->
   Det finns tre typer av operatorer. Först så finns det envariabels-operatorer 
   som opererar på endast ett värde, till exempel ! (motsattsoperatorn) eller ++ 
   (ökningsoperatorn). Den andra gruppen är tvåvariabels-operatorer. Den här 
   gruppen innehåller de flesta av operatorerna som PHP stödjer. En lista följer
   i sektionen om
   <link linkend="language.operators.precedence">Operatorprioritet</link> nedanför.
  </para>
  <para>
   Den tredje gruppen är trevariables-operatorer: ?:. Den bör användas för
   att välja mellan två uttryck beroende på ett tredje snarare än att 
   välja mellan två sattser eller körvägar. Att omge trevaribels-uttryck med 
   parenteser är en väldigt bra idé.
  </para>
  
  <sect1 id="language.operators.precedence">
   <title>Operatorprioritet</title>
   <para>
    Prioritet på en operator säger hur "hårt" den binder samman två 
    uttryck. Till exempel för uttrycket <literal>1 + 5 * 3</literal>
    är svaret <literal>16</literal> och inte <literal>18</literal>
    eftersom multiplikationsoperatorn ("*") har en högre prioritet
    än additionsoperatorn ("+"). Parenteser kan om det är nödvändigt
    användas för att tvinga fram en annan prioritet, till exempel:
    <literal>(1 + 5) * 3</literal> utvärderas till <literal>18</literal>.
   </para>
   <para>
    Den följande tabellen listar operatorprioriteten, den operator
    med högst prioritet är listad först.
    <table>
     <title>Operatorprioritet</title>
     <tgroup cols="2">
      <thead>
       <row>
        <entry>Associativitet</entry>
        <entry>Operatorer</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry>icke-associativ</entry>
        <entry>new</entry>
       </row>
       <row>
        <entry>höger</entry>
        <entry>[</entry>
       </row>
       <row>
        <entry>höger</entry>
        <entry>! ~ ++ -- (int) (float) (string) (array) (object) @</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>* / %</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>+ - .</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>&lt;&lt; &gt;&gt;</entry>
       </row>
       <row>
        <entry>icke-associativ</entry>
        <entry>&lt; &lt;= &gt; &gt;=</entry>
       </row>
       <row>
        <entry>icke-associativ</entry>
        <entry>== != === !==</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>&amp;</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>^</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>|</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>&amp;&amp;</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>||</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>? :</entry>
       </row>
       <row>
        <entry>höger</entry>
        <entry>
         = += -= *= /= .= %= &amp;= |= ^= &lt;&lt;= &gt;&gt;=
        </entry>
       </row>
       <row>
        <entry>höger</entry>
        <entry>print</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>and</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>xor</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>or</entry>
       </row>
       <row>
        <entry>vänster</entry>
        <entry>,</entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>
   <note>
    <para>
     Även om <literal>!</literal> har en högre prioritet än
     <literal>=</literal> så tillåter PHP ändå uttryck liknande
     de här: <literal>if (!$a = foo())</literal>. I det här fallet
     så kommer utmatningen från <literal>foo()</literal> att 
     stoppas in i <varname>$a</varname>.
    </para>
   </note>
  </sect1>

  <sect1 id="language.operators.arithmetic">
   <title>Aritmetikoperatorer</title>
   <simpara>
    Kommer du ihåg de fyra räknesätten från skolan? De här
    operatorerna fungerar precis som dem.
   </simpara>
   <table>
    <title>Aritmetikoperatorer</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>Exempel</entry>
       <entry>Namn</entry>
       <entry>Resultat</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a + $b</entry>
       <entry>Addition</entry>
       <entry>Summan av $a och $b.</entry>
      </row>
      <row>
       <entry>$a - $b</entry>
       <entry>Subtraktion</entry>
       <entry>Skillnaden mellan $a och $b.</entry>
      </row>
      <row>
       <entry>$a * $b</entry>
       <entry>Multiplikation</entry>
       <entry>Produkten av $a och $b.</entry>
      </row>
      <row>
       <entry>$a / $b</entry>
       <entry>Division</entry>
       <entry>Differensen av $a och $b.</entry>
      </row>
      <row>
       <entry>$a % $b</entry>
       <entry>Modulo</entry>
       <entry>Resten vid division av $a och $b.</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   <simpara>
    Divisionsoperatorn ("/") returnerar alltid ett flyttal, 
    även om de två operanderna är heltal (eller strängar som
    blir konverterade till heltal).
   </simpara>
   <simpara>
    Se också manualsidan för
    <link linkend="ref.math">Matematikfunktioner</link>. 
   </simpara>

   <!--
   <simpara>
    The division operator ("/") returns an integer value (the result
    of an integer division) if the two operands are integers (or
    strings that get converted to integers) and the quotient is an
    integer. If either operand is a floating-point value, or the
    operation results in a non-integer value, a floating-point value
    is returned.
   </simpara>
   -->
  </sect1>
  
  <sect1 id="language.operators.assignment">
   <title>Tilldelningsoperatorer</title>
   <simpara>
    Den grundläggande tilldelningsoperatorn är "=". Din första reaktion
    kan vara att tänka på den som "lika med". Gör inte det. Den betyder
    egentligen att den vänstra operanden tilldelas värdet av uttrycket till
    höger (den "tilldelas värdet" alltså).
   </simpara>
   <para>
    Värdet av tilldelningsuttrycket är värdet som tilldelas. Alltså
    värdet av "$a = 3" är 3. Det tillåter dig att göra lite listiga
    saker:
    <informalexample>
     <programlisting role="php"> 
<![CDATA[
<?php

$a = ($b = 4) + 5; // $a är lika med 9 och $b har blivit tilldelat värdet 4.

?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <!-- TODO, translation - oklart? -->
   <para>
    
    Som tillägg till den vanliga tilldelningsoperatorn så finns det
    "kombinerade operatorer"  för alla 
    <link linkend="language.operators">räkningsoperatorer</link>
    och strängoperatorer som låter dig använda ett värde i ett uttryck
    och sen sätta dess värde till resultatet av det uttrycket. Ett exempel:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

$a = 3;
$a += 5; // sätter $a till 8 som om vi hade skrivit: $a = $a + 5;
$b = "Hallå ";
$b .= "där!"; // sätter $b till "Hallå där!" som om vi hade skrivit $b = $b . "där!";

?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <para>
    <!-- TODO, translation..This may also have relevance if you 
    need to copy something like a large array inside a tight loop.
    
    hmm?? - varför skulle de vara relevant? -->
    Notera att tilldelning kopierar orginalvärdet till den nya
    (tilldelning genom värde), så ändringar på den ena påverkar 
    inte den andra. Det här kan vara relevant om du behöver kopiera
    någonting stort, som en stor vektor, inuti en kort loop.
    PHP 4 stödjer och tilldelning genom referens genom att använda
    syntaxen <computeroutput>$var = &amp;$othervar;</computeroutput>. 
    Detta fungerar dock inte i PHP 3. 'Tilldelning genom referens'
    betyder att båda variablerna pekar på samma data och ingenting
    kopieras någonstans. För att lära dig mer om referenser så kan
    du läsa<link linkend="language.references">Referenser 
    förklarade</link>.
   </para>
  </sect1>

  <sect1 id="language.operators.bitwise">
   <title>Bitoperatorer</title>
   <simpara>
    Bitoperatorer låter dig sätta på eller av specifika bits i en integer.
    Om både vänster- och högerparametrarna är strängar så kommer bitoperatorerna
    att operera på tecknen i strängen.
   </simpara>
   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
echo 12 ^ 9; // Skriver ut '5'

echo "12" ^ "9"; // Skriver ut backspace-tecknet (ascii 8)
                 // ('1' (ascii 49)) ^ ('9' (ascii 57)) = #8

echo "hallo" ^ "hello"; // Skriver ut asciivärdena #0 #4 #0 #0 #0
                        // 'a' ^ 'e' = #4
?>
]]>
     </programlisting>
    </informalexample> 
   </para>

   <table>
    <title>Bitoperatorer</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>Exempel</entry>
       <entry>Namn</entry>
       <entry>Resultat</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a &amp; $b</entry>
       <entry>Och</entry>
       <entry>Bitar som är satta i både $a och $b sätts.</entry>
      </row>
      <row>
       <entry>$a | $b</entry>
       <entry>Eller</entry>
       <entry>Bitar som är satta i antingen $a eller $b sätts.</entry>
      </row>
      <row>
       <entry>$a ^ $b</entry>
       <entry>Exklusivt</entry>
       <entry>
        Bitar som är satta i $a eller $b men inte i båda sätts.
       </entry>
      </row>
      <row>
       <entry>~ $a</entry>
       <entry>Inte</entry>
       <entry>
        Bitar som är satta i $a sätts inte och vice versa.
       </entry>
      </row>
      <row>
       <entry>$a &lt;&lt; $b</entry>
       <entry>Vänsterskiftning</entry>
       <entry>
        Skiftar bitarna i $a $b steg till vänster (varje steg betyder
        "multiplicera med två")
       </entry>
      </row>
      <row>
       <entry>$a &gt;&gt; $b</entry>
       <entry>Högerskiftning</entry>
       <entry>
        Skiftar bitarna i $a $b steg till höger (varje steg betyder
        "dividera med två")
       </entry>
      </row>
     </tbody>
    </tgroup>
   </table>
  </sect1>

  <sect1 id="language.operators.comparison">
   <title>Jämförelseoperatorer</title>
   <simpara>
    Jämförelseoperatorer, som deras namn föreslår, låter dig jämföra
    två värden. Du kanske också är intresserad att titta på 
    <link linkend="types.comparisons">typjämförelsetabellerna</link>,
    eftersom de visar diverse relevanta jämförelseexempel.
   </simpara>
   <table>
    <title>Jämförelseoperatorer</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>Exempel</entry>
       <entry>Namn</entry>
       <entry>Resultat</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a == $b</entry>
       <entry>Lika med</entry>
       <entry>&true; om $a är lika med $b.</entry>
      </row>
      <row>
       <entry>$a === $b</entry>
       <entry>Identiska</entry>
       <entry>
        &true; om $a är lika med $b och om de är av samma typ. 
        (enbart PHP 4)
       </entry>
      </row>
      <row>
       <entry>$a != $b</entry>
       <entry>Inte lika med</entry>
       <entry>&true; om $a inte är lika med $b.</entry>
      </row>
      <row>
       <entry>$a &lt;&gt; $b</entry>
       <entry>Inte lika med</entry>
       <entry>&true; om $a inte är lika med $b.</entry>
      </row>
      <row>
       <entry>$a !== $b</entry>
       <entry>Inte identiska</entry>
       <entry>
        &true; om $a inte är lika med $b eller om det inte är av samma typ. 
        (enbart PHP 4)
       </entry>
      </row>
      <row>
       <entry>$a &lt; $b</entry>
       <entry>Mindre än</entry>
       <entry>&true; om $a är mindre än $b.</entry>
      </row>
      <row>
       <entry>$a &gt; $b</entry>
       <entry>Större än</entry>
       <entry>&true; om $a är mindre än $b.</entry>
      </row>
      <row>
       <entry>$a &lt;= $b</entry>
       <entry>Mindre eller lika med</entry>
       <entry>&true; om $a är mindre eller lika med $b.</entry>
      </row>
      <row>
       <entry>$a &gt;= $b</entry>
       <entry>Större eller lika med</entry>
       <entry>&true; om $a är större eller lika med $b.</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   <para>
    <!-- TODO, översättning ternary ??-->
    En annan valoperator är "?:"- eller trevariabels-operatorn, som
    fungerar lika som i C och många andra språk.
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
// Exempel på användning av trevariabelsoperatorn:
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];

// Det ovanför är identiskt med det här if/else-sattsen:
if (empty($_POST['action'])) {
    $action = 'default';
} else {
    $action = $_POST['action'];
}
?>
]]>
     </programlisting>
    </informalexample> 
    Uttrycket <literal>(uttr1) ? (uttr2) : (uttr3)</literal>
    resulterar i <replaceable>uttr2</replaceable> om
    <replaceable>uttr1</replaceable> är &true;, och
    <replaceable>uttr3</replaceable> om
    <replaceable>uttr1</replaceable> är &false;.
   </para>
   <para>
    Se också <function>strcasecmp</function>,
    <function>strcmp</function>,
    <link linkend="language.operators.array">Vektoroperatorer</link>,
    och på manualsidan om 
    <link linkend="language.types">Typer</link>.
   </para>
  </sect1>

  <sect1 id="language.operators.errorcontrol">
   <title>Felkontrollsoperatorer</title>
   <simpara>
    PHP stödjer en felkontrollsoperator: snabel-aet (@). När 
    ett uttryck föregås av ett snabel-a så kommer de eventuella felmeddelandet
    som generas av det uttrycket att ignoreras.
   </simpara>
   <simpara>
    Om <link linkend="ini.track-errors">track_errors</link> är
    aktiverat så kommer de eventuella felmeddelande som generades
    av uttrycket att sparas i variabeln 
    <link linkend="reserved.variables.phperrormsg">$php_errormsg</link>.
    Den här variabeln kommer att skrivas över för varje fel, så kontrollera
    tidigt om du vill använda den.
   </simpara>
   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
/* Avsiktligt filfel */
$my_file = @file ('ickeexisterande_fil') or
    die ("Kunde inte öppna filen: felet var '$php_errormsg'");

// det här fungerar på alla uttryck, inte bara funktioner:
$value = @$cache[$key]; 
// kommer inte att leverera en felnotis om indexet $key inte existerar.

?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <note>
    <simpara>
     @-operatorn fungerar bara på
     <link linkend="language.expressions">uttryck</link>. En enkel regel
     är att om du kan ta värdet av någonting så kan du använda @-operatorn
     på den. Till exempel så kan du sätta den före variabler, funktioner
     och <function>include</function>-anrop, konstanter och så vidare.
     Du kan inte sätta det före funktions- eller klassdefinitioner, eller
     kontrollstrukturer som <literal>if</literal>, <literal>foreach</literal>
     och så vidare.
    </simpara>
   </note>
   <simpara>
    Se också <function>error_reporting</function> och manualsektionen om 
    <link linkend="ref.errorfunc">Felhantering och Loggningsfunktioner</link>.
   </simpara>
   <note>
    <para>
     @-operatorn kommer inte att göra så att fel som beror på tolkningsfel
     inte visas.
    </para>
   </note>
   <warning>
    <para>
     @-opertorn gör däremot så att även kritiska fel som avslutar
     skriptkörningen inte visas. Det betyder att om du använder "@"
     för att inte visa felmeddelanden från en viss funktion och den
     inte finns tillgänglig eller har blivit felstavat så kommer
     skriptet att dö där utan någon som helst indikering om varför.
    </para>
   </warning>
  </sect1>
  
  <sect1 id="language.operators.execution">
   <title>Körningsoperatorer</title>
   <para>
    PHP stödjer en körningsoperator: grava accenter (``). Det är
    alltså inte apostroftecken! PHP kommer att försöka köra innehållet
    som ett shell-kommando. Utmatningen kommer att returneras (Den 
    kommer alltså inte att skrivas ut, utan kan tilldelas en variabel).
    Att använda grav accent är samma sak som att använda funktionen 
    <function>shell_exec</function>. 
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$output = `ls -al`;
echo "<pre>$output</pre>";
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <note>
    <para>
     grav accent-operatorn är avaktiverad när &safemode är aktiverat
     eller <function>shell_exec</function> är avaktiverad.
    </para>
   </note>
   <para>
    Se också manualsektionen om 
    <link linkend="ref.exec">Programkörningsfunktioner</link>, 
    <function>popen</function>, <function>proc_open</function>, och
    <link linkend="features.commandline">Att använda PHP från kommandoraden</link>.
   </para>
  </sect1>

  <sect1 id="language.operators.increment">
   <title>Öknings-/Minskningsoperatorer</title>
   <para>
    PHP stödjer öknings- och minskingsoperatorer både
    för- och efter precis som i C.
   </para>
   <table>
    <title>Öknings-/Minskningsoperatorer</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>Exempel</entry>
       <entry>Namn</entry>
       <entry>Effekt</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>++$a</entry>
       <entry>Ökning före</entry>
       <entry>Ökar $a med ett och returnerar sen $a.</entry>
      </row>
      <row>
       <entry>$a++</entry>
       <entry>Ökning efter</entry>
       <entry>Returnerar $a och ökar sen $a med ett.</entry>
      </row>
      <row>
       <entry>--$a</entry>
       <entry>Minskning före</entry>
       <entry>Minskar $a med ett och returnerar sen $a.</entry>
      </row>
      <row>
       <entry>$a--</entry>
       <entry>Minskning efter</entry>
       <entry>Returnerar $a och minskar sen $a med ett.</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   <para>
    Här är några enkla exempel:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
echo "<h3>Ökning efter</h3>";
$a = 5;
echo "Borde vara 5: " . $a++ . "<br />\n";
echo "Borde vara 6: " . $a . "<br />\n";

echo "<h3>Ökning före</h3>";
$a = 5;
echo "Borde vara 6: " . ++$a . "<br />\n";
echo "Borde vara 6: " . $a . "<br />\n";

echo "<h3>Minskning efter</h3>";
$a = 5;
echo "Borde vara 5: " . $a-- . "<br />\n";
echo "Borde vara 4: " . $a . "<br />\n";

echo "<h3>Minskning före</h3>";
$a = 5;
echo "Borde vara 4: " . --$a . "<br />\n";
echo "Borde vara 4: " . $a . "<br />\n";
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <para>
    PHP följer Perl:s och inte C:s standard när man använder räkneoperationer 
    på teckenvariabler. Till exempel, i Perl så blir 'Z'+1 'AA' medan det i 
    C blir '[' ( ord('Z') == 90, ord('[') == 91 ).
    Ökningsoperatorer kan användas på teckenvariabler men inte minskningsoperatorer.
    <example>
     <title>Räkneoperatorer på teckenvariabler</title>
     <programlisting role="php">
<![CDATA[
<?php
$i = 'W';
for($n=0; $n<6; $n++)
  echo ++$i . "\n";

/*
  Producerar en utmatning liknande den här:

X
Y
Z
AA
AB
AC

*/
?>
]]>
     </programlisting>
    </example>
   </para>
  </sect1>

  <sect1 id="language.operators.logical">
   <title>Logiska operatorer</title>

   <table>
    <title>Logiska operatorer</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>Exempel</entry>
       <entry>Namn</entry>
       <entry>Resultat</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a and $b</entry>
       <entry>Och</entry>
       <entry>&true; om både $a och $b är &true;.</entry>
      </row>
      <row>
       <entry>$a or $b</entry>
       <entry>Eller</entry>
       <entry>&true; om antingen $a eller $b är &true;.</entry>
      </row>
      <row>
       <entry>$a xor $b</entry>
       <entry>Exlusivt</entry>
       <entry>&true; om antingen $a eller $b men inte båda är &true;.</entry>
      </row>
      <row>
       <entry>! $a</entry>
       <entry>Inte</entry>
       <entry>&true; om $a inte är &true;.</entry>
      </row>
      <row>
       <entry>$a &amp;&amp; $b</entry>
       <entry>Och</entry>
       <entry>&true; om både $a och $b är &true;.</entry>
      </row>
      <row>
       <entry>$a || $b</entry>
       <entry>Eller</entry>
       <entry>&true; om antingen $a eller $b är &true;.</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   <simpara>
    Orsaken till att det finns två olika variationer på "och"- och
    "eller"-operatorerna är att de har olika prioritet. (Se 
    <link linkend="language.operators.precedence">Operatorprioritet</link>.)
   </simpara>
  </sect1>

  <sect1 id="language.operators.string">
   <title>Strängoperatorer</title>
   <simpara>
    <!-- TODO, översättning konkatentering?.. svårt ord att förstå kanske?. -->
    Det finns två strängoperatorer. Den första är konkatenteringsoperatorn
    ('.') som returnerar en ihopsatt sträng av dess högra och vänstra
    argument. Den andra är konkantentering- och tilldelningsoperatorn ('.=') 
    som lägger till argumentet på högra sidan till argumentet på vänster sida.
    Läs mer i kapitlet om <link 
    linkend="language.operators.assignment">Tilldelningsoperatorer</link>.
   </simpara>

   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$a = "Hej ";
$b = $a . "världen!"; // nu innehåller $b "Hej världen!"

$a = "Hej ";
$a .= "världen!";     // nu innehåller $a "Hej världen!"
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <para>
    Se också manualsektionerna om  
    <link linkend="language.types.string">Strängtyper</link> och
    <link linkend="ref.strings">Strängfunktioner</link>.
   </para>
  </sect1>
  
  <sect1 id="language.operators.array">
   <title>Vektoroperatorer</title>
   <table>
    <title>Vektoroperatorer</title>
    <tgroup cols="3">
     <thead>
      <row>
       <entry>Exempel</entry>
       <entry>Namn</entry>
       <entry>Resultat</entry>
      </row>
     </thead>
     <tbody>
      <row>
       <entry>$a + $b</entry>
       <entry>Sammanslagning</entry>
       <entry>Sammanslagning av $a och $b.</entry>
      </row>
      <row>
       <entry>$a == $b</entry>
       <entry>Lika med</entry>
       <entry>&true; om $a och $b har samma element.</entry>
      </row>
      <row>
       <entry>$a === $b</entry>
       <entry>Identiska</entry>
       <entry>&true; om $a och $b har samma element och dessa är i samma ordning.</entry>
      </row>
      <row>
       <entry>$a != $b</entry>
       <entry>Inte lika med</entry>
       <entry>&true; om $a inte är lika med $b.</entry>
      </row>
      <row>
       <entry>$a &lt;&gt; $b</entry>
       <entry>Inte lika med</entry>
       <entry>&true; om $a inte är lika med $b.</entry>
      </row>
      <row>
       <entry>$a !== $b</entry>
       <entry>Icke identiska</entry>
       <entry>&true; om $a inte är identiskt med $b.</entry>
      </row>
     </tbody>
    </tgroup>
   </table>
   <para>
    <literal>+</literal>-operatorn lägger till den högra arrayen
    till den vänstra, dubbla nycklar skrivs alltså INTE över.
   </para>
   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$a = array("a" => "apple", "b" => "banana");
$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");

$c = $a + $b; // Sammanslagning av $a och $b
echo "Sammanslagning av \$a och \$b: \n";
var_dump($c);

$c = $b + $a; // Sammanslagning av $b och $a
echo "Sammanslagning av \$b och \$a: \n";
var_dump($c);
?>
]]>
     </programlisting>
    </informalexample>
    När det här skriptet körs kommer utmatningen att vara följande:
    <screen role="php">
<![CDATA[
Sammanslagning av $a och $b:
array(3) {
  ["a"]=>
  string(5) "apple"
  ["b"]=>
  string(6) "banana"
  ["c"]=>
  string(6) "cherry"
}
Sammanslagning av $b och $a:
array(3) {
  ["a"]=>
  string(4) "pear"
  ["b"]=>
  string(10) "strawberry"
  ["c"]=>
  string(6) "cherry"
}
]]>
    </screen>
   </para>
   <para>
    Element i vektorer är lika med varandra bara om de har samma nyckel
    och värde.
   </para>
   <para>
    <example>
     <title>Jämföra vektorer</title>
     <programlisting role="php">
<![CDATA[
<?php
$a = array("apple", "banana");
$b = array(1 => "banana", "0" => "apple");

var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    Se också manualsektionern för
    <link linkend="language.types.array">Vektortypen</link> och 
    <link linkend="ref.array">Vektorfunktioner</link>.
   </para>
  </sect1>
  <sect1 id="language.operators.type">
   <title>Typoperatorer</title>
   <para>
    PHP har en enda typoperator: <literal>instanceof</literal>.
    <literal>instanceof</literal> används för att bestämma om
    ett givet objekt är av en specificerad 
    <link linkend="language.oop">objektklass</link>.
   </para>
   <simpara>
    <literal>instanceof</literal> lades till i PHP 5.
   </simpara>
   <informalexample>
    <programlisting>
<![CDATA[
<?php
class A { }
class B { }

$thing = new A;

if ($thing instanceof A) {
    echo 'A';
}
if ($thing instanceof B) {
    echo 'B';
}
?>
]]>
    </programlisting>
    <simpara>
     Eftersom <literal>$thing</literal> är ett objekt av typ A och inte av typ B
     så körs bara det blocket som kollar mot klass A att köras:
    </simpara>
    <screen>A</screen>
   </informalexample>
  </sect1>
 </chapter>
 
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->