Manual Login and Logout in WordPress

Very recently, I had a situation where I needed to take user's username and password as inputs and log him/her onto Wordpress manually. And this is how I came up with the solution. Check the code below.

<?php
// This is a very important step
// We need to get the wp object
require("wp-load.php");   

// Log Out if anyone is already logged
// in from same browser
if ( is_user_logged_in() ) 
{ 
   // Default Wordpress function 
   // to log a user out
   wp_logout(); 
}

// GET user's Inputs (username, password)
$creds = array();
$creds['user_login']    = $_POST['username'];
$creds['user_password'] = $_POST['password'];

// Extra settings, for Remember me
$creds['remember'] = false;

// The Wordpress function which Logs
// the user in
$user = wp_signon( $creds, false );

// Track ERROR if any
if ( is_wp_error($user) )
{
  echo $user->get_error_message(); 
}
// Login Success
else
{
  echo "You have logged in successfully";
}
?>

The code above is quite self-explanatory. Some points to be noted : 

1. wp_signon() -- It logs any user in with username and passwords passed to it in Array. This function takes a 2nd parameter to mention whether secured cookies are to be used.
2. wp_logout() -- It logs out if any user is logged in
3. The array $cred must be built with the keys ('user_login' and 'user_password') shown above.

Number summation problem

Very recently, I have come across an interesting programming problem which is shown below.

Problem :: We have an array of various numbers. From that array we need to find those numbers which can be written as sum of 2 or more consecutive numbers existing within the same array.

Say for example, in an array of numbers (5,1,3,2,4,6), the first number "5" can be written as "3+2" but not "1+4" as "1" and "4" are not appearing consecutively. Similarly "6" can be written as "5+1" and "2+4" etc. 

So, we need to find out all the numbers which are sum of other consecutive numbers and print them.

1. So, will be requiring a loop which would inspect every number in the array (starting from 5,1 and so on). Let's examine the case of "5".

2. Inside the above loop, we start with adding-numbers (which would be added to produce "5") "1" and start checking if consecutive numbers "3", "2" (i.e 1+3+2+...) and so on can produce the sum "5".
   So, we need a second loop for this. This would find the starting point of adding-numbers. A successful series may be "1+3+..." or "3+2+.." or "2+4+.." etc. So, 1,3,2 etc are starting numbers from which we start to add consecutive numbers.

3. Now, let's consider a case where we have such a starting number say "1". We need a third loop which would run through rest of the array to add consecutive numbers "3", "2" etc  to "1" and produce a sum of "5". This third loop will produce the actual sum.

4. We keep a track whether minimum 2 numbers are added to produce the final result "5" through a counter.

Let's check the code part to understand our approach to solve the problem. The inspection of number "5" have been discussed in comments in the code below.

<?php
// Define the array
$arr = array(5,1,3,2,4,6);

// Here we have the FIRST loop to inspect 
// each number in the array
for($i=0;$i<count($arr);$i++)
{
  // Store the Current number we are inspecting
  // Let's examine the case of 5
  $current_number = $arr[$i];
  
  // Second Loop
  for($j=0;$j<count($arr);$j++)
  {
      // Set $sum variable to hold SUM
      $sum = 0;
      $str = "";
 
      // $count variable makes sure that minimum
      // two numbers are added
      $count = 0;
 
      // We would ignore the Number we are inspecting
      // while Addint. We won't add "5" to $sum 
      // (initially set to 0) to product "5". 
      // Hence we just ignore the situation
      if($j == $i) continue;  
 
      // Otherwise, We move ahead
      if($j != $i) 
      {
  
        // Third Loop, it keeps on Adding to $sum from 
        // the starting point say "1" or "3" or "2" and so on.
        for( $k=$j;$k<count($arr);$k++)
{

          // Avoid the chance of adding the Number
           // which is being inspected (5 in our test case)
          if($k == $i) break;
 
       // Add to SUM ($sum variable)
          $sum += $arr[$k];
  
   // When we add, we increase the counter
   // We need to make sure that minimum 2 numbers
   // are added to produce "5"
   $count++;
  
   // We build a String of numbers we are adding
   $str .= $arr[$k] . ",";
  
    // If summation is already higher than 
           // the Number being inspected, we discard 
           // that combination. This way we can 
           // discard "1+3+2" resulting 6 etc and 
    // save some precious CPU time
    if($sum>$current_number) 
           { 
              break; 
           }
  
          // If minimum 2 digits are added
           // and Sum is "5" let's PRINT the result 
           // and break. This means if we find that 
           // "3+2" is acceptable, then we need to 
           // move to next starting point say "2" and                          // check combinations like "2+4+..." etc
          if($count >= 2 && $sum == $current_number) 
          { 
            // Show Result
            echo "<br> ($i position)" .
                 " $current_number is summation" .
                 " of numbers ". rtrim($str,","); 
            break; 
          } 
      } // Third Loop Ends
    
     }// If ends
 
  } // Second Loop ends

} // First Loop Ends

