The inner function is a function that exists within the scope of its parent function, rather than being a part of the entire object.

Typically, this is how it's done:

function Object1() {
}

Object1.prototype = {
    function1: function () { 
         alert("hello");
    }
};

var obj = new Object1();
obj.function1();

It's worth noting that this method utilizes the prototype of the constructor function Object1, allowing for object inheritance:

var Object2 = Object.create({ function2: function() { } }, Object1.prototype);

To learn more about object-oriented prototype-based programming, visit Mozilla Developer Network (MDN):

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript

this could catch your interest

var CustomObject = function(title) {
  this.title = title;
};

CustomObject.prototype.displayTitle = function(prefix) {
  console.log(prefix + " " + this.title);
};


var customObj = new CustomObject("sophie");
customObj.displayTitle("hey there");
//=> "hey there sophie"

A little extra showcasing private data members

CustomObject.prototype.additionalFunction = function() {

  // private variable
  var counter = 0;

  // private function
  var incrementCounter = function() {
    counter += 1;
  };

  return incrementCounter();
};

customObj.additionalFunction(); //=> 1
customObj.additionalFunction(); //=> 2
customObj.additionalFunction(); //=> 3

For amusement, here's a subclass as well!

var SubObject = function(title, numberOfDogs) {

  // call parent constructor
  CustomObject.call(this, title);

  this.numberOfDogs = numberOfDogs;
};

// setting up prototype chain
SubObject.prototype = Object.create(CustomObject.prototype, {constructor: {value: SubObject}});

// public instance method for SubObject
SubObject.prototype.greetPerson = function() {
  console.log(this.title + " has " + this.numberOfDogs + " dogs");
};

Usage is straightforward

var subObj = new SubObject("sophie", 5);
subObj.greetPerson()
//=> "sophie has 5 dogs"

The method from CustomObject is inherited too

subObj.displayTitle("hello i'm called");
//=> "hello i'm called sophie"

And the private one as well

subObj.additionalFunction(); //=> 1
subObj.additionalFunction(); //=> 2

This specific function is considered 'private' in nature.

In order to make it accessible publicly, the following adjustments would need to be made:

function Object1() 
{
    this.Function1 = function() 
    {
        alert("hello");
    }
}

var thingy = new Object1();
thingy.Function1();

Similarly, to keep variables private, the method used would be:

function Object1()
{
    var myPrivateVariable = 'something';
}

Conversely, public variables could be implemented like so:

function Object1()
{
    this.myPublicVariable = 'something';
}

Avoid inadvertently declaring variables as global by ensuring they are declared directly:

function Object1()
{
    globalVariable = 'oops';
}

JavaScript's approach to OOP differs from many other languages, particularly with prototyping and closures involved.

THIS link covers the basics adequately, but I also recommend "JavaScript: The Good Parts" for further reading.

If you're looking for the optimal approach to achieve your goals, I recommend the following code:

var Item = (function () {
    function Item(parameterOne) {
        this.parameterOne = parameterOne;
   }
    Item.prototype.doSomething = function () {
        console.log(this.parameterOne);
    };
    return Item;
})();

var example = new Item("Pizza");
example.doSomething();

For those interested in utilizing objects and classes within JavaScript, may I suggest considering TypeScript? This language compiles into standard javascript and seamlessly integrates with existing code.

While some may view this as a significant change, it's simply an enhancement of JavaScript with added class capabilities. Since TypeScript is a superset of Javascript, it offers increased efficiency. Additionally, TypeScript will align perfectly with ECMAScript 6 upon its release, allowing for an effortless transition from typescript to javascript. To explore TypeScript firsthand, visit the official website.

Demonstration:

Below is an illustration from a node.js console session.

> var Item = (function () {
...     function Item(parameterOne) {
.....         this.parameterOne = parameterOne;
.....     }
...     Item.prototype.doSomething = function () {
.....         console.log(this.parameterOne);
.....     };
...     return Item;
... })();
undefined
> var example = new Item("Chocolate Cake");
undefined
> example.doSomething();
Chocolate Cake
undefined
>

The above JavaScript code was produced using Typescript, showcasing the improved syntax. Here is how the original Typescript code appears:

class Item {
    constructor(public parameterOne: string) {}

    doSomething (): void {
        console.log(this.parameterOne);
    }
}

var example = new Item("Pizza");
example.doSomething();

Evidently, the cleaner syntax contributes to enhanced readability. For further information on TypeScript, please refer to the official website.

Here is the solution you are seeking.

let car = {
    startEngine: function() {
        console.log("vroom vroom");
    }
}

car.startEngine();

To achieve your goal of creating an object with a function inside it, follow these steps:

let myFunction = function() {   
    console.log("Greetings!");
}

let myObject  = {"function": myFunction};

You can now call the function using: myObject.function();