Bester Javascript syntaktischer Zucker

Hier sind einige Perlen:

Literale:

var obj = {}; //Object literal, equivalent to var obj = new Object();
var arr = []; //Array literal, equivalent to var arr = new Array();
var regex = /something/; //Regular expression literal, equivalent to var regex = new RegExp('something');

Defaults:

arg = arg || 'default'; //if arg evaluates to false, use 'default', which is the same as:
arg = !!arg ? arg : 'default';

Natürlich wissen wir, dass anonyme Funktionen, aber in der Lage, Sie zu behandeln, wie Literale, und führen Sie Sie auf der Stelle (als Verschluss) groß:

(function() { ... })(); //Creates an anonymous function and executes it

Frage:Was andere große syntaktischen Zucker ist in javascript zur Verfügung stehen?

InformationsquelleAutor der Frage |

57

Immer die aktuellen datetime-als Millisekunden:
```
Date.now()
```
Beispielsweise zur Zeit der Ausführung eines Codeabschnitts:
```
var start = Date.now();
//some code
alert((Date.now() - start) + " ms elapsed");
```
InformationsquelleAutor der Antwort Chris Noe

Objekt-Mitgliedschaft testen:

var props = { a: 1, b: 2 }; 

("a" in props) //true 
("b", props) //true 
("c" in props) //false

InformationsquelleAutor der Antwort Chris Noe

26

In Mozilla (und angeblich IE7) können Sie eine XML-Konstante:
```
var xml = <Element></Element>; 
```
Ersetzen können Variablen:
```
var elem = "html"; 
var text = "irgendein text"; 
var xml = <{elem}>{text}</{elem}>; 
```
InformationsquelleAutor der Antwort Chris Noe
25

Verwendung von anonymen Funktionen und einen Verschluss zu erstellen, die eine private variable (information hiding) und die zugehörigen get/set-Methoden:
```
var getter, setter;

(function()
{
   var _privateVar=123;
   getter = function() { return _privateVar; };
   setter = function(v) { _privateVar = v; };
})()
```
InformationsquelleAutor der Antwort Ash
22

Lage zu verlängern nativen JavaScript-Typen über prototypal inheritance.
```
String.prototype.isNullOrEmpty = function(input) {
    return input === null || input.length === 0;
}
```
InformationsquelleAutor der Antwort steve_c
21

Multi-line strings:
```
var str = "Dies ist \ 
alle eins \ 
string."; 
```
Da Sie keine Einrückung der folgenden Zeilen, ohne auch durch die Leerzeichen in der Zeichenfolge, die Menschen im Allgemeinen lieber zu verketten ist mit dem plus-operator. Aber dies ist ein schönes hier dokumentieren Fähigkeit.

InformationsquelleAutor der Antwort Chris Noe

Die Größe die Länge eines Array

length-Eigenschaft ist ein nicht nur Lesen.
Sie können es verwenden, um erhöhen oder verringern Sie die Größe eines Arrays.

var myArray = [1,2,3];
myArray.length //3 elements.
myArray.length = 2; //Deletes the last element.
myArray.length = 20 //Adds 18 elements to the array; the elements have the undefined value. A sparse array.

InformationsquelleAutor der Antwort

20

Verwenden === zu vergleichen mit dem Wert und Typ:
```
var i = 0; 
var s = "0"; 

if (i == s) //wahr 

if (i === s) //false 
```
InformationsquelleAutor der Antwort Chris Noe
16

Wiederholung einer Zeichenfolge wie "-" eine bestimmte Anzahl von Zeiten, die durch die Nutzung der join-Methode auf ein leeres array:
```
var s = new Array(repeat+1).join("-");
```
Ergebnisse in "---" wenn "wiederholen" = = 3.

InformationsquelleAutor der Antwort

Wie die Standard-operator || ist die Wache Betreiber &&.

answer = obj && obj.property

im Gegensatz zu

if (obj) {
    answer = obj.property;
}
else {
    answer = null;
}

InformationsquelleAutor der Antwort

var tags = {
    name: "Jack",
    location: "USA"
};

"Name: {name}<br>From {location}".replace(/\{(.*?)\}/gim, function(all, match){
    return tags[match];
});

Rückruf für die Zeichenfolge ersetzen Sie ist einfach nur nützlich.

InformationsquelleAutor der Antwort

Getter und setter:

function Foo(bar)
{
    this._bar = bar;
}

Foo.prototype =
{
    get bar()
    {
        return this._bar;
    },

    set bar(bar)
    {
        this._bar = bar.toUpperCase();
    }
};

Uns gibt:

>>> var myFoo = new Foo("bar");
>>> myFoo.bar
"BAR"
>>> myFoo.bar = "Baz";
>>> myFoo.bar
"BAZ"

InformationsquelleAutor der Antwort Jonny Buchanan

5

Dies ist nicht eine javascript-exklusiv, sondern speichert wie drei Zeilen code:
```
check ? value1 : value2
```
InformationsquelleAutor der Antwort levik
4

Etwas mehr auf levik Beispiel:
```
var foo = (condition) ? value1 : value2;
```
InformationsquelleAutor der Antwort VirtuosiMedia
4