?>

The above code is explained within the accompanied comments. 

Now, Check the output below :

(0 position) 5 is summation of numbers 3,2
(4 position) 4 is summation of numbers 1,3
(5 position) 6 is summation of numbers 5,1
(5 position) 6 is summation of numbers 1,3,2
(5 position) 6 is summation of numbers 2,4

Find longest substring inside a string

Very recently I have seen a small programming problem given on a site, which is shown below.

Find the length of the longest substring without repeating characters within a given string.

Take the string 'immediate' for example. The longest non-repeating letters would be "mediate". We can't accept "mmediate" because 'm' is repeating. 

In the string "borough", there are longest substring (non-repeating characters) will be "rough".

In the string "xxxxxx", the longest substring without non-repeating characters is "x".

So, we are going to write a program in PHP which would find the longest substring. And we are following this process ..

1. We would run a loop to examine the given string, reading character from 0th position, 1st position and so on.
2. We would pick up non-matching characters and store them in a character array. That array of characters will be converted to sub-strings.
3. Such sub-strings will be stored in a final array.
4. If we have a list of substrings, easily we can make out which is the longest substring among them using the strlen() function and a for loop.

Let's check out the final code :: 

<?php

// The given string is here
$str = "aksjdhiquywenqmneqkjosiqioueyqwemndfgppoiuytrewqasdfghyujikolrvcxzvbybnuimklopoiui";

// This is the final array where substrings will be stored
$subs = array();

// The main LOOP which reads the string
// So when $i is 0, the $str is read from 0th position
// When $i is 1, the $str is read from 1st position
for($i=0;$i<strlen($str);$i++)
{
  
  // A small array where picked-up characters will be stored
  $k = array();
  
  // Another loop which picks up characters from given string
  // and adds to the array $k  
  for($j=$i; $j<strlen($str); $j++)
  {
    // The array $k will be built with characters which are
    // not repeated earlier. So, we used in_array() to check
    // if this picked-up character is already existing in array $k
    if(!in_array( $str[$j], $k))
    {
       $k[] = $str[$j];
    }  
    else
    {
      // So we found a repeating character
      // So, BREAK to build the Substring
      break; 
    }
  }
  
  // When $k holds the series of characters
  // now build the substring and put it in the
  // array $subs
  $subs[] = implode("",$k);
}

// So, now $subs array holds all the possible substrings
// existing in the given string. Now is the time, we 
// find the longest among them
$max = 0; 
$final_str = "";

// Loop and scan
for($i=0; $i< count($subs); $i++)
{
  if(strlen($subs[$i]) > $max) 
  { 
      $max = strlen($subs[$i]); 
      $final_str = $subs[$i]; 
  }
}

// Finally print the result
echo "Max Length : $max, String : [$final_str]";
?>

The above code is quite self-explanatory. Each simply tries to create/extract substrings from the given string. For that we need to run a loop scanning from 0th position in the string $str. 

So, in the first pass, characters are picked up from 0th position in $str and kept in array $k till a non-matching character is found. Next the array $k is converted to a string (read substring) and put in the final array $subs.

In the 2nd pass, characters are picked up from 1st position in $str and kept in array $k and a substring is built eventually and kept in array $subs. 

This way, we build an array of all the possible substrings (made with non-repeating charaters) exist inside the string $str. 

And finally we simply decide which is the longest among them and print the result.

The above program displayed the output to be ::
Max Length : 21, String : [ewqasdfghyujikolrvcxz]

Serialization / Unserialization in PHP - III

We have already discussed how we can serialize/unserialize objects in PHP. Here we would see how we can achieve the same thing using the interface Serializable. 

To use this interface, we have to do away with the __wakeup() and __sleep() magic methods. So, the class implementing this interface does not need these magical functions to be defined. The Serializable interface has 2 abstract functions declared ( without their content body ) which means we must define their content body inside the class which implements this interface. These function have the following signatures :: 

// To get the String representation of our Object
abstract public string serialize ( void ) 

// To Construct our object back from the string
abstract public void unserialize ( string $serialized_data )

