Ukryte funkcje JavaScript? [Zamknięte]

Jak myślisz, jakie „ukryte funkcje” JavaScript powinien wiedzieć każdy programista?

Po obejrzeniu doskonałej jakości odpowiedzi na następujące pytania pomyślałem, że nadszedł czas, aby poprosić o JavaScript.

• Ukryte funkcje HTML
• Ukryte funkcje CSS
• Ukryte funkcje PHP
• Ukryte funkcje ASP.NET
• Ukryte funkcje C #
• Ukryte funkcje Java
• Ukryte funkcje Pythona

Mimo że JavaScript jest obecnie prawdopodobnie najważniejszym językiem po stronie klienta (wystarczy zapytać Google), zaskakujące jest to, jak mało twórców stron internetowych docenia jego moc.

Nie musisz definiować żadnych parametrów dla funkcji. Możesz po prostu użyć argumentsobiektu podobnego do tablicy funkcji .

function sum() {
    var retval = 0;
    for (var i = 0, len = arguments.length; i < len; ++i) {
        retval += arguments[i];
    }
    return retval;
}

sum(1, 2, 3) // returns 6

Mógłbym zacytować większość doskonałej książki Douglasa Crockforda JavaScript: The Good Parts .

Ale wezmę tylko jeden, zawsze używaj ===i !==zamiast ==i!=

alert('' == '0'); //false
alert(0 == ''); // true
alert(0 =='0'); // true

==nie jest przechodni. Jeśli ===go użyjesz , wartość false dla wszystkich tych oświadczeń będzie zgodna z oczekiwaniami.

Funkcje są pierwszorzędnymi obywatelami w JavaScript:

var passFunAndApply = function (fn,x,y,z) { return fn(x,y,z); };

var sum = function(x,y,z) {
  return x+y+z;
};

alert( passFunAndApply(sum,3,4,5) ); // 12

Funkcjonalne techniki programowania można wykorzystać do pisania eleganckiego javascript .

W szczególności funkcje mogą być przekazywane jako parametry, np. Array.filter () akceptuje wywołanie zwrotne:

[1, 2, -1].filter(function(element, index, array) { return element > 0 });
// -> [1,2]

Możesz także zadeklarować funkcję „prywatną”, która istnieje tylko w zakresie określonej funkcji:

function PrintName() {
    var privateFunction = function() { return "Steve"; };
    return privateFunction();
}

Możesz użyć w operatora , aby sprawdzić, czy w obiekcie istnieje klucz:

var x = 1;
var y = 3;
var list = {0:0, 1:0, 2:0};
x in list; //true
y in list; //false
1 in list; //true
y in {3:0, 4:0, 5:0}; //true

Jeśli okaże się, że literały obiektów są zbyt brzydkie, możesz połączyć je z bezparametrową wskazówką funkcji:

function list()
 { var x = {};
   for(var i=0; i < arguments.length; ++i) x[arguments[i]] = 0;
   return x
 }

 5 in list(1,2,3,4,5) //true

Przypisywanie wartości domyślnych do zmiennych

Możesz użyć logicznego lub operatora ||w wyrażeniu przypisania, aby podać wartość domyślną:

var a = b || c;

aZmienna będzie wartość ctylko wtedy, gdy bjest falsy (jeśli jest null, false, undefined, 0, empty string, lub NaN), w przeciwnym razie abędzie uzyskać wartość b.

Jest to często przydatne w funkcjach, gdy chcesz nadać argumentowi domyślną wartość, jeśli nie zostanie podany:

function example(arg1) {
  arg1 || (arg1 = 'default value');
}

Przykład powrotu do IE w procedurach obsługi zdarzeń:

function onClick(e) {
    e || (e = window.event);
}

Następujące funkcje językowe są z nami od dawna, wszystkie implementacje JavaScript obsługują je, ale nie były częścią specyfikacji, dopóki ECMAScript 5. edycja :

debuggeroświadczenie

Opisane w: § 12.15 Oświadczenie debuggera

Ta instrukcja pozwala programowo wstawiać punkty przerwania w kodzie tylko przez:

// ...
debugger;
// ...

Jeśli debugger jest obecny lub aktywny, spowoduje to jego natychmiastowe przerwanie, bezpośrednio na tej linii.

W przeciwnym razie, jeśli debugger nie jest obecny lub aktywny, to instrukcja nie ma zauważalnego wpływu.

Wieloliniowe literały łańcuchowe

