Grundläggande: Skillnad mellan sidversioner

Från Wiki.linux.se
Hoppa till navigering Hoppa till sök
Ingen redigeringssammanfattning
Ingen redigeringssammanfattning
 
(15 mellanliggande sidversioner av samma användare visas inte)
Rad 1: Rad 1:
== Användning av namnrymder: Grunder ==
''(PHP 5 >= 5.3.0, PHP 7, PHP 8)''


= Grundläggande om variabler i PHP =
Innan vi diskuterar användningen av namnrymder är det viktigt att förstå hur PHP vet vilken element i namnrymden din kod begär. En enkel analogi kan göras mellan PHP-namnrymder och ett filsystem. Det finns tre sätt att komma åt en fil i ett filsystem:
Variabler i PHP representeras av ett dollartecken följt av variabelns namn. Variabelnamnet är skiftlägeskänsligt.


Variabelnamn följer samma regler som andra etiketter i PHP. Ett giltigt variabelnamn börjar med en bokstav eller ett understrykningstecken, följt av valfritt antal bokstäver, siffror eller understrykningstecken. Som ett reguljärt uttryck skulle det uttryckas så här: <code>^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$</code>
# Relativt filnamn som <code>foo.txt</code>. Detta löser sig till <code>currentdirectory/foo.txt</code> där <code>currentdirectory</code> är den katalog som för närvarande används. Om den aktuella katalogen är <code>/home/foo</code>, kommer namnet att lösas till <code>/home/foo/foo.txt</code>.
# Relativ sökväg som <code>subdirectory/foo.txt</code>. Detta löser sig till <code>currentdirectory/subdirectory/foo.txt</code>.
# Absolut sökväg som <code>/main/foo.txt</code>. Detta löser sig till <code>/main/foo.txt</code>.


Notera: För våra ändamål här är en bokstav a-z, A-Z och bytes från 128 till 255 (0x80-0xff).
Samma princip kan tillämpas på namnrymdselement i PHP. Till exempel kan ett klassnamn refereras på tre sätt:


Notera: <code>$this</code> är en speciell variabel som inte kan tilldelas. Före PHP 7.1.0 var indirekt tilldelning möjlig (t.ex. genom att använda variabla variabler).
* Okvalificerat namn, eller ett oprefixerat klassnamn som <code>$a = new foo();</code> eller <code>foo::staticmethod();</code>. Om den aktuella namnrymden är <code>currentnamespace</code>, löses detta till <code>currentnamespace\foo</code>. Om koden är global, icke-namnrymd kod, löses detta till <code>foo</code>. En varning: okvalificerade namn för funktioner och konstanter kommer att lösas till globala funktioner och konstanter om den namnrymda funktionen eller konstanten inte är definierad. Se ''[[Använda namnrymder: fallback till global funktion/konstant]]'' för detaljer.
* Kvalificerat namn, eller ett prefixerat klassnamn som <code>$a = new subnamespace\foo();</code> eller <code>subnamespace\foo::staticmethod();</code>. Om den aktuella namnrymden är <code>currentnamespace</code>, löses detta till <code>currentnamespace\subnamespace\foo</code>. Om koden är global, icke-namnrymd kod, löses detta till <code>subnamespace\foo</code>.
* Fullständigt kvalificerat namn, eller ett prefixerat namn med globalt prefixoperatör som <code>$a = new \currentnamespace\foo();</code> eller <code>\currentnamespace\foo::staticmethod();</code>. Detta löses alltid till det bokstavliga namn som specificeras i koden, <code>currentnamespace\foo</code>.


'''Tips:'''
Här är ett exempel på de tre typerna av syntax i faktisk kod:
Se även ''Userland Naming Guide''.


För information om funktioner relaterade till variabler, se ''Variable Functions Reference''.
<pre>
file1.php
<?php
namespace Foo\Bar\subnamespace;


<source lang="php">
const FOO = 1;
$var = 'Bob';
function foo() {}
$Var = 'Joe';
class foo
echo "$var, $Var";      // skriver ut "Bob, Joe"
{
 
     static function staticmethod() {}
$4site = 'not yet';     // ogiltig; börjar med ett nummer
}
$_4site = 'not yet';    // giltig; börjar med ett understrykningstecken
?>
$täyte = 'mansikka';    // giltig; 'ä' är (utökat) ASCII 228.
</pre>
</source>
Som standard tilldelas variabler alltid efter värde. Det betyder att när du tilldelar ett uttryck till en variabel, kopieras hela värdet av det ursprungliga uttrycket till destinationsvariabeln. Det innebär till exempel att efter att ha tilldelat en variabels värde till en annan, kommer ändringar av en av dessa variabler inte att påverka den andra. För mer information om denna typ av tilldelning, se kapitlet om ''Expressions''.


