Скрытые функции JavaScript? [закрытый]

Подарок Microsofts JavaScript: AJAX

AJAXCall('http://www.abcd.com/')

function AJAXCall(url) {
 var client = new XMLHttpRequest();
 client.onreadystatechange = handlerFunc;
 client.open("GET", url);
 client.send();
}

function handlerFunc() {
 if(this.readyState == 4 && this.status == 200) {
 if(this.responseXML != null)
   document.write(this.responseXML)
 }
}

Можно повернуть "любого* объект с целочисленными свойствами и свойством длины в надлежащий массив, и таким образом обеспечить его всеми методами массива, такими как нажатие, поп, соединение встык, карта, отфильтровать, уменьшить, и т.д.

Array.prototype.slice.call({"0":"foo", "1":"bar", 2:"baz", "length":3 }) 

//возвраты ["нечто", "панель", "baz"]

Это работает с объектами jQuery, наборами HTML и объектами Массива от других кадров (как одно возможное решение целой вещи типа массива). Я говорю, если это имеет свойство длины, можно превратить его в массив, и это не имеет значения. Существует много из не, выстраивают объекты со свойством длины, вне объекта arguments.

Если Вы вслепую eval() JSON представляет в виде строки для десериализации его, можно столкнуться с проблемами:

1. Это не безопасно. Строка может содержать злонамеренные вызовы функции!

2. , Если Вы не включаете строку JSON в круглые скобки, имена свойства могут быть ошибочными как маркировки, приводящие к неожиданному поведению или синтаксической ошибке:

   eval("{ \"foo\": 42 }"); // syntax error: invalid label
   eval("({ \"foo\": 42 })"); // OK
   

let.

Дубликат к отсутствие var обзора блока let, представлено в JavaScript 1.7.

• оператор, которому позволяют, позволяет связывать значения с переменными в рамках блока, не влияя на значения подобно названных переменных вне блока.
• выражение, которому позволяют, позволяет, Вы установить переменные определили объем только к отдельному выражению.
• определение, которому позволяют, определяет переменные, объем которых ограничивается к блоку, в котором они определяются. Этот синтаксис очень похож на синтаксис, используемый для var.
• можно также использовать, позволяют для установления переменных, которые существуют только в контексте для цикла.

  function varTest() {
        var x = 31;
    if (true) {
      var x = 71;  // same variable!
      alert(x);  // 71
    }
    alert(x);  // 71
  }

  function letTest() {
    let x = 31;
    if (true) {
      let x = 71;  // different variable
      alert(x);  // 71
    }
    alert(x);  // 31
  }

По состоянию на 2008, JavaScript 1.7 поддерживается в FireFox 2.0 + и Safari 3.x.

== оператор имеет совершенно особое свойство, которое создает это тревожащее равенство (Да, я знаю на других динамических языках как Perl, это поведение ожидалось бы, но JavaScript ususally не пытается быть умным в сравнениях):

>>> 1 == true
true
>>> 0 == false
true
>>> 2 == true
false

Можно выполнить метод объекта на любом объекте, независимо от того, имеет ли он тот метод или нет. Конечно, это не могло бы всегда работать (если метод предполагает, что объект имеет что-то, что это не делает), но это может быть чрезвычайно полезно. Например:

function(){
    arguments.push('foo') // This errors, arguments is not a proper array and has no push method
    Array.prototype.push.apply(arguments, ['foo']) // Works!
}

Все функции являются на самом деле экземплярами встроенного Функция тип, который имеет конструктора, который берет строку, содержащую функциональное определение, таким образом, можно на самом деле определить функции во времени выполнения, например, связав строки:

//e.g., createAddFunction("a","b") returns function(a,b) { return a+b; }
function createAddFunction(paramName1, paramName2)
 { return new Function( paramName1, paramName2
                       ,"return "+ paramName1 +" + "+ paramName2 +";");
 }

кроме того, для пользовательских функций, Function.toString () возвраты функциональное определение как литеральная строка.

JavaScript имеет статические переменные в функциях:

function someFunction(){
  var Static = arguments.callee;
  Static.someStaticVariable = (Static.someStaticVariable || 0) + 1;
  alert(Static.someStaticVariable);
}
someFunction() //Alerts 1
someFunction() //Alerts 2
someFunction() //Alerts 3

Это также имеет статические переменные в Объектах:

function Obj(){
  this.Static = arguments.callee;
}
a = new Obj();
a.Static.name = "a";
b = new Obj();
alert(b.Static.name); //Alerts b

window.name значение сохраняется через изменения страницы, может быть считан родительским окном, если в том же домене (если в iframe, используйте document.getElementById("your frame's ID").contentWindow.name для доступа к нему), и ограничен только доступной памятью.

Функциональные операторы и выражения function обрабатываются по-другому.

function blarg(a) {return a;} // statement
bleep = function(b) {return b;} //expression

Все функциональные операторы анализируются, прежде чем код выполняется - функция у основания файла JavaScript будет доступна в первом операторе. С другой стороны, это не будет в состоянии использовать в своих интересах определенный динамический контекст, такой как окружение with, операторы - эти with не были выполнены, когда функция анализируется.

