cvs: phpdoc-sv /language constants.xml functions.xml

http://cvs.php.net/co.php/phpdoc-sv/language/constants.xml?r=1.1&p=1
Index: phpdoc-sv/language/constants.xml
+++ phpdoc-sv/language/constants.xml
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- EN-Revision: 1.35 Maintainer: jome Status: ready -->
 <chapter id="language.constants">
  <title>Konstanter</title>

  <simpara>
   En konstant är en identifierare (ett namn) med ett enkelt värde. 
   Precis som namnet antyder är det ett värde som inte kan ändras under 
   skriptets körning (med undantag för 
   <link linkend="language.constants.predefined">magiska konstanter</link>, 
   som egentligen inte är konstanter). En konstant är teckenkänslig som 
   standard. Enligt en allmänt accepterad uppfattning så 
   ska konstantnamnen <emphasis>alltid</emphasis>  skrivas med versaler.
  </simpara>
  <para>
   Namnet på en konstant följer samma regler som vilken variabel som helst  
   i PHP. Ett korrekt konstantnamn börjar med en bokstav eller ett 
   understreck, följt av ett antal siffror, nummer eller understreck. 
   Som ett reguljärt uttryck, skulle det uttryckas så här:
   <literal>[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*</literal>

   <!-- TODO: Example of valid & invalid constant names -->
  </para>
  <note>
   <simpara>
    En bokstav är här definierat som a-z, A-Z och ASCII-tecknen 127 till 255 
    (0x7f-0xff). Detta innebär att våra svenska tecken (å, ä och ö) 
    kan användas.
   </simpara>
  </note>

  <simpara>
   Liksom &link.superglobals; är konstanternas räckvidd global. Du kan 
   komma åt konstanter vart som helst i ditt skript utan att behöva tänka på 
   räckvidden. För mer information om räckvidd, läs mer i kapitlet om 
   <link linkend="language.variables.scope">räckvidd</link>.
  </simpara>

  <sect1 id="language.constants.syntax">
   <title>Syntax</title>
   <simpara>
    Du kan definiera en konstant genom att använda 
    <function>define</function>-funktionen. När en konstant har blivit 
    definierad kan den aldrig ändras eller bli odefinierad igen.
   </simpara>
   <simpara>
    Konstanter kan bara innehålla värden av datatyper som <type>boolean</type>, 
    <type>integer</type>, <type>float</type> och <type>string</type>
   </simpara>
   <simpara>
    Du kan få ut konstantens värde genom att helt enkelt skriva dess namn.
    I motsats till variabler ska du <emphasis>inte</emphasis> ha ett
    dollartecken (<literal>$</literal>) framför dess namn.
    Du kan också använda funktionen <function>constant</function> för
    att läsa en konstants värde om du vill kunna få namnet dynamiskt med hjälp
    av en variabel. Använd funktionen <function>get_defined_constants</function> 
    för att få en få en lista med alla definierade konstanter.
   </simpara>

   <note>
    <simpara>
     Konstanter och (globala) variabler ligger i olika namnutrymmen.
     Detta betyder att till exempel &true; och <varname>$TRUE</varname> 
     vanligtvis är olika.
    </simpara>
   </note>
   <simpara>
    Om du använder en odefinierad konstant så tror PHP att du menar
    namnet på själva konstanten som om det vore en <type>string</type> 
    (jämför KONSTANT och "KONSTANT").  Ett fel på 
    <link linkend="ref.errorfunc">E_NOTICE</link>-nivån kommer att utfärdas
    om detta händer. Läs också om varför 
    <link linkend="language.types.array.foo-bar">$foo[bar]</link> är
    fel att skriva (om du inte först definerat <literal>bar</literal> 
    som en konstant). Vill du se om en konstant är definierad kan du använda 
    funktionen <function>defined</function>.
   </simpara>
   <para>
    Skillnaderna mellan konstanter och variabler:
    <itemizedlist>
     <listitem>
      <simpara>
       Konstanter har inte ett dollartecken (<literal>$</literal>)
       före namnet;
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       Konstanter kan bara definieras genom att använda funktionen 
       <function>define</function> och inte genom vanlig tilldelning;
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       Konstanter kan definieras och kommas åt överallt utan hänseende 
       till räckvidder på variabler;
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       Konstanter får inte omdefinieras eller bli odefinierade när de
       väl har blivit satta; och
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       Konstanter får bara innehålla värden av enkla typer.
       (<type>boolean</type>, <type>integer</type>, 
       <type>float</type> och <type>string</type>)
       </simpara>
     </listitem>
    </itemizedlist>
   </para>

   <para>
    <example>
     <title>Definiera konstanter</title>
     <programlisting role="php">
<![CDATA[
<?php
define("KONSTANT", "Hej världen.");
echo KONSTANT; // skriver ut "Hello world."
echo Konstant; // skriver ut "Konstant" och utfärdar en notis.
?>
]]>
     </programlisting>
    </example>

   </para>
  </sect1>
  
  <sect1 id="language.constants.predefined">
   <title>Fördefinierade konstanter</title>

   <simpara>
    PHP tillhandahåller ett stort nummer av fördefinierade konstanter
    till alla skript den kör. Många av dessa konstanter är skapade av
    olika tillägg och kommer bara att finnas när dessa tillägg är 
    tillgängliga, vare sig de är dynamisk laddade eller om de är
    kompilerade tillsammans med PHP.
   </simpara>
   
   <para>
    Det finns fem magiska konstanter som ändras beroende på var
    de är använda. Ett exempel är värdet på 
    <constant>__LINE__</constant>. Den ändras för varje rad i 
    ditt skript. Dessa konstanter är teckenkänsliga. Här är en lista:
   </para>
   <para>
    <table>
     <title>Några "magiska" PHP-konstanter</title>
     <tgroup cols="2">
      <thead>
       <row>
        <entry>Namn</entry>
        <entry>Beskrivning</entry>
       </row>
      </thead>
      <tbody>
       <row>
        <entry><constant>__LINE__</constant></entry>
        <entry>
         Det aktuella radnummeret i filen.
        </entry>
       </row>
       <row>
        <entry><constant>__FILE__</constant></entry>
        <entry>
         Fullständig sökväg och namn till den aktuella filen.
        </entry>
       </row>
       <row>
        <entry><constant>__FUNCTION__</constant></entry>
        <entry>
         Det aktuella funktionsnamnet. (Det här lades till i PHP 4.3.0.)
        </entry>
       </row>
       <row>
        <entry><constant>__CLASS__</constant></entry>
        <entry>
         Det aktuella klassnamnet. (Det här lades till i PHP 4.3.0.)
        </entry>
       </row>
       <row>
        <entry><constant>__METHOD__</constant></entry>
        <entry>
         Den aktuella klassens metodnamn. (Det här lades till i PHP 5.0.0)
        </entry>
       </row>
      </tbody>
     </tgroup>
    </table>
   </para>

   <simpara>
    En lista på fördefinerade konstanter finns i kapitlet om 
    <link linkend="reserved.constants">reserverade konstanter</link>.
   </simpara>


  </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
-->


http://cvs.php.net/co.php/phpdoc-sv/language/functions.xml?r=1.1&p=1
Index: phpdoc-sv/language/functions.xml
+++ phpdoc-sv/language/functions.xml
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- EN-Revision: 1.44 Maintainer: jome Status: ready -->
 <chapter id="functions">
  <title>Funktioner</title>

  <sect1 id="functions.user-defined">
   <title>Användardefinierade funktioner</title>
 
   <para>
    En funktion kan definieras med följande syntax:
   </para>
   <para>
    <example>
     <title>Pseudokod för att demonstrera funktionsanvändning</title>
     <programlisting role="php">
<![CDATA[
<?php
function foo ($arg_1, $arg_2, /* ..., */ $arg_n)
{
    echo "Exempelfunktion.\n";
    return $retval;
}
?>
]]>
     </programlisting>
    </example>
   </para>
   
   <!--
    
    status of func(const $param) ?
    zend doesn't care at all whether or not you specify it.
    I've never seen it before... what's its use? (or was...)
    
    -->
     
   <simpara>
    Vilken giltig PHP-kod som helst kan förekomma inne i en funktion. 
    Till och med andra funktioner och 
    <link linkend="keyword.class">class</link>-definitioner.
   </simpara>
   <simpara>
    I PHP 3 så måste funktionerna vara definierade före de används. I 
    PHP 4 är detta inte nödvändigt. <emphasis>Förutom</emphasis> när en
    funktion är villkorligt definierad som de två exemplen nedan.
   </simpara>
   <para>
    När en funktion är definierad i ett villkorsblock som de två exemplen 
    visar så måste funktiondefinitionen köras <emphasis>före</emphasis>
    funktionen blir anropad.
   </para>
   <para>
    <example>
     <title>Villkorliga funktioner</title>
     <programlisting role="php">
<![CDATA[
<?php

$makefoo = true;

/* Vi kan inte anropa foo() from här
   eftersom den inte existerar än.
   Men vi kan anropa bar() */

bar();

if ($makefoo) {
  function foo ()
  {
    echo "Jag existerar inte innan programkörningen når mig.\n";
  }
}

/* Nu kan vi säkert anropa foo()
   eftersom $makefoo är satt till true */

if ($makefoo) foo();

function bar() 
{
  echo "Jag existerar direkt vid programstart\n";
}

?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    <example>
     <title>Funktioner inuti funktioner</title>
     <programlisting role="php">
<![CDATA[
<?php
function foo() 
{
  function bar() 
  {
    echo "Jag existerar inte förrän foo() har blivit anropad.\n";
  }
}

/* Vi kan inte anropa bar() än
   eftersom den inte existerar. */

foo();

/* Nu kan vi anropa bar(),
   foo() har körts och gjort
   bar() tillgänglig. */

bar();

?>  
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
    PHP stödjer inte funktionsöverlagring. Det är heller inte möjligt att 
    avdefiniera eller omdefiniera tidigare deklarerade funktion.
   </simpara>
   <note>
    <simpara>
     Funktionsnamn är inte teckenkänsliga men det är smartast och anses
     som god sed att anropa funktionen som den ser ut i deklarationen.
    </simpara>
   </note>   
   <simpara>
    PHP 3 stödjer inte funktioner med varierbart antal argument men
    stödjer standardvärlden för argument i funktioner (se 
    <link linkend="functions.arguments.default">standardvärden för 
    argument</link> för mer information). PHP 4 stödjer båda: se <link
    linkend="functions.variable-arg-list">Argumentlistor med varierbar 
    längd</link> och funktionsreferenserna för 
    <function>func_num_args</function>,
    <function>func_get_arg</function>, och
    <function>func_get_args</function> för mer information.
   </simpara>

  </sect1>
 
  <sect1 id="functions.arguments">
   <title>Funktionsargument</title>
 
   <simpara>
    Information kan skickas till funktioner via argumentlistan som
    är en kommaseparerad lista av variabler och/eller konstanter.
   </simpara> 
   <para>
    PHP stödjer värden skickas som argument (standard), <link
    linkend="functions.arguments.by-reference">skickas som 
    referens</link>, och <link
    linkend="functions.arguments.default">standardargumentsvärden
    </link>. Argumentlistor med varierbar längd stödjs bara i PHP
    4 och senare; se <link
    linkend="functions.variable-arg-list">Argumentlistor med 
    varierbar längd</link> och funktionsreferenserna för
    <function>func_num_args</function>,
    <function>func_get_arg</function>, och
    <function>func_get_args</function> för mer information. En 
    liknande effekt går att åstadkomma i PHP 3 genom att skicka
    en vektor med argument till en funktion.
   </para>
   <para>
    <example>
     <title>Skicka vektorer till funktioner</title>
     <programlisting role="php">
<![CDATA[
<?php
function tar_vektor($input)
{
    echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
]]>
     </programlisting>
    </example>
   </para>
 
   <sect2 id="functions.arguments.by-reference">
    <title>Gör så att argument skickas som referens</title>
 
    <simpara>
     Som standard skickas funktionsargument som värden (så om du ändrar
     argumentvärdet inuti funktion så ändras den inte utanför funktionen) 
     Om du vill tillåta funktionen att modifiera dess argument så måste du
     skicka argumenten som referens.
    </simpara>
    <para>
     Om du vill att ett argument till en funktion alltid skickas som
     referens så kan du sätta en ampersand (&amp;-tecken) före 
     argumentnamnet i funktionsdefinitionen:
    </para>
    <para>
     <example>
      <title>Skicka funktionsparametrar som referenser</title>
      <programlisting role="php">
<![CDATA[
<?php
function add_some_extra(&$string)
{
    $string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str;    // outputs 'This is a string, and something extra.'
?>
]]>
      </programlisting>
     </example>
    </para>
 
   </sect2>
 
   <sect2 id="functions.arguments.default">
    <title>Standardvärden för argument</title>
 
    <para>
     En funktion kan definiera standardvärden för argument precis 
     som i C++. Såhär fungerar det:
    </para>
    <para>
     <example>
      <title>Användning av standardvärden för argument i funktioner</title>
      <programlisting role="php">
<![CDATA[
<?php
function makecoffee ($type = "cappuccino")
{
    return "Making a cup of $type.\n";
}
echo makecoffee ();
echo makecoffee ("espresso");
?>
]]>
      </programlisting>
     </example>
    </para>
 
    <para>
     Utmatningen från exemplet ovanför ser ut såhär:
    </para>
    <para>
     <screen>
Making a cup of cappuccino.
Making a cup of espresso.
     </screen>
    </para>
 
    <simpara>
     Standardvärdet måste vara ett konstant uttryck alltså inte till
     exempel en variabel, en klassmedlem eller ett funktionsanrop.
    </simpara>
    <para>
     När man använder standardargument så bör dessa argument vara på 
     höger sida av de argument som inte använder standardargument, annars 
     kommer det inte att fungera som väntat. Titta på följande exempel:
    </para>
    <para>
     <example>
      <title>Felaktig användning av standardargument i funktioner</title>
      <programlisting role="php">
<![CDATA[
<?php
function makeyogurt ($type = "acidophilus", $flavour)
{
    return "Making a bowl of $type $flavour.\n";
}
 
echo makeyogurt ("raspberry");   // won't work as expected
?>
]]>
      </programlisting>
     </example>
    </para>
 
    <para>
     Utmatningen från exemplet ovanför blir:
    </para>
    <para>
     <screen>
Warning: Missing argument 2 in call to makeyogurt() in 
/usr/local/etc/httpd/htdocs/php3test/functest.html on line 41
Making a bowl of raspberry .
     </screen>
    </para>
    <para>
     Jämför nu exemplet ovanför med detta:
    </para>
    <para>
     <example>
      <title>Korrekt användning av standarargument i funktioner</title>
      <programlisting role="php">
<![CDATA[
<?php
function makeyogurt ($flavour, $type = "acidophilus")
{
    return "Making a bowl of $type $flavour.\n";
}
 
echo makeyogurt ("raspberry");   // works as expected
?>
]]>
      </programlisting>
     </example>
    </para>
 
    <para>
     Utmatningen från exemplet ovanför är:
    </para>
    <para>
     <screen>
Making a bowl of acidophilus raspberry.
     </screen>
    </para>

   </sect2>

   <sect2 id="functions.variable-arg-list">
    <title>Argumentlistor med varierbar längd</title>

    <simpara>
     PHP 4 har stöd för argumentlistor med varierbar längd i 
     användardefinierade funktioner. Det är riktigt enkelt faktiskt,
     använd bara funktionerna 
     <function>func_num_args</function>,
     <function>func_get_arg</function>, och
     <function>func_get_args</function>.
    </simpara>

    <simpara>
     Ingen speciell syntax krävs och argumentlistor kan fortfarande
     vara tillhandahållna i funktionsdefinitionerna och kommer att 
     fungera som normalt.
    </simpara>

   </sect2>

  </sect1>
 
  <sect1 id="functions.returning-values">
   <title>Returnera värden</title>
 
   <para>
    Värden returneras genom att använda den valfria returnstatsen.
    Alla typer kan returneras, även listor och objekt. 
    Returnsatsen gör så att funktionen avslutar sin körning 
    omedelbart och återger kontrollen till den rad som funktionen
    anropades från. För mer information, se 
    <function>return</function>.
   </para>
   <para>
    <example>
     <title>Använding av <function>return</function></title>
     <programlisting role="php">
<![CDATA[
<?php
function square ($num)
{
    return $num * $num;
}
echo square (4);   // outputs '16'.
?>
]]>
     </programlisting>
    </example>
   </para>
      
   <para>
    Du kan inte returnera flera värden från en funktion men
    du kan få en liknande effekt genom att returnera en lista.
   </para>
   <para>
    <example>
     <title>Returnera en vektor för att få flera värden</title>
     <programlisting role="php">
<![CDATA[
<?php
function small_numbers()
{
    return array (0, 1, 2);
}
list ($zero, $one, $two) = small_numbers();
?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    För att returnera en referens från en funktion måste du använda 
    referensoperatorn &amp; i både funktionsdeklarationen och när 
    du tilldelar returvärdet till en variabel:
   </para>
   <para>
    <example>
     <title>Returnera en referens från en funktion</title>
     <programlisting role="php">
<![CDATA[
<?php
function &returns_reference()
{
    return $someref;
}

$newref =& returns_reference();
?>
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
    För mer information om referenser, se 
    <link linkend="language.references">referenser förklarade</link>.
   </simpara>
  </sect1>
 
  <sect1 id="functions.variable-functions">
   <title>Variabelfunktioner</title>

   <para>
     PHP stödjer konceptet variabelfunktioner. Med det menas att om
     ett variabelnamn har parenteser efter sig så kommer PHP att leta
     efter en funktion med samma namn som variabelns innehåll och
     försöker, om den hittas, köra den funktionen. Det här kan bland 
     annat användas till att implementera callbacks, funktionstabeller.
   </para>
   <para>
    Variabelfunktioner kommer inte att fungera med språkkonstruktioner
    som <function>echo</function>, <function>print</function>,
    <function>unset</function>, <function>isset</function>,
    <function>empty</function>, <function>include</function>,
    <function>require</function> och liknande. Du måste använda dina
    egna wrapper-funktioner för att kunna utnyttja dessa konstruktioner
    som variabelfunktioner.
   </para>
   <para>
    <example>
     <title>Exempel på variabelfunktioner</title>
     <programlisting role="php">
<![CDATA[
<?php
function foo() {
    echo "In foo()<br />\n";
}

function bar($arg = '')
{
    echo "In bar(); argument was '$arg'.<br />\n";
}

// This is a wrapper function around echo
function echoit($string)
{
    echo $string;
}

$func = 'foo';
$func();        // This calls foo()

$func = 'bar';
$func('test');  // This calls bar()

$func = 'echoit';
$func('test');  // This calls echoit()
?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    Du kan också anropa objektmetoder genom att använda variabelfunktioner.
    <example>
     <title>Exempel på variabelmetoder</title>
     <programlisting role="php">
<![CDATA[
<?php
class Foo
{
    function Variable()
    {
        $name = 'Bar';
        $this->$name(); // This calls the Bar() method
    }
    
    function Bar()
    {
        echo "This is Bar";
    }
}

$foo = new Foo();
$funcname = "Variable";
$foo->$funcname();  // This calls $foo->Variable()

?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    Se också <function>call_user_func</function>,
    <link linkend="language.variables.variable">
    variable variables</link> och <function>function_exists</function>.
   </para>
  </sect1>
  
  <sect1 id="functions.internal">
   <title>Interna (inbyggda) funktioner</title>
   
   <para>
    PHP kommer som standard med många funktioner och konstruktioner. Det
    finns också funktioner som är specifika för PHP:s tilläggsprogram och
    kräver att dessa är kompilerade med PHP för att fungera. Anropar du dessa
    utan att ha tilläggsprogrammet så kommer du att få ett felmeddelande som 
    säger att funktioner inte är definierad. För att kunna använda
    <link linkend="ref.image">image</link>-funktioner som till exempel 
    <function>imagecreatetruecolor</function> så måste PHP vara kompilerat
    med stöd för GD. Eller för att använda 
    <function>mysql_connect</function> så måste ditt PHP vara kompilerat 
    med stöd för <link linkend="ref.mysql">MySQL</link>. Det finns många 
    kärnfunktioner som är inkluderade i varje version av PHP. Till exempel
    <link linkend="ref.strings">sträng</link>- och
    <link linkend="ref.variables">variabel</link>-funktioner.  Ett anrop 
    till <function>phpinfo</function> eller 
    <function>get_loaded_extensions</function> kommer att visa vilka
    tilläggsprogram som är laddade i ditt PHP. Notera också att det är
    många tilläggsprogram som är med i PHP som standard och att PHP-manualen
    är uppdelade med en sektion för varje tillägg.
    Se <link linkend="configuration">konfiguration</link>,  
    <link linkend="installation">installation</link> och tilläggsprogrammens
    kapitel för mer information om hur du kan konfigurerar ditt PHP.
   </para>
   <para>
    Att läsa och förstå en funktions prototyp är förklarat i manualdelen om
    <link linkend="about.prototypes">hur man läser en funktionsdefinition</link>.
    Det är viktigt att förstå vad en funktion returnerar eller om den arbetar
    direkt på ett skickat värde genom referenser. <function>str_replace</function> 
    kommer exempelvis att returnera en modifierad textsträng medan 
    <function>usort</function> arbetar direkt på den inskickade variabeln.
    Varje manualsida har också specifik information om varje funktion, dess
    parametrar, beteende, returvärden för både lyckad och icke-lyckad körning
    och i vilka PHP-versioner funktione finns tillgänglig i. Att förstå dessa viktiga 
    (och ofta hårfina) skillnader är livsviktigt för att kunna skriva en 
    korrekt PHP-kod.
   </para>
   <para>
    Se också <function>function_exists</function>, 
    <link linkend="funcref">the function reference</link>,
    <function>get_extension_funcs</function>, och 
    <function>dl</function>.
   </para>
  </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
-->