Versteckte Funktionen von JavaScript? [geschlossen]

Welche "versteckten Funktionen" von JavaScript sollte Ihrer Meinung nach jeder Programmierer kennen?

Nachdem ich die hervorragende Qualität der Antworten auf die folgenden Fragen gesehen hatte, dachte ich, es sei Zeit, sie nach JavaScript zu fragen.

• Versteckte Funktionen von HTML
• Versteckte Funktionen von CSS
• Versteckte Funktionen von PHP
• Versteckte Funktionen von ASP.NET
• Versteckte Funktionen von C #
• Versteckte Funktionen von Java
• Versteckte Funktionen von Python

Obwohl JavaScript derzeit wohl die wichtigste clientseitige Sprache ist (fragen Sie einfach Google), ist es überraschend, wie wenig die meisten Webentwickler schätzen, wie leistungsfähig es wirklich ist.

Sie müssen keine Parameter für eine Funktion definieren. Sie können einfach das argumentsArray-ähnliche Objekt der Funktion verwenden .

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

Ich könnte den größten Teil von Douglas Crockfords ausgezeichnetem Buch JavaScript: The Good Parts zitieren .

Aber ich nehme nur eine für dich, benutze immer ===und !==anstelle von ==und!=

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

==ist nicht transitiv. Wenn Sie es verwenden ===, würde es erwartungsgemäß für alle diese Aussagen false geben.

Funktionen sind erstklassige Bürger in 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

Funktionale Programmiertechniken können verwendet werden, um elegantes Javascript zu schreiben .

Insbesondere können Funktionen als Parameter übergeben werden, z. B. akzeptiert Array.filter () einen Rückruf:

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

Sie können auch eine "private" Funktion deklarieren, die nur im Rahmen einer bestimmten Funktion vorhanden ist:

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

Sie können die Verwendung in Bediener zu überprüfen , ob ein Schlüssel in einem Objekt vorhanden ist :

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

Wenn Sie die Objektliterale zu hässlich finden, können Sie sie mit dem parameterlosen Funktionstipp kombinieren:

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

Variablen Standardwerte zuweisen

Sie können die Logik oder den Operator ||in einem Zuweisungsausdruck verwenden, um einen Standardwert anzugeben:

var a = b || c;

Die aVariable wird den Wert erhalten , cnur wenn bist falsy (wenn ist null, false, undefined, 0, empty string, oder NaN), andernfalls awird der Wert erhalten b.

Dies ist häufig in Funktionen hilfreich, wenn Sie einem Argument einen Standardwert zuweisen möchten, falls es nicht angegeben wird:

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

Beispiel für einen IE-Fallback in Ereignishandlern:

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

Die folgenden Sprachfunktionen sind seit langem bei uns, alle JavaScript-Implementierungen unterstützen sie, waren jedoch erst in ECMAScript 5th Edition Teil der Spezifikation :

Die debuggerAussage

Beschrieben in: § 12.15 Die Debugger-Anweisung

Mit dieser Anweisung können Sie Haltepunkte programmgesteuert in Ihren Code einfügen, indem Sie:

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

Wenn ein Debugger vorhanden oder aktiv ist, wird er sofort direkt in dieser Zeile unterbrochen.

Andernfalls hat diese Anweisung keine beobachtbare Auswirkung, wenn der Debugger nicht vorhanden oder aktiv ist.

Mehrzeilige String-Literale

Beschrieben in: § 7.8.4 String-Literale

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

Sie müssen vorsichtig sein , weil das Zeichen neben dem \ muss ein Leitungsabschluss sein, wenn Sie ein Leerzeichen nach dem haben \zum Beispiel, wird der Code aussehen genau das gleiche, aber es wird ein erhöhen SyntaxError.

JavaScript hat keinen Blockbereich (aber es hat einen Abschluss, also nennen wir es sogar?).

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

Sie können mit []statt auf auf Objekteigenschaften zugreifen.

Auf diese Weise können Sie eine Eigenschaft nachschlagen, die einer Variablen entspricht.

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

Sie können dies auch verwenden, um Objekteigenschaften abzurufen / festzulegen, deren Name keine legale Kennung ist.

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.

