Trying to replicate JSON.stringify

There are several issues with your code

1. in your object serialization (and seemingly also in your testcases) you forgot to handle booleans. Ie, you will output the property’s name, but not its value. Thus

   stringifier({"a": true})
   

   will produce an output of {"a": } which is obviously wrong

2. You are serializing undefined to null. That’s not standard behaviour. Not sure whether your project is defined that way, but

    JSON.stringify({"a": undefined}) 
   

   will produce {} whereas your code produces {"a": null}

3. In both of your code parts (ie for arrays and for objects) you are checking

    if (... || typeof input[key] === 'object')
       toJson += stringifier(input[key]);
   

   in the very beginning. The problem with that is, that typeof null === "object" ie, your recursive call will get an input of null which probably leads to erroneous results.

   I’d suggest to handle all primitives (number, string, boolean, undefined, null) first. And only if none of them applies, treat it as object or array …

4. For adding the comma, I’d suggest a different approach. Instead of checking if there is an additional element/property to handle and add the comma at the end of the current iteration’s body, move this code to the beginning of the iteration and check if the current iteration is the very first iteration.

    let first = true;
    for (let key in input) {
      if (!first) toJson += ',';
      first = false;
      toJSON += `"${key}":`;
      ...
    }
   

5. You may need special treat for some special objects like Date or Error, because handling them like standard objects may lead to undesired results. Ie for instance

    JSON.stringify(new Date());
   

   produces an ISO date string like "2023-07-06T13:08:29.460Z"

And just as a general remark: It would probably be better, to just handle the Array and object specific parts separately and handle the serialization of primitive values in a single point. Ie currently you have to duplicate the code for serializing number, string or boolean which reduces maintainability and is (as your case shows) error prone. I’d suggest something like the following.

function serialize(input, inarray) {
  switch (typeof input) {
    case "number":
    case "boolean": 
      return `${input}`;
    case "string":
      return `"${input}"`;
    case "undefined":
      //special behaviour of JSON.serialize 
      //it will serialize undefined array elements as "null"
      return inarray ? "null" : undefined;
    case "function":
      //functions don't show up in serialization output
      return undefined;

     //for the behaviour in your code, ie null, undefined and function
     //all being serialzed to null, you can just use the following
     //case "function":
     //case "undefined":
     //  return "null";
  }

  if (input === null)
    return "null";

  //now you can be sure, it's an object or array

  if (Array.isArray(input)) {
    let s = "["; let first = true;
    for (let e of input) {
      let ser = serialize(e, true);
      if (ser === undefined) 
        continue;
      if (!first) s+=", ";
      first = false;
      s += serialize(e);
    }
    return s + "]";
  } else {
    let s = "{"; let first = true;
    for (let k in input) {
      let ser = serialize(input[k]);
      if (ser === undefined)
        continue;

      if (!first) s+=","; 
      first = false;
      s += `"${k}": ${ser}`;
    }
    return s + "}";
  }
}

It’s quick and dirty. There may be some issues with special cases, but you get the idea. One issue with this code is, it doesn’t properly handle strings containing double quotes. Ie something like serialize({a:'a " string'}) leads to an erroneous JSON string …