Check it out!

Я не буду описывать все значения, которые может принимать третий аргумент функции open(). Напомню только, что их необходимо писать через запятую, без пробелов. По умолчанию все опции включены, но если вы укажите хотя бы одну, то другие все автоматически отключатся. Следующий пример открывает popup с адресной строкой, ширина окна составляет 400px, высота — 300px и окно расположено в верхнем левом углу экрана:

popupWin = window.open("contacts.html", "contacts", "location,width=400,height=300,top=0");
popupWin.focus(); // передаём фокус новому окну

Ликбез закончен, теперь собственно о том, как правильно использовать метод window.open(). Точнее, как нужно ставить ссылки на новые окна, открывающиеся с помощью JavaScript’а.

Казалось бы, нет ничего проще — пишем что-то вроде

<a href="javascript:popupWin = window.open('contacts.html', 'contacts', 'location,width=400,height=300,top=0'); popupWin.focus();">Наши координаты</a>.

Часто пишут ещё так:

<a href="#" onClick="popupWin = window.open('contacts.html', 'contacts', 'location,width=400,height=300,top=0'); popupWin.focus();">Наши координаты</a>.

На самом деле, более правильный вариант таков:

<a href="contacts.html" target="_blank" onClick="popupWin = window.open(this.href, 'contacts', 'location,width=400,height=300,top=0'); popupWin.focus(); return false;">Наши координаты</a>

Чем же последний вариант хорош? Многим. Во-первых, вы заботитесь о тех пользователях, у которых по той или иной причине не работает JavaScript. У них откроется файл в обычном новом окне браузера, и они смогут-таки узнать ваши координаты. Во-вторых, поисковые машины смогут корректно проиндексировать страницу contacts.html, не спотыкаясь на JavaScript’е. Ну а в-третьих, статусная строка будет выглядеть нормально. Вместо сбивающих с толку знаков типа «#» в статусной строке будет «человекопонятный» URL.

Кстати, обратите внимание на использование ссылки this.href, указывающей на атрибут href тега a. Таким образом мы избавляемся от необходимости повторно указывать адрес открываемой страницы.

Заметьте также, что в обработчике события onClick нужно указать return false. В противном случае, откроется два новых окна — одно из-за действия атрибута target, другое из-за JavaScript’а.

function fileExt(path) {
return path.substr(path.lastIndexOf(‘.’) + 1);
}

Sample Output
Input Output()
file.ext ext
/folder/subfolder/file.ext ext
file.bak.ext ext

In order to get things working again, i’ve had to make a small workaround:

globalEval: function( data ) {
	data = jQuery.trim( data );if ( data ) {

		// Inspired by code by Andrea Giammarchi
		// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html

		var head = document.getElementsByTagName("head")[0] || document.documentElement,
		script = document.createElement("script");
		script.type = "text/javascript";

		if ( jQuery.browser.msie )
			script.text = data;
		else
			script.appendChild( document.createTextNode( data ) );

		head.appendChild( script );

		try {
			head.removeChild( script );
		}
		catch (e) {
		}

	}

},

If I change the first line to «var head = document.documentElement» it all works fine too

<script MEGASCRIPTNAME charset=”utf-8″></script>

var intValue = 1;
var floatValue = 3.0;
var stringValue = "This is a string\n";
var sqString = 'This is also a string';

Javascript is a dynamically typed language. Variables are declared with the keyword var. Common simple types are supported.

Arrays

var emptyList = [];
var homogenousList = [1, 2, 3];
var heterogenousList = ["one", 2, 3.0];

Javascript has built-in collection objects. The Array object is a dynamically typed sequence of Javascript values. They are created with the bracket notation [] or with the new operator on the Array object (e.g. new Array(5)).

Property Maps

var emptyMap = {};
var homogenousMap = {"one": 1, "two": 2, "three": 3};
var heterogenousMap = {"one": 1,
                       "two": "two",
                       "three": 3.0};

Along with Arrays are the Object objects. They act as property maps with strings serving as keys to dynamically typed data.

Access

// Dot notation property access
window.alert("Homogenous map property \"one\" "
             + <font color="blue">homogenousMap.one</font>);
// Subscript notation property access
window.alert("Homogenous map property \"two\" "
             + <font color="blue">homogenousMap["two"]</font>);

Assignment

homogenousMap["one"] = 10;
homogenousMap.two = 20;

Removal