Einige Leute wissen das nicht und verwenden eval () wie folgt, was eine wirklich schlechte Idee ist :

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

Dies ist schwerer zu lesen, schwerer zu finden (kann jslint nicht verwenden), langsamer auszuführen und kann zu XSS-Exploits führen.

Wenn Sie nach einer anständigen JavaScript-Referenz zu einem bestimmten Thema suchen, geben Sie das Schlüsselwort "mdc" in Ihre Abfrage ein. Ihre ersten Ergebnisse stammen aus dem Mozilla Developer Center. Ich habe keine Offline-Referenzen oder Bücher bei mir. Ich verwende immer den Schlüsselworttrick "mdc", um direkt zu dem zu gelangen, wonach ich suche. Zum Beispiel:

Google: Javascript-Array sortieren mdc
(in den meisten Fällen können Sie "Javascript" weglassen)

Update: Mozilla Developer Center wurde in Mozilla Developer Network umbenannt . Der Schlüsselworttrick "mdc" funktioniert immer noch, aber bald müssen wir möglicherweise stattdessen "mdn" verwenden .

Vielleicht ein bisschen offensichtlich für einige ...

Installieren Sie Firebug und verwenden Sie console.log ("Hallo"). So viel besser als die Verwendung von random alert (); 's, an die ich mich erinnere, dass ich vor ein paar Jahren viel getan habe.

Private Methoden

Ein Objekt kann private Methoden haben.

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

Auch in Crockfords "Javascript: The Good Parts" erwähnt:

parseInt()ist gefährlich. Wenn Sie ihm eine Zeichenfolge übergeben, ohne ihn über die richtige Basis zu informieren, werden möglicherweise unerwartete Zahlen zurückgegeben. Beispiel parseInt('010'): Gibt 8 statt 10 zurück. Wenn Sie eine Basis an parseInt übergeben, funktioniert sie ordnungsgemäß:

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

Funktionen sind Objekte und können daher Eigenschaften haben.

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

fn.foo = 1;

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

Ich muss sagen, dass sich Funktionen selbst ausführen.

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

Da Javascript keinen Blockbereich hat , können Sie eine selbstausführende Funktion verwenden, wenn Sie lokale Variablen definieren möchten:

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

Hier myvarwird der globale Bereich nicht beeinträchtigt oder verschmutzt und verschwindet, wenn die Funktion beendet wird.

Wissen, wie viele Parameter von einer Funktion erwartet werden

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

Wissen, wie viele Parameter von der Funktion empfangen werden

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

Hier sind einige interessante Dinge:

• Vergleicht man NaNmit etwas (noch NaN) ist immer falsch, das schließt ==, <und >.
• NaN Steht für Not a Number, aber wenn Sie nach dem Typ fragen, wird tatsächlich eine Nummer zurückgegeben.
• Array.sort kann eine Komparatorfunktion übernehmen und wird von einem Quicksort-ähnlichen Treiber aufgerufen (abhängig von der Implementierung).
• Reguläre Ausdrücke "Konstanten" können den Zustand beibehalten, wie das letzte, was sie gefunden haben.
• Einige Versionen von JavaScript können Sie für den Zugriff $0, $1, $2Mitglieder auf einem regulären Ausdruck.
• nullist anders als alles andere. Es ist weder ein Objekt, ein Boolescher Wert, eine Zahl, eine Zeichenfolge noch undefined. Es ist ein bisschen wie eine "Alternative" undefined. (Hinweis: typeof null == "object")
• Im äußersten Kontext thisergibt sich das ansonsten unbenennbare [globale] Objekt.
• Wenn Sie eine Variable mit deklarieren var, anstatt sich nur auf die automatische Deklaration der Variablen zu verlassen, hat die Laufzeit eine echte Chance, den Zugriff auf diese Variable zu optimieren
• Das withKonstrukt wird solche Optimierungen zerstören
• Variablennamen können Unicode-Zeichen enthalten.
• Reguläre JavaScript-Ausdrücke sind eigentlich nicht regulär. Sie basieren auf Perls regulären Ausdrücken, und es ist möglich, Ausdrücke mit Lookaheads zu erstellen, deren Auswertung sehr, sehr lange dauert.
• Blöcke können beschriftet und als Ziele von verwendet werden break. Schleifen können beschriftet und als Ziel von verwendet werden continue.
• Arrays sind nicht spärlich. Wenn Sie das 1000. Element eines ansonsten leeren Arrays festlegen, sollte es mit gefüllt werden undefined. (hängt von der Implementierung ab)
• if (new Boolean(false)) {...} wird den {...}Block ausführen
• Die regulären Ausdrucksmodule von Javascript sind implementierungsspezifisch: z. B. ist es möglich, "nicht tragbare" reguläre Ausdrücke zu schreiben.