Opisane w: § 7.8.4 Literałów ciągowych

var str = "This is a \
really, really \
long line!";

Musisz być ostrożny, ponieważ znak obok znaku \ musi być zakończeniem linii, jeśli \na przykład po spacji masz kod, kod będzie wyglądał dokładnie tak samo, ale podniesie go SyntaxError.

JavaScript nie ma zasięgu blokowego (ale ma zamknięcie, więc nazwijmy go nawet?).

var x = 1;
{
   var x = 2;
}
alert(x); // outputs 2

Możesz uzyskać dostęp do właściwości obiektu za pomocą []zamiast.

Pozwala to wyszukać właściwość pasującą do zmiennej.

obj = {a:"test"};
var propname = "a";
var b = obj[propname];  // "test"

Można go również użyć do uzyskania / ustawienia właściwości obiektu, których nazwa nie jest prawnym identyfikatorem.

obj["class"] = "test";  // class is a reserved word; obj.class would be illegal.
obj["two words"] = "test2"; // using dot operator not possible with the space.

Niektórzy nie wiedzą o tym i używają eval () w ten sposób, co jest naprawdę złym pomysłem :

var propname = "a";
var a = eval("obj." + propname);

Jest to trudniejsze do odczytania, trudniejsze do znalezienia błędów (nie można użyć jslinta), wolniejsze do wykonania i może prowadzić do exploitów XSS.

Jeśli korzystasz z Googling w poszukiwaniu porządnego odwołania do JavaScript w danym temacie, dołącz słowo kluczowe „mdc” do zapytania, a pierwsze wyniki będą pochodzić z Centrum deweloperów Mozilla. Nie noszę ze sobą żadnych odniesień ani książek offline. Zawsze używam sztuczki „mdc”, aby bezpośrednio dostać się do tego, czego szukam. Na przykład:

Google: javascript array sort mdc
(w większości przypadków możesz pominąć „javascript”)

Aktualizacja: Mozilla Developer Center została przemianowana na Mozilla Developer Network . Sztuczka słów kluczowych „mdc” nadal działa, ale wkrótce będziemy musieli zacząć korzystać z „mdn” .

Może to trochę oczywiste dla niektórych ...

Zainstaluj Firebug i użyj console.log („cześć”). O wiele lepsze niż używanie random alert ();, które pamiętam wiele lat temu.

Metody prywatne

Obiekt może mieć metody prywatne.

function Person(firstName, lastName) {
    this.firstName = firstName;
    this.lastName = lastName;

    // A private method only visible from within this constructor
    function calcFullName() {
       return firstName + " " + lastName;    
    }

    // A public method available to everyone
    this.sayHello = function () {
        alert(calcFullName());
    }
}

//Usage:
var person1 = new Person("Bob", "Loblaw");
person1.sayHello();

// This fails since the method is not visible from this scope
alert(person1.calcFullName());

Wspomniany również w „Javascript: The Good Parts” Crockforda:

parseInt()jest niebezpieczny. Jeśli przekażesz ciąg bez informowania go o właściwej podstawie, może zwrócić nieoczekiwane liczby. Na przykład parseInt('010')zwraca 8, a nie 10. Przekazywanie bazy do analizy składni powoduje, że działa ona poprawnie:

parseInt('010') // returns 8! (in FF3)
parseInt('010', 10); // returns 10 because we've informed it which base to work with.

Funkcje są obiektami i dlatego mogą mieć właściwości.

fn = funkcja (x) {
   // ...
}

fn.foo = 1;

fn.next = funkcja (y) {
  //
}

Musiałbym powiedzieć, że funkcje wykonujące się same.

(function() { alert("hi there");})();

Ponieważ JavaScript nie ma zasięgu blokowego , możesz użyć funkcji samowykonywającej się, jeśli chcesz zdefiniować zmienne lokalne:

(function() {
  var myvar = 2;
  alert(myvar);
})();

W tym przypadku myvarnie zakłóca ani nie zanieczyszcza zasięgu globalnego i znika po zakończeniu funkcji.

Dowiedz się, ile parametrów oczekuje funkcja

function add_nums(num1, num2, num3 ){
    return num1 + num2 + num3;
}
add_nums.length // 3 is the number of parameters expected.

Dowiedz się, ile parametrów odbiera funkcja

function add_many_nums(){
    return arguments.length;
}    
add_many_nums(2,1,122,12,21,89); //returns 6

Oto kilka interesujących rzeczy:

