JavaScript'in Gizli Özellikleri? [kapalı]

Her programcının bilmesi gereken JavaScript'in hangi "Gizli Özellikleri" olduğunu düşünüyorsunuz?

Aşağıdaki soruların cevaplarının mükemmel kalitesini gördükten sonra JavaScript sormanın zamanı geldiğini düşündüm.

• HTML'nin Gizli Özellikleri
• CSS'nin Gizli Özellikleri
• PHP'nin Gizli Özellikleri
• ASP.NET'in Gizli Özellikleri
• C # 'ın Gizli Özellikleri
• Java'nın Gizli Özellikleri
• Python'un Gizli Özellikleri

JavaScript şu anda tartışmasız en önemli İstemci Tarafı dili olmasına rağmen (sadece Google'a sorun), çoğu web geliştiricisinin gerçekten ne kadar güçlü olduğunu takdir etmesinin şaşırtıcı olması.

Bir işlev için herhangi bir parametre tanımlamanız gerekmez. Sadece işlevin argumentsdizi benzeri nesnesini kullanabilirsiniz.

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

Douglas Crockford'un mükemmel kitabı JavaScript: The Good Parts'ın çoğunu alıntılayabilirim .

Ama senin için sadece bir tane alacağım, her zaman kullan ===ve!== yerine ==ve!=

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

==geçişli değildir. Eğer kullanırsanız ===beklendiği gibi bu tabloların tümü için yanlış verecekti.

Fonksiyonlar JavaScript'te birinci sınıf vatandaşlardır:

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

Fonksiyonel programlama teknikleri zarif javascript yazmak için kullanılabilir .

Özellikle fonksiyonlar parametre olarak iletilebilir, örneğin Array.filter () bir geri çağrıyı kabul eder:

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

Yalnızca belirli bir işlev kapsamında bulunan bir "özel" işlevi de bildirebilirsiniz:

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

Bir nesnede bir anahtar olup olmadığını kontrol etmek için in operatörünü kullanabilirsiniz :

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

Nesne değişmezlerini çok çirkin bulursanız, parametresiz işlev ipucu ile birleştirebilirsiniz:

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

Değişkenlere varsayılan değerler atama

||Varsayılan bir değer sağlamak için bir atama ifadesinde mantıksal veya işleci kullanabilirsiniz :

var a = b || c;

aDeğişken değerini alacak ceğer sadece bbir falsy (eğer null, false, undefined, 0, empty string, veya NaN), aksi adeğerini alacakb .

Bu, sağlanmadığında bir bağımsız değişkene varsayılan bir değer vermek istediğinizde genellikle işlevlerde yararlıdır:

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

Olay işleyicilerinde IE yedek örneği:

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

Aşağıdaki dil özellikleri uzun zamandır bizimle birlikte, tüm JavaScript uygulamaları bunları destekliyor, ancak ECMAScript 5. Baskıya kadar spesifikasyonun bir parçası değildi :

debuggeraçıklama

Açıklama: § 12.15 Hata ayıklayıcı bildirimi

Bu ifade, kesme noktalarını kodunuza programlı olarak aşağıdaki yollarla koymanızı sağlar :

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

Bir hata ayıklayıcı varsa veya etkinse, hemen o satırda, kırılmasına neden olur.

Aksi takdirde, hata ayıklayıcı yoksa veya etkin değilse, bu ifadenin gözlemlenebilir bir etkisi yoktur.

Çok Satırlı Dize değişmez değerleri

Açıklama: § 7.8.4 Dize Değişmezleri

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

Dikkatli olmalısınız, çünkü yanındaki karakterin bir satır sonlandırıcı \ olması gerekir , \örneğin sonrasında boşluk varsa , kod tam olarak aynı görünür , ancak a işareti yükselir SyntaxError.

JavaScript'in blok kapsamı yoktur (ancak kapanması vardır, bu yüzden onu diyelim mi?).

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

Nesne özelliklerine []yerine.

Bu, bir değişkenle eşleşen bir özelliği aramanızı sağlar.

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

Bunu, adı yasal bir tanımlayıcı olmayan nesne özelliklerini almak / ayarlamak için de kullanabilirsiniz.

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.

Bazı insanlar bunu bilmiyor ve bunun gibi eval () kullanıyorlar , bu gerçekten kötü bir fikir :

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

Bu, okunması daha zordur, hataları bulmak daha zordur (jslint kullanamazsınız), yürütülmesi daha yavaştır ve XSS istismarlarına yol açabilir.

Belirli bir konuda iyi bir JavaScript referansı için Google'da çalışıyorsanız, sorgunuza "mdc" anahtar kelimesini ekleyin; ilk sonuçlarınız Mozilla Geliştirici Merkezi'nden olacaktır. Yanımda çevrimdışı referans veya kitap taşımıyorum. Ben her zaman doğrudan aradığım şey almak için "mdc" anahtar kelime hile kullanın. Örneğin:

Google: javascript dizi sıralaması mdc
(çoğu durumda "javascript" i atlayabilirsiniz)

Güncelleme: Mozilla Developer Center , Mozilla Developer Network olarak yeniden adlandırıldı . "Mdc" anahtar kelime hilesi hala işe yarıyor, ancak kısa süre içinde bunun yerine "mdn" kullanmaya başlamamız gerekebilir .

Belki bazıları için biraz açık ...

Firebug'u yükleyin ve console.log ("merhaba") kullanın. Rasgele uyarı () kullanmaktan çok daha iyi; birkaç yıl önce çok şey yaptığımı hatırlıyorum.

Özel Yöntemler

Bir nesnenin özel yöntemleri olabilir.

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

Ayrıca Crockford'un "Javascript: İyi Parçalar" bölümünde de bahsedilmiştir:

parseInt()tehlikeli. Bir dizeyi uygun tabandan haberdar etmeden iletirseniz, beklenmeyen sayılar döndürebilir. ÖrneğinparseInt('010') , 10 değil, 8 döndürür. Bir tabanı parseInt öğesine geçirmek doğru çalışmasını sağlar:

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

İşlevler nesnedir ve bu nedenle özelliklere sahip olabilirler.

fn = işlev (x) {
   // ...
}

fn.foo = 1;

fn.next = işlev (y) {
  //
}

Kendi kendini icra eden işlevler söylemek zorundayım.

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

Javascript'in blok kapsamı olmadığından, yerel değişkenleri tanımlamak istiyorsanız kendi kendini yürütme işlevini kullanabilirsiniz:

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

Burada, myvarküresel kapsamı etkilemez veya kirletmez ve işlev sona erdiğinde kaybolur.

Bir işlev tarafından kaç parametre beklendiğini bilin

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

İşlev tarafından kaç parametre alındığını bilin

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

İşte bazı ilginç şeyler:

• Karşılaştırma NaN(hatta herhangi bir şeyle NaN) içerdiğini, her zaman yanlıştır ==, <ve >.
• NaN Sayı Değil anlamına gelir, ancak türü sorarsanız aslında bir sayı döndürür.
• Array.sort karşılaştırıcı işlevi alabilir ve hızlı sıralamaya benzer bir sürücü tarafından çağrılır (uygulamaya bağlıdır).
• Düzenli ifade "sabitler", eşleştirdikleri son şey gibi durumu koruyabilir.
• JavaScript bazı sürümleri erişmenize izin $0, $1,$2 bir regex üzerinde üye.
• nullbaşka hiçbir şeye benzemez. Ne bir nesne, ne bir boole, bir sayı, bir dize, ne de undefined. Biraz "alternatif" gibi undefined. (Not: typeof null == "object")
• En dıştaki bağlamda, this aksi takdirde adlandırılamayan [Global] nesneyi verir.
• İle değişken bildirme var otomatik olarak bildirilmesine güvenmek yerine, bildirilmesi, çalışma zamanına bu değişkene erişimi optimize etme konusunda gerçek bir şans verir
• withYapı böyle optimzations yok edecek
• Değişken adları Unicode karakterler içerebilir.
• JavaScript normal ifadeleri aslında normal değildir. Perl'in normal ifadelerine dayanırlar ve değerlendirilmeleri çok uzun zaman alan gözcülerle ifadeler oluşturmak mümkündür.
• Bloklar hedef olarak etiketlenebilir ve kullanılabilir break. Döngüler etiketlenebilir ve hedefi olarak kullanılabilir continue.
• Diziler seyrek değildir. Aksi halde boş bir dizinin 1000'inci öğesini ayarlamak, onu doldurmalıdır undefined. (uygulamaya bağlıdır)
• if (new Boolean(false)) {...}{...}bloğu yürütecek
• Javascript'in normal ifade motorları uygulamaya özeldir: örn. "Taşınabilir olmayan" düzenli ifadeler yazmak mümkündür.

[iyi yorumlara yanıt olarak biraz güncellendi; lütfen yorumlara bakın]

Partiye geç kaldığımı biliyorum, ama +operatörün kullanışlılığının "bir şeyi bir sayıya dönüştür" ün ötesine geçmediğine inanamıyorum . Belki de bir özellik ne kadar iyi gizlenmiştir?

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

Tabii ki, tüm bunları Number()bunun yerine kullanarak yapabilirsiniz , ancak +operatör çok daha güzel!

Prototip valueOf()yöntemini geçersiz kılarak bir nesne için sayısal bir dönüş değeri de tanımlayabilirsiniz . Bu nesne üzerinde yapılan herhangi bir sayı dönüşümü NaN, valueOf()yöntemin dönüş değeriyle sonuçlanmaz :

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

" JavaScript Uzatma yöntemleri prototip özelliği aracılığıyla".

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

Bu, containstüm Arraynesnelere bir yöntem ekleyecektir . Bu sözdizimini kullanarak bu yöntemi çağırabilirsiniz

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

Bir özelliği bir nesneden düzgün bir şekilde kaldırmak için, özelliği yalnızca tanımsız olarak ayarlamak yerine silmeniz gerekir :

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

obj.prop2 = undefined;

for (var key in obj) {
    ...

Prop2 özelliği yine de yinelemenin bir parçası olacaktır. Prop2'den tamamen kurtulmak istiyorsanız , şunları yapmalısınız:

delete obj.prop2;

Özellikler arasında yineleme yaptığınızda prop2 özelliği artık görünmez .

with.

Nadiren kullanılır ve açıkçası, nadiren faydalıdır ... Ancak, sınırlı durumlarda, kullanımları vardır.

Örneğin: nesne değişmez değerleri, yeni bir nesnenin özelliklerini hızlı bir şekilde ayarlamak için oldukça kullanışlıdır . Ancak , varolan bir nesnenin özelliklerinin yarısını değiştirmeniz gerekirse ne olur ?

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

// ...

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

Alan Storm bu biraz tehlikeli olabilir işaret: içerik olarak kullanılan nesne yoksa sahip muhtemelen oluşturma veya genel değişken üzerine, özelliklerinden biri, dış kapsam giderilmiş tahsis edilir. Varsayılan veya boş değerlere sahip özelliklerin tanımsız bırakıldığı nesnelerle çalışmak için kod yazmaya alışkınsanız bu özellikle tehlikelidir:

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

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

Bu nedenle, bu withtür bir atama için ifadenin kullanılmasından kaçınmak muhtemelen iyi bir fikirdir .

Ayrıca bkz: JavaScript'in “with” ifadesinin yasal kullanımları var mı?

Yöntemler (veya işlevler) birlikte çalışmak üzere tasarlandıkları türde olmayan nesneler üzerinde çağrılabilir. Özel nesnelerde yerel (hızlı) yöntemleri çağırmak harika.

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

Bu kod listNodes,Array

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

Bu kod listNodes, tarafından kullanılacak yeterli dizi benzeri özellikleri (length, [] operatörü) tanımladığı için çalışır sort().

Prototypal mirası (Douglas Crockford tarafından popülerleştirilmiştir) Javascript'teki birçok şey hakkında düşünme şeklinizde tamamen devrim yaratır.

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

Bu bir katil! Ne yazık ki neredeyse hiç kimse onu kullanmıyor.

Herhangi bir nesnenin yeni örneklerini "başlatmanıza", onları genişletmenize ve diğer özelliklerine (canlı) prototip bir miras bağlantısı sağlamanıza olanak tanır. Misal:

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'

Bazıları buna bir tat meselesi diyebilir, ama:

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

Üçlü operatör, Şema'nın (koşul ...) gibi davranması için zincirlenebilir:

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

olarak yazılabilir ...

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

Bu çok "işlevsel", çünkü yan etkileri olmadan kodunuzu dallar. Bunun yerine:

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

Yazabilirsin:

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

Özyineleme ile de iyi çalışır :)

Sayılar da nesnedir. Böylece aşağıdakiler gibi harika şeyler yapabilirsiniz:

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

JavaScript'teki kapanışlara ne dersiniz (C # v2.0 + 'daki anonim yöntemlere benzer). Bir işlev veya "ifade" oluşturan bir işlev oluşturabilirsiniz.