When the object needs to be serialized, the serialize() method is called. Similarly, when a new object ( of a particluar Class, and that Class Name is known as it (class name) was stored in the String Representation ) needs to be restored, the constructor __construct() is not automatically called; instead the unserialize() function is called as a working constructor. If we need to run the __construct(), we may call it explicitly ( self::__construct(); ) inside the unserialize() function.

So, let's check an example :

<?php
// Our class is implementing the
// Interface Serializable
class MyClass implements Serializable 
{
// Private Data
private $data1;
private $data2;

// Protected Data
protected $data3;
protected $data4;

// Public Data
public $data5;
public $data6;


// Constructor called
public function __construct()
{
   echo "<br> Constructor called";
 $this->data1 = "100";  
   $this->data2 = "200";  
   $this->data3 = "300";  
 $this->data4 = "400";  
 $this->data5 = "500";  
 $this->data6 = "600";  
 
 }

// Serialize function
public function serialize()
{
 echo "<br>Serialize called";
 
 // Return the serialized data
 return serialize(
    array( "data10" => $this->data1,
   "data20" => $this->data2,
"data30" => $this->data3,
"data40" => $this->data4,
"data50" => $this->data5,
"data60" => $this->data6,
 ));
}

// Unserialize function
public function unserialize($data)
{
 // We can call __construct explicitly
 // self::__construct();
 
 echo "<br>unSerialize called";
 
 // Unserialize
 $d = unserialize($data);
 
 // Re-Construct the Object
 $this->data1 = $d['data10'];
 $this->data2 = $d['data20'];
 $this->data3 = $d['data30'];
 $this->data4 = $d['data40'];
 $this->data5 = $d['data50'];
 $this->data6 = $d['data60'];
}

// display() function
function display()
{
  for($i=1;$i<=6;$i++)
    {
      echo "<br>" . $this->{"data$i"} ;
    }
 }

}

// Create a new Object
$obj = new MyClass;

// Serialize the Object
$ser = serialize($obj);

// Check the Serialize Data
var_dump($ser);

// Create new Object from Serialized data
$p   = unserialize($ser);

// Check the Object
var_dump($p);

// Call Public method on Object
$p->display();
?>

The code above is quite self-explanatory through its comments. Let's check out the output of the above code.

Constructor called
Serialize called
string 'C:7:"MyClass":144:{a:6:{s:6:"data10";s:3:"100";s:6:"data20";s:3:"200";s:6:"data30";s:3:"300";s:6:"data40";s:3:"400";s:6:"data50";s:3:"500";s:6:"data60";s:3:"600";}}' (length=164)

unSerialize called
object(MyClass)[2]
  private 'data1' => string '100' (length=3)
  private 'data2' => string '200' (length=3)
  protected 'data3' => string '300' (length=3)
  protected 'data4' => string '400' (length=3)
  public 'data5' => string '500' (length=3)
  public 'data6' => string '600' (length=3)

100
200
300
400
500
600

Let's analyse the output.

1. When $obj object was created, the respective constructor was called printing "Constructor called" on screen.
2. Next, when serialize() function is called upon the object $obj, the member method serialize() is called generating the message "Serialize called". 
3. The 3rd line in the output is the result of serialization of object properties. 
4. Next, we issue the statement $p = unserialize($ser); to unserialize the serialized data and create our new object $p. Hence "unSerialize called" message is displayed on screen.
5. var_dump( $p ) generates the couple of lines next, showing all the properties (and their values) within the object $p.
6. Next, when we call a public display() method in object $p, it iterates through all the properties inside the object and prints their values.

Serialization / Unserialization in PHP - II

We have seen serialization/unserialization of common types in article : Serialization / Unserialization in PHP - I

Here, we would see object serialization. When objects are serialized, PHP looks for a member function __sleep() within the object before it actually does the serialization. So, we can write various clean-up jobs ( like close file pointers, close DB connections, close any open sockets, close any streams, free any used memory, free unused variables, destroy other related objects etc ) inside this function __sleep(). We need to remember that all the private and public properties inside object are serialized.

Similarly, when the serialized format is restored to Object through the function unserialize(), PHP calls __wakeup() member function (if exists) after it is finished with re-constructing the object. We can write various jobs ( restore DB connections, open files which the object works with etc ) inside this function __wakeup(). 

Let's check a code where object is serialized. 

<?php
// Define a Class
class MyClass  
{
    // private properties
    private $data1;
    private $data2;

    // protected properties
    protected $data3;
    protected $data4;

    // public properties
    public $data5;
    public $data6;

    public function __construct()
    {
      // Initialize private properties
      $this->data1 = "\r\n";  
      $this->data2 = NULL;  
      
      // Initialize protected properties
      $this->data3 = NULL;  
      $this->data4 = "400";  
 
      // Initialize public properties
      $this->data5 = "500";  
      $this->data6 = "600";  
    }

