On the Wikipedia page for Shor's algorithm, it is stated that Shor's algorithm is not currently feasible to use to factor RSA-sized numbers, because a quantum computer has not been built with enough qubits due to things such as quantum noise. How do modern quantum computers prevent interference with computations from this noise? Can they prevent it at all?
How do we prevent quantum noise in a quantum computer?
Well, technically the answer is (at least for most systems): we use ridiculously low temperatures (much colder than space), we shield everything (or at least as much as possible) out, that might introduce any noise (radio waves, such as phone signals or light, magnetic fields, ...), we do everything to remove particles on our chips, that might interact with our system and we are super careful, that the connections (i.e. cables, optical fibres and such) to the environment (control and readout lines) carry as little noise as possible.
But that will not be enough to run a relevant Shor. To understand what else we can do, let's understand:
What is Quantum noise?
Noise is present in all systems - so also your classical computer. In classical computers however this can manifest in only one way: a bit that should be in one state (say 1) turns out to be in the other (say 0) instead. This is pretty easy to correct for: we just run the computation in parallel a few times and check every now and again if one of them is off and correct the error (assuming the majority to be right)*. So we, of course try to prevent noise, but more importantly, we correct for it!
Quantum noise turns out to be much more complicated. How so? Well generally the state of a quantum bit (qubit) can be described as a point on a sphere (commonly called bloch sphere). Noise can now move this point somewhere along the sphere (or in fact make the sphere smaller). But we can still apply the same error correcting we used for the classical computer right? No! The tricky part about quantum computing is, that we only get to chose to points on the sphere and get to know to which one it was closer to*. Also we project the state of the qubit into that value - so the value actually becomes the value we measured, no matter what it was before. Crazy, right? Well that's quantum mechanics for ya. So we cannot simply compare the computations while running it as before, because that would destroy our computation!
Quantum error correction to the rescue?
Well, it turns out quantum error correction is actually possible through a few tricks (which are kind of hard to explain here - so just for feelings sake: we measure in a slightly different way instead, allowing us to just measure weather two qubits are the same in some respect or not. Again, if we do measure that they are the same we have projected them into being the same, if not we can correct. The important phrase being in some respect, so we have to do this for several types of errors that can happen and afterwards try to puzzle out what actually happened to the qubit). For it to work however, we need a quantum computer that already has very little noise to begin with (see also "Why do error correction protocols only work when the error rates are already significantly low to begin with?"), can talk (are coupled) to each other and we generally have sufficient control over. Right now, nobody is close to fulfilling all these requirements sufficiently at once (separately on different system they have all been achieved).
*Well that's not exactly how it works, but roughly.
The answer to noise (and any source of error, really) in quantum computations is quantum error correction: You choose an encoding such that discretized errors correspond not only to invalid encodings but also uniquely determine what kind of error must have occured. This is not possible for all errors but with reasonable error models (such as single qubit errors are much more likely than two qubit errors which are much more likely than three qubit errors, etc.) it can be shown that, if your noise and other error sources are below a certain threshold, you can enable arbitrarily large and long computations.