Ez az if($send) egy elég értelmetlen feltétel, főleg, hogy már ezelőtt a sor előtt az execute-tal végre próbálsz hajtani egy műveletet, és ha ez a változó mondjuk NULL, akkor már korábban kapsz erre az arcodba egy hibaüzenetet (mivel nyilván NULL értékkel rendelkező változón nem igazán lehet metódust meghívni). Meg azt írtad, dobódik egy kivétel, "Connection timed out" üzenettel. De másold már be a PONTOS, teljes hibaüzenetet!
Még valami:
$con = new PDO('mysql:host=mysql5.hostbase.net;dbname=artclubl_luminita','*','*');

HELYETT így kellene inicializálnod a PDO-t:

$con = new PDO(
'mysql:host=mysql5.hostbase.net;dbname=artclubl_luminita',
"*",
"*",
array(
PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES UTF8;',
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
)
);

A PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION azért érdekes, hogy kivétel dobódjon probléma esetén, és ne ilyen béna if-else ellenőrzésekre legyen szükség. Emiatt pedig try-catch blokkba kell raknod az egészet, és megfelelően loggolni a hibaüzeneteket.

Itt azt írod, hogy "direkt URL-lel" megy. Tehát ha szépen beírod a böngésződ címsorába, akkor az UPDATE-művelet is sikeresen lefut, nincsen időtúllépés?
Sőt, ha parancssorból hajtod végre, akkor is sikeresen lefut az UPDATE-művelet?
Magyarul egyedül akkor van probléma, ha a tárhelyszolgáltató admin-felületén szerkesztgetett, oda beírt ütemezett feladat futna le? Igazából erről olyan sok részletet nem osztottál meg, hogy hogyan csináltad, arra lehetne tippelni, hogy elrontottál valamit a szerkesztéskor, de tényleg csak tippelgetni lehet ennyi alapján.

