# 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 %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://dailyjournal.gitbook.io/solutions/hackerrank-solutions/certify/javascript-basic.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.