[als Reaktion auf gute Kommentare ein wenig aktualisiert; siehe Kommentare]

Ich weiß, dass ich zu spät zur Party komme, aber ich kann einfach nicht glauben, dass die +Nützlichkeit des Betreibers nicht erwähnt wurde, außer "irgendetwas in eine Zahl umwandeln". Vielleicht ist das so gut versteckt?

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

Natürlich können Sie dies alles Number()stattdessen verwenden, aber der +Bediener ist so viel hübscher!

Sie können auch einen numerischen Rückgabewert für ein Objekt definieren, indem Sie die valueOf()Methode des Prototyps überschreiben . Eine für dieses Objekt durchgeführte Zahlenkonvertierung führt nicht NaNzum Rückgabewert der valueOf()Methode:

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

" Erweiterungsmethoden in JavaScript " über die Prototyp-Eigenschaft.

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

Dadurch wird containsallen ArrayObjekten eine Methode hinzugefügt . Sie können diese Methode mit dieser Syntax aufrufen

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

Um eine Eigenschaft ordnungsgemäß aus einem Objekt zu entfernen, sollten Sie die Eigenschaft löschen, anstatt sie nur auf undefiniert zu setzen :

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

obj.prop2 = undefined;

for (var key in obj) {
    ...

Die Eigenschaft prop2 wird weiterhin Teil der Iteration sein. Wenn Sie prop2 vollständig entfernen möchten , sollten Sie stattdessen Folgendes tun:

delete obj.prop2;

Die Eigenschaft prop2 wird nicht mehr angezeigt, wenn Sie die Eigenschaften durchlaufen.

with.

Es wird selten verwendet und ist ehrlich gesagt selten nützlich ... Aber unter bestimmten Umständen hat es seine Verwendung.

Zum Beispiel: Objektliterale sind sehr praktisch, um Eigenschaften für ein neues Objekt schnell einzurichten . Was aber, wenn Sie die Hälfte der Eigenschaften eines vorhandenen Objekts ändern müssen ?

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

// ...

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

Alan Sturm weist darauf hin , dass dies etwas gefährlich sein: Wenn das Objekt als Kontext verwendet wird , nicht hat eine der Eigenschaften wurde zugewiesen, wird es in dem äußeren Umfang gelöst werden, was möglicherweise zu schaffen oder eine globale Variable zu überschreiben. Dies ist besonders gefährlich, wenn Sie es gewohnt sind, Code für die Arbeit mit Objekten zu schreiben, bei denen Eigenschaften mit Standardwerten oder leeren Werten undefiniert bleiben:

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

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

Daher ist es wahrscheinlich eine gute Idee, die Verwendung der withAnweisung für eine solche Zuordnung zu vermeiden .

Siehe auch: Gibt es legitime Verwendungszwecke für die JavaScript-Anweisung "with"?

Methoden (oder Funktionen) können für Objekte aufgerufen werden, die nicht dem Typ entsprechen, für den sie entwickelt wurden. Dies ist ideal, um native (schnelle) Methoden für benutzerdefinierte Objekte aufzurufen.

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

Dieser Code stürzt ab, weil listNodeses sich nicht um einen handeltArray

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

Dieser Code funktioniert, weil listNodesgenügend Array-ähnliche Eigenschaften (Länge, Operator []) definiert sind, um von verwendet zu werden sort().

Die prototypische Vererbung (populär gemacht von Douglas Crockford) revolutioniert die Art und Weise, wie Sie über viele Dinge in Javascript denken.

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

Es ist ein Mörder! Schade, wie fast niemand es benutzt.

Sie können damit neue Instanzen eines Objekts "erzeugen", erweitern und gleichzeitig eine (live) prototypische Vererbungsverknüpfung zu ihren anderen Eigenschaften beibehalten. Beispiel:

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'

Einige würden dies Geschmackssache nennen, aber:

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

Der Trinary-Operator kann so verkettet werden, dass er sich wie im Schema verhält (cond ...):

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

kann geschrieben werden als ...

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

Dies ist sehr "funktional", da es Ihren Code ohne Nebenwirkungen verzweigt. Also statt:

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

Du kannst schreiben:

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

Funktioniert auch gut mit Rekursion :)

