MiniScript Wiki - User contributions [en]

Object-oriented programming

2025-06-08T21:06:20Z

FR-b0n5a1:

Object-oriented programming (OOP) is a way of organizing code and data using objects, which are essentially self-contained units of data and methods that operate on that data. OOP is a fundamental approach to software development in many languages like Java, C++, and Python.

OOP relies on certain key concepts:
* '''Classes and Objects''': A class is a blueprint for creating objects, which are instances of that class.
* '''Encapsulation''': Bundling data (fields) and methods (procedures) that operate on that data within a single unit (object).
* '''Inheritance''': Creating new classes (subclasses) based on existing classes (superclasses), inheriting their attributes and behaviors.
* '''Polymorphism''': Allowing objects of different classes to be treated as objects of a common superclass, enabling code reuse and flexibility.

== Classes and Objects ==
In their most straightforward form, classes act as blueprints for objects. It's like a how you can drive into a rural area of a city and find many new homes with the same design. The developers used one set of architectural blueprints to build all of those houses. In the same way, one class can be used to construct many objects.

An object, on the other hand, is an actual active instance of a built class in memory. In most languages, there is a keyword that tells the compiler to create an object from a class such as <c>[[new]]</c>.

Classes are mostly defined by their fields and methods. Fields are just like variables except they are tied to a class or object. Methods are similar to functions and they always have access to the fields within their class definition as if they those fields were passed as a parameter to the method. Sometimes a language will require the keyword prefix <c>[[self]]</c> when referencing a field or method within the class definition.

In C++, let's define an Animal class:

class Animal {
protected:
std::string name;
int age;
public:
Animal(const std::string& name, int age)
: name(name), age(age) {}
virtual ~Animal() {}
virtual void speak() const = 0; // Pure virtual function
virtual void info() const {
std::cout << "Name: " << name << ", Age: " << age << std::endl;
}
};

In MiniScript, the same class would be defined as:
<ms>
Animal = { name:"" }

Animal.create = function(name, age)
a = new Animal
a.name = name
a.age = age
return a
end function

Animal.speak = function
end function

Animal.info = function
print "Name: " + self.name + ", Age: " + self.age
end function
</ms>

== Encapsulation ==
Encapsulation is more of a design technique to OOP programming and less of a technical aspect of any OOP language. When you code using this technique, it allows the programmer to organize their project by grouping all behaviour and related data into classes. When instantiated as an Object, this single container can be passed around in your code to "interact" with other objects.

When coding with encapsulation in mind, all behaviours (methods) and properties (fields) related to a class will be defined in that class. Knowing where to draw the line to include or exclude behaviour and properties tends to make or break an OOP design. Often it is better to define something using multiple classes rather than trying to make one monolithic class. A good rule of thumb is to dedicate a class to a single thing.

Looking back at our Animal class above, we can see that it has two fields (name and age) and essentially two methods (speak and info). Looking at <c>info()</c> we can see that it only uses <c>name</c> and <c>age</c>. As mentioned, that is what is defined in the class and so those are the only variables it has access to.

<blockquote> 📚 The other two methods in C++ are the constructor and destructor. In MiniScript, you are not required to have either of these. However, creating a constructor may help to declutter your code and make it easier to read.</blockquote>

== Inheritance ==
In the same way that humans inherit certain genetic traits from their parents, classes can inherit from a single parent classes (some languages support multiple inheritance as well). When a class inherits from another, all of the declared fields and methods of the parent class are automatically given to the child class. Only the inheritance has to be defined for this to work. For instance, in our Animal class, let's create two new children called Dog and Cat.

class Cat : public Animal {
private:
bool likesToClimb;
public:
Cat(const std::string& name, int age, bool likesToClimb)
: Animal(name, age), likesToClimb(likesToClimb) {}
void speak() const override {
std::cout << name << " says: Meow!" << std::endl;
}
void info() const override {
Animal::info();
std::cout << "Likes to climb: " << (likesToClimb ? "Yes" : "No") << std::endl;
}
};

