Here is a decent writeup about VBOs.
Here is a good overview of the calling semantics.
Here here is another good overview of performance issues; in it we see that VBOs are more performant than arrays.
The reason we prefer VBOs is that the data is loaded onto the card, and so you don't have to transfer it every frame. Depending on the type of VBO created, you can give the graphics driver hints on the usage (write-many, read-many vs. write-many, never-read, etc).
VBOs are really good for static geometry like terrain that you don't expect to change, or for instanced geometry.
Vertex arrays are good for data that changes frequently but that also is read by the host machine--so, for directly rendering data that is being manipulated (laser rangefinder data buffers, for example, are where I've used them) frequently. If you can get away with never reading the data on the host device (so, just pushing it out onto the card), VBOs in write-only mode are a good option.
Client Side Vertex Arrays
These are available in OpenGL prior to 3.0, deprecated in 3.0, and gone in 3.1+.
OpenGL ES supports them (OpenGL ES 2 does not).
These are available after OpenGL 1.5.
These are the only way to store geometry data in OpenGL ES 2 (and so, WebGL).