You can use a capture group and match the digits with the hyphen, where the capture group 1 value is denoted by m[1] in the example code:

\(FT\s+(\d+-\d+)\)

Explanation

• \( Match (
• FT\s+ Match FT and 1+ whitespace chars
• (\d+-\d+) Capture group 1, match 1+ digits - 1+ digits
• \) Match )

const text = 'So its (just 1-2) amazing (FT 0-0) its ours final score';
const m = text.match(/\(FT\s+(\d+-\d+)\)/);
if (m) {
  console.log(m[1]);
}

If there can be more occurrences using the /g flag:

const text = 'So its (just 1-2) amazing (FT 0-0) its ours final score, and not (FT 1-1)';
console.log(Array.from(text.matchAll(/\(FT\s+(\d+-\d+)\)/g), m => m[1]));

I'm sure it's not the absolute best, and I can imagine places where it's impractical, but a generalized solution I like for many use cases is below:

var str = 'BeginingoflongstringFToranystringScoreorwhateverwewant)oranystringEndoflongstring';
var first_filter = 'FToranystring';
var second_filter = ')oranystring';
var desired_string = str.slice(
  str.indexOf(first_filter) + first_filter.length,
  str.indexOf(second_filter),
);
console.log(desired_string);

And with your specific data we make one change, using lastIndexOf, rather than indexOf since it's a non-unique phrase in your string. To use it generally, it's best to only search for a string between two unique strings:

var str = 'So its (just 1-2) amazing (FT 0-0) its ours final score';
var first_filter = 'FT';
var second_filter = ')';
var desired_string = str.slice(
  str.indexOf(first_filter) + first_filter.length,
  str.lastIndexOf(second_filter),
);
console.log(desired_string);

Or, rather than just using the closing ")" in this case, you can use ") i":

var str = 'So its (just 1-2) amazing (FT 0-0) its ours final score';
var first_filter = 'FT';
var second_filter = ') i';
var desired_string = str.slice(
  str.indexOf(first_filter) + first_filter.length,
  str.indexOf(second_filter),
);
console.log(desired_string);

In any case it requires knowing your input string perfectly, so is rarely ideal.

A regular expression would make this very easy:

let text = 'So its (just 1-2) amazing (FT 0-0) its ours final score';
let match = text.match(/\(FT\s+([^)]+)\)/);
let result = match[1];

You want to match the left side:

\(FT\s+

Which means match (FT and 1 or more whitespace characters.

Then you want to match the actual data that you want:

([^)]+)

This matches and captures any character that is not ) (the end of our match) and that appears more than once.

Then you match the right side.

\)

Which is quite literally the ) character.

Alternate Method:

You can also use split method with substr / substring, aside from using regex:

Script

function test() { //E.g. you have mustiple instances of "FT"
  var text = 'So its amazing (FT3-0 ) (just 1-2)  amazing (FT  0-0) its ours final score (FT 1-1  )';
  var match = text.split("FT");
  for(var i in match){
    if(i != 0){ //skip index 0 as it doesn't contain the score after every "FT" instance.
      Logger.log(match[i].trim().substr(0, 3)); //used trim to remove all white spaces before the substr method
    }
  }
}

Result

Matching with regex

function lfunko() {
  let s = "So its (just 1-2) amazing (FT 0-0) its ours final score";
  let m = s.match(/(?<=just )([^\)]+)|(?<=FT )([^\)]+)/g);
  Logger.log('First: %s Second: %s', m[0],m[1]);
}

Execution log
3:26:04 PM  Notice  Execution started
3:26:05 PM  Info    First: 1-2 Second: 0-0
3:26:05 PM  Notice  Execution completed

Utilizing two positive look behinds ored together.

If you wish to see some real expertise at such a match just add a regex tag and you will see some real masters of regular expressions.

Added Regex tag for you. Wait for @Wiktor Stribiżew to answer before making your final selection.

And one more for good measure...

const text = 'So its (just 1-2) amazing (FT 7-10) its ours final score';
const regexScore = /FT\s+\d+-\d+/ig;
const regexDigits = /\d+/g
const found = text.match(regexScore);
const score = found[0].match(regexDigits);

console.log(found);
console.log(score);