Thursday, 1 August 2024

Deleting an Element from an Array in PHP

If you’re working with PHP and need to delete elements from an array, you’ve come to the right place. PHP offers several methods for removing elements from arrays, whether you’re dealing with indexed or associative arrays. This blog post will explore various techniques for deleting elements from arrays, ensuring that the removed items are no longer included when iterating through the array.

Read more »

Labels:

Thursday, 10 October 2024

How to Determine if a PHP Array is Associative or Sequential

In PHP, arrays are flexible and can act as both indexed arrays (or “sequential” arrays) and associative arrays. However, PHP treats all arrays as associative by default. So, how can you differentiate between an associative array and a sequential array?

An associative array uses string keys, while a sequential array uses numeric keys starting from 0 and increasing sequentially. In this blog post, we’ll explore a few different ways to check whether a given array is associative or sequential, using practical examples and approaches that avoid expensive operations.

Read more »

Labels:

Thursday, 9 January 2025

How to Check if an Array Includes a Value in JavaScript: The Modern Way


When working with JavaScript arrays, one of the most common tasks is to check whether a certain value exists within an array. Historically, this required writing loops or using methods that were not always intuitive. However, modern JavaScript provides more concise and readable solutions. Let’s explore the best methods for checking if an array contains a value and why you should use them.

1. The Modern Way: Array.prototype.includes()

Starting with ECMAScript 2016 (ES7), JavaScript introduced the includes() method, which is the easiest and most efficient way to check if an array contains a value. It is widely supported by all modern browsers, except for older versions of Internet Explorer.

Read more »

Labels:

Wednesday, 6 November 2019

perl - array and hash common differences

     S.No
                             ARRAYS
                           HASHES

         1.

         2.


         3.

          
          4.

     
          


          5.

          



         6.





           7.


           
         8.


















          

        9.






      10.









      11.




     12.



      13.






       14.






       15.

It is ordered data collection

Data Can be accessed based on index value

Stack operations performed using push,pop,shift,unshift

Duplicate Elements will be exist in Array




For Large data, Arrays will not be in speed as getting values from hash keys.


Arrays can be created using () brackets @array=(1,3,5,6,2);
For More methods refer this link.

for accessing array index
$array[1];


Array can be accessed in loops as below

1.For(@array)
{
}

2.foreach(@array1,@array2)
   {
       Print $_;
   }

3.print grep{},@array;

4. print map{},@array;







Array slices can be used as below
@array[2];





To find length of an array


 $#array+1;
       or
scalar(@array);
      or
$a=@array;


For Emptying Array
$#array = -1;
     or
@array = ( );

To reverse an array
print reverse @array;


To sort array Elements
ascending order
@a=sort{$a <=> $b }@array;
desending order
@a=sort{$b <=> $a }@array;


To add array elements
$array[0]='55';




To Delete array elements
delete $array[1];
 
It is unordered Data Collection

Data Can be accessed based on Key value

Stack operations cannot be performed


Keys will not have Duplicate elements but Values would have Duplicate elements.

Based on hash Keys Data retrival would be fast


Hash is also possible to create using () bracket %hash=(1,3,5,6,2);
For More methods refer this link.
https://kaavannan-perl.blogspot.com/2019/10/perl-hashes-what-is.html


For accessing hash index use the key name
$hash{1};


Hash can be accessed based on keys and values


While(($k,$vals) = each %h)
{
    Print “$k,$vals\n”;
}

Foreach $k (keys %h)
{
Print “$k => $hash{$k}\n”;
}

Foreach $values (values %hash)
{
Print “$values\n”;
}



Hash slices can be used as below,
$hash{'1'}







To find length of hash

@array=keys %hash;
scalar(@array);
     or
$#array+1;
     or
$a=@array;



For Emptying hash
%hash=( );




To reverse a hash
print reverse %hash;



To sort hash elements

 foreach $k (sort keys %hash)
{
   print "$k => $hash{$k}\n";
}



To add hash Elements
$hash{1}='one';





To Delete hash elements
delete($hash{'1'});


Labels:

Monday, 30 January 2023

Perl Data Structures - Arrays of Arrays

Creating Arrays of Arrays:

Method 1:

 @array=(["apple","orange"],["Mango","Banana"],["Papaya","Peach"]);

 print $array[0][1];

Read more »

Labels:

Tuesday, 10 September 2019

How Many Possible ways to remove Duplicates in an array using perl?


Method 1:

sub filter {
    my %hash;
    grep !$hash{$_}++, @_;
}

my @array = qw(e f g h i);
my @final= filter(@array);


Method 2:

use List::MoreUtils qw(uniq);
my @array = qw(1 1 1 2 3 4 4);
my @final= uniq(@array);


Method 3:

my %hash = ();
foreach my $item (@array)
{
    $hash{$item}++;
}
my @final = keys %hash;


Method 4:

my @array=qw( 3 2 3 4 4 3 2);
my @final=keys %{{ map{$_=>1}@array}};
print join ' ', sort{$a<=>$b} @final;


Method 5:

%hash=();
my @array = qw(e j g h i);
@final = grep { ! $hash{$_} ++ } @array;


Method 6:

my @array;
my @finals;

foreach my $var ( @array )
{
    if (! grep(/$var/, @finals ))
    {
          push( @finals, $var );
     }
}


Method 7:

my @array = qw(e f g h i);
my %hash;
@hash{@array}=(1..@array);
@final=keys%hash;


Method 8:

my @final = keys {map {$_ => 1} @array};


Method 9:

@array = qw(e f g h i);
%hash1   = map { $_ => 1 } @array;
@final = keys %hash1;


Method 10:
my @array = qw(e f g h i);
my %hash;
foreach my $v (@array){
        $hash{$v}=1;
}
@final=keys%hash;


kaavannan perl blogspot

Labels: , ,

Friday, 19 March 2021

perl data structures tutorial - part1

Perl provides a rich set of data structures that can be used to store and manipulate data. In this tutorial, I'll cover the most commonly used data structures in Perl, along with code examples.

Arrays

Arrays are ordered lists of scalar values. To declare an array, you use the @ symbol followed by the array name. Here's an example:

@my_array = (1, 2, 3, 4, 5);


You can access individual elements of the array using the array name followed by the index of the element in square brackets. Here's an example:

print $my_array[0]; # prints 1


You can also use the scalar function to get the number of elements in an array:

print scalar(@my_array); # prints 5


Read more »

Labels:

Thursday, 5 September 2024

Removing Duplicates from an Array in Perl

When working with arrays in Perl, you might encounter situations where you need to remove duplicate elements. Perl, with its versatile data structures, offers several ways to accomplish this task. Let’s explore different approaches to remove duplicates from an array, demonstrating the flexibility and power of Perl.

Approach 1: Using a Hash to Filter Unique Elements

One of the simplest and most efficient ways to remove duplicates from an array is by using a hash. Hashes in Perl inherently prevent duplicate keys, which makes them ideal for this task.

Read more »

Labels: