Automatikus és manuális nyelvválasztás


Ha az ember honlapot készít annak általában az az oka, hogy valamilyen információt meg akar osztani a világgal. Bizonyos esetben ezt nem csak egy nyelven szeretnénk megtenni. Ehhez ad ez a leírás segítséget.

Ha régebben egy adott honlap tartalma több nyelven kellett, hogy elérhető legyen, erre többnyire azt a megoldást szokták volt alkalmazni, hogy több aldomain alatt voltk elérhetőek a különböző nyelvű tartalmak és egy kezdőoldalon tudtuk kiválasztani, hogy melyik nyelven (aldomain) akartunk böngészni. Ennek előnye, hogy a látogató a saját nyelvén kezdhette meg a böngészést. Hátránya, hogy egy felesleges kezdőolalt kapunk, aminek már régen lejárt az ideje.

Manapság bevett szokás, hogy az oldal készítője alapértelmezettnek veszi saját anyanyelvét és menüpontok vagy kis zászlók segítségével tud a felhasználó a saját nyelvére váltani. Ez nem biztos, hogy szerencsés megoldás: ha nem elég egyértelmű a nyelvválasztás lehet, hogy a látogató tovább is áll, amint nem találja meg néhány másodpercen belül a nyelvválasztás lehetőségét.

Mivel ma egy komolyabb honlap esetében szinte biztosan adatbázisban tároljuk az adatokat és valamilyen szerver oldali nyelvet használuk az oldal dinamikus előállítására, tudunk annyira rugalmasak és felhasználóbarátak lenni, hogy a látogatóknak automatikusan a saját nyelvükön jelenítjük meg a tartalmat.

Két funkciót fogunk megvalósítani. Az egyik az automatikus nyelvválasztás lesz, a másik pedig az oldalon való manuális nyelvváltoztatás lehetősége.

Automatikus nyelvválasztás

Az egész megoldás azon a feltételezésen alapul, hogy a látogatónk böngészőjében az alapértelmezett nyelv a saját nyelve. Például egy magyar látogató elsődleges nyelve a magyar, egy németé a német, egy szlováké a szlovák és így tovább.

Először tehát kinyerjük a böngésző elsődleges nyelvét:

1
2
3
<?php
  $lang_id = substr($_SERVER['HTTP_ACCEPT_LANGUAGE'], 0, 2);
?>

Ezt követően a switch szerkezetet használjuk fel, hogy beállítsuk az oldal nyelvét, amit aztán cookie-ban tárolunk, majd onnan olvassuk be (a cookie-nak érdemes hosszabb lejáratot adni). A cookie beállítása után értéket adtam egy változónak. Ezt részben a kód átláthatósága miatt csináltam, részben pedig azért, mert a most beállított cookie csak az oldal újratöltése után érhető el (a HTTP protokoll működéséből fakadóan). Megtehettem volna, hogy egy header-rel újra meghívom az oldalt, de ez teljesen felesleges kérés lenne a szerver felé. A default részben adtam meg a magyar nyelvet, nem véletlenül. Ezzel egy lépésben oldottam meg, hogy ha a látogató magyar vagy bármilyen más, eddig fel nem sorolt nyelven szeretne tartalmat elérni akkor alapértelmezetten magyarul fog megjelenni a tartalom.

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
<?php
  switch ( $lang_id )
  {
    case "sk" : 
    { 
       setcookie("site_lang", "szlovak", mktime(0,0,0,1,1,2010));
       $site_lang = "szlovak"; 
    }
    break;
 
    case "cs" :
    {
       setcookie("site_lang", "cseh", mktime(0,0,0,1,1,2010));
       $site_lang = "cseh";
    }
    break;
 
    default :
    {
       setcookie("site_lang", "magyar", mktime(0,0,0,1,1,2010));
       $site_lang = "magyar";
    }
    break;
  }
?>

