05AB1E, 5 bytes

Åps.x

Try it online!
or as a Test Suite

Inefficient for big numbers

JavaScript (ES6), 53 bytes

n=>(g=(o,d=N=n+o)=>N%--d?g(o,d):d-1?g(o<0?-o:~o):N)``

Try it online!

Commented

n => ( // n = input
 g = ( // g = recursive function taking:
 o, // o = offset
 d = // d = current divisor, initialized to N
 N = n + o // N = input + offset
 ) => //
 N % --d ? // decrement d; if d is not a divisor of N:
 g(o, d) // do recursive calls until it is
 : // else:
 d - 1 ? // if d is not equal to 1 (either N is composite or N = 1):
 g( // do a recursive call with the next offset:
 o < 0 ? // if o is negative:
 -o // make it positive (e.g. -1 -> +1)
 : // else:
 ~o // use -(o + 1) (e.g. +1 -> -2)
 ) // end of recursive call
 : // else (N is prime):
 N // stop recursion and return N
)`` // initial call to g with o = [''] (zero-ish)

Octave, 40 bytes

@(n)p([~,k]=min(abs(n-(p=primes(2*n)))))

Try it online!

This uses the fact that there is always a prime between n and 2*n (Bertrand–Chebyshev theorem).

How it works

@(n)p([~,k]=min(abs(n-(p=primes(2*n)))))

@(n) % Define anonymous function with input n
 p=primes(2*n) % Vector of primes up to 2*n. Assign to p
 abs(n-( )) % Absolute difference between n and each prime
 [~,k]=min( ) % Index of first minimum (assign to k; not used)
 p( ) % Apply that index to p

Pyth, 10 bytes

haDQfP_TSy

Try it online here, or verify all the test cases at once here.

haDQfP_TSyQ Implicit: Q=eval(input())
 Trailing Q inferred
 yQ 2 * Q
 S Range from 1 to the above
 f Filter keep the elements of the above, as T, where:
 P_T Is T prime?
 D Order the above by...
 a Q ... absolute difference between each element and Q
 This is a stable sort, so smaller primes will be sorted before larger ones if difference is the same
h Take the first element of the above, implicit print

Japt, 5 bytes

_j}cU

Try it or run all test cases

_j}cU :Implicit input of integer U
_ :Function taking an integer as an argument
 j : Test if integer is prime
 } :End function
 cU :Return the first integer in [U,U-1,U+1,U-2,...] that returns true

Gaia, 3 bytes

ṅD⌡

Try it online!

Rather slow for large inputs, but works given enough memory/time.

I'm not sure why D⌡ implicitly pushes z again, but it makes this a remarkably short answer!

ṅ	| implicit input z: push first z prime numbers, call it P
 D⌡	| take the absolute difference between P and (implicit) z,
	| returning the smallest value in P with the minimum absolute difference

Wolfram Language (Mathematica), 53 bytes

If[PrimeQ[s=#],s,#&@@Nearest[s~NextPrime~-1, 1,s]]&

Try it online!

Python 2, 96 bytes

l=lambda p:min(filter(lambda p:all(p%n for n in range(2,p)),range(2,p*2)),key=lambda x:abs(x-p))

Try it online!

VDM-SL, 161 bytes

f(i)==(lambda p:set of nat1&let z in set p be st forall m in set p&abs(m-i)>=abs(z-i)in z)(x in set1,...,9**7&forall y in set2,...,1003&y<>x=>x mod y<>0)

A full program to run might look like this - it's worth noting that the bounds of the set of primes used should probably be changed if you actually want to run this, since it will take a long time to run for 1 million:

functions
f:nat1+>nat1
f(i)==(lambda p:set of nat1&let z in set p be st forall m in set p&abs(m-i)>=abs(z-i)in z)(x in set1,...,9**7&forall y in set2,...,1003&y<>x=>x mod y<>0)

Explanation:

f(i)== /* f is a function which takes a nat1 (natural number not including 0)*/
(lambda p:set of nat1 /* define a lambda which takes a set of nat1*/
&let z in set p be st /* which has an element z in the set such that */
forall m in set p /* for every element in the set*/
&abs(m-i) /* the difference between the element m and the input*/
>=abs(z-i) /* is greater than or equal to the difference between the element z and the input */
in z) /* and return z from the lambda */
( /* apply this lambda to... */
 /* all elements x such that.. */ 
x in set1,...,9**7 /* x is between 1 and 9^7 */
&forall y in set2,...,1003 /* and for all values between 2 and 1003*/
&y<>x=>x mod y<>0 /* y is not x implies x is not divisible by y*/
 
)

APL(NARS), 38 chars, 76 bytes

⍵≤1:2⋄0π⍵:⍵⋄d←1π⍵⋄(d-⍵)≥⍵-s←¯1π⍵:s⋄d

0π is the test for prime, ¯1π the prev prime, 1π is the next prime; test:

 f←⍵≤1:2⋄0π⍵:⍵⋄d←1π⍵⋄(d-⍵)≥⍵-s←¯1π⍵:s⋄d
 f¨80 100 5 9 532 1
79 101 5 7 523 2 

Jelly, 9 7 bytes

ḤÆRạÞµḢ

Try it online!

Slow for larger input, but works ok for the requested range. Thanks to @EriktheOutgolfer for saving 2 bytes!

Tidy, 43 bytes

x:(prime↦splice(]x,-1,-∞],[x,∞]))@0

