Jquery Multidimenziós tömb a PHP oldalon

Jquery Multidimenziós tömb a PHP oldalon
2013-05-18T23:13:26+02:00
2013-05-19T12:27:05+02:00
2022-11-29T01:55:39+01:00
Fulop
Sziasztok!

Szóval egy multidimenziós tömböt szeretnék elküldeni a PHP oldalra. A Jquery oldalon a tömb az teljesen jó, megtudom jeleníteni és hozzá is tudok tenni. Mikor a push megtörténik utána indítok el egy funkciót amiben szépen megjelenítem a tömb adatait egy console.log - ban.

Itt alul az array az szépen átkerül a php oldalra és szépen megjelenik ott.

Viszont amit a jquery-ben elkészítek és amit meg is jelenítek még a GET előtt a jquery oldalon na az nem megy át.

Ha var array helyett beírom a jquery_array-t az nem megy át.

Köszönet.

var array = {"item4":{"poster4":"poster","logged_in4":"logged_in"}}; $.ajax({ type: "GET", url: 'upload3.php', async: false, cache: false, contentType: "application/json; charset=utf-8", data: {json: JSON.stringify(array)}, dataType: "json", success: function (response) { console.log(response.d); }, error: function (response) { console.log(response.statusText); } })
Mutasd a teljes hozzászólást!
"
Viszont érted nekem nem egy fix array kell, hanem amit a jquery-vel elkészítek és amit itt alul látsz.
"

hol?

te minden példakódodban hagyományos objektumokat használsz (amelyek persze js-ben asszociatív tömbként viselkednek, azaz ún.
square bracket notation
-nal hivatkozhatsz a kulcs-érték párokra, de nem "valódi" tömbök), az összes literálod ilyen, ennélfogva például (alapértelmezetten) nincs
length
property-jük szerintem,

szerintem kevered a szezont a fazonnal (objektum <-> tömb (persze a tömb is objektum)), ezért nem működik a kódod, szerintem,

ha pld. a
jsonarray
-ed egy olyan objektum, amelyikben a
one
property-hez egy 1 elemű tömb tartozik, akkor teljesen érthető az, hogy magát a tömböt átadva (lásd a
data: {json: JSON.stringify(jsonarray.one)}
-t) a
one
"nullaként" jelenik meg a szerver oldalon, mert nem a teljes objektumot adtad át, hanem csak a tömböt, szerintem, és ezért nem fog a teljes objektumot átadva a szerver oldali szkripted működni, mert azt nem ennek megfelelően írtad meg.

de mivel nem tudjuk, hogy a
jsonarray
objektumod az valójában hogyan nézz ki, legalábbis én nem látom, ezért csak találgathatunk,

a js-es log-olós kódod alapján persze felételezhetjük, hogy valami ilyesmi (mivel hivatkozol a
length
property-re, az meg egy "sima" objektumnak csak akkor van, ha definiáltad, azaz szerintem itt használnál "valódi" tömböt):
var jsonarray = {one: [{user:"John", age:22, country:"United States"}]};
ezt az általad írt kliens oldali szkript és a szerveroldali is be tudja járni, ha az utóbbinak a
JSON.stringify(jsonarray.one)
-nal adod át a json "értékét", és úgy fog viselkedni ahogyan tapasztaltad,

ekkor, ha a teljes objektumot át akarod adni, akkor a szerveroldalon nem úgy kell bejárnod, ahogyan próbálkoztál, hiszen ekkor a json stringed a következő lesz:
'{"one":[{"user":"John", "age":22, "country":"United States"}]}
, szerintem, azaz még egy ciklusra lesz szükséged, mivel a
$v
maga is egy tömbként jelenik meg a szerver oldalon,

mondjuk azt nem egészen értem, hogyha ez a helyzet, akkor miért ilyen az átadandó objektumod, miért nem csak a tömböt adod át, stb.

