Kan iemand een eenvoudige uitleg geven van methoden versus functies in OOP-context?

Antwoord 1, autoriteit 100%

Een functie is een stukje code dat bij de naam wordt aangeroepen. Het kan gegevens worden doorgegeven om op te werken (d.w.z. de parameters) en kan optioneel gegevens retourneren (de retourwaarde). Alle gegevens die aan een functie worden doorgegeven, worden expliciet doorgegeven.

Een methode is een stukje code dat wordt aangeroepen met een naam die bij een object hoort. In de meeste opzichten is het identiek aan een functie, behalve twee belangrijke verschillen:

1. Een methode wordt impliciet doorgegeven aan het object waarop deze werd aangeroepen.
2. Een methode kan werken met gegevens die zich in de klasse bevinden (onthoud dat een object een instantie van een klasse is – de klasse is de definitie, het object is een instantie van die gegevens).

(dit is een vereenvoudigde uitleg, waarbij problemen met scope enz. worden genegeerd)

Antwoord 2, autoriteit 51%

Er staat een methode op een object.
Een functie is onafhankelijk van een object.

Voor Java en C# zijn er alleen methoden.
Voor C zijn er alleen functies.

Voor C++ en Python hangt het ervan af of je al dan niet in een klas zit.

Antwoord 3, autoriteit 13%

‘methode’ is het objectgeoriënteerde woord voor ‘functie’. Dat is zo’n beetje alles (dat wil zeggen, geen echt verschil).

Helaas denk ik dat veel van de antwoorden hier het idee bestendigen of bevorderen dat er een complex, betekenisvol verschil is.

Echt, er is niet zoveel aan, alleen verschillende woorden voor hetzelfde.

[late toevoeging]

In feite, zoals Brian Neal opmerkte in een opmerking aan deze vraag, de C++ standaard gebruikt nooit de term ‘methode’ bij het verwijzen naar lidfuncties. Sommige mensen beschouwen dat misschien als een indicatie dat C++ niet echt een objectgeoriënteerde taal is; ik vat het echter liever op als een indicatie dat een behoorlijk slimme groep mensen niet dacht dat er een bijzonder sterke reden was om een ​​andere term te gebruiken.

Antwoord 4, autoriteit 6%

In het algemeen: methoden zijn functies die tot een klasse behoren, functies kunnen op elk ander bereik van de code staan, dus je zou kunnen zeggen dat alle methoden functies zijn, maar niet alle functies zijn methoden:

Neem het volgende python-voorbeeld:

class Door:
  def open(self):
    print 'hello stranger'
def knock_door:
  a_door = Door()
  Door.open(a_door)
knock_door()

Het gegeven voorbeeld toont u een klasse genaamd “Door” die een methode of actie heeft genaamd “open”, het wordt een methode genoemd omdat het in een klasse is gedeclareerd. Er is nog een deel van de code met “def” net eronder die een functie definieert, het is een functie omdat het niet binnen een klasse is gedeclareerd, deze functie roept de methode aan die we in onze klasse hebben gedefinieerd, zoals je kunt zien en uiteindelijk wordt de functie zelf gebeld.

Zoals je kunt zien, kun je een functie overal aanroepen, maar als je een methode wilt aanroepen, moet je ofwel een nieuw object doorgeven van hetzelfde type als de klasse waarin de methode is gedeclareerd (Class.method(object)) of je moet de methode binnen het object (object.Method()) aanroepen, tenminste in python.

Beschouw methoden als dingen die slechts één entiteit kan doen, dus als je een Dog-klasse hebt, zou het logisch zijn om alleen binnen die klasse een blaffunctie te hebben en dat zou een methode zijn, als je ook een Person-klasse hebt, zou het kunnen het is logisch om een ​​functie “feed” te schrijven, want die behoort niet tot een klasse, aangezien zowel mensen als honden kunnen worden gevoed en je zou dat een functie kunnen noemen omdat deze niet tot een bepaalde klasse behoort.

Antwoord 5, autoriteit 4%

Eenvoudige manier om te onthouden:

• Function > Free (Gratis betekent dat het overal kan zijn, niet in een object of klasse hoeft te zijn)
• Method > Member (een lid van een object of klasse)

Antwoord 6, autoriteit 2%

Een zeer algemene definitie van het belangrijkste verschil tussen een Functie en een Methode:

Functies worden gedefinieerd buiten klassen, terwijl methoden worden gedefinieerd binnen en onderdeel van klassen.

