Fitur Tersembunyi dari JavaScript? [Tutup]

Menurut Anda, "Fitur Tersembunyi" apa yang harus diketahui oleh setiap programmer?

Setelah melihat kualitas yang sangat baik dari jawaban untuk pertanyaan-pertanyaan berikut, saya pikir sudah waktunya untuk meminta JavaScript.

• Fitur Tersembunyi dari HTML
• Fitur Tersembunyi dari CSS
• Fitur Tersembunyi dari PHP
• Fitur Tersembunyi dari ASP.NET
• Fitur Tersembunyi C #
• Fitur Tersembunyi di Jawa
• Fitur Tersembunyi Python

Meskipun JavaScript bisa dibilang adalah bahasa Sisi Klien yang paling penting saat ini (tanyakan saja pada Google), mengejutkan betapa sedikit pengembang web yang paling menghargai betapa kuatnya sebenarnya.

Anda tidak perlu menentukan parameter apa pun untuk suatu fungsi. Anda bisa menggunakan argumentsobjek seperti array fungsi .

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

Saya bisa mengutip sebagian besar buku hebat Douglas Crockford, JavaScript: The Good Parts .

Tapi saya akan mengambil satu untuk Anda, selalu gunakan ===dan !==bukan ==dan!=

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

==tidak transitif. Jika Anda menggunakannya ===akan memberikan false untuk semua pernyataan ini seperti yang diharapkan.

Fungsi adalah warga negara kelas satu dalam 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

Teknik pemrograman fungsional dapat digunakan untuk menulis javascript elegan .

Khususnya, fungsi dapat dikirimkan sebagai parameter, misalnya Array.filter () menerima panggilan balik:

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

Anda juga dapat mendeklarasikan fungsi "pribadi" yang hanya ada dalam lingkup fungsi tertentu:

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

Anda dapat menggunakan di operator untuk memeriksa apakah kunci ada dalam suatu objek:

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

Jika Anda menemukan objek literal terlalu buruk, Anda dapat menggabungkannya dengan tip fungsi tanpa parameter:

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

Menetapkan nilai default ke variabel

Anda bisa menggunakan logika atau operator ||dalam ekspresi penugasan untuk memberikan nilai default:

var a = b || c;

The avariabel akan mendapatkan nilai chanya jika badalah falsy (jika adalah null, false, undefined, 0, empty string, atau NaN), jika tidak aakan mendapatkan nilai b.

Ini sering berguna dalam fungsi, ketika Anda ingin memberikan nilai default untuk argumen jika tidak disediakan:

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

Contoh fallback IE dalam event handler:

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

Fitur bahasa berikut telah bersama kami sejak lama, semua implementasi JavaScript mendukungnya, tetapi mereka tidak menjadi bagian dari spesifikasi sampai ECMAScript Edisi 5 :

The debuggerpernyataan

Dijelaskan dalam: § 12.15 Pernyataan debugger

Pernyataan ini memungkinkan Anda untuk meletakkan breakpoints secara terprogram dalam kode Anda hanya dengan:

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

Jika debugger ada atau aktif, itu akan membuatnya segera rusak, tepat di baris itu.

Jika tidak, jika debugger tidak ada atau aktif pernyataan ini tidak memiliki efek yang dapat diamati.

Multiline String literals

Dijelaskan dalam: § 7.8.4 String Literals

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

Anda harus berhati-hati karena karakter di sebelah \ harus menjadi terminator garis, jika Anda memiliki spasi setelah \misalnya, kode akan terlihat persis sama, tetapi akan menaikkan a SyntaxError.

JavaScript tidak memiliki ruang lingkup blok (tetapi ia memiliki penutupan jadi mari kita sebut itu genap?).

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

Anda dapat mengakses properti obyek dengan []bukannya.

Ini memungkinkan Anda mencari properti yang cocok dengan variabel.

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

Anda juga dapat menggunakan ini untuk mendapatkan / mengatur properti objek yang namanya bukan pengenal hukum.

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.

