Can one script run many items?

Yes. Almost always it is better to do it that way.

In general, you'll have a very similar looking script. There will just be an addition of a loop to perform the action on each part (or maybe several loops in things that require waiting). For example, if there was a Model of parts that you wanted to change color when touched, you would just have to modify the event to use a closure:

function Touch(hit, me)
    me.BrickColor = hit.BrickColor
end

for _, part in pairs( workspace.Model:GetChildren() ) do
    part.Touched:connect( function(h)
        Touch(h, part)
    end)
end

The above corresponds to something like this:

function Touch(hit)
    script.Parent.BrickColor = hit.BrickColor
end
script.Parent.Touched:connect( Touch )

A more complicated example is to make a list of parts flip between blue and red every second. The single script for each might look like this:

while true do
    script.Parent.BrickColor = BrickColor.Red();
    wait(1)
    script.Parent.BrickColor = BrickColor.Blue();
    wait(1)
end

If you don't think carefully about it, you might try translating it into the following:

-- THIS DOESN'T WORK!
for _, part in pairs( workspace.Model:GetChildren() ) do
    while true do
        part.BrickColor = BrickColor.Red();
        wait(1)
        part.BrickColor = BrickColor.Blue();
        wait(1)
    end
end

Why? Because it starts an unending loop for just the first part, and never even gets to the second. Removing the loop will be a bit better, but it will do each part in sequence, rather than all at once.

A simple solution is to use 2 for loops:

while true do
    for _, part in pairs( workspace.Model:GetChildren() ) do
        part.BrickColor = BrickColor.Red();
    end
    wait(1)
    for _, part in pairs( workspace.Model:GetChildren() ) do
        part.BrickColor = BrickColor.Blue();
    end
    wait(1)
end

This could be cleaned up with the help of a function to paint a list of parts (avoiding the repeated code)

An even more complicated example is when you want to do the above but you want them each to be flashing at random offsets, e.g.,

while true do
    script.Parent.BrickColor = BrickColor.Blue()
    wait(math.random())
    script.Parent.BrickColor = BrickColor.Red()
    wait(math.random())
end

A direct way to do it is to spawn a new coroutine for each part:

function flash(part)
    while true do
        part.BrickColor = BrickColor.Blue()
        wait(math.random())
        part.BrickColor = BrickColor.Red()
        wait(math.random())
    end
end



for _, part in pairs( workspace.Model:GetChildren()) do
    spawn(function() flash(part) end )
end

Though this isn't very elegant because spawning a large number of threads in general can cause difficulties.

Unfortunately, a direct way to do this in one thread is much more sophisticated (though possible):

changes = {}
for _, part in pairs(workspace.Model:GetChildren()) do
    changes[ part ] =
        {
            time = math.random() + tick() ,
            red = false
        }
end

while true do
    soonest = tick() + 1
    -- The soonest (so far seen) that
    -- a brick needs updating

    for part, data in pairs( changes ) do
        soonest = math.min( soonest, data.time )
    end
    wait( soonest - tick() )

    -- Wait just until that moment
    -- (Less performant, but more responsive, would be
    -- to just always wait using RenderStepped)

    for part, data in pairs( changes ) do
        if data.time < tick() then
            if data.red then
                part.BrickColor = BrickColor.Red()
            else
                part.BrickColor = BrickColor.Blue()
            end
            data.red = not data.red
            data.time = tick() + math.random()
        end
    end
end