Problémás JavaScript fejlesztői interjú kérdések
Már több mint negyed éve interjúztatok JavaScript fejlesztői állásra, és észrevettem, hogy a mi kérdéssorunkból mire tudják a legkevesebben a választ, illetve mire adnak rendszeresen hibás választ. Ezeket a kérdéseket és válaszokat próbáltam összegyűjteni, hátha mások tanulni tudnak belőle.
Hogyan működik az öröklődés JavaScriptben?
A JavaScriptben prototípusos (prototypal) öröklődés van, ami azt jelenti, hogy egy osztály a prototípusától örökli a tulajdonságait. A prototípusa pedig szintén örökölhet tulajdonságokat a saját prototípusától, így jön létre a prototípus lánc (prototype chain). A prototípus lánc azt jelenti, hogy amikor a objektum egy tulajdonságát kérdezzük le, akkor a JavaScript motor előbb megnézi, hogy az definiálva van-e magán az objektumon, majd annak prototípusán, majd a prototípus prototípusán stb. Ha megtalálja, akkor visszadja, ha nem, akkor undefined
értéket ad vissza vagy ReferenceError
hibát dob.
Milyen értéket kap egy változó alapértelmezetten?
undefined
.
Mi a különbség a null
és az undefined
között?
Az undefined
azt jelenti, hogy a változó még nem kapott értéket vagy nem is lett definiálva. A null
azt jelenti, hogy a változó létezik, és a fejlesztő szándékosan jelezni akarja, hogy a változónak nincsen értéke.
Hogyan adódnak át a paraméterek a függvénynek?
A primitív típusok (number
, string
, boolean
, undefined
, null
) érték szerint, az objektumok (azaz minden más) pedig referencia szerint.
Hogyan működik az események propagálása (terjesztése)?
Az események terjesztésének két fázisa van (egyes elméletek szerint három), lefutási sorrendben: az elfogási fázis (capture phase)[, a célpont fázis (target phase)] és a buborékolás fázis (bubbling phase). A capture phase-ben az esemény a dokumentum tetejétől, külsejétől indul, és jut el végül a célponthoz. A bubbling phase során pedig az esemény a célponttól elindul és fölfele végigfut az összes szülő elemen.
Milyen pozicionálás (position) értékek léteznek a CSS-ben és hogyan működnek?
static
- Az elem része a dokumentum folyamnak (document flow), nem számít pozicionáltnak.
relative
- Az elem része a dokumentum folyamnak, helyzete relatív az eredetileg elfoglalt pozíciójához képest.
absolute
- Az elem nem része a dokumentum folyamnak, helyzete relatív a legközelebbi pozicionált elem pozíciójához képest.
fixed
- Az elem nem része a dokumentum folyamnak, helyzete relatív a nézetablakhoz (viewport) képest, nyomtatás esetén minden egyes lapon.
legközelebbi
Az elem nem része a dokumentum folyamnak, helyzete relatív a legközelebbi pozicionált elem pozíciójához képest.
A "legközelebbi" szó így talán félreérthető. Annyiban pontosítanám, hogy a szülői láncban a legközelebbi pozicionált szülőről van szó.
igaz
ráadásul
Szia, És amúgy miért
És amúgy miért kérdezel ilyeneket interjún? Mindig kíváncsi voltama arra, hogy ez mire jó. Szerintem semmit nem mér fel, abszolút semmit. Erre egyébként ha jól tudom már az olyan nagyobbacska vállalatok mint a Google is rájöttek, ha jól tudom nyáron volt hír, hogy a marketing szempontból marhára jól mutató, hiper-szuper nehéz tesztjeik az ég világon semmit nem érnek. Bárhogyan is, szerintem az ilyen kérdezgetés és a gyors tesztek maximum arra jók, hogy az interjúztatók kiélhessák egy kicsit a felsőbbrendűségi érzéseiket és utána ezt publikálják is pl. egy ilyen blogban. Hogy miért nem ér semmit? Sok ember izgulós, sok ember leblokkol ha kérdezik, vagy csak simán nem jut eszébe. valószínű, hogy az interjúztatónak is lehet olyan kérdéseket feltenni amire nem tudna válaszolni... A kicsit hosszabb lélegzetvételű teszt feladatok és elsősorban a próbamunka, amit odahaza, nyugodtan megcsinálhat valaki, ezerszer többet elárulnak a pályázó tudádásáról és kódolási szokásairól, mint az ilyen kérdések.
Na persze, mindenki azt csinál amit akar, ez csak a személyes véleményem, lassan 15 éve dolgozok ezen a területen és bennem ez a vélemény alakult ki. :)
A Google-nél más jellegű
Egyetértek, aki ezekkel sincs
Egyik sem mondható nehéznek vagy trükkösnek Poetro kérdései közül. Ezek egyszerűen az alapok.
Én nem biztos
Szerintem fel tudnád
Persze ha akár név nélkül tudod, hogy van 4 ami ezt meg azt csinálja, akkor adott problémával szembesülve be fog ugrani, hogy az egyik position érték itt jó lehet. Ilyenkor segíthet a referencia.
Saját tapasztalat szerint ha napi szinten sitebuildel vagy uit programoz az ember, normális esetben gyorsan rögzülnek ezek, mert sokszor jönnek jól.
Alapok
Azért, mert szeretném tudni, hogy a jelentkező tisztában van-e az alapokkal, amiket munkája során minden nap használnia kell. Ha ezeket az alapvető koncepciókat rávezetés után sem tudja megválaszolni, kifejteni, akkor nem fogja tudni jól, vagy egyáltalán végezni a munkáját.
Ez nem hiper-szuper nehéz, egyszerűen az alapokat fedi le.
Arra nem vagyok kíváncsi, ki mennyire ért a jQuery-hez, lévén a munkája során nem fog jQuery-t használni. A nyelv, a DOM és a CSS alapjaira vagyok kíváncsi, ugyanis az fogja használni, egy olyan keretrendszerrel, amit valószínűleg még soha nem használt, és ami többek között ezekre az alapokra épül.
Az ember munkája során nap mint nap stresszhelyzetbe kerül, különböző okok miatt, és ha a telefonos beszélgetés alatt, amikor általa ismerős környezetben van, nem tudja az alapokat sem, az nem túl jó fényt vet az folytatásra.
Igen, szoktunk ilyet is kérni, illetve amennyiben van publikus kódja, akkor azt nézzük meg, nem terheljük a jelentkezőt még egy próbafeladat megoldásával, mivel a már elkészült kódja alapján általában meg tudjuk állapítani, hogy egyáltalán érdemes-e behívni / felhívni interjúra.
Természetesen, hat tudsz valami ennél jobb módszert arra, hogy heti 4-5 embert tudjon egy fejlesztő interjúztatni, és közben elvégezze a munkáját is, akkor arról szívesen hallanék egy leírást.
Természetesen az interjúztató
Ezek a kérdések nem is arra valók, hogy az interjúztató a felsőbbrendűségi érzését kiélhesse. Nálunk ez úgy megy, hogy minden jelölttel adnak egy pozíció leírást is, és azzal kapcsolatos kérdéseket kell feltenni. Meg persze általánosakat is. Átfedés mindig van. Vannak kérdések, amik a jelölt számára öncélúnak tűnnek, és valószínűleg azokról a kérdésekről gondolják ezt, amikre nem tudják a választ. Hisz ha valamire nem tudod a választ, nem is tudod miért kérdezik. Pár kérdéssel ki lehet deríteni valakiről, hogy bizonyos dolgokról, amik szerepelnek pl a cv-jében, milyen mély ismeretekkel rendelkezik. Ha pl beírja, hogy dolgozott x technológiával 2 évig, és azzal kapcsolatban felteszel egy kérdést, hamar kiderül, hogy csak használta, vagy vette a fáradtságot arra is, hogy utánamenjen, hogy mi az, amit használ, és miért. Ha nem ment utána, annak értelemszerűen komoly üzenete van. Ha ez csak 1-2 a cv-jében lévő technológiára igaz, akkor rá lehet fogni, hogy csak érintőlegesen használta. De ha pár technológiára van felfűzve az egész cv, akkor ott kilóg a lóláb, ha nem vágja. Pl volt, hogy valaki azt állította, hogy ismeri a springet. Amikor megkérdeztük, hogy milyen bean scope-okat ismer, akkor azt már nem tudta, pedig ez nem egy eldugott dolog benne... Interjúról kifelé jövet megbeszéltük a kollégával, hogy milyen szimpatikus srác, értelmesnek is tűnik, de sajnos nem tudtuk még biztonsággal felvételre ajánlani. A springes kérdéshez hasonló ez a js öröklődés dolog is. Ha erre a kérdésre nem kerül szóba a prototype akár válasz, akár visszakérdezés formájában, akkor az egy erős felkiáltójel az interjúztatónak.
Fontos még megemlíteni, hogy egy interjún nem kell mindenre tudni a választ. Sőt. Jelöltként én kimondottan azokat az interjúkat szeretem, ahol tudnak olyat kérdezni, amire nem tudom a választ, vagy nagyon el kell gondolkodnom. Ez egy jele annak, hogy jó helyen vagy, és tanulni fogsz, ha megállapodtok. És fordítva is fontos, interjúztatóként is kell tudd azt az érzést kelteni, hogy itt nálatok lehet tanulni, ergo érdemes elfogadja majd az ajánlatotokat. A dolog tehát az arányokon múlik, és persze hogy mire nem tudja a jelölt a választ.
Én jelöltként nagyon utáltam az olyan interjúkat, ahol csak egy igen/nem válasz jött. Abból számomra semmi nem derül ki (kivéve, amit én közben le tudtam mérni). Én nagyon értékeltem mindig az olyan interjúztatókat, akik azt mondták, hogy ezt jól tudtad, de ezek azok a területek, ahol még tanulnod kell, hogy a jövőbeli karriercélodat elérd. Szerintem ez korrekt. Bár tény, hogy kevesen mernek ilyen feedbacket adni, mert veszélyes. Nem mindenki szereti, és nem mindenki tolerálja.
És Pepitával egyetértve, szerintem jó dolog, hogy van ilyen bejegyzés a leggyakoribb interjú hibákról. Bár js területen nincs tapasztalatom, de javaban is megvannak ugyanezek a kérdések: ott főként collection és multithread területen megy a szétlövés. A kettő kombinációja meg aztán végképp magic.
Na de hogy olvasnivaló is legyen, interjú témában egy szerintem nagyon érdekes poszt Verhás Pétertől.
Illetve a java interjúk iránt érdeklődőknek egy angol nyelvű blog, ahol tematikusan össze vannak gyűjtve gyakran feltett kérdések: javarevisited
Annyi fűznék hozzá, hogy
A buktatónak minősülő kérdéseket igyekszem többféle módon megfogalmazni, amennyiben lehetséges.
Például ha egy "Milyen értéket kap egy változó alapértelmezetten?" kérdésre többször is olyan szintű választ kapok, hogy "amilyet adok neki" vagy "semmilyet", akkor megkérdezem, hogy "Egy var-ral bevezetett p változóra typeof függvényt hívok, mit kapok eredményül?". Ezt már nem lehet félreérteni.
valóban
A "Hogyan működik az öröklődés JavaScriptben?" kérdésben pedig az a nehéz, hogy hogyan mondjak ne túl sokat és ne intézzem el mégis két szóval -- vagyis nehéz megítélni itt is, hogy milyen részletességgel kéri a kérdező.
A "Milyen értéket kap egy változó alapértelmezetten?" pedig lehet erősködni, hogy mondjuk a function zuzu(){} hatására is létrejön egy alapértelmezett változó, mégsem undefined.
Az utolsó kérdés pedig nem is JS.
Nyilván ez csak szőrszálhasogatás :-)
(egyébként a typeof az nem fv)
Imho ha valaki kommunikálni
Az attól függ, hogy melyik öröklési modelt követed. http://davidshariff.com/blog/javascript-inheritance-patterns/ De ez meg olyan dolog, hogy nekem is google-zni kellett párat, hogy megtaláljam a megfelelő szakszavakat "inheritance pattern", mert olyan régen foglalkoztam a témával. Sokkal relevánsabb lenne, hogy mi az, hogy polimorfizmus, milyen két implementálási módja van (inheritance, composition), melyiket érdemesebb használni (composition over inheritance) és miért (sokan eltúlozzák az öröklődést, kompozit osztályokat meg alig használnak), mutass rá egy példát js-ben bármilyen keretrendszerrel. Az öröklődést úgyis a keretrendszer fogja megoldani helyettünk... Nem baj, ha ezek közül nem mindre tud válaszolni, ha hajlandó tanulni...
Sokkal konkrétabb lenne rákérdezni, hogy mi az, hogy ha kiírod egy változó értékét a konzolba (mi az, hogy konzol?), akkor mit jelent az, hogy
undefined
,null
, végtelen ciklus a kirajzolás során, stb...? Egyáltalán hogyan lehet debuggolni egy kódot, érdemes e kivételeket dobni, vagy null-al visszatérni, stb... Ezek vitatott kérdések (bizonyos körökben), de gondolom van rá saját irányelvetek, amit mindenkitől megköveteltek.Mi az, hogy
cancelBubble
ésstopPropagation
? Esetleg felhozol egy példát, ezzel kapcsolatban, és megkérded mi fog történni, vagy hogy hogyan valósítaná meg az illető, stb...Szinte mindegyik elméleti
Gyakorlati hasznuk is van a kérdéseknek, mert a referencia szerinti átadás nagyon hasznos dolog, én például sokáig nem voltam vele tisztában, emiatt egy csomó fölösleges kört futottam bizonyos helyeken.
JS-ben egyféle öröklés van,
Ez mese. Eleve nincs is öröklődés js-ben by default, ha lenne, akkor nem lenne csak a reserved words-ben az extends és a super, hanem használva is lenne. Ez a prototípus alapú bűvészkedés csak egy a lehetséges megvalósítások közül.
Pont azt mutattam meg az előbb, hogy az ilyen kérdések beszélgetés elindítására teljesen alkalmatlanok, nem támogatják a kommunikációt, hanem gátolják. Csak annyit lehet felmérni velük, hogy az illető, akit kérdezünk ugyanúgy gondolkodik e, mint mi, vagy teljesen máshogy. Ohh ezen kívül még valamire jók, ha visszakérdez, akkor jók a kommunikációs képességei, ha meg nem, hanem elkezd agyalni, hogy vajon mire gondolsz, akkor meg inkább olyan típus, aki mindent maga próbál megoldani.
Ha a "by default" úgy van
Az Object.create() viszont szerintem egyértelműsítette ezt a helyzetet, és így már van (prototípusos) öröklődés JS-ben bűvészkedés nélkül.
Az Object.create() viszont
Az
Object.create()
csak egy egyszerű függvény, ami megkönnyíti a prototípusos öröklődést, semmi több.Ez az egész dolog már ott elhalt, hogy js-ben nincsenek osztályok és metódusok, azok nélkül meg nem lehet öröklődésről beszélni. Ugyanígy nincsenek interface-ek, azok nélkül meg nincs sok értelme polimorfizmusról beszélni. Tudjuk imitálni ezeket a dolgokat a js-ben elérhető eszközökkel, de nem lehet azt kijelenteni, hogy egyik vagy másik út (pl a prototípusos öröklődési minta) kizárólagos. Ez olyan, mintha a vizsgáztató megkérdezné, hogy hogyan tárolsz fát adatbázisban, és ha nem a
nested set
-ről kezdenél beszélni, hanem azadjacency list model
-ről, akkor megbuktál, mert bocs, én nem erre gondoltam... :DMondjuk így végiggondolva a helyes válasz erre:
az, hogy sehogy, nincs öröklődés javascriptben, vannak öröklődési minták, amikkel öröklődést lehet imitálni.
off:
Szerintem az már régen rossz, ha egy kérdés a vizsgáztató beszűkült látásmódját bizonyítja, nem pedig arról szól, hogy a vizsgáztató megpróbáljon minél többet kihozni a vizsgázóból. Persze ezt lehet úgy magyarázni, hogy hát ha valaki nem bírja vizsgán a stresszhelyzetet, akkor majd a határidő csúszásakor sem fogja bírni, de ez elég sokat elárul az adott cégről is. Csak néhány példamondat erre:
azt hiszem érezni az iróniát...
Azt hiszem egy nagyon fontos dolgot
Poetro mindenképp szóban teszi fel ezeket a kérdéseket, vagy személyesen, vagy telón. Tehát bármikor ott az alkalom a pontosításra, visszakérdezésre, stb.
Azt hiszem - ha "beérik" -, komolyabban is válaszolok, eddig úgy tűnik, egy dolgot csak én vettem észre.
Köszönöm a kiegészítést.
Nem értem, miért ne lehetne
+1
Még egy apróság
Én abból indultam ki, hogy
Btw a lényegen ez nem változtat, továbbra sem tartom jó ötletnek elméleti kérdésekkel zaklatni a vizsgázót gyakorlati kérdések helyett, de ez valószínűleg az én beállítottságomtól függ.
Helyesbítek, úgy gondolom, hogy vannak állások, amikhez magas szintű elméleti tudás szükséges, de egy js fejlesztői állás nem ilyen, ahhoz inkább gyakorlati tudás kell. Azt, hogy valakinek milyen gyakorlati tudása van, le lehet mérni az általa készített kódból, esetleg néhány egyszerű teszt feladatból, amiknél szóban el tudja mondani, hogy hogyan oldaná meg őket.
És ha lesznek?
class
és azextends
el fogja fedni.Ráadásul ez az JavaScript fejlesztői álláshoz elég magas szintű elméleti tudásra van szükség, egyrészt azért, mert senior pozícióra keresünk embert, másrészt azért mert nagyon komplex az alkalmazás kliens oldala.
Piros fény
Miért?
Ez a tapasztalatom. Én is
+1, ha bonyolult a feladat,
Egyébként sok dolog van, ami miatt feleslegesen túl komplex lesz egy kliens oldali alkalmazás. Az egyik elterjedt ilyen minta, hogy vastag klienst használtok, és a business logic-ot nem csak szerver, hanem kliens oldalon is implementáljátok. Egy másik minta az overengineering vagy a nem megfelelő irányból (alacsony absztrakciós szintről magasabb felé haladva) elkezdett fejlesztés, ezeket viszont TDD használatával el lehet kerülni. Aztán pl js specifikus, hogyha valaki nem használ require.js-t, akkor nem szokta szétdarabolni kis modulokra a kódját, mert fél, hogy túl lassú lesz a végeredmény, és így tovább... Láttam már 7x-es öröklést is kint a vadvilágban a maga természetességében... :D
Nem hiszem, hogy ezek miatt kukába kellene dobni egy amúgy jól megírt kódot, inkább el kell gondolkodni azon, hogy hol hibáztunk, levonni a konklúziót, és a megfelelő eszközökkel kijavítani a hibát. Ha menthetetlen a kód, túl sok helyen bele kéne nyúlni, csak akkor érdemes újraírni az egészet jobban átgondolva.
Az egyik elterjedt ilyen
Igen, mi egy vastag klienst implementálunk, és a szerver mindent kiszámol, ami a megjelenítéshez szükséges, de a teljes megjelenítés, és annak logikája kliens oldalon számítódik ki. Ha valaki kíváncsi, pár kereséssel megtudhatja, milyen termékről van szó.
Mi nem használunk require.js-t, hanem teljesen más technológiát használunk, és nem is a JS kód, ami sokszor lassú, hanem a böngésző saját API-jai. Rengeteg kisebb modulra van a kód feldarabolva, több száz "osztályról" van szó.
Próbáltam megtalálni milyen
Keresés
Igen, mi egy vastag klienst
A vastag klienst úgy értettem, hogy a kliens szorosan van csatolva az alkalmazáshoz, és nem is futhatna más jellegű alkalmazással. Majd egy cikkben ezt ki fogom fejteni kicsit jobban, most nem szeretnék részletekbe menni. A lényeg, hogy a kliens oldalon nem jó gyakorlat a szerver oldali kódot duplikálni, mert minden kód duplikáció rontja az alkalmazás karbantarthatóságát, és emellett még feleslegesen bonyolítja a kliens oldali kódot.
Igen
Ez így van, mivel az egyik szolgálja ki az adatot, a másik meg megjeleníti. A kettő két különböző dolgot valósít meg, de attól még a csatolás szoros.
A szerver oldali kód nincs duplikálva, mert más dolgot valósít meg az egyik, és mást a másik, de ettől még a kliens bonyolult, ahogy a szerver oldal is, csak más bonyolult az egyikben, mint a másikban.
Hát a szoros csatolás miatt
Bocs, de ekkora ökörségeket
.. egyrészt a "require.js" nem csodaszer, van vagy 100 másik megoldás, de lehet írni sajátot is.. vagy megoldani másként.
.. aki ilyen moduláris rendszerben nyomja ki a js fájlokat, annak továbbképzésre van szükség, mert az egyik legrosszabb megoldás.. mind js alapon, mind szerver oldalon
sokkal jobb megoldások vannak rá.
.. annak, hogy 7x öröklődés van egy javascript kódban semmi köze, se a kód, se az "alkalmazás" minőségéhez, se a gyorsaságához.. tehát egyáltalán nem vad, vagy hibás dolog, ha nem csak 1x az öröklődés.
Lassan a testtel
Miután nagy valószínűséggel nem ismered, mi alapján döntött a require.js/moduláris rendszer mellett, miért ítélkezel? Az öröklődések száma prototípusos módnál valóban nem nagyon számít, mert natív, de pl. az eléggé elterjedt (nem natív) object.extend() esetében ez nem így van, mert minél több szint van, annál lassabb lesz az objektum létrehozása.
Szintén
Ilyenkor nem annyi db másolat készül a teljes "objektumról", ahány örökítés? Mert akkor memóriában számít, persze függ az "objektum" méretétől is, de mindenképp annyiszorosa, ahány öröklődés. Ha jól gondolom.
Ekkor viszont a "nem nagyon" (ami egyébként is: most igen vagy nem?) már inkább "nagyon".
Méretre valószínűleg
Na ne...
Akkor a
Prototípusos öröklődésnél épp
A 34-esben írt példám is ezt érzékelteti.
Már ha jól értem, amit írsz.
Jól érted, köszönöm,
Akkor ezen a vonalon nem sok "érdekes" történik, Gábornak is igaza van.
Jobban kell figyeljek, ill. van restanciám JS-ből (mondjuk ezt tudtam is :)).
Köszönöm a helyre tételt.
Pont, hogy nincs
Olvass már utána lécci a Javascript öröklődésnek, mert pont, hogy nem lesz annyi
szorosa a "osztály/objektum" "mérete" ahányszor örökítettél, épp ez a prototype lényege. Az "csak" egy osztott tároló, "csak" "delegálódik" a gyerekek felé.
El vagy tévedve
Ígérete szerint
Öröklődésről volt szó, az
nem számít annak, így nincs is értelme említeni sem vele kapcsolatban
az "öröklődések száma" kifejezést.
Visszaveszek(?), ha Te meg megtanulsz olvasni és értelmezni.
Ő állította, ".. hogyha valaki nem használ require.js-t, akkor nem szokta szétdarabolni kis modulokra a kódját, mert fél, hogy túl lassú lesz a végeredmény".
A többség nem használ require.js-t, és én csak a többség mundérját védtem, az ilyen, asztalra letett leszólástól, lekicsinyítéstől, általánosítástól.:)
Egyébként nem voltam agresszív.. komoly gond, ha az ökörség szó itt már annak számít.
Az erőszak erőszakot szül,
Öcsém, legalább
Így csak a hónapos regeddel máris lehúztad magad a retyón, ha te leszel gondban egy kérdéssel, a kutya nem fog neked segíteni.
Te írkálsz itt ökörségeket:
Nem a szó, hanem az egész megnyilvánulásod, tudod, láttunk itt már néhány napig hozzád hasonló ifjú mindentudókat... Ebben a szakmában is, mint minden másikban, a legfontosabb helyes megközelítés a magamban kételkedés és az alázat. Így lehet tudást szerezni, mások fikázásával pedig inkább a parlamentben lehet kétes érdemekhez jutni, de itt semmiképp.
Ugyanazt a szerinted tévedést meg lehet ám mondani normálisan is.
Ha ennyire ász vagy, hol voltál idáig?
Megjegyzem - példa a szakmai alázatra -, hogy én csaknem 2 évig csak olvastam a WL-t, nem is regeltem... Figyeltem, hogy mit csinálnak a "nagyok". És nézd vissza a "történetem" (követő), igen sokat kérdeztem eleinte, és nem válaszoltam - mert féltem, hogy nem tudok eleget hozzá. Csak mikor már a sokadik olyan választ olvastam, amit én is írtam volna.
Szóval lehet így is, meg titánkodni, ahogy próbálsz, de ezzel az utóbbival semmire sem mész. Itt.
A részemről az utolsó
.. köszönöm, hogy aggódsz, de ritkán vagyok gondban és nem a weblabor az a hely, ahová "gondjaimmal" fordulnék.
.. nem tudtam, hogy ez a hely itt egy beltenyészet, asztalokkal, "szokásokkal", ahol sokan erkölcscsősznek érzik magukat, akik csak azt nem veszik észre, hogy saját magukat is minősítik mások látatlanban való minősítésével.. köszönöm, hogy leifjúzol és letitánozol.. de egyik sem vagyok.. mint ahogy agresszív sem attól, hogy az "leökörségezek" valamit.. egy alapvető tévedést.. smile-val.
.. A "tényleg utánanézhetnél" kicsit nehéz értelmezni, hogy gondoltad?:) Az oldalon nem találtam használati feltételeket, szabályokat, etikai kódexet. De, elfogadom, ha az ökör szó itt már kiveri a biztosítékot.. és ha versbe foglalom, vagy metaforával írom le?:)) Így jobb: szarvas hiba?:)
Részemről ennyi..
Egyébként ifjú, agresszív titánként:), ez a cikk már csak arra is tökéletes volt, hogy felfedjen pár szarvas hibát:), mind egyesek ismeretében, mind a teszt kérdésekben.
Helyes, köszi!
Komolyan.
A többi rész kommentálásával már nem is fáradnék...
Bár van, amiben igazad van,
Azért ez épp az, amit ő
Nem, távolról sem ugyanaz
Bocs, de ekkora ökörségeket
Megbocsájtok!
Nehéz megfelelő álláspontot
A helyzet az, hogy nyelvi elem ide vagy oda, a js-ben ettől függetlenül többféle öröklési minta lesz míg világ a világ ellentétben az olyan nyelvekkel, amikben van osztály, és általában csak egy extends van mellé. Nem véletlenül kezdtek el néhány éve sokan azon agyalni js-ben, hogy hogyan érdemes megoldani az öröklődést, és nem véletlenül született egy csomó cikk róla. Más nyelvekre az ilyesmi egyáltalán nem jellemző...
Én átfogalmaznám a kérdést úgy, hogy "Melyik a leggyakrabban használt öröklési minta javascriptben?", vagy "Milyen öröklési mintákat ismersz javascriptben?".
A "Functional pattern" egy
Több ok miatt nem beszélhetünk öröklődésről..
.. a legfontosabb, hogy prototype alapú "öröklődéskor" nem írod felől a szülő
"osztály" metódusát és meg tudod hívni bármelyik gyerekéből, ennél felülírod ( nem véletlen, hogy a példákban sem is írja felül a szülő függvényeit ).
.. a másik, ami ebből következik, hogy a példákban különálló "objektumok" jönnek létre, különálló változókkal és függvényekkel. Azaz nem örökölnek semmit a szülőtől, hiába adnál neki egy új függvényt azt nem örökölné egyik "gyereke" sem.
Azonkívül egyébként tök jó ki bug és leak-halmaz a "that" miatt.
A kérdésre tehát egy jó válasz adható.. minden más gányolás.
Szerintem nem kellene
Szerintem a
class
kulcsszó (és társai) nem a legszerencsésebb választás, hiszen ez ugyanúgy csak a prototípusos mintát fogja elfedni egy tömörebb szintakszissal, és aki tényleges osztályokkal rendelkező nyelv felől érkezik a JS-hez, azt igencsak összezavarhatja. Sokkal tisztább lenne bevezetni kulcsszavakat, amik a prototípusos minta sajátjai lennének, de nyilván macerás új foglalt szavakat bevezetni.Egyébként volt már erről korábban blogmark, ami szerintem szépen összefoglalja és fejtegeti a témát.
Sokkal tisztább lenne
Ebben egyetértek. Jobb lett volna már eleve úgy indulni, hogy
A
class
kulcsszó valóban nem helytálló egy osztály nélküli nyelvben, nem is igazán értem, hogy miért reserved word.Ez az egész dolog már ott
Miért ne lehetne öröklődésről beszélni. Vannak más nyelvek is, amikben van öröklődés, és nincsennek benne interfacek és osztályok. Metódusok igenis vannak JS-ben, ugyanis egy objektum azon tulajdonságait, amik függvények, metódusnak hívjuk. A JS ezen kívül támogatja az összes OOP követelményt:
this
kulcsszóval."Azokon a napokon" 1nf3rn0
ja az tény, hogy tegnap ilyen
In object-oriented
Method (computer programming)
Ami innentől lényeges, hogy js-ben vajon vannak e class-ek, vagy nincsenek. Szerintem nincsenek, én legalábbis a konstruktor függvényeket nem tekintem osztályoknak, de ezt csak érzésre mondom, lehet, hogy tévedek benne.
Ádámmal beszéltünk múltkor az encapsulation-ről, azóta leülepedett, de még mindig nem teljesen tiszta a kép ezzel kapcsolatban. Jelenleg az ragadt meg, hogy class-hez kell encapsulation, és a ppp része ennek, de újra el kellene olvasnom az egészet, hogy kitisztuljon a kép.
A function that is associated
ECMAScript Language Specification - 4.2 Language Overview
Innentől kezdve elkezdhetünk
Prototype-based programming
Method (computer programming)
Nekem nem nehéz innentől összerakni, hogyha osztályok nincsenek, akkor metódusok sincsenek, tökmindegy, hogy erről mit mond az ECMAScript specifikáció...
Másrészt viszont:
Inheritance (object-oriented programming)
Szóval az öröklődés nem csak osztályok között értelmezett, hanem objektumok között is, szóval lehetséges prototype based nyelven is örököltetni.
Classical Inheritance in JavaScript Ebből nagyjából kiderül, hogy inheritance alatt a classical inheritance-re gondoltam, viszont úgy néz ki, hogy ez egy tágabb fogalom, ami több részre tagolódik a classical inheritance-re, a prototypal inheritance-re, és még sok más eltérő megoldásra. Szóval ja, bár osztályok nincsenek, öröklődés mégis van js alatt.
Polimorfizmus is van, de sajnos nehezen használható (debuggolható) interface-ek nélkül. A go-jéhoz hasonlító interface implementáció jót tenne a nyelvnek. Meg lehet oldani, csak baromi lassú, mert a Function.prototype.toString-el lehet csak kinyerni a paraméter listát, a típusokat meg alapból valahogy külön kellene megadni. Szóval sajna js-nek is megvannak a maga korlátai.
Amit továbbra is fenntartok, hogy js-ben nem csak prototípusos öröklődés van/megoldható, ezért a kérdés és a válasz pontatlan. Bár ez szőrszálhasogatás, de ha már ennyire elméleti szakembert kerestek...
Nem feltétlenül tartom jó
Ami a Classical Inheritance-et illeti, az valóban egy örököltetési minta, ahogy te fogalmaztál. Egy olyan minta, ami a Javascriptben natívan jelenlévő prototípusos öröklődésre épül (mint több más örököltetési minta, persze nem mindegyik).
Nem feltétlenül tartom jó
Ehhez nem tudok hozzászólni, folytattunk már itt elméleti vitákat ilyen kérdésekről oo, class, encapsulation, polymorphism témában, és arra jutottunk, vagy legalábbis én arra jutottam, hogy össze kellene hozni egy közös szótárat, amiben definiálunk egy-egy fogalmat a megfelelő hivatkozásokkal. Jelenleg nekem erre semmi időm nincsen, és arra sem, hogy tudományos hivatkozásokat keressek. Amit tisztán látok, hogyha nincs közös nevezéktan, akkor az ilyen elméleti kérdéseket mindenki máshogy fogja érteni, a gyakorlati kérdések viszont ezzel szemben szótártól függetlenül teljesen egyértelműek. Aztán persze az is lehet, hogy a probléma csak velem van, mert én gyakorlati úton tanultam meg a js-t, és csak később kezdtem el elmélettel foglalkozni, így elképzelhető, hogy nincsenek meg a megfelelő elméleti alapjaim. :-)
Ezzel egyet tudok érteni. És
A primitív típusok (number,
Hohó, ez nem igaz, minden érték szerint adódik át, szigorúan pass-by-value (hasonlóan a Java-hoz), referencia szerint nem is lehet semmit átadni. Természetesen az objektumokra csak referenciával lehet hivatkozni ettől még.
Csak hogy világos legyen:
Jogos
+1, én is csak néztem bután,
Azt hiszem ez elég jól bizonyítja, hogy mennyire értelmetlenek ezek a kérdések, és a gyakorlat szempontjából mennyire jelentéktelenek. Elég magas labda ez most, nehéz megállni, hogy ne kezdjem cikizni Poetro-t. :D :D (csak hát az élet az ilyesmit mindig visszaadja)
PHP-ben nem igaz!
Rendben, én senki vagyok :), viszont pár kB adat felett simán referenciát adok át PHP-ben, és egy bonyolultabb funkció megvalósítása során ezzel MB-okat spórolok RAM-ban, ami egyben futásidő-csökkenést is jelent. Nagy forgalom esetén ez nagyon nem elhanyagolható, és nekem egyáltalán nem "kényelmetlen". Itt a PHP-részben igen elhamarkodottan ítéltél.
Lehet, hogy csak városi
Remélem legenda
&
jelet... :)Ha viszont saját MD-HTML átalakítókban gondolkozol, igen javaslom, hogy te is szokj rá a referenciákra, minek egyen az alkalmazásod dupla RAM-ot, ha nem kell?
copy-on-write
A linkelt írásban
$a = $b; $a =& $b;
. Ha itt is volt szó róla, linkelhetnéd azt is, hátha közelebbi, bár egy JS-blogot nem akarnék szétoffolni ezért.Esetleg akár új témaként vagy blogban leírhatnád, hogy is van ez pontosan, szerintem nem csak engem érdekelne.
En se offolnek, de
Viszont ha ezutan modositod $b-t, akkor $a nem valtozik, tehat ott mar le kellett, hogy masolodjon.
Ja, es igy hirtelen ez ugrik be pl, hogy itt volt emlitve
Köszi, így már érthető
Ha mindez rám van bízva, akkor lehet jól spórolni, természetesen érteni is kell hozzá.
Ismét egy PHP tulajdonság, amit én nem tartok kifejezetten jó ötletnek...
Ez nem teljesen világos
Rossz kifejezés
Ezt szerintem jobb lenne egyetlen egyszer, a változó deklarálásakor megtenni.
Nekem simán beleférne a PHP-be, hogy nekem kell deklarálnom a változót, sőt, a típusosság is. Ez szemlélet kérdése, de így inkább lehetne OOP nyelv. És lényegesen gyorsabb lenne.
Most konkrétan egy bit
Azt hiszem,
Tévedsz
OK, bocsánat,
Kiemeltem. temak/119974
Referencia szerint
Pontosan :), csak nevezzük
Csak ha már egyszer korrekt kérdés - korrekt válasz poszt, akkor legyenek tényleg korrektek a válaszok.
új kreálódik
Mert ha így van, akkor mégiscsak a referencia adódott át, csak épp nem használtuk semmire, hanem rögtön ugyanazt a nevet (qux) egy másik objektum referenciájaként definiáltuk. (?)
Olyasmi :), az objektumok
Vegyünk egy kevésbé bonyolult példát, azon talán jobban látszik a lényeg:
Értelmetlen
Már korábban leírtam, hogy mi
a
értéke megváltozik, akkor referencia szerint adtuk át, ha nem, akkor érték szerint. JavaScriptben csak érték szerint tudsz átadni értéket (ellentétben pl a C++-szal, ahol referencia szerint is át tudod adni). A JS referenciafogalma leginkább a pointereknek feleltethető meg.szerintem nem csak érték szerint lehet
Nem nevezném értéknek, ami az első paraméterben átadásra kerül.
Szerintem a javascriptben senkit nem érdekel, hogy az ilyen paraméterátadást "referenciának" vagy "pointernek" nevezzük. Ez már nem félreérthető, ha referenciának nevezzük.
Nem teljesen értem ennek mi
Valószínűleg az itt lévők többsége pontosan tudja, hogy Poetro kérdése mire vonatkozott, a választ hogy kell érteni, illetve tisztában van azzal, hogy JS-ben hogy működik a paraméterek átadása. Viszont nem kellene azt terjeszteni, hogy a JS pass-by-reference objektumok esetében (hiszen nem). Objektumokra csak referenciával lehet hivatkozni, és ezek a referenciák függvényhíváskor lemásolódnak (tehát pass-by-value).
Poetro-t idézném
Az objektum referencia "értéke", amire utalsz, az sohasem jelenik (és nem jelenhet) meg a JS-ben, és senkit sem érdekel. Nem lehet rá máshogyan az objektumra hivatkozni, ezért értelmetlen arról beszélni, hogy ez a sohasem látható érték épp megkettőződik-e függvényhíváskor, vagy sem. Az viszont fontos, hogy ilyenkor az objektum összes adata nem helyi értékként kerül kezelésre egy függvény belsejében, hanem "kimutat" az objektum eredeti elemeire. Pedig lehetne másképp is, például az egész objektum lemásolásra kerülhetne (mint szerializáláskor). Tehát erre a kettősségre kell rákérdezni, ezt kell tudni: egy akármilyen hosszú string paraméterként átadva megkettőződik a memóriában és "nem hat vissza" a változtatása az eredeti változó értékére, míg egy egészen kicsi objektum esetében sem történik ilyen másolás, és ezt kell ismernie a JS programozóknak.
Ha azt mondanánk, hogy az objektum by-pass-value, az sokkal megtévesztőbb lenne, mert akkor azzal úgy tűnne, hogy ezt a másolást, megkettőzést, és az ezzel járó "visszahatás hiányát" hangsúlyoznánk.
A "b"-t a függvény paraméterlistájában definiáltam, mindegy, hogy hozzányúltam-e, vagy sem. A "b" semmiképp nem nevezhető értéknek, mert nem használom értékként. A "b"-ben lévő értékhez nem is tudok hozzányúlni, és nem is akarok.
Ha nem nevezhető értéknek, akkor pedig a "referencia" elnevezés szerintem megfelelő ebben a kontextusban.
Én értem, hogy megtévesztő,
A szakirodalom a referencia szerinti átadáson (pass-by-reference) nem a JS-ben is meglévő viselkedést érti, így a további vita szerintem értelmetlen.
értelmetlen valóban
Jó lenne megállapodni, hogy ezt hogyan hívjuk (de amíg nincs ilyen megállapodás, addig szerintem többet mond, ha azt mondjuk, hogy referencia átadása történik, hiszen az is történik, a referencia átadása)
Te hogyan neveznéd ezt? (Tudom, by-pass-value-nak :-) )
(Érdekes és hasznos volt amiket írtál, tetszett, ne érts félre, de szerintem a JS kontextusában értelmetlen azt hangsúlyozni, hogy ez nem referencia átadás)
Tényleg jó lenne
Hívjuk pass-by-reference-nek.
Miért kéne máshogy nevezni,
pass-by-value
.Miért ne érdekelne? Neked mindegy, hogy egy meghívott függvény meg tudja változtatni a hívó oldal paraméterben átadott változóinak értékét, vagy sem? A
pass-by-reference
ugyanis ezt jelentené.Szerintem
Hány százalékban teljesült "a lényeg"?
Igen
De már olyan fura elméleti dologban vagyunk, amit kezdek nem átlátni. A fentebb említett nyelvekben a referencia átadásával valóban átadtam az egész objektumot. Itt ezt nem látom tisztán érvényesülni, de lehet, hogy én vagyok vak.
A kódod 6. sorát pedig nem értem: mi akar a második paraméter lenni, a fv-ed nem is csinál vele semmit. Oda csak simán
inc(a);
kéne, ha minden értékét növelni akarod.Ha pedig
inc(a[0]);
-ként hívod, akkor vagy tömböt csinálsz az a[0] értékéből, de inkább hibával elszáll, mert nem tömb az a[0] értéke.Hát foglalkozzunk vele (akár külön témában).
bocs
Egyébként szőrszálhasogatás folyik, semmi lényeges, szerintem ami fontos azt érted te is.
Köszi
Szőrszálhasogatás
De nem lehet, pont ezt mondja MadBence is, meg én is. Ezért nem pass-by-reference, hanem pass-by-value. A hívó oldalnak egy referenciája van egy másik valamire, nevezzük objektumnak az egyszerűség kedvéért. Ezt a referenciát másolja le és adja át a hívott kódnak (csak ezt, ami a referencia mögött van, azt nem), és a hívó referenciáját nem tudja megváltoztatni a hívott kód. A referencia mögött lévő objektum egy tulajdonságát lehet megváltoztatni, amihez a hívónak semmi köze nincs azon kívül, hogy ő is használja, így ez a változás hatással lesz rá.
Hogy egy kézzelfoghatóbb példát mondjak: Elviszed a barátnőd fodrászhoz. Más lesz a haja, észreveszed, örülsz (vagy nem), de továbbra is ő a barátnőd. Ez a pass-by-value. A pass-by-reference esetén benne van, hogy a fodrász megtréfál, és onnantól Chubaka lesz a barátnőd :) Még mindig szőrszálhasogatásnak látod a dolgot? :)
Kicsit pontosíts!
Ha ezt még helyreteszed, mindent tudni fogok a js referenciaátadásáról.... :)
Tisztázzuk
Rendben
Ahogy már korábban is
A JS paraméterátadása leginkább a 3. változatra hasonlít.
C++ példa:
Á
Az objektum referencia
Dehogynem jelenik meg,
[1]===[1]
azért lesz hamis, mert[1]
értéke nem "1-et tartalmazó tömb", hanem egy referencia egy 1-et tartalmazó tömbre (vö. mondjuk PHP-val, ahol a fenti kifejezés igaz). Hasonlóan, amikor azt mondod, hogyvar a = b;
, akkor a megkapja b értékét (megintcsak vö. a PHP-vel, ahol az érték ilyenkor nem egy referencia, hanem a tömb elemeinek listája.)Érdekes
Összességében nem értek egyet azzal, hogy a referencia ebben az esetben megjelenik a JS-ben, az viszont lehetséges, hogy a motor belső működése "kilátszik". Ettől függetlenül a referencia, mint számérték senkit sem érdekel a JS-ben és ez jó is így.
Ezekután a referencia átadása pont azt kell, hogy jelentse, amit a JS most csinál, vagyis a referencia értékének átadását, és ezt nem célszerű érték szerinti átadásnak nevezni még akkor sem, ha más nyelvekben a by-pass-value kategóriába tartozik (mivel más nyelvekben van ennek jelentősége)
var simple = 1;var complex =
Máshol is van
Csak zárójelben jegyzem meg, hogy Delphiben ugyanúgy van rá lehetőség, és ha jól emlékszem Java-ban is, de ezt nagyon rég nem használtam, ebben tévedhetek. Szóval nem egy szokatlan "jelenség" szerintem sem, kár, hogy js-ben nincs rá lehetőség.
A Java pass-by-value
pass-by-value
.http://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html
Érdemes picit elgondolkodni hogyan hat az encapsulationre, mint az OOP egyik alappillérére a
pass-by-reference
... A Java ilyen "csúfságokat" nem akar megengedni, ezért referenciákat adunk átpass-by-value
. Amúgy a referenciákkal kapcsolatos másik félreértésből eredeztetett "szivatós" Java interjúkérdés, hogy mit lép a Java, ha egy finalként deklarált objektum-on valamilyen mutator metódust hívsz. Meglepően gyakran mondják azt, hogy ezt nem teheted meg, azt gondolva, hogy a final immutable-é teszi az objektumot. Pedig a final csak annyit jelent (a java kód szintjén), hogy az adott referenciát nem módosíthatod a scope-on belül sem (metódus, objektum), míg a nem finalként deklarált referenciát igen, de apass-by-value
miatt ez a módosítás csak az adott scope-on belül fog megtörténni.Többen írták már, hogy a referencia, pointer átadása nem
pass-by-reference
. Bővebben ittAmit eddig senki nem vett észre
Épp azt látni sok helyen, amit Virág és inf3rno pedz: ha már munkáltatót képvisel valaki, akkor "nagyobbnak képzeli magát".
Hát Poetrora ez biztosan nem igaz, különben nem hozta volna létre ezt a bejegyzést sem, és ezért már önmagában szerintem "pontokat érdemel".
A másik, hogy az itt adott válaszokból - mint látható is! - ő maga is tanul, ezek szerint (és persze főnökei szerint :( ) nyilván változtat is az interjúztatásán.
Részemről biztos, hogy a kérdések legalább felére én visszakérdeznék, de nem merem azt mondani, hogy ez ezt vagy azt mindjárt elárul rólam (inf3rno, ez általánosítás).
De azt sem merném állítani, hogy ez jó így. Poetro-t és kommunikációját ismerve (laza, vidám) én azt mondom, hogy indulásnak jók ezek a kérdések, nyilván utána kell pontosítani rajta, ill. rávezetni, de ez nem gond, pont így lehet sokat megtudni elsőre a "vizsgázóról". Poetro nyugodtan felteheti ezeket a kérdéseket, ő messze nem az a "mumus", akire Virág (és részben inf3rno) gondol.
És valóban az alapokra megy, így első olvasatra be is sz....tam, gondolkodni kellett. Az a kérdés jó, amin gondolkodni kell.
Ha az a gondod, hogy mire is gondol a kérdező, kérdezz vissza - szerintem.
Mindezt, mint saját véleményemet írtam, és azzal, hogy magamat csak "gyenge-haladó" kategóriába sorolnám js-ből, bár lehet, hogy a "középhaladó" helyesebb, csak az önkritika...
A lényeg: már a témafelvetés becsülendő, és ismét sokat tanultam Poetro (és a töbiek) révén.
Így van
Feltűnt?
Köszi
Igen, köszönök szépen minden hozzászólást, önös érdekek is fűződnek ezen post létrehozásához. Meg akartam tudni mások hogyan vélekednek a kérdésekről, illetve hogy mit lenne érdemes változtatni.
Igen, próbálom rávezetni őket, példákat adok, ha nem tiszták elsőre a kérdések. Egyébként a telefonos interjó alatt a fentieken felül még vagy 30 kérdést felteszek az OOP, JS és CSS témaköréből, szóval nem ennyire szűkek a kérdések, inkább csak a legbonzolultabbakat, problémásabbakat szerettem volna felhozni.
Tetszik, hogy kivárod, amíg
Igazából nem direkt vártam,
Poetro-val azt hiszem egyszer találkoztam személyesen (WL sörözés), de azt hiszem mindketten vagyunk olyan nyitottak, hogy valamennyire meg is ismertük egymást. És hát az itteni tapasztalatokból is meg lehet magát az embert is ismerni.
Szerintem amennyire "kötekedős" voltál, az simán még belefér (tök jó, hogy te tudsz engem moderálni, nem fordítva :)), serkentette az egészséges vitát.
Összességében én ezt a bejegyzést bekeretezve elküldeném sok, akár nem IT-s cégnek is (főleg HR-eseknek), hogy lám-lám: így is lehet.
Poetro szerintem nagyon okosan és tervszerűen halad a célja felé, ráadásul nem egyedül, egy csapatban, ahol keresztül is kell tudnia vinni az elképzeléseit.
Kezdek vágyni egy Poetro-interjúra, de félek is az eredménytől... :) (Ez mondjuk jó, mert máris, interjú nélkül is tanulásra serkent.)
Ezek JS ismereti kérdések, és megfelelőek
Esetleg még lehetne egy kis jQuery:
- mi a különbség a és b között:
a = document.getElementById("foo");
b = $("#foo");
- hogyan kreálsz egy DIV-et jQuery-vel
Ilyen nehézségű kérdésektől még nem lesz a jelentkezőnek kiütése, ti. hogy túl trükkös a kérdés vagy túl sok erőfeszítést igényel a válasz.
A következő lépcső egy jó kis NPP-teszt lehet (Non-Programming Programmer szűrés).
Az első kérdésed esetén, ha
hogy semmi, mindkét esetben megkapod a kért elemet (én legalábbis ezt mondanám),
mert egy szinten túl észrevétlenül kezeled a különbségeket.
egyet nem értésem
Ha nincs értéke, akkor undefined kellene legyen az értéke (tehát végülis van értéke). A null igenis érték, méghozzá null, és azért van, hogy nem létező objektumot reprezentáljon.
Ha ezzel az értékkel hozol létre változót - ami nem objektumot tartalmaz, nem követsz el nagy bajt, de alapvetően hibásan használod a nyelvet.
A különbség - remélem nem mondok újdonságot - a typeof operátornál jön elő aholis typeof null === "object" és nem null a typeof undefined pedig "undefined" ahogy várjuk.
Ezért tér vissza minden DOM metódus null-lal ha nem talál objektumot (.queryAll) és nem undefined. Szerintem.
Nem null az
Nekem üres NodeListet ad vissza. Firefox getElementsBy* esetén HTMLCollectiont.
OK
Szőrszálhasogatás
igen, szerintem is
+1
typeof null === "object"
Történt ugyanis, hogy az első js implementációban az egyes JS oldali változók C világbeli mutatóit tartalmazó terület alsó pár bitjeiben tárolta tárolta az adott változó típusát (ezek adott architektúrán egy C "long" méretűek így volt hely, előbb jsword majd jsval lesz ebből a longból) és a 0 -ás érték az "object" típust reprezentálta.
A typoeof operátor csak megnézte a mutatott memóriaterület alsó 3 bitjét (JSVAL_IS_OBJECT(v)) ami simán össze "&"-eli a típus bitmaskokkal, és ez alapján döntött.
A JS-ben lévő null értéket C oldalon a 0 szám literál jsval-ba való castolása reprezentálja aminek alsó pár bitje bizony 0 bitekkel van feltöltve (az egész csupa 0 bit) és így illeszkedik object bitmaskjára és typeof már adja is vissza vidáman, hogy "object".
(Itt jegyezném meg, hogy minden szimpátiám a jövő archeológusaié akiknek esetleg forráskód nélkül kell felderíteni valamit :P)
Amennyire én tudom semmiféle "reprezentáljuk azt, hogy..." gondolat nem volt mögötte eredetileg, sőt maga Brendan Eich is ki akarta javítani ezt ES6-ban, de végül nem sikerült:
http://wiki.ecmascript.org/doku.php?id=harmony:typeof_null
(kettőspontot nem eszi meg bbcode url...)
"a jövő archeológusai..."
OFF: Még szerencse hogy a digitális világ nem marad fent elég hosszan hogy az archeológusok is tanuljanak belőle :-)
Esetleg...
Én egyébként azért nem megyek ilyen interjúkra, mert nem tudok js nyelven. Én inkább szeretem a dolgokat php-val és css-sel megoldani. Ahol elég ez is, oda se megyek csak azért, mert kezdetleges tudással rendelkezek.
kesereg..
interjú kérdések
Delegálás?
delegálás vs öröklődés
Természetesen az öröklődés és delegálás fizikailag nem zárja ki egymást, mindkettőnek megvan az előnye és a hátránya, de pl. a többszörös öröklés tudtom szerint jelenleg még csak mixinekkel oldható meg JavaScriptben (ha van más megoldás/ötlet, kérlek osszátok meg), polimorfizmus meg egyszerűen nem megoldható (nincs relatív referencia az ős- konstruktorokra, ilyenkor jöhet a this és call(this) ami nehezen áttekinthető/nyomon követhető és kezelhető kódot eredményez).
Az is tény, hogy alap objektumok szuperkonstruktorait sem illik megváltoztatni a prototype chainben és a prototípusok mechanizmusait csak körültekintően lehet módosítani - jobb esetben sehogy, bár itt is a böngésző különbségek adnak lehetőséget egy kis bizonytalanságra :-) (hasOwnProperty vs. hasOwnProperty.call ill. FF __proto__ témakör - ez szintén jó vizsgakérdés lehet mert erősen kerülendő a legtöbb kódban).
Máshogyan megfogalmazva az osztály szintű öröklődés az egy interfész/tervrajz kiegészítése, a prototype viszont egy bizonyos viselkedés delegálása más objektumokra. Látszólag azonosnak tűnő definíciók, de a különbségek összetettebb rendszerek esetében halmozottan jelentkeznek (főleg JavaScriptnél ahol a prototype gyakorlatilag csak egy delegate kapcsolat két objektum között). Ha megpróbáljuk a "class-ikus" öröklődést imitálni JavaScriptben, akkor pont a JS-motorok natív támogatottságú dinamikusságát lehet elveszíteni vele (ezt nem tudom jelenleg másképpen/jobban megfogalmazni).