delete homogenousMap["one"];
delete homogenousMap.two;

Iteration

for (var <font color="green">key</font> in <font color="blue">heterogenousMap</font>) {
    window.alert("Heterogenous map property \""
                 + <font color="green">key</font>
                 + "\" = "
                 + <font color="blue">heterogenousMap[<font color="green">key</font>]</font>);
}

Functions

var callable = function (message) { // <-- notice assignment
    window.alert("Callable called with message = "
                 + message);
}

function createClosure(initial) {
    var res = function () {
        initial = initial + 1;
        window.alert("Closure with modified state "
                     + initial);
    }
    return res;
}

function callCallable(f, x) {
    f(x);
}

function composeCallables(f, g, x) {
    f(g(x));
}

Functions are first-class objects. That means that they can be created dynamically, stored, passed and returned just like any other value.

Objects

function MyObject(name, value) {
    this.name = name;
    this.value = value;
}

Javascript supports prototype based object orientation. Not a class type but an object constructor is created for new objects with particular properties. In the example above the this keyword used to reference the »current instance» of the object. The this object is essentially a property map with members accessed (and initialized) in this example with the dot notation.

The object constructor, MyObject, is an object constructor not in how it’s defined, which looks like any other Javascript function, but in how it’s »invoked».

    var my = new MyObject("foo", 5);

The new operator before the function invokes the function with a newly construced object as this and returns that the initialized object.

Object Prototype

Part of what makes a language object oriented is that data not only has properties but also »behaviors». Also known as: member functions; methods; and object messages. To implement a member function in Javascript one would be tempted to write something like what’s below based on the member initialization exampled above.

<font color="red">function BadObject(data) {
    this.data = data
    this.memberFunction = function () {
        // ...functions on data...
    }
}
</font>

While the code above will work without error, it does create a new closure for each member function for each new instance of the object. What’s really required is a class level function that works on instance data. But remember, Javascript objects aren’t class based but prototype based. So how do we implement «class» level member functions? (Skip to Implementation) Better yet, how do we implement «class» level members functions in general?

Enter the prototype member.

The internal object member, prototype, has language defined significance in that it is used for resolving property names if the property isn’t found in the current property map. It’s considered internal because, while the instance’s prototype member is »inherited» from the »constructor’s» prototype member, it cannot be accessed directly from the object instance itself. The defined prototype member is a property map itself which holds members for property name resolution. Consider the example below:

 var parentPropertyMap = {<font color="red">"bar"</font>: <font color="red">"I'm the bar"</font>};

 <font color="grey">// Define the constructor with inheritable properties</font>
 function ChildObject(foo) {
     this.<font color="blue">foo</font> = foo;
 }
 ChildObject.prototype = parentPropertyMap;

 childPropertyMap1 = new ChildObject(<font color="blue">"I'm the foo1"</font>);
 childPropertyMap2 = new ChildObject(<font color="blue">"I'm the foo2"</font>);

 <font color="grey">// Prints "childPropertyMap1.foo = I'm the foo1"</font>
 window.alert("childPropertyMap1.foo = " + childPropertyMap1.<font color="blue">foo</font>);

 <font color="grey">// Prints "childPropertyMap2.foo = I'm the foo2"</font>
 window.alert("childPropertyMap2.foo = " + childPropertyMap2.<font color="blue">foo</font>);

 <font color="grey">// Prints "childPropertyMap1.bar = I'm the bar"</font>
 window.alert("childPropertyMap1.bar = " + childPropertyMap1.<font color="red">bar</font>);

 <font color="grey">// Prints "childPropertyMap2.bar = I'm the bar"</font>
 window.alert("childPropertyMap2.bar = " + childPropertyMap2.<font color="red">bar</font>);

The member foo is an instance member added to the instance’s property map during construction:

 function ChildObject(foo) {
     <font color="blue">this.foo = foo;</font>
 }

while bar is in the constructor’s prototype:

 var parentPropertyMap = {"bar": "I'm the bar"};
 ...
 ChildObject.prototype = parentPropertyMap;

which is »inherited» during the new operation:

 childPropertyMap1 = new ChildObject("I'm the foo1");
 childPropertyMap2 = new ChildObject("I'm the foo2");

In other words, the member, bar, is shared across all instances of ChildObject.

Therefore, by implementing the prototype member of the constructor function, we can think of the constructor function itself as the «class» object. Complete with static class functions:

 function ClassObject() {}
 ClassObject.staticClassFunction = function(x) {
     return x * 2;
 }

