With your currently defined variables, you can loop through all the existing store items until you've found the corresponding item, and then update it. If there's no corresponding item, you can create a new one:

function addProduct(uint id,  uint quantity) public {
    // loop through all `store` items until the item with the corresponding ID is found
    for (uint i; i < store.length; i++) {
        if (store[i].id == id) {
            // corresponding item found - update quantity and early return
            store[i].quantity += quantity;
            return;
        }
    }

    // no corresponding item found (the early return didn't invoke) - add the product to the store
    store.push(Store(id, quantity));
}

However, the code above is very inefficient and expensive to run gas-wise. So I'd recommend to add a mapping of existing product IDs to the store array indexes. Then you can simply query the mapping and get the resulting info whether the product ID exists (the value of the mapping is non-zero) or not:

mapping (uint => uint) productIdToArrayIndex;

function addProduct(uint id,  uint quantity) public {
    uint arrayIndex = productIdToArrayIndex[id];
    if (arrayIndex > 0) {
        // the product is stored in the `store[arrayIndex]`
        store[arrayIndex].quantity += quantity;
    }

    // no corresponding item found - add the product to the store, and add their index to the mapping
    store.push(Store(id, quantity));
    productIdToArrayIndex[id] = store.length - 1;
}

There are two approaches.

You can create a view function (docs) that loops through the array and returns true if the item is found. Mind that a view function can be invoked using a gas-free read-only call instead of a (read-write) transaction costing gas fees.

function exists1(uint num) public view returns (bool) {
    for (uint i = 0; i < numbers1.length; i++) {
        if (numbers1[i] == num) {
            return true;
        }
    }

    return false;
}

This approach has a linear complexity. So if you need to validate the value existence during a transaction, it might be costly depending on the total amount of items in the array.

So there's a second approach - duplicate the values as keys of a mapping (docs) that can be accessed directly through its key. There's a constant complexity to search the value but it costs double to store the value.

uint[] numbers1;
mapping(uint => bool) public exists1; // default value for each key is false

function push1(uint num1, uint num2, uint num3) public {
    numbers1.push(num1);
    numbers1.push(num2);
    numbers1.push(num3);

    exists1[num1] = true;
    exists1[num2] = true;
    exists1[num3] = true;
}

You can use an explicit exists field:

pragma solidity ^0.4.24;

contract MyContract {

  struct Person {
    uint age;
    uint size;
    bool exists;
  }

  // Index of a person is its ID.
  Person[] persons;

  event PersonAdded(uint indexed id, uint age, uint size);

  function addPerson(uint _age, uint _size) public {
    Person memory person = Person(_age, _size, true);
    id = persons.push(person) - 1;

    emit PersonAdded(id, _age, _size);
  }

  function removePerson(uint _id) public {
    require(persons[_id].exists, "Person does not exist.");

    delete persons[_id];
  }
}

In order to avoid For loops, You can add another mapping to check if a user exists or not. You can add mapping(string => bool) userExists; so your whole code will look like this:

pragma experimental ABIEncoderV2;


contract structWithMapping{

    struct Data{
        string[] user;
        string[] catagory;
        string[] data;
    }


    mapping(string => Data) mappedData;
    mapping(string => bool) userExists;

    string[] public dataArray;

    function setUserData(string _user, string _catagory, string _data)public{
        var addData = mappedData[_user];


        addData.user.push(_user);
        addData.catagory.push(_catagory);
        addData.data.push(_data);

        require(!userExists[_user]);
        dataArray.push(_user) -1;
        //dont forget to set the mapping value to true for userExists
        userExists[_user] = true;
    }

    function getUsers() view public returns(string[]){
        return dataArray;
    }

    function getUserData(string _user) view public returns(string[] memory, string[] memory, string[] memory){
        return(mappedData[_user].user, mappedData[_user].catagory, mappedData[_user].data);
    }
}

There's no such thing as "existence" in a Solidity mapping.

Every key maps to something. If no value has been set yet, then the value is 0.

For your use case, hashstructs[n].fhash > 0 is probably sufficient. If you want to be explicit, add a bool exists to your struct and set it to true when you add something. Then use hashstructs[n].exists to check for existence.

You can take a look at this source that explains the two approaches: (1) using view functions to loop through an array and return true if item exists with O(n) complexity or (2) duplicate the value as keys of a mapping that can be accessed directly through its key with O(1) complexity.

https://stackoverflow.com/questions/71226909/how-to-check-if-one-value-exists-in-an-array

The entire storage space is virtually initialized to 0. There is no undefined. So you have to compare the value to the 0-value for your type. For example mapping[key] == address(0x0) or mapping[key] = bytes4(0x0).