PHP erbjuder också ett annat sätt att tilldela värden till variabler: tilldela efter referens. Det betyder att den nya variabeln helt enkelt refererar till (med andra ord "blir en alias för" eller "pekar på") den ursprungliga variabeln. Ändringar i den nya variabeln påverkar den ursprungliga, och vice versa.
<pre>
file2.php
<?php
namespace Foo\Bar;
include 'file1.php';


För att tilldela efter referens, förbered bara ett ampersand (&) i början av variabeln som tilldelas (källvariabeln). Till exempel skriver följande kodsnutt ut 'Mitt namn är Bob' två gånger:
const FOO = 2;
 
function foo() {}
<source lang="php">
class foo
$foo = 'Bob';             // Tilldela värdet 'Bob' till $foo
$bar = &$foo;              // Referera $foo via $bar.
$bar = "Mitt namn är $bar";  // Ändra $bar...
echo $bar;
echo $foo;                // $foo är också ändrad.
</source>
En viktig sak att notera är att endast namngivna variabler kan tilldelas genom referens.
 
<source lang="php">
$foo = 25;
$bar = &$foo;      // Detta är en giltig tilldelning.
$bar = &(24 * 7);  // Ogiltig; referenser ett onämnd uttryck.
 
function test()
{
{
  return 25;
    static function staticmethod() {}
}
}


$bar = &test();   // Ogiltig.
/* Okvalificerat namn */
</source>
foo(); // löses till funktionen Foo\Bar\foo
Det är inte nödvändigt att initiera variabler i PHP, men det är en mycket god praxis. Oinitierade variabler har ett standardvärde av sin typ beroende på sammanhanget där de används - booleans standard till false, heltal och flyttal standard till noll, strängar (t.ex. använda i echo) sätts som en tom sträng och arrayer blir till en tom array.
foo::staticmethod(); // löses till klassen Foo\Bar\foo, metod staticmethod
 
echo FOO; // löses till konstanten Foo\Bar\FOO
'''Exempel #1 Standardvärden för oinitierade variabler:'''


<code>
/* Kvalificerat namn */
// Odefinierad OCH oanvänd (inget användningssammanhang) variabel; skriver ut NULL
subnamespace\foo(); // löses till funktionen Foo\Bar\subnamespace\foo
var_dump($unset_var);
subnamespace\foo::staticmethod(); // löses till klassen Foo\Bar\subnamespace\foo,
                                  // metod staticmethod
echo subnamespace\FOO; // löses till konstanten Foo\Bar\subnamespace\FOO


// Boolesk användning; skriver ut 'false'
/* Fullständigt kvalificerat namn */
echo $unset_bool ? "true\n" : "false\n";
\Foo\Bar\foo(); // löses till funktionen Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // löses till klassen Foo\Bar\foo, metod staticmethod
echo \Foo\Bar\FOO; // löses till konstanten Foo\Bar\FOO
?>
</pre>


// Stränganvändning; skriver ut 'string(3) "abc"'
Observera att för att komma åt någon global klass, funktion eller konstant kan ett fullständigt kvalificerat namn användas, till exempel <code>\strlen()</code> eller <code>\Exception</code> eller <code>\INI_ALL</code>.
$unset_str .= 'abc';
var_dump($unset_str);


// Heltalsanvändning; skriver ut 'int(25)'
=== Exempel #1: Åtkomst till globala klasser, funktioner och konstanter inom en namnrymd ===
$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int);


// Flyttalanvändning; skriver ut 'float(1.25)'
<pre>
$unset_float += 1.25;
<?php
var_dump($unset_float);
namespace Foo;


// Array-användning; skriver ut array(1) { [3]=>  string(3) "def" }
function strlen() {}
$unset_arr[3] = "def"; // array() + array(3 => "def") => array(3 => "def")
const INI_ALL = 3;
var_dump($unset_arr);
class Exception {}


// Objektanvändning; skapar nytt stdClass-objekt
$a = \strlen('hi'); // anropar den globala funktionen strlen
// Skriver ut: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }
$b = \INI_ALL; // åtkomst till den globala konstanten INI_ALL
$unset_obj->foo = 'bar';
$c = new \Exception('error'); // instansierar den globala klassen Exception
var_dump($unset_obj);
?>
</code>
</pre>
Att förlita sig på standardvärdet av en oinitierad variabel är problematiskt i fallet där man inkluderar en fil i en annan som använder samma variabelnamn. E_WARNING (före PHP 8.0.0, E_NOTICE) nivå fel ges i fall av att arbeta med oinitierade variabler, dock inte i fallet med att lägga till element till den oinitierade arrayen. ''isset()'' språkkonstruktion kan användas för att upptäcka om en variabel redan har initierats.


