Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
fix(formula): case sensitive (#2329)
Dushusira6761dda2cd3
diff --git a/packages/engine-formula/src/engine/utils/object-compare.ts b/packages/engine-formula/src/engine/utils/object-compare.tsindex 55dd1cc6b6..47f013c4ee 100644--- a/packages/engine-formula/src/engine/utils/object-compare.ts+++ b/packages/engine-formula/src/engine/utils/object-compare.ts@@ -47,7 +47,7 @@ export function findCompareToken(str: string): [compareToken, BaseValueObject] {* 2. >=apple*: normal value, >apple: obtains the same effect as >=apple** 3. <apple*: normal value, <=apple: obtains the same effect as <apple**/-export function valueObjectCompare(range: BaseValueObject, criteria: BaseValueObject, operator?: compareToken) {+export function valueObjectCompare(range: BaseValueObject, criteria: BaseValueObject, operator?: compareToken, isCaseSensitive?: boolean) {if (!operator) {// Only strings can extract comparison symbols, other types of values are 'equal to'// TODO: criteria: 32, ">32", B5, "3?", "apple*", "*~?", TODAY(), ">"&A1:B3@@ -61,7 +61,7 @@ export function valueObjectCompare(range: BaseValueObject, criteria: BaseValueOb}}- return range.compare(criteria, operator);+ return range.compare(criteria, operator, isCaseSensitive);}/**diff --git a/packages/engine-formula/src/engine/value-object/array-value-object.ts b/packages/engine-formula/src/engine/value-object/array-value-object.tsindex fb08f0dba1..d30d63dcd5 100644--- a/packages/engine-formula/src/engine/value-object/array-value-object.ts+++ b/packages/engine-formula/src/engine/value-object/array-value-object.ts@@ -713,7 +713,8 @@ export class ArrayValueObject extends BaseValueObject {) {const compareFunc = getCompare();- const value = valueObject.getValue().toString();+ // case insensitive+ const value = valueObject.getValue().toString().toLocaleLowerCase();let start = 0;let end = searchArray.length - 1;@@ -730,7 +731,8 @@ export class ArrayValueObject extends BaseValueObject {} else {const compareToValue = compareTo.getValue();- compare = compareFunc(compareToValue.toString(), value);+ // case insensitive+ compare = compareFunc(compareToValue.toString().toLocaleLowerCase(), value);}if (compare === 0) {@@ -917,8 +919,8 @@ export class ArrayValueObject extends BaseValueObject {});}- override compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject {- return this._batchOperator(valueObject, BatchOperatorType.COMPARE, operator);+ override compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): BaseValueObject {+ return this._batchOperator(valueObject, BatchOperatorType.COMPARE, operator, isCaseSensitive);}override concatenateFront(valueObject: BaseValueObject): BaseValueObject {@@ -1353,7 +1355,8 @@ export class ArrayValueObject extends BaseValueObject {private _batchOperator(valueObject: BaseValueObject,batchOperatorType: BatchOperatorType,- operator?: compareToken+ operator?: compareToken,+ isCaseSensitive?: boolean): BaseValueObject {const valueList: BaseValueObject[] = [];@@ -1381,7 +1384,7 @@ export class ArrayValueObject extends BaseValueObject {valueList.push(list[0][c] as BaseValueObject);}} else {- return this._batchOperatorArray(valueObject, batchOperatorType, operator);+ return this._batchOperatorArray(valueObject, batchOperatorType, operator, isCaseSensitive);}} else {for (let c = 0; c < columnCount; c++) {@@ -1393,7 +1396,7 @@ export class ArrayValueObject extends BaseValueObject {for (let c = 0; c < columnCount; c++) {const value = valueList[c];- this._batchOperatorValue(value, c, result, batchOperatorType, operator);+ this._batchOperatorValue(value, c, result, batchOperatorType, operator, isCaseSensitive);}const newArray = this._createNewArray(result, rowCount, columnCount);@@ -1408,7 +1411,8 @@ export class ArrayValueObject extends BaseValueObject {column: number,result: BaseValueObject[][],batchOperatorType: BatchOperatorType,- operator?: compareToken+ operator?: compareToken,+ isCaseSensitive?: boolean) {const rowCount = this._rowCount;@@ -1474,7 +1478,7 @@ export class ArrayValueObject extends BaseValueObject {currentValue = BooleanValueObject.create(rowValue);}- const matchResult = currentValue.compare(valueObject, operator as compareToken);+ const matchResult = currentValue.compare(valueObject, operator as compareToken, isCaseSensitive);if ((matchResult as BooleanValueObject).getValue() === true) {rowPositions.forEach((index) => {if (index >= startRow && index <= startRow + rowCount - 1) {@@ -1545,7 +1549,7 @@ export class ArrayValueObject extends BaseValueObject {if (!operator) {result[r][column] = ErrorValueObject.create(ErrorType.VALUE);} else {- result[r][column] = currentValue.compare(valueObject, operator as compareToken);+ result[r][column] = currentValue.compare(valueObject, operator as compareToken, isCaseSensitive);}break;case BatchOperatorType.CONCATENATE_FRONT:@@ -1614,7 +1618,8 @@ export class ArrayValueObject extends BaseValueObject {private _batchOperatorArray(valueObject: BaseValueObject,batchOperatorType: BatchOperatorType,- operator?: compareToken+ operator?: compareToken,+ isCaseSensitive?: boolean) {let rowCount = (valueObject as ArrayValueObject).getRowCount();let columnCount = (valueObject as ArrayValueObject).getColumnCount();@@ -1686,7 +1691,7 @@ export class ArrayValueObject extends BaseValueObject {if (!operator) {rowList[c] = ErrorValueObject.create(ErrorType.VALUE);} else {- rowList[c] = currentValue.compare(opValue, operator as compareToken);+ rowList[c] = currentValue.compare(opValue, operator as compareToken, isCaseSensitive);}break;case BatchOperatorType.CONCATENATE_FRONT:diff --git a/packages/engine-formula/src/engine/value-object/base-value-object.ts b/packages/engine-formula/src/engine/value-object/base-value-object.tsindex 44faf35313..37cb4c9863 100644--- a/packages/engine-formula/src/engine/value-object/base-value-object.ts+++ b/packages/engine-formula/src/engine/value-object/base-value-object.ts@@ -177,7 +177,7 @@ export class BaseValueObject extends ObjectClassType {return ErrorValueObject.create(ErrorType.NAME);}- compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject {+ compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive: boolean = false): BaseValueObject {/** abstract */return ErrorValueObject.create(ErrorType.NAME);}diff --git a/packages/engine-formula/src/engine/value-object/primitive-object.ts b/packages/engine-formula/src/engine/value-object/primitive-object.tsindex 065d677478..3261dd7bb4 100644--- a/packages/engine-formula/src/engine/value-object/primitive-object.ts+++ b/packages/engine-formula/src/engine/value-object/primitive-object.ts@@ -702,61 +702,69 @@ export class NumberValueObject extends BaseValueObject {override compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject {const currentValue = this.getValue();let result = false;+if (typeof value === 'string') {- switch (operator) {- case compareToken.EQUALS:- case compareToken.GREATER_THAN:- case compareToken.GREATER_THAN_OR_EQUAL:- result = false;- break;- case compareToken.LESS_THAN:- case compareToken.LESS_THAN_OR_EQUAL:- case compareToken.NOT_EQUAL:- result = true;- break;- }+ result = this._compareString(operator);} else if (typeof value === 'number') {- if (!Number.isFinite(currentValue) || !Number.isFinite(value)) {- result = this._compareInfinity(currentValue, value, operator);- } else {- switch (operator) {- case compareToken.EQUALS:- result = Big(currentValue).eq(value);- break;- case compareToken.GREATER_THAN:- result = Big(currentValue).gt(value);- break;- case compareToken.GREATER_THAN_OR_EQUAL:- result = Big(currentValue).gte(value);- break;- case compareToken.LESS_THAN:- result = Big(currentValue).lt(value);- break;- case compareToken.LESS_THAN_OR_EQUAL:- result = Big(currentValue).lte(value);- break;- case compareToken.NOT_EQUAL:- result = !Big(currentValue).eq(value);- break;- }- }+ result = this._compareNumber(currentValue, value, operator);} else if (typeof value === 'boolean') {- switch (operator) {- case compareToken.EQUALS:- case compareToken.GREATER_THAN:- case compareToken.GREATER_THAN_OR_EQUAL:- result = false;- break;- case compareToken.LESS_THAN:- case compareToken.LESS_THAN_OR_EQUAL:- case compareToken.NOT_EQUAL:- result = true;- break;- }+ result = this._compareBoolean(operator);}+return BooleanValueObject.create(result);}+ private _compareString(operator: compareToken): boolean {+ switch (operator) {+ case compareToken.EQUALS:+ case compareToken.GREATER_THAN:+ case compareToken.GREATER_THAN_OR_EQUAL:+ return false;+ case compareToken.LESS_THAN:+ case compareToken.LESS_THAN_OR_EQUAL:+ case compareToken.NOT_EQUAL:+ return true;+ }+ }++ private _compareNumber(currentValue: number, value: number, operator: compareToken): boolean {+ if (!Number.isFinite(currentValue) || !Number.isFinite(value)) {+ return this._compareInfinity(currentValue, value, operator);+ } else {+ return this._compareFiniteNumber(currentValue, value, operator);+ }+ }++ private _compareFiniteNumber(currentValue: number, value: number, operator: compareToken): boolean {+ switch (operator) {+ case compareToken.EQUALS:+ return Big(currentValue).eq(value);+ case compareToken.GREATER_THAN:+ return Big(currentValue).gt(value);+ case compareToken.GREATER_THAN_OR_EQUAL:+ return Big(currentValue).gte(value);+ case compareToken.LESS_THAN:+ return Big(currentValue).lt(value);+ case compareToken.LESS_THAN_OR_EQUAL:+ return Big(currentValue).lte(value);+ case compareToken.NOT_EQUAL:+ return !Big(currentValue).eq(value);+ }+ }++ private _compareBoolean(operator: compareToken): boolean {+ switch (operator) {+ case compareToken.EQUALS:+ case compareToken.GREATER_THAN:+ case compareToken.GREATER_THAN_OR_EQUAL:+ return false;+ case compareToken.LESS_THAN:+ case compareToken.LESS_THAN_OR_EQUAL:+ case compareToken.NOT_EQUAL:+ return true;+ }+ }+override pow(valueObject: BaseValueObject): BaseValueObject {if (valueObject.isArray()) {return valueObject.powInverse(this);@@ -1254,76 +1262,85 @@ export class StringValueObject extends BaseValueObject {return StringValueObject.create(this.concatenate(valueObject.getValue(), ConcatenateType.BACK));}- override compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject {+ override compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): BaseValueObject {if (valueObject.isArray()) {// const o = valueObject.getReciprocal();// if (o.isError()) {// return o;// }- return valueObject.compare(this, reverseCompareOperator(operator));+ return valueObject.compare(this, reverseCompareOperator(operator), isCaseSensitive);}- return this.compareBy(valueObject.getValue(), operator);+ return this.compareBy(valueObject.getValue(), operator, isCaseSensitive);}- override compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject {- const currentValue = this.getValue();+ override compareBy(value: string | number | boolean, operator: compareToken, isCaseSensitive: boolean = false): BaseValueObject {+ let currentValue = this.getValue();let result = false;+if (typeof value === 'string') {- if (isWildcard(value)) {- return this._checkWildcard(value, operator);+ // Case sensitivity needs to be considered, most functions are case-insensitive, like VLOOKUP/HLOOKUP/XLOOKUP/MATCH/COUNTIF/COUNTIFS/SUMIF/SUMIFS/SEARCH/FIND(in SUBSTITUTE)+ // A few functions are case-sensitive, like EXACT/FIND/FINDB/REPLACE/REPLACEB/MIDB+ if (!isCaseSensitive) {+ currentValue = currentValue.toLocaleLowerCase();+ value = value.toLocaleLowerCase();}- switch (operator) {- case compareToken.EQUALS:- result = currentValue === value;- break;- case compareToken.GREATER_THAN:- result = currentValue > value;- break;- case compareToken.GREATER_THAN_OR_EQUAL:- result = currentValue >= value;- break;- case compareToken.LESS_THAN:- result = currentValue < value;- break;- case compareToken.LESS_THAN_OR_EQUAL:- result = currentValue <= value;- break;- case compareToken.NOT_EQUAL:- result = currentValue !== value;- break;+ if (isWildcard(value)) {+ return this._checkWildcard(value, operator);}+ result = this._compareString(currentValue, value, operator);} else if (typeof value === 'number') {- switch (operator) {- case compareToken.NOT_EQUAL:- case compareToken.GREATER_THAN:- case compareToken.GREATER_THAN_OR_EQUAL:- result = true;- break;-- case compareToken.EQUALS:- case compareToken.LESS_THAN:- case compareToken.LESS_THAN_OR_EQUAL:- result = false;- break;- }+ result = this._compareNumber(operator);} else if (typeof value === 'boolean') {- switch (operator) {- case compareToken.EQUALS:- case compareToken.GREATER_THAN:- case compareToken.GREATER_THAN_OR_EQUAL:- result = false;- break;- case compareToken.LESS_THAN:- case compareToken.LESS_THAN_OR_EQUAL:- case compareToken.NOT_EQUAL:- result = true;- break;- }+ result = this._compareBoolean(operator);}+return BooleanValueObject.create(result);}+ private _compareString(currentValue: string, value: string, operator: compareToken): boolean {+ switch (operator) {+ case compareToken.EQUALS:+ return currentValue === value;+ case compareToken.GREATER_THAN:+ return currentValue > value;+ case compareToken.GREATER_THAN_OR_EQUAL:+ return currentValue >= value;+ case compareToken.LESS_THAN:+ return currentValue < value;+ case compareToken.LESS_THAN_OR_EQUAL:+ return currentValue <= value;+ case compareToken.NOT_EQUAL:+ return currentValue !== value;+ }+ }++ private _compareNumber(operator: compareToken): boolean {+ switch (operator) {+ case compareToken.NOT_EQUAL:+ case compareToken.GREATER_THAN:+ case compareToken.GREATER_THAN_OR_EQUAL:+ return true;+ case compareToken.EQUALS:+ case compareToken.LESS_THAN:+ case compareToken.LESS_THAN_OR_EQUAL:+ return false;+ }+ }++ private _compareBoolean(operator: compareToken): boolean {+ switch (operator) {+ case compareToken.EQUALS:+ case compareToken.GREATER_THAN:+ case compareToken.GREATER_THAN_OR_EQUAL:+ return false;+ case compareToken.LESS_THAN:+ case compareToken.LESS_THAN_OR_EQUAL:+ case compareToken.NOT_EQUAL:+ return true;+ }+ }+override convertToNumberObjectValue() {return createNumberValueObjectByRawValue(this.getValue());}diff --git a/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.tsindex d8b8e1c36b..79f8d9ceeb 100644--- a/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts@@ -46,6 +46,11 @@ const arrayValueObject2 = ArrayValueObject.create(/*ts*/ `{3, "Third"}`);+const arrayValueObject3 = ArrayValueObject.create(/*ts*/ `{+ "First",1;+ "Second",2;+}`);+const matchArrayValueObject = ArrayValueObject.create(/*ts*/ `{1, 3;4, 6;@@ -229,6 +234,16 @@ describe('Test vlookup', () => {) as BaseValueObject;expect(getObjectValue(resultObject)).toStrictEqual([['First', 'First', 'First', 'First'], ['Fourth', 'Fourth', 'Fourth', 'Fourth'], ['Eighth', 'Eighth', 'Eighth', 'Eighth']]);});++ it('LookupValue is string, case sensitive', async () => {+ const resultObject = textFunction.calculate(+ StringValueObject.create('second'),+ arrayValueObject3.clone(),+ NumberValueObject.create(2),+ NumberValueObject.create(0)+ ) as BaseValueObject;+ expect(getObjectValue(resultObject)).toStrictEqual([[2]]);+ });});describe('Approximate match', () => {diff --git a/packages/engine-formula/src/functions/lookup/vlookup/index.ts b/packages/engine-formula/src/functions/lookup/vlookup/index.tsindex 73ed48fd2a..12732ce055 100644--- a/packages/engine-formula/src/functions/lookup/vlookup/index.ts+++ b/packages/engine-formula/src/functions/lookup/vlookup/index.ts@@ -61,44 +61,62 @@ export class Vlookup extends BaseFunction {// Otherwise colIndexNum takes the first valueif (isSingleValueObject(lookupValue) && isSingleValueObject(rangeLookup) && colIndexNum.isArray()) {- lookupValue = lookupValue.isArray() ? (lookupValue as ArrayValueObject).getFirstCell() : lookupValue;+ return this._handleArrayColIndexNum(lookupValue, tableArray, colIndexNum, rangeLookup);+ }- const rangeLookupValue = this.getZeroOrOneByOneDefault(rangeLookup);+ return this._handleNonArrayColIndexNum(lookupValue, tableArray, colIndexNum, rangeLookup);+ }- if (rangeLookupValue == null) {- return ErrorValueObject.create(ErrorType.VALUE);- }+ private _handleArrayColIndexNum(+ lookupValue: BaseValueObject,+ tableArray: BaseValueObject,+ colIndexNum: BaseValueObject,+ rangeLookup: BaseValueObject+ ) {+ lookupValue = lookupValue.isArray() ? (lookupValue as ArrayValueObject).getFirstCell() : lookupValue;- let errorValue: BaseValueObject | undefined;- const result: BaseValueObject[][] = [];+ const rangeLookupValue = this.getZeroOrOneByOneDefault(rangeLookup);- (colIndexNum as ArrayValueObject).iterator((colIndexNumValueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => {- if (colIndexNumValueObject === null || colIndexNumValueObject === undefined) {- errorValue = ErrorValueObject.create(ErrorType.VALUE);- return false;- }+ if (rangeLookupValue == null) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }- const searchObject = this._handleTableArray(lookupValue, tableArray, colIndexNumValueObject, rangeLookupValue);+ let errorValue: BaseValueObject | undefined;+ const result: BaseValueObject[][] = [];- if (searchObject.isError()) {- errorValue = searchObject;- return false;- }+ (colIndexNum as ArrayValueObject).iterator((colIndexNumValueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => {+ if (colIndexNumValueObject === null || colIndexNumValueObject === undefined) {+ errorValue = ErrorValueObject.create(ErrorType.VALUE);+ return false;+ }- if (result[rowIndex] === undefined) {- result[rowIndex] = [];- }+ const searchObject = this._handleTableArray(lookupValue, tableArray, colIndexNumValueObject, rangeLookupValue);- result[rowIndex][columnIndex] = searchObject;- });+ if (searchObject.isError()) {+ errorValue = searchObject;+ return false;+ }- if (errorValue) {- return errorValue;+ if (result[rowIndex] === undefined) {+ result[rowIndex] = [];}- return createNewArray(result, result.length, result[0].length, this.unitId || '', this.subUnitId || '');+ result[rowIndex][columnIndex] = searchObject;+ });++ if (errorValue) {+ return errorValue;}+ return createNewArray(result, result.length, result[0].length, this.unitId || '', this.subUnitId || '');+ }++ private _handleNonArrayColIndexNum(+ lookupValue: BaseValueObject,+ tableArray: BaseValueObject,+ colIndexNum: BaseValueObject,+ rangeLookup: BaseValueObject+ ) {// max row lengthconst maxRowLength = Math.max(lookupValue.isArray() ? (lookupValue as ArrayValueObject).getRowCount() : 1,