Kapaklara örnek :

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

Ayrıca sınıfları genişletebilir (devralabilir) ve bununla ilgili prototip zincir kaşığı16 kullanarak özellikleri / yöntemleri geçersiz kılabilirsiniz .

Aşağıdaki örnekte bir Pet sınıfı oluşturup bazı özellikleri tanımlarız. Ayrıca Object'den devralınan .toString () yöntemini geçersiz kılar.

Bundan sonra , Pet'i genişleten ve tekrar davranışını (polimorfizm) değiştiren .toString () yöntemini geçersiz kılan bir Dog sınıfı yaratırız . Ayrıca, alt sınıfa başka özellikler ekliyoruz.

Bundan sonra, Köpeğin hala Köpek tipi, Pet tipi ve Nesne tipi olduğunu göstermek için miras zincirini kontrol ediyoruz.

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

Bu soruya verilen her iki cevap da Ray Djajadinata'nın yazdığı harika bir MSDN makalesinden kodlardı.

Türlerine bağlı olarak istisnalar yakalayabilirsiniz. Alıntı sahibi 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
}

NOT: Koşullu catch deyimleri, ECMAScript belirtiminin bir parçası olmayan bir Netscape (ve dolayısıyla Mozilla / Firefox) uzantısıdır ve bu nedenle belirli tarayıcılar dışında güvenilemez.