[[PHP]]
= Sidslut =
[[Språkreferens]]
Orginalhemsidan på Engelska : https://www.php.net/manual/en/language.namespaces.basics.php
[[Kategori:Php]]
<BR>[[PHP]]
<BR>[[Språkreferens]]
<BR>[[Språkreferens#Namnrymder]]
[[Kategori:Php]]<br>
<BR>
<hr>
Det här är en maskinöversättning av PHP-manualen till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på
https://www.linux.se/kontaka-linux-se/

Nuvarande version från 19 augusti 2024 kl. 10.49

Användning av namnrymder: Grunder

(PHP 5 >= 5.3.0, PHP 7, PHP 8)

Innan vi diskuterar användningen av namnrymder är det viktigt att förstå hur PHP vet vilken element i namnrymden din kod begär. En enkel analogi kan göras mellan PHP-namnrymder och ett filsystem. Det finns tre sätt att komma åt en fil i ett filsystem:

  1. Relativt filnamn som foo.txt. Detta löser sig till currentdirectory/foo.txt där currentdirectory är den katalog som för närvarande används. Om den aktuella katalogen är /home/foo, kommer namnet att lösas till /home/foo/foo.txt.
  2. Relativ sökväg som subdirectory/foo.txt. Detta löser sig till currentdirectory/subdirectory/foo.txt.
  3. Absolut sökväg som /main/foo.txt. Detta löser sig till /main/foo.txt.

Samma princip kan tillämpas på namnrymdselement i PHP. Till exempel kan ett klassnamn refereras på tre sätt:

  • Okvalificerat namn, eller ett oprefixerat klassnamn som $a = new foo(); eller foo::staticmethod();. Om den aktuella namnrymden är currentnamespace, löses detta till currentnamespace\foo. Om koden är global, icke-namnrymd kod, löses detta till foo. En varning: okvalificerade namn för funktioner och konstanter kommer att lösas till globala funktioner och konstanter om den namnrymda funktionen eller konstanten inte är definierad. Se Använda namnrymder: fallback till global funktion/konstant för detaljer.
  • Kvalificerat namn, eller ett prefixerat klassnamn som $a = new subnamespace\foo(); eller subnamespace\foo::staticmethod();. Om den aktuella namnrymden är currentnamespace, löses detta till currentnamespace\subnamespace\foo. Om koden är global, icke-namnrymd kod, löses detta till subnamespace\foo.
  • Fullständigt kvalificerat namn, eller ett prefixerat namn med globalt prefixoperatör som $a = new \currentnamespace\foo(); eller \currentnamespace\foo::staticmethod();. Detta löses alltid till det bokstavliga namn som specificeras i koden, currentnamespace\foo.

Här är ett exempel på de tre typerna av syntax i faktisk kod:

file1.php
<?php
namespace Foo\Bar\subnamespace;

const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>
file2.php
<?php
namespace Foo\Bar;
include 'file1.php';

const FOO = 2;
function foo() {}
class foo
{
    static function staticmethod() {}
}

/* Okvalificerat namn */
foo(); // löses till funktionen Foo\Bar\foo
foo::staticmethod(); // löses till klassen Foo\Bar\foo, metod staticmethod
echo FOO; // löses till konstanten Foo\Bar\FOO

/* Kvalificerat namn */
subnamespace\foo(); // löses till funktionen Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // löses till klassen Foo\Bar\subnamespace\foo,
                                  // metod staticmethod
echo subnamespace\FOO; // löses till konstanten Foo\Bar\subnamespace\FOO

/* Fullständigt kvalificerat namn */
\Foo\Bar\foo(); // löses till funktionen Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // löses till klassen Foo\Bar\foo, metod staticmethod
echo \Foo\Bar\FOO; // löses till konstanten Foo\Bar\FOO
?>

Observera att för att komma åt någon global klass, funktion eller konstant kan ett fullständigt kvalificerat namn användas, till exempel \strlen() eller \Exception eller \INI_ALL.

Exempel #1: Åtkomst till globala klasser, funktioner och konstanter inom en namnrymd

<?php
namespace Foo;

function strlen() {}
const INI_ALL = 3;
class Exception {}

$a = \strlen('hi'); // anropar den globala funktionen strlen
$b = \INI_ALL; // åtkomst till den globala konstanten INI_ALL
$c = new \Exception('error'); // instansierar den globala klassen Exception
?>

Sidslut

Orginalhemsidan på Engelska : https://www.php.net/manual/en/language.namespaces.basics.php
PHP
Språkreferens
Språkreferens#Namnrymder


Det här är en maskinöversättning av PHP-manualen till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på https://www.linux.se/kontaka-linux-se/