The onBlur and onChange functions comming from register function are the exact same

[omardevelopsGit]

When logging register(...args) to the console the onBlur and onChange are the exact same.
Codesandbox: https://codesandbox.io/p/sandbox/admiring-sky-sqhrp3?file=%2Fsrc%2FInput.jsx%3A72%2C1

[BrendanC23]

Based on the code, this looks intentional. Is it causing you an actual problem? Here's the relevant code:

react-hook-form/src/logic/createFormControl.ts

Line 1066 in 81f472c

onBlur: onChange,

react-hook-form/src/logic/createFormControl.ts

Lines 693 to 826 in 81f472c

	const onChange: ChangeHandler = async (event) => {
	_state.mount = true;
	const target = event.target;
	let name = target.name as string;
	let isFieldValueUpdated = true;
	const field: Field = get(_fields, name);
	const getCurrentFieldValue = () =>
	target.type ? getFieldValue(field._f) : getEventValue(event);
	const _updateIsFieldValueUpdated = (fieldValue: any): void => {
	isFieldValueUpdated =
	Number.isNaN(fieldValue) ||
	deepEqual(fieldValue, get(_formValues, name, fieldValue));
	};
	if (field) {
	let error;
	let isValid;
	const fieldValue = getCurrentFieldValue();
	const isBlurEvent =
	event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
	const shouldSkipValidation =
	(!hasValidation(field._f) &&
	!_options.resolver &&
	!get(_formState.errors, name) &&
	!field._f.deps) ||
	skipValidation(
	isBlurEvent,
	get(_formState.touchedFields, name),
	_formState.isSubmitted,
	validationModeAfterSubmit,
	validationModeBeforeSubmit,
	);
	const watched = isWatched(name, _names, isBlurEvent);
	set(_formValues, name, fieldValue);
	if (isBlurEvent) {
	field._f.onBlur && field._f.onBlur(event);
	delayErrorCallback && delayErrorCallback(0);
	} else if (field._f.onChange) {
	field._f.onChange(event);
	}
	const fieldState = updateTouchAndDirty(
	name,
	fieldValue,
	isBlurEvent,
	false,
	);
	const shouldRender = !isEmptyObject(fieldState) || watched;
	!isBlurEvent &&
	_subjects.values.next({
	name,
	type: event.type,
	values: { ..._formValues },
	});
	if (shouldSkipValidation) {
	if (_proxyFormState.isValid) {
	if (props.mode === 'onBlur') {
	if (isBlurEvent) {
	_updateValid();
	}
	} else {
	_updateValid();
	}
	}
	return (
	shouldRender &&
	_subjects.state.next({ name, ...(watched ? {} : fieldState) })
	);
	}
	!isBlurEvent && watched && _subjects.state.next({ ..._formState });
	if (_options.resolver) {
	const { errors } = await _executeSchema([name]);
	_updateIsFieldValueUpdated(fieldValue);
	if (isFieldValueUpdated) {
	const previousErrorLookupResult = schemaErrorLookup(
	_formState.errors,
	_fields,
	name,
	);
	const errorLookupResult = schemaErrorLookup(
	errors,
	_fields,
	previousErrorLookupResult.name || name,
	);
	error = errorLookupResult.error;
	name = errorLookupResult.name;
	isValid = isEmptyObject(errors);
	}
	} else {
	_updateIsValidating([name], true);
	error = (
	await validateField(
	field,
	_formValues,
	shouldDisplayAllAssociatedErrors,
	_options.shouldUseNativeValidation,
	)
	)[name];
	_updateIsValidating([name]);
	_updateIsFieldValueUpdated(fieldValue);
	if (isFieldValueUpdated) {
	if (error) {
	isValid = false;
	} else if (_proxyFormState.isValid) {
	isValid = await executeBuiltInValidation(_fields, true);
	}
	}
	}
	if (isFieldValueUpdated) {
	field._f.deps &&
	trigger(
	field._f.deps as
	| FieldPath<TFieldValues>
	| FieldPath<TFieldValues>[],
	);
	shouldRenderByError(name, isValid, error, fieldState);
	}
	}
	};

Notably,

const isBlurEvent =  event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;

The same function is called for both change and blur, but the function checks the event type and acts differently in each case.