BaseScript.net

About | docs | bugs | license

ℹ️ About

🏗️ BaseScript is a programming language, which aims to compile your code to JavaScript.

Why to choose BaseScript?

• It is in the phase of active development, so more and more features are being added constantly. Also, check out RELEASE_NOTES.md, as well as Syntax Highlighter (updated) for the language
• Your ideas are also being reviewed and added, as the language is welcoming collaborations
• It provides you things, that JavaScript lacks:
  • Custom operator declaration
  • Pipe forward and pipe backward operators
  • Emoji variables and operators
  • Interfaces
  • Typed functions and arguments
  • Ability to get compile time errors to prevent runtime errors
  • Syntax sugar from other languages, that are so excess
  • Ability to customize your code the way you want it, and much more!
  • Easy to switch and learn
  • Code with ease
  • Readable and efficient
  • Boilerplate minimization

This page represents the simple to follow documentation of the language.

🔗 How to contact the creators

📬 Email: basescriptnet@gmail.com ✈️ Telegram: @basescript 📹 YouTube: BaseScript Channel

📁 Docs

• Content:

• Getting started
• How to contact the creators
• Variables
• Arrays
• Objects (New Features)
• Strings
• Ternar operator
• Numbers
• BigInts
• Statement block scope
• LOG, print, WRITE and ERROR keywords
• Conditions
• if else statements
• Safe values (New Feature)
• Functions (New Features)
• Custom types
• Debugger
• try|catch|finally statement
• Switch cases
• Loops (New Features)
• Strict mode
• Interfaces
• Operators (New Features)
• Custom Operators

▶️ Getting started

Learn more about CLI usage.

Install via npm

npm i basescript.js -g

At any directory use

bsc -f <file_name> [options?]

For help use

bsc -help

To install globally after git clone, you can use

npm install -g ./

[Deprecated]: Include built-in functionality in .bs files

If you already have it in the main file, connected files won't need it (as well as with -r flag)

#include <builtins>

Run from CLI without an output file

bsc -f <file_name> -r

🗄️ Variables

Variable declaration

let identifier = value
let num, num1 = 1, num2
\num3 // equivalent to let num3

Const declaration

const identifier = value

Variable or value reassignment

identifier = value
array[0] = value

Variable or value reassignment

identifier = value
Object.doSomething = value

🗃️ Arrays

Array creation

new Array(length) // length is optional
[0, 1, 2]

Getting an item from an array

array[index]

Getting a slice of an array

// @params start:end[:step(1 or -1)]
// end and step are optional
array[start:end:step] // all together
array[start::step] // start and step
array[start:] // start only

Getting the last element of the array

array[]

Reassigning to the last element of the array

array[] = value

🧱 Objects

Object creation

new Object() // not recomended
{ x: 1 }

Accessing items of the object

object.x
object['x']

Assigning multiple items at once using .{} operator

let object = {a: 'a'}
object.{
    b: 'b',
    c: 'c'
}
// object is {a: 'a', b: 'b', c: 'c'}

💬 Strings

String creation

new String() // not recomended
"Hello world"
'Programming is awesome'
`I am a
multiline string!`

String item retraction

"Hello world"[4] // outputs 'o'

String last item retraction

"Hello world"[] // outputs 'd'

String slice

// @params start:end[:direction(1 or -1)]
"Hello world"[0:5:-1] // outputs 'olleH'

The typeof operator returns a string

// returns the type of the value
typeof value
typeof(value)

❓ Ternar operator

Regular JS way

isNaN(value) ? 1 : 0
isNaN(value) ? isFinite(value) ? 1 : 0 : -1

Shortened way

With if else

true if isNaN(value) else false

#️⃣ Numbers

Declaration

// All followings are examples
// of the same Integer 1000
1000
1000.00
1_000
1_000.00

The sizeof operator returns a number

// this returns the length of the object keys
// or if not iterable - 0
sizeof value
sizeof(value)

🔢 BigInt

BigInts are threated as numbers, but return typeof BigInt

1000n
1_000n
// 1000.00n will throw an error
// floating point numbers are not allowed

📑 Statement block scope

Example with if block

