├── .gitignore
├── config.example.php.js
├── commands
    ├── die.php.js
    ├── ping.php.js
    ├── echo.php.js
    ├── yell.php.js
    ├── whisper.php.js
    ├── bestwaifu.php.js
    ├── dank.php.js
    ├── eval.php.js
    └── info.php.js
├── constants.php.js
├── bootstrap.php.js
├── package.json
├── errors.php.js
├── functions
    ├── typecasting.php.js
    ├── general_functions.php.js
    ├── conditional_checks.php.js
    ├── array_functions.php.js
    └── string_functions.php.js
├── index.php.js
├── examples
    ├── typecasting.php.js
    ├── strings.php.js
    ├── arrays.php.js
    └── conditionals.php.js
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | 
3 | config.php.js
4 | 


--------------------------------------------------------------------------------
/config.example.php.js:
--------------------------------------------------------------------------------
1 | // <?php
2 | 
3 | module.exports = {
4 | 	token: '',
5 | };
6 | 


--------------------------------------------------------------------------------
/commands/die.php.js:
--------------------------------------------------------------------------------
1 | // <?php
2 | 
3 | exports.execute = async function($message) {
4 | 	await $message['channel'].send('Killing the process...');
5 | 	die();
6 | };
7 | 


--------------------------------------------------------------------------------
/commands/ping.php.js:
--------------------------------------------------------------------------------
1 | // <?php
2 | 
3 | exports.execute = async function($message) {
4 | 	var $sent = await $message['channel'].send('Ping...');
5 | 	$sent.edit(`Pong! Took ${$sent['createdTimestamp'] - $message['createdTimestamp']}`);
6 | };
7 | 


--------------------------------------------------------------------------------
/commands/echo.php.js:
--------------------------------------------------------------------------------
1 | // <?php
2 | 
3 | exports.execute = async function($message, $arguments) {
4 | 	var $to_echo = implode(' ', $arguments);
5 | 	return $message['channel'].send(`${$to_echo}! ` + str_repeat($to_echo + ', ', 3) + `${$to_echo}...`);
6 | }
7 | 
8 | exports.arguments = true;
9 | 


--------------------------------------------------------------------------------
/commands/yell.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | exports.execute = async function($message, $arguments) {
 4 | 	var $commands = $message['client']['commands'];
 5 | 	var $uppercased = strtoupper(implode(' ', $arguments));
 6 | 	return $commands['echo'].execute($message, explode(' ', $uppercased));
 7 | };
 8 | 
 9 | exports.arguments = true;
10 | 


--------------------------------------------------------------------------------
/commands/whisper.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | exports.execute = async function ($message, $arguments) {
 4 | 	var $commands = $message['client']['commands'];
 5 | 	var $lowercased = '`' + strtolower(implode(' ', $arguments)) + '`';
 6 | 	return $commands['echo'].execute($message, explode(' ', $lowercased));
 7 | };
 8 | 
 9 | exports.arguments = true;
10 | 


--------------------------------------------------------------------------------
/commands/bestwaifu.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | exports.execute = async function($message, $arguments) {
 4 | 	if (count($arguments) < 2) {
 5 | 		return $message.reply('you need to give me at least 2 waifus to choose from!');
 6 | 	}
 7 | 
 8 | 	var $chosen = array_rand($arguments);
 9 | 	return $message['channel'].send(`${$arguments[$chosen]} is the best waifu!`);
10 | };
11 | 
12 | exports.arguments = true;
13 | 


--------------------------------------------------------------------------------
/constants.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | var $node_versions = process['versions']['node'].split('.');
 4 | 
 5 | module.exports = {
 6 | 	__DIR__: __dirname,
 7 | 	__FILE__: __filename,
 8 | 	NODE_VERSION: process['version'],
 9 | 	NODE_MAJOR_VERSION: $node_versions[0],
10 | 	NODE_MINOR_VERSION: $node_versions[1],
11 | 	NODE_RELEASE_VERSION: $node_versions[2],
12 | 	DISCORD_JS_VERSION: require('discord.js')['version'],
13 | 	PREFIX: '$',
14 | };
15 | 


