Answer : Yes
It has objects which can contain data and methods that act upon that data. Objects can contain other objects.
- It does not have classes, but it does have constructors which do what classes do, including acting as containers for class variables and methods.
- It does not have class-oriented inheritance, but it does have prototype-oriented inheritance.
Hanselminutes episode 146 looks at OO Ajax. It was a good show and definitely a good show to help form an opinion.
I am responding this question bounced from another angle.
This is an eternal topic, and we could open a flame war in a lot of forums.
We could put here a lot of references about this topic in very old books and forums, because this topic is older than the Internet :)
When I was a student (in 1993), in university, there was a typical home work: Implement a program designed using a OOD (Object-oriented design) with a non-OO language. In those times, the language selected was C (not C++). The objective of this practices was to make clear the difference between OOD and OOP, and could differentiate between OOP and non-OOP languages.
Anyway, it is evidence that not all people have some opinion about this topic :)
I think when you can follow the same or similar design patterns as a true OO language like Java/C#, you can pretty much call it an OO language. Some aspects are obviously different but you can still use very well established OO design pattersn.
It is object oriented, but not based on classes, it's based on prototypes.
Technically it is a prototype language, but it's easy to to OO in it.
The short answer is Yes. For more information:
This is of course subjective and an academic question. Some people argue whether an OO language has to implement classes and inheritance, others write programs that change your life. ;-)
(But really, why should an OO language have to implement classes? I'd think objects were the key components. How you create and then use them is another matter.)
Yes and no.
Yes, it is. However, it doesn't support all of the features one would expect in an object oriented programming language lacking inheritance and polymorphism. This doesn't mean, however, that you cannot simulate these capabilities through the prototyping system that is avaialble to the language.