> For the complete documentation index, see [llms.txt](https://dailyjournal.gitbook.io/solutions/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://dailyjournal.gitbook.io/solutions/hackerrank-solutions/certify/javascript-basic.md).

# JavaScript (Basic)

## #1 JavaScript: Joined Logger

In this challenge, each message object has two properties:

* property *level* having an integer value
* property *text* having a string value

For example: \
`msg = { level: 2, text: "foo" }`

There is an implementation of a simple logger function provided that:

* takes a message object as an argument
* writes the text of the message to the defined output.

Implement a function *joinedLogger* that:

1. takes two arguments: integer *level* and string *separator*.
2. returns a new function, *f*, such that *f* takes a variable number of message objects.
   1. The function *f* uses the logger to write joined *text* values of messages that have a *level* value greater than or equal to the *level* parameter.
   2. The *text* values must be joined by the *separator* string parameter, in the order they are passed to the function. 

For example, let's say there are 3 defined messages:\
`msg1 = { level: 10, text: "foo" }`\
`msg2 = { level: 20, text: "bar" }`\
`msg3 = { level: 30, text: "baz" }`

Calling `joinedLogger(15,';')` must return a function *f*, such that calling `f(msg1, msg2, msg3)` causes the logger to write the string "bar,baz" to the defined output. The *level* passed to *joinedLogger* is 15, and the separator is ';'. Only msg2 and msg3 have a level greater than or equal to 15, so the text of those messages, "bar" and "baz", is joined with the ';' separator and written to the defined output by the logger.

```javascript
function joinedLogger(level, sep) {
    // write your code here
    return function f(...messages) {
        let str = "";
        messages.forEach(msg => {
            if (msg.level >= level) {
                str = str + msg.text + sep;
            }
        })
        let len = sep.length;
        let strArray = str.split("");
        strArray.splice(strArray.length - len, len);
        str = strArray.join("");
        console.log({ str, messages, level, sep });
        fs.createWriteStream(process.env.OUTPUT_PATH).write(str);
        return;
    }
}
```

## #2 JavaScript: Step Counter

In this challenge, you are provided with the implementation of a simple counter object:

```javascript
const counter = (function counter() {
    let value = 0;
    return {
        getValue: function () {
            return value;
        },
        changeBy: function (k) {
            value += k;
        },
    }
})(); 
```

Your task is to implement a function *stepCounter* that:

* takes a single parameter *k*
* returns a new object, representing a step counter with the initial value 0 and with three methods:
  * increment(): increments the current value by *k*
  * decrement(): decrements the current value by *k*
  * getValue(): returns the current value

Your implementation must encapsulate the provided counter object and use it for its implementation. The object returned by *stepCounter* most not have a *changeBy* property.

{% code overflow="wrap" %}

```javascript
function getFixedCounter(k) {
    // write your code here
    let myCounter = counter;
    return {
        increment: () => {
            myCounter.changeBy(k);
        },
        decrement: () => {
            myCounter.changeBy(-k);
        },
        getValue: () => {
            return myCounter.getValue();
        }
    }
}
```

{% endcode %}