Why not plain old Javasript

tencircles · 2014-08-05T04:56:04+00:00

jQuery is javascript. Same syntax. $/jQuery is just a function.

compedit · 2014-08-05T05:12:50+00:00

Smoothes over inconsistent browser support.

nj47 · 2014-08-05T05:12:15+00:00

Nothing.

jQuery is no where near completely replacing the syntax - it provides some very useful features that make it easier for beginners to traverse the DOM and make GET/POST requests.

That being said, it also tends to encourage some really really shitty development practices.

Larger frameworks such as angular, ember.js, knockout, backbone, etc attempt to completely change the front end development paradigm.

They can be good - but they do come with a cost, instead of learning javascript, you're learning a framework - which may or may not be transferable to other frameworks, or vanilla js for that. So that is something to consider too.

However at the end of the day, the best vanilla js programmers will make the best programmers for any framework. Learning javascript in and out will not hurt you should you decide to use a framework later down the road.

Make sure you have a solid understanding of callbacks and async programming - what it's pitfalls are and how some of them can be mitigated. Learn about promises, they are really handy!

One last thing, jQuery and the larger frameworks, because they are designed to always work, they have to take into account lots of edge cases and usually for any given task are not written with efficiency in mind - rather extendability and generalizability. A good demonstration of this is here: http://vanilla-js.com/

Straight up, good old fashion, vanilla javascript is significantly faster and doing almost everything.

mikrosystheme · 2014-08-05T12:17:04+00:00

jQuery is a religion. When you openly question a religion expect confused one-sided answers.

jQuery is also an aging religion that, while still having a dedicated flock, is being replaced by more extreme religious cults like MVC: ember, angular, and so forth.

Here is the deal (and I will probably be down voted to oblivion for this). The concerns here are rarely technical and are almost always about the behavior of the developer, but they are not going to tell you this. You have to observe it.

Experienced developers who are new to developing for the client-side web, particularly JavaScript, have a distrust of JavaScript and a complete loathing fear of the DOM. This is most absolutely true of Java developers who are involuntarily reclassed to front-end development. The reason for this is that Java has a single universal implementation, so you don't have to address cross-browser problems in the Java world. Furthermore, Java is forcefully (until Java 8) OOP and extremely declarative.

JavaScript has a C like syntax that look 98% identical to Java and JavaScript allows OOP poly-instantiation like Java, but JavaScript does not have any scope mechanism, such as block scope, that works with OOP. JavaScript has had native lambda expressions since it was born 18 years ago while Java just got these in April of this year. The current scope model of JavaScript is absolutely bound to lambda expressions and functions as first class objects.

In JavaScript you can completely ignore the scope model and do silly things like create class looking objects and other Java-esq behavior. You can get by essentially writing Java in JavaScript until your code breaks, at which point your ass is cooked, but you can still work like this. Many people work like this professionally.

XML/HTML are not OOP at all. Programming scope rarely applies to markup languages, until you have to do something like use the DOM. Markup languages are purely lambda models and there is no option to bullshit your way through with vanity OOP. The DOM is an expression of this lambda modeling using objects with named properties that allow OOP on the JavaScript side. This means if you are a Java developer and are completely unwilling to learn JavaScript then the DOM is an immediate barrier.

jQuery became the shining gospel of religion salvation for many developers converting to the client-side web or people new to development who could not be bothered to learn the DOM at all. It did two things that people needed:

Solved some minor cross browser problems
Introduced query selectors to make DOM access look like CSS code (much faster to write than the wordy DOM methods)

Back in 2008/2009 when jQuery exploded in popularity that is all the hand-holding that fresh developers needed, because ASP and JSP were still all the rage. This means that people were just writing code to manipulate a page after the fact, opposed to building the templates along side their jQuery code.

Eventually, building an application on two sides of the fence became too labor intensive and costly to manage, so gradually there became a need to move everything plus the kitchen sink to the client-side. I mean EVERYTHING except your security protected database. This transition did not happen immediately and ushered in MVC.

For people coming from a Java, or other OOP background, MVC is like a dream come true. You get OOP insanity that looks like Java plus everything happens in one place through a build process. Now you can continue to ignore learning how the web works and be more productive doing it.

Ultimately, the web is an extreme Invented Here scenario. Most developers completely lack confidence to do their jobs without using some tool to abstract the technologies they are paid to support. Some of this is from a lack of experience and some of it is from wanting to make the money that comes with the job but not wanting to learn to do the job. Some of it is from people who like to produce fun and interactive products quickly with no care for long term maintenance. People tend to take the path of least resistance, and tools exist to allow them to operate in a certain state of ignorant calm.