Solidity provides no obvious way to do this.

One can contemplate an iterative process to search the list, but the gas cost will increase with the size of the list. This puts an upper bound on the size of the list; either by increasing transaction cost to an unacceptable level, or by exceeding the block gas limit so transactions can't run at all.

There are (at least) two general solutions.

1. Invert control so the client performs the iterative operation and interrogates contract functions one row at a time. It's possible to expose indexed lists (searchable) with event emitters. That may help, but in any case, performance will suffer with list size.

2. Use a mapping to facilitate random access in a single step.

Since mappings can't be enumerated and it's not possible to know how many keys have been set or what they are, it may be necessary to devise a system of pointers using both arrays and mappings to produce a "list" of randomly accessible items.

Have a look here for a pattern and better explanation: https://bitbucket.org/rhitchens2/soliditycrud/overview

Hope it helps.

There is an error in your checkNoexists function. If you check any no other than first if(numbers[i]==no), this conditions executes to false for i=0 and returns false. The code is working as it should, your logic is incorrect. Use this instead:

function checkNoExists (uint no) constant returns(bool){
    for(uint i=0; i<numbers.length; i++){
        if(numbers[i]==no){
            return true;
        }
    }
    return false;
}

Array myArray is dynamically sized. You cannot safely try to access an element with an arbitrary index using the [] operator, you first need to check if the index is out of bounds. Here is how you could change your function in contract A to achieve this:

function isIndexExists(uint256 index) public view returns (bool) {
  // If the index is out of bounds, then there is no such element
  if (index >= myArray.length) {
    return false;
  }
  
  // We know that there is an object with that index, so check its 'isExist' property
  return myArray[index].isExist;
}

BTW, note that when you are checking some expression that returns a boolean, you can directly return that value. You don't need the redundant if-else, which takes 5 lines compared to this approach which only takes one line of code.

Have a look here: Are there well-solved and simple storage patterns for Solidity?

You could.

function isMember(uint index) public view returns(bool isIndeed) {
  return members[index].exists;
}

It's preferable to throw an error on an unacceptable state change rather than return false in most situations. So ...

function addBalance(uint index) public returns(bool success) {
  require(isMember(index);
  members[index] += msg.value; // (or _balance if you prefer)
  return true;
}

If there is a good reason to return false and carry on:

function addBalance(uint index) public returns(bool success) {
  if(!isMember(index) return false;
  if(isMember(index)) member[index] += msg.value;
  return true;
}

In my opinion it's almost always better to use the member address as the key instead of storing the structs in numbered rows. Like that, using arbitrary amounts instead msg.value as in your example:

pragma solidity ^0.4.24;

contract MembersContract {

    struct Member {
        uint balance;
        bool exists;
    }

    mapping(address => Member) public members;

    function isMember(address member) public view returns(bool isIndeed) {
        return members[member].exists;
    }

    function addMember(address member) public returns(bool success) {
        require(!isMember(member));
        members[member].exists = true;
        return true;
    }

    function addBalance(address member, uint amount) public returns(bool success){
        require(isMember(member));
        members[member].balance += amount;
        return true;
    }
}

Hope it helps.

You can make a mapping of addresses to structs and include a boolean in the struct.

Be sure to check this pattern: https://medium.com/robhitchens/solidity-crud-part-1-824ffa69509a

Hope it helps.

With arrays. only options is to iterate over the array and check if number is present. This will become expensive as array size grows.

Another options is to maintain an array as well as a mapping.

You can check cost of maintaining and array and a mapping for numbers.

• Array provides capability of iteration
• With mapping, you can check presence of a number in O(1)

It does increase storage cost by 2X, so you have to implement it and compare with iteration to estimate cost for your usecase.

Example of iteration :

pragma solidity ^0.5.2;


contract ArrayTest {
    uint [] public numbers;
    function getNumberCount() public view returns(uint count) {
        return numbers.length;
    }
    function addIfNotPresent(uint num) public{
        uint arrayLength = numbers.length;
        bool found=false;
        for (uint i=0; i<arrayLength; i++) {
            if(numbers[i]==num){
                found=true;
                break;
            }
        }
        if(!found){
            numbers.push(num);
        }
    }
}

Solidity doesn't provide a contains method, you'd have to manually iterate and check.

Using an array for what you're trying to achieve would be a highly inefficient pattern. The best and most cost efficient method is use a mapping data structure. Set the key to be the address and the value to be a boolean. Lists that are too long have the possibility of running out of gas when you're trying to iterate over them.

If you need to iterate through all the keys in the mapping, then you'd need to have an external database to get all the keys. The database can be populated and updated based on events from the smart contract (i.e. an event when the address is added or removed).