    // __sleep() 
    public function __sleep()
    {
echo "__Sleep called";
 
        // within __sleep(), all the clean-up jobs
        // can be included. Along with that, it also
        // needs to return name of the properties 
        // to be serialized in an array format
return array("data1", "data2", "data3", "data4", "data5", "data6");
    
    }

    // __wakeup
    public function __wakeup()
    {
       echo "__wakeup called";
    }

    public function display()
    {
        // Display all the properties
        // We used a simple Loop
for($i=1;$i<=6;$i++)
{
         echo "<br>" . $this->{"data$i"} ;
}

    }
}

// Create Object
$obj = new MyClass;

// Serialize it
$ser = serialize($obj);

// See what happened after serialization
echo "$ser";

// Unserialize it to restore the 
// data/properties in a new object
$p   = unserialize($ser);

// $p is the new Object, hence
// call a member function
$p->display();
?>

The above code defines a class called "MyClass", which includes 3 private and 3 public properties and __wakeup(), __sleep() methods. It also includes a method called display() which shows the values in all the properties. The __wakeup() method should return all the properties which need to be serialized within an array. The __wakeup() function does not have such restrictions.

The above program can run without the __sleep() and __wakeup() methods. In that case the clean-up jobs etc can't be defined and we can't define/select properties which need to be serialized. In that case PHP serializes all the properties within that object.

When serializing the private properties within the object, the class name is  prepended to the property name. Protected properties get an asterisk '*' prepended to their names. Such prepended values have Null bytes padded on both sides.

The code above produces 2 outputs, first is the serialized text of the object, second a list of property values in object $p which is created during the unserialization process of the stored representation we generated when $obj was serialized. Let's check the first output rendered on browser.

O:7:"MyClass":6:{s:14:"MyClassdata1";s:2:" ";s:14: "MyClassdata2";N;s:8:"*data3";N;s:8:"*data4";s:3:"400"; s:5:"data5";s:3:"500";s:5:"data6";s:3:"600";}

O:7:"MyClass":6: means Object having name "MyClass" (length:7) with 6 properties

s:14:"MyClassdata1";s:2:" "; means private property "MyClassdata1" (string, length:14) holds a string (length:2) value " ". Class name "MyClass" is prepended to Private properties. The value " " is text representation rendered on browser, actually it contains '\r\n'. As class name "\0MyClass\0" (padded by Null bytes on both side) was prepended to "data1" making it to "\0MyClass\0data1", the length of the new string is 14 ( 12 of "MyClassdata1" + 2 NULL bytes ) .

s:14:"MyClassdata2";N;        means private property "MyClassdata2" (string length 14) holds a NULL value;
s:8:"*data3";N;                          means protected property "*data3" (string length 8 including NULL bytes on both side) holds NULL value
s:8:"*data4";s:3:"400";      means protected property "*data4" holds string (length:3) value "400" 
s:5:"data5";s:3:"500";         means public property "data5" holds string (length:3) value "500" 
s:5:"data6";s:3:"600";         means public property "data6" holds string (length:3) value "600" 