Eddig azt valósítottuk meg, hogy ha a látogató első alkalommal érkezik oldalunkra, akkor lekérjük böngészőjének elsődleges nyelvét, majd ez alapján beállítunk egy cookie-t, valamint egy változót a későbbi adatbázis-lekérések számára. Most egy if szerkezettel lekezeljük, hogy ha már van beállított cookie, akkor az abban tárolt értéket rendeljük hozzá a változóhoz. Ennek majd a későbbiekben lesz szerepe.

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
<?php
 if ( !$_COOKIE["site_lang"] ) 
 {
    # Kinyerjük a böngészőben beállított elsődleges nyelvet
    $lang_id = substr($_SERVER['HTTP_ACCEPT_LANGUAGE'], 0, 2);
 
    # A böngésző elsődleges nyelve alapján COOKIE létrehozása és az oldal nyelvének beállítása
    switch ( $lang_id )
    {
      case "sk" : 
      { 
         setcookie("site_lang", "szlovak", mktime(0,0,0,1,1,2010));
         $site_lang = "szlovak"; 
      }
      break;
 
      case "cs" :
      {
         setcookie("site_lang", "cseh", mktime(0,0,0,1,1,2010));
         $site_lang = "cseh";
      }
      break;
 
      default :
      {
         setcookie("site_lang", "magyar", mktime(0,0,0,1,1,2010));
         $site_lang = "magyar";
      }
      break;
    }
 }
 else
 {
    $site_lang = $_COOKIE["site_lang"];
 }
?>

Ezzel gyakorlatilag készen is van az automatius nyelvválasztás szerver oldalon.

Manuális nyelvváltás

Most jön a szkript másik fele amivel az oldalon való manuális nyelvváltást valósítjuk meg. A megoldás nem túl bonyolúlt, viszont érdekessége az, hogy bárhol is váltson nyelvet a látogató, ugyanoda tér vissza. Csak annyit fog észrevenni, hogy megváltozott az oldal nyelve, de nem kell újra kezdenie az oldalon való navigálást. Ezt általában javascript segítségével szokás megoldani, mégpedig úgy, hogy php-vel (vagy bármilyen más szerver oldali nyelvvel) generálnak egy JavaScript kódot, ami átirányítja a látogatót a másik nyelv aldomain-jére vagy egy GET paramétert fűz az URL-hez, ami jelzi az oldal számára, hogy milyen nyelven kell kiszolgálni a tartalmat (természtesen itt is történik átirányítás). Az aldomain-re irányítás nem a legszebb megoldás, a GET paraméter pedig teljesen felesleges.

Mivel rendelkezésünkre áll az az információ, hogy melyik oldalról hívták meg a nyelvváltást és van nekünk egy header függvényünk, szerver oldalon mindent el tudunk intézni. Ennek előnye, hogy letiltott JavaScript esetén és JavaScript-et nem támogató böngészővel is működik a manuális nyelvváltás.

Hátrány viszont, hogy néhány felhasználó tiltja a Referer küldést vagy direkt hamis ajánlót küldet, de elég minimális ezen emberek száma, és a helyzet hasonló ahhoz, hogy a Web 2.0 idején bárki még letiltja a JavaScript-et: aki ilyet csinál valószínűleg jó okkal teszi, és tisztában van a következményekkel – BlackY

Lássuk a kódot:

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
<?php
 $referer = $_SERVER["HTTP_REFERER"];
 switch ( $_GET["change_lang"] )  
 {
    case "magyar" :
    {
      setcookie("site_lang", "magyar", mktime(0,0,0,1,1,2010));
      header("Location: $referer");
    }
    break;
 
    case "szlovak" :
    {
      setcookie("site_lang", "szlovak", mktime(0,0,0,1,1,2010));
      header("Location: $referer");
    }
    break;
 
    case "cseh" :
    {
      setcookie("site_lang", "cseh", mktime(0,0,0,1,1,2010));
      header("Location: $referer");
    }
    break;
 }
?>

Az autómatikusan megállapított nyelvet tároló cookie értékét a GET-ben kapott nyelvre változtatjuk (jó hosszú lejárati idővel), majd a REFERER-ben kapott címre továbbítjuk a user-t a header függvény segítségével.

A manuális nyelvváltás linkje pedig így nézhet ki:

1
 index.php?change_lang=szlovak

