It would indeed seem the function uses different logic depending of the parameter order. I think there are two things at play.

First, see this example:

echo similar_text('test','wert'); // 1

echo similar_text('wert','test'); // 2

It seems to be that it is testing how many times any distinct char on param1 is found in param2, and thus result would be different if you swap the params around. It has been reported as a bug, which has been closed as working as expected.

Now, the above is the same for both PHP and javascript implementations - paremeter order has an impact, so saying that JS code wouldn't do this is wrong. This is argued in the bug entry as intended behaviour.

Second - what doesn't seem correct is the MYSQL/PHP word example. With that, javascript version gives 3 irrelevant of the order of params, whereas PHP gives 2 and 3 (and due to that, percentage is equally different). Now, the phrases PHP IS GREAT and WITH MYSQL should have 5 characters in common, irrelevant of which way you compare: H, I, S and T, one each, plus one for empty space. In order they have 3 characters, 'H', ' ' and 'S', so if you look at the ordering, correct answer should be 3 both ways. I modified the C code to a runnable version, and added some output, so one can see what is happening there (codepad link):

#include<stdio.h>



/* {{{ php_similar_str

 */

static void php_similar_str(const char *txt1, int len1, const char *txt2, int len2, int *pos1, int *pos2, int *max)

{

  char *p, *q;

  char *end1 = (char *) txt1 + len1;

  char *end2 = (char *) txt2 + len2;

  int l;



  *max = 0;

  for (p = (char *) txt1; p < end1; p++) {

    for (q = (char *) txt2; q < end2; q++) {

      for (l = 0; (p + l < end1) && (q + l < end2) && (p[l] == q[l]); l++);

      if (l > *max) {

        *max = l;

        *pos1 = p - txt1;

        *pos2 = q - txt2;

      }

    }

  }

}

/* }}} */





/* {{{ php_similar_char

 */

static int php_similar_char(const char *txt1, int len1, const char *txt2, int len2)

{

  int sum;

  int pos1, pos2, max;



  php_similar_str(txt1, len1, txt2, len2, &pos1, &pos2, &max);



  if ((sum = max)) {

    if (pos1 && pos2) {

      printf(txt here %s,%sn, txt1, txt2);

      sum += php_similar_char(txt1, pos1,

                  txt2, pos2);

    }

    if ((pos1 + max < len1) && (pos2 + max < len2)) {

      printf(txt here %s,%sn, txt1+ pos1 + max, txt2+ pos2 + max);

      sum += php_similar_char(txt1 + pos1 + max, len1 - pos1 - max,

                  txt2 + pos2 + max, len2 - pos2 - max);

    }

  }



  return sum;

}

/* }}} */

int main(void)

{

    printf(Found %d similar charsn,

        php_similar_char(PHP IS GREAT, 12, WITH MYSQL, 10));

    printf(Found %d similar charsn,

        php_similar_char(WITH MYSQL, 10,PHP IS GREAT, 12));

    return 0;

}

the result is output:

txt here PHP IS GREAT,WITH MYSQL

txt here P IS GREAT, MYSQL

txt here IS GREAT,MYSQL

txt here IS GREAT,MYSQL

txt here  GREAT,QL

Found 3 similar chars

txt here WITH MYSQL,PHP IS GREAT

txt here TH MYSQL,S GREAT

Found 2 similar chars

So one can see that on the first comparison, the function found 'H', ' ' and 'S', but not 'T', and got the result of 3. The second comparison found 'I' and 'T' but not 'H', ' ' or 'S', and thus got the result of 2.

The reason for these results can be seen from the output: algorithm takes the first letter in the first string that second string contains, counts that, and throws away the chars before that from the second string. That is why it misses the characters in-between, and that's the thing causing the difference when you change the character order.

What happens there might be intentional or it might not. However, that's not how javascript version works. If you print out the same things in the javascript version, you get this:

txt here: PHP, WIT

txt here: P IS GREAT,  MYSQL

txt here: IS GREAT, MYSQL

txt here: IS, MY

txt here:  GREAT, QL

Found 3 similar chars

txt here: WITH, PHP 

txt here: W, P

txt here: TH MYSQL, S GREAT

Found 3 similar chars

showing that javascript version does it in a different way. What the javascript version does is that it finds 'H', ' ' and 'S' being in the same order in the first comparison, and the same 'H', ' ' and 'S' also on the second one - so in this case the order of params doesn't matter.

As the javascript is meant to duplicate the code of PHP function, it needs to behave identically, so I submitted bug report based on analysis of @Khez and the fix, which has been merged now.