Example: Data Expression with plus as concatenator

booking request = guest data + period + room type

guest data = guest name + address + paymethod
           + [passport number]

passport number = letter + {digit}*8

room state = {free | booked | occupied | repair}

account data = transfer + {account record}* + done

Example: Data Expression with implicit concatenation

guestData = guestName, address, paymethod
         [, passportNumber]

if_statement = 'if' condition 'Then' statement
              ['Else:' statement 'End If']

• + Shows the sequence of data. What comes after what.
• [ ] Shows that something is optional.
  [optional-expression]
• { }* Shows that something is repeated a number of times.
  {expression}*
  {expression}*8
  {expression}*(0:8)
  {expression}*(4:*)
• { | | } Shows a choice between several possibilities.
• B = C Shows that the composite data structure B is composed as shown by C.
• ‘free’ Shows a literal value.
• If we want a comma to separate the data parts, we
  show a comma in the formula.

Software Requirements – Styles and Techniques

Solution:
Here is a simple procedure in PHP that can convert UTF-8 string to corresponding full UTF representation. The function was constructed to solve specific problem and is not complete. It supports only 1, 2 and 3 octet (byte) UTF-8 entries. It also doesn’t support BOM.

/**
 * Decode UTF8 without BOM string to UTF string.
 * 
 * @param $string string Original UTF-8 encoded string we need to decode.
 * @param $strip_zeroes Remove trailing zeroes from converted UTF entry points. Default is false.
 * @return string UTF representation of the original UTF8 encoded string.
 *
 * @todo Add support for four byte characters.
 * @author Ivan Georgiev
 */
function utf8_decode($string, $strip_zeroes = false) {
	$pos = 0;
	$len = strlen($string);
	$result = '';
 
	while ($pos < $len) {
		$code1 = ord($string[$pos++]);
		if ($code1 < 0x80) {
			$result .= chr($code1);
		} elseif ($code1 < 0xE0) {
			// Two byte
			$code1 = 0x1F & $code1;
			$code2 = 0x3F & ord($string[$pos++]);
			$res_code1 = $code1 >> 2;
			if ($res_code1 > 0 || $strip_zeroes) {
				$result .= chr($res_code1);
			}
			$result .= chr( ($code1 << 6) | $code2);
		} elseif ($code1 < 0xF0) {
			// Three byte
			$code1 = $code1; // No need to mask
			$code2 = 0x3F & ord($string[$pos++]);
			$code3 = 0x3F & ord($string[$pos++]);
			$res_code1 = chr( ($code1 << 4) | ($code2 >> 2));
			if ($res_code1 > 0 || $strip_zeroes) {
				$result .= chr($res_code1);
			}
			$result .= chr( ($code2 << 6) | $code3);
		}
	}
 
	return $result;
}

See also: Generic File Input Stream in PHP with UTF-8 Support
Back to: PHP Tips and Recipes

The following PHP function converts a hexadecimal string to a binary string. The function is byte-based which means that it interprets consecutive pairs of hexadecimal digits and converts them to binary characters using the standard PHP function chr(). White-spaces are skipped.

A good extension point would be to implement word-based function that works in Big-Endian and Little-Endian modes.

<?php
 
define('HEX2BIN_WS', " \t\n\r");
 
function hex2bin($hex_string) {
    $pos = 0;
	$result = '';
	while ($pos < strlen($hex_string)) {
	  if (strpos(HEX2BIN_WS, $hex_string{$pos}) !== FALSE) {
	    $pos++;
	  } else {
	    $code = hexdec(substr($hex_string, $pos, 2));
		$pos = $pos + 2;
	    $result .= chr($code); 
	  }
	}
	return $result;
}
 
?>

Back to: PHP Tips and Recipes

Solution:

The following class implements simple Input Stream functionality in PHP. It provides a handy function for retrieving complete UTF-8 chars. At this time it supports only 1, 2 or 3 – octet (byte) characters.

<?php
 
class FileInputStream {
    private $fh = FALSE;
	private $fn = null;
 
	public function __construct($file_name) {
		$this->fn = $file_name;
	}
 
	public function open() {
		$this->fh = fopen($this->fn, 'r');
	}
 
	public function close() {
		fclose($this->fh);
	}
 
	public function fetchByte() {
		return fread($this->fh, 1);
	}
 
	public function fetchUtf8Char() {
		$ch = $this->fetchByte();
		$code1 = ord($ch);
		if ($code1 < 0x80) {
			// Single byte
		} elseif ($code1 < 0xE0) {
			// Two byte
			$ch .= $this->fetchByte();
		} elseif ($code1 < 0xF0) {
			// Tree byte
			$ch .= $this->fetchByte() . $this->fetchByte();
		}
		return $ch;
	}
 
	public function hasMore() {
		return ($this->fh !== FALSE) && 
		       (feof($this->fh) === FALSE);
	}
}
 
?>