És akkor lássuk az egész modul-t egyben:

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
<?php
################################################################################
#                   
#  Language Switcher Module
#
#  Last modified: yyyy.mm.dd.
#                   
################################################################################

 $referer = $_SERVER["HTTP_REFERER"];
 
 # Ha nyelválasztás történt a honlapon
 switch ( $_GET["change_lang"] )  
 {
    case "magyar" :
    {
      setcookie("site_lang", "magyar", mktime(0,0,0,1,1,2010));
      header("Location: $referer");
    }
    break;
 
    case "szlovak" :
    {
      setcookie("site_lang", "szlovak", mktime(0,0,0,1,1,2010));
      header("Location: $referer");
    }
    break;
 
    case "cseh" :
    {
      setcookie("site_lang", "cseh", mktime(0,0,0,1,1,2010));
      header("Location: $referer");
    }
    break;
 }
 
 # Ha még nincsen nyelv COOKIE beállítva, akkor létrehozzuk a böngésző elsődleges nyelve alapján
 if ( !$_COOKIE["site_lang"] ) 
 {
    # Kinyerjük a böngészőben beállított elsődleges nyelvet
    $lang_id = substr($_SERVER['HTTP_ACCEPT_LANGUAGE'], 0, 2);
 
    # A böngésző elsődleges nyelve alapján COOKIE létrehozása és az oldal nyelvének beállítása
    switch ( $lang_id )
    {
      case "sk" : 
      { 
         setcookie("site_lang", "szlovak", mktime(0,0,0,1,1,2010));
         $site_lang = "szlovak"; 
      }
      break;
 
      case "cs" :
      {
         setcookie("site_lang", "cseh", mktime(0,0,0,1,1,2010));
         $site_lang = "cseh";
      }
      break;
 
      default :
      {
         setcookie("site_lang", "magyar", mktime(0,0,0,1,1,2010));
         $site_lang = "magyar";
      }
      break;
    }
 }
 else
 {
   $site_lang = $_COOKIE["site_lang"];
 }
?>

Írta: Max Logan


Előzetes megbeszélé után egy kicsit kiegészíteném ezt a leírást: a benne található kód nagyon jó elképzelés alapszik, viszont két dolog nem tetszett benne: minden új nyelvnél külön esetet kell felvinni két helyre is, valamint én egy függvénybe írtam volna, hogy egy-egy oldalletöltéskor gond nélkül N alkalommal meghívható legyen.

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
<?php
function getLang() {
    /*
        Ebben a tömbben összeírjuk a nyelveket a megfelelő, böngésző által küldött nyelv-jelzőket használva kulcsokként
        Az első elem (itt: 'hu' => 'magyar') lesz az alapértelmezett nyelvünk
    */
    $languages = array('hu' => 'magyar', 'sk' => 'szlovak', 'cs' => 'cseh',);
 
    static $currentLang = null; // A statikus változók a függvény meghívásai között megőrzik értéküket
    if(!Is_null($currentLang)) { // Ha nem a kezdőérték (már lett módosítva)
        return $currentLang; // Visszaadjuk a $currentLang-ot, így csak egyszer kell ellenőrizni oldalletöltésenként
    }
 
    if(IsSet($_GET['change_lang']) && IsSet($languages[$_GET['change_lang']])) { // Nyelvváltoztatási kérelem
        setcookie("site_lang", $languages[$_GET['change_lang']], mktime(0,0,0,1,1,2010));
        $_SESSION['site_lang'] = $languages[$_GET['change_lang']];
        if(IsSet($_SERVER['HTTP_REFERER'])) {
            header("Location: " . $_SERVER['HTTP_REFERER']);      
            die();
        }
        else {
            header("Location: " . basename($_SERVER['SCRIPT_NAME']));
            die();
        }
    }
    elseif(IsSet($_COOKIE['site_lang']) && In_array($_COOKIE['site_lang'], $languages)) { // Süti alapú
        $currentLang = $_COOKIE['site_lang'];
        return $_COOKIE['site_lang'];
    }
    elseif(IsSet($_SESSION['site_lang']) && In_array($_SESSION['site_lang'], $languages)) {
        /* Végszükség esetére a munkamenetbe is elmetettük az adatot, ha a sütik le vannak tiltva, de url-en küldi a
    munkamenet azonosítót még mindig a megfelelő nyelven kapja. Így pl. a Google is tudja majd az összes nyelven olvasni
    weboldalunkat. */
        $currentLang = $_SESSION['site_lang'];
        return $_SESSION['site_lang'];
    }
    elseif(IsSet($_SERVER['HTTP_ACCEPT_LANGUAGE']) && IsSet($languages[$_SERVER['HTTP_ACCEPT_LANGUAGE']])) {
        /* Maradt az, hogy a felhasználó böngészőjére bízzuk a választást, feltéve, hogy hajlandó választani
        (küldi a megfelelő fejlécet) */
        $currentLang = $languages[$_SERVER['HTTP_ACCEPT_LANGUAGE']];
        return $languages[$_SERVER['HTTP_ACCEPT_LANGUAGE']];
    }
    else {
        /* Ha minden kötél szakad marad az alapértelmezett nyelv */
        return current($languages); // A $languages tömb első elemét adjuk vissza, ez az alapértelmezett nyelvünk
    }
}