Den Array#forEach auf Javascript 1.6
```
myArray.forEach(function(element) { alert(element); });
```
InformationsquelleAutor der Antwort Pablo Cabrera
4

Folgenden obj || {default:true} syntax :

Aufruf der Funktion mit : Hallo(neededOne && neededTwo && needThree), wenn ein parameter nicht definiert oder false, dann wird es call Hallo(false), manchmal nützlich

InformationsquelleAutor der Antwort
4

Bei der Analyse der Situationen, die mit einem festen Satz von Komponenten-Teile:
```
var str = "John Doe";
```
Zuordnen können Sie die Ergebnisse direkt in Variablen mithilfe der "destructuring assignment" synatx:
```
var [fname, lname] = str.split(" ");
alert(lname + ", " + fname);
```
Ist ein bisschen besser lesbar als:
```
var a = str.split(" ");
alert(a[1] + ", " + a[0]);
```
Abwechselnd:
```
var [str, fname, lname] = str.match(/(.*) (.*)/);
```
Beachten Sie, dass dies ein Javascript 1.7 Funktion. Also Mozilla 2.0+ und Chrome 6+ Browser, zu dieser Zeit.

InformationsquelleAutor der Antwort

Sofort Aufgerufen Pfeil-Funktion:

var test = "hello, world!";
(() => test)(); //returns "hello, world!";

InformationsquelleAutor der Antwort

Ich vergaß:

(function() { ... }).someMethod(); //Functions as objects

InformationsquelleAutor der Antwort

2

Erstellen Sie eine anonyme Objekt-literal einfach: ({})

Beispiel: wissen müssen, wenn Sie Gegenstände haben, die valueOf-Methode:

var hasValueOf = !!({}).valueOf

Bonus syntaktischen Zucker: der Doppel-nicht '!!' für die Konvertierung so ziemlich alles in einen booleschen sehr prägnant auf den Punkt.

InformationsquelleAutor der Antwort
1

Ich Liebe es, eval() in ein json-string und wieder voll aufgefüllt, die Struktur der Daten.
Ich Hasse es zu schreiben, alles mindestens zweimal (einmal IE, einmal für Mozilla).

InformationsquelleAutor der Antwort dicroce
1

Assigining Häufig verwendete Schlüsselwörter (oder Methoden) zu den einfachen Variablen, wie z.B. ths
```
  var $$ = document.getElementById;

  $$('samText');
```
InformationsquelleAutor der Antwort
1

JavaScript Date-Klasse bietet eine semi-"Fluent Interface". Das macht für nicht in der Lage, zum extrahieren des Datums-Teil aus einem Date-Klasse direkt:
```
var today = new Date((new Date()).setHours(0, 0, 0, 0));
```
Es ist nicht eine voll Fluent Interface, denn das folgende wird nur geben uns einen numerischen Wert, das ist nicht wirklich ein Date-Objekt:
```
var today = new Date().setHours(0, 0, 0, 0);
```
InformationsquelleAutor der Antwort

Standard-fallback:

var foo = {}; //empty object literal

alert(foo.bar) //will alert "undefined"

alert(foo.bar || "bar"); //will alert the fallback ("bar")

Einem Beispiel aus der Praxis:

//will result in a type error
if (foo.bar.length === 0)

//with a default fallback you are always sure that the length
//property will be available.
if ((foo.bar || "").length === 0)

InformationsquelleAutor der Antwort

1

Hier habe ich gerade entdeckt: null prüfen Sie vor dem aufrufen der Funktion:
```
a = b && b.length;
```
Dies ist eine kürzere äquivalent zu:
```
a = b ? b.length : null;
```
Der beste Teil ist, dass Sie können überprüfen, eine Eigenschaft Kette:
```
a = b && b.c && b.c.length;
```
InformationsquelleAutor der Antwort

Ich Liebe, wie einfach es ist, zu arbeiten mit Listen:

var numberName = ["zero", "one", "two", "three", "four"][number];

Und hashes:

var numberValue = {"zero":0, "one":1, "two":2, "three":3, "four":4}[numberName];

In den meisten anderen Sprachen, das wäre ziemlich schwer code. Standardwert sind auch schön. Zum Beispiel Fehlercode reporting:

var errorDesc = {301: "Moved Permanently",
                 404: "Resource not found",
                 503: "Server down"
                }[errorNo] || "An unknown error has occurred";

InformationsquelleAutor der Antwort

0

int zu string casten
```
var i = 12;
var s = i+"";
```
InformationsquelleAutor der Antwort
0
```
element.innerHTML = "";  //Replaces body of HTML element with an empty string.
```
Einen shortcut zu löschen, werden alle untergeordneten Knoten des Elementes.

InformationsquelleAutor der Antwort
0

Konvertieren von string zu integer standardmäßig auf 0, wenn imposible,
```
0 | "3" //result = 3
0 | "some string" -> //result = 0
0 | "0" -> 0 //result = 0
```
Kann in einigen Fällen hilfreich sein, vor allem wenn die 0 ist, gilt als schlechtes Ergebnis

InformationsquelleAutor der Antwort
0

Vorlage Literale
```
var a = 10;
var b = 20;
var text = `${a} + ${b} = ${a+b}`;
```
dann die text variable wird wie unten!

10 + 20 = 30

InformationsquelleAutor der Antwort

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.