Forem: AZIZ NAJLAOUI

pointer of a pointer in c

AZIZ NAJLAOUI — Fri, 31 Jan 2025 16:46:21 +0000

Did you know that variables have addresses in memory? Imagine a variable as a home—it contains a value and an address. A pointer is a variable that stores the address of another variable.

To initialize a pointer, we need to specify the type of variable it will point to:

int *p;

Here, p is declared as a pointer to an integer.

Assigning an Address to a Pointer

We use the address-of operator (&) to assign the address of a variable to a pointer:

int x = 5;
p = &x;

If we print p, it will output a random-looking number—this is the memory address of x. However, if we print p, we get the value stored at that address (which is 5). This operation is called **dereferencing.*

printf("I'm p, the address of x: %p\n", p); // Address of x
printf("I'm *p, the value of x: %d\n", *p); // 5

Note: When printing memory addresses, it's better to use %p instead of %d.

Modifying a Variable Through a Pointer

*p = 20;
printf("%d", x); // 20

This means that changing *p also changes x.

Pointer to a Pointer (Double Pointer)

Even a pointer has its own memory address, and we can store that address in another pointer! To initialize a pointer that holds the address of another pointer, we write:

int **q;
q = &p;

The first * indicates that q is a pointer.
The second * means that q stores the address of another pointer.

Accessing Values Using a Double Pointer

Since q holds the address of p,

*q is the value inside p, which is the address of x.
**q is the value of x.
More simply:
q → Address of p.
*q → Value inside p (which is &x).
**q → Value inside x (which is 5).
Final Code

#include <stdio.h>

int main() {
    int *p;
    int x = 5;

    p = &x;

    int **q;
    q = &p;

    printf("I'm q, the address of p: %p\n", q);
    printf("I'm the address of p: %p\n", &p);
    printf("I'm the value of p (the address of x): %p\n", *q);
    printf("I'm the address of x: %p\n", &x);
    printf("I'm the value of x: %d\n", x);
    printf("I'm the value of the variable with address p (so I'm x): %d\n", **q);

    return 0;
}

[Boost]

AZIZ NAJLAOUI — Fri, 31 Jan 2025 16:03:36 +0000

Understanding "this" in JavaScript and its behavior in various scenarios

Richa ・ Jan 29

#javascript #webdev #beginners #learning

6 Must Know JavaScript Array Methods

AZIZ NAJLAOUI — Wed, 22 Jan 2025 20:25:59 +0000

1. Filter
The filter method creates a new array containing only the elements that pass a specified condition. If the condition is true, the element stays in the array; otherwise, it is removed.

How It Works:

The method checks each element in the array.
If the callback function returns true, the element is included in the new array.
If it returns false, the element is excluded.

let boxers = [
    { name: "Tyson Fury", weight: 280 },
    { name: "Mairis Briedis", weight: 199 },
    { name: "Artur Beterbiev", weight: 175 },
    { name: "Jermall Charlo", weight: 160 },
    { name: "Terence Crawford", weight: 146 }
];

// Remove boxers with weight under 170
boxers = boxers.filter(function (boxer) {
    return boxer.weight > 170;
});

// Using arrow function for brevity
boxers = boxers.filter(boxer => boxer.weight > 170);

console.log(boxers);

Output:

[
    { name: "Tyson Fury", weight: 280 },
    { name: "Mairis Briedis", weight: 199 },
    { name: "Artur Beterbiev", weight: 175 }
]

2. Map
The map method creates a new array by applying a specified transformation to each element of the original array. Each element in the new array is replaced by the return value of the callback function.

How It Works:

The method iterates through each element in the array.
It applies the transformation logic defined in the callback function.
The result of the callback function replaces the original element in the new array.

Example:

let decimalNumbers = [222, 354, 4684, 123, 5];

// Convert decimal numbers to hexadecimal
let hexNumbers = decimalNumbers.map(function (num) {
    return num.toString(16);
});

// Using arrow function for brevity
hexNumbers = decimalNumbers.map(num => num.toString(16));

console.log(hexNumbers);

3. Reduce
The reduce method is used to reduce an array to a single value by applying a callback function to each element and accumulating the result.
How It Works:

The method iterates over the array.
It applies the callback function to an accumulator and the current element.
The result of the callback becomes the new accumulator value.
The final accumulator value is returned. Example:

let numbers = [1, 2, 3, 4, 5];

// Find the sum of all numbers
let sum = numbers.reduce(function (accumulator, current) {
    return accumulator + current;
}, 0); // 0 is the initial value of the accumulator

// Using an arrow function for brevity
sum = numbers.reduce((accumulator, current) => accumulator + current, 0);

console.log(sum); // Output: 15

4. Some
The some method checks if at least one element in the array passes a specified condition. It returns true if any element satisfies the condition and false otherwise.

How It Works:

The method iterates through the array.
It stops and returns true as soon as it finds an element that passes the condition.
If no element passes, it returns false. let ages = [16, 20, 14, 18];

// Check if there is at least one adult (age ≥ 18)
let hasAdult = ages.some(function (age) {
    return age >= 18;
});

// Using an arrow function for brevity
hasAdult = ages.some(age => age >= 18);

console.log(hasAdult); // Output: true