Ha megnézzük ennek a kódnak a felépítése hasonló a Max Logan által írtéhoz, annyi különbséggel, hogy nincs benne switch szerkezet. Hogy hogyan is működik?

1
2
3
4
5
6
    $languages = array('hu' => 'magyar', 'sk' => 'szlovak', 'cs' => 'cseh',);
 
    static $currentLang = null;
    if(!Is_null($currentLang)) {
        return $currentLang;
    }

A $languages tömbünkbe tölthetjük fel a használt nyelveinket, kulcs => érték párosokat használva, ahol a kulcs az adott nyelvű böngészők által küldött nyelvkód (pl.: hu, sk, jp, en) az érték a nyelv neve. A következő két sor már érdekesebb: a static (statikus) kulcsszóval deklarált változók két függvényhívás között megőrzik értéküket: ezt fogjuk kihasználni, hogy csak egyszer kelljen végignézegetni, hogy mely nyelvet akarja a felhasználó használni. Ha nem egyezik meg az alapértékével (null) ezt adjuk vissza.

1
    if(IsSet($_GET['change_lang']) && IsSet($languages[$_GET['change_lang']]))

Ebben a részben a nyelvváltási kérelmet kezeljük le. Figyeljük meg, hogy már a feltételben ellenőriztük, hogy létezik-e az adott nyelv: ha a $languages-ben nincs $_GET[‘change_lang’]-al megegegyező kulccsú (pl.: hu, jp) elem lépünk a következőre.

1
    elseif(IsSet($_COOKIE['site_lang']) && In_array($_COOKIE['site_lang'], $languages))

Itt a sütit ellenőrizzük, létezik-e és az értéke megfelelő-e. Itt már a tömbelem értékét nézzük (in_array függvény), mivel a sütiben nem a tömbkulcsot, hanem az értékét tároltuk el korábban.