Next part of the program is the unserialization part where we call the unserialize() function to restore an object from the stored representation $ser. And as a result, we create new object $p of type "MyClass" (The serialized data starts with "O:7:"MyClass"). Hence the call $p->display() calls the member function display() which iterates through all the properties inside the $p object and prints them on screen.

In such cases where object of undefined class to be created during unserialization, it creates object of "stdClass". Check the example below :

<?php
// an Array is being converted to Object
$o = (object) array("name" => "chandan");

// Serialize 
$ser = serialize($o);

// Unserialize would instatiate
// Object of class PHP default 'stdClass'
$po = unserialize( $ser );

// Print the new object details
var_dump($po);

// Access member properties
echo "Hello {$po->name}";
?>

The above code is quite self-explanatory. It produces the following output :: 

object(stdClass)[2]
  public 'name' => string 'chandan' (length=7)

Hello chandan

$po is an object of PHP built-in class 'stdClass' with a public member "name" and this property holds a string value "chandan". So, when $po->name is referred, it prints the correct value as unserialize() correctly re-constructed object from stored representation.

Serialization / Unserialization in PHP - I

Through Serialization, we can produce a storable representation of a value. PHP offers serialize() function which accepts value of any type except resource type. The serialize() function can accept arrays also. Array/Objects with circular references ( means some values reference to others within the array or objects ) can also be serialized. The serialize() function returns a byte-stream representation of the value and this may include NULL bytes and in case NULL bytes are serialized, it is better to store the serialized representation in BLOB field within Database. If we try to save it in CHAR, VARCHAR or TEXT type fields, those NULL bytes will be removed.

The reverse process i.e converting the serialized format to respective PHP value ( including array/object ), is called unserialization. PHP offers unserialize() function for unserialization.

Now check an example ::

<?php
// Define same Variables
$i = 100;
$j = true;
$k = "sample text";
$l = array("name" => "John", "age" => 23, "salary" => 103.25, "is_adult" => true );

// Serialize and store in other variables
$ii = serialize($i); 
$jj = serialize($j);
$kk = serialize($k);
$ll = serialize($l);

// Print Serialized data
echo "<b>Serialization returns storable strings ::</b><br>";
echo "$ii $jj $kk $ll <br>";

// Unserialize
echo "<b>Unserialization restores :: </b><br>";

// Print what we got after unserialization
echo unserialize($ii) . "<br>";
echo unserialize($jj) . "<br>";
echo unserialize($kk) . "<br>";

// print_r used to print the array
print_r( unserialize($ll) );  
?>

In the above program, we defined some variables of type integer, boolean, string and array and we called the serialize() function on each of them and stored the results in other variables. Next, we called unserialize() function to restore original data from the serialized representation.

Check the output :: 

Serialization returns storable strings ::
i:100; 
b:1; 
s:11:"sample text"; 
a:4:{s:4:"name";s:4:"John";s:3:"age";i:23;s:6:"salary";d:103.25;s:8:"is_adult";b:1;} 

Unserialization restores :: 
100
1
sample text
Array ( [name] => John [age] => 23 [salary] => 103.25 [is_adult] => 1 ) 

See that serialize($i) generates a string like "i:100" which means integer value 100. 
Similarly, "b:1" means Boolean value 1
s:11:"sample text" means String with length: 11 and value: 'sample text'

Let's understand the serialized text a:4:{s:4:"name";s:4:"John";s:3:" age";i:23; s:6:"salary"; d:103.25;s:8:"is_adult";b:1;} created for array $l. Array's key and value - both are sequentially stored.

a:4 means array of 4 values. All the values are wrapped in curly braces.
s:4:"name";       => Key, String of length:4, key value:"name" 
s:4:"John";       => Value, String of length:4, value:"John"
s:3:"age";          => Key, String of length:3, key value:"age"
i:23;                      => Value, Integer 23
s:6:"salary";  => Key, String of length:6, key value:"salary"
d:103.25;            => Value, Double value 103.25
s:8:"is_adult"; => Key, String of length:8, key value:"is_adult"
b:1;                        => Value, Boolean value 1

Let's check some more serialized arrays.

<?php
// Array 1
$arr1 = array("John",20,103.5,true);

// Array 2
// See that the 3rd item would have index '11'
$arr2 = array(10=> "John", 9=> 20, 103.5, 1=>true);

// Array 3
$arr2 = array('name'=> "John", 'age'=> 20, 'is_adult'=>true);

echo unserialize($arr1);
echo unserialize($arr2);
?>

The first output of the above program is ::
a:4:{i:0;s:4:"John";i:1;i:20;i:2;d:103.5;i:3;b:1;}

As said earlier, array's key and value are stored sequentially. 

a:4:                          means array consists of 4 items.
i:0;s:4:"John" means integer key 0 holds string (length:4) value "John".
i:1;i:20                means integer key 1 holds integer value 20.
i:2;d:103.5        means integer key 2 holds double value 103.5.
i:3;b:1                  means integer key 3 holds boolean value true/1.

The 2nd output of the above program is ::
a:4:{i:10;s:4:"John";i:9;i:20;i:11;d:103.5;i:1;b:1;}

i:10;s:4:"John"; means integer Key/index '10' holds a string "John"
i:9;i:20;                  means integer Key/index '9' holds an integer value 20
i:11;d:103.5;        means integer Key/index '11' holds a double value 103.5

The 3rd output of the above program is ::
a:3:{s:4:"name";s:4:"John";s:3:"age";i:20;s:8:"is_adult";b:1;}

s:4:"name";s:4:"John"; means string (length:4) key "name" holds string value "John" (length:4)
s:3:"age";i:20;              means string (length:3) key "age" holds integer value 20
s:8:"is_adult";b:1;    means string (length:8) key "is_adult" holds boolean value true/1

The unserialize() function converts the stored representation to appropriate PHP value. This function returns FALSE if the passed string is not unserializable. 

Check out the next part of this article : Serialization / Unserialzation in PHP - II