: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
SerializeJSON jQuery plugin.
https://github.com/marioizquierdo/jquery.serializeJSON
version 3.2.1 (Feb, 2021)
Copyright (c) 2012-2021 Mario Izquierdo
Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
/* global define, require, module */
if ( 'function' === typeof define && define.amd ) { // AMD. Register as an anonymous module.
define( ['jquery'], factory );
} else if ( 'object' === typeof exports ) { // Node/CommonJS.
jQuery = require( 'jquery' );
module.exports = factory( jQuery );
} else { // Browser globals (zepto supported).
factory( window.jQuery || window.Zepto || window.$ ); // Zepto supported on browsers as well.
var rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i;
var rsubmittable = /^(?:input|select|textarea|keygen)/i;
var rcheckableType = /^(?:checkbox|radio)$/i;
$.fn.serializeJSON = function( options ) {
var _this = this; // NOTE: the set of matched elements is most likely a form, but it could also be a group of inputs.
var opts = f.setupOpts( options ); // Validate options and apply defaults.
var typeFunctions = $.extend( {}, opts.defaultTypes, opts.customTypes );
// Make a list with {name, value, el} for each input element.
var serializedArray = f.serializeArray( _this, opts );
// Convert the serializedArray into a serializedObject with nested keys.
var serializedObject = {};
var nameSansType = obj.name;
var type = $( obj.el ).attr( 'data-value-type' );
if ( ! type && ! opts.disableColonTypes ) { // Try getting the type from the input name.
p = f.splitType( obj.name ); // "foo:string" => ["foo", "string"].
return; // Ignore fields with type skip.
type = opts.defaultType; // "string" by default
typedValue = f.applyTypeFunc( obj.name, obj.value, type, obj.el, typeFunctions ); // Parse type as string, number, etc.
if ( ! typedValue && f.shouldSkipFalsy( obj.name, nameSansType, type, obj.el, opts ) ) {
return; // Ignore falsy inputs if specified in the options.
keys = f.splitInputNameIntoKeysArray( nameSansType );
f.deepSet( serializedObject, keys, typedValue, opts );
// Use $.serializeJSON as namespace for the auxiliary functions
// and to define defaults.
defaultOptions: {}, // Reassign to override option defaults for all serializeJSON calls.
defaultBaseOptions: { // Do not modify, use defaultOptions instead.
checkboxUncheckedValue: undefined, // To include that value for unchecked checkboxes (instead of ignoring them).
useIntKeysAsArrayIndex: false, // Tip: name="foo[2]" value="v" => {foo: [null, null, "v"]}, instead of {foo: ["2": "v"]}.
skipFalsyValuesForTypes: [], // Skip serialization of falsy values for listed value types.
skipFalsyValuesForFields: [], // Skip serialization of falsy values for listed field names.
disableColonTypes: false, // Do not interpret ":type" suffix as a type.
customTypes: {}, // Extends defaultTypes.
'string': function( str ) {
'number': function( str ) {
'boolean': function( str ) {
var falses = ['false', 'null', 'undefined', '', '0'];
return -1 === falses.indexOf( str );
'null': function( str ) {
var falses = ['false', 'null', 'undefined', '', '0'];
return -1 === falses.indexOf( str ) ? str : null;
'array': function( str ) {
return JSON.parse( str );
'object': function( str ) {
return JSON.parse( str );
'skip': null // Skip is a special type used to ignore fields.
// Validate and set defaults.
setupOpts: function( options ) {
'checkboxUncheckedValue',
'useIntKeysAsArrayIndex',
'skipFalsyValuesForTypes',
'skipFalsyValuesForFields',
if ( validOpts.indexOf( opt ) === -1 ) {
throw new Error( 'serializeJSON ERROR: invalid option \'' + opt + '\'. Please use one of ' + validOpts.join( ', ' ) );
// Helper to get options or defaults.
return $.extend( {}, f.defaultBaseOptions, f.defaultOptions, options );
// Just like jQuery's serializeArray method, returns an array of objects with name and value.
// but also includes the dom element (el) and is handles unchecked checkboxes if the option or data attribute are provided.
serializeArray: function( _this, opts ) {
elements = $.prop( this, 'elements' ); // Handle propHook "elements" to filter or add form elements.
return elements ? $.makeArray( elements ) : this;
// Filter with the standard W3C rules for successful controls: http://www.w3.org/TR/html401/interact/forms.html#h-17.13.2.
return this.name && // Must contain a name attribute.
! $el.is( ':disabled' ) && // Must not be disable (use .is(":disabled") so that fieldset[disabled] works).
rsubmittable.test( this.nodeName ) && ! rsubmitterTypes.test( type ) && // only serialize submittable fields (and not buttons).
(this.checked || ! rcheckableType.test( type ) || f.getCheckboxUncheckedValue( $el, opts ) != null); // skip unchecked checkboxes (unless using opts).
var type = this.type; // "input", "select", "textarea", "checkbox", etc.
if ( rcheckableType.test( type ) && ! this.checked ) {
val = f.getCheckboxUncheckedValue( $el, opts );
return {name: el.name, value: val.replace( rCRLF, '\r\n' ), el: el};
return {name: el.name, value: val.replace( rCRLF, '\r\n' ), el: el};
getCheckboxUncheckedValue: function( $el, opts ) {
var val = $el.attr( 'data-unchecked-value' );
val = opts.checkboxUncheckedValue;
// Parse value with type function.
applyTypeFunc: function( name, strVal, type, el, typeFunctions ) {
var typeFunc = typeFunctions[type];
if ( ! typeFunc ) { // quick feedback to user if there is a typo or missconfiguration.
'serializeJSON ERROR: Invalid type ' + type + ' found in input name \'' + name + '\', please use one of ' + objectKeys( typeFunctions )
return typeFunc( strVal, el );
// Splits a field name into the name and the type. Examples:
// "foo:boolean" => ["foo", "boolean"].
// "foo[bar]:null" => ["foo[bar]", "null"].
splitType: function( name ) {
var parts = name.split( ':' );
if ( parts.length > 1 ) {
return [parts.join( ':' ), t];
// Check if this input should be skipped when it has a falsy value,
// depending on the options to skip values by name or type, and the data-skip-falsy attribute.
shouldSkipFalsy: function( name, nameSansType, type, el, opts ) {
var skipFromDataAttr = $( el ).attr( 'data-skip-falsy' );
if ( skipFromDataAttr != null ) {
return skipFromDataAttr !== 'false'; // any value is true, except the string "false".
optForFields = opts.skipFalsyValuesForFields;
if ( optForFields && (optForFields.indexOf( nameSansType ) !== -1 || optForFields.indexOf( name ) !== -1) ) {
optForTypes = opts.skipFalsyValuesForTypes;
return ! ! ( optForTypes && optForTypes.indexOf( type ) !== -1 );
// Split the input name in programmatically readable keys.
// "foo[inn][bar]" => ["foo", "inn", "bar"]
// "foo[inn[bar]]" => ["foo", "inn", "bar"]
// "foo[inn][arr][0]" => ["foo", "inn", "arr", "0"]
// "arr[][val]" => ["arr", "", "val"].
splitInputNameIntoKeysArray: function( nameWithNoType ) {
var keys = nameWithNoType.split( '[' ); // split string into array.
return key.replace( /\]/g, '' );
); // Remove closing brackets.
} // Ensure no opening bracket ("[foo][inn]" should be same as "foo[inn]")
// Set a value in an object or array, using multiple keys to set in a nested object or array.
// This is the main function of the script, that allows serializeJSON to use nested keys.
// deepSet(obj, ["foo"], v) // obj["foo"] = v
// deepSet(obj, ["foo", "inn"], v) // obj["foo"]["inn"] = v // Create the inner obj["foo"] object, if needed
// deepSet(obj, ["foo", "inn", "123"], v) // obj["foo"]["arr"]["123"] = v //
// deepSet(obj, ["0"], v) // obj["0"] = v
// deepSet(arr, ["0"], v, {useIntKeysAsArrayIndex: true}) // arr[0] = v
// deepSet(arr, [""], v) // arr.push(v)
// deepSet(obj, ["arr", ""], v) // obj["arr"].push(v)
// deepSet(arr, ["", v] // arr => [v]
// deepSet(arr, ["", "foo"], v) // arr => [v, {foo: v}]
// deepSet(arr, ["", "bar"], v) // arr => [v, {foo: v, bar: v}]
// deepSet(arr, ["", "bar"], v) // arr => [v, {foo: v, bar: v}, {bar: v}].
deepSet: function( o, keys, value, opts ) {
if ( isUndefined( o ) ) {
throw new Error( 'ArgumentError: param \'o\' expected to be an object or array, found undefined' );
if ( ! keys || 0 === keys.length ) {
throw new Error( 'ArgumentError: param \'keys\' expected to be an array with least one element' );
// Only one key, then it's not a deepSet, just assign the value in the object or add it to the array.
if ( 1 === keys.length ) {
if ( key === '' ) { // Push values into an array (o must be an array).
o[key] = value; // Keys can be object keys (strings) or array indexes (numbers).
var nextKey = keys[1]; // Nested key.
var tailKeys = keys.slice( 1 ); // List of all other nested keys (nextKey is first).
if ( key === '' ) { // Push nested objects into an array (o must be an array).
var lastIdx = o.length - 1;
var lastVal = o[lastIdx];
// if the last value is an object or array, and the new key is not set yet.
if ( isObject( lastVal ) && isUndefined( f.deepGet( lastVal, tailKeys ) ) ) {
key = lastIdx; // then set the new value as a new attribute of the same object.
key = lastIdx + 1; // otherwise, add a new element in the array.
if ( nextKey === '' ) { // "" is used to push values into the nested array "array[]".
if ( isUndefined( o[key] ) || ! isArray( o[key] ) ) {
o[key] = []; // define (or override) as array to push values.
if ( opts.useIntKeysAsArrayIndex && isValidArrayIndex( nextKey ) ) { // if 1, 2, 3 ... then use an array, where nextKey is the index.
if ( isUndefined( o[key] ) || ! isArray( o[key] ) ) {
o[key] = []; // Define (or override) as array, to insert values using int keys as array indexes.
} else { // nextKey is going to be the nested object's attribute.
if ( isUndefined( o[key] ) || ! isObject( o[key] ) ) {
o[key] = {}; // Define (or override) as object, to set nested properties.
// Recursively set the inner object.
f.deepSet( o[key], tailKeys, value, opts );
deepGet: function( o, keys ) {
if ( isUndefined( o ) || isUndefined( keys ) || keys.length === 0 || ( ! isObject( o ) && ! isArray( o ) ) ) {
if ( '' === key ) { // "" means next array index (used by deepSet)
if ( 1 === keys.length ) {
tailKeys = keys.slice( 1 );
return f.deepGet( o[key], tailKeys );
// Polyfill Object.keys to get option keys in IE<9.
var objectKeys = function( obj ) {
return Object.keys( obj );
var isObject = function( obj ) {
return obj === Object( obj );
}; // true for Objects and Arrays.
var isUndefined = function( obj ) {
}; // safe check for undefined values.
var isValidArrayIndex = function( val ) {
return /^[0-9]+$/.test( String( val ) );
}; // 1,2,3,4 ... are valid array indexes.
var isArray = Array.isArray || function( obj ) {
return '[object Array]' === Object.prototype.toString.call( obj );
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