Antwoord 7, autoriteit 2%

Als je zin hebt om te lezen, is hier “Mijn introductie tot OO-methoden”

Het idee achter het objectgeoriënteerde paradigma is om de software te “bedreigingen” uit … nou ja “objecten”. Objecten in de echte wereld hebben eigenschappen, bijvoorbeeld als je een medewerker hebt, de medewerker heeft een naam, een medewerker-ID, een functie, hij behoort tot een afdeling enz. enz.

Het object weet ook hoe het met zijn attributen moet omgaan en kan er enkele bewerkingen op uitvoeren. Laten we zeggen dat als we willen weten wat een medewerker op dit moment doet, we het hem zouden vragen.

employe whatAreYouDoing.

Dat “whatAreYouDoing” is een “bericht” dat naar het object wordt gestuurd. Het object weet die vragen te beantwoorden, er wordt gezegd dat het een “methode” heeft om de vraag op te lossen.

Dus de manier waarop objecten hun gedrag moeten blootleggen, worden methoden genoemd. Methoden zijn dus het artefact-object dat iets moet “doen”.

Andere mogelijke methoden zijn

employee whatIsYourName
employee whatIsYourDepartmentsName

enz.

Functies daarentegen zijn manieren waarop een programmeertaal bepaalde gegevens moet berekenen, u kunt bijvoorbeeld de functie addValues( 8 , 8 ) hebben die 16 teruggeeft

// pseudo-code
function addValues( int x, int y )  return x + y 
// call it 
result = addValues( 8,8 )
print result // output is 16...

Aangezien de eerste populaire programmeertalen (zoals fortran, c, pascal) het OO-paradigma niet dekten, roepen ze deze artefacten alleen “functies” aan.

de vorige functie in C zou bijvoorbeeld zijn:

int addValues( int x, int y ) 
{
   return x + y;
}

Het is niet “natuurlijk” om te zeggen dat een object een “functie” heeft om een ​​actie uit te voeren, omdat functies meer verband houden met wiskundige zaken terwijl een werknemer weinig wiskunde heeft, maar u kunt methoden hebben die precies hetzelfde doen als functies, bijvoorbeeld in Java zou dit de equivalente functie addValues ​​zijn.

public static int addValues( int x, int y ) {
    return x + y;
}

Ziet u er bekend uit? Dat komt omdat Java zijn oorsprong heeft in C++ en C++ op C.

Uiteindelijk is het slechts een concept, in implementatie kunnen ze er hetzelfde uitzien, maar in de OO-documentatie worden ze methode genoemd.

Hier is een voorbeeld van het voorheen Employee-object in Java.

public class Employee {
    Department department;
    String name;
    public String whatsYourName(){
        return this.name;
    }
    public String whatsYourDeparmentsName(){
         return this.department.name();
    }
    public String whatAreYouDoing(){
        return "nothing";
    } 
    // Ignore the following, only set here for completness
    public Employee( String name ) {
        this.name = name;
    }
}
// Usage sample.
Employee employee = new Employee( "John" ); // Creates an employee called John
// If I want to display what is this employee doing I could use its methods.
// to know it.
String name = employee.whatIsYourName():
String doingWhat = employee.whatAreYouDoint();
// Print the info to the console.
 System.out.printf("Employee %s is doing: %s", name, doingWhat );
Output:
Employee John is doing nothing.

Het verschil zit dan in het “domein” waar het wordt toegepast.

AppleScript heeft het idee van “natuurlijke taal” matphor , dat op een gegeven moment OO had. Bijvoorbeeld Smalltalk. Ik hoop dat het redelijk gemakkelijker voor je is om methoden in objecten te begrijpen nadat je dit hebt gelezen.

OPMERKING: De code moet niet worden gecompileerd, alleen om als voorbeeld te dienen. Voel je vrij om het bericht aan te passen en een Python-voorbeeld toe te voegen.

Antwoord 8

In de OO-wereld worden de twee vaak gebruikt om hetzelfde te betekenen.

Vanuit een puur Math- en CS-perspectief zal een functie altijd hetzelfde resultaat retourneren als deze wordt aangeroepen met dezelfde argumenten ( f(x,y) = (x + y) ). Een methode daarentegen wordt meestal geassocieerd met een instantie van een klasse. Nogmaals, de meeste moderne OO-talen gebruiken de term “functie” grotendeels niet meer. Veel statische methoden kunnen veel op functies lijken, omdat ze meestal geen status hebben (niet altijd waar).