if value {
    ...statements
}
if value BEGIN
    ...statements
END
if value do
    statement
if value:
    statement

🚪 LOG, print, WRITE and ERROR keywords

📝 Note: optional parenthesis are accepted

print and LOG

// they do the same thing
// just a syntax sugar
print 10 // console.log(10)
print(10) // console.log(10)
print if defined I_dont_exist // will not print anything unless the condition is truthy!
LOG "hello world" // console.log("hello world")

// appends the message to the HTML body element
// equivalent to document.write() method
WRITE "Message" // document.write("Message")
```-->

> ERROR

```javascript
// equivalent to console.error() method
ERROR "Something went wrong"
// console.error("Something went wrong")
ERROR if errorMessage // shows an error if errorMessage is not falsy

🔄 Conditions

Comparision operators

==, !=, ===, !==, >, <, >=, <=, is, is not
// is transforms into ===
// is not transforms into !==

Multivalue comparision

// Note: list of values always must be righthand
name == ('John', 'Danny', 'Charlie')
// automatically transforms into
name == 'John' || name == 'Danny' || name == 'Charlie'

random > (some_number, other_number, 20)
// same as
random > some_number && random > other_number && random > 20
// basically said, you have a callback result for your expression
// whatever the first two arguments are,
// it needs to be at least more, than 20

↔️ Ternary if

num if num > 0
num if num > 0 and num < 5 else num == undefined

num ? num > 0
num ? num > 0 and num < 5 : num == undefined

🚸 If else statements

If statement without else

if num < 0:
    num = 0

if num < 0 {
    num = 0
    num1 = 10
}

if (num < 0):
    num = 0

if (num < 0) {
    num = 0
}

If statement with else

if temperature > 25:
    print "It's hot!"
else print "It's cold!"

Unless statement

unless isAdmin:
    print "You don't have access."
// same as
if (!isAdmin) {
    console.log("You don't have access.");
}

Safe values

safeValue function tries to see if the value exists, and if so, returns it's value, otherwise undefined. By functionality, it is similar to JavaScript's ?. optional chaining, but you won't need to chain things more than once. It is done for you

let v = safeValue(null.property) // will return undefined

defined keyword allows you to see if a variable or value has ever been declared. Returns a boolean. Useful when unsure, or working with dynamically defined variables

// this will only execute, if the variable has been defined, and won't cause an error.
if defined no_one_declared_me {
    doStuff()
}

🚄 Functions

Declaration

function a () {
    // ...statements
    return value
}
// if no arguments are carried,
// no parenthesis are required
function a {
    // ...statements
    return value
}
// same as
def a () {
    // ...statements
    return value
}
// or
def a {
    // ...statements
    return value
}

Shortcut for return

return value
// same as
=> value
function add(a, b):=> a + b

Calling functions

add(10, 20)

If a function needs to be called multiple times, use the ->() operator

let elementsToWatch = document.querySelector->(
    '#login',
    '#password',
    '#submitBtn',
) // returns an array of elements

let content = readFile->(
    &('header', 'utf8'),
    &('content', 'utf8'),
    &('footer', 'utf8'),
).join('\n')
// returns an array, then uses the join method

For object properties, use ->[] operator to return an array with multiple property calls

let game = new Game()
game->[
    player,
    getEnemies(),
    getEntities()
] // returns an array of the property call results
// Note: all of those are methods and properties of game
// but you won't need to specify `game.player`. Simple:)
// This, in fact, uses the javascript `with` statement under the hood for now, which might be updated for safety purposes in the future

Typed arguments and args constant

📝 NOTE: every function contains args constant, which is an array representation of arguments object

// this ensures that a and b are integers
// anything else will throw an error
function add(Int a, Int b) {
    return a + b
}
// only strings are allowed
function say(String text) {
    WRITE text // deprecated
}

🧩 Custom types

Declaration

type NotEmptyArray (Array value) {
    if value.length !== 0: => true
}

Notes: type name must start with uppercase letter Exactly one argument is required

🚧 Debugger

Starting the debugger

if num < 0 {
    debugger
}

🙌 try|catch|finally statement

try without catch and finally

