Javascript stop execution abort or exit

Better one is

function Abort()
{
   throw new Error('This is not an error. This is just to abort javascript');
}

than from any where call this

try
{
    for(var i=0;i<10;i++)
    {
         if(i==5)Abort();
    }
} catch(e){}

For you

function callFunc()  
{      
    //stop execution here 
    Abort();

    } 

//code from where you are going to call

try
{
  if(a.value==1 && b.value==2)    
  {        
   callFunc()   
  }    
  frm.submit(); 
}
catch(e) {}

As you've discovered, aborting JavaScript almost always involves exceptions. If you truly can't change the wrapper, then you might have to resort to something a bit more extreme. One (evil) way to kill the script is to convince the browser that it's taking too long, by running an infinite loop:

function callFunc()
{
    //stop execution here
    var n = 1;
    while (n) {
        n += 1;
    }
}

Modern browsers will let the user kill the script after a while. Granted, it will make your site seem broken, but that should give you the leverage you need to get a better API in place.

If the busy-loop is too extreme, you could replace the simple addition with a plugin-based sleep, or perhaps a synchronous network request that takes an extremely long time, wrapped in its own try/catch safety net.

I understand what you are trying to do. You don't want to kill the Javascript interpreter, you just want to prevent the form submission from proceeding.

HTML

<form id="myForm">
  …
</form>

Javascript

// Setup…
var frm = document.getElementById('myForm'),
    a = { value: 1 },
    b = { value: 2 };

// Can change this code
var callFunc = function() {
    // Throwing will do nothing here, since
    // exceptions are being caught in a try/catch

    // Instead, let's overwrite the submit handler with one that
    // will cancel the form submission, then restore the old handler
    var oldSubmitHandler = frm.submit;
    var killHandler = function(e) {
        // Prevents the submission
        e.preventDefault();

        // Restores the old handler
        frm.submit = oldSubmitHandler;
    };
    frm.submit = killHandler;
};

// Can't change any of this code
if(a.value==1 && b.value==2)
{
    try { callFunc() } catch(e) { } 
}

// Want to stop this from happening
frm.submit();

See it in action: http://jsfiddle.net/3A7xC/

Better way is this:

if(a.value==1 && b.value==2)
{
  try{
    callFunc();  
    frm.submit();
  }
   catch(e) {
    // stop execution
  } 
}

If an exception is thrown in function callFunc, the frm.submit(); line would not be executed. Instead, it will skip to the catch clause

Lots of answers, one more for fun.

You can put the code in a function, have the try block throw an error, then return from the catch clause:

function foo() {
    var a = {value:1};
    var b = {value:2};

    if(a.value==1 && b.value==2) {

       try {
          callFunc();

       } catch(e) {
          alert(e.message);
          return;
       }
    }
    alert('error didn\'t stop me!');
}



function callFunc() {
      throw new Error('This is an error.');  
}

Otherwise you can set a flag in the catch block and test for it immediately afterward before going any further. Or take one of the other answer's options.

So the inside of the callFunc is the only thing you can change? How about this:

callFunc(){
    frm.submit(function() {
      alert('this should not submit');
      return false;
  });   
}

To kill the execution of a JS script use:

system.stop()

You can abort javascript execution using throw:

if(a.value==1 && b.value==2){
    try{callFunc()  }catch(e) {} 
}
frm.submit();

function callFunc() {
    throw "stop execution";
}