Beberapa orang tidak mengetahui hal ini dan akhirnya menggunakan eval () seperti ini, yang merupakan ide yang sangat buruk :

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

Ini lebih sulit untuk dibaca, lebih sulit untuk menemukan kesalahan dalam (tidak dapat menggunakan jslint), lebih lambat untuk dieksekusi, dan dapat menyebabkan eksploitasi XSS.

Jika Anda mencari Google untuk referensi JavaScript yang layak pada topik tertentu, sertakan kata kunci "mdc" dalam permintaan Anda dan hasil pertama Anda akan berasal dari Pusat Pengembang Mozilla. Saya tidak membawa referensi atau buku luring apa pun. Saya selalu menggunakan trik kata kunci "mdc" untuk langsung mendapatkan apa yang saya cari. Sebagai contoh:

Google: javascript array sort mdc
(dalam kebanyakan kasus Anda dapat menghilangkan "javascript")

Pembaruan: Pusat Pengembang Mozilla telah diubah namanya menjadi Jaringan Pengembang Mozilla . Trik kata kunci "mdc" masih berfungsi, tetapi segera kita mungkin harus mulai menggunakan "mdn" .

Mungkin sedikit jelas bagi beberapa ...

Instal Firebug dan gunakan console.log ("hello"). Jauh lebih baik daripada menggunakan peringatan acak (); yang saya ingat pernah saya lakukan beberapa tahun yang lalu.

Metode Pribadi

Objek dapat memiliki metode pribadi.

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());

Juga disebutkan dalam "Javascript: The Good Parts" Crockford:

parseInt()berbahaya. Jika Anda memberikannya string tanpa memberi tahu basis yang tepat, itu dapat mengembalikan angka yang tidak terduga. Misalnya parseInt('010')mengembalikan 8, bukan 10. Melewati basis ke parseInt membuatnya berfungsi dengan benar:

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

Fungsi adalah objek dan karenanya dapat memiliki properti.

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

fn.foo = 1;

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

Saya harus mengatakan fungsi self-executing.

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

Karena Javascript tidak memiliki ruang lingkup blok , Anda dapat menggunakan fungsi self-executing jika Anda ingin mendefinisikan variabel lokal:

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

Di sini, myvarapakah tidak mengganggu atau mencemari lingkup global, dan menghilang ketika fungsi berakhir.

Ketahui berapa banyak parameter yang diharapkan oleh suatu fungsi

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

Ketahui berapa banyak parameter yang diterima oleh fungsi

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

Berikut ini beberapa hal menarik:

• Membandingkan NaNdengan apa pun (datar NaN) selalu salah, termasuk ==, <dan >.
• NaN Singkatan dari Not a Number tetapi jika Anda meminta jenis itu sebenarnya mengembalikan nomor.
• Array.sort dapat mengambil fungsi pembanding dan dipanggil oleh driver quicksort-like (tergantung pada implementasi).
• Ekspresi reguler "konstanta" dapat mempertahankan status, seperti hal terakhir yang cocok.
• Beberapa versi JavaScript memungkinkan Anda untuk mengakses $0, $1, $2anggota pada regex.
• nulltidak seperti yang lain. Ini bukan objek, boolean, angka, string, atau pun bukan undefined. Agak seperti "pengganti" undefined. (Catatan: typeof null == "object")
• Dalam konteks terluar, thismenghasilkan objek [Global] yang tidak dapat disebutkan namanya.
• Mendeklarasikan suatu variabel dengan var, alih-alih hanya mengandalkan deklarasi variabel secara otomatis, memberikan peluang nyata pada runtime untuk mengoptimalkan akses ke variabel tersebut.
• The withmembangun akan menghancurkan optimzations seperti
• Nama variabel dapat berisi karakter Unicode.
• Ekspresi reguler JavaScript sebenarnya tidak reguler. Mereka didasarkan pada regex Perl, dan dimungkinkan untuk membangun ekspresi dengan lookaheads yang membutuhkan waktu yang sangat, sangat lama untuk mengevaluasi.
• Blok dapat diberi label dan digunakan sebagai target break. Loop dapat diberi label dan digunakan sebagai target continue.
• Array tidak jarang. Mengatur elemen ke-1000 dari array kosong yang seharusnya diisi undefined. (tergantung pada implementasi)
• if (new Boolean(false)) {...} akan mengeksekusi {...}blok
• Mesin ekspresi reguler Javascript spesifik untuk implementasi: mis. Dimungkinkan untuk menulis ekspresi reguler "non-portabel".