class Dog : public Animal {
private:
std::string favoriteToy;
public:
Dog(const std::string& name, int age, const std::string& favoriteToy)
: Animal(name, age), favoriteToy(favoriteToy) {}
void speak() const override {
std::cout << name << " says: Woof!" << std::endl;
}
void info() const override {
Animal::info();
std::cout << "Favorite toy: " << favoriteToy << std::endl;
}
};

In MiniScript, these would be defined as:
<ms>
Cat = new Animal
Cat.likesToClimb = true
Cat.create = function(name, age, likesToClimb)
c = new Cat
c.name = name
c.age = age
c.likesToClimb = likesToClimb
return c
end function

Cat.speak = function
print self.name + " says: Meow!"
end function

Cat.info = function
super
print "Likes to Climb: " + self.likesToClimb
end function

Dog = new Animal
Dog.favouriteToy = "None"
Dog.create = function(name, age, favouriteToy)
d = new Dog
d.name = name
d.age = age
d.favouriteToy = self.favouriteToy
return d
end function

Dog.speak = function
print self.name + " says: Woof!"
end function

Dog.info = function
super
print "Favourite Toy: " + self.favouriteToy
end function
</ms>

MiniScript supports prototype-based OOP through <c>[[new]]</c>, <c>[[self]]</c>, <c>[[super]]</c>, and <c>[[isa|__isa]]</c>.

[[Category:Language]]

RawData.setByte

2025-01-30T00:38:43Z

FR-b0n5a1:

<c>[[RawData]].setByte</c> writes an unsigned byte into a [[RawData]] buffer.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''offset'' || number || 0 || position in buffer at which to start writing
|-
| ''value'' || number || 0 || unsigned byte to write
|}

== Example ==
<ms>
data = [13, 32, 47, 92, 95, 47, 92, 13, 40, 32, 111, 46, 111, 32, 41, 13, 32, 62, 32, 94, 32, 60, 13, 32, 77, 69, 79, 87, 33, 13]

a = new RawData
a.resize data.len
for i in range (0, data.len - 1)
a.setByte i, data[i]
end for

print a.utf8
</ms>
This example creates a [[RawData]] buffer, sizes it to length of data array, and then writes each byte of data array in the buffer, and finally print the buffer as an UTF-8 string (here : a little ASCII art of a cat).

See also : [[RawData.byte]]

[[Category:Mini Micro]]

RawData.byte

2025-01-30T00:37:33Z

FR-b0n5a1: Created page with "<c>RawData.byte</c> gets one unsigned byte from a RawData buffer. {| class="wikitable" |- ! Parameter Name !! Type !! Default Value !! Meaning |- | ''offset'' || numb..."

<c>[[RawData]].byte</c> gets one unsigned byte from a [[RawData]] buffer.

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''offset'' || number || 0 || position in buffer at which get the value
|}

== Example ==
<ms>
PNG_HEADER = [137, 80, 78, 71, 13, 10, 26, 10]

filePath = "/sys/pics/tank.png"
rawImg = file.loadRaw(filePath)

isPNG = true
for i in range (0, PNG_HEADER.len - 1)
isPNG = isPNG and PNG_HEADER[i] == rawImg.byte(i)
end for

if isPNG then
print filePath + " is a PNG file"
end if
</ms>
This example loads a file as a [[RawData]] buffer, and then checks the first 8 bytes to determine if it is a PNG file.

See also : [[RawData.setByte]]

[[Category:Mini Micro]]

RawData.setByte

2025-01-29T23:28:52Z

FR-b0n5a1: Created page with "<c>RawData.setByte</c> writes an unsigned byte into a RawData buffer. === Arguments === {| class="wikitable" |- ! Parameter Name !! Type !! Default Value !! Meaning..."

RawData.setUtf8

2025-01-29T23:25:28Z

FR-b0n5a1:

<c>[[RawData]].setUtf8</c> writes a string into a [[RawData]] buffer in UTF-8 format, and returns the number of bytes written.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''offset'' || number || 0 || position in buffer at which to start writing
|-
| ''s'' || string || "" || string to write
|}

=== Returns ===

This function returns the number of bytes written. If the given string contains only ASCII characters, than this is equal to the [[len]] of the string. If it contains any non-ASCII characters, then it will be more than the length of the string, since non-ASCII characters require multiple bytes to represent in UTF-8.