static class variables:

 function ClassObject() {}
 ClassObject.staticClassVariable = 5;

shared member variables:

 function ClassObject() {}
 ClassObject.prototype.sharedMember = 5;

and of course, shared member functions:

 function ClassObject(x) {
     this.x = x;
 }
 ClassObject.prototype.memberFunction = function(x) {
     return x * this.x;
 }

Member Function Implementation

function Message(message) {
    this.message = message;
}

Message.prototype.show = function() {
    window.alert("Message.show() with message = "
                 + this.message);
}

(More on Classes and Objects)

Example Code

//////////////////////////////////////
// Basic Types
var intValue = 1;
var floatValue = 3.0;
var stringValue = "This is a string\n";

///////////////////////////////////////
// Array
var emptyList = [];
var homogenousList = [1, 2, 3];
var heterogenousList = ["one", 2, 3.0];

///////////////////////////////////////
// Property Map
//
var emptyMap = {};
var homogenousMap = {"one": 1, "two": 2, "three": 3};
var heterogenousMap = {"one": 1,
                       "two": "two",
                       "three": 3.0};

///////////////////////////////////////
// Functions as values
//
var callable = function (message) { // <-- notice assignment
    window.alert("Callable called with message = "
                 + message);
}

function createClosure(initial) {
    var res = function () {
        initial = initial + 1;
        window.alert("Closure with modified state "
                     + initial);
    }
    return res;
}

///////////////////////////////////////
// Functions as arguments
//
function callCallable(f, x) {
    f(x);
}

function composeCallables(f, g, x) {
    f(g(x));
}

///////////////////////////////////////
// Objects
//
function MyObject(name, value) {
    this.name = name;
    this.value = value;
}

///////////////////////////////////////
// Objects with Member Functions
//
function Message(message) {
    this.message = message;
}

Message.prototype.show = function() {
    window.alert("Message.show() with message = "
                 + this.message);
}

///////////////////////////////////////
// Demo Utilities
//
function quote(message) {
    return "\"" + message + "\"";
}

///////////////////////////////////////
// HTML Invoked demonstration
//
//
function main() {
    window.alert("Integer = " + intValue);
    window.alert("Float = " + floatValue);
    window.alert("String = " + stringValue);

    for (var item in emptyList) {
        window.alert("Empty list item = " + item);
    }

    // Script style index iteration
    for (var i in homogenousList) {
        window.alert("Homogenous list item = "
                     + homogenousList[i]);
    }

    // C style index iteration
    for (var i=0; i < heterogenousList.length; ++i) {
        window.alert("Heterogenous list item = "
                     + heterogenousList[i]);
    }

    // Dot notation property access
    window.alert("Homogenous map property \"one\" "
                 + homogenousMap.one);
    // Subscript notation property access
    window.alert("Homogenous map property \"two\" "
                 + homogenousMap["two"]);

    for (var key in heterogenousMap) {
        window.alert("Heterogenous map property \""
                     + key
                     + "\" = "
                     + heterogenousMap[key]);
    }

    callable("(Function value invoked)");
    closure();
    closure();

    callCallable(closure);
    composeCallables(callable, quote, "My Message");

    var my = new MyObject("foo", 5);
    window.alert("MyObject my.name = " + my.name);
    window.alert("MyObject my[\"value\"] = " + my["value"]);

    var msg = new Message("bar");
    for (var key in Message.prototype) {
        window.alert("Message prototype member \""
                     + key
                     + "\" = "
                     + Message.prototype[key]);
    }

    window.alert("Message msg.message = " + msg.message);
    msg.show();
}

Andrea Giammarchi создал небольшой (0,5 Kb) javascript мониторинга CPU.

Скрипт реализует монитор который отображает загрузку процессора клиента.
На мой взгляд, подобное решение может использоваться для оптимизации нагрузки на клиентский ПК, в процессе работы веб- приложениями требующего значительные ресурсы клиентского ПК (ajax решения и.т.д.).

Вставить скрипт себе на страницу можно так:

<script type=“text/javascript” src=“http://www.3site.eu/JPU/JPU.js”>
<!–//
JPU - by WebReflection
//–>
</script>

Запустить скрипт на данной страницы можно нажав тут
Более детально — тут.
З.Ы. Скрипт написан Just for fun — о сверх точности говорить пока рано.