szerkesztve: közben "leesett", hogy vélhetőleg te php-s oldalról közelíted meg a js-t, ezért használod a tömb elnevezést ott is, ahol nem lenne indokolt, szerintem, mivel úgy-e a php-ban a tömb rendezett kulcs-érték párok sokasága, azért is gondolom ezt, mivel a kliens oldalon, a js szkriptben is használsz a property-k (a "kulcs"-ok) megadásánál idézőjeleket, de valójában nincs rájuk szükség (legalábbis akkor, amikor definiálod az objektumodat),
Mutasd a teljes hozzászólást!

  • Szia!

    Én a kódrészletben nem látok jquery_array-t. Mit tartalmazna az?
    Másrészt nem kötözködni akarok, de lehetne szerver és kliens oldalnak hívni a php/jquery oldalt?

    Ha leírod, hogy mi van a jquery_array-ben (ami nem is tömb, hanem egy OBJEKTUM!), akkor bizonyára tudunk segíteni.

    MI
    Mutasd a teljes hozzászólást!
  • Szóval

    data: {json: JSON.stringify(jsonarray.one)},

    Tehát a jsonarray multidimenziós tömb egy belső tömböt tartalmaz a one-t. Tesztnek egy tömböt készítek egy belső tömbbel.

    Tehát elkészítek jsonarray tömböt és hozzáadom a one-t.

    Utána megjelenik a kliens oldalon teljesen jól a for ciklusban.

    data: {json: JSON.stringify(jsonarray)}, Így nem megy át.

    Így pedig átmegy, és így jelenik meg:

    data: {json: JSON.stringify(jsonarray.one)},

    Tehát a ONE-t azt nullaként jelenik meg a PHP oldalon, de alatta a teszt adatok azok jók.

    0

    user | 21
    age | 22
    country | United States
    Mutasd a teljes hozzászólást!
  • Szia!

    Szerintem szerveroldalon csak simán print_r()-el írasd ki a $_REQUEST-et, (ill. ha megvan a json string, akkor persze azt is és nézd meg a struktúráját.). Kapsz js hibát? A nem megy alatt mit értesz? Nem küldi el a js? Megáll a js? Synthax error? Ha chrome-ot használsz ott a console, ff alatt meg firebug és nézd meg mit ír. Ill. chrome és ff alatt is haszálhatod a console.log() és .dir() metódusokat.
    console.log("Objektumom: " + jsonarray);
    Meg bemásolhatnád a teljes kódot, mert lehet ennyi erővel js hiba, php hiba, hálózat hiba, stb... is.

    MI
    Mutasd a teljes hozzászólást!
  • Jquery - nél van sikeres funkció nincs error.

    Ez átkerül a PHP-hez: var array = {"test":{"poster":"poster","logged_in":"logged_in"}};

    Viszont érted nekem nem egy fix array kell, hanem amit a jquery-vel elkészítek és amit itt alul látsz.


    Itt pedig nincs semmi a jsonarray-nál.

    console.log('Objektumom:' + jsonarray +'');


    Pedig itt meg van:


    for(var key in jsonarray) { console.log('Külső Array Name: ' + key + ' '); for(var i = 0; i < jsonarray[key].length; i++) { for(var belso_array_key in jsonarray[key][i]) { console.log('' + belso_array_key + ' | ' + jsonarray[key][i][belso_array_key] + ''); } } }
    Mutasd a teljes hozzászólást!
  • A PHP oldalon meg így jelenítem meg.

    Ha a json-nál ezt adom meg tesztként : '{"u1":{"user":"John", "age":22, "country":"United States"}}';

    Akkor szépen megjelenik. Egyszerűen nem jövők rá arra, hogy miért nem tudom ugyanezt az adatot a tartalmazó tömböt átküldeni a PHP-nek.

    $json = $_POST["json"]; $_SESSION["decoded11"] = $json; $cc = $_SESSION["decoded11"]; $phpArray = json_decode($cc, true); foreach ($phpArray as $key => $value) { echo "<h2>$key</h2>"; foreach ($value as $k => $v) { echo "$k | $v <br />"; }
    Mutasd a teljes hozzászólást!
  • "
    Viszont érted nekem nem egy fix array kell, hanem amit a jquery-vel elkészítek és amit itt alul látsz.
    "

    hol?

    te minden példakódodban hagyományos objektumokat használsz (amelyek persze js-ben asszociatív tömbként viselkednek, azaz ún.
    square bracket notation
    -nal hivatkozhatsz a kulcs-érték párokra, de nem "valódi" tömbök), az összes literálod ilyen, ennélfogva például (alapértelmezetten) nincs
    length
    property-jük szerintem,

    szerintem kevered a szezont a fazonnal (objektum <-> tömb (persze a tömb is objektum)), ezért nem működik a kódod, szerintem,

    ha pld. a
    jsonarray
    -ed egy olyan objektum, amelyikben a
    one
    property-hez egy 1 elemű tömb tartozik, akkor teljesen érthető az, hogy magát a tömböt átadva (lásd a
    data: {json: JSON.stringify(jsonarray.one)}
    -t) a
    one
    "nullaként" jelenik meg a szerver oldalon, mert nem a teljes objektumot adtad át, hanem csak a tömböt, szerintem, és ezért nem fog a teljes objektumot átadva a szerver oldali szkripted működni, mert azt nem ennek megfelelően írtad meg.

    de mivel nem tudjuk, hogy a
    jsonarray
    objektumod az valójában hogyan nézz ki, legalábbis én nem látom, ezért csak találgathatunk,

    a js-es log-olós kódod alapján persze felételezhetjük, hogy valami ilyesmi (mivel hivatkozol a
    length
    property-re, az meg egy "sima" objektumnak csak akkor van, ha definiáltad, azaz szerintem itt használnál "valódi" tömböt):
    var jsonarray = {one: [{user:"John", age:22, country:"United States"}]};
    ezt az általad írt kliens oldali szkript és a szerveroldali is be tudja járni, ha az utóbbinak a
    JSON.stringify(jsonarray.one)
    -nal adod át a json "értékét", és úgy fog viselkedni ahogyan tapasztaltad,

    ekkor, ha a teljes objektumot át akarod adni, akkor a szerveroldalon nem úgy kell bejárnod, ahogyan próbálkoztál, hiszen ekkor a json stringed a következő lesz:
    '{"one":[{"user":"John", "age":22, "country":"United States"}]}
    , szerintem, azaz még egy ciklusra lesz szükséged, mivel a
    $v
    maga is egy tömbként jelenik meg a szerver oldalon,

    mondjuk azt nem egészen értem, hogyha ez a helyzet, akkor miért ilyen az átadandó objektumod, miért nem csak a tömböt adod át, stb.

    szerkesztve: közben "leesett", hogy vélhetőleg te php-s oldalról közelíted meg a js-t, ezért használod a tömb elnevezést ott is, ahol nem lenne indokolt, szerintem, mivel úgy-e a php-ban a tömb rendezett kulcs-érték párok sokasága, azért is gondolom ezt, mivel a kliens oldalon, a js szkriptben is használsz a property-k (a "kulcs"-ok) megadásánál idézőjeleket, de valójában nincs rájuk szükség (legalábbis akkor, amikor definiálod az objektumodat),
    Mutasd a teljes hozzászólást!
  • Köszönöm az írásodat.

    Igen szerintem nem jó az egész a kliens oldalon.

    Így csináltam a tömöt, de ugye szerintem ez most akkor rossz.

    var kulso_array = []; var belso_array = ["one","two"]; for(var i = 0; i < belso_array.length; i++) { kulso_array[belso_array[i]] = [] kulso_array[belso_array[i]].push({"First Name":"James","Last Name":"Bond"}); } kulso_array.one.splice(0,0,{"Code": "007", "Gun": "Glock"}); kulso_array.two.splice(2,0,{"Code": "007", "Gun": "Walther P99 MI6 007"});


    Értelem szerűen a kulso_array-t szeretném a php - nek küldeni, de hát most teljesen nem értem.

    Olyasmi kellene nekem, hogy létrehozok egy úgymond "külső" tömböt.

    var array = [];

    Utána ebbe a "külső" tömbbe kellene push-olni olyat, hogy

    {user:{"id":"1", "tag":"teszt" stb. stb.}}

    Tehát ez kivitelezhető? Tehát, hogy a kliens oldalon szépen pusholgatok stb. Majd ezt az array[] tömböt átküldeni a PHP oldalra, majd ott a PHP pedig ugye megjelenítené így:


    user:
    "id":"1",
    "tag":"teszt"
    stb. stb.

    másik user:
    "id":"2",
    "tag":"valami"
    stb. stb.

    torolt user:
    "id":"3",
    "tag":"szia"
    stb. stb.
    Mutasd a teljes hozzászólást!
  • gondolom, mivel elfogadtad a hozzászólásomat megoldásnak, ezért feltételezem, hogy rájöttél mi a gond, de azért leírom (az utókornak):

    szerintem, mint már írtam te a PHP oldalról közelít(ett)ed meg a JavaScriptet,
    tudtommal PHP-ben a tömb egy asszociatív szerkezet, azaz nyugodtam használhatsz az indexnek (a "kulcs"-nak) nem nemnegatív egész szám értékeket is, tehát "tetszőleges" karaktersorozatot,
    a JavaScript-ben viszont a tömb indexe az mindenképpen egy nemnegatív érték,

    a félreértés a részedről onnan van, hogy a JavaScript-ben az objektumok viszont asszociatív tömbként viselkednek, azaz azokat lehet "kulcsolni" "karaktersorozattal",

    tehát a példakódodban (a JavaScript-ben, a ciklusban) levő hivatkozás (a
    kulso_array
    elemeinek létrehozása) nem jó, mivel a
    kulso_array
    -t egy üres tömbnek inicializáltad, ezért azt a
    belso_array
    elemeivel nem indexelheted, mivel azok nem nemnegatív egészek, hanem karaktersorozatok, a ciklusodat "kiterítve" a
    kulso_array["one"]
    hibás hivatkozás jelen esetben, akkor lenne működőképes, ha a
    kulso_array
    egy hagyományos objektum lenne, azaz a
    var kulso_array = {};
    definíciót használtad volna,

    mondjuk az még mindig nem egészen világos számomra, hogy valójában milyen "adatszerkezetet" akartál a kliens oldalon létrehozni, azaz a "külső tömbödet" valóban tömbnek szeretted volna kezelni, vagy "hagyományos" objektumnak, és az egyes elemeit hasonlóan, de gondolom sikerült megoldanod, ezért ezt már csak te tudod,

    a kliens oldalon ilyen esetekben akkor jársz a legjobban, ha kiíratod az objektumaid "állapotát" (jelenesetben a json stringet) a konzolra, vagy egyszerűen egy
    alert()
    -tel, így egyből látod, hogy valójában miről is van szó, de ezt más Pistaapunk javasolta korábban, csak gondolom leírom még egyszer, mert ezek szerint átsiklott rajta a figyelmed (vagy az ő hozzászólását kellett volna elfogadnod megoldásként),
    Mutasd a teljes hozzászólást!
  • bocsánat, de mint a "bemutatkozásomnál" írtam: nem válaszolok érdemben privátban, mivel ez egy nyilvános fórum, meg azért is ide írom, hogyha valamit rosszul írnék, akkor kijavíthasson egy hozzáértő,

    szóval,

    igen a JavaScript-ben nem olyan a tömb, mint a PHP-ban,

    JavaScript-ben a tömb az egy olyan objektum, aminek az elemeit egy nemnegatív egésszel kulcsolhatod, és persze rendelkezik az elemeinek indexelésén (elérhetőségén) kívül egy sor hasznos művelettel, metódussal ( JavaScript Array Reference ), azaz itt nem asszociatív adatszerkezetről van szó, mivel mint írtam nem használhatsz indexnek nem nemnegatív egészet, tehát karaktersorozattal nem tudod az elemeket indexelni,
    azaz a [] operátor egy tömb esetén (is) "indexként" viselkedik, de közben meg (dinamikus) objektumról van szó, ezért tetszőleges property-vel kiegészítheted, és mivel az objektumok asszociatív tömbként viselkednek a JavaScript-ben, ezért azokat viszont lehet "indexelni" karaktersorozattal, de ebben az esetben az nem magára egy tömb elemre fog vonatkozni, hanem értelemszerűen az adott property-re, tehát írhatod a következőt:
    // 0. var tomb = []; console.log(tomb, tomb.length); alert(tomb); // kimenet: [] 0 // alert ablaka: "üres" // 1. tomb[0] = 0; console.log(tomb, tomb.length); alert(tomb); // kimenet: [0] 1 // alert ablaka: 0 // 2. tomb.one = 1; console.log(tomb, tomb.length); alert(tomb); // kimenet: [0, one:1] 1 // alert ablaka: 0 // 3. tomb[2] = 2; console.log(tomb, tomb.length); alert(tomb); // kimenet: [0, 2: 2, one: 1] 3 // alert ablaka: 0,,2

    Google Chrome Verzió: 26.0.1410.64 m-ben a fenti kimenet fog megjelenni a konzolban, és láthatod, hogy kicsit "zavaros", az
    alert
    ablakában persze kiderül, hogy miről van szó:

    0. létrehoztunk egy üres tömböt,
    ekkor értelemszerű mindkét kimenet, hiszen a tömb üres, ezért a hossza 0, és "nincs mit" megjeleníteni az
    alert()
    ablakában (jobban mondva kiírja a "semmit"),

    1. a 0. elemnek adtunk egy értéket (
    tomb[0] = 0;
    ), ekkor értelemszerű megint a két kimenet: a tömb a 0-értéket tartalmazza a 0. indexen, a hossza 1,

    2. a tömbnek adtunk egy új property-t, na itt már zavaros a console kimenete, mivel látható, hogy a hossznak még mindig jól csak 1-et ír ki, hiszen a tömbnek valójában csak a 0 az eleme, viszont a konzolban sajnálatos módon úgy tűnik mintha még egy elem lenne, aminek az indexe
    one
    , a hozzátartozó érték pedig
    1
    , közben persze ez csak a tömbnek, mint objektumnak egy property-je lesz, az
    alert()
    ablakában persze jól látszódik, hogy a tömb valójában tömbelemmel nem bővült,

    3. felveszünk egy újabb elemet a tömbbe, a 2. indexre, ekkor megint lesz egy kis zavar, mivel a konzolban a 3-as hossz esetleg megtéveszthet, hiszen a []-ek között 3 elemet fogsz látni, de az
    alert()
    ablakából valójában kiderül, hogy miről is van szó: mivel a tömb (indexét tekintve a) 2. elemét (amely valójában darabszámra a 3.) adtuk meg, ezért a kimaradt 1. elem (ami nullától sorszámozva persze a 2.) automatikusan az
    undefined
    értéket fogja kapni, azaz a tömbünk így 3 elemű lesz, az első eleme (a 0. indexű) az elsőnek felvett 0, a második eleme (az 1. indexű) az általunk nem meghatározott
    undefined
    , majd a harmadik (a 2. indexű) pedig a 2 értéket fogja tartalmazni, a
    one
    értelemszerűen továbbra is egy property-lesz, amelyik tehát nem tömbelemként szerepel,

    hogy még "összezavarjalak", fentebb írtam, hogy az objektumokat JavaScript-ben lehet asszociatív tömbként indexelni, ezért a következő kódkiegészítés értelmes:
    // 4. console.log(tomb["one"]); alert(tomb["one"]);
    és mindkét "helyen" szépen megjelenik az 1-es,

    azt kell észrevenni, hogy ez esetben a [] operátor nem hagyományos tömbindexoperátorként fog értelmeződni, azaz nem a tömb elemét fogja címezni, hanem a property-t, mivel az ún.
    square bracket notation
    -t használtuk valójában,

    a félreértések elkerülése végett viszont objektum property-je nem lehet szám, mivel az nem elfogadott azonosító, azaz ilyet nem írhatsz:
    var obj = {}; obj.1 = 1; alert(obj[1]);

    viszont ilyet igen:
    var obj = {}; obj[1] = 1; alert(obj[1]);
    és ez utóbbi nem jelenti azt, hogy az
    obj
    objektumod tömb lenne, vagy azzá "alakult volna", azaz maradt "hagyományos" objektum, csak az ún.
    square bracket notation
    hivatkozás miatt hozzáadtunk egy új property-t, az "1" néven, "kulccsal",

    gondolom ez jó zavaros, de ha utánagondolsz, akkor szerintem érthető,

    ha nem tömböt használsz, hanem "hagyományos" objektumokat, akkor értelemszerűen nem használhatsz rájuk olyan metódusokat, amelyek nem implementáltak, azaz nyilván a
    push
    ,
    splice
    nem működik, kivéve, ha megírod,

    de felesleges szerintem "bonyolítani", azaz ebben az esetben el kell szakadnod a "tömbös" hozzáállástól, azaz a
    push
    helyett simán a
    square bracket notation
    -t használva hozzáadhatsz újabb property-t, a
    delete
    -t használva meg törölhetsz, azaz a következő példakód értelmes:
    var obj = {}; alert(JSON.stringify(obj)); // {} obj[0] = "nulla"; obj[1] = 1; alert(JSON.stringify(obj)); // {"0":"nulla","1":1} delete obj[0]; alert(JSON.stringify(obj)); // {"1":1}

    nyilván használhatsz tömböt is, de szerintem első körben azt kellene eldöntened, hogy valójában mit is akarsz küldeni, mert nekem még mindig nem világos,
    azaz a "külső tömböd" tömb lenne-e vagy nem? minek lenne tömb? nem értem, hogy miért nem egy sima objektum,
    a "belső tömböd" hasonlóan tömb lenne-e vagy nem? minek lenne tömb?

    lehetne persze mindkettő esetben (JavaScriptben, a kliens oldalon) tömb is, de nem látom, hogy miért ragaszkodnál hozzá, ha nem nemnegatív értékekkel akarsz indexelni, hiszen akkor nem lehet az,

    röviden ennyi, szerintem,


    szerkesztve: nyilván, ha a PHP-ben találkoztál először a tömbökkel, akkor ez az egész zavaros lehet, és biztosan nehezen emészthető, hogy a JavaScript-ben miért is van máshogy (a jó "kérdés" az, hogy miért van a PHP-ban máshogy, mint ahogyan "szokásos", legalábbis az ismertebb programnyelvek nagy többségét tekintve)

    szerkesztés szerkesztése: a legutolsó példakódom lehet, hogy kicsit "félreérthető", nyilván a nemnegatív egészek helyett a már sokszor említett
    square bracket notation
    -ban tetszőleges "kulcsot" használhatsz, azaz írhatod:
    var obj = {}; alert(JSON.stringify(obj)); // {} obj["user"] = {id:1, tag:"teszt"}; obj["masik user"] = {id:2, tag:"valami"}; obj["torolt user"] = {id:3, tag:"szia"}; alert(JSON.stringify(obj)); // {"user":{"id":1,"tag":"teszt"},"masik user":{"id":2, "tag":"valami"},"torolt_user":{"id":3,"tag":"szia"}} delete obj["masik user"]; alert(JSON.stringify(obj)); // {"user":{"id":1,"tag":"teszt"},"torolt_user":{"id":3,"tag":"szia"}}
    Mutasd a teljes hozzászólást!
Tetszett amit olvastál? Szeretnél a jövőben is értesülni a hasonló érdekességekről?
abcd