== Example ==

<ms>r = new RawData
r.resize 32
print r.setUtf8(4, "Hello!")</ms>

This example creates a [[RawData]] buffer, sizes it to 32 bytes, and then writes the string "Hello!" starting at byte 4. It prints out 6, as that is the number of bytes in the string.

[[Category:Mini Micro]]

RawData.setUtf8

2025-01-29T23:05:04Z

FR-b0n5a1:

<c>RawData.setUtf8</c> writes a string into a [[RawData]] buffer in UTF-8 format, and returns the number of bytes written.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''offset'' || number || 0 || position in buffer at which to start writing
|-
| ''s'' || string || "" || string to write
|}

=== Returns ===

This function returns the number of bytes written. If the given string contains only ASCII characters, than this is equal to the [[len]] of the string. If it contains any non-ASCII characters, then it will be more than the length of the string, since non-ASCII characters require multiple bytes to represent in UTF-8.

== Example ==

<ms>r = new RawData
r.resize 32
print r.setUtf8(4, "Hello!")</ms>

This example creates a [[RawData]] buffer, sizes it to 32 bytes, and then writes the string "Hello!" starting at byte 4. It prints out 6, as that is the number of bytes in the string.

[[Category:Mini Micro]]

Key.put

2025-01-29T20:22:36Z

FR-b0n5a1: Created page with "<c>key.put</c> allows you to enqueue a string, or single character by code point, into the keyboard buffer. == Example == <ms> // Put MiniScript code for a countdown from..."

<c>[[key]].put</c> allows you to enqueue a string, or single character by code point, into the keyboard buffer.

== Example ==
<ms>
// Put MiniScript code for a countdown from 10 to 1, then print "BOOM!"
key.put "for i in range(10, 1); clear; print i; wait; end for; clear; print ""BOOM!"""
key.put 13 // carriage return

// Put MiniScript code to print "Hello, World!"
key.put "print ""Hello, World!"""
key.put 13 // carriage return

key.put 99 // c
key.put 108 // l
key.put 101 // e
key.put 97 // a
key.put 114 // r
</ms>

[[Category:Mini Micro]]

Or

2025-01-29T19:19:29Z

FR-b0n5a1: Created page with "<c>or</c> is a keyword for logical binary operator of disjunction (or) of [https://en.wikipedia.org/wiki/Boolean_algebra boolean algebra]. It evaluates..."

<c>or</c> is a [[:Category:Keywords|keyword]] for logical binary operator of disjunction (or) of [https://en.wikipedia.org/wiki/Boolean_algebra boolean algebra]. It evaluates two operands and returns <c>true</c> when at least one of the operands is <c>true</c>, else it returns <c>false</c>.

== Examples ==
<ms>
print false or false // output : 0
print false or true // output : 1
print true or false // output : 1
print true or true // output : 1

a = false
b = true
c = false
print a or b // output : 1
print b or c // output : 1
print a or c // output : 0

minimum = 3
maximum = 7
A = 4
B = 9
print A > minimum or B < maximum // output : 1
print A < minimum or B < maximum // output : 0
</ms>

[[Category:Language]]
[[Category:Keywords]]

And

2025-01-29T19:18:29Z

FR-b0n5a1: Created page with "<c>and</c> is a keyword for logical binary operator of conjunction (and) of [https://en.wikipedia.org/wiki/Boolean_algebra boolean algebra]. It evaluate..."

<c>and</c> is a [[:Category:Keywords|keyword]] for logical binary operator of conjunction (and) of [https://en.wikipedia.org/wiki/Boolean_algebra boolean algebra]. It evaluates two operands and returns <c>true</c> only when both operands are <c>true</c>, else it returns <c>false</c>.

== Examples ==
<ms>
print false and false // output : 0
print false and true // output : 0
print true and false // output : 0
print true and true // output : 1

a = true
b = false
c = true
print a and b // output : 0
print b and c // output : 0
print a and c // output : 1

minimum = 3
maximum = 7
A = 4
B = 9
print A > minimum and A < maximum // output : 1
print B > minimum and B < maximum // output : 0
</ms>

[[Category:Language]]
[[Category:Keywords]]