try: isWorking(1)
// same as:
try {
    isWorking(1)
}
// catch block is automatically inserted
// automatically outputs console.warn(err.message)

try with catch

try: isWorking(1)
catch: console.error(err)
// variable err is automatically declared

// same as:
try {
    isWorking(1)
} catch err {
    console.error(err)
}

try with finally

try: isWorking(1)
finally: doSomethingElse()
// same as:
try {
    isWorking(1)
} finally {
    doSomethingElse()
}

👏 Switch cases

Declaration, cases?, default?

switch typeof value {
    case 'String':
        return value
    case 'Number':
    case 'Null':
    case 'Undefined':
    case 'NaN':
        return value + '';
    default: return '';
}

To instantly break the case, use case* feature

let error = ''
switch errorNumber {
    case* 403: error = 'Forbidden'
    case* 404: error = 'Not Found'
    case* 500: error = 'Internal Server Error'
}

Use switch* clause as a value

let error = switch errorNumber {
    case 403: 'Forbidden'
    case 404: 'Not Found'
    case 500: 'Internal Server Error'
}

🔛 Loops

Declaration using times keyword (not a reserved one)

8 times {
    print 'Yes!'
}
// Note: For now, only a numeric value is allowed before `times` keyword

Declaration of while loop

while isTrue {
    print true
}
// or
while (isTrue):
    print true

Declaration of for loop

for key in object {
    print object[key]
}
for value of object {
    print value
}
for i of range(0, 10) {
    print i
}
for i from 0 till 10 {
    print i
}
for i from 0 through 10 {
    print i
}
// notice, const or let are alowed here, but not necessary
for i = 0; i < 10; i++ {
    print i
}

☝️ Strict mode

Declaration

'use strict'
// learn more at https://www.w3schools.com/js/js_strict.asp

Interfaces

Declaration

interface Person {
    name: String,
    age: Int,
    children: Person[] | Null
}

Usage

let people = []
function addToArray(Person person) {
    people.push(person)
}
addToArray({
    name: 'John',
    age: 19,
    children: null
})

Operators

Arrow and dot operators, ->[], ->(), .{} (see Functions, Objects)

->() // Calls a function if used on functions multiple times, depending on argument length
->[] // Calls an object property/properties multiple times, without the need to refer to the object each time

.{} // assigns or reassigns multiple properties and methods to an object at once, and returns the result

Arithmetic Operators

+ Plus
- Minus
* Multiply
/ Divide
~/ Divide and drop the floating part
% Modulus
** Exponentiation
++ Increment
-- Decrement

Logical Operators

&& Logical and
|| Logical or
!  Logical not

Bitwise operators

&   AND
|   OR
~   NOT
^   XOR
<<  Left shift
>>  Right shift
>>> Unsigned right shift

Type And Size Operators

typeof // describes the type of the object
sizeof // describes the size of the object, or returns null

The instanceof operator

value instanceof Array
// as well as
value not instanceof Array
// or
value !instanceof Array

The in operator

value in object
// as well as
value not in object
// or
value !in object

Pipe Forward And Pipe Back Operators

|> Pipe forward
<| Pipe back
// example
// pipe forward
num + 5 |> Array // Same as Array(num + 5)
num + 5 |> Array(0, 1) // Same as Array(num + 5, 0, 1)
num + 5 |> Array(0, 1, .) // Same as Array(0, 1, num + 5)

'  How\'s it going?   '
    |> escape
    |> trim
    |> write('file.txt', .)

// pipe back

write('file.txt', .)
    <| trim
    <| escape
    <| '  How\'s it going?   '

📏 Custom operators

Declaration

// operator "#" [A-Za-z0-9_\/*+-.&|$@!^#~]:+ ...
operator #/ (Number left, Number right) {
    if isNaN(left / right): return 0
    return left / right;
}

Usage

// outputs 0 instead of NaN
print Infinity #/ Infinity

🤫 More and more is coming soon!

The documentation is not final, and more examples and syntax sugar tricks will be added

We are constantly updating, fixing and adding new features!

📃 License

😉 Free Software, Hell Yeah!

This project is open-sourced software licensed under the MIT License.

See the LICENSE file for more information.