Antwoord 9

Stel dat een functie een codeblok is (meestal met zijn eigen bereik, en soms met zijn eigen sluiting) dat een aantal argumenten kan ontvangen en ook een resultaat kan retourneren.

Een methode is een functie die eigendom is van een object (in sommige objectgeoriënteerde systemen is het juister om te zeggen dat deze eigendom is van een klasse). “eigendom” zijn van een object/klasse betekent dat je naar de methode verwijst via het object/de klasse; als u bijvoorbeeld in Java een methode “open()” wilt aanroepen die eigendom is van een object “door”, moet u “door.open()” schrijven.

Meestal krijgen methoden ook enkele extra attributen die hun gedrag binnen het object/de klasse beschrijven, bijvoorbeeld: zichtbaarheid (gerelateerd aan het objectgeoriënteerde concept van inkapseling) die definieert van welke objecten (of klassen) de methode kan worden aangeroepen.

p>

In veel objectgeoriënteerde talen behoren alle “functies” tot een object (of klasse) en dus zijn er in deze talen geen functies die geen methoden zijn.

Antwoord 10

Methoden zijn functies van klassen. In normaal jargon wisselen mensen overal methode en functie uit. In principe kun je ze als hetzelfde beschouwen (niet zeker of globale functies methoden worden genoemd).

http://en.wikipedia.org/wiki/Method_(computer_science)

Antwoord 11

Een functie is een wiskundig concept. Bijvoorbeeld:

f(x,y) = sin(x) + cos(y)

zegt dat functie f() de sin van de eerste parameter zal retourneren die is toegevoegd aan de cosinus van de tweede parameter. Het is gewoon wiskunde. Toevallig zijn sin() en cos() ook functies. Een functie heeft een andere eigenschap: alle aanroepen van een functie met dezelfde parameters moeten hetzelfde resultaat opleveren.

Een methode daarentegen is een functie die gerelateerd is aan een object in een objectgeoriënteerde taal. Het heeft één impliciete parameter: het object waarop wordt gereageerd (en zijn status).

Dus als je een object Z hebt met een methode g(x), zie je mogelijk het volgende:

Z.g(x) = sin(x) + cos(Z.y)

In dit geval wordt de parameter x doorgegeven, hetzelfde als in het functievoorbeeld eerder. De parameter voor cos() is echter een waarde die zich binnen het object Z bevindt. Z en de gegevens die erin leven (Z.y) zijn impliciete parameters voor de methode g() van Z.

Antwoord 12

Historisch gezien kan er een subtiel verschil zijn geweest tussen een “methode” die geen waarde teruggeeft, en een “functie” die dat wel doet. Elke taal heeft zijn eigen lexicon van termen met speciale betekenis.

In “C” betekent het woord “functie” een programmaroutine.

In Java heeft de term “functie” geen speciale betekenis. Terwijl “methode” een van de routines betekent die de implementatie van een klasse vormen.

In C# zou dat vertalen als:

public void DoSomething() {} // method
public int DoSomethingAndReturnMeANumber(){} // function

Maar echt, ik herhaal dat er echt geen verschil is tussen de twee concepten.
Als je de term “functie” gebruikt in informele discussies over Java, zullen mensen aannemen dat je “methode” bedoelde en doorgaan. Gebruik het niet in de juiste documenten of presentaties over Java, anders zie je er dom uit.

Antwoord 13

Functie of een methode is een benoemd aanroepbaar stuk code dat enkele bewerkingen uitvoert en optioneel een waarde retourneert.

In C taal wordt de term functie gebruikt. Java & C# mensen zouden zeggen dat het een methode is (en in dit geval wordt een functie gedefinieerd binnen een klasse/object).

Een C++-programmeur zou het een functie of soms een methode kunnen noemen (afhankelijk van of ze C++-code in procedurele stijl schrijven of een objectgeoriënteerde manier van C++ doen, ook een C/C++-programmeur zou waarschijnlijk noem het een functie omdat de term ‘methode’ minder vaak wordt gebruikt in de C/C++-literatuur).

Je gebruikt een functie door de naam gewoon te noemen,

result = mySum(num1, num2);

Je zou een methode aanroepen door eerst naar het object te verwijzen, zoals,

result = MyCalc.mySum(num1,num2);

Antwoord 14

Functie is een reeks logica die kan worden gebruikt om gegevens te manipuleren.

