Keep it simple. Only allow underscore and alphanumeric regex:

/^[a-zA-Z0-9_]+$/

Javascript es6 implementation (works for React):

const re = /^[a-zA-Z0-9_]+$/;
re.test(variable_to_test);

$(function() {     
var haveFirst = false;
$('.alphaonly').on('keypress', function (event) {
  if( $(this).val().length === 0 ) {
     haveFirst = false;
  }
var regex = new RegExp("^[a-z0-9_]+$");
var first = new RegExp("^[a-z]+$");
var key = String.fromCharCode(!event.charCode ? event.which : event.charCode);
if(!first.test(key) && haveFirst == false){
   event.preventDefault();
   return false;
}else if(regex.test(key)){
   haveFirst = true;
}
if (!regex.test(key)) {
   event.preventDefault();
   return false;
}
}); 
}) 

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> 
<input name="lorem" class="alphaonly">

/^[^_]+$/ would match a string of 1 or more character containing any character except underscore.

the following character class (in Perl)

[^\W_]

\W is the same as [^\w]

This portion of the regex seems to be looking for special characters:

(?=.*[!@#$%^&*-])

Note that the character class does not include an underscore, try changing this to the following:

(?=.*[_!@#$%^&*-])

You will also need to modify or remove this portion of the regex:

(?=.*\W+)

\W is equivalent to [^a-zA-Z0-9_], so if an underscore is your only special character this portion of the regex will cause it to fail. Instead, change it to the following (or remove it, it is redundant since you already check for special characters earlier):

(?=.*[^\w_])

Complete regex:

/(?=^.{8,}$)(?=.*[_!@#$%^&*-])(?=.*\d)(?=.*[^\w_])(?![.\n])(?=.*[a-z])(?=.*[A-Z]).*$/

This should make it:

"^[A-Za-z_-][A-Za-z0-9_-]*$"

[A-Za-z_-] means a letter or underscore or hyphen
[A-Za-z0-9_-]* is the same, but allows numbers too

So this will allow letters, underscores, hyphens, and numbers, but no numbers at the start.

Looking at your valid input example Account-Numbers_2010 | NewMoney | test_data | a1B2-c3_d4_5e-6f, you may want to also allow spaces and |. This one allows them:

"^[A-Za-z_ |-][A-Za-z0-9_ |-]*$"

This one correctly matches Account-Numbers_2010 | NewMoney | test_data | a1B2-c3_d4_5e-6f and not 2010_Account_Numbers | New$Money | %test*data | 1aB2.

Here's a simple replacement for your function based on regular expressions:

function blockSpecialChar(e) {
    return /[^A-Za-z0-9._]/.test(e);
}

See it working: https://jsfiddle.net/utt3sf6p/

If you want to use keycodes instead of a regular expression, you have to use the correct keycode function getCharAt() and change your boolean expression a bit:

function blockSpecialChar(e) {
    var k = e.charCodeAt(0);
    return ((k > 64 && k < 91) || (k > 96 && k < 123) || (k >= 48 && k <= 57) || (k == 46) || (k == 95));
}

See it working: https://jsfiddle.net/wfn37pu6/

Note: The examples assume that e contains a single character. If e is a keyboard event (like onkeypress) instead, you have to replace .test(e) with .test(e.key) and e.charCodeAt(0) with e.key.charCodeAt(0).

You can put your special characters in a Regex pattern, then remove all special characters from your text by using the Replace method.

var regex = new Regex("[!@#$%\^&*\(\)-+=\/\\\{\}\[\]\|:;\"'<>,.\?\~`;]");

var result = regex.Replace("Some!D#Text_With%Special$Character", string.Empty);

The result would be "SomeText_WithSpecialCharacter".

It looks like you're using (?=.*\W+) to match special characters. But _ is a word character that's in \w, and \W is everything else, so this doesn't match _. Change it to: (?=.*[\W_]+)

Also, you don't need + in this. You only need to match 1 to be successful.

Put _ and . to the negated set of characters ([^...]):

$string = preg_replace('/[^a-zA-Z0-9_.]/', '', $string);

You should not omit $string = .. because preg_replace return replaced string. It does not change the string in place.

You may add an alternative in your JS regex:

var pattern = /(?:[^\w\/\\-]|_)/g;
               ^^^          ^^^

See the regex demo. This pattern can be used to remove the unwanted chars in JS.

In a .NET regex, you may use a character class substraction, and the pattern can be written as

var pattern = @"[^-\w\/\\-[_]]";

See the .NET regex demo

To match whole strings that only allow -, / and \ + letters/digits, use

var pattern = /^(?:(?!_)[\w\/\\-])*$/;
var pattern = @"^[-\w/\\-[_]]*$";

See this JS regex demo and the .NET regex demo.

Here, ^(?:(?!_)[\w\/\\-])*$ / ^[-\w/\\-[_]]*$ match a whole string (the ^ and $ anchors require the full string match) that only contains word, /, \ and - chars.

NOTE: In C#, \w by default matches much more than \w in JS regex. You need to use RegexOptions.ECMAScript option to make \w behave the same way as in JS.