Use string concatenation.

String message = "this is value  want to pass to the ActualMessage attribute " ;
String input = "{\r\n" + 
               "\"Level\": 0,\r\n" + 
               "\"Name\": \"String\",\r\n" + 
               "\"msgName\": \"String\",\r\n" + 
               "\"ActualMessage\": \"" + message + "\",\r\n" + 
               "\"TimeStamp\": \"/Date(-62135596800000-0000)/\"\r\n" + 
               "}" ;

I always recommend using the serialize method to generate correct JSON:

String payload = JSON.serialize(
  new Map<String, Object> {
    'UserID' => username
  });

This will emit the correct JSON, even if your username were to contain special characters, etc.

This simply cannot be achived by using a json file. Instead you can use a function that returns this json object. So you can pass the color as argument to the function, and which can be included in the json object.

var getData = (color)=>{

    var data = {
        "id": 0,
        "name": "custom",
        "html": `<button id='changecolor' style='color: rgb(255, 255, 255); background-color: ${color}; border-color: rgb(158, 50, 168);'>Accept</button>`
    }

    return data
}

later you can call getData(color) at the place you use the json object.

You can also save this as a js file if needed

export const data = color => ({
            "id": 0,
            "name": "custom",
            "html": `<button id='changecolor' style='color: rgb(255, 255, 255); background-color: ${color}; border-color: rgb(158, 50, 168);'>Accept</button>`
        })

As far as I can understand your code, you are getting all image_file properties, even those with numbers. You can easily do it with this:

var images = [];

//iterate through the array
$.each(data, function (i, item) {

  //iterate through each property
  $.each(item, function (key, value) {

    //if the property starts with image_file, push into the array
    if (key.indexOf('image_file') === 0) images.push(value);
  });
});

console.log(images); // ["path\\Off.gif","path\\Off1.gif","path\\On1.gif","path\\Off2.gif","path\\On2.gif","path\\half.gif"]

You're looking for the range built-in.

.[] | [.field.empID = range(1;1000000)]

^{demo at jqplay.org}

What you have provided in the question is not a well formed json. Ignoring that, you can read a well formed json string into a JSONObject, and replace the values as you want :

private static String getData(String name, int age, String street, String line) throws JSONException {
    JSONObject jsonObject = new JSONObject("{  name : VARIABLE1,  age : VARIABLE2,  address : { street : VARIABLE3,    line : VARIABLE4  }}");
    JSONObject address = (JSONObject) jsonObject.get("address");
    jsonObject.put("name", name);
    jsonObject.put("age", age);
    address.put("street", street);
    address.put("line", line);
    return jsonObject.toString();
}

You can call this method as :

getData("Random", 20, "str", "lin");

I would suggest doing it a little differently

I will try to explain in pseudo code since i dont understand your variable names

1. read json file
2. array = JSON.parse(fileContents)
3. array.push(newItem)
4. newContents = JSON.stringify(array)
5. file WRITE (not append) newContents

This depends a lot on your security goals, and on what kind of user interface you want to offer to the author of these expressions.

Loading variables into the local scope does work, since Python is a very dynamic language. There's a risk though that the variables might re-define existing objects, thus breaking your code – what if there's a variable called len, for example?

Therefore, it's usually safer to avoid running the user input in a Python context. Instead:

• define a simple programming language for these expressions
• write an interpreter that executes the expressions

Python does have tools to help here. We can parse strings as Python code via the ast module. This returns a data structure that represents the syntax, and doesn't execute anything (though the parser isn't necessarily safe against malicious inputs). We can take the data structure, walk it, and execute it according to the rules we define – such as by resolving variables only from a dictionary. Example code for Python 3.10:

import ast

def interpret(code: str, variables: dict) -> dict:
  module: ast.Module = ast.parse(code, mode='exec')
  for statement in module.body:
    _interpret_statement(statement, variables)
  return variables

def _interpret_statement(statement: ast.stmt, variables: dict) -> None:
  match statement:
    case ast.Assign(targets=[ast.Name(id=name)], value=value):
      variables[name] = _interpret_expr(value, variables)
      return

    case other:
      raise InterpreterError("Syntax not supported", other)

def _interpret_expr(expr: ast.expr, variables: dict) -> Any:
  match expr:
    case ast.BinOp(left=left_ast, op=op, right=right_ast):
      left = _interpret_expr(left_ast, variables)
      right = _interpret_expr(right_ast, variables)
      return _interpret_binop(left, op, right)

    case ast.Name(id=name):
      return variables[name]

    case ast.Constant(value=(int(value) | float(value))):
      return value

    case other:
      raise InterpreterError("Syntax not supported", other)
    

def _interpret_binop(left: Any, op: ast.operator, right: Any) -> Any:
  match op:
    case ast.Add(): return left + right
    case ast.Sub(): return left - right
    case ast.Mult(): return left * right
    case ast.Div(): return left / right
    case ast.Pow(): return left**right
    case other:
      raise InterpreterError(
        "Operator not supported",
        ast.BinOp(ast.Name("_"), other, ast.Name("_")))

class InterpreterError(Exception):
  def __init__(self, msg: str, code: Optional[ast.AST] = None) -> None:
    super().__init__(msg, code)
    self._msg = msg
    self._code = code

  def __str__(self):
    if self._code:
      return f"{self._msg}: {ast.unparse(self._code)}"
    return self._msg

This can then be used to interpret commands, returning a dictionary with all the variables:

>>> interpret("z = x**2+y**2", {"x": 3, "y": 2})
{'x': 3, 'y': 2, 'z': 13}

While this allows you to interpret the Python code however you want (you control the semantics), you are still limited to Python's syntax. For example, you should use the ** operator for exponentiation, not Python's ^ xor-operator.

If you want your own syntax, then you'll probably have to write your own parser. There are a variety of parsing algorithms and parser generators, but I'm partial to hand-written “recursive descent”. This generally involves writing recursive functions of the form parse(Position) -> Optional[tuple[Position, Value]] that gradually consume the input. I have written an example parser and interpreter using that strategy, and have previously contrasted different parsing approaches in an answer about implementing query languages in a Python program.