Terwijl Methode een functie is die wordt gebruikt om de gegevens van het object te manipuleren waar het thuishoort.
Dus technisch gezien, als je een functie hebt die niet volledig gerelateerd is aan je klasse, maar die in de klasse is gedeclareerd, is het geen methode; Het wordt een slecht ontwerp genoemd.

Antwoord 15

In OO-talen zoals Object Pascal of C++ is een “methode” een functie die aan een object is gekoppeld. Dus, bijvoorbeeld, een “Hond”-object kan een “blaf”-functie hebben en dit zou als een “Methode” worden beschouwd. De functie “StrLen” daarentegen staat op zichzelf (deze geeft de lengte van een tekenreeks die als argument wordt opgegeven). Het is dus slechts een “functie”. Javascript is technisch ook objectgeoriënteerd, maar heeft veel beperkingen in vergelijking met een volwaardige taal zoals C++, C# of Pascal. Desalniettemin moet het onderscheid nog steeds gelden.

Een paar aanvullende feiten: C# is volledig objectgeoriënteerd, dus u kunt geen zelfstandige “functies” maken. In C# is elke functie gebonden aan een object en is dus technisch gezien een ‘methode’. De kicker is dat maar weinig mensen in C# ernaar verwijzen als “methoden” – ze gebruiken gewoon de term “functies” omdat er geen echt onderscheid te maken is.

Tot slot – zodat Pascal-goeroes me hier niet bespringen – maakt Pascal ook onderscheid tussen “functies” (die een waarde teruggeven) en “procedures” die dat niet doen. C# maakt dit onderscheid niet expliciet, hoewel je er natuurlijk voor kunt kiezen om een ​​waarde terug te geven of niet.

Antwoord 16

Methoden voor een klasse werken op de instantie van de klasse, het object genoemd.

class Example
{
   public int data = 0; // Each instance of Example holds its internal data. This is a "field", or "member variable".
   public void UpdateData() // .. and manipulates it (This is a method by the way)
   {
      data = data + 1;
   }
   public void PrintData() // This is also a method
   {
      Console.WriteLine(data);
   }
}
class Program
{
   public static void Main()
   {
       Example exampleObject1 = new Example();
       Example exampleObject2 = new Example();
       exampleObject1.UpdateData();
       exampleObject1.UpdateData();
       exampleObject2.UpdateData();
       exampleObject1.PrintData(); // Prints "2"
       exampleObject2.PrintData(); // Prints "1"
   }
}

Antwoord 17

Aangezien je Python noemde, kan het volgende een nuttige illustratie zijn van de relatie tussen methoden en objecten in de meeste moderne objectgeoriënteerde talen. In een notendop, wat zij een “methode” noemen, is slechts een functie die een extra argument krijgt doorgegeven (zoals andere antwoorden hebben aangegeven), maar Python maakt dat explicieter dan de meeste talen.

# perfectly normal function
def hello(greetee):
  print "Hello", greetee
# generalise a bit (still a function though)
def greet(greeting, greetee):
  print greeting, greetee
# hide the greeting behind a layer of abstraction (still a function!)
def greet_with_greeter(greeter, greetee):
  print greeter.greeting, greetee
# very simple class we can pass to greet_with_greeter
class Greeter(object):
  def __init__(self, greeting):
    self.greeting = greeting
  # while we're at it, here's a method that uses self.greeting...
  def greet(self, greetee):
    print self.greeting, greetee
# save an object of class Greeter for later
hello_greeter = Greeter("Hello")
# now all of the following print the same message
hello("World")
greet("Hello", "World")
greet_with_greeter(hello_greeter, "World")
hello_greeter.greet("World")

Vergelijk nu de functie greet_with_greeter en de methode greet: het enige verschil is de naam van de eerste parameter (in de functie noemde ik het “greeter”, in de methode noemde ik het “zelf”). Dus ik kan de greet-methode op precies dezelfde manier gebruiken als de functie greet_with_greeter (met behulp van de “dot”-syntaxis om er bij te komen, omdat ik het in een klas):

Greeter.greet(hello_greeter, "World")

Dus ik heb effectief van een methode een functie gemaakt. Kan ik van een functie een methode maken? Nou, aangezien Python je laat rommelen met klassen nadat ze zijn gedefinieerd, laten we het proberen:

Greeter.greet2 = greet_with_greeter
hello_greeter.greet2("World")