[sedikit diperbarui dalam menanggapi komentar yang baik; silakan lihat komentar]

Saya tahu saya terlambat ke pesta, tapi saya tidak bisa percaya +kegunaan operator belum disebutkan di luar "mengubah apa pun menjadi angka". Mungkin itu seberapa baik fitur tersembunyi itu?

// 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

Tentu saja, Anda dapat melakukan semua ini menggunakan Number(), tetapi +operator jauh lebih cantik!

Anda juga dapat menentukan nilai pengembalian numerik untuk objek dengan mengganti valueOf()metode prototipe . Konversi angka apa pun yang dilakukan pada objek itu tidak akan menghasilkan NaN, tetapi nilai pengembalian valueOf()metode:

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

" Metode ekstensi dalam JavaScript " melalui properti prototipe.

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

Ini akan menambahkan containsmetode ke semua Arrayobjek. Anda dapat memanggil metode ini menggunakan sintaks ini

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

Untuk menghapus properti dari objek dengan benar, Anda harus menghapus properti alih-alih hanya mengaturnya menjadi tidak terdefinisi :

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

obj.prop2 = undefined;

for (var key in obj) {
    ...

Prop2 properti masih akan menjadi bagian dari iterasi. Jika Anda ingin sepenuhnya menghilangkan prop2 , Anda sebaiknya melakukan:

delete obj.prop2;

Prop2 properti tidak akan lagi muncul saat Anda mengulangi properti.

with.

Ini jarang digunakan, dan terus terang, jarang bermanfaat ... Tapi, dalam keadaan terbatas, memang ada kegunaannya.

Misalnya: objek literal cukup berguna untuk mengatur properti dengan cepat pada objek baru . Tetapi bagaimana jika Anda perlu mengubah setengah dari properti pada objek yang ada?

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

// ...

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

Alan Storm menunjukkan bahwa ini bisa agak berbahaya: jika objek yang digunakan sebagai konteks tidak memiliki salah satu properti yang ditugaskan, itu akan diselesaikan dalam lingkup luar, mungkin membuat atau menimpa variabel global. Ini sangat berbahaya jika Anda terbiasa menulis kode untuk bekerja dengan objek di mana properti dengan nilai default atau kosong dibiarkan tidak terdefinisi:

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

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

Oleh karena itu, mungkin ide yang baik untuk menghindari penggunaan withpernyataan untuk penugasan tersebut.

Lihat juga: Apakah ada kegunaan sah untuk pernyataan "dengan" JavaScript?

Metode (atau fungsi) dapat dipanggil pada objek yang bukan tipe yang dirancang untuk bekerja dengannya. Ini bagus untuk memanggil metode asli (cepat) pada objek kustom.

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

Kode ini macet karena listNodesbukanArray

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

Kode ini berfungsi karena listNodesmendefinisikan cukup properti mirip array (panjang, [] operator) untuk digunakan oleh sort().

Warisan prototipe (dipopulerkan oleh Douglas Crockford) sepenuhnya merevolusi cara Anda berpikir tentang banyak hal dalam Javascript.

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

Itu pembunuh! Sayang sekali hampir tidak ada yang menggunakannya.

Ini memungkinkan Anda untuk "membuat" contoh baru dari objek apa pun, memperluasnya, sambil mempertahankan tautan pewarisan prototipikal (langsung) ke properti lainnya. Contoh:

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'

Beberapa akan menyebut ini masalah selera, tetapi:

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

Operator triner dapat dirantai untuk bertindak seperti Skema (kond ...):

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

dapat ditulis sebagai ...

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

Ini sangat "fungsional", karena percabangan kode Anda tanpa efek samping. Jadi alih-alih:

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

Kamu bisa menulis:

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

Bekerja dengan baik dengan rekursi juga :)

