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.

there are my lastest methods used to check if a contract has a function:

import _ from 'lodash';
import { Abi, Address, BaseError, ContractFunctionRevertedError, PublicClient } from 'viem';
import Web3 from 'web3';


/**
 * @description unable to penetrate proxy contracts
 * @param method The param need the format:```transferFrom(address,address,uint256)```
 */
export const isMethodExistA = async (web3: Web3, contractAddress: Address, method: string): Promise<boolean> => {
  try {
    const code = await web3.eth.getCode(contractAddress);
    const methodSignature = web3.eth.abi.encodeFunctionSignature(method);

    return code.indexOf(methodSignature.slice(2, methodSignature.length)) > 0;
  } catch (e: any) {
    return false;
  }
};


/**
 * @description unable to penetrate proxy contracts
 * @param method The param need the format:```{
    inputs: [],
    name: 'getOwners',
    outputs: [{ internalType: 'address[]', name: '', type: 'address[]' }],
    stateMutability: 'view',
    type: 'function'
  }```
 */
export const isMethodExistB = async (web3: Web3, contractAddress: Address, method: any): Promise<boolean> => {
  try {
    const code = await web3.eth.getCode(contractAddress);
    const methodSignature = web3.eth.abi.encodeFunctionSignature(method);

    return code.indexOf(methodSignature.slice(2, methodSignature.length)) > 0;
  } catch (e: any) {
    return false;
  }
};


/**
 * @description can penetrate proxy contracts
 * @param methodABI The param need the format:```[{
    inputs: [],
    name: 'getOwners',
    outputs: [{ internalType: 'address[]', name: '', type: 'address[]' }],
    stateMutability: 'view',
    type: 'function'
  }]```, and perform const assertion, that is ```const [] as const```
 */
export const isMethodExistC = async (
  publicClient: PublicClient,
  contractAddress: Address,
  methodABI: Abi,
  functionName: string,
  args?: any[]
) => {
  try {
    const ret = await publicClient.simulateContract({
      address: contractAddress,
      abi: methodABI,
      functionName: functionName,
      args: args,
    });
    return true;
  } catch (e: any) {
    if (e instanceof BaseError) {
      if (e.cause instanceof ContractFunctionRevertedError) {
        return true;
      }
    }
    return false;
  }
};

There are some examples using the above methods:

import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import Web3 from 'web3';

const web3 = new Web3('https://eth-mainnet.g.alchemy.com/v2/...');
const publicClient = createPublicClient({
  chain: mainnet,
  transport: http('https://eth-mainnet.g.alchemy.com/v2/...'),
});

isMethodExistA(
  web3,
  '0x791250f047ae1de09f2a9ab98eec91caa9bf0a2d',
  'execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,bytes)'
).then((ret) => console.log('ret:', ret));

isMethodExistB(web3, '0xd9db270c1b5e3bd161e8c8503c55ceabee709552', {
  inputs: [
    { internalType: 'address', name: 'to', type: 'address' },
    { internalType: 'uint256', name: 'value', type: 'uint256' },
    { internalType: 'bytes', name: 'data', type: 'bytes' },
    {
      internalType: 'enum Enum.Operation',
      name: 'operation',
      type: 'uint8',
    },
    { internalType: 'uint256', name: 'safeTxGas', type: 'uint256' },
    { internalType: 'uint256', name: 'baseGas', type: 'uint256' },
    { internalType: 'uint256', name: 'gasPrice', type: 'uint256' },
    { internalType: 'address', name: 'gasToken', type: 'address' },
    {
      internalType: 'address payable',
      name: 'refundReceiver',
      type: 'address',
    },
    { internalType: 'bytes', name: 'signatures', type: 'bytes' },
  ],
  name: 'execTransaction',
  outputs: [{ internalType: 'bool', name: 'success', type: 'bool' }],
  stateMutability: 'payable',
  type: 'function',
}).then((ret) => console.log('ret:', ret));

const execTransactionABI = [
  {
    inputs: [
      { internalType: 'address', name: 'to', type: 'address' },
      { internalType: 'uint256', name: 'value', type: 'uint256' },
      { internalType: 'bytes', name: 'data', type: 'bytes' },
      {
        internalType: 'enum Enum.Operation',
        name: 'operation',
        type: 'uint8',
      },
      { internalType: 'uint256', name: 'safeTxGas', type: 'uint256' },
      { internalType: 'uint256', name: 'baseGas', type: 'uint256' },
      { internalType: 'uint256', name: 'gasPrice', type: 'uint256' },
      { internalType: 'address', name: 'gasToken', type: 'address' },
      {
        internalType: 'address payable',
        name: 'refundReceiver',
        type: 'address',
      },
      { internalType: 'bytes', name: 'signatures', type: 'bytes' },
    ],
    name: 'execTransaction',
    outputs: [{ internalType: 'bool', name: 'success', type: 'bool' }],
    stateMutability: 'payable',
    type: 'function',
  },
] as const;

isMethodExistC(publicClient, '0x29469395eaf6f95920e59f858042f0e28d98a20b', execTransactionABI, 'execTransaction', [
  '0xfec7443780F800601118288dEd58D339Fd06dAC4',
  33,
  '0x4444',
  0,
  33,
  33,
  33,
  '0xfec7443780F800601118288dEd58D339Fd06dAC4',
  '0xfec7443780F800601118288dEd58D339Fd06dAC4',
  '0x233',
])
  .then((exist) => console.log('execTransaction exist:', exist))
  .catch((e) => console.log('execTransaction err:', e.message));

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).

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;
}