--------------------------------------------------------------------------------
/bootstrap.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | var { readdirSync: scandir } = require('fs');
 4 | var $functions = scandir('./functions');
 5 | const CONSTANTS = require('./constants.php');
 6 | 
 7 | function register_globally($array) {
 8 | 	for (let $key of Object.keys($array)) {
 9 | 		global[$key] = $array[$key];
10 | 	}
11 | }
12 | 
13 | register_globally(CONSTANTS);
14 | 
15 | for (let $function of $functions) {
16 | 	var $file = require(`./functions/${$function}`);
17 | 	register_globally($file);
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "discord.js-bot-but-php",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "index.php.js",
 6 |   "scripts": {
 7 |     "arrays": "node examples/arrays.php.js",
 8 |     "conditionals": "node examples/conditionals.php.js",
 9 |     "strings": "node examples/strings.php.js",
10 |     "typecasting": "node examples/typecasting.php.js"
11 |   },
12 |   "keywords": [],
13 |   "author": "",
14 |   "license": "ISC",
15 |   "dependencies": {
16 |     "discord.js": "^11.2.1"
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/commands/dank.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | exports.execute = async function($message, $arguments) {
 4 | 	var $mentions = array($message['mentions']['users']); 
 5 | 
 6 | 	if (empty($mentions)) return $message.reply('you didn\'t mention anybody!');
 7 | 	if (count($mentions) > 5) return $message.reply('please don\'t mention more than 5 users at a time!');
 8 | 
 9 | 	var $dank = array_map(function($mention) {
10 | 		return `<@${$mention[0]}> is dank!`;
11 | 	}, $mentions);
12 | 
13 | 	return $message['channel'].send(implode('\n', $dank));
14 | }
15 | 
16 | exports.arguments = true;
17 | 


--------------------------------------------------------------------------------
/errors.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | module.exports = {
 4 | 	/**
 5 | 	 * Throw a TypeError, PHP style.
 6 | 	 * 
 7 | 	 * @param {string} $function The name of the function that errored.
 8 | 	 * @param {number} $parameter The position of the parameter.
 9 | 	 * @param {string} $expected The expected type. 
10 | 	 * @param {*} $given The given input.
11 | 	 */
12 | 	type_error($function, $parameter, $expected, $given) {
13 | 		throw new TypeError(
14 | 			`WARNING \`${$function}()\` expects parameter ${$parameter} to be ${$expected}, ${typeof $given} given`
15 | 		);
16 | 	},
17 | };
18 | 


--------------------------------------------------------------------------------
/commands/eval.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | var { inspect } = include_once('util');
 4 | 
 5 | exports.execute = async function($message, $arguments) {
 6 | 	var $client = $message['client'];
 7 | 	var $bot = $client;
 8 | 	var $msg = $message;
 9 | 
10 | 	try {
11 | 		var $regex = new RegExp($client['token']);
12 | 		var $evaled = eval(implode(' ', $arguments));
13 | 		
14 | 		if (gettype($evaled) !== 'string') $evaled = inspect($evaled, false, 0);
15 | 
16 | 		return $message['channel'].send('```\n' + $evaled + '```');
17 | 	}
18 | 	catch ($e) {
19 | 		print_r($e);
20 | 		return $message['channel'].send('```\n' + $e + '```');
21 | 	}
22 | };
23 | 
24 | exports.arguments = true;
25 | 


--------------------------------------------------------------------------------
/commands/info.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | var { RichEmbed } = include_once('discord.js');
 4 | 
 5 | exports.execute = async function($message, $arguments) {
 6 | 	var $client = $message['client'];
 7 | 	var $sanc = $client['users'].get('126485019500871680');
 8 | 
 9 | 	var $embed = new RichEmbed()
10 | 		.setColor('#4E5A91')
11 | 		.setAuthor(
12 | 			`Made by ${$sanc['tag']}, for shits 'n giggles.`,
13 | 			$sanc['displayAvatarURL'],
14 | 			'https://github.com/Danktuary/discord.js-Bot-But-PHP',
15 | 		)
16 | 		.addField('Total commands', count(Object.keys($client['commands'])), true)
17 | 		.addField('Total users', count(array($client['users'])), true)
18 | 		.addField('Total servers', count(array($client['guilds'])), true)
19 | 		.addField('NODE_VERSION', NODE_VERSION, true)
20 | 		.addField('DISCORD_JS_VERSION', DISCORD_JS_VERSION, true)
21 | 		.addField('PREFIX', PREFIX, true);
22 | 
23 | 	return $message['channel'].send({ embed: $embed });
24 | };
25 | 


--------------------------------------------------------------------------------
/functions/typecasting.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | module.exports = {
 4 | 	/**
 5 | 	 * Get the boolean value of a variable
 6 | 	 * 
 7 | 	 * @param {*} $var The scalar value being converted to a boolean.
 8 | 	 * @return {boolean} The boolean value of $var.
 9 | 	 */
10 | 	boolval: Boolean,
11 | 
12 | 	/**
13 | 	 * Get the string  value of a variable
14 | 	 * 
15 | 	 * @param {*} $var The variable that is being converted to a string.
16 | 	 * @return {string} The string value of $var.
17 | 	 */
18 | 	strval: String,
19 | 
20 | 	/**
21 | 	 * Get the integer value of a variable
22 | 	 * 
23 | 	 * @param {*} $var The scalar value being converted to an integer
24 | 	 * @param {number} $base The base for the conversion
25 | 	 * @return {number} The integer value of var on success, or 0 on failure.
26 | 	 */
27 | 	intval: parseInt,
28 | 
29 | 	/**
30 | 	 * Get the float value of a variable
31 | 	 * 
32 | 	 * @param {*} $var May be any scalar type.
33 | 	 * @return {boolean} The float value of the given variable.
34 | 	 */
35 | 	floatval: parseFloat,
36 | 
37 | 	/**
38 | 	 * Alias of floatval()
39 | 	 */
40 | 	doubleval: parseFloat,
41 | };
42 | 


--------------------------------------------------------------------------------
/index.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | require('./bootstrap.php');
 4 | var $config = require_once(__DIR__ + '/config.php');
 5 | 
 6 | var { basename } = require_once('path');
 7 | var { readdirSync: scandir } = require_once('fs');
 8 | var { Client } = require_once('discord.js');
 9 | 
10 | var $client = new Client;
11 | $client['commands'] = {};
12 | 
13 | var $command_files = scandir(__DIR__ + '/commands');
14 | 
15 | for (let $file of $command_files) {
16 | 	const $name = basename($file, '.js');
17 | 	$client['commands'][basename($name, '.php')] = include_once(__DIR__ + `/commands/${$name}`);
18 | }
19 | 
20 | $client.on('ready', function() {
21 | 	print_r('eNd mEeeEEEE pleAASeee');
22 | 	print_r('Ready!');
23 | });
24 | 
25 | $client.on('message', function($message) {
26 | 	if (stripos($message['content'], PREFIX) !== 0 || $message['author']['bot']) return;
27 | 
28 | 	var [$name, ...$arguments] = explode(' ', substr($message['content'], strlen(PREFIX)));
29 | 
30 | 	// because `explode()` doesn't take a regex,
31 | 	// and I don't wanna recreate `preg_split()`
32 | 	$arguments = array_filter($arguments, function($argument) {
33 | 		return $argument;
34 | 	});
35 | 
36 | 	if (!$client['commands'][$name]) return;
37 | 
38 | 	var $command = $client['commands'][$name];
39 | 
40 | 	if ($command['arguments'] && empty($arguments)) {
41 | 		return $message.reply('you didn\'t provide any arguments!');
42 | 	}
43 | 
44 | 	$command.execute($message, $arguments)
45 | 		.catch(function($e) {
46 | 			print_r($e['stack']);
47 | 			$message.reply('there was an error trying to execute that command!');
48 | 		});
49 | });
50 | 
51 | $client.login($config['token']);
52 | 


--------------------------------------------------------------------------------
/examples/typecasting.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | require('../bootstrap.php');
 4 | 
 5 | function someFunction() {
 6 | 	// ...
 7 | }
 8 | 
 9 | print_r('\n`boolval()` examples\n---------------\n');
10 | 
11 | print_r('true: ' + boolval(true));
12 | print_r('false: ' + boolval(false));
13 | print_r('\'\': ' + boolval(''));
14 | print_r('\'string\': ' + boolval('string'));
15 | print_r('0: ' + boolval(0));
16 | print_r('10: ' + boolval(10));
17 | print_r('10.5: ' + boolval(10.5));
18 | print_r('[]: ' + boolval([]));
19 | print_r('[\'an\', \'array\']: ' + boolval(['an', 'array']));
20 | print_r('{}: ' + boolval({}));
21 | print_r('{ some: \'object\' }: ' + boolval({ some: 'object' }));
22 | print_r('someFunction(): ' + boolval(someFunction));
23 | 
24 | print_r('\n`strval()` examples\n---------------\n');
25 | 
26 | print_r('true: ' + strval(true));
27 | print_r('false: ' + strval(false));
28 | print_r('\'\': ' + strval(''));
29 | print_r('\'string\': ' + strval('string'));
30 | print_r('0: ' + strval(0));
31 | print_r('10: ' + strval(10));
32 | print_r('10.5: ' + strval(10.5));
33 | print_r('[]: ' + strval([]));
34 | print_r('[\'an\', \'array\']: ' + strval(['an', 'array']));
35 | print_r('{}: ' + strval({}));
36 | print_r('{ some: \'object\' }: ' + strval({ some: 'object' }));
37 | print_r('someFunction(): ' + strval(someFunction));
38 | 
39 | print_r('\n`intval()` examples\n---------------\n');
40 | 
41 | print_r('true: ' + intval(true));
42 | print_r('false: ' + intval(false));
43 | print_r('\'\': ' + intval(''));
44 | print_r('\'string\': ' + intval('string'));
45 | print_r('0: ' + intval(0));
46 | print_r('10: ' + intval(10));
47 | print_r('10.5: ' + intval(10.5));
48 | print_r('[]: ' + intval([]));
49 | print_r('[\'an\', \'array\']: ' + intval(['an', 'array']));
50 | print_r('{}: ' + intval({}));
51 | print_r('{ some: \'object\' }: ' + intval({ some: 'object' }));
52 | print_r('someFunction(): ' + intval(someFunction));
53 | 
54 | print_r('\n`floatval()` & `doubleval()` examples\n---------------\n');
55 | 
56 | print_r('true: ' + floatval(true));
57 | print_r('false: ' + floatval(false));
58 | print_r('\'\': ' + floatval(''));
59 | print_r('\'string\': ' + floatval('string'));
60 | print_r('0: ' + floatval(0));
61 | print_r('10: ' + floatval(10));
62 | print_r('10.5: ' + floatval(10.5));
63 | print_r('[]: ' + floatval([]));
64 | print_r('[\'an\', \'array\']: ' + floatval(['an', 'array']));
65 | print_r('{}: ' + floatval({}));
66 | print_r('{ some: \'object\' }: ' + floatval({ some: 'object' }));
67 | print_r('someFunction(): ' + floatval(someFunction));
68 | 


--------------------------------------------------------------------------------
/examples/strings.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | require('../bootstrap.php');
 4 | 
 5 | print_r('\n`explode()` examples\n---------------\n');
 6 | 
 7 | print_r('\'This is a sentence.\' by ` `: ');
 8 | print_r(explode(' ', 'This is a sentence.'));
 9 | 
10 | print_r('\n\'This is a sentence.\' by `i`: ');
11 | print_r(explode('i', 'This is a sentence.'));
12 | 
13 | print_r('\n\'100,000,000,000.00\' by `,`: ');
14 | print_r(explode(',', '100,000,000,000.00'));
15 | 
16 | print_r('\n\'100.00\' by ``: ');
17 | print_r(explode('', '100.00'));
18 | 
19 | print_r('\n`lcfirst()` examples\n---------------\n');
20 | 
21 | print_r('\'some string\': ' + lcfirst('some string'));
22 | print_r('\'Some string\': ' + lcfirst('Some string'));
23 | print_r('\'SOME STRING\': ' + lcfirst('SOME STRING'));
24 | 
25 | print_r('\n`ucfirst()` examples\n---------------\n');
26 | 
27 | print_r('\'some string\': ' + ucfirst('some string'));
28 | print_r('\'Some string\': ' + ucfirst('Some string'));
29 | print_r('\'SOME STRING\': ' + ucfirst('SOME STRING'));
30 | 
31 | print_r('\n`strtolower()` examples\n---------------\n');
32 | 
33 | print_r('\'some string\': ' + strtolower('some string'));
34 | print_r('\'Some string\': ' + strtolower('Some string'));
35 | print_r('\'SOME STRING\': ' + strtolower('SOME STRING'));
36 | 
37 | print_r('\n`strtoupper()` examples\n---------------\n');
38 | 
39 | print_r('\'some string\': ' + strtoupper('some string'));
40 | print_r('\'Some string\': ' + strtoupper('Some string'));
41 | print_r('\'SOME STRING\': ' + strtoupper('SOME STRING'));
42 | 
43 | print_r('\n`strlen()` examples\n---------------\n');
44 | 
45 | print_r('\'Some string\': ' + strlen('Some string'));
46 | print_r('555: ' + strlen(555));
47 | print_r('555.0: ' + strlen(555.0));
48 | print_r('555.5: ' + strlen(555.5));
49 | 
50 | print_r('\n`str_repeat()` examples\n---------------\n');
51 | 
52 | print_r('\'something\' x 0: ' + str_repeat('something', 0));
53 | print_r('\'something\' x 1: ' + str_repeat('something', 1));
54 | print_r('\'something\' x 5: ' + str_repeat('something', 5));
55 | 
56 | print_r('\n`stripos()` examples\n---------------\n');
57 | 
58 | print_r('\'Some string\', \'some\': ' + stripos('Some string', 'some'));
59 | print_r('\'Some string\', \'string\': ' + stripos('Some string', 'string'));
60 | print_r('\'Some string\', \'z\`: ' + stripos('Some string', 'z'));
61 | print_r('\'Some string\', \'s\', 3: ' + stripos('Some string', 's', 3));
62 | print_r('\'Some string\', \'s\', 10`: ' + stripos('Some string', 's', 3));
63 | 
64 | print_r('\n`substr()` examples\n---------------\n');
65 | 
66 | print_r('\'Some string\', 3: ' + substr('Some string', 3));
67 | print_r('\'Some string\', -3: ' + substr('Some string', -3));
68 | print_r('\'Some string\', 3, 3: ' + substr('Some string', 3, 3));
69 | print_r('\'Some string\', -3, 3: ' + substr('Some string', -3, 3));
70 | 


--------------------------------------------------------------------------------
/examples/arrays.php.js:
--------------------------------------------------------------------------------
  1 | // <?php
  2 | 
  3 | require('../bootstrap.php');
  4 | 
  5 | var $names = ['Sanc', 'Dank', 'Sanctuary', 'Danktuary'];
  6 | 
  7 | var $numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  8 | var $numbers_words = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten'];
  9 | var $numbers_by_5 = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100];
 10 | 
 11 | var $2D_array = [
 12 | 	'first',
 13 | 	'second',
 14 | 	[
 15 | 		'inner first',
 16 | 		'inner second',
 17 | 		[
 18 | 			'inner inner first',
 19 | 			'inner inner second'
 20 | 		],
 21 | 	],
 22 | 	'fourth',
 23 | ];
 24 | 
 25 | function someFunction () {
 26 | 	// ...
 27 | }
 28 | 
 29 | print_r('\n`array()` examples\n---------------\n');
 30 | 
 31 | print_r('true: ');
 32 | print_r(array(true));
 33 | 
 34 | print_r('\nfalse: ');
 35 | print_r(array(false));
 36 | 
 37 | print_r('\n\'\': ');
 38 | print_r(array(''));
 39 | 
 40 | print_r('\n\'string\': ');
 41 | print_r(array('string'));
 42 | 
 43 | print_r('\n0: ');
 44 | print_r(array(0));
 45 | 
 46 | print_r('\n10: ');
 47 | print_r(array(10));
 48 | 
 49 | print_r('\n10.5: ');
 50 | print_r(array(10.5));
 51 | 
 52 | print_r('\n[]: ');
 53 | print_r(array([]));
 54 | 
 55 | print_r('\n[\'an\', \'array\']: ');
 56 | print_r(array(['an', 'array']));
 57 | 
 58 | print_r('\n{}: ');
 59 | print_r(array({}));
 60 | 
 61 | print_r('\n{ some: \'object\' }: ');
 62 | print_r(array({ some: 'object' })); 
 63 | 
 64 | print_r('\nsomeFunction(): ');
 65 | print_r(array(someFunction));
 66 | 
 67 | print_r('\n`array_map()` examples\n---------------\n');
 68 | 
 69 | print_r('$names mapped, appending \' is dank\': ');
 70 | print_r(array_map(function($name) {
 71 | 	return $name + ' is dank.';
 72 | }, $names));
 73 | 
 74 | print_r('\n$numbers multiplied by themselves: ');
 75 | print_r(array_map(function($number) {
 76 | 	return $number * $number;
 77 | }, $numbers));
 78 | 
 79 | print_r('\n`array_filter()` examples\n---------------\n');
 80 | 
 81 | print_r('$numbers_by_5 % 10: ');
 82 | print_r(array_filter($numbers_by_5, function($number) {
 83 | 	return $number % 10;
 84 | }));
 85 | 
 86 | print_r('\n$number_words with lengths greater than 3: ');
 87 | print_r(array_filter($numbers_words, function($word) {
 88 | 	return strlen($word) > 3;
 89 | }));
 90 | 
 91 | print_r('\n`array_rand()` examples\n---------------\n');
 92 | 
 93 | print_r('Single key: ');
 94 | print_r(array_rand($numbers_words));
 95 | 
 96 | print_r('\nMultiple keys: ');
 97 | print_r(array_rand($numbers_words, 5));
 98 | 
 99 | print_r('\n`count()` & `sizeof()` examples\n---------------\n');
100 | 
101 | print_r('2D array (non-recursive): ');
102 | print_r(count($2D_array));
103 | 
104 | print_r('\n2D array (recursive): ');
105 | print_r(count($2D_array, true));
106 | 
107 | print_r('\n`in_array()` examples\n---------------\n');
108 | 
109 | print_r('Non-strict: ');
110 | print_r(in_array('1', $numbers));
111 | 
112 | print_r('\nStrict: ');
113 | print_r(in_array('1', $numbers, true));
114 | 


--------------------------------------------------------------------------------
/functions/general_functions.php.js:
--------------------------------------------------------------------------------
 1 | // <?php
 2 | 
 3 | var { inspect } = require('util');
 4 | var { is_integer, is_null } = require('./conditional_checks.php');
 5 | 
 6 | module.exports = {
 7 | 	/**
 8 | 	 * The `require_once` statement is identical to `require`
 9 | 	 * except it will check if the file has already been included,
10 | 	 * and if so, not include (require) it again.
11 | 	 */
12 | 	require_once: require,
13 | 
14 | 	/**
15 | 	 * The include statement includes and evaluates the specified file
16 | 	 *
17 | 	 * @param {string} $file The file to include.
18 | 	 */
19 | 	include($file) {
20 | 		try {
21 | 			return require($file);
22 | 		} catch ($e) {
23 | 			console.error($e);
24 | 		}
25 | 	},
26 | 
27 | 	/**
28 | 	 * The include statement includes and evaluates the specified file
29 | 	 *
30 | 	 * @param {string} $file The file to include.
31 | 	 */
32 | 	include_once() {
33 | 		return this.include(...arguments);
34 | 	},
35 | 
36 | 	/**
37 | 	 * Prints human-readable information about a variable
38 | 	 * 
39 | 	 * @param {*} $expression The expression to be printed.
40 | 	 * @param {boolean} $return If you would like to capture the output of print_r(), use the return parameter.
41 | 	 * When this parameter is set to TRUE, print_r() will return the information rather than print it.
42 | 	 * @return {*} Returns the variable representation when the return parameter is used and evaluates to TRUE.
43 | 	 * Otherwise, this function will return NULL.
44 | 	 */
45 | 	print_r($expression = '', $return = false) {
46 | 		if ($return == true) return $expression;
47 | 		if ($expression === '') return console.log();
48 | 		if (this.gettype($expression) === 'string') return console.log($expression);
49 | 		return console.log(inspect($expression, { showHidden: true, depth: null }));
50 | 	},
51 | 
52 | 	/**
53 | 	 * Outputs or returns a parsable string representation of a variable
54 | 	 * 
55 | 	 * @param {*} $expression The variable you want to export.
56 | 	 * @param {boolean} $return If used and set to TRUE, var_export() will return the variable representation instead of outputting it.
57 | 	 * @return {*} Returns the variable representation when the return parameter is used and evaluates to TRUE.
58 | 	 * Otherwise, this function will return NULL.
59 | 	 */
60 | 	var_export() {
61 | 		return this.print_r(...arguments);
62 | 	},
63 | 
64 | 	/**
65 | 	 * Get the type of a variable
66 | 	 * 
67 | 	 * @param {*} $var The variable being type checked.
68 | 	 */
69 | 	gettype($var) {
70 | 		return typeof $var;
71 | 	},
72 | 
73 | 	/**
74 | 	 * Output a message and terminate the current script
75 | 	 * 
76 | 	 * @param {*} $status If status is a string, this function prints the status just before exiting.
77 | 	 * If status is an integer, that value will be used as the exit status and not printed.
78 | 	 * The status 0 is used to terminate the program successfully.
79 | 	 * @return {void}
80 | 	 */
81 | 	exit($status) {
82 | 		if (is_integer($status)) process.exit($status);
83 | 		if (!is_null($status)) this.print_r($status);
84 | 		process.exit();
85 | 	},
86 | 
87 | 	/**
88 | 	 * Equivalent to exit
89 | 	 */
90 | 	die() {
91 | 		return this.exit(...arguments);
92 | 	},
93 | };
94 | 


--------------------------------------------------------------------------------
/functions/conditional_checks.php.js:
--------------------------------------------------------------------------------
  1 | // <?php
  2 | 
  3 | module.exports = {
  4 | 	/**
  5 | 	 * Finds whether a variable is an array
  6 | 	 * 
  7 | 	 * @param {*} $variable The variable being evaluated.
  8 | 	 * @return {boolean} Returns TRUE if var is an array, FALSE otherwise.
  9 | 	 */
 10 | 	is_array: Array.isArray,
 11 | 
 12 | 	/**
 13 | 	 * Finds out whether a variable is a boolean
 14 | 	 * 
 15 | 	 * @param {*} $var The variable being evaluated.
 16 | 	 * @return {boolean} Returns TRUE if var is a boolean, FALSE otherwise.
 17 | 	 */
 18 | 	is_bool($var) {
 19 | 		return typeof $var === 'boolean' || $var instanceof Boolean;
 20 | 	},
 21 | 
 22 | 	/**
 23 | 	 * Verify that the contents of a variable can be called as a function
 24 | 	 * 
 25 | 	 * @param {*} $var The value to check
 26 | 	 * @return {boolean} Returns TRUE if var is callable, FALSE otherwise.
 27 | 	 */
 28 | 	is_callable($var) {
 29 | 		return typeof $var === 'function';
 30 | 	},
 31 | 	
 32 | 	/**
 33 | 	 * Alias of is_float()
 34 | 	 * 
 35 | 	 * @return {boolean} Returns TRUE if var is a float, FALSE otherwise.
 36 | 	 */
 37 | 	is_double() {
 38 | 		return this.is_float(...arguments);
 39 | 	},
 40 | 
 41 | 	/**
 42 | 	 * Finds whether the type of the given variable is float.
 43 | 	 * 
 44 | 	 * @param {*} $var The variable being evaluated.
 45 | 	 * @return {boolean} Returns TRUE if var is a float, FALSE otherwise.
 46 | 	 */ 
 47 | 	is_float($var) {
 48 | 		return (!isNaN($var) && !Number.isInteger($var));
 49 | 	},	
 50 | 
 51 | 	/**
 52 | 	 * Find whether the type of the given  variable is integer
 53 | 	 * 
 54 | 	 * @param {*} $var The variable being evaluated.
 55 | 	 * @return {boolean} Returns TRUE if var is an integer, FALSE otherwise.
 56 | 	 */
 57 | 	is_int: Number.isInteger,
 58 | 
 59 | 	/**
 60 | 	 * Alias of is_int()
 61 | 	 * 
 62 | 	 * @return {boolean} Returns TRUE if var is an integer, FALSE otherwise.
 63 | 	 */
 64 | 	is_integer: Number.isInteger,
 65 | 
 66 | 	/**
 67 | 	 * Finds whether a variable is NULL
 68 | 	 * 
 69 | 	 * @param {*} $var The variable being evaluated.
 70 | 	 * @return {boolean} Returns TRUE if var is null, FALSE otherwise.
 71 | 	 */
 72 | 	is_null($var) {
 73 | 		return $var == null;
 74 | 	},
 75 | 
 76 | 	/**
 77 | 	 * Finds whether a variable is a number or a numeric string
 78 | 	 * 
 79 | 	 * @param {*} $var The variable being evaluated.
 80 | 	 * @return {boolean} Returns TRUE if var is a number or a numeric string, FALSE otherwise.
 81 | 	 */
 82 | 	is_numeric($var) {
 83 | 		return !isNaN($var);
 84 | 	},
 85 | 
 86 | 	/**
 87 | 	 * Find whether the type of a variable is string
 88 | 	 * 
 89 | 	 * @param {*} $var The variable being evaluated.
 90 | 	 * @return {boolean} Returns TRUE if var is of type string, FALSE otherwise.
 91 | 	 */
 92 | 	is_string($var) {
 93 | 		return typeof $var === 'string';
 94 | 	},
 95 | 
 96 | 	/**
 97 | 	 * Determine whether a variable is empty
 98 | 	 * 
 99 | 	 * @param {*} $var Variable to be checked
100 | 	 * @return {boolean} Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE.
101 | 	 */
102 | 	empty($var) {
103 | 		return (!$var || (this.is_array($var) && !$var['length']));
104 | 	},
105 | };
106 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <div align="center">
 2 | 	<img src="http://i.imgur.com/JN0sMnl.png" title="it's joke" alt="it's joke" />
 3 | </div>
 4 | 
 5 | # Discord.js Bot (but PHP)
 6 | 
 7 | The most repulsive repo you never wanted to see!
 8 | 
 9 | # FAQ (or something like that)
10 | 
11 | ### Wh... Why would you do such a thing?
12 | 
13 | I was bored. I needed yet another reason for people to yell at me. This seemed like it'd work well.
14 | 
15 | ### Using `var`? Prepending variable names with `$`? Attaching all those functions to `global`?!?!
16 | 
17 | ITS. JOKE.
18 | 
19 | But there are reasons for each of those.
20 | 
21 | * PHP variables are declared and referenced with `$`, so that's a no-brainer.
22 | * PHP variables are function-scoped, just like `var`, so it only makes sense to use `var` over `let` or `const`.
23 | * Attaching functions to `global` is bad, yes, but I couldn't think of any other way to do so. I'd never do such a thing in a real project. You got something better, huh?! (Really, if you do, feel free to create a pull request.)
24 | 
25 | ### Some of those functions don't work the exact same as they do in PHP!
26 | 
27 | Trust me, I (probably) know. Some are either missing additional parameters, simply can't work the same because of some stupid JavaScript limitation, or some other miscellaneous reason. I tried my best, okay?! 😭
28 | 
29 | ### A few of those doc blocks don't look very accurate, or they're a bit inconsistent. Why?
30 | 
31 | You can probably blame the PHP docs for some of those. As everyone knows, PHP isn't the most consistent thing in the world. But for inaccurate function/param/return value descriptions, you can probably blame me. I myself probably won't be doing much about it, though.
32 | 
33 | ### Did you really spend time and effort into this, all for a joke?
34 | 
35 | Yes, yes I did. This is a good measurement of how far I'll go for a joke.
36 | 
37 | Did I spend too much time on this? Yes. Could I have spent this time being productive and doing the things I should've been working on instead? Most definitely. Do I regret it at all? Nope!
38 | 
39 | Fun fact: I actually occassionally confused myself when looking at this code, because my brain couldn't tell if it was JS or PHP at a glance. With that being said, I think I've achieved the goal of this project.
40 | 
41 | ### How do I contribute to this ridiculous project?
42 | 
43 | Are you drunk? Not even ***I*** want to contribute.
44 | 
45 | ... But if you really want to, feel free to create a pull request - even if it's just for shits 'n giggles. As long as it looks like real PHP, anything goes.
46 | 
47 | # Examples
48 | 
49 | For the sake of taking this joke even further, I went the extra mile and made an examples folder. You can check them out by running `npm run <script>`, where `<script>` can be `arrays`, `conditionals`, `strings`, or `typecasting`.
50 | 
51 | The only ones that I didn't create examples for were the functions inside the `./functions/general_functions.php.js` file, but you can probably just look at the code/doc blocks and get a general idea of what each of them do.
52 | 
53 | # Rest in Peace to...
54 | 
55 | * Your eyes
56 | * My eyes
57 | * My sanity
58 | * The friendships I once had before publishing this
59 | 
60 | # Credit
61 | 
62 | The message that sparked it all:
63 | <div align="center">
64 | 	<img src="https://i.imgur.com/G6iXTGG.png" alt="" />
65 | </div>
66 | 


--------------------------------------------------------------------------------
/examples/conditionals.php.js:
--------------------------------------------------------------------------------
  1 | // <?php
  2 | 
  3 | require('../bootstrap.php');
  4 | 
  5 | class EmptyClass {
  6 | 	/* ... */
  7 | }
  8 | 
  9 | class OtherClass {
 10 | 	constructor() {
 11 | 		this.prop = true;
 12 | 	}
 13 | 
 14 | 	example() {
 15 | 		// ...
 16 | 	}
 17 | 
 18 | 	static staticExample() {
 19 | 		// ...
 20 | 	}
 21 | }
 22 | 
 23 | var $other_class = new OtherClass;
 24 | 
 25 | var $closure = function() {
 26 | 	// ...
 27 | };
 28 | 
 29 | var $undef;
 30 | 
 31 | print_r('\n`is_array()` examples\n---------------\n');
 32 | 
 33 | print_r('\'some string\': ' + is_array('some string'));
 34 | print_r('regular array: ' + is_array(['this', 'is', 'an', 'array']));
 35 | print_r('empty array: ' + is_array([]));
 36 | print_r('object: ' + is_array({}));
 37 | 
 38 | print_r('\n`is_bool()` examples\n---------------\n');
 39 | 
 40 | print_r('true: ' + is_bool(true));
 41 | print_r('false: ' + is_bool(false));
 42 | print_r('1: ' + is_bool('true'));
 43 | print_r('\'true\': ' + is_bool('true'));
 44 | print_r('Boolean(\'yes\'): ' + is_bool(Boolean('yes')));
 45 | print_r('new Boolean(\'yes\'): ' + is_bool(new Boolean('yes')));
 46 | 
 47 | print_r('\n`is_callable()` examples\n---------------\n');
 48 | 
 49 | print_r('closure: ' + is_callable($closure));
 50 | print_r('empty class: ' + is_callable(EmptyClass));
 51 | print_r('instantiated class: ' + is_callable($other_class));
 52 | print_r('class property: ' + is_callable($other_class['prop']));
 53 | print_r('class method: ' + is_callable($other_class['example']));
 54 | print_r('static class method: ' + is_callable(OtherClass.staticExample));
 55 | 
 56 | print_r('\n`is_float()` & `is_double()` examples\n---------------\n');
 57 | 
 58 | print_r('5: ' + is_float(5));
 59 | print_r('5.0: ' + is_float(5.0));
 60 | print_r('5.1: ' + is_float(5.1));
 61 | print_r('\'5.1\': ' + is_float('5.0'));
 62 | print_r('\'5.1\': ' + is_float('5.1'));
 63 | print_r('\'100 percent\': ' + is_int('100 percent'));
 64 | print_r('NaN: ' + is_float(NaN));
 65 | 
 66 | print_r('\n`is_int()` & `is_integer()` examples\n---------------\n');
 67 | 
 68 | print_r('5: ' + is_int(5));
 69 | print_r('5.0: ' + is_int(5.0));
 70 | print_r('5.1: ' + is_int(5.1));
 71 | print_r('\'5.1\': ' + is_int('5.1'));
 72 | print_r('\'5.1\': ' + is_int('5.0'));
 73 | print_r('\'100 percent\': ' + is_int('100 percent'));
 74 | print_r('NaN: ' + is_int(NaN));
 75 | 
 76 | print_r('\n`is_numeric()` examples\n---------------\n');
 77 | 
 78 | print_r('5: ' + is_numeric(5));
 79 | print_r('5.0: ' + is_numeric(5.0));
 80 | print_r('5.1: ' + is_numeric(5.1));
 81 | print_r('\'5.1\': ' + is_numeric('5.1'));
 82 | print_r('\'5.1\': ' + is_numeric('5.0'));
 83 | print_r('\'100 percent\': ' + is_int('100 percent'));
 84 | print_r('NaN: ' + is_numeric(NaN));
 85 | 
 86 | print_r('\n`is_null()` examples\n---------------\n');
 87 | 
 88 | print_r('null: ' + is_null(null));
 89 | print_r('undefined: ' + is_null(undefined));
 90 | print_r('\'\': ' + is_null(''));
 91 | print_r('0: ' + is_null(0));
 92 | print_r('NaN: ' + is_null(NaN));
 93 | 
 94 | print_r('\n`is_string()` examples\n---------------\n');
 95 | 
 96 | print_r('\'some string\': ' + is_string('some string'));
 97 | print_r('(5).toString(): ' + is_string((5).toString()));
 98 | print_r('String(true): ' + is_string(String(true)));
 99 | print_r('String(): ' + is_string(String()));
100 | 
101 | print_r('\n`empty()` examples\n---------------\n');
102 | 
103 | print_r(': ' + empty());
104 | print_r('\'\': ' + empty(''));
105 | print_r('0: ' + empty(0));
106 | print_r('0.0: ' + empty(0.0));
107 | print_r('false: ' + empty(false));
108 | print_r('null: ' + empty(null));
109 | print_r('undefined: ' + empty(undefined));
110 | print_r('[]: ' + empty([]));
111 | print_r('{}: ' + empty({}));
112 | 


--------------------------------------------------------------------------------
/functions/array_functions.php.js:
--------------------------------------------------------------------------------
  1 | // <?php
  2 | 
  3 | var { type_error } = require('../errors.php');
  4 | var { is_array, is_bool, is_callable, is_numeric } = require('./conditional_checks.php');
  5 | var { boolval } = require('./typecasting.php');
  6 | 
  7 | module.exports = {
  8 | 	/**
  9 | 	 * Create an array
 10 | 	 * 
 11 | 	 * @param {*} $var The variable to turn into an array. 
 12 | 	 * @return {array} Returns an array of the parameters.
 13 | 	 */
 14 | 	array($var) {
 15 | 		return Array.from($var);
 16 | 	},
 17 | 
 18 | 	/**
 19 | 	 * Applies the callback to the elements of the given arrays
 20 | 	 * 
 21 | 	 * @param {function} $callback Callback function to run for each element in each array.
 22 | 	 * @param {array} $array An array to run through the callback function.
 23 | 	 * @return {array} Returns an array containing all the elements of $array
 24 | 	 * after applying the callback function to each one.
 25 | 	 */
 26 | 	array_map($callback, $array) {
 27 | 		if (!is_callable($callback)) type_error('array_map', 1, 'function', $callback);
 28 | 		if (!is_array($array)) type_error('array_map', 2, 'array', $array);
 29 | 
 30 | 		return $array.map($callback);
 31 | 	},
 32 | 
 33 | 	/**
 34 | 	 * Filters elements of an array using a callback function
 35 | 	 * 
 36 | 	 * @param {array} $array The array to iterate over
 37 | 	 * @param {function} $callback The callback function to use
 38 | 	 * @return {array} Returns the filtered array.
 39 | 	 */
 40 | 	array_filter($array, $callback) {
 41 | 		if (!is_array($array)) type_error('array_filter', 1, 'array', $array);
 42 | 		if (!is_callable($callback)) type_error('array_filter', 2, 'function', $callback);
 43 | 
 44 | 		return $array.filter($callback);
 45 | 	},
 46 | 
 47 | 	/**
 48 | 	 * Pick one or more random entries out of an array
 49 | 	 * 
 50 | 	 * @param {array} $array The input array.
 51 | 	 * @param {number} $num Specifies how many entries should be picked.
 52 | 	 * @return {*} When picking only one entry, array_rand() returns the key for a random entry.
 53 | 	 * Otherwise, an array of keys for the random entries is returned.
 54 | 	 */
 55 | 	array_rand($array, $num = 1) {
 56 | 		if (!is_array($array)) type_error('array_rand', 1, 'array', $array);
 57 | 		if (!is_numeric($num)) type_error('array_rand', 2, 'integer', $num);
 58 | 		if ($num < 1 || $num > this.count($array)) {
 59 | 			throw new Error('WARNING `array_rand()`: Second argument has to be between 1 and the number of elements in the array');
 60 | 		}
 61 | 
 62 | 		var $indexes = [];
 63 | 		
 64 | 		for (var i = 0; i < $num; ++i) {
 65 | 			$indexes.push(Math.floor(Math.random() * this.count($array)));
 66 | 		}
 67 | 
 68 | 		return $indexes;
 69 | 	},
 70 | 
 71 | 	/**
 72 | 	 * Count all elements in an array, or something in an object
 73 | 	 * 
 74 | 	 * @param {array} $array An array.
 75 | 	 * @param {boolean} $recursive If set to true, count() will recursively count the array.
 76 | 	 * @return {number} Returns the number of elements in $array.
 77 | 	 */
 78 | 	count($array, $recursive = false) {
 79 | 		if (!is_array($array)) type_error('count', 1, 'array', $array);
 80 | 		if (!is_bool($recursive)) type_error('count', 2, 'bool', $recursive);
 81 | 
 82 | 		if ($recursive != true) return $array['length'];
 83 | 
 84 | 		var $count = 0;
 85 | 
 86 | 		function count_array($arr) {
 87 | 			for (var $i = 0; $i < $arr['length']; ++$i) {
 88 | 				if (is_array($arr[$i])) {
 89 | 					count_array($arr[$i]);
 90 | 					continue;
 91 | 				}
 92 | 
 93 | 				++$count;
 94 | 			}
 95 | 
 96 | 			return $count;
 97 | 		}
 98 | 
 99 | 		return count_array($array);
100 | 	},
101 | 
102 | 	/**
103 | 	 * Alias of count()
104 | 	 */
105 | 	sizeof() {
106 | 		return this.count(...arguments);
107 | 	},
108 | 
109 | 	/**
110 | 	 * Checks if a value exists in an array
111 | 	 * 
112 | 	 * @param {*} $needle The searched value.
113 | 	 * @param {array} $haystack The array.
114 | 	 * @param {boolean} $strict If the third parameter strict is set to TRUE
115 | 	 * then the in_array() function will also check the types of the needle in the haystack.
116 | 	 * @return {boolean} Returns TRUE if needle is found in the array, FALSE otherwise.
117 | 	 */
118 | 	in_array($needle, $haystack, $strict = false) {
119 | 		if (!is_array($haystack)) type_error('in_array', 2, 'array', $haystack);
120 | 		if (!is_bool($strict)) type_error('in_array', 2, 'bool', $strict);
121 | 
122 | 		return boolval($haystack.find(function($toFind) {
123 | 			return ($strict == true) ? $toFind === $needle : $toFind == $needle;
124 | 		}));
125 | 	},
126 | 
127 | 	/**
128 | 	 * Join array elements with a string
129 | 	 * 
130 | 	 * @param {string} $glue Defaults to an empty string.
131 | 	 * @param {array} $pieces The array of strings to implode.
132 | 	 * @return {string} Returns a string containing a string representation
133 | 	 * of all the array elements in the same order, with the glue string between each element.
134 | 	 */
135 | 	implode($glue, $pieces) {
136 | 		if (!is_null($pieces) && !is_string($glue)) type_error('implode', 1, 'string', $glue);
137 | 		if (!is_null($pieces) && !is_array($pieces)) type_error('implode', 2, 'array', $pieces);
138 | 
139 | 		return (!is_null($pieces)) ? $pieces.join($glue) : $glue.join('');
140 | 	},
141 | 
142 | 	/**
143 | 	 * Alias of implode()
144 | 	 */
145 | 	join() {
146 | 		return this.implode(...arguments);
147 | 	},
148 | };
149 | 


--------------------------------------------------------------------------------
/functions/string_functions.php.js:
--------------------------------------------------------------------------------
  1 | // <?php
  2 | 
  3 | var { type_error } = require('../errors.php');
  4 | var { strval } = require('./typecasting.php');
  5 | var { is_array, is_integer, is_null, is_string } = require('./conditional_checks.php');
  6 | 
  7 | module.exports = {
  8 | 	/**
  9 | 	 * 
 10 | 	 * @param {string} $delimiter The boundary string.
 11 | 	 * @param {string} $string The input string.
 12 | 	 * @param {number} $limit? If limit is set and positive, the returned array will contain
 13 | 	 * a maximum of limit elements with the last element containing the rest of string.
 14 | 	 * If the limit parameter is negative, all components except the last -limit are returned.
 15 | 	 * If the limit parameter is zero, then this is treated as 1.
 16 | 	 * @return {string[]} Returns an array of strings created by splitting the string parameter on boundaries formed by the delimiter.
 17 | 	 */
 18 | 	explode($delimiter, $string, $limit = null) {
 19 | 		if (!is_string($delimiter)) type_error('explode', 1, 'string', $delimiter);
 20 | 		if (!is_string($string)) type_error('explode', 2, 'string', $string);
 21 | 		if (!is_null($limit) && !is_integer($limit)) type_error('explode', 3, 'integer', $limit);
 22 | 
 23 | 		if ($limit) {
 24 | 			if ($limit == 0) return [$string];
 25 | 			if ($limit < 0) return $string.split($delimiter, $limit);
 26 | 
 27 | 			var $rest = $string.split($delimiter).slice($limit).join($delimiter);
 28 | 			return $string.split($delimiter, $limit).concat($rest);
 29 | 		}
 30 | 
 31 | 		return $string.split($delimiter);
 32 | 	},
 33 | 
 34 | 	/**
 35 | 	 * Make a string's first character lowercase
 36 | 	 * 
 37 | 	 * @param {string} $str The input string.
 38 | 	 * @return {string} Returns the resulting string.
 39 | 	 */
 40 | 	lcfirst($str) {
 41 | 		if (!is_string($str)) type_error('lcfirst', 1, 'string', $str);
 42 | 		return $str[0].toLowerCase() + $str.slice(1);
 43 | 	},
 44 | 
 45 | 	/**
 46 | 	 * Make a string's first character uppercase
 47 | 	 * 
 48 | 	 * @param {string} $str The input string.
 49 | 	 * @return {string} Returns the resulting string.
 50 | 	 */
 51 | 	ucfirst($str) {
 52 | 		if (!is_string($str)) type_error('ucfirst', 1, 'string', $str);
 53 | 		return $str[0].toUpperCase() + $str.slice(1);
 54 | 	},
 55 | 
 56 | 	/**
 57 | 	 * Make a string lowercase
 58 | 	 * 
 59 | 	 * @param {string} $string The input string.
 60 | 	 * @return {string} Returns the lowercased string.
 61 | 	 */
 62 | 	strtolower($string) {
 63 | 		if (!is_string($string)) type_error('strtolower', 1, 'string', $string);
 64 | 		return $string.toLowerCase();
 65 | 	},
 66 | 
 67 | 	/**
 68 | 	 * Make a string uppercase
 69 | 	 * 
 70 | 	 * @param {string} $string The input string.
 71 | 	 * @return {string} Returns the uppercased string.
 72 | 	 */
 73 | 	strtoupper($string) {
 74 | 		if (!is_string($string)) type_error('strtoupper', 1, 'string', $string);
 75 | 		return $string.toUpperCase();
 76 | 	},
 77 | 
 78 | 	/**
 79 | 	 * Get string length
 80 | 	 * 
 81 | 	 * @param {string} $string The string being measured for length.
 82 | 	 * @return {number} The length of the string on success, and 0 if the string is empty.
 83 | 	 */
 84 | 	strlen($string) {
 85 | 		if (!is_string($string) && !is_numeric($string)) type_error('strlen', 1, 'string', $string);
 86 | 		return strval($string)['length'];
 87 | 	},
 88 | 
 89 | 	/**
 90 | 	 * Repeat a string
 91 | 	 * 
 92 | 	 * @param {string} $input The string to be repeated.
 93 | 	 * @param {number} $multiplier Number of time the input string should be repeated.
 94 | 	 * multiplier has to be greater than or equal to 0. If the multiplier is set to 0, the function will return an empty string.
 95 | 	 * @return {string} Returns the repeated string.
 96 | 	 */
 97 | 	str_repeat($input, $multiplier) {
 98 | 		if (!is_string($input)) type_error('str_repeat', 1, 'string', $input);
 99 | 		if (!is_numeric($multiplier)) type_error('str_repeat', 2, 'integer', $multiplier);
100 | 		return $input.repeat($multiplier);
101 | 	},
102 | 
103 | 	/**
104 | 	 * Find the position of the first occurrence of a case-insensitive substring in a string
105 | 	 * 
106 | 	 * @param {*} $haystack The string to search in.
107 | 	 * @param {*} $needle Note that the needle may be a string of one or more characters.
108 | 	 * @param {*} $offset If specified, search will start this number of characters counted
109 | 	 * from the beginning of the string. If the offset is negative, the search will
110 | 	 * start this number of characters counted from the end of the string.
111 | 	 * @return {*} Returns the position of where the needle exists relative to
112 | 	 * the beginnning of the haystack string (independent of offset).
113 | 	 * Also note that string positions start at 0, and not 1.
114 | 	 */
115 | 	stripos($haystack, $needle, $offset = 0) {
116 | 		if (!is_string($haystack)) type_error('strpos', 1, 'string', $haystack);
117 | 		if (!is_string($needle)) type_error('strpos', 2, 'string', $needle);
118 | 		if (!is_numeric($offset)) type_error('strpos', 3, 'integer', $offset);
119 | 
120 | 		return this.strtolower($haystack).indexOf(this.strtolower($needle), $offset);
121 | 	},
122 | 
123 | 	/**
124 | 	 * Return part of a string
125 | 	 * 
126 | 	 * @param {string} $string The input string. Must be one character or longer.
127 | 	 * @param {number} $start The position of the string to start from.
128 | 	 * @param {number} $length The number of characters to extract.
129 | 	 * @return {string} Returns the extracted part of string; or FALSE on failure, or an empty string.
130 | 	 */
131 | 	substr($string, $start, $length) {
132 | 		if (!is_string($string)) type_error('substr', 1, 'string', $string);
133 | 		if (!is_numeric($start)) type_error('substr', 2, 'integer', $start);
134 | 		if (!is_null($length) && !is_numeric($length)) type_error('substr', 3, 'integer', $length);
135 | 
136 | 		return $string.substr($start, $length);
137 | 	},
138 | };
139 | 


--------------------------------------------------------------------------------