(#16199) PumpkinSeed:
"Nem láttam még olyan oldalt aminek ez hozta volna meg a sikert."
Én igen, SoundCloud, YouTube, ...
(Jó, értem én... )

[ Szerkesztve ]

Sk8erPeter

1. Az if-nek az a története, hogy mikor anno ajánlottad a mysql_connect() helyett a PDO-t akkor még feltett szándékom volt NEM megtanulni a PHP-t így nem is nagyon néztem, hogy mit vágok ki a példakódokból... de át fogom írni úgy ahogy az előbb tanácsoltad...
2. Bemásoltam itt
3.Igen, ha beírom a böngésző címsorába írom vagy parancssorból futtatom akkor minden tökéletes.
4.A beírt parancsot is megosztottam (akkor te is hozzászóltál) és azt mondtátok, hogy jó... mást meg nagyon nem írhattam el mert a pontos idő beállítása grafikus felületen történik...

Egyébként azóta a szolgáltató közölte, hogy be kell állítani a portod de úgy se nagyon működik....

"Tigris, tigris, csóvafény éjszakáknak erdején, mily kéz adta teneked szörnyü és szép termeted?" -William Blake-

így módosították a parancsot és végre valahára működik
wget --delete-after http://artclublumir.com/cron/cron.php > /home/artclubl/public_html/cron/cron_log.txt

"Tigris, tigris, csóvafény éjszakáknak erdején, mily kéz adta teneked szörnyü és szép termeted?" -William Blake-

Lenne egy kérdésem, hátha valaki tud segíteni.
Éppen egy memcache üzenőfalat írok, tehát semmi féle sql nincs benne.
Az a bajom vele hogy mindig csak az új adatokat írja be, gyakorlatilag szépen írja is amit kell neki csak nem tudom hogy hogyan tároljam el a régieket is ...

Tehát van ez a sor:
$memcache->set("uzenofal", array("date" => time(), "class" => $class, "userid" => $userid, "username" => $username, "text" => $text), false, 999);

És nekem kellene a régi adat, tehát így mindig csak egy üzenet lesz eltárolva ami a legújabb, próbáltam úgy is hogy array("date" => time(), $cache["date"]) ...
De így se jó, nyilván az $cache = $memcache->get("uzenofal")-al ...
Aki ilyen nagy tömb szakértő vagy ért hozzá annak megköszönném ha segítene!

Szerk.:
Közbe rájöttem hogyha nem nem elválasztó jelekkel csinálom hanem ponttal tehát time() . $cache["date"] akkor így már jó ...
De nem tudom hogy írassam ki az adatokat.

[ Szerkesztve ]

Tömbök tömbjét tárolod mondjuk (a set() második paramétere)? Annyit kell csak tenned, hogy a túl régi üzeneteket mindig takarítsd ki előtte.

Ez már megoldva, de viszont hogy írassam ki???
Mert foreach() nem jó valamiért ...

Mutass kódot.

Ez a lényeg:
Adatokat innen nyerem ki:
$adatok = $memcache->get("uzenofal");

És így kiír mindent szépen.
print_r($adatok["date"] . "<br />" . $adatok["text"]);

De így egybe írja ki, nekem meg sor tördelve kell!

Lejárt a szerk. idő

De megnéztem így:
foreach($adatok as $array => $value) {
print($value . "<br />");
}

Így kiír mindent, de viszont úgy tördeli a sorokat ahogy vannak az értékek, azt nem tudom hogyan tudom kiolvasni külön-külön, tehát most egy sorban van egy adat.
Nekem meg úgy kellene hogy soronként és egy sor például: date, username, text

Nem tudom hogy hogyan tudnám megoldani.
Elég sokat terhel az SQL fal, és így szinte 0% load.

Már szó volt a tömbök tömbjéről, és ehhez értelemszerűen két egymásba ágyazott foreach-ciklusra lesz szükséged, hogy normálisan elérd a tömbben tárolt tömb kulcsait/értékeit. Már ha jól értem, mit szeretnél, hogy először csak mindent jól ki akarsz íratni, és annyi; bár lehet, hogy félreértelek, jó lenne tudni, nálad mit jelent az, hogy $value... (Na, látod, ez a hátránya az ilyen fos változóneveknek. ) Egyébként hogy értelmesen lásd, mit tartalmaz egy tömb, csak egy gyorsteszt erejéig debuggolhatnál, vagy írasd ki az értékét var_export()-tal, print_r()-rel, var_dump()-pal, stb... (Nyilván aztán amint megtudtad, mi van benne, ezeket a sorokat selejtezd ki, amúgy is illik inkább normálisan debuggolni a kódot, nem kiíratni minden hülyeséget.)
De lehetőleg felejtsd el az ilyen változóneveket, mint az $array, meg $value, mert ezek a nevek semmit nem mondanak a változók tartalmáról, így ha ránézel a kódra, mindig előbb el kell gondolkodni rajta, az mit is tartalmaz pontosan. Nem kell félni a hosszú, beszédes változónevektől, SŐT.

"Elég sokat terhel az SQL fal, és így szinte 0% load. "
Hát ha minden a memóriában tárolódik, és onnan is kell kiolvasni, akkor nem csoda, mivel semmiféle adatbázis-kapcsolódási, oda való feltöltési (lockolási, stb.) overhead nincs a dologban. Viszont ahogy Athlon64+ említette, épp emiatt ne felejtsd el a túl régieket törölni, különben szép kis memóriahasználatod lesz.

(#16205) kemkriszt98 :
Akkor fasza, ha megoldódott, viszont az echo után használj már szóközt, háthogynézezmárkianélkül.

[ Szerkesztve ]

Sk8erPeter

Néztem a var_dump-al és print_r-el is, szépen kiír mindent, de értelemszerűen ürítve lenne a fal, igazából naponta törlődne a memcache-ből az értéke, mellesleg txt fájlba van mentve minden napról mentés is hogyha valami fontosról volt szó vagy valaki káromkodott és törölte.

Meg próbálom ezt az "ágyazott foreach-ciklus"-t megvalósítani.
Köszi!

Ti ezt hogy íratnátok ki úgy hogy az id szerint törje a sorokat és hozzá legyen rendelve a text???

$tomb = array("id" => 1, 5, "text" => "valami", "mégvalami");

foreach($tomb as $kulcs => $value) {
echo $value . "<br />";
}

Van valami különösebb oka annak, hogy adatbázis helyett ezt a megoldást választottad?

but without you, my life is incomplete, my days are absolutely gray

Igen, főleg az hogy jóval gyorsabb lesz és érdekel is az adatok kiolvasása ...

Szerintem jó dolog, főleg a sebesség miatt is.
Nyilván jquery-vel látszik csak a különbség, de így is ennyi a különbség már.
SQL-el: 0.0481
Memcache-el: 0.0003

Ennek itt mi értelme van? Ha már tényleges felhasználás a cél, akkor miért nem egyértelműen használod fel a kulcsokat, miért általánosan akarsz végigmenni a tömbön? A másik, hogy remélem, ez a tömb csak példa, és nem úgy néz ki a gyakorlatban, hogy összekutyulva asszociatív tömb és numerikus kulcssal ellátott tömb egyben. Akkor már miért nincs az 5-nek, meg a "mégvalami"-nek is valami normális indexe? Ha tényleg nincs, hát akkor adjál nekik (nem egy CMS által generált kódot használsz, ahol néha ilyen ocsmány kutyult tömböket használnak, hanem te írod az egész kódot), ha van, akkor meg aszerint használd a kulcsokat, ne általánosan akarj végigmenni foreach-ciklussal. Legalábbis az elég furcsa, ha az a valódi felhasználás, hogy igazából nem is tudod egyértelműen már a kódból, hogy mi is van a tömbben.

Egyébként már írták neked, hogy használd tömbök tömbjét, miért nem teszed? Most nem is tudom, hogy működik a megoldásod (vagy ez csak példakód?). Sőt, ami szebb lenne, miért nem használod inkább objektumok tömbjét?
A tömbök tömbje mondjuk ilyen lehetne:
$conversations = array(
array("id" => 5, "text" => "asdasdasd"),
array("id" => 6, "text" => "blabla"),
);
de ez finoman szólva nem valami szép, inkább objektumok tömbje kéne. Szóval definiálnál egy osztályt, amiben értelmesen tárolhatnád az adatokat, lenne több attribútuma, aztán példányosítanád. Ezerszer nagyobb rugalmasságot kapnál cserébe.

(#16213) : Nem "ágyazott" foreach-ciklus, hanem EGYMÁSBA ágyazott ciklus. Ha nem lenne egyértelmű, ez két egymásba ágyazott foreach-ciklus (és ezt a végtelenségig lehet bővíteni):
foreach(...) {
foreach(...) {
// ...
}
}

(#16216) :
"Nyilván jquery-vel látszik csak a különbség"
Hogy mi van? Mégis mi a frász köze lenne a jQuery-nek a dolog gyorsaságához?

Sk8erPeter

Mivel ez az üzenőfal iframe-el működik ezért alapból túl nagy sebesség különbözet nincsen ránézésre.
Tehát egy átlag felhasználó nem fogja észre venni ...
Köszi, és megnézem!

Úgy értettem, hogy nem stimmel az a mondat, hogy "Nyilván jquery-vel látszik csak a különbség", mert nincs köze a jQuery-nek ahhoz, hogy miért gyors a dolog. Azért gyors, mert a memóriában tárolsz, onnan olvasol, és nincs ott az adatbázis-kezelési overhead. Plain JavaScripttel, meg teljesen más megközelítéssel is meg lehetne írni az egészet, a lényeg a gyorsaságban jelen esetben a szerveroldal (mert az a szűk keresztmetszet, a kliensoldali kód nyilván gyors, hacsak nem egy szutyok).

Jé, most lettem PH! félisten, atyaúristen.

[ Szerkesztve ]

Sk8erPeter

Megvilágosodtam kicsit, értem már hogy kell kiolvasni, de van egy problémám.
Hogy tároljam úgy hogy az előző üzenetek is megmaradjanak???
Mivel a memcache úgy működik hogy van 1 kulcsom és azon belül vannak az adatok.
Na most, hogy tároljam az előző üzeneteket is?
Így lehetne hogy $memcache->set("uzenofal", $_GET["text"] . $regiuzik

Csak így az a baj hogy nincsen elválasztva hanem egybe van az összes üzenet.
Mert . van ott, de ha beírom hogy , akkor nem menti el.

Ezt nem értem hogy lehetne ...

Úgy nézem hogy sajnos nem fog működni ez a full memcache üzenőfal.

$conversations = array(
array("id" => 1, "text" => "első üzenet"),
array("id" => 2, "text" => "második üzenet"),
array("id" => 3, "text" => "harmadik üzenet"),
array("id" => 4, "text" => "negyedik üzenet"),
);

foreach($conversations as $beszelgetes) {
echo $beszelgetes["id"] . " - " . $beszelgetes["text"] . "<br />";
$memcache->set("beszelgetes", array("id" => $beszelgetes["id"], "text" => $beszelgetes["text"]), false, 99);
}

$memoriaban = $memcache->get("beszelgetes");
var_dump($memoriaban);

Így megnéztem, és csak a negyedik üzenetet tárolja, tehát nem jó ...

Nem tudom hogy lehetne tárolni a régieket, mert máshogy nem lehet kiolvasni az összeset csak foreach-al.

[ Szerkesztve ]

Ő, de miért nem magát a $conversations tömböt tárolod, úgy, ahogy van?
http://php.net/manual/en/memcache.set.php
a függvény fejléce a doksiban:
bool Memcache::set ( string $key , mixed $var [, int $flag [, int $expire ]] )
Mint látható, a második paraméter "mixed", tehát nincs korlátozva, hogy milyen típust állíthatsz így be.
Próbáld ki ezt (nem tudom most tesztelni):

foreach($conversations as $beszelgetes) {
echo $beszelgetes["id"] . " - " . $beszelgetes["text"] . "<br />";
}

$memcache->set("beszelgetes", $conversations, false, 99);

A $conversations tömbhöz meg értelemszerűen hozzáadhatsz, illetve abból törölhetsz, aztán újból beállíthatod az előbbi módon (elvileg jónak kéne lennie).

Egyébként itt a harmadik paraméternél nem lenne jobb false helyett használni esetedben pl. a MEMCACHE_COMPRESSED vagy más konstanst?
http://stackoverflow.com/questions/2105663/what-is-compression-for-in-phps-memcache/2106096#2106096

U.i.: plíz használd a Programkód gombot, miután kijelölted a kódot! Köszi!

[ Szerkesztve ]

Sk8erPeter

Oké, mindjárt megnézem mit csinál erre.
Jó lenne nagyon ez a memcache üzenőfal.
Kicsit már lemondtam róla.

Na, így már faxa!!!

array(4) { [0]=> array(2) { ["id"]=> int(1) ["text"]=> string(11) "első üzenet" } [1]=> array(2) { ["id"]=> int(2) ["text"]=> string(14) "második üzenet" } [2]=> array(2) { ["id"]=> int(3) ["text"]=> string(15) "harmadik üzenet" } [3]=> array(2) { ["id"]=> int(4) ["text"]=> string(15) "negyedik üzenet" } }

Ezt adja vissza var_dump-al, tehát működik.
Már csak azt kellene megfejtenem hogy hogy mentsem el az új adatot és a régit egyben!

Fontolóra vehetnéd a Memcache::add metódust is, így az előbbi megoldás helyett, ahol egy nagy tömbben töltöd fel a beszélgetéseket, akár egyenként is feltölthetnéd, tehát így:

foreach($conversations as $conversation) {
echo $conversation["id"] . " - " . $conversation["text"] . "<br />";
$memcache->add('beszelgetes', $conversation, MEMCACHE_COMPRESSED, 99);
}

Próbát megér, még nem használtam, majd írd meg, ez mit eredményez, ha lekéred az adatokat. Így elvileg bármikor tudsz hozzáadogatni, nem írja fölül, mint a set.
(Ott van még a replace-metódus is egyébként, ha majd az kéne, de ezt próbáld meg előbb.)

Egyébként fontolóra vehetnéd valamilyen NoSQL-megoldás használatát is (mint pl. a mongoDB), az ilyen feladatokra szintén nagyon hatékony tud lenni (lásd Facebook).

[ Szerkesztve ]

Sk8erPeter

Kicsit megnézegettem ezt a Memcache->add-ot.
Ez kb. arra jó hogy egyszer beállít egy fix értéket, ami utána nem módosul, max. ha lejár a memcache ideje.
Akár mit írok be már nem írja felül az értékét a kulcs-nak.

Jelen esetben nem jobb mint a set ...

[ Szerkesztve ]

Közben kezdek rájönni a megoldásra.

$conversations = array(
array("id" => $id, "text" => $text),
foreach($cache as $ertek) {
array("id" => $ertek["id"], "text" => $ertek["text"]),
}
);
$memcache->set("uzenofal", $conversations, false, 999);

Tehát kell a tömb-be egy foreach ami külön létrehozza a sorokat és így tárol.
Így jó is lenne az üzenőfal szerintem!!! De viszont valami hiba van, mert semmit se jelez ...

Gondolom valami szintaktika hibás mert array(), foreach hááát ...

[ Szerkesztve ]

Jó, hát most nem tudom tesztelni, akkor használd a replace-t, úgy, hogy a módosított tömböt rakod a helyére, és kész, első megközelítésként jó lesz, aztán szépíted, ha lehet. Direkt azért linkeltem az előbb, ne csak a hsz. felét olvasd el.

(#16226) : Ez a kód most remélem csak egy rossz vicc volt!

[ Szerkesztve ]

Sk8erPeter

Nem értjük egymást.
Nekem az a problémám hogy nem tudom tárolni a régebbi bejegyzéseket is.
Mindig csak az ujjat írja fel, a régi megy a levesbe.

Tehát, a memcache set úgy működik hogy mindig újra írja az egész kulcs értékét.
Na most, így mindig elveszik az "előző" üzenet.

Tehát, valahogy tárolnom kell a GET tartalmát és a memcache előző tartalmát.
Így érted?

[ Szerkesztve ]

Tehát, egyszerű példával mutatom.

Van egy ilyen kódom:

$akarmi = array(
array("id" => 5, "text" => "mindegy"),
array("id" => 10, "text" => "asdasd"),
);

foreach($akarmi as $cucc) {
$conversations = array(
array("id" => $_GET["id"], "text" => $_GET["text"]),
array("id" => $cucc["id"], "text" => $cucc["text"]),
);
}

foreach($conversations as $beszelgetes) {
echo $beszelgetes["id"] . " - " . $beszelgetes["text"] . "<br />";
}

És ebből ez jön vissza:
1 - valamicske
10 - asdasd

Tehát, az 1-es mező az GET-el megvan adva, szóval
http://localhost/?id=1&text=valamicske

És amint látszik az 5-ös kimarad de a 10-est beírja.

Én értelek, csak te nem értesz. Miért nem kéred le felülírás ELŐTT az előző értéket, fűzöd hozzá ehhez a tömbhöz az új értékeket, és replace-eled EZUTÁN a korábbi tömböt? Első körben.
Vagy most az a baj, hogy ha csatlakozik egy másik kliens, akkor annál még nincs beállítva ez az érték, vagy mi?

[ Szerkesztve ]

Sk8erPeter

De, tehát ezt a szerver tárolja.
Szóval mindenki "kliens" látja.

"Miért nem kéred le felülírás ELŐTT az előző értéket, fűzöd hozzá ehhez a tömbhöz az új értékeke"

Ezzel próbálkozok, de nem megy ...

ÁÁÁÁÁÁÁÁÁÁÁ
De így most szupi!!!

$valami = array(
array("id" => $_GET["id"], "text" => $_GET["text"]));
foreach($valami as $gecike) {
$akarmi = array(
array("id" => $gecike["id"], "text" => $gecike["text"]),
array("id" => 5, "text" => "mindegy"),
array("id" => 10, "text" => "asdasd"),
);
}

Tehát most:
1valamicske
5mindegy
10asdasd

Ezt írja a böngésző és:
http://localhost/?id=1&text=valamicske

Szóval kiírja az összes értékét a tömb-nek, jöjjön a memcache rá és lássuk hogy jó-e.
Izgulok.

[ Szerkesztve ]

De már megint mi a frász ez a kód?
Miért raksz egy foreach-ciklust a tömb-definiálásba?

Csak hogy konkretizáljuk, én így értettem, hogy merge-ölöd a tömböt (tehát összefűzöd) a korábbi értékekkel, először lekérve a korábbi értéket, majd replace-elve (persze ellenőrizd először, hogy van-e már feltöltve egyáltalán ilyen érték!):

// korábbi értékek
// http://hu1.php.net/manual/en/memcache.get.php
// eszerint a get-nek array-t kell megadni, ha array-t vársz
$conversations_before = $memcache->get(array('uzenofal'));

// új értékek
$conversations_current = array(
array('id'=>1, 'text'=>'qwe'),
array('id'=>1, 'text'=>'ret'),
);

// ellenőrzöd, hogy van-e egyáltalán már ilyen érték feltöltve, mert csak akkor lehet replace-elni ezzel a kulccsal később!
// összefűzöd a két tömböt
$conversations = ($conversations_before !== FALSE) ? array_merge($conversations_before, $conversations_current) : $conversations_current;

// replace, ha van már ilyen kulcs, set, ha nincs még
if($conversations_before !== FALSE) {
$memcache->replace('uzenofal', $conversations, MEMCACHE_COMPRESSED, 999);
}
else {
$memcache->set('uzenofal', $conversations, MEMCACHE_COMPRESSED, 999);
}

Persze ezt most csak kézzel írtam, nem teszteltem, de a gondolatmenet remélem átjött.
Szóval vág?

[ Szerkesztve ]

Sk8erPeter

Most így szépen beírja, csak kiolvasni nem tudom eddig még.

array(2) { ["uzenofal"]=> array(2) { ["uzenofal"]=> array(2) { ["uzenofal"]=> array(2) { ["uzenofal"]=> array(2) { ["uzenofal"]=> array(2) { ["uzenofal"]=> array(2) { ["uzenofal"]=> NULL [0]=> array(5) { ["id"]=> int(1) ["username"]=> string(5) "coder" ["class"]=> int(8) ["userid"]=> string(1) "1" ["text"]=> string(3) "csá" } } [0]=> array(5) { ["id"]=> int(1) ["username"]=> string(5) "coder" ["class"]=> int(8) ["userid"]=> string(1) "1" ["text"]=> string(3) "asg" } } [0]=> array(5) { ["id"]=> int(1) ["username"]=> string(5) "coder" ["class"]=> int(8) ["userid"]=> string(1) "1" ["text"]=> string(5) "asdfh" } } [0]=> array(5) { ["id"]=> int(1) ["username"]=> string(5) "coder" ["class"]=> int(8) ["userid"]=> string(1) "1" ["text"]=> string(4) "asdh" } } [0]=> array(5) { ["id"]=> int(1) ["username"]=> string(5) "coder" ["class"]=> int(8) ["userid"]=> string(1) "1" ["text"]=> string(2) ":D" } } [0]=> array(5) { ["id"]=> int(1) ["username"]=> string(5) "coder" ["class"]=> int(8) ["userid"]=> string(1) "1" ["text"]=> string(2) "új" } } [0]=> array(5) { ["id"]=> int(1) ["username"]=> string(5) "coder" ["class"]=> int(8) ["userid"]=> string(1) "1" ["text"]=> string(2) ":D" } }

Mivel dupla tömb ezért így is próbálkoztam, de nem jó ...

$adat = $memcache->get("uzenofal");
foreach($adat as $valami) {
foreach($valami as $kulcsom) {
echo $kulcsom["text"];
}
}

[ Szerkesztve ]

Ez egy brutálisan egymásba ágyazott tömb (nem "dupla tömb", hanem sokszorosan egymásba ágyazott darab, az "uzenofal" kulccsal ellátott tömbbe beírtál egy másik "uzenofal" kulccsal ellátott tömböt, és abba egy továbbit, stb...), amiből egyértelműen következik, hogy rosszul történik a beírás. Ergo nem igaz az, hogy "szépen beírja", mert rossz.

[ Szerkesztve ]

Sk8erPeter

Én már nagyon megvagyok zavarodva.
Mellesleg felesleges a replace mert mindennek van külön ID-je és ahogy mondtam ez üzenőfal ...

Az adatokat var_dump-al kaptam, amúgy.

Bocs, este van már látom mi a baj ...

[ Szerkesztve ]

"Mellesleg felesleges a replace mert mindennek van külön ID-je és ahogy mondtam ez üzenőfal ..."
Ez hogy jön ide, hogy mindennek van külön id-je? Sehogy: eddig az volt a problémád, hogy a korábbi értékek egyszerűen törlődnek, mert szimplán felülírtad őket a Memcache::set metódussal. Arra kellett a replace, hogy a korábbi és az új értékek egyesítéséből keletkező tömbbel helyettesítsd a régebben feltöltött tömböt.
Így meg tudod tartani a régebbi és az új értékeket is. (Persze itt majd figyelj a memóriahasználatra, erre írtuk, hogy a túl régieket törölni kéne a memóriából, előtte esetleg beírva adatbázisba, ha meg akarod tartani hosszú távon, hogy visszakereshető legyen később.)

[ Szerkesztve ]

Sk8erPeter

Kicsit nézegettem, most így írja be, de szerintem ez se jó ...

array(1) { ["uzenofal"]=> array(2) { ["uzenofal"]=> array(2) { ["uzenofal"]=> NULL [0]=> array(2) { ["username"]=> string(5) "coder" ["text"]=> string(4) "heló" } } [0]=> array(2) { ["username"]=> string(5) "coder" ["text"]=> string(3) "asd" } } }

Köszi a segítséget.
Megoldódott!!!

Az array nem kellett a get-re.
Így jó!

Szívesen, de akkor másold már be légyszi azt a kódot (legalább egy körülbelülit), ami működik, ha már ennyit szenvedtünk vele... (Nekem most nincs kedvem agyalni a témán, de a megoldás érdekelne.)

(#16237) : Ja, nyilván nem jó, mert ötezerszer szerepel benne az "uzenofal" kulcs...

[ Szerkesztve ]

Sk8erPeter

Igen, csak este volt és már majdnem letöröltem mindent azért mert nem jött össze.

Oké, itt a működő kód.
$conversations_before = $memcache->get('uzenofal');

// új értékek
$conversations_current = array(
array('id' => rand(1,999999999), 'date' => time(), 'username' => $username, 'userid' => $userid, 'class' => $class, 'text'=> $text),
);

// ellenőrzöd, hogy van-e egyáltalán már ilyen érték feltöltve, mert csak akkor lehet replace-elni ezzel a kulccsal később!
// összefűzöd a két tömböt
$conversations = ($conversations_before !== FALSE) ? array_merge($conversations_current, $conversations_before) : $conversations_current;

// replace, ha van már ilyen kulcs, set, ha nincs még
if($conversations_before !== FALSE) {
$memcache->replace('uzenofal', $conversations, MEMCACHE_COMPRESSED, 999);
}
else {
$memcache->set('uzenofal', $conversations, MEMCACHE_COMPRESSED, 999);
}
}

$adatok = $memcache->get('uzenofal');
foreach($adatok as $eredmeny) {
if (get_user_class() >= UC_MODERATOR) {
$del="<span class='date' title='Törlés'><a href=/memcache_fal.php?del=".$eredmeny["id"]."><img src='pic/torles.gif' style='height:10px; border:none;' /></a></span>";
}
echo "<span class='date'>[".strftime("%H:%M",$eredmeny["date"])."]</span> $del <a href='javascript:window.top.SmileIT(\"[b]$eredmeny[username]:[/b]\",\"shbox\",\"shbox_text\")'><img style='height:10px; border:none;' alt='Válasz' title='Válasz' src='pic/jobbra.gif' /></a> <a href='$BASEURL/userdetails.php?id=".$eredmeny["userid"]."' target='_blank'>" . get_user_class_color($eredmeny["class"], $eredmeny["username"]) . "</a> " . format_shoutbox($eredmeny["text"]) . "<br />";
}

Viszont lenne még egy kérdésem.

A törlést nem tudom hogy oldjam meg.
Nagyon faintosan működik így is.
De amint látod az ID ahogy beírom az elég "random".

Mivel eddig volt egy ilyen megoldásom hogyha van értéke a memcache-nek akkor az id az növekvő, tehát $memcacheérték + 1 ha nincs akkor meg értelemszerűen 1-ről indul ...

Amúgy ez a compress asszem valami tömörítés a memcache-ben.
A memcache-ben még benne hagytam az idő-t, de azt majd kiveszem, mert csak akkor fog frissülni hogyha újat írnak be.

[ Szerkesztve ]

Tehát akkor mégis működik a kódom, amit mutattam? Ahogy elnézem, csak annyi különbség van, hogy a get-metódusnál nem array-t használsz, és hogyha ez így működőképes, az számomra arra utal, hogy hibás/hiányos a hivatalos dokumentáció:
http://hu1.php.net/manual/en/memcache.get.php
itt ezeket a fejléceket írja:
string Memcache::get ( string $key [, int &$flags ] )
array Memcache::get ( array $keys [, array &$flags ] )
Magyarul ezek szerint ha string kulcsot adsz meg, akkor stringet is kapsz vissza; de Te a kódod szerint tömböt kaptál vissza. Akkor itt a hivatalos doksiban kéne lennie még legalább egy mixed Memcache::get ( string $key [, int &$flags ] ) sornak is... Ez így logikus is lenne, hiszen a set-metódussal is mixed állítható be, így lekérésnél is nyilván mixed lehetne. Na, ezt is megtudtuk.

DE:
- jól érzed, ez az 'id' => rand(1,999999999) sor teljesen rossz. Mi van, ha a rand() eredményeként éppen olyan azonosító jön ki, ami már létezik? Sehol nem ellenőrzöd. De amúgy sem szokás sehol így generálni az azonosítót. Ja, és az azonosító nem feltétlenül kell, hogy szám legyen (lásd uniqid()), vagy ha mégis az kell, akkor oldd meg, hogy inkrementálva legyen, de akkor meg figyelni kell arra is, hogy ha több kliens is csatlakozik, akkor atomikusan történjen az inkrementálás, ne tudjanak korábbi/"kettő közötti" állapotot kiolvasni. Cél egyáltalán ezt feltölteni majd valami adatbázisba, hogy meglegyenek a régi adatok? Mert ha nem, szerintem simán használhatnád a uniqid() függvényt, és meg is vagy. Ha adatbázisba feltöltöd, ott max. akkor problémás, ha az id-hez egy automatikusan inkrementálódó int van beállítva; az nyilván nem fogadja el az angol ábécé karaktereit.
Az inkrementálós megoldáshoz nem ártana valami lockolás, hogy egyszerre csak egy kliens tudja módosítani az értéket, de simán megtehetnéd azt, hogy egyszerűen a set/replace-szel egy MÁSIK kulcsot állítasz be, ami ezt a számot tárolja, azt lekéred, megnöveled, stb.
- minek kéred le a replace/set után még egyszer az adatokat a get-metódussal? Hiszen már ott van a $conversations-tömbödben. Mondjuk annyiból jó lehet, hogy ha közben más kliens módosította az adatokat, akkor azt is megkapod...
- erre a feladatra szerintem tényleg jobb lenne valami NoSQL-megoldás, amiről korábban írtam.

"Amúgy ez a compress asszem valami tömörítés a memcache-ben."
Igen (MEMCACHE_COMPRESSED), de ezt szerintem hagyd ott szépen, ahogy mutattam, lásd:
http://stackoverflow.com/questions/2105663/what-is-compression-for-in-phps-memcache/2106096#2106096

[ Szerkesztve ]

Sk8erPeter

Nagyon köszi az eddigi segítséged.

Egy kérdésem van, hogy szedjem ki az adott tömbömből azt az értéket amit valaki törölni akar?

Mondjuk van 40. üzenet, és valaki kitörli a 35.-et, akkor azt hogy???

Ezt meg tudnám oldani, de nem értem hogy hogy vegyem ki, mert nyilván memcache->delete kellene, de nem tudom hogy mert ezért van az ID, hogy behatároljuk hogy hova tartozó az üzenet.

Gondolkodom erősen, ha van ötleted akkor ...

Szívesen!
Jó a felvetés, legegyszerűbb (még ha nem is szép) megoldás jelen esetben az lenne, ha maga az azonosító lenne a tömbindex, és annak értéke pedig az adatokat tartalmazó tömb lenne. Ez továbbra is tömbök tömbje, ahogy a korábbi megoldás is volt, csak annyi különbséggel, hogy itt explicite meghatározod a tömbindexet, nem pedig az automatikus számozásra bízod (mivel eddig numerikus indexek voltak használva, 0, 1, 2, ...).
Tehát valahogy így, pszeudokóddal:

$conversations = array(
AZONOSÍTÓ1 => array(
"text" => "asdasd",
),
AZONOSÍTÓ2 => array(
"text" => "blabla",
),
AZONOSÍTÓ3 => array(
"text" => "qweqwe",
),
);

az AZONOSÍTÓ1, AZONOSÍTÓ2, stb. kulcs lehet szám, vagy lehet egy string is (attól függően, milyen típusú azonosítót használsz).
Akár redundánsan is tárolhatod az azonosítót, úgy, hogy pl.:

AZONOSÍTÓ3 => array(
'id' => AZONOSÍTÓ3,
'text' => 'qweqwe',
),

Ez bizonyos esetekben leegyszerűsítheti a dolgot, persze figyelni kell rá, hogy ez konzisztens maradjon, ne legyen egyik helyen ilyen azonosító, másik helyen amolyan.
Egyébként tényleg érdemes lehet bevezetni egy osztályt, hogy szebben tudd tárolni és kezelni az adatokat.

Jelen esetben ezzel az egyszerű megoldással tehát úgy tudnád törölni, hogy egyszerűen írsz egy unset($conversations[AZONOSÍTÓ3]); sort, ezzel kitörölve az adott tömbindexet, és ezután replace-eled a korábbi tömböt a memcache-ben, és meg is vagy.

Itt is egyébként figyelni kell arra, nehogy egy másik csatlakozott kliens egy korábbi kiolvasott adatból tudjon beírni, úgy, hogy visszarakja valahogy ezt az értéket a tömbbe...
Ezért is mondom, hogy szebb megoldást továbbra is valamilyen NoSQL-megoldással lehetne készíteni.

Sk8erPeter

Zsír, meg is oldottam megint a kiegészítéseddel a problémát!

Így néz ki a törlés része:

if (isset($_GET['del'])){
$conversations = $memcache->get('uzenofal');
unset($conversations[$_GET['del']]);
$memcache->set('uzenofal', $conversations, MEMCACHE_COMPRESSED, 999);
}

És így a bevitel:

$conversations_current = array($azonosito =>
array('id' => $azonosito, 'date' => time(), 'username' => $username, 'userid' => $userid, 'class' => $class, 'text'=> $text),
);

Tehát a tömb azonosítója megegyezik a tömb-ben tárolttal és így simán ki lehet olvasni mindent, és uniqid()-vel fut szépen!

Már csak egy utolsó dolog van vissza, nem tudom hogy limitáljam max. 40 üzenetet akarok megjeleníteni, de nem tudom hogy tudnám így a tömbök miatt.

Fasza, ha működik.

Általános gyakorlat az, hogy a szuperglobális tömböket NEM használjuk fel közvetlenül, alaposan validáljuk előtte.

"Már csak egy utolsó dolog van vissza, nem tudom hogy limitáljam max. 40 üzenetet akarok megjeleníteni, de nem tudom hogy tudnám így a tömbök miatt."
Hát úgy, hogy a tömb utolsó 40 elemét veszed. Pl. array_slice-t használhatsz erre a célra. Egy egyszerű példa:
http://stackoverflow.com/questions/5468912/php-get-the-last-3-elements-of-an-array/5468954#5468954
Természetesen neked nem 3 kell, hanem 40.
DE arra figyelj, hogy előtte count()-tal ellenőrizd le, hogy több eleme van-e, mint 40, és ha igen, csak akkor szabdald fel, és vedd az utolsó 40 elemét.

Viszont az is lehet, hogy ezt már érdemes lenne vagy a memcache-nek egy külön kulcsa alatt tárolni, vagy adatbázisba pakolni, és kitörölni a memóriából, mert ha úgysem érdekes jelen esetben, akkor minek terpeszkedjen a memóriában feleslegesen.

Sk8erPeter

Így nem egyszerűbb???

echo "Összesen: " . $valami . " üzenet van beküldve!<br />";
$szam = 1;
foreach($adatok as $eredmeny) {
if (get_user_class() >= UC_MODERATOR) {
$del="<span class='date' title='Törlés'><a href=/memcache_fal.php?del=".$eredmeny["id"]."><img src='pic/torles.gif' style='height:10px; border:none;' /></a></span>";
}
echo "<span class='date'>[".strftime("%H:%M",$eredmeny["date"])."]</span> $del <a href='javascript:window.top.SmileIT(\"[b]$eredmeny[username]:[/b]\",\"shbox\",\"shbox_text\")'><img style='height:10px; border:none;' alt='Válasz' title='Válasz' src='pic/jobbra.gif' /></a> <a href='$BASEURL/userdetails.php?id=".$eredmeny["userid"]."' target='_blank'>" . get_user_class_color($eredmeny["class"], $eredmeny["username"]) . "</a> " . $eredmeny["text"] . "<br />";
if ($szam++ == 20) break;
}

És kész is!
Köszi még egyszer!

[ Szerkesztve ]

Hát itt 20-at jelenítesz meg, 40-et akartál. De végül is oké. Amúgy azt hittem, csak a csatlakozott kliensnek akarsz megjeleníteni ennyit, az fura, ha pont az adminnak kevesebbet jelenítesz meg, mint amennyi van, legalább biztosíts lehetőséget a továbbiak törlésére (lapozásra) is az adminnak.
Ez az >= UC_MODERATOR kicsit fura feltétel, szerepköröknek kellene lennie, és akinek van joga törölni, csak az törölhessen, ebből még gond származhat, ha ilyen "nagyobb-egyenlő, mint valami konstans" feltételt raksz be (mi van, ha bővíted a szerepköröket, és nagyobb számot kell rendelni valami másik szerepkörnek, akinek nem kéne, hogy joga legyen a törléshez) - csak egy szerepkör legyen, aki tud törölni, ezt rendelgesd hozzá júzerekhez, és annak az egyenlőségét ellenőrizd inkább.
És ez továbbra is csak egy átmeneti megoldás, csak hogy működjön a dolog legalább, ennél azért jóval szebben is lehet, hogy ne mindig nagy tömbökkel operálj, szóval majd később ezt a megoldást azért szépítsd.
De örülök, ha sikerült működésre bírni, szívesen.

Sk8erPeter

Az csak egy példa volt, már 40 van megjelenítve.
A rang pedig jó, pont az a lényeg hogy ami SQL-ben megvan adva az szerint van UC_CLASS

Külön van definiálva...

De attól még akkor sem jó így, az előző magyarázatot továbbra is fenntartom... Úgy szokás, hogy hozzárendelsz egy-egy szerepkört a júzerekhez, ami egy tágabb fogalom, benne foglaltatik pl. az is, hogy ő törölhet, módosíthat, blabla, ő csak módosíthat, de nem törölhet, és így tovább... tehát azt érdemes ellenőrizni, hogy az adott júzernek van-e konkrétan olyan joga (nem szerepköre, mert a szerepkör tágabb fogalom, amiben több jogosultság is benne lehet), hogy töröljön. Na mindegy, ez csak egy javaslat, érdemes lehet megfontolni, hogy később ne legyenek problémáid belőle.

Sk8erPeter

Lenne egy érdekesség amit most vettem észre.
Ezeken az üzeneteken van formázás, amibe nagyon sok str_replace van.

Gyakorlatilag alapból a fal lefut ez a formázás nélkül: 0.0009 alatt.

De így ezzel a formázással tehát ami be teszi a smileyeket meg ilyesmiket így már 0.02 vagy 0.06, tehát jóval nagyobb mint előtte.

És elvileg soronként értelmezi a foreach miatt, nem tudom hogy ezen lehet-e egyszerűsíteni ...