Angka juga benda. Jadi Anda dapat melakukan hal-hal keren seperti:

// 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

Bagaimana dengan penutupan dalam JavaScript (mirip dengan metode anonim di C # v2.0 +). Anda dapat membuat fungsi yang membuat fungsi atau "ekspresi".

Contoh penutupan :

//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);

Anda juga dapat memperluas (mewarisi) kelas dan menimpa properti / metode menggunakan sendok rantai prototipe16 disinggung.

Dalam contoh berikut ini kita membuat Pet kelas dan mendefinisikan beberapa properti. Kami juga mengganti metode .toString () yang diwarisi dari Object.

Setelah ini kita membuat kelas Dog yang memperluas Pet dan menimpa metode .toString () lagi-lagi mengubah perilaku itu (polimorfisme). Selain itu kami menambahkan beberapa properti lainnya ke kelas anak.

Setelah ini, kami memeriksa rantai pewarisan untuk menunjukkan bahwa Anjing masih berjenis Anjing, berjenis Pet, dan berjenis Obyek.

// 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

Kedua jawaban untuk pertanyaan ini adalah kode yang dimodifikasi dari artikel MSDN yang bagus oleh Ray Djajadinata.

Anda dapat menangkap pengecualian tergantung pada jenisnya. Dikutip dari 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
}

CATATAN: Klausa tangkapan bersyarat adalah ekstensi Netscape (dan karenanya Mozilla / Firefox) yang bukan bagian dari spesifikasi skrip ECMAS dan karenanya tidak dapat diandalkan kecuali pada browser tertentu.

Dari atas kepala saya...

Fungsi

arguments.callee merujuk ke fungsi yang meng-host variabel "argumen", sehingga dapat digunakan untuk kambuh fungsi anonim:

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

Itu berguna jika Anda ingin melakukan sesuatu seperti ini:

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

Benda

Hal yang menarik tentang anggota objek: mereka dapat memiliki string apa pun sebagai nama mereka:

//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);
}

String

String.split dapat menggunakan ekspresi reguler sebagai parameter:

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

String.replace dapat mengambil ekspresi reguler sebagai parameter pencarian dan fungsi sebagai parameter pengganti:

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

Anda dapat menggunakan objek alih-alih beralih sebagian besar waktu.

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

Pembaruan: jika Anda khawatir tentang kasus yang dinilai sebelumnya tidak efisien (mengapa Anda khawatir tentang efisiensi ini sejak awal dalam desain program ??) maka Anda dapat melakukan sesuatu seperti ini:

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)]();
}

Ini lebih berat untuk mengetik (atau membaca) daripada switch atau objek, tetapi mempertahankan manfaat menggunakan objek daripada switch, yang dirinci di bagian komentar di bawah ini. Gaya ini juga membuatnya lebih mudah untuk mengubah ini menjadi "kelas" yang tepat setelah cukup dewasa.

update2: dengan ekstensi sintaks yang diusulkan untuk ES.next, ini menjadi

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

Pastikan untuk menggunakan metode hasOwnProperty ketika melakukan iterasi melalui properti objek:

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

Ini dilakukan agar Anda hanya akan mengakses properti langsung dari anObject , dan tidak menggunakan properti yang berada di bawah rantai prototipe.

Variabel pribadi dengan Antarmuka Umum

Ini menggunakan trik kecil yang rapi dengan definisi fungsi self-calling. Segala sesuatu di dalam objek yang dikembalikan tersedia di antarmuka publik, sementara yang lainnya bersifat pribadi.

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());