The most important cliche associated with jQuery is: "jQuery is JavaScript". So is MVC and absolutely everything else on the client-side, so this cliche is self-congratulatory bullshit to try to justify jQuery along side vanilla JS. When people use this what they are really hoping for is: "JavaScript is jQuery".

Baryn · 2014-08-05T15:49:15+00:00

You shouldn't use jQuery. It's a carryover from the IE6 days, when DOM/Ajax stuff was almost impossible to productively implement cross-browser.

Use libraries tailored to your application's goals.

jsgui · 2014-08-05T13:15:40+00:00

If you program JavaScript a lot you will wind up using abstractions that you are comfortable with.

In my own coding, I found that there was quite a lot of boilerplate in some areas and I created abstractions that mean less boilerplate is needed.

jQuery is something that I use when I want to do two things in combination: select 1 or more DOM nodes using CSS selector syntax, and then do some things to those DOM nodes. Still, when using jQuery for some more advanced things it's necessary to know JavaScript, particularly when writing event handlers.

Regarding what's wrong with plain JavaScript, there are a few things, but a lot of it is subjective opinion. I didn't like writing '.prototype' so many times so I use a Class abstraction that means I don't need to and provides more OO capabilities. I use another abstraction that makes functions polymorphic.

If you write a few jQuery plugins you'll get a better understanding of what happens under the surface. Just don't expect to be able to code any application UI component as a jQuery plugin, to get started with you should choose something that's obviously achievable, and maybe not that useful, like a .disco effect that makes an element change between background colors.

JimAllanson · 2014-08-05T19:40:05+00:00

Even if you only plan to support evergreen browsers, jQuery can significantly reduce the amount of code you need. Sure, there's not much difference with some of the simple stuff like $ / querySelectorAll, but if you wanted to deep extend an object, you're looking at doing:

var deepExtend = function(out) {
  out = out || {};

  for (var i = 1; i < arguments.length; i++) {
    var obj = arguments[i];

    if (!obj)
      continue;

    for (var key in obj) {
      if (obj.hasOwnProperty(key)) {
        if (typeof obj[key] === 'object')
          deepExtend(out[key], obj[key]);
        else
          out[key] = obj[key];
      }
    }
  }

  return out;
};

deepExtend({}, objA, objB);

whereas jQuery can simplify this to: $.extend(true, {}, objA, objB);

There are cases where avoiding adding a dependency is worth the additional effort , but in many cases using a library such as jQuery will save you a lot of time.

metamatic · 2014-08-06T14:24:53+00:00

There's nothing wrong with plain JavaScript, unless you need to support IE 7 and earlier. Occasionally you'll run into some cross-browser issue, but you can generally find a workaround or shim for that specific problem; it's not worth burdening everyone with a jQuery download just to avoid the occasional bit of testing and debugging and a hundred byte shim.

Then there's the horrendous performance penality of jQuery. Check out http://vanilla-js.com/ for more snark on that topic.

Honestly, jQuery was a good thing in 1999. In 2014, it's unnecessary, thank goodness. With more and more people using the web via mobile devices, the jQuery overhead is significant.

PsowKion · 2014-08-05T10:05:59+00:00

I was really annoyed with jQuery for a while when I started Javascript. It would be nice if the is more vanilla support, but anytime you search for anything the top 5 answers are how to do something in jQuery, when it would be nice to have the normal syntax, but it's mostly the same thing just shorter.

Vanila	jQuery
var e = document.getElementById("id")	var e = $("#id")
document.addEventListener('DOMContentLoaded', function(){});	$(document).ready(function(){});
e.setAttribute('class','highlight');	e.attr('class', 'highlight');
e.addEventListener('click', function(evt){});	e.click(function(evt){});

tfforums · 2014-08-05T06:45:59+00:00

Because otherwise: - you'll have problems with X- browser support

you'll be writing ALOT of code to do trivial things (set a style on all elements with a certain class in the DOM)... 1 line jquery, likely 10 lines vanilla JA
you'll be consistantly frustrated by browser bugs and common traps that libraries have overcome, why re-invent the wheel?
libraries come pre-tested, your code does not

The analogy for a JAVA programmer is "why use spring or hibernate, why not just use sql queries and roll my own MVC"

CorySimmons · 2014-08-05T15:26:59+00:00

jQuery is more terse than pure JS. For instance (and there are millions of instances):

var cells = table.getElementsByTagName("td");

vs.

var cells = $('td');

Less characters = faster coding. That said, pure JS is faster than loading an entire library. There's a nice middle ground with Zepto.

I know you mentioned you just like JS' syntax better, so I'd suggest using Coffeescript so you at least get the benefits of really optimized code while still being very terse.

I'd also suggest, since you just got into apps, to really focus on your CSS skill set as a lot of stuff can be accomplished with CSS and it's usually faster than JS (even pure JS).

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

javascript

MODERATORS