Ja, de functie greet_with_greeter staat nu ook bekend als de methode greet2. Dit toont het enige echte verschil tussen een methode en een functie: wanneer je een methode “op” een object aanroept door object.method(args) aan te roepen, verandert de taal deze op magische wijze in method(object, args).

(OO-puristen zouden kunnen beweren dat een methode iets anders is dan een functie, en als je begint met geavanceerde Python of Ruby – of Smalltalk! – zul je hun punt gaan inzien. Ook geven sommige talen methoden speciale toegang tot bits van een object. Maar het belangrijkste conceptuele verschil is nog steeds de verborgen extra parameter.)

Antwoord 18

voor mij:
de functie van een methode en een functie is hetzelfde als ik het ermee eens ben dat:

• een functie kan een waarde teruggeven
• kan parameters verwachten

Net als bij elk stukje code kun je objecten hebben die je invoert en je kunt een object hebben dat als resultaat ontstaat. Terwijl ze dat doen, kunnen ze de staat van een object veranderen, maar dat zou hun basisfunctioneren voor mij niet veranderen.

Er kan een verschil in definitie zijn bij het aanroepen van functies van objecten of andere codes. Maar is dat niet iets voor een verbale differentiatie en daarom wisselen mensen ze uit? Het genoemde voorbeeld van berekening zou ik voorzichtig mee zijn. omdat ik werknemers inhuur om mijn berekeningen te doen:

new Employer().calculateSum( 8, 8 );

Op die manier kan ik erop vertrouwen dat een werkgever verantwoordelijk is voor berekeningen. Als hij meer geld wil, laat ik hem vrij en laat de taak van de ophaler van het afval om ongebruikte werknemers weg te gooien de rest doen en krijg ik een nieuwe werknemer.

Zelfs het argument dat een methode een objectfunctie is en een functie een niet-verbonden berekening, zal me niet helpen. De functiedescriptor zelf en idealiter de documentatie van de functie zal me vertellen wat het nodig heeft en wat het kan retourneren. De rest, zoals het manipuleren van de staat van een object, is niet echt transparant voor mij. Ik verwacht dat beide functies en methoden leveren en manipuleren wat ze beweren zonder in detail te hoeven weten hoe ze het doen.
Zelfs een pure rekenfunctie kan de status van de console veranderen of toevoegen aan een logbestand.

Antwoord 19

Voor zover ik weet is een methode elke bewerking die op een klasse kan worden uitgevoerd. Het is een algemene term die gebruikt wordt bij het programmeren.

In veel talen worden methoden weergegeven door functies en subroutines. Het belangrijkste onderscheid dat de meeste talen hiervoor gebruiken, is dat functies een waarde terug kunnen sturen naar de aanroeper en een subroutine niet. Veel moderne talen hebben echter alleen functies, maar deze kunnen optioneel geen waarde retourneren.

Stel bijvoorbeeld dat je een kat wilt beschrijven en je wilt dat die kan geeuwen. Je zou een Cat-klasse maken, met een Yawn-methode, wat hoogstwaarschijnlijk een functie zou zijn zonder enige retourwaarde.

Antwoord 20

Bij benadering van de eerste orde is een methode (in C++-stijl OO) een ander woord voor een lidfunctie, dat wil zeggen een functie die deel uitmaakt van een klasse.

In talen als C/C++ kun je functies hebben die geen lid zijn van een klasse; je roept een functie die niet aan een klasse is gekoppeld geen methode aan.

Antwoord 21

Laten we niet te ingewikkeld maken wat een heel eenvoudig antwoord zou moeten zijn. Methoden en functies zijn hetzelfde. Je roept een functie een functie aan als deze buiten een klasse staat, en je roept een functie een methode aan als deze binnen een klasse is geschreven.

Antwoord 22

IMHO-mensen wilden gewoon een nieuw woord uitvinden voor eenvoudigere communicatie tussen programmeurs wanneer ze wilden verwijzen naar functies in objecten.

Als je methoden zegt, bedoel je functies binnen de klasse.
Als je functies zegt, bedoel je gewoon functies buiten de klas.

De waarheid is dat beide woorden worden gebruikt om functies te beschrijven. Zelfs als je het verkeerd gebruikt, gebeurt er niets verkeerd. Beide woorden beschrijven goed wat u met uw code wilt bereiken.

Functie is een code die een rol (een functie) moet spelen om iets te doen.
Methode is een methode om het probleem op te lossen.

Het doet hetzelfde. Het is hetzelfde ding. Als je super precies wilt zijn en mee wilt gaan met de conventie, kun je methoden aanroepen als de functies in objecten.