Try it online!

Explanation

This is a lambda with parameter x. This works by creating the following sequence:

[x - 1, x, x - 2, x + 1, x - 3, x + 2, x - 4, x + 3, ...]

This is splicing together the two sequences ]x, -1, -∞] (left-closed, right-open) and [x, ∞] (both open).

For x = 80, this looks like:

[79, 80, 78, 81, 77, 82, 76, 83, 75, 84, 74, 85, ...]

Then, we use f↦s to select all elements from s satisfying f. In this case, we filter out all composite numbers, leaving only the prime ones. For the same x, this becomes:

[79, 83, 73, 71, 89, 67, 97, 61, 59, 101, 103, 53, ...]

Then, we use (...)@0 to select the first member of this sequence. Since the lower of the two needs to be selected, the sequence which starts with x - 1 is spliced in first.

Note: Only one of x and x - 1 can be prime, so it is okay that the spliced sequence starts with x - 1. Though the sequence could be open on both sides ([x,-1,-∞]), this would needlessly include x twice in the sequence. So, for sake of "efficiency", I chose the left-closed version (also because I like to show off Tidy).

Python 2, 71 bytes

f=lambda n,k=1,p=1:k<n*3and min(k+n-p%k*2*n,f(n,k+1,p*k*k)-n,key=abs)+n

Try it online!

A recursive function that uses the Wilson's Theorem prime generator. The product p tracks $(k-1)!^2$, and p%k is 1 for primes and 0 for non-primes. To make it easy to compare abs(k-n) for different primes k, we store k-n and compare via abs, adding back n to get the result k.

The expression k+n-p%k*2*n is designed to give k-n on primes (where p%k=1), and otherwise a "bad" value of k+n that's always bigger in absolute value and so doesn't affect the minimum, so that non-primes are passed over.

C# (Visual C# Interactive Compiler), 112 bytes

g=>Enumerable.Range(2,2<<20).Where(x=>Enumerable.Range(1,x).Count(y=>x%y<1)<3).OrderBy(x=>Math.Abs(x-g)).First()

Try it online!

Left shifts by 20 in submission but 10 in TIO so that TIO terminates for test cases.

APL (Dyalog Extended), 20 bytes^SBCS

⊢(⊃>/⍤|⍤-⌽⊢)¯4 4⍭3⌈⊢

Try it online!

⊢ the argument

3⌈ max of 3 and that

¯4 4⍭ the previous and next primes`

⊢(…) apply the following infix tacit function to that, with the original argument as left argument:

 ⊢ the primes

 …⌽ cyclically rotate them the following number of steps:

  - the original argument minus the primes

  ⍤ then

  | absolute value of that

  ⍤ then

  >/ Boolean (0/1) whether the left is greater than the right (i.e. 1 if next is closer)

 ⊃ pick the first one (i.e. previous if previous is closer and next if next is closer)

Swift, 186 bytes

func p(a:Int)let b=q(a:a,b:-1),c=q(a:a,b:1);print(a-b<=c-a ? b:c)
func q(a:Int,b:Int)->Intvar k=max(a,2),c=2;while k>c && c != a/2if k%c==0k+=b;c=2elsec=c==2 ? c+1:c+2;return k

Try it online!

Jelly, 14 bytes

ÆpæRÆnạÞƲ2>?2Ḣ

Try it online!

C# (Visual C# Interactive Compiler), 96 bytes

n=>for(int i=0,j;;)if((j=n+i/2*(i++%2*2-1))>1&&Enumerable.Range(2,j-2).All(d=>j%d>0))return j;

Try it online!

Zsh, 101 92 91 bytes

-9 by collapsing the body into the head of p's loop, -1 from using i=j instead of i=$1 in main loop.

p()for ((n=2;n<$1&&$1%n++;)):
(($1==n))&&<<<$1
j=$1
for ((i=j;;++j&&--i))p $i||p $j&&exit

Try it online!

Try it online!

57 48 bytes to the prime testing function, 43 42 bytes to the main loop (1 byte to the newline between them):

p() # prime function: takes one input, outputs via return code
for (( n = 2; n < $1 && $1 % n++; )) # divisibility check in loop header
 : # no-op loop body
(( $1 == n )) && # if we looped up to $1:
 <<< $1 # echo out $1. Otherwise, this will return false

For the last condition, we can't use the shorter (($1-n))||, because we need to return false to the main loop if we didn't find a prime. We print in the function to avoid complexity in the main loop.

j=$1 # set i = j = $1. Doing one in and one out is smallest
for (( i = j; ; ++j && --i )) # loop indefinitely, increment and decrement
 p $i || p $j && exit # if either $i or $j was a prime, exit

Conditionals are left-associative, which we take advantage of here. We do test the starting number twice to make the decrement logic simpler.

C, 122 bytes

#define r return
p(a,i)if(a<2)r 0;i=1;while(++i<a)if(a%i<1)r 0;r 1;c(a,b)b=a;while(1)if(p(b))r b;if(p(--a))r a;b++;

Use it calling function c() and passing as argument the number, it should return the closest prime.

Python 2, 93 bytes

lambda n:sorted(range(1,3*n),key=lambda x:abs(x-n)if all(x%k for k in range(2,x))else 2*n)[0]

J, 19 15 bytes

(0improve this answer