• Porównując NaNz niczego (nawet NaN) jest zawsze fałszywe, który zawiera ==, <i >.
• NaN Oznacza nie liczbę, ale jeśli poprosisz o typ, faktycznie zwraca liczbę.
• Array.sort może przyjmować funkcję komparatora i jest wywoływany przez sterownik podobny do szybkiego (zależy od implementacji).
• Wyrażenia regularne „stałe” mogą utrzymywać stan, podobnie jak ostatnia pasująca rzecz.
• Niektóre wersje JavaScript pozwalają na dostęp $0, $1, $2członkowie na regex.
• nulljest niepodobne do niczego innego. Nie jest to ani obiekt, wartość logiczna, liczba, ciąg znaków ani undefined. To trochę jak „alternatywny” undefined. (Uwaga:typeof null == "object" )
• W najbardziej oddalonym kontekście this zwraca obiekt [Global] którego w przeciwnym razie nie można nazwać.
• Deklarowanie zmiennej za pomocą var , zamiast polegać tylko na automatycznej deklaracji zmiennej, daje środowisku wykonawczemu realną szansę na zoptymalizowanie dostępu do tej zmiennej
• The withKonstrukt zniszczy takie optimzations
• Nazwy zmiennych mogą zawierać znaki Unicode.
• Wyrażenia regularne JavaScript nie są w rzeczywistości regularne. Opierają się one na wyrażeniach regularnych Perla i możliwe jest konstruowanie wyrażeń z wyprzedzeniem, których ocena zajmuje bardzo, bardzo dużo czasu.
• Bloki można oznaczyć i wykorzystać jako cele break. Pętle mogą być oznaczone i używane jako cel continue.
• Tablice nie są rzadkie. Ustawienie 1000-tego elementu pustej tablicy powinno być wypełnione undefined. (zależy od implementacji)
• if (new Boolean(false)) {...} wykona {...}blok
• Mechanizmy wyrażeń regularnych JavaScript są specyficzne dla implementacji: np. Możliwe jest pisanie „nieprzenośnych” wyrażeń regularnych.

[zaktualizowano trochę w odpowiedzi na dobre komentarze; zobacz komentarze]

Wiem, że jestem spóźniony na imprezę, ale nie mogę uwierzyć +, że użyteczność operatora nie została wspomniana poza „konwersją czegokolwiek na liczbę”. Może tak dobrze ukryta jest funkcja?

// Quick hex to dec conversion:
+"0xFF";              // -> 255

// Get a timestamp for now, the equivalent of `new Date().getTime()`:
+new Date();

// Safer parsing than parseFloat()/parseInt()
parseInt("1,000");    // -> 1, not 1000
+"1,000";             // -> NaN, much better for testing user input
parseInt("010");      // -> 8, because of the octal literal prefix
+"010";               // -> 10, `Number()` doesn't parse octal literals 

// A use case for this would be rare, but still useful in cases
// for shortening something like if (someVar === null) someVar = 0;
+null;                // -> 0;

// Boolean to integer
+true;                // -> 1;
+false;               // -> 0;

// Other useful tidbits:
+"1e10";              // -> 10000000000
+"1e-4";              // -> 0.0001
+"-12";               // -> -12

Oczywiście możesz to wszystko zrobić za pomocą Number(), ale+ operator jest o wiele ładniejszy!

Możesz także zdefiniować numeryczną wartość zwracaną dla obiektu, zastępując valueOf()metodę prototypu . Żadna konwersja liczb wykonana na tym obiekcie nie spowoduje NaN, ale zwróci wartość valueOf()metody:

var rnd = {
    "valueOf": function () { return Math.floor(Math.random()*1000); }
};
+rnd;               // -> 442;
+rnd;               // -> 727;
+rnd;               // -> 718;

„ Metody rozszerzeń w JavaScript ” za pośrednictwem właściwości prototype.

Array.prototype.contains = function(value) {  
    for (var i = 0; i < this.length; i++) {  
        if (this[i] == value) return true;  
    }  
    return false;  
}

Spowoduje to dodanie containsmetody do wszystkich Arrayobiektów. Możesz wywołać tę metodę za pomocą tej składni

var stringArray = ["foo", "bar", "foobar"];
stringArray.contains("foobar");

Aby poprawnie usunąć właściwość z obiektu, powinieneś usunąć właściwość zamiast po prostu ustawić ją na niezdefiniowaną :

var obj = { prop1: 42, prop2: 43 };

