Mark Pilgrim details how to detect every HTML5 feature in browsers using JavaScript object detection. Covers every element, and its facets, for example not just whether the audio element is supported, but whether it supports MP3 too. Also covers features like local storage, Web Sockets, Web Workers, and user interface enhancements of the HTML5 specification
PPK describes the this keyword as a reference to the owner of the function we are executing, or the object that a function is a method of. He then compares how attaching a function to an event in two different ways affects what the this keyword references.
Tim Caswell describes the JavaScript variable 'this', which is about current scope and current context. The only way to create scope in JavaScript is through function definitions, and in most cases the context is the receiver of the message (the object before the dot in the method call). He also talks about approaches to controlling what this references with call, apply and bind.
Mike Alsup builds up to an elegant plugin development pattern for jQuery plugins, starting with requirements and adding a piece at a time. By explaining the reasoning and though behind each piece of the puzzle, it explains a number of important good parts of the JavaScript language
Christian Heilmann lays out seven rules to better unobtrusive JavaScript, including not making assumptions about JavaScript, the browser and the document. Work with structured markup. If you are traversing a document, maybe there's a solution that can take advantage of CSS's selector mechanism instead. Work with browsers and users. Better understanding of events, and playing nice with namespace, scope, and patterns. And of course, think about the next developer, so keep the code maintainable.
Fellow co-worker Lawrence Carvalho discusses the Undo functionality, and as web based applications start to replace desktop ones, this crucial bit of functionality will become expected by application users. Lawrence talks about the Memento design pattern and guides us through designing objects that can undo their changes. He builds an undoable text widget.
Jim Ley covers the intricacies of type conversion, implicit and explicit. He covers type conversion into boolean, string, number, undefined, null; and parsing into floats and integers. This is backed up by conversion tables for quick reference. There's also a useful section on regular expressions for form field validation.
Andy Hume whittles away the various JavaScript libraries to produce a clear explanation of event delegation and how it works. Its a technique that reduces the number of event listeners attached to the document by attaching just one event listener to a container element. He presents a simple code example and talks about the benefits of event delegation, including performance and code maintenance. (Includes workarounds for IE and a Safari bug)
Cory Hudson sees callbacks as benefiting from currying JavaScript functions, and defines currying as turning a function with two arguments into a function with one argument that returns a function of one argument. He starts off with two functions and shows how to combine them into one curried function, and also builds a generic version. He shows a good usage of a curried function in an array map() function, which is similar to Prototype's bind().
Jonathan Snook demonstrates when JavaScript passes by reference or passes by value. Essentially, primitive types are passed by value, objects are passed by reference. Passing functions however, makes things look like a pass by value if the this keyword is being used in the code. Snook offers workarounds to this by passing objects so that the context is correct, or using the call() function to ensure the context is correct.
Dan Webb describes curried functions as a way of creating reusable callback functions for event handlers or Ajax requests, or anything that takes a function as an argument. By using closures, curried functions have a simple way of persisting data between calls. He also offers an elegant way of running a lots of methods on objects, with a simple map function written as a curried function.
Svend Tofte discussed currying JavaScript functions, which he describes as a way to partially evaluate functions. Its a function that returns another function. In an example, one function either adds together two numbers, or if only one parameter is sent, returns a function that can be called later to supply the second number.
Tim describes another two different approaches to using the Module Pattern (a way of creating Singletons). The first example takes advantage of the natural indentation to clearly see which methods are private and which are public. The second is a curried function, a function that returns another function.
David Dorward compares dot notation and square bracket notation, where square bracket notation can be used where dot notation can't. Recommends using dot notation, because its easier to read, and square bracket notation when it can't be done with dot notation.
Erik Arvidsson warns against extending the JavaScript Object with Object.prototype, as it can lead to breakages in third party code when they use the for(key in obj) method of iterating through any class (since they all are subclasses of Object). Instead Erik recommends extending the classes that directly benefit from the extending functions, and treat Object as a final constant. Erik also suggests that hashes and associative arrays should be done in JavaScript using Object, not Arrays.
The Yahoo! Web Developer Network provides a one page overview of JSON, giving a quick tutorial on JSON, how to get Yahoo! Web services to emit JSON, offering an output of a JSON object literal as well as using a callback function method. Yahoo! also describes how their web services typically translate their XML structures into JSON.
Christian Heilmann offers another incremental improvement to the Module Pattern, and calls it the Revealing Module Pattern. This defines an anonymous object that contains a list of methods and properties that are publicly available. Christian notes that this method also allows you to set up a public property that's privately generated by a method. Christian's improvement makes it quickly clear which properties and methods are public.
Ryan Campbell of Particletree offers a step-by-step guide to getting started with JSON. Since JavaScript can use JSON to either send or receive from the server (both parts of an AJAX request), Ryan suggests getting started with sending JSON (after stringifying it) to the server and converting it to a server side object. Then sending that object back, encoded as JSON, to the client and process that. He offers working library code for both JavaScript and PHP (for the server part).
Christian Heilmann compares the Object Literal to Douglas Crockford's Module pattern and finds that the Module pattern fixes a major problem of the object literal - the difficult choice of using this or fully qualified references to functions in the same block. Christian also covers the improvements in the Module Pattern, like the decluttering of the return block, which makes the resulting a little easier to work with.
Eric Miraglia explains Douglas Crockford's Module pattern, a way of creating encapsulated JavaScript functions that offer private and public methods and properties. It uses an anonymous function that returns an object containing our methods, and avoids the big issue of cluttering up the global namespace with global functions. Its based on the Singleton pattern.
Klaus Komenda discusses a number of ways of encapsulating JavaScript functions into objects and namespaces, and shows how to use each pattern. He covers Singletons, Douglas Crockford's Module Pattern and Custom Objects, building the same functionality with each technique.
A table that lists CSS style properties and their JavaScript equivalents. Useful for dynamically setting styles in JavaScript, although the better method, if possible, is to use classes instead, and those classes are styled with CSS. A few are missing, like float which is a reserved word in JavaScript.
An evolt article that covers using Regular Expressions, including the difference between static and dynamic regular expressions (compiled at compile time or runtime respectively). Good selection of tables such as regex modifiers, patterns and escaping, look ahead, backreferences. Includes a short section on usage. A neat short cheatsheet for starting to use regular expressions.
As web pages become more and more like applications, code performance becomes more and more important. This article looks at a number of performance issues to avoid, in EcmaScript, DOM and AJAX requests. Covers eval, the with keyword, try/catch in performance-critical code, global variables, implicit object conversion, string concatenation, primitive operations over function calls, repainting and reflowing documents, modifying elements, using XPath.
An online copy of O'Reilly's 2002 book Creating Applications with Mozilla. It focused on pre-1.0 versions of Mozilla, so details about the application structure has changed, but the XUL elements are relatively stable.
JavaScript documentation surrounding version 1.5, 1.6 (supported by Firefox 1.5 and Mozilla 1.8), and version 1.7 (supported by Firefox 2.0). Backed up by mailing lists, newsgroups and an IRC channel
A reference manual for the core JavaScript language for version 1.5. Covers the standard base objects, methods and properties, including RegExp, and Java-related objects. Archive copy of Netscape's reference published in September 2000.
All JavaScript implementations implement a debugger statement, which can be called at any point in your script. Also we have console.debug in Firebug.
Another Douglas Crockford video. This time Douglas talks about the Document Object Model, about how Java failed, and JavaScript evolved thanks to DHTML and DOM. He talks about how to use DOM to traversing and manipulating elements in an HTML document, walking the DOM, making elements, innerHTML, as well as Events, memory leaks. He talks about the cracks in DOM, and how we must be prepared to back off when we hit the browser limits of DOM.
Douglas Crockford's presentation on Advanced JavaScript. He covers topics such as inheritance, modules, debugging, efficiency and JSON.
Douglas Crockford's JavaScript code conventions. Covers indentation, line length, comments, variable and function declarations, minification, statements and labels, whitespace, scope and eval.
First in a series of talks from Douglas Crockford about the JavaScript language. These talks cover the JavaScript language, from the history, the language, advanced features, platforms, standards and programming style. Talks about inheritance, using functions to build objects, closures, as well as the basic JavaScript syntax. Also covers code conventions. JavaScript is a language that requires discipline.
Instead of creating a new XmlHttpRequest object for every request, this post provides code to pool these objects together and reuse them. This saves a great deal of processing times, particularly in IE.
An example of a Decorator pattern based on the flexibility of prototype to extend a JavaScript object. Decorating an object allows customised functions to be called before and after a method call, the real method call is wrapped between the before and after hooks. One method of Aspect-oriented programming with JavaScript
Matt Kruse's JavaScript Toolbox presents a number of excellent best practice ideas including: using var, feature detection, when to use square bracket notation, avoiding eval, referencing forms and form elements, avoiding the with keyword, using onclick instead of JavaScript pseudo-protocol, using unary + to type convert to numbers, avoiding document.all, not using HTML comments in script blocks, avoid cluttering the global namespace, avoiding prototype.js, avoiding synch Ajax calls, using JSON and the correct way to use script tags
Christian Heilmann offers us Dishy, a JavaScript REST API for talking to del.icio.us. Taking full advantage of del.icio.us' JSON format and the script element, Dishy doesn't need a server-side proxy. Its a useful helper class for easily getting information from del.icio.us.
Guides, notes, overviews, documentation for the Prototype library. Pathfinder compiles a list of useful resources for this library.
Christian Heilmann's excellent guide to writing unobtrusive JavaScript. Takes the reader from the inline JavaScript world right through to a clean dynamically attached events with all the JavaScript code in external files. Covers DOM Scripting. This is the key reference to unobtrusive scripting.
Ryan Campbell shows how to get the Prototype library up and running, and introduces and documents Protoype's $() function. Form helper functions, getElementsByClassName functions, Element helper functions, Ajax support, timer functions are all covered.
An index of JavaScript's core methods, ordered by method name. No DOM methods are listed, but Browser Object Model (BOM) is.
Douglas Crockford discusses his method of exposing the powerful prototypal inheritance from JavaScript, using his object function which untangles JavaScript's classical-adopted constructor pattern.
A collection of performance related techniques, including temporary references (for deeply namespaced properties), optimising loops by referencing the collection length once, reasons to avoid the with syntax, using null over the delete function, comparison for equality and identity and short-circuit logical expressions
Comparing three methods of URI encoding. Escape() is probably best avoided, with encodeURI() and encodeURIComponent() being used depending on what form your data is in.
Gez Lemon reviews Christian Heilmann's recently published book. Its a thumbs up, and recommended for developers working with standards and accessibility, regardless of their JavaScript level.
Douglas Crockford introduces the JavaScript Object Notation, a lightweight data interchange format that's giving XML-based web services a run for its money. Its a subset of the JavaScript programming language, and very easy for programs to parse or generate, and so its not surprising that all major languages now have JSON libraries/code snippets.
As well as supporting CSS based selectors, jQuery also supports XPath expressions. This page lists a plethora of code snippets demonstrating jQuery's XPath matching capabilities.
A list of the CSS Selectors supported by jQuery. It includes the regular gamut of CSS selectors as well as attribute selectors, pseudo-selectors and child selectors.