There are a lot of tutorials on the subject you can pretty much google it.
Basically the spaces match the matrix names Model, World, View, Projection.
To put it pointedly though spaces themselves imply relativity to some origin.
A space must be relative to something.
In the case of your model its relative to the origin from which it was created this is the 0,0,0 position in say your model editor, vertices in this space are related to system modeling coordinates from its vertices orgin point we define the models spac-ial positioning.
This is the local space that vertices derived from they are relative to what is called model space. When you put it into your game any transformations done on it prior to and seperate from worldspace transforms are called local space transformations though the term is used synonymously with model space.
When you drop it into your game into your game world, you position it in your World Space by the world matrix (this is called translation) just like you place a piece on a map facing some direction (rotation). This is Your world's space. Typically each object has its own unique world transformation. Your model vertices were relative to your model editors origin now there relative to your game worlds origin.
Now its nice and all to have everything in your world on your map but when you want to look at objects that are far from position 0,0,0 you need to either move them closer to you or move yourself closer to them. For this you need to define what that position and orientation is which is what we call a camera.
This is were the view space comes in what it does is defines a position as the new origin of the world. The idea is that it transforms the entire world so all vertices from all models are effected by it. But its spacial change is very similar to the world matrices change its just another transformation to the world but to all of them.
Typically it is thought of as a camera or sometimes even called camera space. It basically translates and rotates everything around its position at least everything that is transformed by it. This includes your vertices from model space that were placed into your world.
This can be done in steps on vertices for example vertice * world = p then p * view = p2 then p * projection = p3 the result. However transforming vertices by each matrice one at a time is inefficient, This is why we multiply the matrices together first.
The short cut to doing this in steps is as said to multiply the matrices together first, then multiplying the vertices by that final result, this is called (transforming). Vector3 has a transform function that takes a matrix just for this reason.
The projection space deals with creating a type of projection into gpu or screen space it usually acts as a scaling matrix that scales x y coordinates to gpu virtual space its special in that it also can scale x y coordinates dependent on there depth. This defines a mathematical view frustrum (you can google it) It can do other things like effects on its own which are beyond the scope of this topic.
The projection matrix is essentially a fancy scaling matrix because gpu space is virtual it ranges from -1 to 1 from end to end (things beyond this range are clip-ed simply not drawn) so it scales everything way way down. It seldom needs to change unless you resize the game window.
We have matrix's that denote these different spaces and one multiplied by the other gives a combined space such as a model vertices * matrix.world = gives a model to world transformation.
It places the model into the world space. model(or your vertices) * world * view = a WorldView space transform it translates vertices from model space were they were created thru world space were they are oriented into view space (were they are reoriented around the view matrix or the cameras lookat orientation) finally by the projection were they are projected to the gpu's virtual space typically just called screen space.
When you multiply all the matrices first...
world * view * projection you get a final matrix WorldViewProjection.
Though typically you per frame you keep a ViewProjection matrix combination even across multiple frames tacking on the world to it whenever a objects world orientation changes lets you multiiply your models vertices against it the gpu does this when you pass in your vertices thru draw setting the world matrix for the model.
With that it can multiply vertices against the frames final matrix directly which is of course what shaders do.