Kafamın tepesinden ...

Fonksiyonlar

arguments.callee, "arguments" değişkenini barındıran işlevi ifade eder, böylece anonim işlevleri geri almak için kullanılabilir:

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

Böyle bir şey yapmak istiyorsanız bu yararlıdır:

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

Nesneler

Nesne üyeleri hakkında ilginç bir şey: isimleri olarak herhangi bir dizeye sahip olabilirler:

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

Teller

String.split normal ifadeleri parametre olarak alabilir:

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

String.replace normal bir ifadeyi arama parametresi olarak, işlevi de işlev parametresi olarak alabilir:

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

Çoğu zaman anahtar yerine nesne kullanabilirsiniz.

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

Güncelleme: Önceden verimsiz olduğunu değerlendiren vakalardan endişe ediyorsanız (neden programın tasarımında bu kadar erken verimlilik konusunda endişelisiniz ??) o zaman böyle bir şey yapabilirsiniz:

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

Bu, bir anahtardan veya nesneden yazmak (veya okumak) için daha zahmetlidir, ancak aşağıdaki yorumlar bölümünde ayrıntılı olarak açıklanan, anahtar yerine bir nesne kullanmanın yararlarını korur. Bu tarz aynı zamanda, yeterince büyüdüğünde bunu uygun bir "sınıf" haline getirmeyi daha kolay hale getirir.

update2: ES.next için önerilen sözdizimi uzantılarıyla bu olur

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

Bir nesnenin özellikleri arasında yineleme yaparken hasOwnProperty yöntemini kullandığınızdan emin olun :

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

Bu, yalnızca anObject öğesinin doğrudan özelliklerine erişmeniz ve prototip zincirinin altındaki özellikleri kullanmamanız için yapılır.

Genel Arayüzlü özel değişkenler

Kendinden çağırma işlevi tanımına sahip düzgün küçük bir numara kullanır. Geri döndürülen nesnenin içindeki her şey genel arayüzde kullanılabilirken, diğer her şey özeldir.

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