Antwoord 23

Functie is het concept dat voornamelijk behoort tot Proceduregeoriënteerd programmeren waarbij een functie een entiteit is die gegevens kan verwerken en u waarde teruggeeft

Methode is het concept van Object georiënteerd programmeren waarbij een methode lid is van een klasse die meestal de verwerking uitvoert op de klasseleden.

Antwoord 24

Ik ben geen expert, maar dit is wat ik weet:

1. Functie is een term in de C-taal, het verwijst naar een stukje code en de functienaam is de identifier om deze functie te gebruiken.

2. Methode is de OO-term, meestal heeft deze een deze-aanwijzer in de functieparameter. Je kunt dit stukje code niet aanroepen zoals C, je moet object gebruiken om het aan te roepen.

3. De aanroepmethoden zijn ook verschillend. Roep hier de betekenis op om het adres van dit stukje code te vinden. C/C++, de koppelingstijd gebruikt het functiesymbool om te lokaliseren.

4. Doelstelling-C is anders. Roep een C-functie aan om de gegevensstructuur te gebruiken om het adres te vinden. Het betekent dat alles tijdens runtime bekend is.

Antwoord 25

Ik weet dat vele anderen al hebben geantwoord, maar ik ontdekte dat het volgende een eenvoudig, maar effectief éénregelig antwoord is. Hoewel het er niet veel beter uitziet dan de antwoorden van anderen hier, maar als je het aandachtig leest, heeft het alles wat je moet weten over de methode versus functie.

Een methode is een functie met een gedefinieerde ontvanger, in OOP-termen is een methode een functie op een instantie van een object.

Antwoord 26

Functie – Een functie in een onafhankelijk stuk code dat enige logica bevat en onafhankelijk moet worden aangeroepen en buiten de klasse wordt gedefinieerd.

Methode – Een methode is een onafhankelijk stuk code dat wordt aangeroepen met verwijzing naar een object en dat binnen de klasse wordt gedefinieerd.

Antwoord 27

In C++ wordt soms de methode gebruikt om het begrip lidfunctie van een klasse weer te geven. Onlangs vond ik echter een verklaring in het boek The C++ Programming Language 4th Edition , op pagina 586 “Derived Classes”

Een virtuele functie wordt soms een methode genoemd.

Dit is een beetje verwarrend, maar hij zei soms, dus het is ongeveer logisch dat de maker van C++ de neiging heeft om methoden te zien als functies die op objecten kunnen worden aangeroepen en zich polymorf kunnen gedragen.

Antwoord 28

Hier is wat uitleg voor methode versus functie met behulp van JavaScript-voorbeelden:

test(20, 50); is een functie die wordt gedefinieerd en gebruikt om enkele stappen uit te voeren of iets terug te sturen dat ergens kan worden opgeslagen/gebruikt.

Je kunt code hergebruiken: definieer de code één keer en gebruik hem vele malen.

Je kunt dezelfde code vaak gebruiken met verschillende argumenten, om verschillende resultaten te produceren.

var x = myFunction(4, 3);   // Function is called, return value will end up in x
function myFunction(a, b) {
    return a * b;          // Function returns the product of a and b
}

var test = something.test(); hier test() kan een methode van een object zijn of een op maat gedefinieerd prototype voor ingebouwde objecten, hier is meer uitleg:

JavaScript-methoden zijn de acties die op objecten kunnen worden uitgevoerd.

Een JavaScript-methode is een eigenschap die een functiedefinitie bevat.

Ingebouwde eigenschap/methode voor strings in javascript:

var message = "Hello world!";
var x = message.toUpperCase();
//Output: HELLO WORLD!

Aangepast voorbeeld:

function person(firstName, lastName, age, eyeColor) {
    this.firstName = firstName;  
    this.lastName = lastName;
    this.age = age;
    this.eyeColor = eyeColor;
    this.changeName = function (name) {
        this.lastName = name;
    };
}
something.changeName("SomeName"); //This will change 'something' objject's name to 'SomeName'

U kunt bijvoorbeeld ook eigenschappen definiëren voor String, Array, enz.

String.prototype.distance = function (char) {
    var index = this.indexOf(char);
    if (index === -1) {
        console.log(char + " does not appear in " + this);
    } else {
        console.log(char + " is " + (this.length - index) + " characters from the end of the string!");
    }
};
var something = "ThisIsSomeString"
// now use distance like this, run and check console log
something.distance("m");