`5. Every
The every method checks if all elements in the array pass a specified condition. It returns true only if all elements satisfy the condition; otherwise, it returns false.

How It Works:

The method iterates through the array.
If it finds an element that fails the condition, it stops and returns false.
If all elements pass, it returns true. let scores = [80, 85, 90, 95];

`
// Check if all scores are above 75
let allAbove75 = scores.every(function (score) {
return score > 75;
});

// Using an arrow function for brevity
allAbove75 = scores.every(score => score > 75);

console.log(allAbove75); // Output: true
`
6. Includes

The includes method checks if an array contains a specific value. It returns true if the value exists in the array and false otherwise.
How It Works:

The method checks for the value in the array.
It uses strict equality (===) for comparison.
It can also check for specific values starting from a given index. Example:

`
let numbers = [1, 2, 3, 4, 5];

// Check for "3" starting from index 2
let includesThree = numbers.includes(3, 2);

console.log(includesThree); // Output: true

string.indexOf() under the hood

AZIZ NAJLAOUI — Thu, 16 Jan 2025 22:42:50 +0000

Hello Developers,

Today, I was trying to implement the indexOf() method from scratch. So far, this is what I've found:

function myIndexOf(string, target, start = 0) {
    let l = target.length;

    // Adjust the start index if it's negative
    if (start < 0) {
        start = (string.length + start % string.length) % string.length;
    }
    console.log(start);

    // Loop through the string, looking for the target
    for (let i = start; i <= string.length - l; i++) {
        if (string.substr(i, l) === target) {
            return i;
        }
    }

    // Return -1 if the target isn't found
    return -1;
}

console.log(myIndexOf("search me in me", "me", -34));

Code Explanation:
The indexOf() method accepts three parameters:

1.string: The string in which we are searching.
2.target: The substring we are looking for.
3.start: The index where the search will begin (defaults to 0).

First Attempt:
My initial idea was simple: loop through the string, and when I find string[i] === target, return i. If no match is found by the end of the loop, return -1. The code looked like this:

for (let i = 0; i < string.length; i++) {
    if (string[i] === target) {
        return i;
    }
}
return -1;

However, this approach only works when the target is a single character, since we're comparing character by character.

Second Attempt:
I then realized that if the target is longer than one character, I need to compare substrings. I used the substr() method to compare a substring of the same length as the target. The loop was adjusted to stop when there are enough characters left in the string to compare:

for (let i = 0; i < string.length - target.length + 1; i++) {
    if (string.substr(i, target.length) === target) {
        return i;
    }
}
return -1;

Third Attempt:
Next, I needed to handle the start parameter, which can be negative. The built-in indexOf() method starts searching from string.length + start when start is negative. For example, if the string length is 10 and the start is -4, the search will start at index 6 (i.e., 10 - 4).

To account for this, I updated the code to handle negative start values:

function myIndexOf(string, target, start = 0) {
    let l = target.length;

    if (start < 0) {
        start = Math.max(0, string.length + start);  // Adjust negative start
    }
    console.log(start);

    for (let i = start; i <= string.length - l; i++) {
        if (string.substr(i, l) === target) {
            return i;
        }
    }

    return -1;
}

Final Version:
Curious about handling start values greater than the string length, I decided to modify the function to keep "rolling around" the string if start exceeds the string length. This way, the function will continue searching from the appropriate index after wrapping around. The final solution uses this formula to adjust the start index:

start = (string.length + start % string.length) % string.length;

How It Works:

The modulo operation start % string.length ensures that start is within a range of -string.length to string.length.
Adding string.length ensures that any negative result becomes positive.
The final modulo operation ensures that the value of start is wrapped around and falls within valid index boundaries.

im thinking next to use binary search instead of the linear what do you think !

Fixing a "Show More / Show Less" Button with JavaScript

AZIZ NAJLAOUI — Tue, 31 Dec 2024 18:17:35 +0000

Hello developers! 👨‍💻👩‍💻
I'm a CS student and im learning javascript because i want to be a frontend developer , and today I wanted to share a concept I recently learned while making a simple "Show More / Show Less" button using JavaScript.
can you tell what the diffrence between the first code and the second
and witch one is true !!

I was trying to create a button that toggles the visibility of text, like this:

simple html 2 paragrah one of them with the class of text hidden-text
it the one we will toggle and a button that will do the job

<p>lorem ipsum dolor sit amet consectetur adipisicing elit. </p>
<p class="text hidden-text">fsdfsfsd .... </p> 
<button class="show-more">show more....</button>

css:

.hidden-text {
  display: none;
}

ive declared all the variable i need

let showButton = document.querySelector(".show-more");
let text = document.querySelector(".text");
let value = false; // Initially, the text is hidden

my first code was :

showButton.addEventListener("click", (value) => {
    value = !value;
    text.classList.toggle("hidden-text");
    showButton.textContent = value ? "show less..." : "show more..."; // Update button text
});

but this didn't work the value was always false even that i swithced using value=!value
after some search i found out why this happend

Every time the button was clicked, the local value parameter inside the callback function was being redeclared, which shadows the outer value.

that means that The outer value remains unchanged, always staying false.
and The local value is toggled inside the callback, but it only exists during that function's execution and doesn’t affect the outer value.

To solve this, I needed to remove the value parameter from the callback and directly use the outer value that persists across button clicks.

let value = false; // Persistent state variable

showButton.addEventListener("click", () => { 
    value = !value; // Toggle the outer value
    text.classList.toggle("hidden-text");
    showButton.textContent = value ? "show less..." : "show more..."; // Update button text based on value
});