Zahlen sind auch Objekte. So kannst du coole Sachen machen wie:

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

Wie wäre es mit Schließungen in JavaScript (ähnlich wie bei anonymen Methoden in C # v2.0 +). Sie können eine Funktion erstellen, die eine Funktion oder einen "Ausdruck" erstellt.

Beispiel für Schließungen :

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

Sie können Klassen auch erweitern (erben) und Eigenschaften / Methoden überschreiben, indem Sie den Prototyp-Kettenlöffel16 verwenden, auf den angedeutet wird.

Im folgenden Beispiel erstellen wir eine Klasse Pet und definieren einige Eigenschaften. Wir überschreiben auch die von Object geerbte .toString () -Methode.

Danach erstellen wir eine Dog-Klasse, die Pet erweitert und die .toString () -Methode überschreibt, um ihr Verhalten erneut zu ändern (Polymorphismus). Zusätzlich fügen wir der untergeordneten Klasse einige andere Eigenschaften hinzu.

Danach überprüfen wir die Vererbungskette, um zu zeigen, dass Dog immer noch vom Typ Dog, vom Typ Pet und vom Typ Object ist.

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

Beide Antworten auf diese Frage waren Codes, die aus einem großartigen MSDN-Artikel von Ray Djajadinata modifiziert wurden.

Abhängig von ihrem Typ können Sie Ausnahmen abfangen. Zitiert aus 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
}

HINWEIS: Bedingte catch-Klauseln sind eine Netscape-Erweiterung (und damit Mozilla / Firefox), die nicht Teil der ECMAScript-Spezifikation ist und daher nur für bestimmte Browser verwendet werden kann.

Aus meinem Kopf ...

Funktionen

Argumente.callee bezieht sich auf die Funktion, die die Variable "Argumente" hostet, sodass damit anonyme Funktionen wiederholt werden können:

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

Das ist nützlich, wenn Sie so etwas tun möchten:

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

Objekte

Eine interessante Sache über Objektmitglieder: Sie können eine beliebige Zeichenfolge als Namen haben:

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

Saiten

String.split kann reguläre Ausdrücke als Parameter verwenden:

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

String.replace kann einen regulären Ausdruck als Suchparameter und eine Funktion als Ersatzparameter verwenden:

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

Sie können die meiste Zeit Objekte anstelle von Schaltern verwenden.

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

Update: Wenn Sie besorgt sind, dass die Fälle, die im Voraus bewertet werden, ineffizient sind (warum machen Sie sich so früh im Programmdesign Sorgen um die Effizienz?), Können Sie Folgendes tun:

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

Dies ist schwieriger zu tippen (oder zu lesen) als ein Schalter oder ein Objekt, behält jedoch die Vorteile der Verwendung eines Objekts anstelle eines Schalters bei, die im Kommentarbereich unten beschrieben werden. Dieser Stil macht es auch einfacher, dies in eine richtige "Klasse" zu verwandeln, sobald es groß genug ist.

update2: Mit den vorgeschlagenen Syntaxerweiterungen für ES.next wird dies

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

Stellen Sie sicher, dass Sie die hasOwnProperty- Methode verwenden, wenn Sie die Eigenschaften eines Objekts durchlaufen:

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

Dies geschieht so, dass Sie nur auf die direkten Eigenschaften von anObject zugreifen und nicht die Eigenschaften verwenden, die sich in der Prototypenkette befinden.

Private Variablen mit einer öffentlichen Schnittstelle

Es verwendet einen kleinen Trick mit einer selbstaufrufenden Funktionsdefinition. Alles innerhalb des zurückgegebenen Objekts ist in der öffentlichen Schnittstelle verfügbar, während alles andere privat ist.

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