I kept the functionality of the Input File Stream class to the bare minimum. I haven’t implemented any features that were not necessary for the solving the particular problem the Input Stream was designed for. You can implement methods that solve your problems. For example, you can implement a readLine method.

Useful concrete Input Stream could be a StringInputStream that implements same stream operations as File Input Stream, but for sequential read from string.

Programming patterns require that you create a interface class, for example InputStream. Concrete classes should implement the InputStream interface. PHP allows for replacing types without checking inheritance. Because of performance considerations I decided not to create an abstract interface.

See Also: utf8_decode: Decode UTF-8 Encoded String in PHP
Back to: PHP Tips and Recipes

How to join together two strings and how to make one long string from numerous pieces?

Solution

For the purpose of a single statement, use the plus (+) operator to concatenate multiple strings.

var longString = "One piece " + "plus one more ";

To compose a string value in multiple statements, use the operator +=

var sentence = "";
sentence += "word1 ";
sentence += "word2 ";
sentence += "word3";

We can also use and the plus for this operation, but its less elegant:

var sentence = "word1 word2 word3";

• number
• string
• boolean
• object
• function
• undefined

Example #1

typeof(123);			//This will return number
typeof("abd");			//This will return string
typeof(false);			//This will return boolean
 
 
typeof(typeof(var));		
//This will return string - no matter what the type of var is

Sometimes it is possible that IE thinks that a function is actually an object.

Example #2

typeof(document.getElementById);			
//The possible result for this operation is object, instead of function

There are a bunch of functions, which see what actually the variable contains.

bool is_numeric($var) – this function checks if var is a number or a numeric string. It returns TRUE if var is a numeric string or FALSE otherwise.

Example #1

<?php
	is_numeric(345);		// Returns true
	is_numeric("456"); 		// Returns true	
	is_numeric("adf");             	// Returns false	
	is_numeric("345dffds");     	// Returns false
?>

bool is_int($var) – this function checks if var is a integer. It returns TRUE if var is a integer or FALSE otherwise.

Example #2

<?php
	is_numeric(345);		// Returns true
	is_numeric(345.345);		// Returns false
	is_numeric("456"); 		// Returns false	
?>

bool is_double($var) – this function checks if var is a double. It returns TRUE if var is a integer or FALSE otherwise.

Example #3

<?php
	is_numeric(345.345);		// Returns true
	is_numeric(345);		// Returns false
	is_numeric("456.68"); 		// Returns false	
?>

This three functions are enough to see if the variable is a number. There are also another functions for checking what the type of a variable is, such is_bool() , is_array() , is_string() , is_object() etc.

You are given a Java array. You need Java Code to shuffle array elements in random order.

Solution

To shuffle array elements, traverse the array and swap the current array element with another element, selected randomly.

/**
 * Shuffle array Java class
 *
 * @author: Ivan Georgiev
 */
public class ArrayShuffler
{
	public static void shuffle(int[] targetArray)
	{
		int targetIndex;
		int swapBuffer;
		int maxInd = targetArray.length - 1;
		for(int curIndex=0; curIndex < targetArray.length; curIndex++)
		{
			targetIndex = (int) Math.round(Math.random() * maxInd);
			swapBuffer = targetArray[curIndex];
			targetArray[curIndex] = targetArray[targetIndex];
			targetArray[targetIndex] = swapBuffer;
		}
	}
}

Discussion

The array is traversed position-by-position. For each position we swap the element into that position with randomly selected element from the array. The random selection is done using the Math.random method. By traversing all the array elements we ensure that it is “well” shuffled.

Usually we shuffle an array to produce a random selection of array elements. If the number of elements in an array is big the time necessary for shuffling the array would be significant. It would also be impossible or at least undesirable to load all the elements into memory. For that purpose it would be better to generate a list of array indexes to represent array elements.

Sample client code

Here is a simple Java application to demonstrate how the random array shuffler works.

 
public class ArrayShufflerTest
{
	public static void main(String[] args)
	{
		// Define and initialize array of integers 0, 1, ..., 99
		int[] arr = new int[100];
		for (int i=0; i<arr.length; i++)
			arr[i] = i;
		// Display initial array
		System.out.println("Initial array: ");
		printArray(arr);
		// Invoke the shuffler method to shuffle the array.
		ArrayShuffler.shuffle(arr);
		// Display shuffled array
		System.out.println("Shuffled array: ");
		printArray(arr);
	}
 
	private static void printArray(int[] arr)
	{
		for (int el: arr)
		{
			System.out.print(el + " ");
		}
		System.out.println();
	}
}

For this purpose we use the function alert(), which opens up a box with a message. In our example it’s “Hello JavaScript!”, but it could be everything.

<script type="text/javascript">
	window.alert("Hello JavaScript!");
</script>

This function is very handy when there is a debugging process for a JavaScript. But be beware not to place it in a loop. Otherwise there would be a nasty alert for a lot of times, which could make you angry and you probably will have to press the “OK” button for a thousand times.