1
    elseif(IsSet($_SESSION['site_lang']) && In_array($_SESSION['site_lang'], $languages)) {

Ezt a részt elsősorban a Google és hasonló keresők miatt tettem bele: ezek ugyanis nem kezelik a sütiket (így a munkamenet sütiket sem), viszont az url-ek végére rendszerint beírják a munkamenet-azonosítót, következésképp a Google is tud nyelvet váltani.

1
    elseif(IsSet($_SERVER['HTTP_ACCEPT_LANGUAGE']) && IsSet($languages[$_SERVER['HTTP_ACCEPT_LANGUAGE']])) {

Itt a már ismert módszert, a felhasználó böngészője nyelvének ellenőrzését használjuk. Itt is azonnal ellenőrizzük persze, hogy érvényes nyelv-e, ha igen, ezt állítjuk be.

Maradt az else ág, ami akkor fog lefutni, ha az előzőek közül egyik sem: a felhasználó egy ismeretlen nyelvű böngészővel nézi az oldalunkat és nem váltott nyelvet.

Ha megnézzük a kódot minden ágban valami ilyesmi találunk:

1
        $currentLang = $languages[$_SERVER['HTTP_ACCEPT_LANGUAGE']];

Ez a sor mindig elmenti a megtalált nyelvet a korábban már static-al deklarált változónkba a nyelv értékét, így a getLang() következő meghívásakor azonnal ez kerül visszaadásra.

Felhasználás

Most, hogy már van egy nyelvcsere függvényünk már “csak” a valós nyelvkezelést kell megoldani. Mivel ahány rendszer annyi adattárolási módszer, erre általános megoldást nem tudunk adni, viszont néhány tippet adhatunk.

Switch

A legkézenfekvőbb megoldás a switch szerkezet használata 1-1 nyelvi elem kiírásánál. Viszont ennek használatával megintcsak frissítenünk kell több helyen a kódot, ha a új nyelvet viszünk fel.

1
2
3
4
5
6
7
8
9
10
11
Switch(getLang()) {
   case 'english':
      print 'Hello world!';
      break;
   case 'deutsch':
      print 'Hallo Welt!';
      break;
   default:
      print 'Helló Világ';
      break;
}
A nyelvi fájl

Bevett szokás, hogy a nem változó nyelvi sztringeket (pl.: “felhasználónév”, “adatlap”, “utolsó bejegyzés ideje” és hasonlók) nyelvi fájlokban tároljuk. Ezzel a nyelvrendszerrel ennek megvalósítása pillanatokba telhet:

1
2
3
4
5
6
if(file_exists('languages/' . getLang() . '.php')) {
  include 'nyelvek/' . strtolower(getLang()) . '.php';
  }
else {
  include 'nyelvek/magyar.php';
  }

Ha létezik az adott nyelvnek megfelelő nyelvi fájl (egy, a nyelvek könyvtárban levő, végig kisbetűs, nyelvneve.php nevű fájlt) akkor azt töltjük be, ha nem, akkor az alapot (itt: magyar.php). Ezekben a fájlokban egy tömbben az ilyen stringeket összeírhatjuk, pl.:

1
2
$lang['username'] = "Felhasználónév";
$lang['lastpost'] = "Utolsó bejegyzés ideje";

Minden nyelvünkhoz elkészítünk egy ilyen fájlt és kész vagyunk. Utána használhatjuk is pl. a $lang[‘username’]-t ott, ahol – a magyar oldalon – a “Felhasználónév” szót akarjuk kiírni.

A “switch-get-es” megoldás

A Switch-get név még mindig nem a legjobb, (a II-es óta nincs szó Switch-ről), viszont gyakori a használata. Ugyan a switch get III leírásban már van nyelvkezelés, a switch get II tutorialban leírt megoldással összehegeszthetjük mostani nyelvcsere-rendszerünket:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
$_GET['id'] = str_replace('../', '',$_GET['id'] );
$lang = strtolower(getLang());
if (isset($_GET['id']) and $_GET['id'] != '') {
    if (is_file("modulok/" . $lang . "/" . $_GET["id"] . ".php")) {
        chdir('modulok/' . $lang);
        include($_GET["id"] . ".php");
        chdir(dirname(__FILE__));
    }
    else {
    include("modulok/" . $lang . "/error.php");
    }
}
else {
    include ("modulok/" . $lang . "/kezdolap.php");
}
?>

Ekkor a fájlrendszerünknek így kellene kinézni:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[modulok]
   [magyar]
      error.php
      kezdolap.php
      galeria.php
      hirek.php
      ...
   [english]
      error.php
      kezdolap.php
      galeria.php
      hirek.php
      ...
   ...
index.php

Figyeljünk arra, hogy függetlenül attól, hogyan írtuk a getLang() kódjába a nyelvek nevét mindig kisbetűs könyvtárakat hozzunk létre a fentebb látható strtolower() miatt!

A csúnyább adatbázis megoldás

Ha már kész van az adatbázisunk, fut az oldalunk és nem akarunk módosítani az adatbázis-szerkezeten csinálhatjuk azt, hogy új adatbázisba visszük fel az új nyelvekhez tartozó táblákat/adatokat, majd az adatbázis-kapcsolódás után a nyelvtől függően választjuk ki az adatbázist. Pl.:

1
mysql_select_db('mydb_' . getLang());

Ez a megoldás – bár működőképes – hosszú távon nehezen tartható fenn (pl. admin felületünket is képessé kell tennünk több adatbázis kezelésére).

A szebb adatbázis megoldás

Ha most kezdjük fejleszteni oldalunkat, akkor a tábláinkat hozzuk létre úgy, hogy egy külön mezőbe eltároljuk, hogy az adott rekord milyen nyelvű adatot tartalmaz. Például:

1
2
3
4
5
6
7
CREATE TABLE `hirek` (
`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`cim` TEXT NOT NULL ,
`szoveg` TEXT NOT NULL ,
`ido` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ,
`nyelv` VARCHAR( 32 ) NOT NULL
) ENGINE = MYISAM ;

Egy ilyen táblából például a magyar nyelvű híreket egy ilyen kéréssel kérhetjük le:

1
SELECT * FROM `hirek` WHERE `nyelv`='magyar' LIMIT 0,10

Egy új feltételt vittünk fel, a nyelv-nél megadjuk a szükséges nyelvet. Ez alapján minden SQL-kérésünkbe felvihetjük ezt a plusz feltételt:

1
$q = mysql_query("SELECT * FROM `hirek` WHERE `nyelv`='" . getLang() . "' LIMIT 0,10");
Kapcsolódó bejegyzések:
  • A cikk előzményeként olvasd el ezt a 2 leírást (php switch get I. és php switch get II.). A fórumon felvetődött a kérdés: hogy lehetne megoldani a nyelvválasztás …

  • Ezt a kis kódrészletet azért osztom meg, mert sok javascriptes megoldást láttam már a dátum kiíratására. Alapból nekem nem tetszett, ahogy a php kiírja a date fü …

  • Az első kérdés, ami felmerül majdnem mindenkiben, hogy lehet egy többnyelvű honlapot megcsinálni, amin váltani lehet a nyelvek között. Vegyünk egy példát, van eg …

  • Egyszer mindenki elérkezik odáig, hogy több nyelvű honlapot kell készítenie. Ilyenkor jön a nagy kérdés, hogy adatbázissal csináljuk-e meg avagy sem. Ez a kérdés …

  • Gyakran látni a weboldalakon “vissza” linkeket. Általában ezek arra a helyre mutatnak, ahonnan valószínűleg jöhetett a felhasználó, rosszabb esetben JavaScript-e …

A cikket beküldte: Max Logan (http://)

6 hozzászólás

  1. hetes says:

    Automatikus nyelvválasztás(magyar-angol-német, alapértelmezetten magyar) esetén, a google az angol tartalmat fogja beindexelni és az amúgy fontos magyart figyelmen kívül hagyja? Létezik olyan megoldás ami seo szempontjából is megállja a helyét?

  2. András says:

    Spec amit most csinálok oldalt, ott nincsen csak manuális nyelválasztás, az nem fáradtság senkinek sem szerintem.
    De pl phpBB fórumadminként már láttam hogy, guglibot éppen látogatóba jött, szóval gondolom van valami módszer ami alapján neki adhatod azt a nyelvet amit ő vár.
    Bár így leírva, seoszempontbl a legjobb az lenne, hogyha mindent beindexelne.
    Szerintem a “keresés magyar oldalakon” épp ezért van.
    No mindegy

  3. hetes says:

    Akkor a legjobb gondolom az, ha mindegyik nyelv külön url-t kap és nem pedig egy url-en szolgálja ki a különböző nyelvű tartalmakat brózer alapján.

    /oldal
    /english/oldal
    /deutsch/oldal

    Azért sütiben még elmenthetem, hogy később automatikusan átirányítson. Pompás.

  4. Semmu says:

    Esetleg $_SERVER[‘USER_AGENT’]-ből meg lehet állapítani, hogy éppen hús-vér lény, vagy keresőrobot nézi-e az oldalt, és az alapján is lehet akkor már nyelvet állítani.
    szerintem :)

  5. Hami says:

    Sziasztok!

    Nekem egy olyan nyelvváltóra lenne szükségem ami 3 másodperc elteltével beirányít a lekért nyelvre. De semmiféle switchre és egyéb dologra nincs szükségem.

    Mindössze annyi, hogy bejön egy php lap legelőször amely azonosítás után behívná a megfelelő mappákat.

    Tehát hxxp://www.valami.hu/index.php fogad ez a fájl ellenőrzi, hogy honnan érkezett a látogató és ami után megállapította, tételezzük, hogy magyar akkor átirányítja a látogatót a nyelv_magyar/index.php -ra.

    Mindössze ezt szeretném megoldani. Tudtok segíteni?

  6. A says:

    Sziasztok!

    Jó a tutorial de egy dolgo nem értek. A static kulcsszó miért kell? Vagyis miért kell egy oldalletötlsésen belül többször meghívni a függvényt? Hiszen a static miatt az előző lefutás kimenetét kapjuk vissza újra. Vagy valamit rosszul értelmezek?

Szólj hozzá
a Automatikus és manuális nyelvválasztás c. bejegyzéshez

- Engedélyezett HTML elemek: <a> <em> <strong> <ul> <ol> <li>
- Forráskód beküldéséhez tedd a kódot ezek közé: <pre lang="php" line="1">Kódrészlet helye itt</pre>