Seçkin Anıl Ünlü's Library tagged javascript → View Popular

1. Closures to Extend Variable Scope
Simply put, closures allow variable scope to be extended past the common scope restrictions of functions.
20 more annotations...
- That inner function has access to all variables in its parent function’s scope. This comes in handy when creating methods and properties in object oriented scripts.
- To create a closure, you nest a function inside of a function.
- Because the method in the alert is actually calling a nested function, that method is able to read the value of the variable called newValue, even thought that variable is not within the scope of the anonymous function, or method.
- The power of the closure is revealed when that method (the inner function) is called, and values that normally wouldn’t be accessible are within "regional" scope and are thus able to be used as any other value.
- 2. Object Literals to Pass Optional Arguments
- Instead of passing the large number of arguments in the conventional fashion, which could unnecessarily complicate the function, you can pass just one argument which ends up being a collection of arguments declared in an object literal.
- First, the function itself is simplified
- Plus, the actual argument values are easy to read, and can easily be understood, updated, or modified, since the correlation between the values and the argument references are more direct.
- 3. Contextual Targeting of DOM Elements
- Whatever the case, it’s not impossible to access those unidentified DOM elements via JavaScript. Using what I call "contextual targeting", you can gain access to, and modify, almost any element in the DOM. As long as you have a map of the general template that contains the element you want to target, you can access that element and manipulate it the same way you would an element that has a class name or ID.
- The possibilities are endless with contextual targeting, and there are even more options available if you’re using a JavaScript library that normalizes browser differences and simplifies DOM manipulation.
- 4. Using Namespaces to Prevent Conflicts
- If you’re doing an extensive amount of raw JavaScript coding and suspect that additions could be made to the same pages you’re working on, you can prevent any future conflicts with your code by giving your code its own namespace.
- Object-oriented JavaScript implements namespace-like principles due to the fact that properties and methods are declared inside of objects, thus there are less likely to be conflicts.
- The first few lines create the namespace by checking to see if the "MY" object already exists. This object can be whatever you want it to be. Just pick a name that you don’t think will ever be used again.
- 5. Hybrid Application Development
- You can create powerful JavaScript applications if you use a combination of a JavaScript library and raw JavaScript code.
- There is no point in reinventing the wheel. You can implement your favorite JavaScript library and take advantage of its simplified Ajax calls, DOM methods, and normalization of browser differences.
- 6. Rendering Readable HTML
- Now the code is much more readable, and conforms to the manner in which HTML is rendered in an actual HTML page.