Выражения function выполняются встроенный, правильный, где с ними встречаются. Они не доступны перед тем временем, но они могут использовать в своих интересах динамический контекст.

Понятие truthy и значений falsy. Вы не должны делать чего-то как

если (someVar ===, неопределенный || пустой указатель someVar ===)...

Просто сделайте:

, если (! someVar).

Каждое значение имеет соответствующее булево представление.

Можно сделать почти что-либо между круглыми скобками при разделении операторов с запятыми:

var z = ( x = "can you do crazy things with parenthesis", ( y = x.split(" "), [ y[1], y[0] ].concat( y.slice(2) ) ).join(" ") )

alert(x + "\n" + y + "\n" + z)

Вывод:

can you do crazy things with parenthesis
can,you,do,crazy,things,with,parenthesis
you can do crazy things with parenthesis

Одно из моего избранного является проверкой типа конструктора:

function getObjectType( obj ) {  
    return obj.constructor.name;  
}  

window.onload = function() {  
    alert( getObjectType( "Hello World!" ) );  
    function Cat() {  
        // some code here...  
    }  
    alert( getObjectType( new Cat() ) );  
}

Так вместо усталого старого [Объектный объект] Вы часто добираетесь с typeof ключевым словом, можно на самом деле получить реальные типы объектов, основанные на конструкторе.

Другой использует аргументы переменной в качестве способа "перегрузить" функции. Все, что Вы делаете, использует выражение для обнаружения количества аргументов и возвращает перегруженный вывод:

function myFunction( message, iteration ) {  
    if ( arguments.length == 2 ) {  
        for ( i = 0; i < iteration; i++ ) {  
            alert( message );  
        }  
    } else {  
        alert( message );  
    }  
}  

window.onload = function() {  
    myFunction( "Hello World!", 3 );  
}

Наконец, я сказал бы стенографию оператора присваивания. Я узнал об этом из источника платформы jQuery... старый путь:

var a, b, c, d;
b = a;
c = b;
d = c;

новое (стенография) путь:

var a, b, c, d;
d = c = b = a;

Хорошее развлечение:)

Предотвратите раздражающие ошибки при тестировании в Internet Explorer при использовании console.log () для Firebug:

function log(message) {
    (console || { log: function(s) { alert(s); }).log(message);
}

JavaScript использует литерал простого объекта:

var x = { intValue: 5, strValue: "foo" };

Это создает законченный объект.

JavaScript использует основанную на прототипе объектную ориентацию и обеспечивает способность расширить типы во времени выполнения:

String.prototype.doubleLength = function() {
    return this.length * 2;
}

alert("foo".doubleLength());

объект делегирует весь доступ к атрибутам, которые это не содержит само к его "прототипу", другому объекту. Это может использоваться для реализации наследования, но на самом деле более мощно (даже если более громоздкий):

/* "Constructor" */
function foo() {
    this.intValue = 5;
}

/* Create the prototype that includes everything
 * common to all objects created be the foo function.
 */
foo.prototype = {
    method: function() {
        alert(this.intValue);
    }
}

var f = new foo();
f.method();

Вот несколько ярлыков:

var a = []; // equivalent to new Array()
var o = {}; // equivalent to new Object()

Путем JavaScript работает с Датой (), просто волнует меня!

function isLeapYear(year) {
    return (new Date(year, 1, 29, 0, 0).getMonth() != 2);
}

Это - действительно "скрытая функция".

Редактирование: Удаленный"?" условие, как предложено в комментариях для politcorrecteness. Был:... новая Дата (год, 1, 29, 0, 0) .getMonth ()! = 2? верный: ложь... Посмотрите на комментарии для деталей.

Существует несколько ответов в этом потоке, показывающем, как расширить объект Массива через его прототип. Это - ПЛОХАЯ ИДЕЯ, потому что она повреждается for (i in a) оператор.

Так он хорошо, если Вы, оказывается, не используете for (i in a) нигде в Вашем коде? Ну, только если Ваш собственный код является единственным кодом, который Вы выполняете, который не является, слишком вероятно, в браузере. Я боюсь, что, если люди начинают расширять свои объекты Массива как это, Переполнение стека начнет переполняться с набором таинственных ошибок JavaScript.

Посмотрите полезные детали здесь .

Когда Вы хотите удалить элемент из массива, можно использовать , удаляют оператор, как таковой:

var numbers = [1,2,3,4,5];
delete numbers[3];
//numbers is now [1,2,3,undefined,5]

, Как Вы видите, элемент был удален, но дыру покинули в массиве, так как элемент был заменен неопределенный значение.

Таким образом, для работы вокруг этой проблемы, вместо того, чтобы использовать удаляют , используют соединение встык метод массива... как таковой:

var numbers = [1,2,3,4,5];
numbers.splice(3,1);
//numbers is now [1,2,3,5]

первый аргумент [1 113] соединение встык является ординалом в массиве [индекс], и вторым является число элементов для удаления.