obj.prop2 = undefined;

for (var key in obj) {
    ...

Właściwość prop2 nadal będzie częścią iteracji. Jeśli chcesz całkowicie pozbyć się prop2 , powinieneś zamiast tego:

delete obj.prop2;

Właściwość prop2 nie będzie się już pojawiać podczas iteracji po właściwościach.

with.

Jest rzadko używany i, szczerze mówiąc, rzadko przydatny ... Ale w ograniczonych okolicznościach ma swoje zastosowania.

Na przykład: literały obiektów są bardzo przydatne do szybkiego ustawiania właściwości nowego obiektu. Ale co, jeśli musisz zmienić połowę właściwości istniejącego obiektu?

var user = 
{
   fname: 'Rocket', 
   mname: 'Aloysus',
   lname: 'Squirrel', 
   city: 'Fresno', 
   state: 'California'
};

// ...

with (user)
{
   mname = 'J';
   city = 'Frostbite Falls';
   state = 'Minnesota';
}

Alan Storm wskazuje, że może to być nieco niebezpieczne: jeśli obiekt użyty jako kontekst nie ma przypisanej jednej z właściwości, zostanie rozwiązany w zewnętrznym zakresie, prawdopodobnie tworząc lub nadpisując zmienną globalną. Jest to szczególnie niebezpieczne, jeśli jesteś przyzwyczajony do pisania kodu do pracy z obiektami, w których właściwości z wartościami domyślnymi lub pustymi pozostają niezdefiniowane:

var user = 
{
   fname: "John",
// mname definition skipped - no middle name
   lname: "Doe"
};

with (user)
{
   mname = "Q"; // creates / modifies global variable "mname"
}

Dlatego prawdopodobnie dobrym pomysłem jest uniknięcie użycia withinstrukcji do takiego przypisania.

Zobacz także: Czy istnieją uzasadnione zastosowania wyrażenia „with” JavaScript?

Metody (lub funkcje) można wywoływać na obiektach, które nie są typu, z którym zostały zaprojektowane. Świetnie nadaje się do wywoływania metod rodzimych (szybkich) na obiektach niestandardowych.

var listNodes = document.getElementsByTagName('a');
listNodes.sort(function(a, b){ ... });

Ten kod ulega awarii, ponieważ listNodesnie jest toArray

Array.prototype.sort.apply(listNodes, [function(a, b){ ... }]);

Ten kod działa, ponieważ listNodesdefiniuje wystarczającą liczbę właściwości podobnych do tablicy (operator długości, []) do użycia przez sort().

Dziedziczenie prototypowe (spopularyzowane przez Douglasa Crockforda) całkowicie rewolucjonizuje sposób myślenia o mnóstwie rzeczy w JavaScript.

Object.beget = (function(Function){
    return function(Object){
        Function.prototype = Object;
        return new Function;
    }
})(function(){});

To zabójca! Szkoda, że ​​prawie nikt go nie używa.

Pozwala „spłodzić” nowe wystąpienia dowolnego obiektu, rozszerzyć je, zachowując (żywy) prototypowy link dziedziczący do innych właściwości. Przykład:

var A = {
  foo : 'greetings'
};  
var B = Object.beget(A);

alert(B.foo);     // 'greetings'

// changes and additionns to A are reflected in B
A.foo = 'hello';
alert(B.foo);     // 'hello'

A.bar = 'world';
alert(B.bar);     // 'world'


// ...but not the other way around
B.foo = 'wazzap';
alert(A.foo);     // 'hello'

B.bar = 'universe';
alert(A.bar);     // 'world'

Niektórzy nazwaliby to kwestią gustu, ale:

aWizz = wizz || "default";
// same as: if (wizz) { aWizz = wizz; } else { aWizz = "default"; }

Operator trójnożny można powiązać, aby działał jak Scheme (cond ...):

(cond (predicate  (action  ...))
      (predicate2 (action2 ...))
      (#t         default ))

można zapisać jako ...

predicate  ? action( ... ) :
predicate2 ? action2( ... ) :
             default;

Jest to bardzo „funkcjonalne”, ponieważ rozgałęzia kod bez skutków ubocznych. Więc zamiast:

if (predicate) {
  foo = "one";
} else if (predicate2) {
  foo = "two";
} else {
  foo = "default";
}

Możesz pisać:

foo = predicate  ? "one" :
      predicate2 ? "two" :
                   "default";

Działa też dobrze z rekurencją :)

Liczby są również obiektami. Możesz więc robić fajne rzeczy, takie jak:

// convert to base 2
(5).toString(2) // returns "101"

// provide built in iteration
Number.prototype.times = function(funct){
  if(typeof funct === 'function') {
    for(var i = 0;i < Math.floor(this);i++) {
      funct(i);
    }
  }
  return this;
}


(5).times(function(i){
  string += i+" ";
});
// string now equals "0 1 2 3 4 "

var x = 1000;

x.times(function(i){
  document.body.innerHTML += '<p>paragraph #'+i+'</p>';
});
// adds 1000 parapraphs to the document

Co powiesz na zamknięcia w JavaScript (podobne do anonimowych metod w C # v2.0 +). Możesz utworzyć funkcję, która tworzy funkcję lub „wyrażenie”.

Przykład zamknięć :

//Takes a function that filters numbers and calls the function on 
//it to build up a list of numbers that satisfy the function.
function filter(filterFunction, numbers)
{
  var filteredNumbers = [];

  for (var index = 0; index < numbers.length; index++)
  {
    if (filterFunction(numbers[index]) == true)
    {
      filteredNumbers.push(numbers[index]);
    }
  }
  return filteredNumbers;
}

//Creates a function (closure) that will remember the value "lowerBound" 
//that gets passed in and keep a copy of it.
function buildGreaterThanFunction(lowerBound)
{
  return function (numberToCheck) {
    return (numberToCheck > lowerBound) ? true : false;
  };
}

var numbers = [1, 15, 20, 4, 11, 9, 77, 102, 6];

var greaterThan7 = buildGreaterThanFunction(7);
var greaterThan15 = buildGreaterThanFunction(15);

numbers = filter(greaterThan7, numbers);
alert('Greater Than 7: ' + numbers);

numbers = filter(greaterThan15, numbers);
alert('Greater Than 15: ' + numbers);

Możesz także rozszerzyć (odziedziczyć) klasy i przesłonić właściwości / metody za pomocą prototypowej łyżki łańcuchowej16, o której wspominano.

W poniższym przykładzie tworzymy klasę Pet i definiujemy niektóre właściwości. Zastępujemy również metodę .toString () odziedziczoną z Object.

Następnie tworzymy klasę Dog, która rozszerza Pet i zastępuje metodę .toString () ponownie zmieniając jej zachowanie (polimorfizm). Ponadto dodajemy inne właściwości do klasy potomnej.

Następnie sprawdzamy łańcuch dziedziczenia, aby pokazać, że pies jest nadal typu pies, typu zwierzę i typu obiekt.

// Defines a Pet class constructor 
function Pet(name) 
{
    this.getName = function() { return name; };
    this.setName = function(newName) { name = newName; };
}

// Adds the Pet.toString() function for all Pet objects
Pet.prototype.toString = function() 
{
    return 'This pets name is: ' + this.getName();
};
// end of class Pet

// Define Dog class constructor (Dog : Pet) 
function Dog(name, breed) 
{
    // think Dog : base(name) 
    Pet.call(this, name);
    this.getBreed = function() { return breed; };
}

// this makes Dog.prototype inherit from Pet.prototype
Dog.prototype = new Pet();

// Currently Pet.prototype.constructor
// points to Pet. We want our Dog instances'
// constructor to point to Dog.
Dog.prototype.constructor = Dog;

// Now we override Pet.prototype.toString
Dog.prototype.toString = function() 
{
    return 'This dogs name is: ' + this.getName() + 
        ', and its breed is: ' + this.getBreed();
};
// end of class Dog

var parrotty = new Pet('Parrotty the Parrot');
var dog = new Dog('Buddy', 'Great Dane');
// test the new toString()
alert(parrotty);
alert(dog);

// Testing instanceof (similar to the `is` operator)
alert('Is dog instance of Dog? ' + (dog instanceof Dog)); //true
alert('Is dog instance of Pet? ' + (dog instanceof Pet)); //true
alert('Is dog instance of Object? ' + (dog instanceof Object)); //true

Obie odpowiedzi na to pytanie były kodami zmodyfikowanymi ze świetnego artykułu MSDN autorstwa Raya Djajadinaty.

Możesz wychwycić wyjątki w zależności od ich rodzaju. Cytat z MDC :

try {
   myroutine(); // may throw three exceptions
} catch (e if e instanceof TypeError) {
   // statements to handle TypeError exceptions
} catch (e if e instanceof RangeError) {
   // statements to handle RangeError exceptions
} catch (e if e instanceof EvalError) {
   // statements to handle EvalError exceptions
} catch (e) {
   // statements to handle any unspecified exceptions
   logMyErrors(e); // pass exception object to error handler
}

UWAGA: warunkowe klauzule catch są rozszerzeniem Netscape (a zatem Mozilla / Firefox), które nie jest częścią specyfikacji ECMAScript i dlatego nie można na nim polegać, z wyjątkiem określonych przeglądarek.

Z czubka mojej głowy ...

Funkcje

arguments.callee odnosi się do funkcji, która obsługuje zmienną „arguments”, więc można jej użyć do rekurencji funkcji anonimowych:

var recurse = function() {
  if (condition) arguments.callee(); //calls recurse() again
}

Jest to przydatne, jeśli chcesz zrobić coś takiego:

//do something to all array items within an array recursively
myArray.forEach(function(item) {
  if (item instanceof Array) item.forEach(arguments.callee)
  else {/*...*/}
})

Obiekty

Ciekawa rzecz w elementach obiektu: mogą mieć dowolny ciąg znaków jako swoje nazwy:

//these are normal object members
var obj = {
  a : function() {},
  b : function() {}
}
//but we can do this too
var rules = {
  ".layout .widget" : function(element) {},
  "a[href]" : function(element) {}
}
/* 
this snippet searches the page for elements that
match the CSS selectors and applies the respective function to them:
*/
for (var item in rules) {
  var elements = document.querySelectorAll(rules[item]);
  for (var e, i = 0; e = elements[i++];) rules[item](e);
}

Smyczki

String.split może przyjmować wyrażenia regularne jako parametry:

"hello world   with  spaces".split(/\s+/g);
//returns an array: ["hello", "world", "with", "spaces"]

String.replace może przyjmować wyrażenie regularne jako parametr wyszukiwania i funkcję jako parametr zastępczy:

var i = 1;
"foo bar baz ".replace(/\s+/g, function() {return i++});
//returns "foo1bar2baz3"

Przez większość czasu możesz używać obiektów zamiast przełączników.

function getInnerText(o){
    return o === null? null : {
        string: o,
        array: o.map(getInnerText).join(""),
        object:getInnerText(o["childNodes"])
    }[typeis(o)];
}

Aktualizacja: jeśli obawiasz się, że przypadki oceniania z wyprzedzeniem są nieefektywne (dlaczego martwisz się wydajnością już na wczesnym etapie projektowania programu?), Możesz zrobić coś takiego:

function getInnerText(o){
    return o === null? null : {
        string: function() { return o;},
        array: function() { return o.map(getInnerText).join(""); },
        object: function () { return getInnerText(o["childNodes"]; ) }
    }[typeis(o)]();
}

Jest to bardziej uciążliwe, aby pisać (lub czytać) niż przełącznik lub obiekt, ale zachowuje zalety korzystania z obiektu zamiast przełącznika, szczegółowo opisane w sekcji komentarzy poniżej. Ten styl ułatwia także przekształcenie go w odpowiednią „klasę”, gdy tylko dorośnie.

update2: staje się to dzięki proponowanym rozszerzeniom składni dla ES.next

let getInnerText = o -> ({
    string: o -> o,
    array: o -> o.map(getInnerText).join(""),
    object: o -> getInnerText(o["childNodes"])
}[ typeis o ] || (->null) )(o);

Pamiętaj, aby użyć metody hasOwnProperty podczas iteracji po właściwościach obiektu:

for (p in anObject) {
    if (anObject.hasOwnProperty(p)) {
        //Do stuff with p here
    }
}

Odbywa się to, aby uzyskać dostęp tylko do bezpośrednich właściwości obiektu anObject , a nie korzystać z właściwości znajdujących się w dół łańcucha prototypów.

Zmienne prywatne z interfejsem publicznym

Używa schludnej sztuczki z definicją funkcji wywołującej. Wszystko w zwracanym obiekcie jest dostępne w interfejsie publicznym, a wszystko inne jest prywatne.

var test = function () {
    //private members
    var x = 1;
    var y = function () {
        return x * 2;
    };
    //public interface
    return {
        setx : function (newx) {
            x = newx;
        },
        gety : function () {
            return y();
        }
    }
}();

assert(undefined == test.x);
assert(undefined == test.y);
assert(2 == test.gety());
test.setx(5);
assert(10 == test.gety());